Vue d’ensemble
Une fonction d'agrégation effectue un calcul sur un ensemble de valeurs et renvoie une seule valeur scalaire.
L'agrégation verticale est supportée qui prend un ensemble de valeurs de différentes lignes et agrège en une seule valeur. L'agrégation horizontale qui prend un ensemble de valeurs d'une liste de groupe de valeurs et agrège en une seule valeur n'est pas encore supportée.
DISTINCT
Les fonctions avg()
, count()
, max()
, min()
, sum()
, collect_list()
, stddev_samp()
, et stddev_pop()
supportent l'utilisation du quantificateur d'ensemble DISTINCT
pour dédupliquer les valeurs avant l'agrégation.
Valeurs Nulles
Les lignes contenant des valeurs null
sont ignorées par toutes les fonctions d'agrégation, sauf count(*)
.
Exemple de Graph
Les exemples suivants s'exécutent contre ce graph :
avg()
Calcule la moyenne d'un ensemble de valeurs.
Syntaxe | avg(<values>) |
||
Arguments | Nom | Type | Description |
<values> |
Numérique | Les valeurs cibles | |
Type de Retour | DOUBLE |
MATCH (n)
RETURN avg(n.score)
Résultat:
avg(n.score) |
---|
7.33333333333333 |
FOR item IN [2, "a", 3, "1.2", null]
RETURN avg(item)
Résultat:
avg(item) |
---|
3 |
collect_list()
Collecte un ensemble de valeurs dans une liste.
Syntaxe | collect_list(<values>) |
||
Arguments | Nom | Type | Description |
<values> |
Tout | Les valeurs cibles | |
Type de Retour | LIST |
MATCH (n)
RETURN collect_list(n.title)
Résultat:
collect_list(n.title) |
---|
["Optimizing Queries","Efficient Graph Search","Path Patterns"] |
count()
Retourne le nombre de lignes dans l'entrée.
Syntaxe | count(<values>) |
||
Arguments | Nom | Type | Description |
<values> |
Tout | Les valeurs cibles | |
Type de Retour | UINT |
MATCH (n)
RETURN count(n)
Résultat:
count(n) |
---|
3 |
count(*)
count(*)
retourne le nombre de lignes dans la table de travail actuelle.
En comparant les deux requêtes suivantes, les valeurs null
ne sont prises en compte que lors de l'utilisation de count(*)
:
FOR item IN [1, "a", "2", "b3", null]
RETURN count(item)
Résultat:
count(item) |
---|
4 |
FOR item IN [1, "a", "2", "b3", null]
RETURN count(*)
Résultat:
count(*) |
---|
5 |
count(DISTINCT)
Vous pouvez inclure le quantificateur d'ensemble DISTINCT
dans count()
pour retourner le nombre de lignes distinctes dans l'entrée.
FOR item IN [1, 1, "a", "2", "b3"]
RETURN count(DISTINCT item)
Résultat:
count(DISTINCT item) |
---|
4 |
max()
Retourne la valeur maximale dans un ensemble de valeurs.
Syntaxe | max(<values>) |
||
Arguments | Nom | Type | Description |
<values> |
Numérique | Les valeurs cibles | |
Type de Retour | DOUBLE |
MATCH (n)
RETURN max(n.score)
Résultat:
max(n.score) |
---|
9 |
FOR item IN [1, "a", "2.1", "b3"]
RETURN max(item)
Résultat:
max(item) |
---|
2 |
min()
Retourne la valeur minimale dans un ensemble de valeurs.
Syntaxe | min(<values>) |
||
Arguments | Nom | Type | Description |
<values> |
Numérique | Les valeurs cibles | |
Type de Retour | DOUBLE |
MATCH (n)
RETURN min(n.score)
Résultat:
min(n.score) |
---|
6 |
FOR item IN [3, "a", "0.2", "b2"]
RETURN min(item)
Résultat:
min(item) |
---|
0 |
percentile_cont()
Calcule la valeur percentile continue sur un ensemble de valeurs.
Syntaxe | percentile_cont(<values>, <percentile>) |
||
Arguments | Nom | Type | Description |
<values> |
Numérique | Les valeurs cibles | |
<percentile> |
Numérique | Nombre entre 0.0 et 1.0 | |
Type de Retour | DOUBLE |
percentile_cont()
est calculé en utilisant les étapes suivantes :
- Trier les valeurs dans l'ordre croissant.
- Calculer la position percentile comme
p = percentile × (n − 1) + 1
, oùn
est le nombre de valeurs non nulles. - Déterminer la valeur percentile en utilisant l'interpolation linéaire :
- Si
p
est un entier, la valeur correspondante à cette position est la valeur percentile. - Si
p
est un décimal entre deux entiersp1
etp2
(p1
<p
<p2
), interpoler entre la valeurv1
à la positionp1
et la valeurv2
à la positionp2
pour calculer la valeur percentile commev1 + (p - p1) × (v2 - v1)
.
- Si
FOR item IN [3, 9, 4, 7, 6]
RETURN percentile_cont(item, 0.4)
Résultat:
percentile_cont(item, 0.4) |
---|
5.2 |
FOR item IN [3, 9, 4, 7, 6]
RETURN percentile_cont(item, 0.5)
Résultat:
percentile_cont(item, 0.5) |
---|
6 |
percentile_disc()
Calcule la valeur percentile discrète sur un ensemble de valeurs.
Syntaxe | percentile_disc(<values>, <percentile>) |
||
Arguments | Nom | Type | Description |
<values> |
Numérique | Les valeurs cibles | |
<percentile> |
Numérique | Nombre entre 0.0 et 1.0 | |
Type de Retour | DOUBLE |
percentile_disc()
est calculé en utilisant les étapes suivantes :
- Trier les valeurs dans l'ordre croissant.
- Calculer la position percentile comme
p = percentile × (n − 1) + 1
, oùn
est le nombre de valeurs non nulles. - Déterminer la valeur percentile :
- Si
p
est un entier, la valeur à cette position exacte est sélectionnée comme valeur percentile. - Si
p
n'est pas un entier, supprimer la partie décimale dep
et obtenirp'
, la valeur à la positionp'
est sélectionnée comme valeur percentile.
- Si
FOR item IN [3, 9, 4, 7, 6]
RETURN percentile_disc(item, 0.4)
Résultat:
percentile_disc(item, 0.4) |
---|
4 |
FOR item IN [3, 9, 4, 7, 6]
RETURN percentile_disc(item, 0.5)
Résultat:
percentile_disc(item, 0.5) |
---|
6 |
stddev_pop()
Calcule l'écart-type de population d'un ensemble de valeurs.
Syntaxe | stddev_pop(<values>) |
||
Arguments | Nom | Type | Description |
<values> |
Numérique | Les valeurs cibles | |
Type de Retour | Numérique |
MATCH (n)
RETURN stddev_pop(n.score)
Résultat:
stddev_pop(n.score) |
---|
1.24721912892465 |
stddev_samp()
Calcule l'écart-type d'échantillon d'un ensemble de valeurs.
Syntaxe | stddev_samp(<values>) |
||
Arguments | Nom | Type | Description |
<values> |
Numérique | Les valeurs cibles | |
Type de Retour | DOUBLE |
MATCH (n)
RETURN stddev_samp(n.score)
Résultat:
stddev_samp(n.score) |
---|
1.52752523165195 |
sum()
Calcule la somme d'un ensemble de valeurs.
Syntaxe | sum(<values>) |
||
Arguments | Nom | Type | Description |
<values> |
Numérique | Les valeurs cibles | |
Type de Retour | DOUBLE |
MATCH (n)
RETURN sum(n.score)
Résultat:
sum(n.score) |
---|
22 |
FOR item IN [3, "a", "1.2", "b2"]
RETURN sum(item)
Résultat:
sum(item) |
---|
4 |