Zapytanie o dokumenty, których rozmiar tablicy jest większy niż 1

Mam kolekcję MongoDB z dokumentami w następującym formacie:

{
  "_id" : ObjectId("4e8ae86d08101908e1000001"),
  "name" : ["Name"],
  "zipcode" : ["2223"]
}
{
  "_id" : ObjectId("4e8ae86d08101908e1000002"),
  "name" : ["Another ", "Name"],
  "zipcode" : ["2224"]
}

Obecnie mogę uzyskać dokumenty pasujące do określonego rozmiaru tablicy:

db.accommodations.find({ name : { $size : 2 }})

To poprawnie zwraca dokumenty z 2 elementami w nametablicy. Nie mogę jednak wykonać $gtpolecenia, aby zwrócić wszystkie dokumenty, w których namepole ma rozmiar tablicy większy niż 2:

db.accommodations.find({ name : { $size: { $gt : 1 } }})

Jak mogę wybrać wszystkie dokumenty z nametablicą o rozmiarze większym niż jeden (najlepiej bez konieczności modyfikowania bieżącej struktury danych)?

Aktualizacja:

Dla wersji MongoDB 2.2+ bardziej efektywny sposób to zrobić opisane przez @JohnnyHK w innej odpowiedzi .

1. Za pomocą $ gdzie

db.accommodations.find( { $where: "this.name.length > 1" } );

Ale...

JavaScript działa wolniej niż natywne operatory wymienione na tej stronie, ale jest bardzo elastyczny. Aby uzyskać więcej informacji, zobacz stronę przetwarzania po stronie serwera.

2. Utwórz dodatkowe pole NamesArrayLength, zaktualizuj je o długość tablicy nazw, a następnie użyj w zapytaniach:

db.accommodations.find({"NamesArrayLength": {$gt: 1} });

Będzie to lepsze rozwiązanie i będzie działało znacznie szybciej (możesz na nim utworzyć indeks).

Istnieje bardziej wydajny sposób na wykonanie tego w MongoDB 2.2+, ponieważ można używać indeksów tablic numerycznych w kluczach obiektów zapytań.

// Find all docs that have at least two name array elements.
db.accommodations.find({'name.1': {$exists: true}})

Możesz wesprzeć to zapytanie za pomocą indeksu, który używa częściowego wyrażenia filtrującego (wymaga wersji 3.2+):

// index for at least two name array elements
db.accommodations.createIndex(
    {'name.1': 1},
    {partialFilterExpression: {'name.1': {$exists: true}}}
);

Uważam, że jest to najszybsze zapytanie, które odpowiada na twoje pytanie, ponieważ nie używa interpretowanej $whereklauzuli:

{$nor: [
    {name: {$exists: false}},
    {name: {$size: 0}},
    {name: {$size: 1}}
]}

Oznacza to „wszystkie dokumenty oprócz tych bez nazwy (nieistniejącej lub pustej tablicy) lub z tylko jedną nazwą”.

Test:

> db.test.save({})
> db.test.save({name: []})
> db.test.save({name: ['George']})
> db.test.save({name: ['George', 'Raymond']})
> db.test.save({name: ['George', 'Raymond', 'Richard']})
> db.test.save({name: ['George', 'Raymond', 'Richard', 'Martin']})
> db.test.find({$nor: [{name: {$exists: false}}, {name: {$size: 0}}, {name: {$size: 1}}]})
{ "_id" : ObjectId("511907e3fb13145a3d2e225b"), "name" : [ "George", "Raymond" ] }
{ "_id" : ObjectId("511907e3fb13145a3d2e225c"), "name" : [ "George", "Raymond", "Richard" ] }
{ "_id" : ObjectId("511907e3fb13145a3d2e225d"), "name" : [ "George", "Raymond", "Richard", "Martin" ] }
>

Możesz także użyć agregacji:

db.accommodations.aggregate(
[
     {$project: {_id:1, name:1, zipcode:1, 
                 size_of_name: {$size: "$name"}
                }
     },
     {$match: {"size_of_name": {$gt: 1}}}
])

// dodajesz „rozmiar_nazwy” do dokumentu transportowego i używasz go do filtrowania rozmiaru nazwy

Spróbuj zrobić coś takiego:

db.getCollection('collectionName').find({'ArrayName.1': {$exists: true}})

1 jest liczbą, jeśli chcesz pobrać rekord większy niż 50, to zrób ArrayName.50 Dzięki.

Żadne z powyższych nie działało dla mnie. Ten zrobił, więc dzielę się tym:

db.collection.find( {arrayName : {$exists:true}, $where:'this.arrayName.length>1'} )

Możesz użyć $ expr (operator wersji mongo 3.6), aby użyć funkcji agregujących w regularnym zapytaniu.

Porównaj query operatorsvs aggregation comparison operators.

db.accommodations.find({$expr:{$gt:[{$size:"$name"}, 1]}})

db.accommodations.find({"name":{"$exists":true, "$ne":[], "$not":{"$size":1}}})

MongoDB 3.6 zawiera $ expr https://docs.mongodb.com/manual/reference/operator/query/expr/

Możesz użyć $ expr, aby ocenić wyrażenie w dopasowaniu $ lub znaleźć.

{ $match: {
           $expr: {$gt: [{$size: "$yourArrayField"}, 0]}
         }
}

lub znajdź

collection.find({$expr: {$gte: [{$size: "$yourArrayField"}, 0]}});

Znalazłem to rozwiązanie, aby znaleźć przedmioty o polu tablicy większym niż pewna długość

db.allusers.aggregate([
  {$match:{username:{$exists:true}}},
  {$project: { count: { $size:"$locations.lat" }}},
  {$match:{count:{$gt:20}}}
])

W agregacji pierwszego dopasowania $ użyto argumentu, który jest prawdziwy dla wszystkich dokumentów. Jeśli puste, dostanę

"errmsg" : "exception: The argument to $size must be an Array, but was of type: EOO"

Znam jego stare pytanie, ale próbuję tego z $ gte i $ size w znalezieniu. Myślę, że znalezienie () jest szybsze.

db.getCollection('collectionName').find({ name : { $gte : {  $size : 1 } }})

Chociaż powyższe odpowiedzi działają poprawnie, to, co pierwotnie próbowałeś zrobić, było poprawne, ale masz tylko składnię wstecz (przełącz „$ size” i „$ gt”) ..

Poprawny:

db.collection.find({items: {$gt: {$size: 1}}})

Błędny:

db.collection.find({items: {$size: {$gt: 1}}})