ClickHouse/docs/fr/sql_reference/aggregate_functions/reference.md

machine_translated	machine_translated_rev	toc_priority	toc_title
true	f865c9653f	36	Référence

La Fonction De Référence

compter

Compte le nombre de lignes ou de valeurs non NULL.

ClickHouse prend en charge les syntaxes suivantes pour count:

• count(expr) ou COUNT(DISTINCT expr).
• count() ou COUNT(*). Le count() la syntaxe est spécifique à ClickHouse.

Paramètre

La fonction peut prendre:

• Zéro des paramètres.
• Un expression.

Valeur renvoyée

• Si la fonction est appelée sans paramètres, il compte le nombre de lignes.
• Si l' expression est passé, alors la fonction compte combien de fois cette expression retournée not null. Si l'expression renvoie un Nullable- tapez la valeur, puis le résultat de count séjours pas Nullable. La fonction renvoie 0 si l'expression est retournée NULL pour toutes les lignes.

Dans les deux cas le type de la valeur renvoyée est UInt64.

Détail

Clickhouse soutient le COUNT(DISTINCT ...) syntaxe. Le comportement de cette construction dépend de la count_distinct_implementation paramètre. Il définit lequel des uniq* fonctions est utilisée pour effectuer l'opération. La valeur par défaut est la uniqExact fonction.

Le SELECT count() FROM table la requête n'est pas optimisé, car le nombre d'entrées dans la table n'est pas stockée séparément. Il choisit une petite colonne de la table et compte le nombre de valeurs qu'il contient.

Exemple

Exemple 1:

SELECT count() FROM t

┌─count()─┐
│       5 │
└─────────┘

Exemple 2:

SELECT name, value FROM system.settings WHERE name = 'count_distinct_implementation'

┌─name──────────────────────────┬─value─────┐
│ count_distinct_implementation │ uniqExact │
└───────────────────────────────┴───────────┘

SELECT count(DISTINCT num) FROM t

┌─uniqExact(num)─┐
│              3 │
└────────────────┘

Cet exemple montre que count(DISTINCT num) est effectuée par le uniqExact en fonction de l' count_distinct_implementation valeur de réglage.

tout(x)

Sélectionne la première valeur rencontrée. La requête peut être exécutée dans n'importe quel ordre, et même dans un ordre différent à chaque fois, de sorte que le résultat de cette fonction est indéterminée. Pour obtenir un résultat déterminé, vous pouvez utiliser le ‘min’ ou ‘max’ fonction au lieu de ‘any’.

Dans certains cas, vous pouvez compter sur l'ordre de l'exécution. Cela s'applique aux cas où SELECT provient d'une sous-requête qui utilise ORDER BY.

Lorsqu'un SELECT la requête a l' GROUP BY ou au moins une fonction d'agrégat, ClickHouse (contrairement à MySQL) exige que toutes les expressions du SELECT, HAVING, et ORDER BY clauses être calculée à partir de clés ou de fonctions d'agrégation. En d'autres termes, chaque colonne sélectionnée dans la table doit être utilisée soit dans les clés, soit dans les fonctions d'agrégation. Pour obtenir un comportement comme dans MySQL, vous pouvez mettre les autres colonnes dans le any fonction d'agrégation.

anyHeavy (x)

Sélectionne une valeur fréquente à l'aide poids lourds algorithme. S'il y a une valeur qui se produit plus de la moitié des cas dans chacun des threads d'exécution de la requête, cette valeur est renvoyée. Normalement, le résultat est non déterministe.

anyHeavy(column)

Argument

• column – The column name.

Exemple

Prendre la OnTime ensemble de données et sélectionnez n'importe quelle valeur AirlineID colonne.

SELECT anyHeavy(AirlineID) AS res
FROM ontime

┌───res─┐
│ 19690 │
└───────┘

anyLast (x)

Sélectionne la dernière valeur rencontrés. Le résultat est tout aussi indéterminé que pour le any fonction.

groupBitAnd

S'applique au niveau du BIT AND pour les séries de nombres.

groupBitAnd(expr)

Paramètre

expr – An expression that results in UInt* type.

Valeur de retour

La valeur de la UInt* type.

Exemple

Des données de Test:

binary     decimal
00101100 = 44
00011100 = 28
00001101 = 13
01010101 = 85

Requête:

SELECT groupBitAnd(num) FROM t

Où num est la colonne avec les données de test.

Résultat:

binary     decimal
00000100 = 4

groupBitOr

S'applique au niveau du BIT OR pour les séries de nombres.

groupBitOr(expr)

Paramètre

expr – An expression that results in UInt* type.

Valeur de retour

La valeur de la UInt* type.

Exemple

Des données de Test:

binary     decimal
00101100 = 44
00011100 = 28
00001101 = 13
01010101 = 85

Requête:

SELECT groupBitOr(num) FROM t

Où num est la colonne avec les données de test.

Résultat:

binary     decimal
01111101 = 125

groupBitXor

S'applique au niveau du BIT XOR pour les séries de nombres.

groupBitXor(expr)

Paramètre

expr – An expression that results in UInt* type.

Valeur de retour

La valeur de la UInt* type.

Exemple

Des données de Test:

binary     decimal
00101100 = 44
00011100 = 28
00001101 = 13
01010101 = 85

Requête:

SELECT groupBitXor(num) FROM t

Où num est la colonne avec les données de test.

Résultat:

binary     decimal
01101000 = 104

groupBitmap

Calculs Bitmap ou agrégés à partir d'une colonne entière non signée, retour cardinalité de type UInt64, si Ajouter suffixe-State, puis retour objet bitmap.

groupBitmap(expr)

Paramètre

expr – An expression that results in UInt* type.

Valeur de retour

La valeur de la UInt64 type.

Exemple

Des données de Test:

UserID
1
1
2
3

Requête:

SELECT groupBitmap(UserID) as num FROM t

Résultat:

num
3

min (x)

Calcule le minimum.

max (x)

Calcule le maximum.

argMin (arg, val)

Calcule la ‘arg’ valeur pour un minimum ‘val’ valeur. S'il y a plusieurs valeurs différentes de ‘arg’ pour des valeurs minimales de ‘val’ la première de ces valeurs rencontrées est de sortie.

Exemple:

┌─user─────┬─salary─┐
│ director │   5000 │
│ manager  │   3000 │
│ worker   │   1000 │
└──────────┴────────┘

SELECT argMin(user, salary) FROM salary

┌─argMin(user, salary)─┐
│ worker               │
└──────────────────────┘

argMax(arg, val)

Calcule la ‘arg’ valeur pour un maximum ‘val’ valeur. S'il y a plusieurs valeurs différentes de ‘arg’ pour les valeurs maximales de ‘val’ la première de ces valeurs rencontrées est de sortie.

