web-dev-qa-db-fra.com

Trouver tous les documents dans une collection avec Mongo Go Driver

J'ai vérifié la réponse ICI mais cela utilise l'ancienne et la MGO non comprise. Comment puis-je trouver tous les documents dans une collection à l'aide du conducteur Mongo-Go?

J'ai essayé de passer un filtre nil, mais cela ne renvoie aucun document et renvoie plutôt nil. J'ai également vérifié la Documentation mais n'a vu aucune mention de renvoi de tous les documents. Voici ce que j'ai essayé avec un résultat susmentionné.

client, err := mongo.Connect(context.TODO(), "mongodb://localhost:27017")
coll := client.Database("test").Collection("albums")
if err != nil { fmt.Println(err) }
// we can assume we're connected...right?
fmt.Println("connected to mongodb")

var results []*Album
findOptions := options.Find()
cursor, err := coll.Find(context.TODO(), nil, findOptions)
if err != nil {
   fmt.Println(err) // prints 'document is nil'
}

En outre, je suis à peu près confus sur la raison pour laquelle j'ai besoin de spécifier findOptions lorsque j'ai appelé la fonction Find() fonction de la collection (ou n'est-ce pas nécessaire pour spécifier?).

mongodbgomongo-go
5
Kelly Flet

Essayez de passer un bson.D au lieu de nil:

cursor, err := coll.Find(context.TODO(), bson.D{})

En outre, FindOptions est facultatif.

Disclaimer: Je n'ai jamais utilisé le pilote officiel, mais il y a quelques exemples à https://godoc.org/go.mongodb.org/mongo-driver/mongo

On dirait que leur tutoriel est obsolète: /

3
Moshe Revah

Voici ce que j'ai proposé avec le pilote officiel de MongoDB pour Golang. J'utilise Godotenv ( https://github.com/joho/godotenv ) pour transmettre les paramètres de la base de données.

//Find multiple documents
func FindRecords() {
    err := godotenv.Load()

    if err != nil {
        fmt.Println(err)
    }

    //Get database settings from env file
    //dbUser := os.Getenv("db_username")
    //dbPass := os.Getenv("db_pass")
    dbName := os.Getenv("db_name")
    docCollection := "retailMembers"

    dbHost := os.Getenv("db_Host")
    dbPort := os.Getenv("db_port")
    dbEngine := os.Getenv("db_type")

    //set client options
    clientOptions := options.Client().ApplyURI("mongodb://" + dbHost + ":" + dbPort)
    //connect to MongoDB
    client, err := mongo.Connect(context.TODO(), clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    //check the connection
    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Connected to " + dbEngine)
    db := client.Database(dbName).Collection(docCollection)

    //find records
    //pass these options to the Find method
    findOptions := options.Find()
    //Set the limit of the number of record to find
    findOptions.SetLimit(5)
    //Define an array in which you can store the decoded documents
    var results []Member

    //Passing the bson.D{{}} as the filter matches  documents in the collection
    cur, err := db.Find(context.TODO(), bson.D{{}}, findOptions)
    if err !=nil {
        log.Fatal(err)
    }
    //Finding multiple documents returns a cursor
    //Iterate through the cursor allows us to decode documents one at a time

    for cur.Next(context.TODO()) {
        //Create a value into which the single document can be decoded
        var elem Member
        err := cur.Decode(&elem)
        if err != nil {
            log.Fatal(err)
        }

        results =append(results, elem)

    }

    if err := cur.Err(); err != nil {
        log.Fatal(err)
    }

    //Close the cursor once finished
    cur.Close(context.TODO())

    fmt.Printf("Found multiple documents: %+v\n", results)


}
3
Isaac Muthui