Comprensión de los tipos de interfaz en modelos mgo

En el contexto de MongoDB y Go, modelar datos con interfaces puede presentar desafíos debido a la naturaleza dinámica de interfaces. Aquí hay una explicación concisa del problema que ha encontrado y una solución sugerida.

El problema con los tipos de interfaz

El modelo de datos basado en documentos de MongoDB no proporciona tipos información para documentos incrustados. Cuando se utiliza mgo para descomponer documentos MongoDB que contienen tipos de interfaz en estructuras Go, mgo no puede determinar el tipo específico de cada documento incrustado. Esto da como resultado el error "el valor del tipo bson.M no se puede asignar al tipo Nodo". es envolver el tipo de interfaz en una estructura personalizada que proporciona información de tipo. Esto permite a mgo identificar el tipo específico del documento incrustado durante la descomposición.

Considere el siguiente ejemplo:

Implementación de la función SetBSON

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

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

func (nt *NodeWithType) SetBSON(r bson.Raw) error { // Decodifica el campo "Tipo" y determina el tipo de Nodo var tipocadena Str si error := r.Unmarshal(&typeStr); errar != nulo { volver error } // Crea una nueva instancia del tipo Nodo según el tipo de cadena nodo, ok := reflect.New(reflect.TypeOf(Node).Elem()).Interface().(Node) si !vale { errores de retorno. Nuevo ("tipo de nodo no válido") } // Desclasificar los datos restantes en la instancia de Nodo si errar := r.Unmarshal(nodo); errar != nulo { volver error } // Asigna la instancia de Nodo a la estructura NodeWithType nt.Nodo = nodo retorno nulo }

Conclusión

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
}