Comprendre les types d'interfaces dans les modèles mgo

Dans le contexte de MongoDB et Go, la modélisation des données avec des interfaces peut présenter des défis en raison de la nature dynamique d'interfaces. Voici une explication concise du problème que vous avez rencontré et une suggestion de solution.

Le problème avec les types d'interface

Le modèle de données basé sur les documents de MongoDB ne fournit pas de type informations pour les documents intégrés. Lors de l'utilisation de mgo pour désorganiser des documents MongoDB contenant des types d'interface dans des structures Go, mgo ne peut pas déterminer le type spécifique de chaque document incorporé. Cela entraîne l'erreur « la valeur de type bson.M n'est pas attribuable au type Node. »

Solution : encapsuler les types d'interface

Pour résoudre cette limitation, une approche consiste à envelopper le type d'interface dans une structure personnalisée qui fournit des informations de type. Cela permet à mgo d'identifier le type spécifique du document incorporé lors de la désorganisation.

Considérez l'exemple suivant :

type NodeWithType struct {
   Node Node `bson:"-"`
   Type string
}

type Workflow struct {
   CreatedAt time.Time
   StartedAt time.Time
   CreatedBy string
   Nodes []NodeWithType
}

Implémentation de la fonction SetBSON

Pour compléter cette solution, vous devez implémenter la fonction SetBSON pour le type NodeWithType. Cette fonction décodera la chaîne de type, créera une instance du type correspondant et la désorganisera.

func (nt *NodeWithType) SetBSON(r bson.Raw) error {
   // Decode the "Type" field and determine the Node type
   var typeStr string
   if err := r.Unmarshal(&typeStr); err != nil {
      return err
   }

   // Create a new instance of the Node type based on the type string
   node, ok := reflect.New(reflect.TypeOf(Node).Elem()).Interface().(Node)
   if !ok {
      return errors.New("invalid Node type")
   }

   // Unmarshal the remaining data into the Node instance
   if err := r.Unmarshal(node); err != nil {
      return err
   }

   // Assign the Node instance to the NodeWithType struct
   nt.Node = node
   return nil
}

Conclusion

L'utilisation de ce modèle vous permet d'utiliser efficacement les interfaces tout en conservant la possibilité de désassembler des documents incorporés de différents types. En fournissant des informations de type explicites, mgo peut décoder de manière transparente ces documents dans les structures Go souhaitées.