Cette section présente des méthodes sur un objet Connection pour insérer des nodes et des edges dans le graph ou supprimer des nodes et des edges du graphset.

Chaque exemple se concentre uniquement sur l'utilisation de la méthode. Pour un exemple de code complet, veuillez vous référer à l' exemple complet.

Modèle de Données du Graph Exemple

Les exemples ci-dessous démontrent comment insérer ou supprimer des nodes ou des edges d'un graphset avec le schema et les définitions de propriétés suivantes :

Mapping des Types de Propriétés

Lors de l'insertion de nodes ou d'edges, vous pouvez avoir besoin de spécifier des valeurs de propriétés de différents types. Le mapping entre les types de propriétés Ultipa et les types de données Go/Driver est le suivant :

Insertion

InsertNodes()

Insère de nouveaux nodes d'un schema dans le graph actuel.

Paramètres :

• string: Nom du schema.
• []Node: La liste des objets Node à insérer.
• InsertRequestConfig (Optionnel): Paramètres de configuration pour la requête. Si nil est fourni, la fonction utilisera les paramètres de configuration par défaut.

Retourne :

• Response: Résultat de la requête. L'objet Response contient un alias nodes qui détient tous les nodes insérés lorsque InsertRequestConfig.Slient est réglé sur true.
• error: Un objet d'erreur contenant des détails sur les problèmes survenus. nil est retourné si l'opération est réussie.

// Insère deux nodes dans le schema 'user' dans le graphset 'lcc', affiche le code d'erreur et les informations des nodes insérés

requestConfig := &configuration.RequestConfig{
  UseMaster: true,
  GraphName: "lcc",
}

// Il n'y a pas d'alias dans Response si InsertRequestConfig.Slient est faux
insertRequestConfig := &configuration.InsertRequestConfig{
  RequestConfig: requestConfig,
  InsertType:    ultipa.InsertType_NORMAL,
  Silent:        true,
}

var nodes []*structs.Node
node1 := structs.NewNode()
node1.UUID = 1
node1.ID = "U001"
node1.Set("name", "Alice")
node1.Set("age", 18)
node1.Set("score", 65.32)
node1.Set("birthday", "1993-5-4")
node1.Set("location", "point(23.63 104.25)")
node1.Set("profile", "abc")
node1.Set("interests", []string{"tennis", "violin"})
node1.Set("permissionCodes", []int32{2004, 3025, 1025})
node2 := structs.NewNode()
node2.UUID = 2
node2.ID = "U002"
node2.Set("name", "Bob")
nodes = append(nodes, node1, node2)
myInsert, _ := conn.InsertNodes("user", nodes, insertRequestConfig)

println("Operation succeeds:", myInsert.Status.IsSuccess())
nodeList, schemaList, _ := myInsert.Alias("nodes").AsNodes()
printers.PrintNodes(nodeList, schemaList)

Operation succeeds: true
+------+------+--------+-------+-------+---------------+--------------------------+-----------------------------+------------+-----------------+------------------+
|  ID  | UUID | Schema | name  |  age  |     score     |         birthday         |          location           |  profile   |    interests    | permissionCodes  |
+------+------+--------+-------+-------+---------------+--------------------------+-----------------------------+------------+-----------------+------------------+
| U001 |  1   |  user  | Alice |  18   | 65.3200000000 | 1993-05-04T00:00:00.000Z | POINT(23.630000 104.250000) | [97 98 99] | [tennis violin] | [2004 3025 1025] |
| U002 |  2   |  user  |  Bob  | <nil> |     <nil>     |          <nil>           |            <nil>            |   <nil>    |      <nil>      |      <nil>       |
+------+------+--------+-------+-------+---------------+--------------------------+-----------------------------+------------+-----------------+------------------+

InsertEdges()

Insère de nouveaux edges d'un schema dans le graph actuel.

Paramètres :

