“Like” සමඟ මොන්ගෝ ඩීබී විමසන්නේ කෙසේද?

SQL හි likeවිමසුම සමඟ මට යමක් විමසීමට අවශ්‍යයි :

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

මොන්ගෝ ඩීබී හි දී මම එය සාක්ෂාත් කරගන්නේ කෙසේද? ප්‍රලේඛනයlike තුළ මට ක්‍රියාකරුවෙකු සොයාගත නොහැක .

එය එසේ විය යුතුය:

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

හෝ, සමාන:

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

ඔබ සොයන්නේ කොතැනක හෝ "m" අඩංගු දෙයක් (SQL හි %ක්‍රියාකරු Regexp ගේ ' .*' ට සමාන වේ ), නමුත් "m" නූලෙහි ආරම්භයට නැංගුරම් ලා ඇති දෙයක් නොවේ.

සටහන: මොන්ගෝඩ්බ් වර්ග අඩි "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%'

out: paulo, patric

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

out: paulo, patric

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

පිටත: පෙඩ්රෝ

තුළ

• PyMongo භාවිතා Python
• Node.js භාවිතා කරමින් මොන්ගෝස්
• ජොන්ගෝ , ජාවා භාවිතා කිරීම
• mgo , Go භාවිතා කරමින්

ඔබට කළ හැකිය:

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

මෙය පිටු සලකුණක් ලෙස තබා ගන්න , ඔබට අවශ්‍ය වෙනත් වෙනස් කිරීම් සඳහා යොමු කිරීමක්.

ඔබට තේරීම් 2 ක් ඇත:

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

හෝ

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

දෙවනුව ඔබට "i" වැනි තවත් විකල්ප ඇත. "නූල්" ගැන, ඔබට ". 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' }}

ඕනෑම JS ස්ක්‍රිප්ටයක් තැනීම සඳහා ඔබට ප්‍රකාශය භාවිතා කළ හැකිය:

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

යොමුව: http://docs.mongodb.org/manual/reference/operator/where/

මොන්ගෝ ඩීබී මාලිමා යන්ත්‍රය සමඟ, ඔබ දැඩි මාදිලියේ වාක්‍ය ඛණ්ඩය භාවිතා කළ යුතුය.

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

(මොන්ගෝ ඩීබී මාලිමා යන්ත්‍රයේ, ඒ "වෙනුවට ඔබ භාවිතා කිරීම වැදගත් වේ ')

SQL හි, ' like ' විමසුම මේ වගේ ය:

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

මොන්ගෝ ඩී බී කොන්සෝලය තුළ, මෙය පෙනෙන්නේ:

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

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

එකතු pretty()කිරීමේ ක්‍රමයේදී වඩාත් කියවිය හැකි පරිදි ආකෘතිගත JSON ව්‍යුහය නිපදවන සියලුම ස්ථානවල ඇත.

Regex මිල අධිකයි.

තවත් ක්‍රමයක් නම් පෙළ දර්ශකයක් නිර්මාණය කර එය භාවිතයෙන් සෙවීමයි $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 ලය වන්නේ සොයන වර්ගයේ ව්‍යුහාත්මක අවස්ථාවයි

පහත පරිදි ගැලපෙන සාමාන්‍ය ප්‍රකාශන භාවිතා කරන්න. 'මම' මඟින් සිද්ධි සංවේදීතාව පෙන්වයි.

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

පරිමාණය සඳහා ප්‍රතික්‍රියාශීලී මොන්ගෝ ඒපී,

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'}රටාවද භාවිතා කිරීමට හේතු ඇති බව පෙනේ . බලන්න: මොන්ගෝබීඩී රෙජෙක්ස් සින්ටැක්ස් සීමා කිරීම්

මෙය සම්පුර්ණ රෙජෙක්ස් නිබන්ධනයක් නොවේ, නමුත් ඉහත ඡන්ද විමසීම් නොපැහැදිලි තනතුරක් දැකීමෙන් පසුව මෙම පරීක්ෂණ ක්‍රියාත්මක කිරීමට මා පෙලඹුණි .

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

ඔබ වසන්ත-දත්ත මොන්ගෝඩ් භාවිතා කරන්නේ නම් ඔබට මෙය මේ ආකාරයෙන් කළ හැකිය:

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

නූල් දීපක්පර්මාර්, දීපක්, පර්මාර්

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

ans deepakparmar

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

ans deepakparmar, දීපක්

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

ans deepakparmar, parmar

මොන්ගෝ ෂෙල් ආධාරක රීජෙක්ස් ලෙස, එය සම්පූර්ණයෙන්ම හැකි ය.

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

විමසුම සිද්ධි සංවේදී නොවන ලෙස අපට අවශ්‍ය නම්, පහත දැක්වෙන පරිදි අපට "i" විකල්පය භාවිතා කළ හැකිය:

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

ඔබට මොන්ගෝ හි 'ලයික්' සෙවීම අවශ්‍ය නම් මෙම විමසුම භාවිතා කිරීමෙන් ඔබ $ රීජෙක්ස් සමඟ යා යුතුය

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

MYSQL විමසුම් මොන්ගෝ ඩීබී වෙත පරිවර්තනය කිරීමට මට නොමිලේ මෙවලමක් හමු විය. http://www.querymongo.com/ මම විමසුම් කිහිපයක් සමඟ පරීක්ෂා කළෙමි. මා දකින පරිදි ඒවා සියල්ලම පාහේ නිවැරදි ය. ඒ අනුව, පිළිතුර නම්

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

මොන්ගෝ රීජෙක්ස් ඉවත් කර ඇත.
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()

අපි නූල් රටා සොයන විට, සෑම විටම අපට නඩුව ගැන විශ්වාස නැති විට ඉහත රටාව භාවිතා කිරීම වඩා හොඳය. උදව් කරන බලාපොරොත්තුව !!!