sum(x)

Calcule la somme. Ne fonctionne que pour les numéros.

sumWithOverflow (x)

Calcule la somme des nombres, en utilisant le même type de données pour le résultat que pour les paramètres d'entrée. Si la somme dépasse la valeur maximale pour ce type de données, la fonction renvoie une erreur.

Ne fonctionne que pour les numéros.

sumMap (clé, valeur)

Les totaux de la ‘value’ tableau selon les clés spécifiés dans le ‘key’ tableau. Le nombre d'éléments dans ‘key’ et ‘value’ doit être identique pour chaque ligne totalisée. Returns a tuple of two arrays: keys in sorted order, and values ​​summed for the corresponding keys.

Exemple:

CREATE TABLE sum_map(
    date Date,
    timeslot DateTime,
    statusMap Nested(
        status UInt16,
        requests UInt64
    )
) ENGINE = Log;
INSERT INTO sum_map VALUES
    ('2000-01-01', '2000-01-01 00:00:00', [1, 2, 3], [10, 10, 10]),
    ('2000-01-01', '2000-01-01 00:00:00', [3, 4, 5], [10, 10, 10]),
    ('2000-01-01', '2000-01-01 00:01:00', [4, 5, 6], [10, 10, 10]),
    ('2000-01-01', '2000-01-01 00:01:00', [6, 7, 8], [10, 10, 10]);
SELECT
    timeslot,
    sumMap(statusMap.status, statusMap.requests)
FROM sum_map
GROUP BY timeslot

┌────────────timeslot─┬─sumMap(statusMap.status, statusMap.requests)─┐
│ 2000-01-01 00:00:00 │ ([1,2,3,4,5],[10,10,20,10,10])               │
│ 2000-01-01 00:01:00 │ ([4,5,6,7,8],[10,10,20,10,10])               │
└─────────────────────┴──────────────────────────────────────────────┘

skewPop

Calcule la asymétrie d'une séquence.

skewPop(expr)

Paramètre

expr — Expression retour d'un nombre.

Valeur renvoyée

The skewness of the given distribution. Type — Float64

Exemple

SELECT skewPop(value) FROM series_with_value_column

skewSamp

Calcule la asymétrie de l'échantillon d'une séquence.

Il représente une estimation non biaisée de l'asymétrie d'une variable aléatoire si les valeurs passées forme de son échantillon.

skewSamp(expr)

Paramètre

expr — Expression retour d'un nombre.

Valeur renvoyée

