"좋아요"를 사용하여 MongoDB에 문의하는 방법

"좋아요"를 사용하여 MongoDB에 문의하는 방법

것이 like 삭제:

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

"MongoDB" "MongoDB" "MongoDB" "MongoDB" "MongoDB" "MongoDB" "MongoDB" "MongoDB" "MongoDB"?수 .like를 참조해 주세요.

다음과 같이 해야 합니다.

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

또는 비슷한 경우:

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

있는 것을 있습니다m'은 'm'이 들어 있습니다).% 표현식인 ''어느 정도'에 해당합니다..*에 '.'

주의: MongoDB는 SQL에서 "LIKE"보다 강력한 정규 표현을 사용합니다.정규 표현을 사용하면 상상하는 모든 패턴을 만들 수 있습니다.

정규 표현에 대한 자세한 내용은 정규 표현(MDN)을 참조하십시오.

db.users.insert({name: 'patrick'})
db.users.insert({name: 'petra'})
db.users.insert({name: 'pedro'})

그 때문에,

대상:

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

출력: patrick, petra

대상:

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

출력: patrick

대상:

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

출력: pedro

인

• PyMongo를 사용한 PyMongo
• Node.js를 사용한 Mongoose
• 종오, Java 사용
• mgo, Go 사용

다음 작업을 수행할 수 있습니다.

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

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

$collection->find(array('name'=> array('$regex' => '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'}})

end로로로 끝나다string

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

정규 표현식 치트 시트를 책갈피로 보관하고 필요한 기타 변경에 대한 참조를 보관합니다.

MongoDB에서는 정규 표현을 사용합니다.

예를들면,

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

다음 두 가지 선택지가 있습니다.

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의 Mongoose의 경우:

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

MongoDB 나침반에서는 다음과 같이 strict mode 구문을 사용해야 합니다.

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

나침반에서는 (MongoDB 나침반)을것이 중요합니다."')

MongoDB 2.6의 새로운 기능을 사용할 수 있습니다.

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

Node.js 프로젝트에서 Mongoose를 사용하는 경우 다음과 같은 쿼리를 사용합니다.

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

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

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

참조: $where

MongoDb에서는 MongoDb 참조 연산자 정규식(regex)을 사용할 수 있습니다.

동일 예에 대해서

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

MongoDb

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

    2) db.users.find({ "name": { $regex: new RegExp("m", 'i') } })

    3) db.users.find({ "name": { $regex:/m/i } })

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

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

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

MongoDb Any of Above with /^String/

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

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

MongoDb Any of Above with /String$/

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

Go 및 mgo 드라이버:

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

여기서 결과는 원하는 유형의 구조 인스턴스입니다.

SQL에서 '좋아요' 쿼리는 다음과 같습니다.

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()method는 모든 장소에서 보다 읽기 쉬운 포맷된 JSON 구조를 생성합니다.

PHP mongo Like의 경우.

PHP mongo like에 몇 가지 문제가 있었습니다.정규 표현식 파라미터를 연결하는 것은 상황에 따라 도움이 된다는 것을 알게 되었습니다.- PHP mongo find 필드는 다음과 같이 시작됩니다.

예를들면,

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)

yourdb={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, 파르마

템플릿 리터럴을 변수와 함께 사용하는 것도 가능합니다.

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

정규 표현식은 처리 비용이 많이 듭니다.

하나의 ''를 사용해서 것입니다.$search.

검색할 수 있도록 할 필드의 텍스트 색인을 만듭니다.

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

텍스트 색인에서 문자열 검색:

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

다음과 같이 일치하는 정규식을 사용합니다.'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);

가지 자바스크립트를 모두 가 있는 것 ./regex_pattern/및 패o MongoDB 。{'$regex': 'regex_pattern'}양식.자세한 내용은 MongoDB 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" }

유사한 쿼리는 다음과 같습니다.

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]

Spring-Data MongoDB를 사용하는 경우 다음과 같이 수행할 수 있습니다.

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

문자열 변수가 있는 경우 정규식으로 변환해야 합니다.그러면 MongoDB는 같은 문을 사용합니다.

const name = req.query.title; //John
db.users.find({ "name": new Regex(name) });

결과는 다음과 같습니다.

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

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

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

정규 표현으로 쿼리할 수 있습니다.

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

문자열이 사용자로부터 수신된 경우 사용하기 전에 문자열을 이스케이프할 수 있습니다.이렇게 하면 사용자의 리터럴 문자가 정규식 토큰으로 해석되지 않습니다.

예를 들어 문자열 "A"를 검색해도 이스케이프가 없으면 "AB"와 일치합니다.심플을 사용할 수 있습니다.replace사용하기 전에 끈에서 벗어나야 합니다.다음 기능을 재사용할 수 있도록 했습니다.

function textLike(str) {
  var escaped = str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
  return new RegExp(escaped, 'i');
}

따라서 문자열은 대소문자를 구분하지 않는 패턴 매칭이 되고 리터럴 도트도 됩니다.예:

>  textLike('A.');
<  /A\./i

이제 이동 중에도 정규 표현을 생성할 수 있습니다.

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

MongoDB에서 '좋아요' 검색을 원하는 경우 $regex로 검색하십시오.이를 사용함으로써 쿼리는 다음과 같습니다.

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

상세한 것에 대하여는, 메뉴얼도 참조해 주세요($regex).

유사한 쿼리에 해당하는 결과를 찾는 한 가지 방법은 다음과 같습니다.

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

어디에i는 대소문자를 구분하지 않는 가져오기 데이터에 사용됩니다.

결과를 얻을 수 있는 또 다른 방법:

db.collection.find({"name":/aus/})

위는 aus를 포함하는 이름에 aus가 있는 결과를 제공합니다.

언급URL : https://stackoverflow.com/questions/3305561/how-to-query-mongodb-with-like