• string: Nom du schema.
• []Edge: La liste des objets Edge à insérer.
• InsertRequestConfig (Optionnel): Paramètres de configuration pour la requête. Si nil est fourni, la fonction utilisera les paramètres de configuration par défaut.

Retourne :

• Response: Résultat de la requête. L'objet Response contient un alias edges qui détient tous les edges insérés lorsque InsertRequestConfig.Slient est réglé sur true.
• error: Un objet d'erreur contenant des détails sur les problèmes survenus. nil est retourné si l'opération est réussie.

// Insère deux edges dans le schema 'follows' dans le graphset 'lcc', affiche le code d'erreur et les informations des edges insérés
requestConfig := &configuration.RequestConfig{
  UseMaster: true,
  GraphName: "lcc",
}

// Il n'y a pas d'alias dans Response si InsertRequestConfig.Slient est faux
insertRequestConfig := &configuration.InsertRequestConfig{
  RequestConfig: requestConfig,
  InsertType:    ultipa.InsertType_NORMAL,
  Silent:        true,
}

var edges []*structs.Edge
edge1 := structs.NewEdge()
edge1.UUID = 1
edge1.From = "U001"
edge1.To = "U002"
edge1.Set("createdOn", "2024-5-6")
edge2 := structs.NewEdge()
edge2.UUID = 2
edge2.From = "U002"
edge2.To = "U001"
edge2.Set("createdOn", "2024-5-8")
edges = append(edges, edge1, edge2)

myInsert, err := conn.InsertEdges("follows", edges, insertRequestConfig)
if err != nil {
  println(err)
}
println("Operation succeeds:", myInsert.Status.IsSuccess())
edgeList, schemaList, _ := myInsert.Alias("edges").AsEdges()
printers.PrintEdges(edgeList, schemaList)

Operation succeeds: true
+------+-----------+------+---------+------+---------+-------------------------------+
| UUID | FROM_UUID | FROM | TO_UUID |  TO  | SCHEMA  |           createdOn           |
+------+-----------+------+---------+------+---------+-------------------------------+
|  1   |     1     | U001 |    2    | U002 | follows | 2024-05-06T00:00:00.000+08:00 |
|  2   |     2     | U002 |    1    | U001 | follows | 2024-05-08T00:00:00.000+08:00 |
+------+-----------+------+---------+------+---------+-------------------------------+

InsertNodesBatchBySchema()

Insère de nouveaux nodes d'un schema dans le graph actuel via gRPC. Les propriétés dans les valeurs de node doivent être cohérentes avec celles déclarées dans la structure du schema.

Paramètres :

• Schema: Le schema cible.
• []Node: La liste des objets Node à insérer.
• InsertRequestConfig (Optionnel): Paramètres de configuration pour la requête. Si nil est fourni, la fonction utilisera les paramètres de configuration par défaut.

Retourne :

• InsertResponse: Résultat de la requête.
• error: Un objet d'erreur contenant des détails sur les problèmes survenus. nil est retourné si l'opération est réussie.

// Insère deux nodes dans le schema 'user' dans le graphset 'lcc' et affiche le code d'erreur 
requestConfig := &configuration.RequestConfig{
  UseMaster: true,
  GraphName: "lcc",
}

insertRequestConfig := &configuration.InsertRequestConfig{
  RequestConfig: requestConfig,
  InsertType:    ultipa.InsertType_OVERWRITE,
}

