MongoDB Sample operatører

MongoDB betingede operatører angiv en betingelse, som værdien af dokumentfeltet skal svare til.

Sammenligningsforespørgselsoperatører

$eq (lige)
$ne (ikke ens)
$gt (mere end)
$lt (mindre end)
$gte (mere eller lig med)
$lte (mindre eller lig med)
$in definerer en matrix af værdier, hvoraf den ene skal have et dokumentfelt
$nin definerer en matrix af værdier, der ikke skal have et dokumentfelt

For eksempel finder vi alle dokumenter, der har en aldersnøgleværdi på mindre end 30:

db.users.find ({age: {$lt : 30}})

Brugen af andre sammenligningsoperatører vil være ens. For eksempel den samme nøgle, kun over 30:

db.users.find ({age: {$gt : 30}})

Bemærk, at sammenligningen her er lavet over heltalstyper, ikke strenge. Hvis nøglealderen repræsenterer strengværdier, skal sammenligningen udføres over linjerne:db.users.find ({age:{$gt :“30”}}), men resultatet vil være det samme.

Men lad os forestille os en situation, hvor vi skal finde alle volumener med en aldersfeltværdi større end 30, men mindre end 50. I dette tilfælde kan vi kombinere to operatorer:

db.users.find ({age: {$gt : 30, $lt: 50}})

Vi finder brugere, hvis alder er 22:

db.users.find ({age: {$eq : 22}})

I bund og grund er dette analogien til den næste forespørgsel:

db.users.find ({age: 22})

Omvendt handling – find brugere, hvis alder IKKE er 22:

db.users.find ({age: {$ne : 22}})

$in-operatoren definerer et array af mulige udtryk og søger efter de nøgler, hvis værdi er i arrayet:

db.users.find ({age: {$in : [22, 32]}})

På den modsatte måde definerer $nin-operatoren et array af mulige udtryk og søger efter de nøgler, hvis værdi er fraværende i dette array:

db.users.find ({alder:{$nin:[22, 32]}})

Logiske operatorer

Logiske operatorer udføres over prøveudtagningsbetingelser:

$or :forbinder to betingelser, og dokumentet skal opfylde en af disse betingelser
$og: forbinder to betingelser, og dokumentet skal opfylde begge betingelser
$not: dokumentet må IKKE matche betingelsen
$nor: forbinder to betingelser, og dokumentet må IKKE opfylde begge betingelser

MongoDB Sample operatorer

$or-operatoren repræsenterer en logisk ELLER-operation og definerer et sæt nøgleværdi-par, der skal være til stede i et dokument. Og hvis et dokument har mindst ét sådant nøgleværdi-par, svarer det til denne forespørgsel og udvindes fra databasen:

db.users.find ({$or : [{name: "Tom"}, {age: 22}]})

Dette udtryk returnerer alle dokumenter med enten name=Tom eller age=22.

Et andet eksempel vil returnere alle dokumenter med enten name=Tom og age=22 eller med "tysk" blandt sprogværdierne:

db.users.find ({name: "Tom", $or : [{age: 22}, {languages: "german"}]})

Betingede operatorer kan bruges i underudtryk eller underudtryk:

db.users.find ({$or : [{name: "Tom"}, {age: {$gte:30}}]})

I dette tilfælde vælger vi alle dokumenter, hvor navn=”Tom” eller aldersfeltet har en værdi på 30 eller højere.

Operator $and

$and operatoren repræsenterer en logisk operation AND (logisk multiplikation) og definerer et sæt kriterier, som et dokument skal opfylde. I modsætning til $or-operatøren skal dokumentet opfylde alle de specificerede kriterier. For eksempel:

db.users.find ({$and : [{name: "Tom"}, {age: 32}]})

Her skal de valgte dokumenter have navnet Tom og alder 32 – begge disse funktioner.

MongoDB Array-søgning

Nogle operatorer er designet til at arbejde med arrays:

$all: definerer et sæt værdier, der skal eksistere i et array
$size: definerer antallet af elementer, der skal være i et array
$elemMatch: angiver den betingelse, som elementerne i arrayet skal svare til

MongoDB $all

$all-operatoren definerer en række mulige udtryk og kræver, at dokumenter har hele det definerede sæt af udtryk. Følgelig bruges den til at søge i arrayet. Dokumenter har f.eks. en række sprog, der gemmer de fremmedsprog, der tales af brugeren. Og for at finde alle de personer, der taler både engelsk og fransk på samme tid, kan vi bruge følgende udtryk:

db.users.find ({languages: {$all : ["english", "french"]}})

Operator $elemMatch

$elemMatch-operatoren giver dig mulighed for at vælge dokumenter, hvor arrays indeholder elementer, der falder ind under visse betingelser. Lad f.eks. databasen indeholde en samling af brugervurderinger for specifikke kurser. Lad os tilføje et par dokumenter:

db.grades.insertMany([{student: "Tom", courses:[{name: "Java", grade: 5}, {name: "MongoDB", grade: 4}]},
{student: "Alice", courses:[{name: "C++", grade: 3}, {name: "MongoDB", grade: 5}]}))

Hvert dokument har et array, som igen består af indlejrede dokumenter.

Nu finder vi elever, der har en karakter over 3 for MongoDB-kurset:

db.grades.find({courses: {$elemMatch: {name: "MongoDB", grade: {$gt: 3}}}})

Operator $size

$size-operatoren bruges til at finde dokumenter, hvor arrays har et antal elementer svarende til værdien af $size. Lad os f.eks. udtrække alle dokumenter, hvor der er to elementer i sprogarrayet:

db.users.find ({languages: {$size:2}})

En sådan forespørgsel vil f.eks. svare til følgende dokument:

{"name": "Tom", "age": 32, languages: ["english", "german"]}

Operator $eksisterer

$exists-operatøren tillader kun at udtrække de dokumenter, hvor en bestemt nøgle er til stede eller fraværende. Returner for eksempel alle de dokumenter, der indeholder firmanøglen:

db.users.find ({company: {$exists:true}})

Hvis vi angiver $exists som den falske parameter, vil forespørgslen kun returnere de dokumenter, som ikke indeholder firmanøglen.

Operator $type

$type-operatoren udtrækker kun de dokumenter, hvor en bestemt nøgle har en værdi af en bestemt type, f.eks. en streng eller et tal:

db.users.find ({age: {$type: "string"}})
> db.users.find ({age: {$type: "number"}})

Operator $regex

$regex-operatoren angiver et regulært udtryk, som feltværdien skal svare til . Lad f.eks. feltnavnet nødvendigvis have bogstavet "b":

db.users.find ({name: {$regex: "b"}})

Det er vigtigt at forstå, at $regex ikke kun tager strenge, men regulære udtryk, for eksempel:navn:{$regex:“om$”} – værdien af navn skal slutte med “om”.