Especifica un query

Overview

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

Para buscar coincidencias en un subconjunto de documentos, especifique un filtro de consulta que contenga sus criterios de coincidencia. Estos criterios consisten en los campos y valores que desea que estén presentes en un documento. Un filtro de consulta contiene al menos un conjunto de criterios de coincidencia para determinar qué documentos se incluirán en el conjunto resultante.

En un filtro de consulta, puede hacer coincidir campos con Valores literales o con operadores de consulta. Los operadores de consulta permiten realizar operaciones matemáticas o lógicas para localizar documentos dentro de una colección.

Los criterios de coincidencia con valores literales utilizan 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 operadores de consulta 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 de un documento comparándolo con el valor especificado en los criterios de coincidencia. Los operadores de comparación comunes incluyen $gt para comparaciones "mayor que", $lte para comparaciones "menor o igual que" y $ne para comparaciones "distinto de".

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. Comprueban si los documentos cumplen todos, al menos uno o ninguno de los criterios especificados. Los operadores lógicos comunes incluyen $and, donde todos los criterios de coincidencia deben ser verdaderos, y $or, donde al menos uno de ellos debe ser verdadero.

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 elementos 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 los valores de un documento según el valor especificado en los criterios de coincidencia. Los operadores de evaluación comunes incluyen $regex, donde el valor de un campo debe coincidir con la expresión regular especificada, y $text, donde el valor del campo debe contener la cadena 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 matriz comprueban los valores o la cantidad de elementos en un campo de matriz.

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 decimal (base10) al número binario (base2) correspondiente. Comprueban si el valor de un documento tiene los mismos bits que el valor de los 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.