schema := structs.NewSchema("user")
schema.Properties = append(schema.Properties, &structs.Property{
  Name: "name",
  Type: ultipa.PropertyType_STRING,
}, &structs.Property{
  Name: "age",
  Type: ultipa.PropertyType_INT32,
}, &structs.Property{
  Name: "score",
  Type: ultipa.PropertyType_DECIMAL,
}, &structs.Property{
  Name: "birthday",
  Type: ultipa.PropertyType_DATETIME,
}, &structs.Property{
  Name: "location",
  Type: ultipa.PropertyType_POINT,
}, &structs.Property{
  Name: "profile",
  Type: ultipa.PropertyType_BLOB,
}, &structs.Property{
  Name:     "interests",
  Type:     ultipa.PropertyType_LIST,
  SubTypes: []ultipa.PropertyType{ultipa.PropertyType_STRING},
}, &structs.Property{
  Name:     "permissionCodes",
  Type:     ultipa.PropertyType_SET,
  SubTypes: []ultipa.PropertyType{ultipa.PropertyType_INT32},
})

var nodes []*structs.Node
node1 := structs.NewNode()
node1.UUID = 1
node1.ID = "U001"
node1.Set("name", "Alice")
node1.Set("age", 18)
node1.Set("score", 65.32)
node1.Set("birthday", "1993-5-4")
node1.Set("location", "point(23.63 104.25)")
node1.Set("profile", "abc")
node1.Set("interests", []string{"tennis", "violin"})
node1.Set("permissionCodes", []int32{2004, 3025, 1025})

node2 := structs.NewNode()
node2.UUID = 2
node2.ID = "U002"
node2.Set("name", "Bob")
node2.Set("age", nil)
node2.Set("score", nil)
node2.Set("birthday", nil)
node2.Set("location", nil)
node2.Set("profile", nil)
node2.Set("interests", nil)
node2.Set("permissionCodes", nil)
nodes = append(nodes, node1, node2)

myInsert, err := conn.InsertNodesBatchBySchema(schema, nodes, insertRequestConfig)
if err != nil {
  println(err)
}
println("Operation succeeds:", myInsert.Status.IsSuccess())

Operation succeeds: true

InsertEdgesBatchBySchema()

Insère de nouveaux edges d'un schema dans le graph actuel via gRPC. Les propriétés dans les valeurs de edge doivent être cohérentes avec celles déclarées dans la structure du schema.

Paramètres :

• Schema: Le schema cible.
• []Edge: La liste des objets Edge à insérer.
• InsertRequestConfig (Optionnel): Paramètres de configuration pour la requête. Si nil est fourni, la fonction utilisera les paramètres de configuration par défaut.

Retourne :

• InsertResponse: Résultat de la requête.
• error: Un objet d'erreur contenant des détails sur les problèmes survenus. nil est retourné si l'opération est réussie.

// Insère deux edges dans le schema 'follows' dans le graphset 'lcc' et affiche le code d'erreur

requestConfig := &configuration.RequestConfig{
  UseMaster: true,
  GraphName: "lcc",
}

insertRequestConfig := &configuration.InsertRequestConfig{
  RequestConfig: requestConfig,
  InsertType:    ultipa.InsertType_OVERWRITE,
}

schema := structs.NewSchema("follows")
schema.Properties = append(schema.Properties, &structs.Property{
  Name: "createdOn",
  Type: ultipa.PropertyType_TIMESTAMP,
})

var edges []*structs.Edge
edge1 := structs.NewEdge()
edge1.UUID = 1
edge1.From = "U001"
edge1.To = "U002"
edge1.Set("createdOn", "2024-5-6")
edge2 := structs.NewEdge()
edge2.UUID = 2
edge2.From = "U002"
edge2.To = "U001"
edge2.Set("createdOn", "2024-5-8")
edges = append(edges, edge1, edge2)

myInsert, err := conn.InsertEdgesBatchBySchema(schema, edges, insertRequestConfig)
if err != nil {
  println(err)
}
println("Operation succeeds:", myInsert.Status.IsSuccess())

Operation succeeds: true

InsertNodesBatchAuto()

Insère de nouveaux nodes d'un ou plusieurs schemas dans le graph actuel via gRPC. Les propriétés dans les valeurs de node doivent être cohérentes avec celles définies dans la structure du schema correspondant.

Paramètres :

