Come lo chiedi in Mongo? (Non è nullo)

Question

db.mycollection.find(HAS IMAGE URL) 

Answer 1

la query essere

db.mycollection.find({"IMAGE URL":{"$exists":"true"}}) 

tornerà tutti i documenti che hanno "URL immagine" come chiave ...........

Answer 2

Questo restituirà tutti i documenti con una chiave chiamata "URL di IMMAGINE", ma potrebbero comunque avere un valore nullo.

db.mycollection.find({"IMAGE URL":{$exists:true}}); 

Ciò restituirà tutti i documenti sia con una chiave denominata "URL immagine" e un valore non nullo.

db.mycollection.find({"IMAGE URL":{$ne:null}}); 

Inoltre, secondo la documentazione, $ esiste attualmente non è possibile utilizzare un indice, ma $ ne può.

Modifica: aggiunta di alcuni esempi a causa di interesse per questa risposta

Alla luce di questi inserti:

db.test.insert({"num":1, "check":"check value"}); 
db.test.insert({"num":2, "check":null}); 
db.test.insert({"num":3}); 

Ciò restituirà tutti i tre documenti:

db.test.find(); 

Ciò restituirà la solo primo e secondo documento:

db.test.find({"check":{$exists:true}}); 

Ciò restituirà il primo documento unico:

db.test.find({"check":{$ne:null}}); 

Ciò restituirà solo il secondo e terzo documenti:

db.test.find({"check":null}) 

Answer 3

In pymongo è possibile utilizzare:

db.mycollection.find({"IMAGE URL":{"$ne":None}}); 

Perché pymongo rappresenta mongo "null" come python "None".

Answer 4

Un'alternativa che non è stata menzionata, ma che potrebbe essere un'opzione più efficiente per alcuni (non funzionerà con le voci NULL) è utilizzare un sparse index (le voci nell'indice esistono solo quando c'è qualcosa nel campo). Ecco una serie di dati di esempio:

db.foo.find() 
{ "_id" : ObjectId("544540b31b5cf91c4893eb94"), "imageUrl" : "http://example.com/foo.jpg" } 
{ "_id" : ObjectId("544540ba1b5cf91c4893eb95"), "imageUrl" : "http://example.com/bar.jpg" } 
{ "_id" : ObjectId("544540c51b5cf91c4893eb96"), "imageUrl" : "http://example.com/foo.png" } 
{ "_id" : ObjectId("544540c91b5cf91c4893eb97"), "imageUrl" : "http://example.com/bar.png" } 
{ "_id" : ObjectId("544540ed1b5cf91c4893eb98"), "otherField" : 1 } 
{ "_id" : ObjectId("544540f11b5cf91c4893eb99"), "otherField" : 2 } 

Ora, creare l'indice sparse sul campo URL dell'immagine:

db.foo.ensureIndex({ "imageUrl": 1 }, { sparse: true }) 
{ 
    "createdCollectionAutomatically" : false, 
    "numIndexesBefore" : 1, 
    "numIndexesAfter" : 2, 
    "ok" : 1 
} 

Ora, c'è sempre la possibilità (e, in particolare, con un piccolo set di dati come il mio campione) che invece di usare un indice, MongoDB userà una scansione della tabella, anche per una potenziale query indice coperta. Come si è visto che mi dà un modo semplice per illustrare la differenza qui:

db.foo.find({}, {_id : 0, imageUrl : 1}) 
{ "imageUrl" : "http://example.com/foo.jpg" } 
{ "imageUrl" : "http://example.com/bar.jpg" } 
{ "imageUrl" : "http://example.com/foo.png" } 
{ "imageUrl" : "http://example.com/bar.png" } 
{ } 
{ } 

OK, in modo che i documenti in più senza imageUrl vengono restituiti, solo vuoto, non quello che volevamo.Solo per confermare il motivo per cui, fare un spiegare:

db.foo.find({}, {_id : 0, imageUrl : 1}).explain() 
{ 
    "cursor" : "BasicCursor", 
    "isMultiKey" : false, 
    "n" : 6, 
    "nscannedObjects" : 6, 
    "nscanned" : 6, 
    "nscannedObjectsAllPlans" : 6, 
    "nscannedAllPlans" : 6, 
    "scanAndOrder" : false, 
    "indexOnly" : false, 
    "nYields" : 0, 
    "nChunkSkips" : 0, 
    "millis" : 0, 
    "server" : "localhost:31100", 
    "filterSet" : false 
} 

Quindi, sì, un BasicCursor equivale a una scansione di tabella, che non ha utilizzato l'indice. Diamo forzare la query per utilizzare il nostro indice sparse con un hint():

db.foo.find({}, {_id : 0, imageUrl : 1}).hint({imageUrl : 1}) 
{ "imageUrl" : "http://example.com/bar.jpg" } 
{ "imageUrl" : "http://example.com/bar.png" } 
{ "imageUrl" : "http://example.com/foo.jpg" } 
{ "imageUrl" : "http://example.com/foo.png" } 

E c'è il risultato che cercavamo - solo i documenti con il campo popolato vengono restituiti. Anche questo utilizza solo l'indice (cioè è una query indice coperta), quindi solo l'indice deve essere in memoria per restituire i risultati.

Questo è un caso di utilizzo specializzato e non può essere utilizzato in generale (vedere altre risposte per tali opzioni). In particolare va notato che allo stato attuale non è possibile utilizzare count() in questo modo (per il mio esempio restituirà 6 non 4), quindi utilizzare solo quando appropriato.

Answer 5

db.collection_name.find({"filed_name":{$exists:true}});

fetch documenti che contengono questo filed_name anche se è nullo.

mia proposta:

db.collection_name.find({"field_name":{$type:2}}) //type:2 == String 

Puoi controllare il tipo di attributo richiesto, verrà restituito tutti i documenti che la sua nome_campo interrogato contiene un valore, perché si sta verificando il tipo di depositata il resto se è null la condizione del tipo non corrisponde, quindi non verrà restituito nulla.

Nb: se il nome_campo ha una stringa vuota che significa "", sarà returned.It è lo stesso comportamento per db.collection_name.find({"filed_name":{$ne:null}});

convalida Extra:

Ok, quindi abbiamo non sono ancora finiti, abbiamo bisogno di una condizione extra.

db.collection_name. find({ "field_name":{$type:2},$where:"this.field_name.length >0"})

O

db.collection_name. find({ "field_name":{$ne:null},$where:"this.field_name.length >0"})

di riferimento per tutti i tipi: https://docs.mongodb.com/manual/reference/operator/query/type/#op._S_type

Answer 6

condivisione per i lettori futuri.

Questa query ha lavorato per noi (query eseguita da MongoDB compass):

{ 
    "fieldName": { 
    "$nin": [ 
     "", 
     null 
    ] 
    } 
} 

Answer 7

db.<collectionName>.find({"IMAGE URL":{"$exists":"true"}, "IMAGE URL": {$ne: null}})