Zapytanie dokumentu Golang MongoDB

To jest rozdział dotyczący używania zapytań do dokumentów MongoDB w GoLang.

Wymagane samouczki

• Samouczek MongoDB

Wskazówka: Jeśli nie znasz składni zapytań MongoDB, przeczytaj najpierw samouczek MongoDB. Składnia wyrażeń używana do operacji MongoDB w GoLang jest taka sama.

Przygotowanie danych testowych

Wstaw partię danych dokumentów do kolekcji coll.

docs := []interface{}{
    bson.D{
        {"item", "journal"},
        {"qty", 25},
        {"size", bson.D{
            {"h", 14},
            {"w", 21},
            {"uom", "cm"},
        }},
        {"status", "A"},
    },
    // ... (inne dane dokumentów)
}

wynik, błąd := coll.InsertMany(context.Background(), docs)

Zapytanie o wszystkie dokumenty

kursor, błąd := coll.Find(
    context.Background(),
    bson.D{}, // Ustaw puste warunki zapytania
)

Warunki zapytania równości

Podobne do dopasowania równości w SQL.

kursor, błąd := coll.Find(
    context.Background(),
    bson.D{{"status", "D"}},   // Warunek równoważny: status = D
)

Operator zapytania in

Podobne do zapytania in w SQL.

kursor, błąd := coll.Find(
    context.Background(),
    bson.D{{"status", bson.D{{"$in", bson.A{"A", "D"}}}}}) // Warunek równoważny: status in ('A', 'D')

Warunki zapytania and

Podobne do logicznego wyrażenia and w SQL.

kursor, błąd := coll.Find(
    context.Background(),
    bson.D{ // Warunek równoważny: status='A' and qty < 30 
        {"status", "A"},
        {"qty", bson.D{{"$lt", 30}}},
    })

Warunki zapytania or

Podobne do logicznego wyrażenia or w SQL.

kursor, błąd := coll.Find(
    context.Background(),
    bson.D{ // Warunek równoważny: status = "A" OR qty < 30
        {"$or", // Użyj operatora $or
            bson.A{ // Użyj definicji typu tablicy bson.A
                bson.D{{"status", "A"}},
                bson.D{{"qty", bson.D{{"$lt", 30}}}},
            }},
    })

Przykład złożonego zapytania

kursor, błąd := coll.Find(
    context.Background(),
    bson.D{ // Warunek równoważny: status = "A" AND ( qty < 30 OR item LIKE "p%")
        {"status", "A"},
        {"$or", bson.A{
            bson.D{{"qty", bson.D{{"$lt", 30}}}},
            bson.D{{"item", primitive.Regex{Pattern: "^p", Options: ""}}},
        }},
    })

Przejście przez wyniki zapytania

Przykład 1

// Zapytaj dokumenty, gdzie nazwa to 'Bob'
kursor, błąd := coll.Find(context.TODO(), bson.D{{"name", "Bob"}}, opts)
if błąd != nil {
	log.Fatal(błąd)
}

// Zdefiniuj tablicę dokumentów typu bson.M, gdzie bson.M jest strukturą danych klucz-wartość podobną do mapy
var wyniki []bson.M
// Użyj funkcji All do pobrania wszystkich wyników zapytania i zapisz wyniki do zmiennej wyniki
if błąd = kursor.All(context.TODO(), &wyniki); błąd != nil {
	log.Fatal(błąd)
}

// Przejdź przez tablicę wyników
for _, wynik := range wyniki {
	fmt.Println(wynik)
}

Wyjaśnienie: Przykład używa typu bson.M do przechowywania danych dokumentów. Możesz dostosować typ struktury o ile pola są zgodne z dokumentem.

Przykład 2：

// Zdefiniuj zmienną typu struktury do zapisania wyniku zapytania
var wynik struct {
    Value float64
}

// Zdefiniuj warunek zapytania dokumentu name = 'pi'
filtr := bson.D{{"name", "pi"}}
// Utwórz obiekt kontekstu i ustaw limit czasu zapytania na 5 sekund
ctx, anuluj = context.WithTimeout(context.Background(), 5*time.Second)
defer anuluj()

// Zapytaj pojedyncze dane na podstawie warunku i użyj funkcji Decode do zapisania wyniku do zmiennej wynik
błąd = kolekcja.FindOne(ctx, filtr).Decode(&wynik)

// Sprawdź błędy zapytania
if błąd == mongo.ErrNoDocuments {
    // Dokument nie znaleziony
    fmt.Println("Dokument nie istnieje")
} else if błąd != nil {
    log.Fatal(błąd)
}
// Inne działania

Wskazówka: Aby uzyskać bardziej zaawansowaną składnię wyrażeń zapytań MongoDB, proszę odnieść się do samouczka MongoDB.