The skewness of the given distribution. Type — Float64. Si n <= 1 (n est la taille de l'échantillon), alors la fonction renvoie nan.

Exemple

SELECT skewSamp(value) FROM series_with_value_column

kurtPop

Calcule la kurtosis d'une séquence.

kurtPop(expr)

Paramètre

expr — Expression retour d'un nombre.

Valeur renvoyée

The kurtosis of the given distribution. Type — Float64

Exemple

SELECT kurtPop(value) FROM series_with_value_column

kurtSamp

Calcule la l'échantillon le coefficient d'aplatissement d'une séquence.

Il représente une estimation non biaisée de la kurtose d'une variable aléatoire si les valeurs passées forment son échantillon.

kurtSamp(expr)

Paramètre

expr — Expression retour d'un nombre.

Valeur renvoyée

The kurtosis of the given distribution. Type — Float64. Si n <= 1 (n la taille de l'échantillon), alors la fonction renvoie nan.

Exemple

SELECT kurtSamp(value) FROM series_with_value_column

timeSeriesGroupSum(uid, horodatage, valeur)

timeSeriesGroupSum peut agréger différentes séries temporelles qui échantillonnent l'horodatage et non l'alignement. Il utilisera une interpolation linéaire entre deux échantillons d'horodatage, puis additionnera les séries temporelles ensemble.

• uid la série temporelle est elle unique, UInt64.
• timestamp est de type Int64 afin de prendre en charge la milliseconde ou la microseconde.
• value est la métrique.

La fonction renvoie un tableau de tuples avec (timestamp, aggregated_value) pair.

Avant d'utiliser cette fonction, assurez-vous timestamp est dans l'ordre croissant.

Exemple:

┌─uid─┬─timestamp─┬─value─┐
│ 1   │     2     │   0.2 │
│ 1   │     7     │   0.7 │
│ 1   │    12     │   1.2 │
│ 1   │    17     │   1.7 │
│ 1   │    25     │   2.5 │
│ 2   │     3     │   0.6 │
│ 2   │     8     │   1.6 │
│ 2   │    12     │   2.4 │
│ 2   │    18     │   3.6 │
│ 2   │    24     │   4.8 │
└─────┴───────────┴───────┘

CREATE TABLE time_series(
    uid       UInt64,
    timestamp Int64,
    value     Float64
) ENGINE = Memory;
INSERT INTO time_series VALUES
    (1,2,0.2),(1,7,0.7),(1,12,1.2),(1,17,1.7),(1,25,2.5),
    (2,3,0.6),(2,8,1.6),(2,12,2.4),(2,18,3.6),(2,24,4.8);

SELECT timeSeriesGroupSum(uid, timestamp, value)
FROM (
    SELECT * FROM time_series order by timestamp ASC
);

Et le résultat sera:

[(2,0.2),(3,0.9),(7,2.1),(8,2.4),(12,3.6),(17,5.1),(18,5.4),(24,7.2),(25,2.5)]

timeSeriesGroupRateSum(uid, ts, val)

De même timeSeriesGroupRateSum, timeSeriesGroupRateSum calculera le taux de séries temporelles, puis additionnera les taux ensemble. En outre, l'horodatage doit être dans l'ordre croissant avant d'utiliser cette fonction.

Utilisez cette fonction, le résultat ci-dessus sera:

[(2,0),(3,0.1),(7,0.3),(8,0.3),(12,0.3),(17,0.3),(18,0.3),(24,0.3),(25,0.1)]

avg (x)

Calcule la moyenne. Ne fonctionne que pour les numéros. Le résultat est toujours Float64.

uniq

Calcule le nombre approximatif des différentes valeurs de l'argument.

uniq(x[, ...])

Paramètre

La fonction prend un nombre variable de paramètres. Les paramètres peuvent être Tuple, Array, Date, DateTime, String ou des types numériques.

Valeur renvoyée

• A UInt64numéro de type.

Détails de mise en œuvre

Fonction:

• Calcule un hachage pour tous les paramètres de l'agrégat, puis l'utilise dans les calculs.

• Utilise un algorithme d'échantillonnage adaptatif. Pour l'état de calcul, La fonction utilise un échantillon de valeurs de hachage d'éléments jusqu'à 65536.

  This algorithm is very accurate and very efficient on the CPU. When the query contains several of these functions, using `uniq` is almost as fast as using other aggregate functions.
  

• Fournit le résultat de manière déterministe (cela ne dépend pas de l'ordre de traitement de la requête).

Nous vous recommandons d'utiliser cette fonction dans presque tous les scénarios.

Voir Aussi

• uniqcombiné
• uniqCombined64
• uniqHLL12
• uniqExact

uniqcombiné

Calcule le nombre approximatif de différentes valeurs d'argument.

uniqCombined(HLL_precision)(x[, ...])

Le uniqCombined la fonction est un bon choix pour calculer le nombre de valeurs différentes.

Paramètre

La fonction prend un nombre variable de paramètres. Les paramètres peuvent être Tuple, Array, Date, DateTime, String ou des types numériques.

HLL_precision est le logarithme en base 2 du nombre de cellules dans HyperLogLog. Facultatif, vous pouvez utiliser la fonction comme uniqCombined(x[, ...]). La valeur par défaut pour HLL_precision est 17, qui est effectivement 96 Ko d'espace(2 ^ 17 cellules, 6 bits chacune).

Valeur renvoyée

• Nombre UInt64numéro de type.

Détails de mise en œuvre

Fonction:

• Calcule un hachage (hachage 64 bits pour String et 32 bits sinon) pour tous les paramètres dans l'agrégat, puis l'utilise dans les calculs.

• Utilise une combinaison de trois algorithmes: tableau, table de hachage et HyperLogLog avec une table de correction d'erreur.

  For a small number of distinct elements, an array is used. When the set size is larger, a hash table is used. For a larger number of elements, HyperLogLog is used, which will occupy a fixed amount of memory.
  

• Fournit le résultat de manière déterministe (cela ne dépend pas de l'ordre de traitement de la requête).

!!! note "Note" Comme il utilise le hachage 32 bits pour non-String type, le résultat aura une erreur très élevée pour les cardinalités significativement plus grandes que UINT_MAX (erreur va augmenter rapidement après quelques dizaines de milliards de valeurs distinctes), donc dans ce cas, vous devez utiliser uniqCombined64

Par rapport à la uniq la fonction, la uniqCombined:

• Consomme plusieurs fois moins de mémoire.
• Calcule avec plusieurs fois plus de précision.
• A généralement des performances légèrement inférieures. Dans certains scénarios, uniqCombined peut faire mieux que uniq par exemple, avec des requêtes distribuées qui transmettent un grand nombre d'agrégation des états sur le réseau.

Voir Aussi

• uniq
• uniqCombined64
• uniqHLL12
• uniqExact

uniqCombined64

Même que uniqcombiné, mais utilise le hachage 64 bits pour tous les types de données.

uniqHLL12

Calcule le nombre approximatif de différentes valeurs d'argument, en utilisant HyperLogLog algorithme.

uniqHLL12(x[, ...])

Paramètre

La fonction prend un nombre variable de paramètres. Les paramètres peuvent être Tuple, Array, Date, DateTime, String ou des types numériques.

Valeur renvoyée

• A UInt64numéro de type.

Détails de mise en œuvre

Fonction:

• Calcule un hachage pour tous les paramètres de l'agrégat, puis l'utilise dans les calculs.

• Utilise L'algorithme HyperLogLog pour approximer le nombre de valeurs d'argument différentes.

  212 5-bit cells are used. The size of the state is slightly more than 2.5 KB. The result is not very accurate (up to ~10% error) for small data sets (<10K elements). However, the result is fairly accurate for high-cardinality data sets (10K-100M), with a maximum error of ~1.6%. Starting from 100M, the estimation error increases, and the function will return very inaccurate results for data sets with extremely high cardinality (1B+ elements).
  

• Fournit le résultat déterminé (il ne dépend pas de l'ordre de traitement de la requête).

Nous ne recommandons pas d'utiliser cette fonction. Dans la plupart des cas, l'utilisation de la uniq ou uniqcombiné fonction.

Voir Aussi

• uniq
• uniqcombiné
• uniqExact

uniqExact

Calcule le nombre exact de différentes valeurs d'argument.

uniqExact(x[, ...])

L'utilisation de la uniqExact fonction si vous avez absolument besoin d'un résultat exact. Sinon l'utilisation de la uniq fonction.

Le uniqExact la fonction utilise plus de mémoire que uniq parce que la taille de l'état a surabondance de croissance que le nombre de valeurs différentes augmente.

Paramètre

La fonction prend un nombre variable de paramètres. Les paramètres peuvent être Tuple, Array, Date, DateTime, String ou des types numériques.

Voir Aussi

• uniq
• uniqcombiné
• uniqHLL12

groupArray(x), groupArray (max_size) (x)

Crée un tableau de valeurs de l'argument. Les valeurs peuvent être ajoutées au tableau dans une (indéterminée) de commande.

La deuxième version (avec le max_size paramètre) limite la taille du tableau résultant à max_size élément. Exemple, groupArray (1) (x) est équivalent à [any (x)].

Dans certains cas, vous pouvez toujours compter sur l'ordre de l'exécution. Cela s'applique aux cas où SELECT provient d'une sous-requête qui utilise ORDER BY.

groupeparrayinsertat(valeur, position)

Insère une valeur dans le tableau à la position spécifiée.

!!! note "Note" Cette fonction utilise des positions à base zéro, contrairement aux positions à base unique classiques pour les tableaux SQL.

Accepts the value and position as input. If several values ​​are inserted into the same position, any of them might end up in the resulting array (the first one will be used in the case of single-threaded execution). If no value is inserted into a position, the position is assigned the default value.

Paramètres facultatifs:

• Valeur par défaut pour la substitution dans des positions vides.
• La longueur du tableau résultant. Cela vous permet de recevoir des tableaux de la même taille pour tous les agrégats clés. Lorsque vous utilisez ce paramètre, la valeur par défaut doit être spécifiée.

groupeparraymovingsum

Calcule la somme mobile des valeurs d'entrée.

groupArrayMovingSum(numbers_for_summing)
groupArrayMovingSum(window_size)(numbers_for_summing)

La fonction peut prendre la taille de la fenêtre comme paramètre. Si spécifié, la fonction prend la taille de la fenêtre égal au nombre de lignes dans la colonne.

Paramètre

• numbers_for_summing — Expression résultant en une valeur de type de données Numérique.
• window_size — Size of the calculation window.

Valeurs renvoyées

• Tableau de la même taille et de même type que les données d'entrée.

Exemple

La table d'échantillon:

CREATE TABLE t
(
    `int` UInt8,
    `float` Float32,
    `dec` Decimal32(2)
)
ENGINE = TinyLog

┌─int─┬─float─┬──dec─┐
│   1 │   1.1 │ 1.10 │
│   2 │   2.2 │ 2.20 │
│   4 │   4.4 │ 4.40 │
│   7 │  7.77 │ 7.77 │
└─────┴───────┴──────┘

Requête:

SELECT
    groupArrayMovingSum(int) AS I,
    groupArrayMovingSum(float) AS F,
    groupArrayMovingSum(dec) AS D
FROM t

┌─I──────────┬─F───────────────────────────────┬─D──────────────────────┐
│ [1,3,7,14] │ [1.1,3.3000002,7.7000003,15.47] │ [1.10,3.30,7.70,15.47] │
└────────────┴─────────────────────────────────┴────────────────────────┘

SELECT
    groupArrayMovingSum(2)(int) AS I,
    groupArrayMovingSum(2)(float) AS F,
    groupArrayMovingSum(2)(dec) AS D
FROM t

┌─I──────────┬─F───────────────────────────────┬─D──────────────────────┐
│ [1,3,6,11] │ [1.1,3.3000002,6.6000004,12.17] │ [1.10,3.30,6.60,12.17] │
└────────────┴─────────────────────────────────┴────────────────────────┘

groupArrayMovingAvg

Calcule la moyenne mobile des valeurs d'entrée.

groupArrayMovingAvg(numbers_for_summing)
groupArrayMovingAvg(window_size)(numbers_for_summing)

La fonction peut prendre la taille de la fenêtre comme paramètre. Si spécifié, la fonction prend la taille de la fenêtre égal au nombre de lignes dans la colonne.

Paramètre

• numbers_for_summing — Expression résultant en une valeur de type de données Numérique.
• window_size — Size of the calculation window.

Valeurs renvoyées

• Tableau de la même taille et de même type que les données d'entrée.

La fonction utilise l'arrondi vers zéro. Il tronque les décimales insignifiantes pour le type de données résultant.

Exemple

La table d'échantillon b:

CREATE TABLE t
(
    `int` UInt8,
    `float` Float32,
    `dec` Decimal32(2)
)
ENGINE = TinyLog

┌─int─┬─float─┬──dec─┐
│   1 │   1.1 │ 1.10 │
│   2 │   2.2 │ 2.20 │
│   4 │   4.4 │ 4.40 │
│   7 │  7.77 │ 7.77 │
└─────┴───────┴──────┘

Requête:

SELECT
    groupArrayMovingAvg(int) AS I,
    groupArrayMovingAvg(float) AS F,
    groupArrayMovingAvg(dec) AS D
FROM t

┌─I─────────┬─F───────────────────────────────────┬─D─────────────────────┐
│ [0,0,1,3] │ [0.275,0.82500005,1.9250001,3.8675] │ [0.27,0.82,1.92,3.86] │
└───────────┴─────────────────────────────────────┴───────────────────────┘

SELECT
    groupArrayMovingAvg(2)(int) AS I,
    groupArrayMovingAvg(2)(float) AS F,
    groupArrayMovingAvg(2)(dec) AS D
FROM t

┌─I─────────┬─F────────────────────────────────┬─D─────────────────────┐
│ [0,1,3,5] │ [0.55,1.6500001,3.3000002,6.085] │ [0.55,1.65,3.30,6.08] │
└───────────┴──────────────────────────────────┴───────────────────────┘

groupUniqArray(x), groupUniqArray (max_size) (x)

Crée un tableau à partir de différentes valeurs d'argument. La consommation de mémoire est la même que pour la uniqExact fonction.

La deuxième version (avec le max_size paramètre) limite la taille du tableau résultant à max_size élément. Exemple, groupUniqArray(1)(x) est équivalent à [any(x)].

quantile

Calcule une approximation quantile des données numériques de la séquence.

Cette fonction s'applique réservoir d'échantillonnage avec une taille de réservoir jusqu'à 8192 et un générateur de nombres aléatoires pour l'échantillonnage. Le résultat est non-déterministe. Pour obtenir un quantile exact, Utilisez le quantileExact fonction.

Lorsque vous utilisez plusieurs quantile* fonctionne avec différents niveaux dans une requête, les états internes ne sont pas combinées (qui est, la requête fonctionne moins efficacement qu'il le pouvait). Dans ce cas, utilisez la les quantiles fonction.

Syntaxe

quantile(level)(expr)

Alias: median.

Paramètre

• level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level la valeur dans la plage de [0.01, 0.99]. Valeur par défaut: 0.5. À level=0.5 la fonction calcule médian.
• expr — Expression over the column values resulting in numeric types de données, Date ou DateTime.

Valeur renvoyée

• Approximative de quantiles de niveau spécifié.

Type:

• Float64 pour l'entrée de type de données numériques.
• Date si les valeurs d'entrée ont le Date type.
• DateTime si les valeurs d'entrée ont le DateTime type.

Exemple

Table d'entrée:

┌─val─┐
│   1 │
│   1 │
│   2 │
│   3 │
└─────┘

Requête:

SELECT quantile(val) FROM t

Résultat:

┌─quantile(val)─┐
│           1.5 │
└───────────────┘

Voir Aussi

• médian
• les quantiles

quantileDeterministic

Calcule une approximation quantile des données numériques de la séquence.

Cette fonction s'applique réservoir d'échantillonnage avec une taille de réservoir jusqu'à 8192 et un algorithme déterministe d'échantillonnage. Le résultat est déterministe. Pour obtenir un quantile exact, Utilisez le quantileExact fonction.

Lorsque vous utilisez plusieurs quantile* fonctionne avec différents niveaux dans une requête, les états internes ne sont pas combinées (qui est, la requête fonctionne moins efficacement qu'il le pouvait). Dans ce cas, utilisez la les quantiles fonction.

Syntaxe

quantileDeterministic(level)(expr, determinator)

Alias: medianDeterministic.

Paramètre

• level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level la valeur dans la plage de [0.01, 0.99]. Valeur par défaut: 0.5. À level=0.5 la fonction calcule médian.
• expr — Expression over the column values resulting in numeric types de données, Date ou DateTime.
• determinator — Number whose hash is used instead of a random number generator in the reservoir sampling algorithm to make the result of sampling deterministic. As a determinator you can use any deterministic positive number, for example, a user id or an event id. If the same determinator value occures too often, the function works incorrectly.

Valeur renvoyée

• Approximative de quantiles de niveau spécifié.

Type:

• Float64 pour l'entrée de type de données numériques.
• Date si les valeurs d'entrée ont le Date type.
• DateTime si les valeurs d'entrée ont le DateTime type.

Exemple

Table d'entrée:

┌─val─┐
│   1 │
│   1 │
│   2 │
│   3 │
└─────┘

Requête:

SELECT quantileDeterministic(val, 1) FROM t

Résultat:

┌─quantileDeterministic(val, 1)─┐
│                           1.5 │
└───────────────────────────────┘

Voir Aussi

• médian
• les quantiles

quantileExact

Exactement calcule l' quantile des données numériques de la séquence.

To get exact value, all the passed values ​​are combined into an array, which is then partially sorted. Therefore, the function consumes O(n) de mémoire, où n est un nombre de valeurs qui ont été passées. Cependant, pour un petit nombre de valeurs, la fonction est très efficace.

Lorsque vous utilisez plusieurs quantile* fonctionne avec différents niveaux dans une requête, les états internes ne sont pas combinées (qui est, la requête fonctionne moins efficacement qu'il le pouvait). Dans ce cas, utilisez la les quantiles fonction.

Syntaxe

quantileExact(level)(expr)

Alias: medianExact.

Paramètre

• level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level la valeur dans la plage de [0.01, 0.99]. Valeur par défaut: 0.5. À level=0.5 la fonction calcule médian.
• expr — Expression over the column values resulting in numeric types de données, Date ou DateTime.

Valeur renvoyée

• Quantiles de niveau spécifié.

Type:

• Float64 pour l'entrée de type de données numériques.
• Date si les valeurs d'entrée ont le Date type.
• DateTime si les valeurs d'entrée ont le DateTime type.

Exemple

Requête:

SELECT quantileExact(number) FROM numbers(10)

Résultat:

┌─quantileExact(number)─┐
│                     5 │
└───────────────────────┘

Voir Aussi

• médian
• les quantiles

quantileExactWeighted

Exactement calcule l' quantile d'une séquence de données numériques, en tenant compte du poids de chaque élément.

To get exact value, all the passed values ​​are combined into an array, which is then partially sorted. Each value is counted with its weight, as if it is present weight times. A hash table is used in the algorithm. Because of this, if the passed values ​​are frequently repeated, the function consumes less RAM than quantileExact. Vous pouvez utiliser cette fonction au lieu de quantileExact et spécifiez le poids 1.

Lorsque vous utilisez plusieurs quantile* fonctionne avec différents niveaux dans une requête, les états internes ne sont pas combinées (qui est, la requête fonctionne moins efficacement qu'il le pouvait). Dans ce cas, utilisez la les quantiles fonction.

Syntaxe

quantileExactWeighted(level)(expr, weight)

Alias: medianExactWeighted.

Paramètre

• level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level la valeur dans la plage de [0.01, 0.99]. Valeur par défaut: 0.5. À level=0.5 la fonction calcule médian.
• expr — Expression over the column values resulting in numeric types de données, Date ou DateTime.
• weight — Column with weights of sequence members. Weight is a number of value occurrences.

Valeur renvoyée

• Quantiles de niveau spécifié.

Type:

• Float64 pour l'entrée de type de données numériques.
• Date si les valeurs d'entrée ont le Date type.
• DateTime si les valeurs d'entrée ont le DateTime type.

Exemple

Table d'entrée:

┌─n─┬─val─┐
│ 0 │   3 │
│ 1 │   2 │
│ 2 │   1 │
│ 5 │   4 │
└───┴─────┘

Requête:

SELECT quantileExactWeighted(n, val) FROM t

Résultat:

┌─quantileExactWeighted(n, val)─┐
│                             1 │
└───────────────────────────────┘

Voir Aussi

• médian
• les quantiles

quantileTiming

Avec la précision déterminée calcule le quantile des données numériques de la séquence.

Le résultat est déterministe (il ne dépend pas de l'ordre de traitement de la requête). La fonction est optimisée pour travailler avec des séquences qui décrivent des distributions comme les temps de chargement des pages web ou les temps de réponse du backend.

Lorsque vous utilisez plusieurs quantile* fonctionne avec différents niveaux dans une requête, les états internes ne sont pas combinées (qui est, la requête fonctionne moins efficacement qu'il le pouvait). Dans ce cas, utilisez la les quantiles fonction.

Syntaxe

quantileTiming(level)(expr)

Alias: medianTiming.

Paramètre

• level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level la valeur dans la plage de [0.01, 0.99]. Valeur par défaut: 0.5. À level=0.5 la fonction calcule médian.

• expr — Expression sur une colonne Valeurs renvoyant un Flottant*numéro de type.

  - If negative values are passed to the function, the behavior is undefined.
  - If the value is greater than 30,000 (a page loading time of more than 30 seconds), it is assumed to be 30,000.
  

Exactitude

Le calcul est précis si:

• Le nombre Total de valeurs ne dépasse pas 5670.
• Le nombre Total de valeurs dépasse 5670, mais le temps de chargement de la page est inférieur à 1024ms.

Sinon, le résultat du calcul est arrondi au plus proche multiple de 16 ms.

!!! note "Note" Pour calculer les quantiles de temps de chargement de page, cette fonction est plus efficace et précise que quantile.

Valeur renvoyée

• Quantiles de niveau spécifié.

Type: Float32.

!!! note "Note" Si aucune valeur n'est transmise à la fonction (lors de l'utilisation de quantileTimingIf), Nan est retourné. Le but est de différencier ces cas de cas qui aboutissent à zéro. Voir Clause ORDER BY pour des notes sur le tri NaN valeur.

Exemple

Table d'entrée:

┌─response_time─┐
│            72 │
│           112 │
│           126 │
│           145 │
│           104 │
│           242 │
│           313 │
│           168 │
│           108 │
└───────────────┘

Requête:

SELECT quantileTiming(response_time) FROM t

Résultat:

┌─quantileTiming(response_time)─┐
│                           126 │
└───────────────────────────────┘

Voir Aussi

• médian
• les quantiles

quantileTimingWeighted

Avec la précision déterminée calcule le quantile d'une séquence de données numériques en fonction du poids de chaque élément de séquence.

Le résultat est déterministe (il ne dépend pas de l'ordre de traitement de la requête). La fonction est optimisée pour travailler avec des séquences qui décrivent des distributions comme les temps de chargement des pages web ou les temps de réponse du backend.

Lorsque vous utilisez plusieurs quantile* fonctionne avec différents niveaux dans une requête, les états internes ne sont pas combinées (qui est, la requête fonctionne moins efficacement qu'il le pouvait). Dans ce cas, utilisez la les quantiles fonction.

Syntaxe

quantileTimingWeighted(level)(expr, weight)

Alias: medianTimingWeighted.

Paramètre

• level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level la valeur dans la plage de [0.01, 0.99]. Valeur par défaut: 0.5. À level=0.5 la fonction calcule médian.

• expr — Expression sur une colonne Valeurs renvoyant un Flottant*numéro de type.

  - If negative values are passed to the function, the behavior is undefined.
  - If the value is greater than 30,000 (a page loading time of more than 30 seconds), it is assumed to be 30,000.
  

• weight — Column with weights of sequence elements. Weight is a number of value occurrences.

Exactitude

Le calcul est précis si:

• Le nombre Total de valeurs ne dépasse pas 5670.
• Le nombre Total de valeurs dépasse 5670, mais le temps de chargement de la page est inférieur à 1024ms.

Sinon, le résultat du calcul est arrondi au plus proche multiple de 16 ms.

!!! note "Note" Pour calculer les quantiles de temps de chargement de page, cette fonction est plus efficace et précise que quantile.

Valeur renvoyée

• Quantiles de niveau spécifié.

Type: Float32.

!!! note "Note" Si aucune valeur n'est transmise à la fonction (lors de l'utilisation de quantileTimingIf), Nan est retourné. Le but est de différencier ces cas de cas qui aboutissent à zéro. Voir Clause ORDER BY pour des notes sur le tri NaN valeur.

Exemple

Table d'entrée:

┌─response_time─┬─weight─┐
│            68 │      1 │
│           104 │      2 │
│           112 │      3 │
│           126 │      2 │
│           138 │      1 │
│           162 │      1 │
└───────────────┴────────┘

Requête:

SELECT quantileTimingWeighted(response_time, weight) FROM t

Résultat:

┌─quantileTimingWeighted(response_time, weight)─┐
│                                           112 │
└───────────────────────────────────────────────┘

Voir Aussi

• médian
• les quantiles

quantileTDigest

Calcule une approximation quantile d'une séquence de données numériques utilisant t-digest algorithme.

L'erreur maximale est de 1%. La consommation de mémoire est log(n), où n est un certain nombre de valeurs. Le résultat dépend de l'ordre d'exécution de la requête et n'est pas déterministe.

La performance de la fonction est inférieure à la performance de quantile ou quantileTiming. En termes de rapport entre la taille de L'état et la précision, cette fonction est bien meilleure que quantile.

Lorsque vous utilisez plusieurs quantile* fonctionne avec différents niveaux dans une requête, les états internes ne sont pas combinées (qui est, la requête fonctionne moins efficacement qu'il le pouvait). Dans ce cas, utilisez la les quantiles fonction.

Syntaxe

quantileTDigest(level)(expr)

Alias: medianTDigest.

Paramètre

• level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level la valeur dans la plage de [0.01, 0.99]. Valeur par défaut: 0.5. À level=0.5 la fonction calcule médian.
• expr — Expression over the column values resulting in numeric types de données, Date ou DateTime.

Valeur renvoyée

• Approximative de quantiles de niveau spécifié.

Type:

• Float64 pour l'entrée de type de données numériques.
• Date si les valeurs d'entrée ont le Date type.
• DateTime si les valeurs d'entrée ont le DateTime type.

Exemple

Requête:

SELECT quantileTDigest(number) FROM numbers(10)

Résultat:

┌─quantileTDigest(number)─┐
│                     4.5 │
└─────────────────────────┘

Voir Aussi

• médian
• les quantiles

quantileTDigestWeighted

Calcule une approximation quantile d'une séquence de données numériques utilisant t-digest algorithme. La fonction prend en compte le poids de chaque séquence de membre. L'erreur maximale est de 1%. La consommation de mémoire est log(n), où n est un certain nombre de valeurs.

La performance de la fonction est inférieure à la performance de quantile ou quantileTiming. En termes de rapport entre la taille de L'état et la précision, cette fonction est bien meilleure que quantile.

Le résultat dépend de l'ordre d'exécution de la requête et n'est pas déterministe.

Lorsque vous utilisez plusieurs quantile* fonctionne avec différents niveaux dans une requête, les états internes ne sont pas combinées (qui est, la requête fonctionne moins efficacement qu'il le pouvait). Dans ce cas, utilisez la les quantiles fonction.

Syntaxe

quantileTDigest(level)(expr)

Alias: medianTDigest.

Paramètre

• level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level la valeur dans la plage de [0.01, 0.99]. Valeur par défaut: 0.5. À level=0.5 la fonction calcule médian.
• expr — Expression over the column values resulting in numeric types de données, Date ou DateTime.
• weight — Column with weights of sequence elements. Weight is a number of value occurrences.

Valeur renvoyée

• Approximative de quantiles de niveau spécifié.

Type:

• Float64 pour l'entrée de type de données numériques.
• Date si les valeurs d'entrée ont le Date type.
• DateTime si les valeurs d'entrée ont le DateTime type.

Exemple

Requête:

SELECT quantileTDigestWeighted(number, 1) FROM numbers(10)

Résultat:

┌─quantileTDigestWeighted(number, 1)─┐
│                                4.5 │
└────────────────────────────────────┘

Voir Aussi

• médian
• les quantiles

médian

Le median* les fonctions sont les Alias pour le correspondant quantile* fonction. Ils calculent la médiane d'un échantillon de données numériques.

Fonction:

• median — Alias for quantile.
• medianDeterministic — Alias for quantileDeterministic.
• medianExact — Alias for quantileExact.
• medianExactWeighted — Alias for quantileExactWeighted.
• medianTiming — Alias for quantileTiming.
• medianTimingWeighted — Alias for quantileTimingWeighted.
• medianTDigest — Alias for quantileTDigest.
• medianTDigestWeighted — Alias for quantileTDigestWeighted.

Exemple

Table d'entrée:

┌─val─┐
│   1 │
│   1 │
│   2 │
│   3 │
└─────┘

Requête:

SELECT medianDeterministic(val, 1) FROM t

Résultat:

┌─medianDeterministic(val, 1)─┐
│                         1.5 │
└─────────────────────────────┘

quantiles(level1, level2, …)(x)

Toutes les fonctions quantiles ont également des fonctions quantiles correspondantes: quantiles, quantilesDeterministic, quantilesTiming, quantilesTimingWeighted, quantilesExact, quantilesExactWeighted, quantilesTDigest. Ces fonctions calculent tous les quantiles des niveaux listés en une seule passe et renvoient un tableau des valeurs résultantes.

varSamp (x)

Calcule le montant Σ((x - x̅)^2) / (n - 1), où n est la taille de l'échantillon et x̅est la valeur moyenne de x.

Il représente une estimation non biaisée de la variance d'une variable aléatoire si les valeurs passées forment son échantillon.

Retourner Float64. Lorsque n <= 1, retourner +∞.

varPop (x)

Calcule le montant Σ((x - x̅)^2) / n, où n est la taille de l'échantillon et x̅est la valeur moyenne de x.

En d'autres termes, dispersion pour un ensemble de valeurs. Retourner Float64.

stddevSamp (x)

Le résultat est égal à la racine carrée de varSamp(x).

stddevPop (x)

Le résultat est égal à la racine carrée de varPop(x).

topK (N) (x)

Renvoie un tableau des valeurs approximativement les plus fréquentes dans la colonne spécifiée. Le tableau est trié par ordre décroissant de fréquence approximative des valeurs (et non par les valeurs elles-mêmes).

Met en œuvre la Gain De Place Filtré algorithme d'analyse de TopK, basé sur l'algorithme de réduction et de combinaison de Économie D'Espace Parallèle.

topK(N)(column)

Cette fonction ne fournit pas un résultat garanti. Dans certaines situations, des erreurs peuvent se produire et renvoyer des valeurs fréquentes qui ne sont pas les valeurs les plus fréquentes.

Nous vous recommandons d'utiliser l' N < 10 valeur; performance est réduite avec grand N valeur. Valeur maximale de N = 65536.

Paramètre

• ‘N’ est le nombre d'éléments de retour.

Si le paramètre est omis, la valeur par défaut 10 est utilisé.

Argument

• ' x ' – The value to calculate frequency.

Exemple

Prendre la OnTime ensemble de données et sélectionnez les trois valeurs les plus fréquentes AirlineID colonne.

SELECT topK(3)(AirlineID) AS res
FROM ontime

┌─res─────────────────┐
│ [19393,19790,19805] │
└─────────────────────┘

topKWeighted

Semblable à topK mais prend un argument de type entier - weight. Chaque valeur est comptabilisée weight les temps de calcul de fréquence.

Syntaxe

topKWeighted(N)(x, weight)

Paramètre

• N — The number of elements to return.

Argument

• x – The value.
• weight — The weight. UInt8.

Valeur renvoyée

Renvoie un tableau des valeurs avec la somme approximative maximale des poids.

Exemple

Requête:

SELECT topKWeighted(10)(number, number) FROM numbers(1000)

Résultat:

┌─topKWeighted(10)(number, number)──────────┐
│ [999,998,997,996,995,994,993,992,991,990] │
└───────────────────────────────────────────┘

covarSamp(x, y)

Calcule la valeur de Σ((x - x̅)(y - y̅)) / (n - 1).

Renvoie Float64. Lorsque n <= 1, returns +∞.

covarPop (x, y)

Calcule la valeur de Σ((x - x̅)(y - y̅)) / n.

corr (x, y)

Calcule le coefficient de corrélation de Pearson: Σ((x - x̅)(y - y̅)) / sqrt(Σ((x - x̅)^2) * Σ((y - y̅)^2)).

categoricalInformationValue

Calcule la valeur de (P(tag = 1) - P(tag = 0))(log(P(tag = 1)) - log(P(tag = 0))) pour chaque catégorie.

categoricalInformationValue(category1, category2, ..., tag)

Le résultat indique comment une caractéristique discrète (catégorique) [category1, category2, ...] contribuer à un modèle d'apprentissage qui prédit la valeur de tag.

simplelineearregression

Effectue une régression linéaire simple (unidimensionnelle).

simpleLinearRegression(x, y)

Paramètre:

• x — Column with dependent variable values.
• y — Column with explanatory variable values.

Valeurs renvoyées:

Constant (a, b) de la ligne y = a*x + b.

Exemple

SELECT arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [0, 1, 2, 3])

┌─arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [0, 1, 2, 3])─┐
│ (1,0)                                                             │
└───────────────────────────────────────────────────────────────────┘

SELECT arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [3, 4, 5, 6])

┌─arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [3, 4, 5, 6])─┐
│ (1,3)                                                             │
└───────────────────────────────────────────────────────────────────┘

stochasticLinearRegression

Cette fonction implémente la régression linéaire stochastique. Il prend en charge les paramètres personnalisés pour le taux d'apprentissage, le coefficient de régularisation L2, la taille de mini-lot et a peu de méthodes pour mettre à jour les poids (Adam (utilisé par défaut), simple SGD, Élan, Nesterov).

Paramètre

Il y a 4 paramètres personnalisables. Ils sont passés à la fonction séquentiellement, mais il n'est pas nécessaire de passer tous les quatre-les valeurs par défaut seront utilisées, mais un bon modèle nécessite un réglage des paramètres.

stochasticLinearRegression(1.0, 1.0, 10, 'SGD')

1. learning rate est le coefficient sur la longueur de l'étape, lorsque l'étape de descente de gradient est effectuée. Un taux d'apprentissage trop élevé peut entraîner des poids infinis du modèle. Par défaut est 0.00001.
2. l2 regularization coefficient ce qui peut aider à éviter le surajustement. Par défaut est 0.1.
3. mini-batch size définit le nombre d'éléments, dont les gradients seront calculés et additionnés pour effectuer une étape de descente de gradient. La descente stochastique Pure utilise un élément, mais avoir de petits lots (environ 10 éléments) rend les étapes de gradient plus stables. Par défaut est 15.
4. method for updating weights ils sont: Adam (par défaut), SGD, Momentum, Nesterov. Momentum et Nesterov nécessitent un peu plus de calculs et de mémoire, mais ils sont utiles en termes de vitesse de convergence et de stabilité des méthodes de gradient stochastique.

Utilisation

stochasticLinearRegression est utilisé en deux étapes: ajustement du modèle et prédiction sur de nouvelles données. Afin de correspondre le modèle et l'enregistrer son état pour utilisation ultérieure nous utilisons -State combinator, qui enregistre essentiellement l'état (poids du modèle, etc.). Pour prédire nous utilisons la fonction evalMLMethod qui prend un état comme un argument ainsi que des fonctionnalités à prévoir sur.

1. Raccord

Une telle requête peut être utilisé.

CREATE TABLE IF NOT EXISTS train_data
(
    param1 Float64,
    param2 Float64,
    target Float64
) ENGINE = Memory;

CREATE TABLE your_model ENGINE = Memory AS SELECT
stochasticLinearRegressionState(0.1, 0.0, 5, 'SGD')(target, param1, param2)
AS state FROM train_data;

Ici, nous devons également insérer des données dans train_data table. Le nombre de paramètres n'est pas fixe, il dépend uniquement du nombre d'arguments, passés dans linearRegressionState. Ils doivent tous être des valeurs numériques. Notez que la colonne avec la valeur cible (que nous aimerions apprendre à prédire) est insérée comme premier argument.

2. Prédire

Après avoir enregistré un État dans la table, nous pouvons l'utiliser plusieurs fois pour la prédiction, ou même fusionner avec d'autres États et créer de nouveaux modèles encore meilleurs.

WITH (SELECT state FROM your_model) AS model SELECT
evalMLMethod(model, param1, param2) FROM test_data

La requête renvoie une colonne de valeurs prédites. Notez que le premier argument de evalMLMethod être AggregateFunctionState objet, sont ensuite des colonnes de fonctionnalités.

test_data est un tableau comme train_data mais peut ne pas contenir de valeur cible.

Note

1. Pour fusionner deux modèles l'utilisateur peut créer une telle requête: sql SELECT state1 + state2 FROM your_models où your_models le tableau contient les deux modèles. Cette requête renvoie la nouvelle AggregateFunctionState objet.

2. L'utilisateur peut récupérer les poids du modèle pour ses propres fins, sans enregistrer le modèle, si aucune -State combinator est utilisé. sql SELECT stochasticLinearRegression(0.01)(target, param1, param2) FROM train_data Une telle requête s'adaptera au Modèle et retournera ses poids-d'abord sont des poids, qui correspondent aux paramètres du modèle, le dernier est un biais. Ainsi, dans l'exemple ci-dessus, la requête renvoie une colonne avec 3 valeurs.

Voir Aussi

• stochasticLogisticRegression
• Différence entre les régressions linéaires et logistiques

stochasticLogisticRegression

Cette fonction implémente la régression logistique stochastique. Il peut être utilisé pour le problème de classification binaire, prend en charge les mêmes paramètres personnalisés que stochasticLinearRegression et fonctionne de la même manière.

Paramètre

Les paramètres sont exactement les mêmes que dans stochasticLinearRegression: learning rate, l2 regularization coefficient, mini-batch size, method for updating weights. Pour plus d'informations, voir paramètre.

stochasticLogisticRegression(1.0, 1.0, 10, 'SGD')

1. Raccord

See the `Fitting` section in the [stochasticLinearRegression](#stochasticlinearregression-usage-fitting) description.

Predicted labels have to be in \[-1, 1\].

1. Prédire

Using saved state we can predict probability of object having label `1`.

``` sql
WITH (SELECT state FROM your_model) AS model SELECT
evalMLMethod(model, param1, param2) FROM test_data
```

The query will return a column of probabilities. Note that first argument of `evalMLMethod` is `AggregateFunctionState` object, next are columns of features.

We can also set a bound of probability, which assigns elements to different labels.

``` sql
SELECT ans < 1.1 AND ans > 0.5 FROM
(WITH (SELECT state FROM your_model) AS model SELECT
evalMLMethod(model, param1, param2) AS ans FROM test_data)
```

Then the result will be labels.

`test_data` is a table like `train_data` but may not contain target value.

Voir Aussi

• stochasticLinearRegression
• Différence entre les régressions linéaires et logistiques.

groupBitmapAnd

Calculs le et d'une colonne bitmap, retour cardinalité de type UInt64, si Ajouter suffixe-État, puis retour objet bitmap.

groupBitmapAnd(expr)

Paramètre

expr – An expression that results in AggregateFunction(groupBitmap, UInt*) type.

Valeur de retour

La valeur de la UInt64 type.

Exemple

DROP TABLE IF EXISTS bitmap_column_expr_test2;
CREATE TABLE bitmap_column_expr_test2
(
    tag_id String,
    z AggregateFunction(groupBitmap, UInt32)
)
ENGINE = MergeTree
ORDER BY tag_id;

INSERT INTO bitmap_column_expr_test2 VALUES ('tag1', bitmapBuild(cast([1,2,3,4,5,6,7,8,9,10] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag2', bitmapBuild(cast([6,7,8,9,10,11,12,13,14,15] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag3', bitmapBuild(cast([2,4,6,8,10,12] as Array(UInt32))));

SELECT groupBitmapAnd(z) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─groupBitmapAnd(z)─┐
│               3   │
└───────────────────┘

SELECT arraySort(bitmapToArray(groupBitmapAndState(z))) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─arraySort(bitmapToArray(groupBitmapAndState(z)))─┐
│ [6,8,10]                                         │
└──────────────────────────────────────────────────┘

groupBitmapOr

Calculs le ou d'une colonne bitmap, retour cardinalité de type UInt64, si Ajouter suffixe-État, puis retour objet bitmap. C'est l'équivalent de groupBitmapMerge.

groupBitmapOr(expr)

Paramètre

expr – An expression that results in AggregateFunction(groupBitmap, UInt*) type.

Valeur de retour

La valeur de la UInt64 type.

Exemple

DROP TABLE IF EXISTS bitmap_column_expr_test2;
CREATE TABLE bitmap_column_expr_test2
(
    tag_id String,
    z AggregateFunction(groupBitmap, UInt32)
)
ENGINE = MergeTree
ORDER BY tag_id;

INSERT INTO bitmap_column_expr_test2 VALUES ('tag1', bitmapBuild(cast([1,2,3,4,5,6,7,8,9,10] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag2', bitmapBuild(cast([6,7,8,9,10,11,12,13,14,15] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag3', bitmapBuild(cast([2,4,6,8,10,12] as Array(UInt32))));

SELECT groupBitmapOr(z) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─groupBitmapOr(z)─┐
│             15   │
└──────────────────┘

SELECT arraySort(bitmapToArray(groupBitmapOrState(z))) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─arraySort(bitmapToArray(groupBitmapOrState(z)))─┐
│ [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]           │
└─────────────────────────────────────────────────┘

groupBitmapXor

Calculs le XOR d'une colonne bitmap, retour cardinalité de type UInt64, si Ajouter suffixe-État, puis retour objet bitmap.

groupBitmapOr(expr)

Paramètre

expr – An expression that results in AggregateFunction(groupBitmap, UInt*) type.

Valeur de retour

La valeur de la UInt64 type.

Exemple

DROP TABLE IF EXISTS bitmap_column_expr_test2;
CREATE TABLE bitmap_column_expr_test2
(
    tag_id String,
    z AggregateFunction(groupBitmap, UInt32)
)
ENGINE = MergeTree
ORDER BY tag_id;

INSERT INTO bitmap_column_expr_test2 VALUES ('tag1', bitmapBuild(cast([1,2,3,4,5,6,7,8,9,10] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag2', bitmapBuild(cast([6,7,8,9,10,11,12,13,14,15] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag3', bitmapBuild(cast([2,4,6,8,10,12] as Array(UInt32))));

SELECT groupBitmapXor(z) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─groupBitmapXor(z)─┐
│              10   │
└───────────────────┘

SELECT arraySort(bitmapToArray(groupBitmapXorState(z))) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─arraySort(bitmapToArray(groupBitmapXorState(z)))─┐
│ [1,3,5,6,8,10,11,13,14,15]                       │
└──────────────────────────────────────────────────┘

Article Original