Como você consulta "não é nulo" no Mongo?

Eu gostaria de executar uma seguinte consulta:

db.mycollection.find(HAS IMAGE URL)

Qual deve ser a sintaxe correta?

Isso retornará todos os documentos com uma chave chamada "IMAGE URL", mas eles ainda podem ter um valor nulo.

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

Isso retornará todos os documentos com uma chave chamada "URL de IMAGEM" e um valor não nulo.

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

Além disso, de acordo com os documentos, $ existe atualmente não pode usar um índice, mas $ ne pode.

Edit: Adicionando alguns exemplos devido ao interesse nesta resposta

Dadas estas inserções:

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

Isso retornará todos os três documentos:

db.test.find();

Isso retornará apenas o primeiro e o segundo documentos:

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

Isso retornará apenas o primeiro documento:

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

Isso retornará apenas o segundo e o terceiro documentos:

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

Um forro é o melhor:

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

Aqui,

mycollection : coloque o nome da coleção desejada

nome do campo : coloque seu nome campo desejado

Explicação:

$ existe : quando verdadeiro, $ existe corresponde aos documentos que contêm o campo, incluindo documentos em que o valor do campo é nulo. Se for falso, a consulta retornará apenas os documentos que não contêm o campo.

$ ne seleciona os documentos em que o valor do campo não é igual ao valor especificado. Isso inclui documentos que não contêm o campo.

Portanto, no seu caso fornecido, a consulta a seguir retornará todos os documentos com o campo imageurl e não terá valor nulo:

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

No pymongo você pode usar:

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

Porque pymongo representa mongo "null" como python "None".

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

buscar documentos que contenham esse nome_do_arquivo mesmo que seja nulo.

Minha proposição:

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

Você pode verificar o tipo de atributo requerido, ele retornará todos os documentos que seu nome_campo consultado contém um valor, porque você está verificando o tipo de arquivo arquivado, caso seja nulo, a condição de tipo não corresponde, portanto nada será retornado.

Nota : se o field_name tiver uma cadeia vazia que significa "", será retornada. É o mesmo comportamento para

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

Validação extra:

Ok, então ainda não terminamos, precisamos de uma condição extra.

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

OU

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

Referência

Compartilhamento para futuros leitores.

Esta consulta funcionou para nós (consulta executada a partir do MongoDB compass ):

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

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

Em um caso ideal, você gostaria de teste para todos os três valores , nula , "" ou esvaziar (campo não existe no registro)

Você pode fazer o seguinte.

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

Uma alternativa que não foi mencionada, mas que pode ser uma opção mais eficiente para alguns (não funcionará com entradas NULL), é usar um índice esparso (as entradas no índice existem apenas quando há algo no campo). Aqui está um conjunto de dados de amostra:

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 }

Agora, crie o índice esparso no campo imageUrl:

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

Agora, sempre há uma chance (e em particular com um pequeno conjunto de dados como o meu exemplo) de que, em vez de usar um índice, o MongoDB use uma varredura de tabela, mesmo para uma possível consulta de índice coberta. Acontece que isso me dá uma maneira fácil de ilustrar a diferença aqui:

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, os documentos extras sem imageUrlestão sendo devolvidos, apenas vazios, não o que queríamos. Apenas para confirmar o porquê, faça uma explicação:

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
}

Então, sim, a BasicCursoré igual a uma varredura de tabela, não usou o índice. Vamos forçar a consulta a usar nosso índice esparso com um 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 existe o resultado que estávamos procurando - apenas documentos com o campo preenchido são retornados. Isso também usa apenas o índice (ou seja, é uma consulta de índice coberta), portanto, apenas o índice precisa estar na memória para retornar os resultados.

Este é um caso de uso especializado e não pode ser usado em geral (consulte outras respostas para essas opções). Em particular, deve-se notar que, como estão as coisas, você não pode usar count()dessa maneira (no meu exemplo, retornará 6 e não 4); portanto, use somente quando apropriado.

A maneira mais simples de verificar a existência da coluna no mongo compass é:

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

a consulta será

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

retornará todos os documentos com "URL de IMAGEM" como chave ...........