• []Node: La liste des objets Node à insérer.
• InsertRequestConfig (Optionnel): Paramètres de configuration pour la requête. Si nil est fourni, la fonction utilisera les paramètres de configuration par défaut.

Retourne :

• InsertBatchAutoResponse: Résultat de la requête.
• error: Un objet d'erreur contenant des détails sur les problèmes survenus. nil est retourné si l'opération est réussie.

// Insère deux nodes dans le schema 'user' et un node dans le schema `product` dans le graphset 'lcc' et affiche le code d'erreur

requestConfig := &configuration.RequestConfig{
  UseMaster: true,
  GraphName: "lcc",
}

insertRequestConfig := &configuration.InsertRequestConfig{
  RequestConfig: requestConfig,
  InsertType:    ultipa.InsertType_NORMAL,
}

var N1 []*structs.Node
node1 := structs.NewNode()
node1.Schema = "user"
node1.UUID = 1
node1.ID = "U001"
node1.Set("name", "Alice")
node1.Set("age", 18)
node1.Set("score", 65.32)
node1.Set("birthday", "1993-5-4")
node1.Set("location", "point(23.63 104.25)")
node1.Set("profile", "abc")
node1.Set("interests", []string{"tennis", "violin"})
node1.Set("permissionCodes", []int32{2004, 3025, 1025})
N1 = append(N1, node1)
insert1, err := conn.InsertNodesBatchAuto(N1, insertRequestConfig)
if err != nil {
  println(err)
}
for _, item := range insert1.Resps {
  println("Operation succeeds:", item.Status.IsSuccess())
}

var N2 []*structs.Node
node2 := structs.NewNode()
node2.Schema = "user"
node2.UUID = 2
node2.ID = "U002"
node2.Set("name", "Bob")
node2.Set("age", nil)
node2.Set("score", nil)
node2.Set("birthday", nil)
node2.Set("location", nil)
node2.Set("profile", nil)
node2.Set("interests", nil)
node2.Set("permissionCodes", nil)
N2 = append(N2, node2)
insert2, err := conn.InsertNodesBatchAuto(N2, insertRequestConfig)
if err != nil {
  println(err)
}
println(insert1.ErrorCode)
for _, item := range insert2.Resps {
  println("Operation succeeds:", item.Status.IsSuccess())
}

var N3 []*structs.Node
node3 := structs.NewNode()
node3.Schema = "product"
node3.UUID = 3
node3.ID = "P001"
node3.Set("name", "Wireless Earbud")
node3.Set("price", float32(93.2))
N3 = append(N3, node3)
insert3, err := conn.InsertNodesBatchAuto(N3, insertRequestConfig)
if err != nil {
  println(err)
}
for _, item := range insert3.Resps {
  println("Operation succeeds:", item.Status.IsSuccess())
}

Operation succeeds: true
Operation succeeds: true
Operation succeeds: true

InsertEdgesBatchAuto()

Insère de nouveaux edges d'un ou plusieurs schemas dans le graph actuel via gRPC. Les propriétés dans les valeurs de edge doivent être cohérentes avec celles définies dans la structure du schema correspondant.

Paramètres :

• []Edge: La liste des objets Edge à insérer.
• InsertRequestConfig (Optionnel): Paramètres de configuration pour la requête. Si nil est fourni, la fonction utilisera les paramètres de configuration par défaut.

Retourne :

• InsertBatchAutoResponse: Résultat de la requête.
• error: Un objet d'erreur contenant des détails sur les problèmes survenus. nil est retourné si l'opération est réussie.

// Insère deux edges dans le schema 'follows' et un edge dans le schema 'purchased' dans le graphset 'lcc' et affiche le code d'erreur

requestConfig := &configuration.RequestConfig{
  UseMaster: true,
  GraphName: "lcc",
}

insertRequestConfig := &configuration.InsertRequestConfig{
  RequestConfig: requestConfig,
  InsertType:    ultipa.InsertType_NORMAL,
}

