Cette section présente des méthodes sur un objet Connection pour télécharger des fichiers de résultats d'algorithme et exporter des nodes et edges d'un graphset.

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

DownloadAlgoResultFile()

Télécharge un fichier de résultats d'une tâche d'algorithme dans le graph actuel.

Paramètres :

• string: Nom du fichier.
• string: ID de la tâche d'algorithme qui a généré le fichier.
• RequestConfig (Optionnel): Paramètres de configuration pour la requête. Si nil est fourni, la fonction utilisera les paramètres de configuration par défaut.
• func: Fonction qui reçoit le résultat de la requête.

Renvoie :

• error: Un objet d'erreur contenant des détails sur tout problème survenu. nil est renvoyé si l'opération réussit.

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

// Exécute l'algorithme Louvain dans le graphset 'miniCircle' et affiche l'ID de la tâche

_, err1 := conn.Uql("algo(louvain).params({phase1_loop_num: 20, min_modularity_increase: 0.001}).write({file:{filename_community_id: 'communityID', filename_ids: 'ids', filename_num: 'num'}})",
  requestConfig)
if err1 != nil {
  println(err1)
}

time.Sleep(5 * time.Second)

myTask, _ := conn.ShowTask("louvain", structs.TaskStatusDone, requestConfig)
myTaskID := myTask[0].TaskInfo.TaskID
println("TaskID is:", myTaskID)

receive := func(data []byte) error {
  var fileName = "communityID"
  filePath := fileName
  file, err := os.Create(filePath)
  if err != nil {
    return err
  }
  defer file.Close()
  _, err = file.Write(data)
  if err != nil {
    return err
  }
  return nil
}

myDownload := conn.DownloadAlgoResultFile("communityID", utils.JSONString(myTaskID), requestConfig, receive)
if myDownload != nil {
  println(myDownload)
} else {
  println("File is downloaded")
}

TaskID is: 65483
File is downloaded

DownloadAllAlgoResultFile()

Télécharge tous les fichiers de résultats d'une tâche d'algorithme dans le graph actuel.

Paramètres :

• string: ID de la tâche d'algorithme qui a généré le(s) fichier(s).
• RequestConfig (Optionnel): Paramètres de configuration pour la requête. Si nil est fourni, la fonction utilisera les paramètres de configuration par défaut.
• func: Fonction qui reçoit le résultat de la requête.

Renvoie :

• error: Un objet d'erreur contenant des détails sur tout problème survenu. nil est renvoyé si l'opération réussit.

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

// Exécute l'algorithme Louvain dans le graphset 'miniCircle' et affiche l'ID de la tâche

_, err1 := conn.Uql("algo(louvain).params({phase1_loop_num: 20, min_modularity_increase: 0.001}).write({file:{filename_community_id: 'communityID', filename_ids: 'ids', filename_num: 'num'}})",
  requestConfig)
if err1 != nil {
  println(err1)
}

time.Sleep(5 * time.Second)

myTask, _ := conn.ShowTask("louvain", structs.TaskStatusDone, requestConfig)
myTaskID := myTask[0].TaskInfo.TaskID
println("TaskID is:", myTaskID)

receive := func(data []byte, filename string) error {
  file, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY|os.O_APPEND, os.ModePerm)
  if err != nil {
    panic(err)
  }
  defer file.Close()
  _, err = file.Write(data)
  return nil
}

myDownload := conn.DownloadAllAlgoResultFile(utils.JSONString(myTaskID), requestConfig, receive)
if myDownload != nil {
  println(myDownload)
} else {
  println("Files are downloaded")
}

TaskID is: 65838
Files are downloaded

Export()

Exporte des nodes et edges depuis le graph actuel.

Paramètres :

• ExportRequest: Configurations pour la requête d'export, y compris dbType:ULTIPA.DBType, schemaName:string, limit:number et selectPropertiesName:string[].
• Listener: Listener pour le process d'export.
• RequestConfig (Optionnel): Paramètres de configuration pour la requête. Si nil est fourni, la fonction utilisera les paramètres de configuration par défaut.

Renvoie :

• error: Un objet d'erreur contenant des détails sur tout problème survenu. nil est renvoyé si l'opération réussit.

