Come si esegue una query per "non è null" in Mongo?

Vorrei eseguire una query seguente:

db.mycollection.find(HAS IMAGE URL)

Quale dovrebbe essere la sintassi corretta?

Ciò restituirà tutti i documenti con una chiave denominata "URL IMMAGINE", ma potrebbero comunque avere un valore nullo.

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

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

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

Inoltre, secondo i documenti, $ esiste attualmente non può usare un indice, ma $ ne può.

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

Dati questi inserti:

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

Questo restituirà tutti e tre i documenti:

db.test.find();

Ciò restituirà solo il primo e il secondo documento:

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

Questo restituirà solo il primo documento:

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

Ciò restituirà solo il secondo e il terzo documento:

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

Una fodera è la migliore:

db.mycollection.find({ 'fieldname' : { $exists: true, $ne: null } });

Qui,

mycollection : inserisci il nome della tua collezione desiderata

fieldname : inserisci il nome del campo desiderato

Spiegazione:

$ esiste : quando è vero, $ esiste corrisponde ai documenti che contengono il campo, inclusi i documenti in cui il valore del campo è nullo. Se è falso, la query restituisce solo i documenti che non contengono il campo.

$ ne seleziona i documenti in cui il valore del campo non è uguale al valore specificato. Ciò include i documenti che non contengono il campo.

Quindi, nel tuo caso fornito, esiste la seguente query che restituisce tutti i documenti con il campo imageurl e che non hanno valore null:

db.mycollection.find({ 'imageurl' : { $exists: true, $ne: null } });

In pymongo puoi usare:

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

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

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

recupera i documenti che contengono questo nome file anche se è nullo.

La mia proposta:

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

Puoi controllare il tipo di attributo richiesto, restituirà tutti i documenti che il suo field_name interrogato contiene un valore perché stai controllando il tipo di file archiviato altrimenti se è nullo la condizione del tipo non corrisponde quindi non verrà restituito nulla.

Nb : se field_name ha una stringa vuota che significa "", verrà restituito. È lo stesso comportamento per

db.collection_name.find({"filed_name":{$ne:null}});

Convalida aggiuntiva:

Ok, quindi non abbiamo ancora finito, 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"})

Riferimento

Condivisione per i futuri lettori.

Questa query ha funzionato per noi (query eseguita dalla bussola MongoDB ):

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

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

In un caso ideale, si desidera di prova per tutti e tre i valori , nulla , "" o svuotare (campo non esiste nel record)

Puoi fare quanto segue.

db.users.find({$and: [{"name" : {$nin: ["", null]}}, {"name" : {$exists: true}}]})

Un'alternativa che non è stata menzionata, ma che potrebbe essere un'opzione più efficiente per alcuni (non funzionerà con le voci NULL) è quella di utilizzare un indice sparse (le voci nell'indice esistono solo quando c'è qualcosa nel campo). Ecco un set 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, crea l'indice sparse sul campo imageUrl:

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 esempio) che invece di utilizzare un indice, MongoDB utilizzerà una scansione di tabella, anche per una potenziale query di indice coperta. A quanto pare, questo 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, quindi i documenti extra con no imageUrlvengono restituiti, semplicemente vuoti, non quello che volevamo. Giusto per confermare il perché, spiega:

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ì, a BasicCursorequivale a una scansione della tabella, non ha utilizzato l'indice. Forziamo 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 stavamo cercando: vengono restituiti solo i documenti con il campo popolato. Questo utilizza anche solo l'indice (ovvero è una query di indice coperta), quindi solo l'indice deve essere in memoria per restituire i risultati.

Questo è un caso d'uso specializzato e non può essere usato in generale (vedi altre risposte per quelle 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 si prega di utilizzare solo quando appropriato.

Il modo più semplice per verificare l'esistenza della colonna nella bussola mongo è:

{ 'column_name': { $exists: true } }

la query sarà

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

restituirà tutti i documenti con "URL IMMAGINE" come chiave ...........