Stockage et récupération Mongodb dans le pilote mongogo

Contenu de la question

J'essaie d'insérer des données et de lire ces données depuis mongodb à l'aide du pilote mongo go. J'utilise une structure avec des champs de données. Lorsque j'utilise le type de données comme interface, j'obtiens plusieurs cartes et lorsque je le spécifie comme tranche de carte, il renvoie une seule carte. Les données dans MongoDB sont similaires.

package main

import (
    "context"
    "fmt"

    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

type Host struct {
    Hostname string                   `bson:"hostname"`
    Data     []map[string]interface{} `bson:"data"` //return single map
    // Data     interface{} `bson:"data"` //returns multiple maps

}

func main() {
    // Set up a MongoDB client
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
    client, err := mongo.Connect(context.Background(), clientOptions)
    if err != nil {
        panic(err)
    }

    // Set up a MongoDB collection
    collection := client.Database("testdb").Collection("hosts")

    // Create a host object to insert into the database
    host := Host{
        Hostname: "example.com",
        Data: []map[string]interface{}{
            {"key1": "using specific type", "key2": 123},
        },
    }

    // Insert the host object into the collection
    _, err = collection.InsertOne(context.Background(), host)
    if err != nil {
        panic(err)
    }

    // Query the database for the host object
    filter := bson.M{"hostname": "example.com"}
    var result Host
    err = collection.FindOne(context.Background(), filter).Decode(&result)
    if err != nil {
        panic(err)
    }

    // Print the host object
    fmt.Println(result)
}

Lors de l'utilisation de l'interface uniquement

Lors de l'utilisation de tuiles de carte

Les données stockées dans les deux cas sont similaires.

Pourquoi obtenons-nous des écarts de données lorsque nous essayons d'accéder aux données ?

Réponse correcte

Lorsque vous utilisez interface{}, cela signifie que vous laissez au conducteur le soin de choisir le type de données qui, selon lui, représente le mieux les données provenant de mongodb.

Lorsque vous utilisez []map[string]interface{}, vous indiquez explicitement que vous souhaitez une tranche de carte, où chaque carte peut représenter un document.

Quand vous utilisez interface{} 时，您什么也不说。驱动程序将选择 bson.a 来表示数组，并选择 bson.d, vous ne dites rien. Le pilote choisira bson.a pour représenter un tableau et

pour représenter un document.

bson.a a> 只是一个 [] 接口{}，并且 bson.d 是 []e 其中 e

est

type e struct {
    key   string
    value interface{}
}

bson.dDonc, fondamentalement,

est une liste ordonnée de paires clé-valeur (propriétés).

interface{} 时，您会得到一片切片，而不是多个地图。不打印类型信息，fmtAinsi, lorsque vous utilisez

, vous obtenez une tranche au lieu de plusieurs cartes. Sans imprimer les informations de type, le package fmt imprime les tranches et les cartes, toutes deux entourées de crochets.

Si vous voulez voir le type, imprimez-le comme ceci :

fmt.printf("%#v\n", result.data)

[]map[string]接口{}Sortie lors de l'utilisation de

 : 

[]map[string]interface {}{map[string]interface {}{"key1":"using specific type", "key2":123}}

interface{}Sortie lors de l'utilisation de

 : 🎜

primitive.A{primitive.D{primitive.E{Key:"key1", Value:"using specific type"}, primitive.E{Key:"key2", Value:123}}}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!