// Exporte 10 nodes de schema 'account' avec des propriétés sélectionnées dans le graphset 'miniCircle' et affiche le résultat
type MyListener struct {
  Properties []string
}

func (l *MyListener) ProcessNodes(nodes []*structs.Node) error {
  file, err := os.Create("node.csv")
  if err != nil {
    panic(err)
  }
  defer file.Close()
  writer := csv.NewWriter(file)
  defer writer.Flush()
  if nodes != nil {
    for _, node := range nodes {
      var sliceString []string
      for _, key := range l.Properties {
        vv := ConvertDataToString(node.Values.Data[key])
        sliceString = append(sliceString, vv)
      }
      err := writer.Write(sliceString)
      if err != nil {
        panic(err)
      }
    }
  }
  return nil
}

func (l *MyListener) ProcessEdges(edges []*structs.Edge) error {
  file, err := os.Create("edge.csv")
  if err != nil {
    panic(err)
  }
  defer file.Close()
  writer := csv.NewWriter(file)
  defer writer.Flush()
  if edges != nil {
    for _, node := range edges {
      var sliceString []string
      for _, key := range l.Properties {
        vv := ConvertDataToString(node.Values.Data[key])
        sliceString = append(sliceString, vv)
      }
      err := writer.Write(sliceString)
      if err != nil {
        panic(err)
      }
    }
  }
  return nil
}

func ConvertDataToString(value interface{}) string {
  switch value.(type) {
  case int32:
    v := value.(int32)
    str := strconv.FormatInt(int64(v), 10)
    return str
  case string:
    v := value.(string)
    return v
  case int64:
    v := value.(string)
    return v
  case []interface{}:
    var slic []string
    for _, val := range value.([]interface{}) {
      if vv, ok := val.(string); ok {
        slic = append(slic, vv)
      }
      if vv, ok := val.(int32); ok {
        vvv := strconv.FormatInt(int64(vv), 10)
        slic = append(slic, vvv)
      }
    }
    result := strings.Join(slic, ",")
    return result
  }
  return ""
}

func main() {

  config, _ := configuration.NewUltipaConfig(&configuration.UltipaConfig{
    Hosts:    []string{"192.168.1.85:60611", "192.168.1.87:60611", "192.168.1.88:60611"},
    Username: "root",
    Password: "root",
  })

  conn, _ := sdk.NewUltipa(config)

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

  var request = ultipa.ExportRequest{
    Schema:           "account",
    SelectProperties: []string{"_id", "_uuid", "year", "name"},
    DbType:           ultipa.DBType_DBNODE,
    Limit:            10,
  }

  myExport := conn.Export(&request, &MyListener{request.SelectProperties}, requestConfig)
  if myExport != nil {
    println(myExport)
  } else {
    println("File is exported")
  }

File is exported

Exemple Complet

package main

import (
  "os"
  "time"

  "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
  //Exemple URI: Hosts:=[]string{"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: "miniCircle",
  }

  // Exécute l'algorithme Louvain et affiche l'ID de la tâche
  _, err1 := conn.Uql("algo(louvain).params({phase1_loop_num: 20, min_modularity_increase: 0.001}).write({file:{filename_community_id: 'communityID', filename_ids: 'ids', filename_num: 'num'}})",
    requestConfig)
  if err1 != nil {
    println(err1)
  }

  time.Sleep(5 * time.Second)

  myTask, _ := conn.ShowTask("louvain", structs.TaskStatusDone, requestConfig)
  myTaskID := myTask[0].TaskInfo.TaskID
  println("TaskID is:", myTaskID)

  // Télécharge tous les fichiers générés par la tâche d'algorithme ci-dessus et affiche la réponse de téléchargement
  receive := func(data []byte, filename string) error {
    file, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY|os.O_APPEND, os.ModePerm)
    if err != nil {
      panic(err)
    }
    defer file.Close()
    _, err = file.Write(data)
    return nil
  }

  myDownload := conn.DownloadAllAlgoResultFile(utils.JSONString(myTaskID), requestConfig, receive)
  if myDownload != nil {
    println(myDownload)
  } else {
    println("Files are downloaded")
  }

}