Come interrogare MongoDB con "mi piace"?

Voglio interrogare qualcosa con la likequery di SQL :

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

Come posso ottenere lo stesso in MongoDB? Non riesco a trovare un operatore likenella documentazione .

Dovrebbe essere:

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

o simili:

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

Stai cercando qualcosa che contenga "m" da qualche parte (l' %operatore " SQL" equivale a Regexp's " .*"), non qualcosa che abbia "m" ancorato all'inizio della stringa.

nota: mongodb usa espressioni regolari che sono più potenti di "MI PIACE" in sql. Con le espressioni regolari puoi creare qualsiasi modello che immagini.

Per ulteriori informazioni sulle espressioni regolari, fare riferimento a questo 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%'

fuori: paulo, patric

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

fuori: paulo, patric

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

fuori: pedro

In

• PyMongo usando Python
• Mongoose usando Node.js
• Jongo , usando Java
• mgo , usando Go

tu puoi fare:

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

In PHP, puoi usare il seguente codice:

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

Userai regex per questo in mongo.

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

Ci sono già molte risposte. Sto offrendo diversi tipi di requisiti e soluzioni per la ricerca di stringhe con regex.

Puoi fare con regex che contiene la parola cioè come. Inoltre è possibile utilizzare $options => iper la ricerca senza distinzione tra maiuscole e minuscole

contiene string

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

Non contiene stringsolo con regex

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

Maiuscole e minuscole esatte string

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

Iniziare con string

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

Termina con string

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

Mantenere questo come segnalibro, e un punto di riferimento per tutte le altre modifiche potrebbe essere necessario.

Hai 2 scelte:

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

o

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

Nella seconda hai più opzioni, come "i" nelle opzioni per trovare usando la distinzione tra maiuscole e minuscole. E riguardo alla "stringa", puoi usare come ". String. " (% String%), o "string. *" (String%) e ". * String) (% string) per esempio. Puoi usare espressioni regolari come vuoi.

Godere!

Se si utilizza node.js , si dice che è possibile scrivere questo:

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

Inoltre , puoi scrivere questo:

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

Hai già ottenuto le risposte, ma per abbinare regex all'insensibilità al caso

È possibile utilizzare la seguente query

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

La iin /m/iindica insensibilità al maiuscolo / minuscolo e .pretty()fornisce un risultato più grazioso

Per Mongoose in Node.js

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

È possibile utilizzare la nuova funzionalità di 2.6 mongodb:

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

Nel progetto nodejs e usa mongoose usa Like query

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

Per PHP mongo Like.
Ho avuto diversi problemi con php mongo like. ho scoperto che concatenare i parametri regex aiuta in alcune situazioni che PHP mongo trova il campo inizia con . Ho pensato di postare qui per contribuire al thread più popolare

per esempio

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)

L'uso dei letterali di template con variabili funziona anche:

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

Con MongoDB Compass, è necessario utilizzare la sintassi della modalità rigorosa, come tale:

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

(Nella bussola MongoDB, è importante utilizzare al "posto di ')

È possibile utilizzare l'istruzione where per creare qualsiasi script JS:

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

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

In SQL, la query " like " è simile alla seguente:

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

Nella console MongoDB, si presenta così:

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

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

In aggiunta pretty()metodo sarà in tutti i luoghi in cui produce una struttura JSON formattata che è più leggibile.

Regex sono costosi sono processo.

Un altro modo è creare un indice di testo e quindi cercarlo utilizzando $search.

Crea un indice di testo dei campi che desideri rendere ricercabile:

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

Cerca una stringa nell'indice di testo:

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

In Go e il driver mgo:

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

dove risultato è l'istanza struct del tipo ricercato

Usa le espressioni regolari corrispondenti come di seguito. La "i" mostra insensibilità al maiuscolo / minuscolo.

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

Come Query sarebbe come mostrato di seguito

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

per 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]

Sembra che ci siano ragioni per usare sia il /regex_pattern/modello javascript che il {'$regex': 'regex_pattern'}modello mongo . Vedi: Restrizioni alla sintassi MongoBD RegEx

Questo non è un tutorial completo su RegEx, ma sono stato ispirato a eseguire questi test dopo aver visto un post ambiguo molto votato sopra .

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

Se si utilizza Spring-Data Mongodb È possibile farlo in questo modo:

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

Poiché la shell Mongo supporta regex, questo è completamente possibile.

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

Se vogliamo che la query non faccia distinzione tra maiuscole e minuscole, possiamo usare l'opzione "i", come mostrato di seguito:

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

Se vuoi la ricerca "Mi piace" in mongo, allora dovresti andare con $ regex usando questa query

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

per di più puoi leggere anche la documentazione. https://docs.mongodb.com/manual/reference/operator/query/regex/

Usa la ricerca per sottostringa di aggregazione (con indice !!!):

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

Corda 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

Ho trovato uno strumento gratuito per tradurre le query MYSQL in MongoDB. http://www.querymongo.com/ Ho controllato con diverse domande. come vedo quasi tutti sono corretti. In base a ciò, la risposta è

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

MongoRegex è stato deprecato.
Usa 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()

Quando cerchiamo schemi di stringhe, è sempre meglio usare lo schema sopra come quando non siamo sicuri del caso. Spero che aiuti!!!