wake-up-neo.com

Wie kann man MongoDB mit "like" abfragen?

Ich möchte etwas mit der Abfrage like von SQL abfragen:

SELECT * FROM users  WHERE name LIKE '%m%'

Wie erreiche ich dasselbe in MongoDB? Ich kann keinen Operator für like in der Dokumentation finden.

sqlmongodbmongodb-querysql-like
1283
Freewind

Das müsste sein:

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

oder ähnliches:

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

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

1746
Kyle H
db.users.insert({name: 'paulo'})
db.users.insert({name: 'patric'})
db.users.insert({name: 'pedro'})

db.users.find({name: /a/})  //like '%a%'

raus: paulo, patric

db.users.find({name: /^pa/}) //like 'pa%'

raus: paulo, patric

db.users.find({name: /ro$/}) //like '%ro'

raus: pedro

317
Johnathan Douglas

Im

  • PyMongo mit Python
  • Mungo mit Node.js
  • Jongo mit Java
  • mgo mit Go

du kannst tun:

db.users.find({'name': {'$regex': 'sometext'}})
247
Afshin Mehrabani

In PHP können Sie folgenden Code verwenden:

$collection->find(array('name'=> array('$regex' => 'm'));
83
leon

Dafür würden Sie im Mongo Regex verwenden.

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

49
Joshua Partogi

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

Sie können mit regulären Ausdrücken arbeiten, die Word enthalten, d. H. Sie können auch $options => i für die Suche ohne Berücksichtigung der Groß-/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 Berücksichtigung der Groß- und Kleinschreibung string

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

Beginnen Sie mit string

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

Beenden Sie mit string

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

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

40
Somnath Muluk

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

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

auch , du kannst folgendes schreiben:

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

Sie haben zwei 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ß- und Kleinschreibung zu finden. Und für "string" können Sie ".string." (% string%) oder "string. *" (String%) und ". * String) (% string) verwenden Beispiel: Sie können den regulären Ausdruck nach Belieben verwenden.

Genießen!

28
user3645907

Schon hast du die Antworten bekommen, aber Regex mit Groß- und Kleinschreibung zu vergleichen

Sie könnten die folgende Abfrage verwenden

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

Das i in /m/i zeigt die Unterscheidung zwischen Groß- und Kleinschreibung an, und .pretty() liefert eine hübschere Ausgabe

18
The6thSense

Für Mungo in Node.js

db.users.find({'name': {'$regex': '.*sometext.*'}})
13
Aqib Mumtaz

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"
    }
});
11
cmarrero01

Für PHP Mongo Like.
Ich hatte mehrere Probleme mit PHP wie Mongo. Ich fand, dass die Verkettung der Regex-Parameter in einigen Situationen hilft PHP Mongo Find Feld beginnt mit . Ich dachte, ich würde hier posten, um zu dem populäreren 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)
11
Dap

In nodejs projizieren und verwenden Sie Mungo wie 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);
            });
9
Shaishab Roy

In MongoDB Compass müssen Sie die strikte Modussyntax verwenden:

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