var E1 []*structs.Edge
edge1 := structs.NewEdge()
edge1.Schema = "follows"
edge1.UUID = 1
edge1.From = "U001"
edge1.To = "U002"
edge1.Set("createdOn", "2024-5-6")
E1 = append(E1, edge1)

insert1, err := conn.InsertEdgesBatchAuto(E1, insertRequestConfig)
if err != nil {
  println(err)
}
for _, item := range insert1.Resps {
  println("Operation succeeds:", item.Status.IsSuccess())
}

var E2 []*structs.Edge
edge2 := structs.NewEdge()
edge2.Schema = "follows"
edge2.UUID = 2
edge2.From = "U002"
edge2.To = "U001"
edge2.Set("createdOn", "2024-5-8")
E2 = append(E2, edge2)

insert2, err := conn.InsertEdgesBatchAuto(E2, insertRequestConfig)
if err != nil {
  println(err)
}
println(insert1.ErrorCode)
for _, item := range insert2.Resps {
  println("Operation succeeds:", item.Status.IsSuccess())
}

var E3 []*structs.Edge
edge3 := structs.NewEdge()
edge3.Schema = "purchased"
edge3.UUID = 3
edge3.From = "U002"
edge3.To = "P001"
edge3.Set("qty", 1)
E3 = append(E3, edge3)
insert3, err := conn.InsertEdgesBatchAuto(E3, insertRequestConfig)
if err != nil {
  println(err)
}
for _, item := range insert3.Resps {
  println("Operation succeeds:", item.Status.IsSuccess())
}

Operation succeeds: true
Operation succeeds: true
Operation succeeds: true

Suppression

DeleteNodes()

Supprime les nodes qui satisfont aux conditions données du graph actuel. Il est important de noter que la suppression d'un node entraîne la suppression de tous les edges qui y sont connectés.

Paramètres :

• string: La condition de filtrage pour spécifier les nodes à supprimer.
• InsertRequestConfig (Optionnel): Paramètres de configuration pour la requête. Si nil est fourni, la fonction utilisera les paramètres de configuration par défaut.

Retourne :

• Response: Résultat de la requête. L'objet Response contient un alias nodes qui détient tous les nodes supprimés lorsque InsertRequestConfig.Slient est réglé sur true.
• error: Un objet d'erreur contenant des détails sur les problèmes survenus. nil est retourné si l'opération est réussie.

// Supprime un node @user dont le nom est 'Alice' du graphset 'lcc' et affiche le code d'erreur
// Tous les edges attachés au node supprimé sont également supprimés

requestConfig := &configuration.RequestConfig{
  UseMaster: true,
  GraphName: "lcc",
}

insertRequestConfig := &configuration.InsertRequestConfig{
  RequestConfig: requestConfig,
  InsertType:    ultipa.InsertType_NORMAL,
}

myDeletion, _ := conn.DeleteNodes("{@user.name == 'Alice'}", insertRequestConfig)
println("Operation succeeds:", myDeletion.Status.IsSuccess())

Operation succeeds: true

DeleteEdges()

Supprime les edges qui satisfont aux conditions données du graph actuel.

Paramètres :

• string: La condition de filtrage pour spécifier les edges à supprimer.
• InsertRequestConfig (Optionnel): Paramètres de configuration pour la requête. Si nil est fourni, la fonction utilisera les paramètres de configuration par défaut.

Retourne :

• Response: Résultat de la requête. L'objet Response contient un alias edges qui détient tous les edges supprimés lorsque InsertRequestConfig.Slient est réglé sur true.
• error: Un objet d'erreur contenant des détails sur les problèmes survenus. nil est retourné si l'opération est réussie.

// Supprime tous les edges @purchased du graphset 'lcc' et affiche le code d'erreur

requestConfig := &configuration.RequestConfig{
  UseMaster: true,
  GraphName: "lcc",
}

