Especificar uma query

Visão geral

Neste guia, você pode aprender como especificar uma query para corresponder a um subconjunto de documentos.

Para corresponder a um subconjunto de documentos, especifique um filtro de query contendo seus critérios de correspondência. Os critérios de correspondência consistem nos campos e valores que você deseja apresentar em um documento. Um filtro de consulta contém pelo menos um conjunto de critérios de correspondência para determinar quais documentos incluir no conjunto resultante.

Em um filtro de queries, você pode corresponder campos com valores literais ou com operadores de query. Os operadores de query permitem que você realize operações matemáticas ou lógicas para localizar documentos dentro de uma coleção.

Os critérios de correspondência com valores literais usam o seguinte formato:

filter := bson.D{{"<field>", "<value>"}}

Os critérios de correspondência com um operador de query usam o seguinte formato:

filter := bson.D{{"<field>", bson.D{{"<operator>", "<value>"}}}}

As seções seguintes utilizam valores literais e operadores de query com o método Find() para corresponder a um subconjunto de documentos.

coll := client.Database("tea").Collection("ratings")
docs := []interface{}{
	bson.D{{"type", "Masala"}, {"rating", 10}, {"vendor", bson.A{"A", "C"}}},
	bson.D{{"type", "English Breakfast"}, {"rating", 6}},
	bson.D{{"type", "Oolong"}, {"rating", 7}, {"vendor", bson.A{"C"}}},
	bson.D{{"type", "Assam"}, {"rating", 5}},
	bson.D{{"type", "Earl Grey"}, {"rating", 8}, {"vendor", bson.A{"A", "B"}}},
}
result, err := coll.InsertMany(context.TODO(), docs)
if err != nil {
	panic(err)
}
fmt.Printf("%d documents inserted with IDs:\n", len(result.InsertedIDs))

Valores literais

Os filtros de query de valor literal retornam documentos com uma correspondência exata em relação a seus critérios de correspondência.

filter := bson.D{{"type", "Oolong"}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

filter := bson.D{{"type", "Oolong"}}

filter := bson.D{{"type", bson.D{{"$eq", "Oolong"}}}}

Comparação

Os operadores de comparação analisam o valor em um documento em relação ao valor especificado nos seus critérios de correspondência. Os operadores de comparação comuns incluem $gt para comparações "maior que", $lte para comparações "menor que ou igual a" e $ne para comparações "não igual a".

filter := bson.D{{"rating", bson.D{{"$lt", 7}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

Lógica

Os operadores lógicos exigem pelo menos dois critérios de correspondência. Eles verificam se os documentos atendem a todos, pelo menos um ou nenhum dos critérios especificados. Os operadores lógicos comuns incluem $and, em que todos os critérios de correspondência devem ser verdadeiros, e $or, em que pelo menos um dos critérios de correspondência deve ser verdadeiro.

filter := bson.D{
   {"$and",
      bson.A{
         bson.D{{"rating", bson.D{{"$gt", 7}}}},
         bson.D{{"rating", bson.D{{"$lte", 10}}}},
      },
   },
}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

filter := bson.D{{"type", "Oolong"}, {"rating", 7}}

filter := bson.D{
      {"$and",
              bson.A{
                          bson.D{{"type", "Oolong"}},
                          bson.D{{"rating", 7}},
                  }},
}

Elemento

Os operadores de elemento verificam a presença ou tipo do campo especificado.

filter := bson.D{{"vendor", bson.D{{"$exists", false}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

Avaliação

Os operadores de avaliação analisam valores em um documento com base no valor especificado em seus critérios de correspondência. Os operadores de avaliação comuns incluem $regex onde o valor de um campo deve corresponder à expressão regular especificada e $text onde o valor do campo deve conter a string especificada.

filter := bson.D{{"type", bson.D{{"$regex", "^E"}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

Array

Os operadores de array verificam os valores ou a quantidade de elementos em um campo de array.

filter := bson.D{{"vendor", bson.D{{"$all", bson.A{"C"}}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

Bitwise

Os operadores bit a bit convertem um campo numérico de um número de base 10 (decimal) no número de base 2 (binário) correspondente. Eles verificam se o valor em um documento tem os mesmos bits definidos como o valor em seus critérios de correspondência.

filter := bson.D{{"rating", bson.D{{"$bitsAllSet", 6}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

Informações adicionais