(In MongoDB Compass ist es wichtig, dass Sie " anstelle von ' verwenden.)

8
damd

In SQL sieht die Abfrage "like" folgendermaßen aus:

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

In der MongoDB-Konsole sieht es so 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 verwendet, an denen formatierte JSON-Strukturen erzeugt werden, die besser lesbar sind.

8
MAA

Regex sind teuer sind Prozess.

Eine andere Möglichkeit besteht darin, einen Textindex zu erstellen und ihn dann mit $search zu durchsuchen.

Erstellen Sie einen Textindex für Felder, die durchsucht werden sollen:

db.collection.createIndex({name: 'text', otherField: 'text'});

Suchen Sie nach einer Zeichenfolge im Textindex:

db.collection.find({
  '$text'=>{'$search': "The string"}
})
7
Rust

Verwenden Sie reguläre Ausdrücke, die wie folgt übereinstimmen. Das "i" zeigt Groß- und Kleinschreibung.

var collections = mongoDatabase.GetCollection("Abcd");

var queryA = Query.And(
         Query.Matches("strName", new BsonRegularExpression("ABCD", "i")), 
         Query.Matches("strVal", new BsonRegularExpression("4121", "i")));

var queryB = Query.Or(
       Query.Matches("strName", new BsonRegularExpression("ABCD","i")),
       Query.Matches("strVal", new BsonRegularExpression("33156", "i")));

var getA = collections.Find(queryA);
var getB = collections.Find(queryB);
7
Shalabh Raizada

In Go und dem mgo Treiber:

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

dabei ist das Ergebnis die Strukturinstanz des gesuchten Typs

7
user2312578

Mit der where-Anweisung können Sie ein beliebiges JS-Skript erstellen:

db.myCollection.find( { $where: "this.name.toLowerCase().indexOf('m') >= 0" } );

Referenz: http://docs.mongodb.org/manual/reference/operator/where/

7
brenoriba

Es scheint, dass es Gründe dafür gibt, sowohl das Javascript /regex_pattern/-Muster als auch das Mongo {'$regex': 'regex_pattern'}-Muster zu verwenden. Siehe: MongoBD RegEx-Syntaxeinschränkungen

Dies ist kein vollständiges RegEx-Tutorial, aber ich wurde dazu inspiriert, diese Tests durchzuführen, nachdem ein hoch gewählter, mehrdeutiger Beitrag oben angezeigt wurde.

> ['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" }
5
Bruno Bronosky

Like Query 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]
5
prayagupd

Wenn Sie Spring-Data Mongodb verwenden, können Sie dies folgendermaßen tun:

String tagName = "m";
Query query = new Query();
query.limit(10);        
query.addCriteria(Criteria.where("tagName").regex(tagName));
4
Vaibhav

Da Mongo Shell Regex unterstützt, ist dies durchaus möglich.

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

Wenn bei der Abfrage die Groß- und Kleinschreibung nicht berücksichtigt werden soll, können Sie die Option "i" verwenden, wie unten gezeigt:

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

Wenn Sie 'Like'-Suche in Mongo wollen, dann sollten Sie mit $ regex gehen, indem Sie diese Abfrage verwenden

db.product.find({name:{$regex:/m/i}})

weitere Informationen finden Sie auch in der Dokumentation. https://docs.mongodb.com/manual/reference/operator/query/regex/

4
jarry jafery

Die Verwendung von Vorlagenliteralen mit Variablen funktioniert auch:

{"firstname": {$regex : `^${req.body.firstname}.*` , $options: 'si' }}

3
besthost

Ich habe ein kostenloses Tool gefunden, um MYSQL-Abfragen in MongoDB zu übersetzen. http://www.querymongo.com/ Ich habe mehrere Fragen beantwortet. wie ich sehe sind fast alle richtig. Demnach lautet die Antwort

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

Verwenden Sie die Aggregationssubstringsuche (mit Index !!!):

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

MongoRegex ist veraltet.
Verwenden Sie MongoDB\BSON\Regex

$regex = new MongoDB\BSON\Regex ( '^m');
$cursor = $collection->find(array('users' => $regex));
//iterate through the cursor
2
Albert s
db.customer.find({"customerid": {"$regex": "CU_00000*", "$options": "i"}}).pretty()

Wenn wir nach String-Mustern suchen, ist es immer besser, das obige Muster zu verwenden, da wir uns über die Groß- und Kleinschreibung nicht sicher sind. Ich hoffe, das hilft!!!

1
priya raj

Vollständiger Name wie "Letzter" mit Status == "Ausstehend" 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();
1
Shubham Verma

Wenn Sie PHP verwenden, können Sie MongoDB_DataObject wrapper wie folgt verwenden:

$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);
}
1
CEDA
>> db.car.distinct('name')
[ "honda", "tat", "tata", "tata3" ]

>> db.car.find({"name":/. *ta.* /})
0
arnav

Sie können den Platzhalterfilter auch wie folgt verwenden:

{"query": { "wildcard": {"lookup_field":"search_string*"}}}

verwenden Sie unbedingt *.

0
saim2025

Zeichenfolge Deepakparmar, Dipak, Parmar

db.getCollection('yourdb').find({"name":/^dee/})

ans deepakparmar

db.getCollection('yourdb').find({"name":/d/})

ans deepakparmar, dipak

db.getCollection('yourdb').find({"name":/mar$/})

ans deepakparmar, dipak, parmar

0
Deepak parmar