"like"로 MongoDB를 쿼리하는 방법은 무엇입니까?

SQL 쿼리로 무언가를 쿼리하고 싶습니다 like.

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

MongoDB에서 어떻게 동일한 결과를 얻습니까? 설명서like 에서 연산자를 찾을 수 없습니다 .

다음과 같아야합니다.

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

또는 유사한 :

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

문자열의 시작 부분에 "m"이 고정 된 것이 아니라 "m"이 포함 된 것을 찾고 있습니다 (SQL의 ' %'연산자는 Regexp의 ' .*' 와 동일 함 ).

참고 : mongodb는 SQL에서 "LIKE"보다 강력한 정규식을 사용합니다. 정규 표현식을 사용하면 상상할 수있는 패턴을 만들 수 있습니다.

정규 표현식에 대한 자세한 내용은이 링크를 참조하십시오 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%'

아웃 : 파울로

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

아웃 : 파울로

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

아웃 : 페드로

에

• 파이썬을 사용하는 PyMongo
• Node.js를 사용하는 몽구스
• Java를 사용하는 Jongo
• Go를 사용하여 mgo

넌 할 수있어:

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

PHP에서는 다음 코드를 사용할 수 있습니다.

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

몽고에서는 정규 표현식을 사용합니다.

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

이미 많은 답변이 있습니다. 정규식으로 문자열 검색을위한 다양한 유형의 요구 사항과 솔루션을 제공하고 있습니다.

단어를 포함하는 정규 표현식으로 할 수 있습니다. $options => i대소 문자를 구분하지 않는 검색에도 사용할 수 있습니다

포함 string

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

string정규식 만 포함하지 않습니다

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

대소 문자를 구분하지 않음 string

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

로 시작 string

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

끝나다 string

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

이것을 책갈피로 유지 하고 필요한 다른 변경 사항에 대한 참조로 유지하십시오 .

두 가지 선택이 있습니다 :

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

또는

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

두 번째 옵션에서는 대소 문자를 구분하지 않고 찾을 수있는 옵션에 "i"와 같은 추가 옵션이 있습니다. "string"에 대해서는 ".string . "(% string %) 또는 "string. *"(string %) 및 ". * string) (% string)과 같이 사용할 수 있습니다. 정규식을 사용할 수 있습니다. 원하는대로.

즐겨!

사용하는 경우 Node.js를을 , 그것은 당신이 쓸 수 있다고 말한다 :

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

또한 다음 과 같이 작성할 수 있습니다.

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

이미 답을 얻었지만 대소 문자를 구분하지 않는 정규 표현식과 일치시킵니다.

다음 쿼리를 사용할 수 있습니다

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

i에서는 /m/i소문자 구분을 표시하고 .pretty()더 예쁜 출력을 제공

Node.js의 몽구스

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

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

에서 nodejs 프로젝트 및 사용 몽구스 사용 쿼리처럼

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

PHP 몽고 좋아요.
PHP mongo와 같은 몇 가지 문제가있었습니다. 정규식 매개 변수를 연결하면 PHP 몽고 찾기 필드가로 시작되는 상황에 도움이된다는 것을 알았 습니다 . 더 인기있는 스레드에 기여하기 위해 여기에 게시 할 것이라고 생각했습니다.

예 :

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)

변수와 함께 템플릿 리터럴을 사용하면 작동합니다.

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

MongoDB Compass에서는 다음과 같이 엄격한 모드 구문을 사용해야합니다.

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

(MongoDB Compass에서는 사용하는 것이 중요합니다. " 대신 대신 하는' )

where 문을 사용하여 JS 스크립트를 작성할 수 있습니다.

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

참조 : http://docs.mongodb.org/manual/reference/operator/where/

SQL에서 ' like '쿼리는 다음과 같습니다.

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

MongoDB 콘솔에서는 다음과 같습니다.

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

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

또한 pretty()메소드는 더 읽기 쉬운 형식의 JSON 구조를 생성하는 모든 장소에서 사용됩니다.

정규식은 비용이 많이 듭니다.

또 다른 방법은 텍스트 색인을 만든 다음 다음을 사용하여 검색하는 것입니다. $search 입니다.

검색 할 텍스트 색인 필드를 작성하십시오.

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

텍스트 인덱스에서 문자열을 검색하십시오.

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

Go와 mgo 드라이버에서 :

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

여기서 result는 찾는 유형의 구조체 인스턴스입니다.

아래와 같이 정규식을 사용하십시오. 'i'는 대소 문자를 구분하지 않습니다.

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

같은 쿼리는 다음과 같습니다

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

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]

/regex_pattern/몽고 {'$regex': 'regex_pattern'}패턴 뿐만 아니라 자바 스크립트 패턴 을 모두 사용해야하는 이유가있는 것 같습니다 . 참조 : MongoBD RegEx 구문 제한

이것은 완전한 RegEx 튜토리얼은 아니지만 위의 투표에서 모호한 게시물을 본 후 이러한 테스트를 실행하도록 영감을 받았습니다 .

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

Spring-Data Mongodb를 사용하는 경우 다음과 같은 방법으로이를 수행 할 수 있습니다.

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

Mongo 쉘이 정규식을 지원하므로 완전히 가능합니다.

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

쿼리에서 대소 문자를 구분하지 않으려면 아래에 표시된 것처럼 "i"옵션을 사용할 수 있습니다.

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

mongo에서 '좋아요'검색을 원하면이 쿼리를 사용하여 $ regex를 사용해야합니다.

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

자세한 내용은 설명서를 참조하십시오. https://docs.mongodb.com/manual/reference/operator/query/regex/

집계 하위 문자열 검색 사용 (인덱스 포함) :

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

문자열 디 팍파 마르, 디팍, 파 마르

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

ans deepakparmar

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

ans deepakparmar, 디팍

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

ans deepakparmar, 파 마르

MYSQL 쿼리를 MongoDB로 변환하는 무료 도구를 찾았습니다. http://www.querymongo.com/ 몇 가지 쿼리로 확인했습니다. 내가 볼 수 있듯이 거의 모든 것이 정확합니다. 그것에 따르면, 대답은

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

MongoRegex는 더 이상 사용되지 않습니다.
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()

문자열 패턴을 검색 할 때는 항상 대소 문자를 모를 때와 같이 위 패턴을 사용하는 것이 좋습니다. 희망이 도움이됩니다 !!!