Jak wysłać zapytanie do MongoDB za pomocą „Lubię to”?

Chcę zapytać o coś za pomocą likezapytania SQL :

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

Jak mogę osiągnąć to samo w MongoDB? Nie mogę znaleźć operatora likew dokumentacji .

To musiałoby być:

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

lub podobne:

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

Szukasz czegoś, co zawiera gdzieś „m” ( %operator SQL jest odpowiednikiem „Regexp .*”), a nie czegoś, co „m” jest zakotwiczone na początku łańcucha.

Uwaga: mongodb używa wyrażeń regularnych, które są silniejsze niż „LIKE” w sql. Za pomocą wyrażeń regularnych możesz stworzyć dowolny wzór, jaki sobie wyobrażasz.

Więcej informacji na temat wyrażeń regularnych można znaleźć pod tym linkiem 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%'

obecnie: paulo, patric

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

obecnie: paulo, patric

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

obecnie: pedro

W

• PyMongo używa Pythona
• Mongoose przy użyciu Node.js
• Jongo , używając Java
• mgo , używając Go

możesz to zrobić:

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

W PHP możesz użyć następującego kodu:

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

Używałbyś do tego wyrażeń regularnych w mongo.

na przykład: db.users.find({"name": /^m/})

Istnieje już wiele odpowiedzi. Podaję różnego rodzaju wymagania i rozwiązania dotyczące wyszukiwania ciągów za pomocą wyrażenia regularnego.

Możesz zrobić z wyrażeniami regularnymi, które zawierają słowo tj. Podobne. Możesz także użyć $options => ido wyszukiwania bez rozróżniania wielkości liter

Zawiera string

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

Nie zawiera stringtylko wyrażenia regularnego

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

Dokładnie bez rozróżniania wielkości liter string

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

Zacząć od string

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

Kończyć z string

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

Zachowaj to jako zakładkę i odniesienie do wszelkich innych potrzebnych zmian.

Masz 2 możliwości:

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

lub

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

Na drugim masz więcej opcji, takich jak „i” w opcjach wyszukiwania bez rozróżniania wielkości liter. Jeśli chodzi o „ciąg znaków”, możesz użyć na przykład „. Ciąg. ” (% Ciąg%) lub „ciąg. *” (Ciąg%) i „. * Ciąg) (% ciąg). Możesz użyć wyrażenia regularnego jak chcesz.

Cieszyć się!

Jeśli używasz node.js , oznacza to , że możesz napisać to:

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

Również , można napisać tak:

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

Masz już odpowiedzi, ale aby dopasować wyrażenie regularne do nieuwzględniania wielkości liter

Możesz użyć następującego zapytania

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

Symbol iin /m/iwskazuje niewrażliwość na wielkość liter i .pretty()zapewnia ładniejszy wynik

Dla Mongoose w Node.js

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

Możesz użyć nowej funkcji 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"
    }
});

W projekcie nodejs i użyj mangusty użyj zapytania Like

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

Dla PHP mongo Like.
Miałem kilka problemów z php mongo jak. odkryłem, że konkatenacja parametrów wyrażenia regularnego pomaga w niektórych sytuacjach zaczyna się od pola znajdowania mongo PHP . Pomyślałem, że opublikuję tutaj, aby przyczynić się do bardziej popularnego wątku

na przykład

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)

Działa także użycie literałów szablonów ze zmiennymi:

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

W MongoDB Compass musisz użyć składni trybu ścisłego, takiej jak:

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

(W kompasie MongoDB ważne jest, aby używać "zamiast ')

Możesz użyć instrukcji where do zbudowania dowolnego skryptu JS:

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

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

W SQL zapytanie „ like ” wygląda następująco:

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

W konsoli MongoDB wygląda to tak:

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

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

Ponadto pretty()metoda będzie we wszystkich miejscach, w których sformatowana struktura JSON jest bardziej czytelna.

Regex są drogie to proces.

Innym sposobem jest utworzenie indeksu tekstu, a następnie wyszukiwanie go za pomocą $search.

Utwórz tekstowy Indeks pól, które chcesz umożliwić wyszukiwanie:

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

Wyszukaj ciąg w indeksie tekstowym:

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

W Go i sterowniku mgo:

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

gdzie wynik jest instancją struct poszukiwanego typu

Użyj wyrażeń regularnych pasujących jak poniżej. „I” pokazuje niewrażliwość na wielkość liter.

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

Podobnie jak w przypadku zapytania, jak pokazano poniżej

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

dla interfejsu API Scala ReactiveMongo ,

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]

Wydaje się, że istnieją powody stosowania zarówno /regex_pattern/wzorca javascript , jak i {'$regex': 'regex_pattern'}wzoru mongo . Zobacz: Ograniczenia składni Reggo MongoBD

To nie jest kompletny samouczek RegEx, ale zainspirowałem się do uruchomienia tych testów po zobaczeniu wysoko głosowanego dwuznacznego postu powyżej .

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

Jeśli korzystasz z Mongodb Spring-Data, możesz to zrobić w następujący sposób:

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

Ponieważ regex obsługuje powłokę Mongo, jest to całkowicie możliwe.

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

Jeśli chcemy, aby zapytanie nie rozróżniało wielkości liter, możemy użyć opcji „i”, jak pokazano poniżej:

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

Jeśli chcesz wyszukać „Lubię to” w mongo, powinieneś użyć $ regex za pomocą tego zapytania

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

więcej można również przeczytać w dokumentacji. https://docs.mongodb.com/manual/reference/operator/query/regex/

Użyj wyszukiwania podciągów agregacji (z indeksem !!!):

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

Sznurek 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

Znalazłem bezpłatne narzędzie do tłumaczenia zapytań MYSQL na MongoDB. http://www.querymongo.com/ Sprawdziłem kilka zapytań. jak widzę, prawie wszystkie z nich są poprawne. Zgodnie z tym, odpowiedź brzmi

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

MongoRegex został uznany za przestarzały.
Użyj 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()

Kiedy szukamy wzorców ciągów, zawsze lepiej jest użyć powyższego wzorca, ponieważ nie jesteśmy pewni wielkości liter. Mam nadzieję, że to pomaga !!!