"जैसे" के साथ MongoDB से पूछताछ कैसे करें?




mongodb-query sql-like (20)

मैं SQL की like क्वेरी के रूप में कुछ पूछना चाहता हूं:

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

MongoDB में ऐसा कैसे करें?
मुझे documentations में like लिए ऑपरेटर नहीं मिल रहा है।


MongoDB कम्पास के साथ, आपको सख्त मोड सिंटैक्स का उपयोग करने की आवश्यकता है, जैसे:

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

(मोंगोडीबी कम्पास में, यह महत्वपूर्ण है कि आप " इसके बजाय " उपयोग करें)


MongoRegex को हटा दिया गया है।
MongoDB \ BSON \ Regex का प्रयोग करें

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

PHP में, आप निम्न कोड का उपयोग कर सकते हैं:

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

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

आप किसी जेएस स्क्रिप्ट को बनाने के लिए कहां कथन का उपयोग कर सकते हैं:

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

संदर्भ: http://docs.mongodb.org/manual/reference/operator/where/


आपके पास 2 विकल्प हैं:

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

या

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

दूसरे पर आपके पास केस असंवेदनशील उपयोग करने के विकल्पों में "i" जैसे विकल्प हैं। और "स्ट्रिंग" के बारे में, उदाहरण के लिए आप " स्ट्रिंग " (% स्ट्रिंग%), या "स्ट्रिंग। *" (स्ट्रिंग%) और "। * स्ट्रिंग) (% स्ट्रिंग) जैसे उपयोग कर सकते हैं। आप नियमित अभिव्यक्ति का उपयोग कर सकते हैं जैसा तुम चाहो।

का आनंद लें!


एसक्यूएल में, ' जैसे ' क्वेरी इस तरह दिखती है:

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

MongoDB कंसोल में, ऐसा लगता है:

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

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

Addion pretty() विधि में उन सभी स्थानों पर होगा जहां स्वरूपित जेएसओएन संरचना उत्पन्न होती है जो अधिक पठनीय है।


ऐसा लगता है कि जावास्क्रिप्ट /regex_pattern/ पैटर्न के साथ-साथ मोंगो {'$regex': 'regex_pattern'} पैटर्न दोनों का उपयोग करने के कारण हैं। देखें: मोंगोबीडी रेगेक्स सिंटेक्स प्रतिबंध

यह एक पूर्ण 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" }

नीचे दी गई नियमित अभिव्यक्तियों का उपयोग करें। 'मैं' केस असंवेदनशीलता दिखाता है।

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.users.find({'name': {'$regex': '.*sometext.*'}})

पहले से ही कई जवाब हैं। मैं regex के साथ स्ट्रिंग खोज के लिए विभिन्न प्रकार की आवश्यकताओं और समाधान दे रहा हूँ।

आप रेगेक्स के साथ कर सकते हैं जिसमें शब्द यानी शब्द शामिल है। इसके अलावा आप $options => i असंवेदनशील खोज के मामले में उपयोग कर सकते हैं

string शामिल string

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

केवल regex के साथ 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.movies.find({title: /.*Twelve Monkeys.*/}).sort({regularizedCorRelation : 1}).limit(10);

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]

में

  • Pythono पायथन का उपयोग कर
  • Node.js का उपयोग कर Mongoose
  • जावा का उपयोग कर जोंगो
  • एमओओ , गो का उपयोग कर

तुम कर सकते हो:

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

मोंगो खोल समर्थन regex के रूप में, यह पूरी तरह से संभव है।

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

अगर हम क्वेरी को असंवेदनशील होना चाहते हैं, तो हम नीचे दिखाए गए "i" विकल्प का उपयोग कर सकते हैं:

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

यदि आप PHP का उपयोग कर रहे हैं, तो आप नीचे MongoDB_DataObject उपयोग कर सकते हैं:

$model = new MongoDB_DataObject();

$model->query("select * from users where name like '%m%'");

while($model->fetch()) {
    var_dump($model);
}

या:

$model = new MongoDB_DataObject('users);

$model->whereAdd("name like '%m%'");

$model->find();

while($model->fetch()) {
    var_dump($model);
}

यदि आप मोंगो में 'पसंद' करना चाहते हैं तो आपको इस क्वेरी का उपयोग करके $ regex के साथ जाना चाहिए

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

अधिक के लिए आप दस्तावेज भी पढ़ सकते हैं। https://docs.mongodb.com/manual/reference/operator/query/regex/


यह होना होगा:

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

या इसी के समान:

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

आप किसी ऐसे चीज़ की तलाश में हैं जिसमें कहीं "एम" है (एसक्यूएल का ' % ' ऑपरेटर रेगेक्स के ' .* ' के बराबर है), ऐसा कुछ नहीं है जिसमें स्ट्रिंग की शुरुआत में "एम" लगाया गया हो।


> db.car.distinct ('name') ["होंडा", "tat", "tata", "tata3"]

> db.car.find ({"name": /। ta। /})


पूर्ण नाम जैसे 'आखिरी' स्थिति == 'लंबित' दो तिथियों के बीच:

db.orders.find({
      createdAt:{$gt:ISODate("2017-04-25T10:08:16.111Z"),
      $lt:ISODate("2017-05-05T10:08:16.111Z")},
      status:"Pending",
      fullName:/last/}).pretty();

स्थिति == 'लंबित' और ऑर्डर जैसे 'PHA876174':

db.orders.find({
     status:"Pending",
     orderId:/PHA876174/
     }).pretty();

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

जब हम स्ट्रिंग पैटर्न की खोज कर रहे होते हैं, तो हमेशा उपर्युक्त पैटर्न का उपयोग करना बेहतर होता है जब हम मामले के बारे में निश्चित नहीं होते हैं। उम्मीद है की वो मदद करदे!!!







sql-like