Cette section introduit des méthodes sur un objet Connection pour télécharger des fichiers de résultats d'algorithmes et exporter des nodes et edges depuis un 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.

downloadAlgoResultFile()

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

Paramètres :

• string: Nom du fichier.
• string: ID de la tâche algorithmique qui a généré le fichier.
• DownloadFileResultListener: Écouteur pour le processus de téléchargement.
• RequestConfig (Optionnel): Paramètres de configuration pour la requête.

Retourne :

• Response: Résultat de la requête.

let requestConfig = <RequestType.RequestConfig>{
  useMaster: true,
  graphSetName: "miniCircle",
};

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

let resp = await 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
);
let myTask = await conn.showTask(
  "louvain",
  RequestType.TASK_STATUS.TASK_DONE,
  requestConfig
);

let myTaskID = myTask.data.map((item) => item.task_info.task_id)[0];
console.log("taskID = ", myTaskID);

let myDownload = await conn.downloadAlgoResultFile(
  "communityID",
  myTaskID,
  function (chunkData) {
    fsPromises
      .writeFile(`E:/NodeJs/Algo/communityID`, chunkData)
      .then(() => {
        console.log("Téléchargement réussite");
      })
      .catch((err) => {
        console.error("Erreur de téléchargement d'écriture", err);
      });
  },
  {
    graphSetName: "miniCircle",
    stream: {
      onData(data) {
        console.log("Succès");
      },
      onEnd() {},
      onError(error) {
        console.error("Erreur de téléchargement d'écriture");
      },
    },
  }
);

taskID =  60085
Succès
Téléchargement réussite

downloadAllAlgoResultFile()

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

Paramètres :

• string: ID de la tâche algorithmique qui a généré le(s) fichier(s).
• DownloadFileResultListener: Écouteur pour le processus de téléchargement.
• RequestConfig (Optionnel): Paramètres de configuration pour la requête.

Retourne :

• Response: Résultat de la requête.

let requestConfig = <RequestType.RequestConfig>{
  useMaster: true,
  graphSetName: "miniCircle",
};

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

let resp = await 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
);
let myTask = await conn.showTask(
  "louvain",
  RequestType.TASK_STATUS.TASK_DONE,
  requestConfig
);

let myTaskID = myTask.data.map((item) => item.task_info.task_id)[0];
console.log("taskID = ", myTaskID);

let myDownload = await conn.downloadAllAlgoResultFile(
  myTaskID,
  function (chunkData) {
    fsPromises
      .writeFile(`E:/NodeJs/Algo/LovainResult`, chunkData)
      .then(() => {
        console.log("Téléchargement réussite");
      })
      .catch((err) => {
        console.error("Erreur de téléchargement d'écriture", err);
      });
  },
  {
    graphSetName: "miniCircle",
    stream: {
      onData(data) {},
      onEnd() {},
      onError(error) {
        console.error("Erreur de téléchargement d'écriture");
      },
    },
  }
);

taskID =  60088
Téléchargement réussite
Téléchargement réussite
Téléchargement réussite

export()

Exporte les nodes et edges du graph actuel.

Paramètres :

• RequestType.ExportRequest: Configurations pour la requête d'exportation, incluant dbType:ULTIPA.DBType, schemaName:string, limit:number et selectPropertiesName:string[].
• ExportListener: Écouteur pour le processus d'exportation.
• RequestConfig (Optionnel): Paramètres de configuration pour la requête.

Retourne :

• Response: Résultat de la requête.

// Exporte 10 nodes du schema 'account' avec les propriétés sélectionnées dans le graphset 'miniCircle' et imprime leur information

let requestConfig = <RequestType.RequestConfig>{
  useMaster: true,
  graphSetName: "miniCircle",
};

let resp = await conn.export(
  {
    dbType: ULTIPA.DBType.DBNODE,
    schemaName: "account",
    limit: 10,
    selectPropertiesName: ["_id", "_uuid", "name", "year"],
  },
  async (n, e) => {
    console.log(n);
  },
  {
    graphSetName: "miniCircle",
    stream: {
      onData(data) {},
      onEnd() {},
      onError(error) {
        console.error("Erreur de téléchargement d'écriture");
      },
    },
  }
);

