Change Password

Please enter the password.
Please enter the password. Between 8-64 characters. Not identical to your email address. Contain at least 3 of: uppercase, lowercase, numbers, and special characters.
Please enter the password.
Submit

Change Nickname

Current Nickname:
Submit

Apply New License

License Detail

Please complete this required field.

  • Ultipa Graph V4

Standalone

Please complete this required field.

Please complete this required field.

The MAC address of the server you want to deploy.

Please complete this required field.

Please complete this required field.

Cancel
Apply
ID
Product
Status
Cores
Applied Validity Period(days)
Effective Date
Excpired Date
Mac Address
Apply Comment
Review Comment
Close
Profile
  • Full Name:
  • Phone:
  • Company:
  • Company Email:
  • Country:
  • Language:
Change Password
Apply

You have no license application record.

Apply
Certificate Issued at Valid until Serial No. File
Serial No. Valid until File

Not having one? Apply now! >>>

Product Created On ID Amount (USD) Invoice
Product Created On ID Amount (USD) Invoice

No Invoice

v4.5
Search
    Français
    v4.5

      Opérateurs

      Tous les Opérateurs

      Catégorie
      Opérateurs
      Opérateurs de Propriété Référence de Propriété: .
      Prédicat d'Existence de Propriété: PROPERTY_EXISTS()
      Opérateurs Logiques AND, OR, XOR, NOT
      Opérateurs Arithmétiques +, -, *, /, %, ^
      Opérateurs de Comparaison =, <>, >, <, >=, <=
      Opérateurs de Chaîne Concaténation de Chaîne: ||
      Prédicats Normalisés: IS NORMALIZED, IS NOT NORMALIZED
      Opérateurs de Liste Construction de Liste: []
      Accès aux Éléments: []
      Vérification de l'Appartenance: IN
      Concaténation de Liste: ||
      Opérateurs de Chemin Construction de Chemin: PATH[]
      Concaténation de Chemin: ||
      Opérateurs de Record Construction de Record: RECORD{}
      Référence de Champ: .
      Prédicats de Null IS NULL, IS NOT NULL
      Prédicats de Type de Valeur IS TYPED, IS NOT TYPED
      Prédicats Étiquetés IS LABELED, IS NOT LABELED, :
      Prédicats Source/Destination IS SOURCE OF, IS NOT SOURCE OF, IS DESTINATION OF, IS NOT DESTINATION OF
      Prédicats Dirigés IS DIRECTED, IS NOT DIRECTED
      Prédicat Tout Différent ALL DIFFERENT()
      Prédicat Même SAME()
      Prédicat d'Existence de Propriété PROPERTY_EXISTS()
      Prédicats de Valeur Booléenne IS TRUE, IS FALSE

      Opérateurs de Propriété

      Référence de Propriété

      Le . (point) vous permet de référencer une propriété d'un élément de graph.

      MATCH (n)
      RETURN n._id LIMIT 10
      

      Prédicat d'Existence de Propriété

      Le prédicat PROPERTY_EXISTS(<elemVar>, <propertyName>) détermine si un élément de graph référencé a une propriété.

      Détails

      • Chaque <elemVar> doit avoir un degré de référence singleton.

      MATCH (n:User) LIMIT 1
      RETURN PROPERTY_EXISTS(n, "uuid")
      

      Opérateurs Logiques

      AND

      Combine deux ou plusieurs conditions de sorte que toutes doivent être vraies pour que l'expression entière soit évaluée comme vraie.

      Table de vérité pour l'opérateur AND:

      AND Vrai Faux
      Vrai Vrai Faux
      Faux Faux Faux

      Cette requête renvoie les utilisateurs dont age dépasse 30 et incomeGroup est égal à 4:

      MATCH (n:User)
      WHERE n.age > 30 AND n.incomeGroup = 4
      RETURN n
      

      OR

      Combine deux ou plusieurs conditions dont l'une d'elles doit être vraie pour que l'expression entière soit évaluée comme vraie.

      Table de vérité pour l'opérateur OR:

      OR Vrai Faux
      Vrai Vrai Vrai
      Faux Vrai Faux

      Cette requête renvoie les utilisateurs dont age dépasse 30, ou incomeGroup est égal à 4:

      MATCH (n:Person)
      WHERE n.age > 30 OR n.incomeGroup = 4
      RETURN n
      

      XOR

      Combine deux ou plusieurs conditions. L'expression entière est évaluée comme vraie uniquement lorsque exactement une des conditions est vraie. Si les deux conditions sont vraies ou les deux sont fausses, elle retourne faux.

      Table de vérité pour l'opérateur XOR:

      XOR Vrai Faux
      Vrai Faux Vrai
      Faux Vrai Faux

      Cette requête renvoie les utilisateurs dont age dépasse 30 ou incomeGroup est égal à 4, mais exclut les utilisateurs qui répondent aux deux critères:

      MATCH (n:Person)
      WHERE n.age > 30 XOR n.incomeGroup = 4
      RETURN n
      

      NOT

      Négocie une condition, renvoyant vrai si la condition spécifiée est fausse et inversement.

      Table de vérité pour l'opérateur NOT:

      NOT
      Vrai Faux
      Faux Vrai

      Cette requête renvoie les utilisateurs dont age n'est pas 30:

      MATCH (n:Person)
      WHERE NOT n.age = 30
      RETURN n
      

      Opérateurs Arithmétiques

      Effectue des opérations mathématiques sur des valeurs numériques. GQL supporte les opérateurs arithmétiques suivants:

      • Addition: +
      • Soustraction: -
      • Multiplication: *
      • Division: /
      • Modulus: %
      • Exponentiation: ^

      RETURN (2+8)%3
      

      Résultat:

      (2+8)%3
      1

      Opérateurs de Comparaison

      Compare deux valeurs ou expressions et retourne vrai ou faux. GQL supporte les opérateurs de comparaison suivants:

      • Égal à: =
      • Différent de: <>
      • Supérieur à: >
      • Inférieur à: <
      • Supérieur ou égal à: >=
      • Inférieur ou égal à: <=

      Cette requête renvoie les utilisateurs dont age n'est pas 30:

      MATCH (n:Person)
      WHERE n.age <> 30
      RETURN n
      

      Opérateurs de Chaîne

      Concaténation de Chaîne

      L'opérateur de concaténation || combine plusieurs chaînes en une seule chaîne en fusionnant les caractères de chaque chaîne dans l'ordre.

      RETURN "data" || "base"
      

      Résultat:

      "data" || "base"
      database

      Prédicats Normalisés

      Détermine si une valeur de chaîne de caractères est normalisée. GQL supporte les prédicats normalisés suivants:

      • IS [ <normal form> ] NORMALIZED
      • IS NOT [ <normal form> ] NORMALIZED

      Détails

      RETURN "Å" IS NORMALIZED AS normRes
      

      Résultat:

      normRes
      1

      RETURN "Å" IS NFD NORMALIZED AS normRes
      

      Résultat:

      normRes
      0

      Opérateurs de Liste

      Construction de Liste

      Les [] peuvent créer une liste en plaçant des éléments séparés par des virgules à l'intérieur.

      LET items = [1,2,3]
      RETURN items
      

      Résultat:

      items
      [1,2,3]

      Les [] peuvent également construire une liste imbriquée:

      LET items = [[1,2],[2,3]]
      RETURN items
      

      Résultat:

      items
      [[1,2],[2,3]]

      Accès aux Éléments

      Les [] peuvent accéder aux éléments au sein d'une liste par leurs index. Les listes utilisent des index basés sur zéro, ce qui signifie que le premier élément est à l'index 0.

      LET items = ["a", 1, "b"]
      RETURN items[0]
      

      Résultat:

      items[0]
      a

      Vérification de l'Appartenance

      L'opérateur d'appartenance IN vérifie si un élément spécifié existe au sein d'une liste. Il s'évalue à 1 pour vrai et 0 pour faux.

      RETURN 2 IN [1,2,3] AS inList
      

      Résultat:

      inList
      1

      L'opérateur IN peut filtrer efficacement les éléments de graph en fonction de l'appartenance à une liste spécifiée. Par exemple, cette requête récupère les nœuds dont _id est "U01" ou "U02":

      MATCH (n) WHERE n._id IN ["U01", "U02"]
      RETURN n
      

      Concaténation de Liste

      L'opérateur de concaténation || combine plusieurs listes en une seule liste en fusionnant les éléments de chaque liste dans l'ordre.

      RETURN [1,2,3] || [3,4,5] AS newList
      

      Résultat:

      newList
      [1,2,3,3,4,5]

      Opérateurs de Chemin

      Construction de Chemin

      Le PATH[] crée un chemin en énumérant les références de node et d'edge dans l'ordre.

      <path value constructor> ::= "PATH[" <path element list> "]"
      
      <path element list> ::= <node reference> [ <path element list step>... ]
      
      <path element list step> ::= "," <edge reference> "," <node reference>
      

      Détails

      • Si <path element list> contient la valeur null ou n'identifie pas un chemin, une exception est levée: Malformed path.

      MATCH (n1 {_id: "U01"}), (n2 {_id: "U02"}), -[e {_uuid:39}]->
      RETURN PATH[n2, e, n1]
      

      Concaténation de Chemin

      L'opérateur de concaténation || joint plusieurs chemins en un chemin unique continu, fusionnant le dernier node du premier chemin avec le premier node du second chemin lorsqu'ils sont identiques. Si cette condition n'est pas remplie, une exception est levée: Malformed path.

      MATCH p1 = ({_id: "U01"})->(n), p2 = (n)->()
      RETURN p1 || p2
      

      Opérateurs de Record

      Construction de Record

      Le RECORD{} crée un record en spécifiant des champs.

      <record constructor> ::=  [ "RECORD" ] "{" [ <field> [ { "," <field> }... ] ] "}"
      
      <field> ::= <field name> ":" <value expression>
      

      LET rec = RECORD{length: 20, width: 59, height: 10}
      RETURN rec.length
      

      Résultat:

      rec.length
      20

      Référence de Champ

      Le . (point) vous permet de référencer un champ d'un record.

      LET rec = RECORD{length: 20, width: 59, height: 10}
      RETURN rec.length * rec.width * rec.height AS capacity
      

      Résultat:

      capacity
      11800

      Prédicats de Null

      Spécifie un test pour une valeur null. GQL supporte les prédicats de null suivants:

      • IS NULL
      • IS NOT NULL

      Cette requête récupère le title de chaque node :Paper si la valeur n'est pas null; sinon, elle renvoie le message TITLE NOT FOUND.

      MATCH (n:Paper)
      RETURN CASE 
        WHEN n.title IS NOT NULL THEN n.title
        ELSE "TITLE NOT FOUND"
      END
      

      Prédicats de Type de Valeur

      Détermine si une valeur est conforme à un type spécifique. GQL supporte les prédicats de type de valeur suivants:

      • IS TYPED <value type>
      • IS NOT TYPED <value type>

      Détails

      • Actuellement, la <value type> supporte les mots-clés de type de données suivants: STRING, BOOL.

      RETURN "a" IS TYPED BOOL AS typeCheck
      

      Résultat:

      typeCheck
      0

      Prédicats Étiquetés

      Détermine si un élément de graph satisfait une instruction d'étiquette. GQL supporte les prédicats étiquetés suivants:

      • IS LABELED
      • IS NOT LABELED
      • :

      MATCH (n) WHERE n IS NOT LABELED Paper
      RETURN n
      

      MATCH (n:Paper)
      RETURN n
      

      Prédicats Source/Destination

      Détermine si un node est la source ou la destination d'un edge. GQL supporte les prédicats source/destination suivants:

      • <node reference> IS SOURCE OF <edge reference>
      • <node reference> IS NOT SOURCE OF <edge reference>
      • <node reference> IS DESTINATION OF <edge reference>
      • <node reference> IS NOT DESTINATION OF <edge reference>

      MATCH (n {_id: "P1"}), ()-[e:Cites]->() WHERE n IS SOURCE OF e
      RETURN e
      

      Prédicats Dirigés

      Les prédicats dirigés déterminent si une variable d'edge est liée à un edge dirigé. GQL supporte les prédicats dirigés suivants:

      • IS DIRECTED
      • IS NOT DIRECTED

      Détails

      • Tous les edges créés dans Ultipa Graph Database sont dirigés.

      MATCH ()-[e]-()
      RETURN e IS DIRECTED
      

      Résultat:

      e IS DIRECTED
      1

      Prédicat Tout Différent

      Détermine si tous les éléments de graph liés à une liste de variables d'éléments sont doublement différents les uns des autres. GQL supporte le prédicat tout différent suivant:

      • ALL_DIFFERENT(<elemVar>, <elemVar>[{,<elemVar>}...])

      Détails

      • Chaque <elemVar> doit avoir un degré de référence singleton.
      • Aucun des <elemVar>s ne doit être lié à une valeur null.
      • Toutes les valeurs liées aux <elemVar>s doivent être comparables.

      MATCH (n1:User {_id: "U05"}), (n2)-[:Joins]->(n3)
      RETURN n1._id, n2._id, n3._id, ALL_DIFFERENT(n1, n2, n3)
      

      Résultat:

      n1._id n2._id n3._id
      ALL_DIFFERENT(n1, n2, n3)
      U05 U05 C01 0
      U05 U04 C02 1
      U05 U02 C01 1

      Prédicat Même

      Détermine si toutes les variables d'éléments lient au même élément de graph. GQL supporte le prédicat même suivant:

      • SAME(<elemVar>, <elemVar>[{,<elemVar>}...])

      Détails

      • Chaque <elemVar> doit avoir un degré de référence singleton.
      • Aucun des <elemVar>s ne doit être lié à une valeur null.
      • Toutes les valeurs liées aux <elemVar>s doivent être comparables.

      MATCH (n1:User {_id: "U05"}), ()-[:Follows]->(n2), (n3)-[:Joins]->()
      RETURN n1._id, n2._id, n3._id, SAME(n1, n2, n3)
      

      Résultat:

      n1._id n2._id n3._id
      SAME(n1, n2, n3)
      U05 U03 U04 0
      U05 U03 U05 0
      U05 U05 U04 0
      U05 U05 U05 1

      Prédicats de Valeur Booléenne

      Évalue la véracité d'une expression booléenne ou d'une variable, déterminant si elle est vraie ou fausse. GQL supporte les prédicats de valeur booléenne suivants:

      • IS TRUE
      • IS FALSE

      RETURN 1 > 2 IS TRUE
      

      Résultat:

      1 > 2 IS TRUE
      0
      Please complete the following information to download this book
      *
      公司名称不能为空
      *
      公司邮箱必须填写
      *
      你的名字必须填写
      *
      你的电话必须填写