mongodb - query - mongoose regex




Wie kann man MongoDB mit "Gefällt mir" abfragen? (20)

Ich möchte etwas als SQL- like Abfrage abfragen:

select * 
from users 
where name like '%m%'

Wie mache ich das gleiche in MongoDB?
Ich kann keinen Operator für like in den documentations .


Als Mongo-Shell unterstützt Regex, das ist völlig möglich.

db.users.findOne({"name" : /.*sometext.*/});

Wenn die Abfrage die Groß- und Kleinschreibung nicht berücksichtigen soll, können wir die Option "i" verwenden, wie im Folgenden dargestellt:

db.users.findOne({"name" : /.*sometext.*/i});

Das müsste sein:

db.users.find({"name": /.*m.*/})

o.ä:

db.users.find({"name": /m/})

Sie suchen nach etwas, das irgendwo "m" enthält (der SQL-Operator " % " entspricht Regexps " .* "), Nicht etwas, bei dem "m" am Anfang der Zeichenfolge verankert ist.


Es gibt bereits viele Antworten. Ich gebe verschiedene Arten von Anforderungen und Lösungen für die String-Suche mit Regex.

Sie können mit Regex tun, die Wort enthalten, wie. Sie können auch $options => i für die Suche ohne Berücksichtigung der Groß- und Kleinschreibung verwenden

Enthält string

db.collection.find({name:{'$regex' : 'string', '$options' : 'i'}})

Enthält string nur mit Regex

db.collection.find({name:{'$regex' : '^((?!string).)*$', '$options' : 'i'}})

Genaue Groß- und Kleinschreibung string

db.collection.find({name:{'$regex' : '^string$', '$options' : 'i'}})

Beginnen Sie mit einer string

db.collection.find({name:{'$regex' : '^string', '$options' : 'i'}})

Ende mit string

db.collection.find({name:{'$regex' : 'string$', '$options' : 'i'}})

Behalten Sie this als Lesezeichen und als Referenz für andere Änderungen, die Sie möglicherweise benötigen.


Es scheint, dass es Gründe gibt, sowohl das javascript /regex_pattern/ pattern als auch das mongo {'$regex': 'regex_pattern'} Muster zu verwenden. Siehe: MongoBD RegEx Syntax Einschränkungen

Dies ist kein komplettes RegEx-Tutorial, aber ich wurde inspiriert, diese Tests durchzuführen, nachdem ich oben einen vieldeutigen Beitrag gesehen habe .

> ['abbbb','bbabb','bbbba'].forEach(function(v){db.test_collection.insert({val: v})})

> db.test_collection.find({val: /a/})
{ "val" : "abbbb" }
{ "val" : "bbabb" }
{ "val" : "bbbba" }

> db.test_collection.find({val: /.*a.*/})
{ "val" : "abbbb" }
{ "val" : "bbabb" }
{ "val" : "bbbba" }

> db.test_collection.find({val: /.+a.+/})
{ "val" : "bbabb" }

> db.test_collection.find({val: /^a/})
{ "val" : "abbbb" }

> db.test_collection.find({val: /a$/})
{ "val" : "bbbba" }

> db.test_collection.find({val: {'$regex': 'a$'}})
{ "val" : "bbbba" }

Für PHP mongo Like.
Ich hatte mehrere Probleme mit php mongo. Ich fand, dass die Verkettung der Regex-Parameter hilft in einigen Situationen PHP Mongo finden Feld beginnt mit . Ich dachte, ich würde hier posten, um zu dem bekannteren Thread beizutragen

z.B

db()->users->insert(['name' => 'john']);
db()->users->insert(['name' => 'joe']);
db()->users->insert(['name' => 'jason']);

// starts with
$like_var = 'jo';
$prefix = '/^';
$suffix = '/';
$name = $prefix . $like_var . $suffix;
db()->users->find(['name' => array('$regex'=>new MongoRegex($name))]);
output: (joe, john)

// contains
$like_var = 'j';
$prefix = '/';
$suffix = '/';
$name = $prefix . $like_var . $suffix;
db()->users->find(['name' => array('$regex'=>new MongoRegex($name))]);

output: (joe, john, jason)

Ich habe ein kostenloses Tool gefunden, um MYSQL-Anfragen in MongoDB zu übersetzen. http://www.querymongo.com/ Ich habe mit mehreren Abfragen überprüft. Wie ich sehe, sind fast alle richtig. Demnach ist die Antwort

db.users.find({
    "name": "%m%"
});

In Nodejs Projekt und verwenden Sie Mungouse Like Abfrage