[
  Node {
    id: 'ULTIPA8000000000000001',
    uuid: '1',
    schema: 'account',
    values: { name: 'Yu78', year: 1978 }
  },
  Node {
    id: 'ULTIPA8000000000000002',
    uuid: '2',
    schema: 'account',
    values: { name: 'jibber-jabber', year: 1989 }
  },
  Node {
    id: 'ULTIPA8000000000000003',
    uuid: '3',
    schema: 'account',
    values: { name: 'mochaeach', year: 1982 }
  },
  Node {
    id: 'ULTIPA8000000000000004',
    uuid: '4',
    schema: 'account',
    values: { name: 'Win-win0', year: 2007 }
  },
  Node {
    id: 'ULTIPA8000000000000005',
    uuid: '5',
    schema: 'account',
    values: { name: 'kevinh', year: 1973 }
  },
  Node {
    id: 'ULTIPA8000000000000006',
    uuid: '6',
    schema: 'account',
    values: { name: 'alexyhel', year: 1974 }
  },
  Node {
    id: 'ULTIPA8000000000000007',
    uuid: '7',
    schema: 'account',
    values: { name: 'hooj', year: 1986 }
  },
  Node {
    id: 'ULTIPA8000000000000008',
    uuid: '8',
    schema: 'account',
    values: { name: 'vv67', year: 1990 }
  },
  Node {
    id: 'ULTIPA8000000000000009',
    uuid: '9',
    schema: 'account',
    values: { name: '95smith', year: 1988 }
  },
  Node {
    id: 'ULTIPA800000000000000A',
    uuid: '10',
    schema: 'account',
    values: { name: 'jo', year: 1992 }
  }
]

Exemple Complet

import { ConnectionPool, ULTIPA } from "@ultipa-graph/ultipa-node-sdk";
import { GraphExra } from "@ultipa-graph/ultipa-node-sdk/dist/connection/extra/graph.extra";
import { getEdgesPrintInfo } from "@ultipa-graph/ultipa-node-sdk/dist/printers/edge";
import { RequestType } from "@ultipa-graph/ultipa-node-sdk/dist/types";
import { ListFormat } from "typescript";

let sdkUsage = async () => {
  // Configurations de connection
  //Exemple d'URI: hosts="mqj4zouys.us-east-1.cloud.ultipa.com:60010"
  let hosts = [
    "192.168.1.85:60061",
    "192.168.1.86:60061",
    "192.168.1.87:60061",
  ];
  let username = "***";
  let password = "***";
  let connPool = new ConnectionPool(hosts, username, password);

  // Établit la connexion à la base de données
  let conn = await connPool.getActive();
  let isSuccess = await conn.test();
  console.log(isSuccess);

  // Configurations de requête
  let requestConfig = <RequestType.RequestConfig>{
    graphSetName: "miniCircle",
    useMaster: true,
  };

  // Exécute l'algorithme Louvain et imprime l'ID de la tâche
  let resp = await 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
  );
  let myTask = await conn.showTask(
    "louvain",
    RequestType.TASK_STATUS.TASK_DONE,
    requestConfig
  );
  let myTaskID = myTask.data.map((item) => item.task_info.task_id)[0];
  console.log("taskID = ", myTaskID);

  // Télécharge tous les fichiers générés par la tâche algorithmique ci-dessus et imprime la réponse de téléchargement
  let myDownload = await conn.downloadAllAlgoResultFile(
    myTaskID,
    function (chunkData) {
      fsPromises
        .writeFile(`C:/NodeJs/tw/LovainResult`, chunkData)
        .then(() => {
          console.log("Téléchargement réussite");
        })
        .catch((err) => {
          console.error("Erreur de téléchargement d'écriture", err);
        });
    },
    {
      graphSetName: "miniCircle",
      stream: {
        onData(data) {},
        onEnd() {},
        onError(error) {
          console.error("Erreur de téléchargement d'écriture");
        },
      },
    }
  );
};

sdkUsage().then(console.log).catch(console.log);