insertRequestConfig := &configuration.InsertRequestConfig{
  RequestConfig: requestConfig,
  InsertType:    ultipa.InsertType_NORMAL,
}

deleteEdge, _ := conn.DeleteEdges("{@purchased}", insertRequestConfig)
println("Operation succeeds:", deleteEdge.Status.IsSuccess()

Operation succeeds: true

Exemple Complet

package main

import (
  ultipa "github.com/ultipa/ultipa-go-sdk/rpc"
  "github.com/ultipa/ultipa-go-sdk/sdk"
  "github.com/ultipa/ultipa-go-sdk/sdk/configuration"
  "github.com/ultipa/ultipa-go-sdk/sdk/structs"
  "github.com/ultipa/ultipa-go-sdk/utils"
)

func main() {

  // Configurations de connexion
  //URI exemple: hosts="mqj4zouys.us-east-1.cloud.ultipa.com:60010"
  config, _ := configuration.NewUltipaConfig(&configuration.UltipaConfig{
    Hosts:    []string{"192.168.1.85:60061", "192.168.1.86:60061", "192.168.1.87:60061"},
    Username: "***",
    Password: "***",
  })

  // Établit la connexion à la base de données
  conn, _ := sdk.NewUltipa(config)

  // Configurations de requête
  requestConfig := &configuration.RequestConfig{
    UseMaster: true,
    GraphName: "lcc",
  }

  // Configurations de Requête d'Insertion
  insertRequestConfig := &configuration.InsertRequestConfig{
    RequestConfig: requestConfig,
    InsertType:    ultipa.InsertType_NORMAL,
  }

  // Insère deux nodes dans le schema 'user' et un node dans le schema `product` dans le graphset 'lcc' et affiche le code d'erreur

  var N1 []*structs.Node
  node1 := structs.NewNode()
  node1.Schema = "user"
  node1.UUID = 1
  node1.ID = "U001"
  node1.Set("name", "Alice")
  node1.Set("age", 18)
  node1.Set("score", 65.32)
  node1.Set("birthday", "1993-5-4")
  node1.Set("location", "point(23.63 104.25)")
  node1.Set("profile", "abc")
  node1.Set("interests", []string{"tennis", "violin"})
  node1.Set("permissionCodes", []int32{2004, 3025, 1025})
  N1 = append(N1, node1)
  insert1, err := conn.InsertNodesBatchAuto(N1, insertRequestConfig)
  if err != nil {
    println(err)
  }
  for _, item := range insert1.Resps {
    println("Operation succeeds:", item.Status.IsSuccess())
  }

  var N2 []*structs.Node
  node2 := structs.NewNode()
  node2.Schema = "user"
  node2.UUID = 2
  node2.ID = "U002"
  node2.Set("name", "Bob")
  node2.Set("age", nil)
  node2.Set("score", nil)
  node2.Set("birthday", nil)
  node2.Set("location", nil)
  node2.Set("profile", nil)
  node2.Set("interests", nil)
  node2.Set("permissionCodes", nil)
  N2 = append(N2, node2)
  insert2, err := conn.InsertNodesBatchAuto(N2, insertRequestConfig)
  if err != nil {
    println(err)
  }
  println(insert1.ErrorCode)
  for _, item := range insert2.Resps {
    println("Operation succeeds:", item.Status.IsSuccess())
  }
  var N3 []*structs.Node
  node3 := structs.NewNode()
  node3.Schema = "product"
  node3.UUID = 3
  node3.ID = "P001"
  node3.Set("name", "Wireless Earbud")
  node3.Set("price", float32(93.2))
  N3 = append(N3, node3)
  insert3, err := conn.InsertNodesBatchAuto(N3, insertRequestConfig)
  if err != nil {
    println(err)
  }
  for _, item := range insert3.Resps {
    println("Operation succeeds:", item.Status.IsSuccess())
  }
};