Consulta de documentos de Golang MongoDB

Este capítulo introduce el uso de las consultas de documentos MongoDB en Golang.

Tutoriales previos

• Tutorial de MongoDB

Consejo: Si no estás familiarizado con la sintaxis de consulta de MongoDB, lee primero el tutorial de MongoDB. La sintaxis de expresión utilizada para las operaciones de MongoDB en Golang es la misma.

Preparar datos de prueba

Inserta un lote de datos de documentos en la colección coll.

docs := []interface{}{
    bson.D{
        {"item", "journal"},
        {"qty", 25},
        {"size", bson.D{
            {"h", 14},
            {"w", 21},
            {"uom", "cm"},
        }},
        {"status", "A"},
    },
    // ... (otros datos de documentos)
}

resultado, err := coll.InsertMany(context.Background(), docs)

Consultar todos los documentos

cursor, err := coll.Find(
    context.Background(),
    bson.D{}, // Establecer condición de consulta vacía
)

Condiciones de consulta de igualdad

Similar al emparejamiento de igualdad de SQL.

cursor, err := coll.Find(
    context.Background(),
    bson.D{{"status", "D"}},   // Condición equivalente: status = D
)

Operador de consulta in

Similar a la consulta in de SQL.

cursor, err := coll.Find(
    context.Background(),
    bson.D{{"status", bson.D{{"$in", bson.A{"A", "D"}}}}}) // Condición equivalente: status in ('A', 'D')

Condiciones de consulta and

Similar a la expresión lógica and de SQL.

cursor, err := coll.Find(
    context.Background(),
    bson.D{ // Condición equivalente: status='A' y qty < 30 
        {"status", "A"},
        {"qty", bson.D{{"$lt", 30}}},
    })

Condiciones de consulta or

Similar a la expresión lógica or de SQL.

cursor, err := coll.Find(
    context.Background(),
    bson.D{ // Condición equivalente: status = "A" O qty < 30
        {"$or", // Usando el operador $or
            bson.A{ // Usando definición de tipo de array bson.A
                bson.D{{"status", "A"}},
                bson.D{{"qty", bson.D{{"$lt", 30}}}},
            }},
    })

Ejemplo de consulta compuesta

cursor, err := coll.Find(
    context.Background(),
    bson.D{ // Condición equivalente: status = "A" Y ( qty < 30 O item LIKE "p%")
        {"status", "A"},
        {"$or", bson.A{
            bson.D{{"qty", bson.D{{"$lt", 30}}}},
            bson.D{{"item", primitive.Regex{Pattern: "^p", Options: ""}}},
        }},
    })

Recorrer resultados de consulta

Ejemplo 1

// Consultar documentos donde el nombre es 'Bob'
cursor, err := coll.Find(context.TODO(), bson.D{{"name", "Bob"}}, opts)
if err != nil {
	log.Fatal(err)
}

// Definir un array de documentos de tipo bson.M, donde bson.M es una estructura de datos de clave-valor similar a un mapa
var results []bson.M
// Usar la función All para recuperar todos los resultados de la consulta y guardar los resultados en la variable results.
if err = cursor.All(context.TODO(), &results); err != nil {
	log.Fatal(err)
}

// Recorrer el array de resultados
for _, result := range results {
	fmt.Println(result)
}

Explicación: El ejemplo utiliza el tipo bson.M para almacenar datos de documentos. Puedes personalizar un tipo de struct siempre y cuando los campos coincidan con el documento.

Ejemplo 2:

// Definir una variable de tipo struct para guardar el resultado de la consulta
var result struct {
    Value float64
}

// Definir la condición de consulta del documento nombre = 'pi'
filtro := bson.D{{"name", "pi"}}
// Crear un objeto de contexto y establecer el tiempo de espera de la consulta en 5 segundos
ctx, cancel = context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// Consultar un solo dato basado en la condición y usar la función Decode para guardar el resultado en la variable result
err = collection.FindOne(ctx, filtro).Decode(&result)

// Comprobar errores de consulta
if err == mongo.ErrNoDocuments {
    // Documento no encontrado
    fmt.Println("El documento no existe")
} else if err != nil {
    log.Fatal(err)
}
// Otro manejo

Consejo: Para una sintaxis de expresión de consulta de MongoDB más sofisticada, consulta el tutorial de MongoDB.