Interrogazione dei documenti di MongoDB in Golang

Questo capitolo introduce l'uso delle query di documenti Golang MongoDB.

Tutorial Prerequisiti

• MongoDB Tutorial

Suggerimento: se non conosci la sintassi delle query di MongoDB, leggi prima il tutorial su MongoDB. La sintassi espressiva utilizzata per le operazioni di MongoDB in Golang è la stessa.

Prepara i Dati di Test

Inserisci un insieme di dati di documento nella raccolta coll.

docs := []interface{}{
    bson.D{
        {"item", "journal"},
        {"qty", 25},
        {"size", bson.D{
            {"h", 14},
            {"w", 21},
            {"uom", "cm"},
        }},
        {"status", "A"},
    },
    // ... (altri dati del documento)
}

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

Query di Tutti i Documenti

cursor, err := coll.Find(
    context.Background(),
    bson.D{}, // Imposta condizione di query vuota
)

Condizioni di Query di Uguaglianza

Simile alla corrispondenza di uguaglianza di SQL.

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

Operatore di Query in

Simile alla query in di SQL.

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

Condizioni di Query and

Simile all'espressione logica and di SQL.

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

Condizioni di Query or

Simile all'espressione logica or di SQL.

cursor, err := coll.Find(
    context.Background(),
    bson.D{ // Condizione equivalente: status = "A" O qty < 30
        {"$or", // Using $or operator
            bson.A{ // Using bson.A array type definition
                bson.D{{"status", "A"}},
                bson.D{{"qty", bson.D{{"$lt", 30}}}},
            }},
    })

Esempio di Query Composta

cursor, err := coll.Find(
    context.Background(),
    bson.D{ // Condizione equivalente: status = "A" E ( 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: ""}}},
        }},
    })

Attraversa i Risultati della Query

Esempio 1

// Query dei documenti in cui il nome è 'Bob'
cursor, err := coll.Find(context.TODO(), bson.D{{"name", "Bob"}}, opts)
if err != nil {
	log.Fatal(err)
}

// Definisci un array di documenti di tipo bson.M, dove bson.M è una struttura dati chiave-valore simile a una mappa
var results []bson.M
// Utilizza la funzione All per recuperare tutti i risultati della query e salvare i risultati nella variabile results.
if err = cursor.All(context.TODO(), &results); err != nil {
	log.Fatal(err)
}

// Attraversa l'array di risultati
for _, result := range results {
	fmt.Println(result)
}

Spiegazione: L'esempio utilizza il tipo bson.M per memorizzare i dati del documento. Puoi personalizzare un tipo di struct purché i campi corrispondano al documento.

Esempio 2

// Definisci una variabile di tipo struct per salvare il risultato della query
var result struct {
    Value float64
}

// Definisci la condizione di query del documento nome = 'pi'
filter := bson.D{{"name", "pi"}}
// Crea un oggetto contesto e imposta il timeout della query a 5 secondi
ctx, cancel = context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// Esegui una query di singolo dato in base alla condizione e utilizza la funzione Decode per salvare il risultato nella variabile result
err = collection.FindOne(ctx, filter).Decode(&result)

// Controlla gli errori della query
if err == mongo.ErrNoDocuments {
    // Documento non trovato
    fmt.Println("Documento non esiste")
} else if err != nil {
    log.Fatal(err)
}
// Altro gestione

Suggerimento: Per una sintassi di espressione di query MongoDB più sofisticata, consulta il tutorial su MongoDB.