var User = mongoose.model('User');

var searchQuery={};
searchQuery.email = req.query.email;
searchQuery.name = {$regex: req.query.name, $options: 'i'};
User.find(searchQuery, function(error, user) {
                if(error || user === null) {
                    return res.status(500).send(error);
                }
                return res.status(200).send(user);
            });

In Go und dem mgo-Treiber:

Collection.Find(bson.M{"name": bson.RegEx{"m", ""}}).All(&result)

Dabei ist result die Strukturinstanz des gesuchten Typs


In SQL sieht die Like -Abfrage wie folgt aus:

select * from users where name like '%m%'

In der MongoDB-Konsole sieht es folgendermaßen aus:

db.users.find({"name": /m/})     // Not JSON formatted

db.users.find({"name": /m/}).pretty()  // JSON formatted

Zusätzlich wird die pretty() -Methode an allen Stellen, an denen eine formatierte JSON-Struktur erzeugt wird, lesbarer.


Mit MongoDB Compass müssen Sie die strikte Modus-Syntax als solche verwenden:

{ "text": { "$regex": "^Foo.*", "$options": "i" } }

(In MongoDB Compass ist es wichtig, dass Sie " statt ' )


Sie haben 2 Möglichkeiten:

db.users.find({"name": /string/})

oder

db.users.find({"name": {"$regex": "string", "$options": "i"}})

Auf der zweiten Seite haben Sie mehr Optionen, wie "i" in Optionen, um Groß- / Kleinschreibung zu finden. Und über die "Zeichenfolge" können Sie wie ". String. " (% String%), oder "string. *" (String%) und ". * String) (% string) verwenden. Sie können regulären Ausdruck verwenden wie du willst.

Genießen!


Sie können die neue Funktion von 2.6 mongodb verwenden:

db.foo.insert({desc: "This is a string with text"});
db.foo.insert({desc:"This is a another string with Text"});
db.foo.ensureIndex({"desc":"text"});
db.foo.find({
    $text:{
        $search:"text"
    }
});

Sie würden Regex dafür in Mongo verwenden.

zB: db.users.find({"name": /^m/})


Verwenden Sie Aggregation Teilstringsuche (mit Index !!!):

db.collection.aggregate([{
        $project : {
            fieldExists : {
                $indexOfBytes : ['$field', 'string']
            }
        }
    }, {
        $match : {
            fieldExists : {
                $gt : -1
            }
        }
    }, {
        $limit : 5
    }
]);

Wenn Sie node.js verwenden , können it Folgendes schreiben:

db.collection.find( { field: /acme.*corp/i } );
//or
db.collection.find( { field: { $regex: 'acme.*corp', $options: 'i' } } );

Sie können dies auch schreiben:

db.collection.find( { field: new RegExp('acme.*corp', 'i') } );

Wenn Sie PHP verwenden, können Sie den MongoDB_DataObject Wrapper wie MongoDB_DataObject :

$model = new MongoDB_DataObject();

$model->query("select * from users where name like '%m%'");

while($model->fetch()) {
    var_dump($model);
}

ODER:

$model = new MongoDB_DataObject('users);

$model->whereAdd("name like '%m%'");

$model->find();

while($model->fetch()) {
    var_dump($model);
}


Wie Abfrage wäre wie unten gezeigt

db.movies.find({title: /.*Twelve Monkeys.*/}).sort({regularizedCorRelation : 1}).limit(10);

für scala ReactiveMongo api,

val query = BSONDocument("title" -> BSONRegex(".*"+name+".*", "")) //like
val sortQ = BSONDocument("regularizedCorRelation" -> BSONInteger(1))
val cursor = collection.find(query).sort(sortQ).options(QueryOpts().batchSize(10)).cursor[BSONDocument]

FullName wie 'last' mit Status == 'Pending' zwischen zwei Daten:

db.orders.find({
      createdAt:{$gt:ISODate("2017-04-25T10:08:16.111Z"),
      $lt:ISODate("2017-05-05T10:08:16.111Z")},
      status:"Pending",
      fullName:/last/}).pretty();

status == 'Pending' und orderId LIKE 'PHA876174':

db.orders.find({
     status:"Pending",
     orderId:/PHA876174/
     }).pretty();

db.customer.find({"customerid": {"$regex": "CU_00000*", "$options": "i"}}).pretty()

Wenn wir nach Zeichenketten suchen, ist es immer besser, das obige Muster zu verwenden, als wenn wir nicht sicher sind, ob es sich um einen Fall handelt. Ich hoffe, das hilft!!!





sql-like