Tous les Types de Données
Catégorie |
Types Prise en Charge | Pris en Charge par Property |
---|---|---|
Numérique | int32, int64, uint32, uint64, float, double, decimal | Oui |
Textuel | string, text | Oui |
Temporel | datetime, timestamp | Oui |
Spatial | point | Oui |
Binaire | blob | Oui |
Booléen | bool | Non |
Null | null | Non |
Données de Graph | NODE, EDGE, PATH, GRAPH | Non |
Liste | list (contenant des éléments des types ci-dessus) | Oui, mais limité à des éléments numériques, textuels ou temporels à l'exclusion de decimal |
Ensemble | set (contenant des éléments des types ci-dessus sauf list) | Oui, mais limité à des éléments numériques, textuels ou temporels à l'exclusion de decimal |
Objet | object | Non |
Tabulaire | TABLE | Non |
Property
Chaque property de node ou edge créé a un type de données. Tous les types de données pris en charge pour les properties sont :
Type | Description |
---|---|
int32 | Entier signé 32 bits (-2,147,483,648 à 2,147,483,647) |
uint32 | Entier non signé 32 bits (0 à 4,294,967,295) |
int64 | Entier signé 64 bits (-9,223,372,036,854,775,808 à 9,223,372,036,854,775,807) |
uint64 | Entier non signé 64 bits (0 à 18,446,744,073,709,551,615) |
float | Nombre en virgule flottante simple précision 32 bits avec 6 à 7 chiffres significatifs (parties entière et fractionnaire, excl. le point décimal) |
double | Nombre en virgule flottante double précision 64 bits avec 15 à 16 chiffres significatifs (parties entière et fractionnaire, excl. le point décimal) |
decimal | Nombre avec précision (1~65) et échelle (0~30)[1] spécifiées, par ex., 'decimal(10,4)' représente un nombre décimal avec un total de 10 chiffres, dont 4 après le point décimal, et les 6 restants avant le point décimalRemarque : Doit être entouré de guillemets lors de la définition |
string | Caractères d'une longueur jusqu'à 60 000 octets Remarque : C'est le type par défaut lors de la création d'une property |
text | Caractères avec aucune limite de longueur |
datetime | Valeur de date et heure avec une plage de 1000-01-01 00:00:00.000000 à 9999-12-31 23:59:59.499999, stockée comme uint64 Formats d'entrée valables incluent yyyy-mm-dd hh:mm:ss et yyyy-mm-dd hh:mm:ss.ssssss |
timestamp | Un point précis dans le temps relatif (en secondes) à partir de 1970-01-01 00:00:00 UTC; le fuseau horaire peut être réglé via RequestConfig du SDK souhaité; stocké en tant que uint32Formats d'entrée valables incluent yyyy-mm-dd hh:mm:ss , yyyy-mm-dd , yyyymmddhhmmss et yyyymmdd |
point | Coordonnées géographiques bidimensionnelles représentant un emplacement ou une position; les deux valeurs sont stockées en tant que double |
blob | Utilisé pour stocker de grands objets binaires tels que fichier, image, audio ou vidéo; la longueur est soumise au paramètre max_rpc_msgsize (par défaut à 4M) du serveur |
list | Prise en charge de int32[], int64[], uint32[], uint64[], float[], double[], string[], text[], datetime[] et timestamp[] Remarque : Doit être entouré de guillemets lors de la définition |
set | Prise en charge de set(int32), set(int64), set(uint32), set(uint64), set(float), set(double), set(string), set(text), set(datetime) et set(timestamp) Remarque : Doit être entouré de guillemets lors de la définition |
[1] La précision est le nombre total de chiffres dans le nombre, incluant à la fois les parties entière et fractionnaire (excl. le point décimal). L'échelle est le nombre de chiffres à droite du point décimal.
Données Renvoyées
Une fois que les données sont récupérées de la base de données et traitées, elles peuvent être renvoyées avec les types suivants :
Type |
Structure de Données (JSON) |
---|---|
NODE | {id: , uuid: , schema: , values: {...}} |
EDGE | {uuid: , schema: , from: , from_uuid: , to: , to_uuid: , values: {...}} |
PATH | {length: , nodes: [...], edges: [...]} |
GRAPH | {nodes: [...], edges: [...]} |
TABLE | {name: , headers: [...], rows: [...]} |
ATTR | Autres types autres que les types ci-dessus |
Exemple de graph :
NODE
Renvoyer le node dont le nom est Alice :
find().nodes({name == 'Alice'}) as n
return n{*}
Structure de données du node:
{
"id": "STU001",
"uuid": 1,
"schema": "student",
"values": {
"name": "Alice",
"age": 25
}
}
EDGE
Renvoyer l'edge dont le UUID est 53 :
find().edges({_uuid == 53}) as e
return e{*}
Structure de données de l'edge :
{
"uuid": 53,
"schema": "studyAt",
"from": "STU001",
"to": "UNI001",
"from_uuid": 1,
"to_uuid": 1001,
"values": {
"start": 2001,
"end": 2005
}
}
PATH
Renvoyer le path d'Alice à Oxford :
n({name == 'Alice'}).e().n({name == 'Oxford'}) as p
return p{*}
Structure de données du path :
{
"length": 1,
"nodes": [{
"id": "STU001",
"uuid": 1,
"schema": "student",
"values": {
"name": "Alice",
"age": 25
}
}, {
"id": "UNI001",
"uuid": 1001,
"schema": "university",
"values": {
"name": "Oxford"
}
}],
"edges": [{
"uuid": 53,
"schema": "studyAt",
"from": "STU001",
"to": "UNV001",
"from_uuid": 1,
"to_uuid": 1001,
"values": {
"start": 2001,
"end": 2005
}
}]
}
GRAPH
Renvoyer le graph formé par le path d'Alice à Oxford :
n({name == 'Alice'}).e().n({name == 'Oxford'}) as p
return toGraph(collect(p))
Structure de données du graph :
{
"nodes": [{
"id": "STU001",
"uuid": 1,
"schema": "student",
"values": {
"name": "Alice",
"age": 25
}
}, {
"id": "UNI001",
"uuid": 1001,
"schema": "university",
"values": {
"name": "Oxford"
}
}],
"edges": [{
"uuid": 53,
"schema": "studyAt",
"from": "STU001",
"to": "UNI001",
"from_uuid": 1,
"to_uuid": 1001,
"values": {
"start": 2001,
"end": 2005
}
}]
}
TABLE
Renvoyer le tableau de toutes les properties ID et name des nodes :
find().nodes() as n
return table(n._id, n.name)
Résultat :
n._id | n.name |
---|---|
STU001 | Alice |
UNI001 | Oxford |
Structure de données du tableau :
{
"name": "table(n._id, n.name)",
"alias": "table(n._id, n.name)",
"headers": [
"n._id",
"n.name"
],
"rows": [
[
"STU001",
"Alice"
],
[
"UNI001",
"Oxford"
]
]
}
ATTR
Renvoyer combien d'années Alice a étudié à Oxford :
find().edges({_uuid == 53}) as e
return e.end - e.start
Structure de données de la valeur :
{
"values": [
4
]
}
Pour spécifier un format de retour valide dans la clause RETURN, veuillez vous référer au tableau fourni ici.
Null
Dans Ultipa Graph, null signifie l'absence d'une valeur pour une property ou le résultat d'une requête. Cela diffère de 0 ou d'une chaîne vide. Les valeurs nulles sont rencontrées dans les scénarios suivants :
- Lors de l'insertion de nouveaux nodes ou edges (
insert()
,insert().overwrite()
), les properties qui ne sont pas spécifiées reçoivent des valeurs nulles. - Lors de la création d'une nouvelle property, les nodes ou edges existants du schema correspondant reçoivent des valeurs nulles pour la nouvelle property créée.
- Lorsqu'une property demandée n'existe pas, des valeurs nulles sont renvoyées à la place.
- Lors de l'utilisation du préfixe OPTIONAL pour une requête (
find()
,khop()
,n().e().n()
, etc.), si la requête ne donne pas de résultats, des valeurs nulles sont renvoyées à la place de rien.
Lorsque null est impliqué dans une expression d'opération conditionnelle :
- Si le jugement est définitif, retourne vrai ou faux;
- sinon, retourne null.
Expression | Résultat |
Remarque |
---|---|---|
null == 3 | null | Null représente une valeur inconnue ou manquante, donc sa comparaison à une autre valeur ne peut pas définitivement donner un résultat. Cela s'applique de même aux opérateurs != , < , > , >= et <= . |
null == null | null | Cela s'applique de même aux opérateurs != , < , > , >= et <= . |
[1, null, 2] == [1, 3, 2] | null | Cela s'applique de même à l'opérateur != . |
[1, null, 2] == [1, null, 2] | null | Cela s'applique de même à l'opérateur != . |
[1, null, 2] == [1, null, 3] | false | Le jugement est sûr puisque les troisièmes éléments sont différents. Le résultat est vrai pour l'opérateur != . |
[1, null, 2] == [1, null, 2, 3] | false | Le jugement est sûr puisque les longueurs des deux listes sont différentes. Le résultat est vrai pour l'opérateur != . |
null <> [1, 3] | null | Cela s'applique de même à l'opérateur <=> . |
1 IN [1, null, 2] | true | Le résultat est false pour l'opérateur NOT IN . |
3 IN [1, null, 2] | null | Cela s'applique de même à l'opérateur NOT IN . |
null IN [ ] | false | Le jugement est sûr puisque la liste donnée est vide. Le résultat est vrai pour l'opérateur NOT IN . |
Tout calcul numérique (+
, -
, *
, /
, %
) impliquant null aura pour résultat null.
Toute opération d'agrégation (count()
, sum()
, max()
, min()
, avg()
, stddev()
, collect()
) impliquant null ignorera les lignes avec des valeurs nulles.
Fonctions et opérateurs liés à null: