Especifica un query

Overview

En esta guía, puedes aprender a especificar una query para hacer coincidir un subconjunto de documentos.

Para coincidir con un subconjunto de documentos, especifique un filtro de query que contenga sus criterios de coincidencia. Los criterios de coincidencia consisten en los campos y valores que desea que estén presentes en un documento. Un filtro de query contiene al menos un conjunto de criterios de coincidencia para determinar qué documentos incluir en el conjunto resultante.

En un filtro de query, puedes filtrar campos con valores literales o con operadores del query. Los operadores del query permiten realizar operaciones matemáticas o lógicas para localizar documentos dentro de una colección.

Los criterios de coincidencia con valores literales usan el siguiente formato:

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

Los criterios de coincidencia con un operador de consulta utilizan el siguiente formato:

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

Las siguientes secciones utilizan valores literales y operador del query con el Find() método para hacer coincidir un subconjunto de documentos.

type Tea struct {
	Type   string
	Rating int32
	Vendor []string `bson:"vendor,omitempty" json:"vendor,omitempty"`
}

coll := client.Database("db").Collection("tea")
docs := []any{
	Tea{Type: "Masala", Rating: 10, Vendor: []string{"A", "C"}},
	Tea{Type: "English Breakfast", Rating: 6},
	Tea{Type: "Oolong", Rating: 7, Vendor: []string{"C"}},
	Tea{Type: "Assam", Rating: 5},
	Tea{Type: "Earl Grey", Rating: 8, Vendor: []string{"A", "B"}},
}
result, err := coll.InsertMany(context.TODO(), docs)

Valores literales

Los filtros de consulta de valor literal devuelven documentos que coinciden exactamente con sus criterios de coincidencia.

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

{"type":"Oolong","rating":7,"vendor":["C"]}

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

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

Comparación

Los operadores de comparación analizan el valor en un documento frente al valor especificado en tus criterios de coincidencia. Los operadores de comparación generales incluyen $gt para comparaciones "mayor que", $lte para comparaciones "menor o igual que" y $ne para comparaciones "no igual a".

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

{"type":"English Breakfast","rating":6}
{"type":"Assam","rating":5}

Lógica

Los operadores lógicos requieren al menos dos criterios de coincidencia. Verifican si los documentos cumplen con todos, al menos, uno o ninguno de los criterios especificados. Los operadores lógicos comunes incluyen $and, donde todos los criterios de coincidencia deben cumplirse, y $or, donde al menos uno de los criterios de coincidencia debe cumplirse.

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 []Tea
if err = cursor.All(context.TODO(), &results); err != nil {
    panic(err)
}
for _, result := range results {
    res, _ := bson.MarshalExtJSON(result, false, false)
    fmt.Println(string(res))
}

{"type":"Masala","rating":10,"vendor":["A","C"]}
{"type":"Earl Grey","rating":8,"vendor":["A","B"]}

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

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

Elemento

Los operadores de elemento verifican la presencia o el tipo del campo especificado.

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

{"type":"English Breakfast","rating":6}
{"type":"Assam","rating":5}

Evaluación

Los operadores de evaluación analizan valores en un documento según el valor especificado en tus criterios de coincidencia. Los operadores de evaluación comunes incluyen $regex en los que el valor de un campo debe coincidir con la expresión regular especificada y $text en los que el valor del campo debe contener la string especificada.

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

{"type":"English Breakfast","rating":6}
{"type":"Earl Grey","rating":8,"vendor":["A","B"]}

Arreglo

Los operadores de arreglo verifican los valores o la cantidad de elementos en un campo de arreglo.

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

{"type":"Masala","rating":10,"vendor":["A","C"]}
{"type":"Oolong","rating":7,"vendor":["C"]}

Bitwise

Los operadores bit a bit convierten un campo numérico de un número en base 10 (decimal) en el número correspondiente en base 2 (binario). Verifican si el valor en un documento tiene los mismos bits establecidos que el valor en tus criterios de coincidencia.

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

{"type":"English Breakfast","rating":6}
{"type":"Oolong","rating":7,"vendor":["C"]}

Información Adicional

Para obtener información sobre cómo especificar una consulta geoespacial, consulte la guía sobre datos geoespaciales.