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

Ich möchte etwas mit der SQL- likeAbfrage abfragen:

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

Wie erreiche ich dasselbe in MongoDB? Ich kann likein der Dokumentation keinen Operator finden .

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 dem von Regexp .*"), und nicht nach etwas, das "m" am Anfang der Zeichenfolge verankert hat.

Hinweis: Mongodb verwendet reguläre Ausdrücke, die in SQL leistungsfähiger sind als "LIKE". Mit regulären Ausdrücken können Sie jedes Muster erstellen, das Sie sich vorstellen.

Weitere Informationen zu regulären Ausdrücken finden Sie unter diesem Link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions

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

Im

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

du kannst tun:

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

In PHP können Sie folgenden Code verwenden:

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

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

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

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

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

Enthält string

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

Enthält nicht stringnur Regex

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

Genaue Groß- und Kleinschreibung wird nicht berücksichtigt string

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

Beginnen mit string

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

Ende mit string

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

Bewahren Sie dies als Lesezeichen und als Referenz für andere Änderungen auf, die Sie möglicherweise benötigen.

Sie haben 2 Möglichkeiten:

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

oder

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

Auf der zweiten haben Sie mehr Optionen, wie "i" in Optionen, um die Groß- und Kleinschreibung nicht zu berücksichtigen. Und für den "String" können Sie beispielsweise ". String. " (% String%) oder "string. *" (String%) und ". * String) (% string) verwenden. Sie können reguläre Ausdrücke verwenden wie du willst.

Genießen!

Wenn Sie node.js verwenden , heißt es , dass Sie Folgendes schreiben können:

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

Auch können, schreiben Sie diese:

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

Sie haben bereits die Antworten erhalten, aber um Regex mit Groß- und Kleinschreibung zu vergleichen

Sie können die folgende Abfrage verwenden

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

Die iin der /m/izeigt Groß- und Kleinschreibung und .pretty()bietet eine hübsche Ausgabe

Für Mungo in Node.js.

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

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

Verwenden Sie in nodejs project and use mongoose die 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);
            });

Für PHP Mongo Like.
Ich hatte mehrere Probleme mit PHP Mongo wie. Ich fand, dass die Verkettung der Regex-Parameter in einigen Situationen hilft, mit denen PHP Mongo Find Field beginnt . 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)

Die Verwendung von Vorlagenliteralen mit Variablen funktioniert auch:

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

Bei 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 verwenden ')

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/

In SQL, das ‚ wie ‘ Abfrage sieht wie folgt 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

Außerdem wird die pretty()Methode an allen Stellen, an denen eine formatierte JSON-Struktur erzeugt wird, besser lesbar sein.

Regex sind teuer sind Prozess.

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

Erstellen Sie einen Textindex mit Feldern, 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"}
})

In Go und dem mgo-Treiber:

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

Dabei ist result die struct-Instanz des gesuchten Typs

Verwenden Sie die folgenden regulären Ausdrücke. Das 'i' zeigt die Groß- und Kleinschreibung nicht an.

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);

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]

Es scheint Gründe zu geben, sowohl das Javascript- /regex_pattern/Muster als auch das Mongo- {'$regex': 'regex_pattern'}Muster zu verwenden. Siehe: MongoBD RegEx-Syntaxbeschränkungen

Dies ist kein vollständiges RegEx-Tutorial, aber ich wurde inspiriert, diese Tests durchzuführen, nachdem ich oben einen mehrstimmigen, mehrdeutigen 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" }

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));

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});

Wenn Sie "Gefällt mir" in Mongo suchen möchten, 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/

Verwenden Sie die Suche nach Aggregationssubstrings (mit Index !!!):

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

String 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, parmar

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

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

MongoRegex ist veraltet.
Verwenden Sie MongoDB \ BSON \ Regex

$regex = new MongoDB\BSON\Regex ( '^m');
$cursor = $collection->find(array('users' => $regex));
//iterate through the cursor

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

Wenn wir nach Zeichenfolgenmustern suchen, ist es immer besser, das obige Muster zu verwenden, wenn wir uns über den Fall nicht sicher sind. Ich hoffe, das hilft!!!