Referencia de función agregada 

contar 

Cuenta el número de filas o valores no NULL.

ClickHouse admite las siguientes sintaxis para count:
- count(expr) o COUNT(DISTINCT expr).
- count() o COUNT(*). El count() la sintaxis es específica de ClickHouse.

Parámetros

La función puede tomar:

Valor devuelto

  • Si se llama a la función sin parámetros, cuenta el número de filas.
  • Si el expresion se pasa, entonces la función cuenta cuántas veces esta expresión devuelve no nula. Si la expresión devuelve un NULL-type valor, entonces el resultado de count no se queda Nullable. La función devuelve 0 si la expresión devuelta NULL para todas las filas.

En ambos casos el tipo del valor devuelto es UInt64.

Detalles

ClickHouse soporta el COUNT(DISTINCT ...) sintaxis. El comportamiento de esta construcción depende del count_distinct_implementation configuración. Define cuál de las uniq* se utiliza para realizar la operación. El valor predeterminado es el uniqExact función.

El SELECT count() FROM table consulta no está optimizado, porque el número de entradas en la tabla no se almacena por separado. Elige una pequeña columna de la tabla y cuenta el número de valores en ella.

Ejemplos

Ejemplo 1:

SELECT count() FROM t
┌─count()─┐
│       5 │
└─────────┘

Ejemplo 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 │
└────────────────┘

Este ejemplo muestra que count(DISTINCT num) se realiza por el uniqExact función según el count_distinct_implementation valor de ajuste.

cualquiera (x) 

Selecciona el primer valor encontrado.
La consulta se puede ejecutar en cualquier orden e incluso en un orden diferente cada vez, por lo que el resultado de esta función es indeterminado.
Para obtener un resultado determinado, puede usar el ‘min’ o ‘max’ función en lugar de ‘any’.

En algunos casos, puede confiar en el orden de ejecución. Esto se aplica a los casos en que SELECT proviene de una subconsulta que usa ORDER BY.

Cuando un SELECT consulta tiene el GROUP BY cláusula o al menos una función agregada, ClickHouse (en contraste con MySQL) requiere que todas las expresiones SELECT, HAVING, y ORDER BY las cláusulas pueden calcularse a partir de claves o de funciones agregadas. En otras palabras, cada columna seleccionada de la tabla debe usarse en claves o dentro de funciones agregadas. Para obtener un comportamiento como en MySQL, puede colocar las otras columnas en el any función de agregado.

Cualquier pesado (x) 

Selecciona un valor que ocurre con frecuencia pesos pesados algoritmo. Si hay un valor que se produce más de la mitad de los casos en cada uno de los subprocesos de ejecución de la consulta, se devuelve este valor. Normalmente, el resultado es no determinista.

anyHeavy(column)

Argumento

  • column – The column name.

Ejemplo

Tome el A tiempo conjunto de datos y seleccione cualquier valor que ocurra con frecuencia AirlineID columna.

SELECT anyHeavy(AirlineID) AS res
FROM ontime
┌───res─┐
│ 19690 │
└───────┘

Cualquier último (x) 

Selecciona el último valor encontrado.
El resultado es tan indeterminado como para el any función.

Método de codificación de datos: 

Se aplica bit a bit AND para la serie de números.

groupBitAnd(expr)

Parámetros

expr – An expression that results in UInt* tipo.

Valor de retorno

Valor de la UInt* tipo.

Ejemplo

Datos de prueba:

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

Consulta:

SELECT groupBitAnd(num) FROM t

Donde num es la columna con los datos de prueba.

Resultado:

binary     decimal
00000100 = 4

GrupoBitO 

Se aplica bit a bit OR para la serie de números.

groupBitOr(expr)

Parámetros

expr – An expression that results in UInt* tipo.

Valor de retorno

Valor de la UInt* tipo.

Ejemplo

Datos de prueba:

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

Consulta:

SELECT groupBitOr(num) FROM t

Donde num es la columna con los datos de prueba.

Resultado:

binary     decimal
01111101 = 125

GrupoBitXor 

Se aplica bit a bit XOR para la serie de números.

groupBitXor(expr)

Parámetros

expr – An expression that results in UInt* tipo.

Valor de retorno

Valor de la UInt* tipo.

Ejemplo

Datos de prueba:

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

Consulta:

SELECT groupBitXor(num) FROM t

Donde num es la columna con los datos de prueba.

Resultado:

binary     decimal
01101000 = 104

Método de codificación de datos: 

Mapa de bits o cálculos agregados de una columna entera sin signo, devuelve cardinalidad de tipo UInt64, si agrega el sufijo -State, luego devuelve objeto de mapa de bits.

groupBitmap(expr)

Parámetros

expr – An expression that results in UInt* tipo.

Valor de retorno

Valor de la UInt64 tipo.

Ejemplo

Datos de prueba:

UserID
1
1
2
3

Consulta:

SELECT groupBitmap(UserID) as num FROM t

Resultado:

num
3

Mínimo (x) 

Calcula el mínimo.

máximo (x) 

Calcula el máximo.

¿Cómo puedo hacerlo?) 

Calcula el ‘arg’ para un valor mínimo ‘val’ valor. Si hay varios valores diferentes de ‘arg’ para valores mínimos de ‘val’, el primero de estos valores encontrados es la salida.

Ejemplo:

┌─user─────┬─salary─┐
│ director │   5000 │
│ manager  │   3000 │
│ worker   │   1000 │
└──────────┴────────┘
SELECT argMin(user, salary) FROM salary
┌─argMin(user, salary)─┐
│ worker               │
└──────────────────────┘

Descripción) 

Calcula el ‘arg’ para un valor máximo ‘val’ valor. Si hay varios valores diferentes de ‘arg’ para valores máximos de ‘val’, el primero de estos valores encontrados es la salida.

suma (x) 

Calcula la suma.
Solo funciona para números.

¿Cómo puedo obtener más información?) 

Calcula la suma de los números, utilizando el mismo tipo de datos para el resultado que para los parámetros de entrada. Si la suma supera el valor máximo para este tipo de datos, la función devuelve un error.

Solo funciona para números.

Por ejemplo, el valor es el siguiente:)) 

Totals el ‘value’ matriz de acuerdo con las claves especificadas en el ‘key’ matriz.
Pasar una tupla de matrices de claves y valores es sinónimo de pasar dos matrices de claves y valores.
El número de elementos en ‘key’ y ‘value’ debe ser el mismo para cada fila que se sume.
Returns a tuple of two arrays: keys in sorted order, and values ​​summed for the corresponding keys.

Ejemplo:

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

SELECT
    timeslot,
    sumMap(statusMap.status, statusMap.requests),
    sumMap(statusMapTuple)
FROM sum_map
GROUP BY timeslot
┌────────────timeslot─┬─sumMap(statusMap.status, statusMap.requests)─┬─sumMap(statusMapTuple)─────────┐
│ 2000-01-01 00:00:00 │ ([1,2,3,4,5],[10,10,20,10,10])               │ ([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])               │ ([4,5,6,7,8],[10,10,20,10,10]) │
└─────────────────────┴──────────────────────────────────────────────┴────────────────────────────────┘

SkewPop 

Calcula el la asimetría de una secuencia.

skewPop(expr)

Parámetros

exprExpresion devolviendo un número.

Valor devuelto

The skewness of the given distribution. Type — Float64

Ejemplo

SELECT skewPop(value) FROM series_with_value_column

Sistema abierto 

Calcula el asimetría de la muestra de una secuencia.

Representa una estimación imparcial de la asimetría de una variable aleatoria si los valores pasados forman su muestra.

skewSamp(expr)

Parámetros

exprExpresion devolviendo un número.

Valor devuelto

The skewness of the given distribution. Type — Float64. Si n <= 1 (n es el tamaño de la muestra), luego la función devuelve nan.

Ejemplo

SELECT skewSamp(value) FROM series_with_value_column

KurtPop 

Calcula el curtosis de una secuencia.

kurtPop(expr)

Parámetros

exprExpresion devolviendo un número.

Valor devuelto

The kurtosis of the given distribution. Type — Float64

Ejemplo

SELECT kurtPop(value) FROM series_with_value_column

KurtSamp 

Calcula el curtosis muestra de una secuencia.

Representa una estimación imparcial de la curtosis de una variable aleatoria si los valores pasados forman su muestra.

kurtSamp(expr)

Parámetros

exprExpresion devolviendo un número.

Valor devuelto

The kurtosis of the given distribution. Type — Float64. Si n <= 1 (n es un tamaño de la muestra), luego la función devuelve nan.

Ejemplo

SELECT kurtSamp(value) FROM series_with_value_column

Para obtener más información, consulta nuestra Política de privacidad y nuestras Condiciones de uso) 

timeSeriesGroupSum puede agregar diferentes series de tiempo que muestran la marca de tiempo no la alineación.
Utilizará la interpolación lineal entre dos marcas de tiempo de muestra y luego sumará series temporales juntas.

  • uid es la identificación única de la serie temporal, UInt64.
  • timestamp es el tipo Int64 para admitir milisegundos o microsegundos.
  • value es la métrica.

La función devuelve una matriz de tuplas con (timestamp, aggregated_value) par.

Antes de utilizar esta función, asegúrese de timestamp está en orden ascendente.

Ejemplo:

┌─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
);

Y el resultado será:

[(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)]

También puede utilizar el siguiente ejemplo:) 

De manera similar a timeSeriesGroupSum, timeSeriesGroupRateSum calcula la tasa de series temporales y luego suma las tasas juntas.
Además, la marca de tiempo debe estar en orden ascendente antes de usar esta función.

Aplicando esta función a los datos del timeSeriesGroupSum ejemplo, se obtiene el siguiente resultado:

[(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)]

Acerca de) 

Calcula el promedio.
Solo funciona para números.
El resultado es siempre Float64.

avgPonderado 

Calcula el media aritmética ponderada.

Sintaxis

avgWeighted(x, weight)

Parámetros

Tipo de x y weight debe ser el mismo.

Valor devuelto

  • Media ponderada.
  • NaN. Si todos los pesos son iguales a 0.

Tipo: Float64.

Ejemplo

Consulta:

SELECT avgWeighted(x, w)
FROM values('x Int8, w Int8', (4, 1), (1, 0), (10, 2))

Resultado:

┌─avgWeighted(x, weight)─┐
│                      8 │
└────────────────────────┘

uniq 

Calcula el número aproximado de diferentes valores del argumento.

uniq(x[, ...])

Parámetros

La función toma un número variable de parámetros. Los parámetros pueden ser Tuple, Array, Date, DateTime, String, o tipos numéricos.

Valor devuelto

Detalles de implementación

Función:

  • Calcula un hash para todos los parámetros en el agregado, luego lo usa en los cálculos.

  • Utiliza un algoritmo de muestreo adaptativo. Para el estado de cálculo, la función utiliza una muestra de valores hash de elemento de hasta 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.
    
  • Proporciona el resultado de forma determinista (no depende del orden de procesamiento de la consulta).

Recomendamos usar esta función en casi todos los escenarios.

Ver también

uniqCombined 

Calcula el número aproximado de diferentes valores de argumento.

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

El uniqCombined es una buena opción para calcular el número de valores diferentes.

Parámetros

La función toma un número variable de parámetros. Los parámetros pueden ser Tuple, Array, Date, DateTime, String, o tipos numéricos.

HLL_precision es el logaritmo base-2 del número de células en HyperLogLog. Opcional, puede utilizar la función como uniqCombined(x[, ...]). El valor predeterminado para HLL_precision es 17, que es efectivamente 96 KiB de espacio (2 ^ 17 celdas, 6 bits cada una).

Valor devuelto

Detalles de implementación

Función:

  • Calcula un hash (hash de 64 bits para String y 32 bits de lo contrario) para todos los parámetros en el agregado, luego lo usa en los cálculos.

  • Utiliza una combinación de tres algoritmos: matriz, tabla hash e HyperLogLog con una tabla de corrección de errores.

    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.
    
  • Proporciona el resultado de forma determinista (no depende del orden de procesamiento de la consulta).

En comparación con el uniq función, el uniqCombined:

  • Consume varias veces menos memoria.
  • Calcula con una precisión varias veces mayor.
  • Por lo general, tiene un rendimiento ligeramente menor. En algunos escenarios, uniqCombined puede funcionar mejor que uniq, por ejemplo, con consultas distribuidas que transmiten un gran número de estados de agregación a través de la red.

Ver también

UniqCombined64 

Lo mismo que uniqCombined, pero utiliza hash de 64 bits para todos los tipos de datos.

uniqHLL12 

Calcula el número aproximado de diferentes valores de argumento HyperLogLog algoritmo.

uniqHLL12(x[, ...])

Parámetros

La función toma un número variable de parámetros. Los parámetros pueden ser Tuple, Array, Date, DateTime, String, o tipos numéricos.

Valor devuelto

Detalles de implementación

Función:

  • Calcula un hash para todos los parámetros en el agregado, luego lo usa en los cálculos.

  • Utiliza el algoritmo HyperLogLog para aproximar el número de valores de argumento diferentes.

    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).
    
  • Proporciona el resultado determinado (no depende del orden de procesamiento de la consulta).

No recomendamos usar esta función. En la mayoría de los casos, use el uniq o uniqCombined función.

Ver también

uniqExact 

Calcula el número exacto de diferentes valores de argumento.

uniqExact(x[, ...])

Utilice el uniqExact función si necesita absolutamente un resultado exacto. De lo contrario, use el uniq función.

El uniqExact función utiliza más memoria que uniq, porque el tamaño del estado tiene un crecimiento ilimitado a medida que aumenta el número de valores diferentes.

Parámetros

La función toma un número variable de parámetros. Los parámetros pueden ser Tuple, Array, Date, DateTime, String, o tipos numéricos.

Ver también

¿Cómo puedo hacerlo?) 

Crea una matriz de valores de argumento.
Los valores se pueden agregar a la matriz en cualquier orden (indeterminado).

La segunda versión (con el max_size parámetro) limita el tamaño de la matriz resultante a max_size elemento.
Por ejemplo, groupArray (1) (x) es equivalente a [any (x)].

En algunos casos, aún puede confiar en el orden de ejecución. Esto se aplica a los casos en que SELECT procede de una subconsulta que utiliza ORDER BY.

GrupoArrayInsertAt 

Inserta un valor en la matriz en la posición especificada.

Sintaxis

groupArrayInsertAt(default_x, size)(x, pos);

Si en una consulta se insertan varios valores en la misma posición, la función se comporta de las siguientes maneras:

  • Si se ejecuta una consulta en un solo subproceso, se utiliza el primero de los valores insertados.
  • Si una consulta se ejecuta en varios subprocesos, el valor resultante es uno indeterminado de los valores insertados.

Parámetros

  • x — Value to be inserted. Expresion lo que resulta en uno de los tipos de datos compatibles.
  • pos — Position at which the specified element x se va a insertar. La numeración de índices en la matriz comienza desde cero. UInt32.
  • default_x— Default value for substituting in empty positions. Optional parameter. Expresion dando como resultado el tipo de datos configurado para x parámetro. Si default_x no está definido, el valores predeterminados se utilizan.
  • size— Length of the resulting array. Optional parameter. When using this parameter, the default value default_x debe ser especificado. UInt32.

Valor devuelto

  • Matriz con valores insertados.

Tipo: Matriz.

Ejemplo

Consulta:

SELECT groupArrayInsertAt(toString(number), number * 2) FROM numbers(5);

Resultado:

┌─groupArrayInsertAt(toString(number), multiply(number, 2))─┐
│ ['0','','1','','2','','3','','4']                         │
└───────────────────────────────────────────────────────────┘

Consulta:

SELECT groupArrayInsertAt('-')(toString(number), number * 2) FROM numbers(5);

Resultado:

┌─groupArrayInsertAt('-')(toString(number), multiply(number, 2))─┐
│ ['0','-','1','-','2','-','3','-','4']                          │
└────────────────────────────────────────────────────────────────┘

Consulta:

SELECT groupArrayInsertAt('-', 5)(toString(number), number * 2) FROM numbers(5);

Resultado:

┌─groupArrayInsertAt('-', 5)(toString(number), multiply(number, 2))─┐
│ ['0','-','1','-','2']                                             │
└───────────────────────────────────────────────────────────────────┘

Inserción multihilo de elementos en una posición.

Consulta:

SELECT groupArrayInsertAt(number, 0) FROM numbers_mt(10) SETTINGS max_block_size = 1;

Como resultado de esta consulta, obtiene un entero aleatorio en el [0,9] gama. Por ejemplo:

┌─groupArrayInsertAt(number, 0)─┐
│ [7]                           │
└───────────────────────────────┘

groupArrayMovingSum 

Calcula la suma móvil de los valores de entrada.

groupArrayMovingSum(numbers_for_summing)
groupArrayMovingSum(window_size)(numbers_for_summing)

La función puede tomar el tamaño de la ventana como un parámetro. Si no se especifica, la función toma el tamaño de ventana igual al número de filas de la columna.

Parámetros

  • numbers_for_summingExpresion dando como resultado un valor de tipo de datos numérico.
  • window_size — Size of the calculation window.

Valores devueltos

  • Matriz del mismo tamaño y tipo que los datos de entrada.

Ejemplo

La tabla de ejemplo:

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 │
└─────┴───────┴──────┘

Consulta:

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] │
└────────────┴─────────────────────────────────┴────────────────────────┘

Método de codificación de datos: 

Calcula la media móvil de los valores de entrada.

groupArrayMovingAvg(numbers_for_summing)
groupArrayMovingAvg(window_size)(numbers_for_summing)

La función puede tomar el tamaño de la ventana como un parámetro. Si no se especifica, la función toma el tamaño de ventana igual al número de filas de la columna.

Parámetros

  • numbers_for_summingExpresion dando como resultado un valor de tipo de datos numérico.
  • window_size — Size of the calculation window.

Valores devueltos

  • Matriz del mismo tamaño y tipo que los datos de entrada.

La función utiliza redondeando hacia cero. Trunca los decimales insignificantes para el tipo de datos resultante.

Ejemplo

La tabla de ejemplo 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 │
└─────┴───────┴──────┘

Consulta:

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] │
└───────────┴──────────────────────────────────┴───────────────────────┘

¿Cómo puedo obtener más información?) 

Crea una matriz a partir de diferentes valores de argumento. El consumo de memoria es el mismo que para el uniqExact función.

La segunda versión (con el max_size parámetro) limita el tamaño de la matriz resultante a max_size elemento.
Por ejemplo, groupUniqArray(1)(x) es equivalente a [any(x)].

cuantil 

Calcula un aproximado cuantil de una secuencia de datos numéricos.

Esta función se aplica muestreo de embalses con un tamaño de depósito de hasta 8192 y un generador de números aleatorios para el muestreo. El resultado es no determinista. Para obtener un cuantil exacto, use el quantileExact función.

Cuando se utilizan múltiples quantile* funciones con diferentes niveles en una consulta, los estados internos no se combinan (es decir, la consulta funciona de manera menos eficiente de lo que podría). En este caso, use el cantiles función.

Sintaxis

quantile(level)(expr)

Apodo: median.

Parámetros

  • level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level valor en el rango de [0.01, 0.99]. Valor predeterminado: 0.5. En level=0.5 la función calcula mediana.
  • expr — Expression over the column values resulting in numeric tipos de datos, Fecha o FechaHora.

Valor devuelto

  • Cuantil aproximado del nivel especificado.

Tipo:

  • Float64 para la entrada de tipo de datos numéricos.
  • Fecha si los valores de entrada tienen Date tipo.
  • FechaHora si los valores de entrada tienen DateTime tipo.

Ejemplo

Tabla de entrada:

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

Consulta:

SELECT quantile(val) FROM t

Resultado:

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

Ver también

quantileDeterminista 

Calcula un aproximado cuantil de una secuencia de datos numéricos.

Esta función se aplica muestreo de embalses con un tamaño de depósito de hasta 8192 y algoritmo determinista de muestreo. El resultado es determinista. Para obtener un cuantil exacto, use el quantileExact función.

Cuando se utilizan múltiples quantile* funciones con diferentes niveles en una consulta, los estados internos no se combinan (es decir, la consulta funciona de manera menos eficiente de lo que podría). En este caso, use el cantiles función.

Sintaxis

quantileDeterministic(level)(expr, determinator)

Apodo: medianDeterministic.

Parámetros

  • level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level valor en el rango de [0.01, 0.99]. Valor predeterminado: 0.5. En level=0.5 la función calcula mediana.
  • expr — Expression over the column values resulting in numeric tipos de datos, Fecha o FechaHora.
  • 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.

Valor devuelto

  • Cuantil aproximado del nivel especificado.

Tipo:

  • Float64 para la entrada de tipo de datos numéricos.
  • Fecha si los valores de entrada tienen Date tipo.
  • FechaHora si los valores de entrada tienen DateTime tipo.

Ejemplo

Tabla de entrada:

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

Consulta:

SELECT quantileDeterministic(val, 1) FROM t

Resultado:

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

Ver también

quantileExact 

Calcula exactamente el cuantil de una secuencia de datos numéricos.

To get exact value, all the passed values ​​are combined into an array, which is then partially sorted. Therefore, the function consumes O(n) memoria, donde n es un número de valores que se pasaron. Sin embargo, para un pequeño número de valores, la función es muy efectiva.

Cuando se utilizan múltiples quantile* funciones con diferentes niveles en una consulta, los estados internos no se combinan (es decir, la consulta funciona de manera menos eficiente de lo que podría). En este caso, use el cantiles función.

Sintaxis

quantileExact(level)(expr)

Apodo: medianExact.

Parámetros

  • level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level valor en el rango de [0.01, 0.99]. Valor predeterminado: 0.5. En level=0.5 la función calcula mediana.
  • expr — Expression over the column values resulting in numeric tipos de datos, Fecha o FechaHora.

Valor devuelto

  • Cuantil del nivel especificado.

Tipo:

  • Float64 para la entrada de tipo de datos numéricos.
  • Fecha si los valores de entrada tienen Date tipo.
  • FechaHora si los valores de entrada tienen DateTime tipo.

Ejemplo

Consulta:

SELECT quantileExact(number) FROM numbers(10)

Resultado:

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

Ver también

quantileExactWeighted 

Calcula exactamente el cuantil de una secuencia de datos numéricos, teniendo en cuenta el peso de cada elemento.

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. Puede usar esta función en lugar de quantileExact y especifique el peso 1.

Cuando se utilizan múltiples quantile* funciones con diferentes niveles en una consulta, los estados internos no se combinan (es decir, la consulta funciona de manera menos eficiente de lo que podría). En este caso, use el cantiles función.

Sintaxis

quantileExactWeighted(level)(expr, weight)

Apodo: medianExactWeighted.

Parámetros

  • level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level valor en el rango de [0.01, 0.99]. Valor predeterminado: 0.5. En level=0.5 la función calcula mediana.
  • expr — Expression over the column values resulting in numeric tipos de datos, Fecha o FechaHora.
  • weight — Column with weights of sequence members. Weight is a number of value occurrences.

Valor devuelto

  • Cuantil del nivel especificado.

Tipo:

  • Float64 para la entrada de tipo de datos numéricos.
  • Fecha si los valores de entrada tienen Date tipo.
  • FechaHora si los valores de entrada tienen DateTime tipo.

Ejemplo

Tabla de entrada:

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

Consulta:

SELECT quantileExactWeighted(n, val) FROM t

Resultado:

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

Ver también

quantileTiming 

Con la precisión determinada calcula el cuantil de una secuencia de datos numéricos.

El resultado es determinista (no depende del orden de procesamiento de la consulta). La función está optimizada para trabajar con secuencias que describen distribuciones como tiempos de carga de páginas web o tiempos de respuesta de back-end.

Cuando se utilizan múltiples quantile* funciones con diferentes niveles en una consulta, los estados internos no se combinan (es decir, la consulta funciona de manera menos eficiente de lo que podría). En este caso, use el cantiles función.

Sintaxis

quantileTiming(level)(expr)

Apodo: medianTiming.

Parámetros

  • level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level valor en el rango de [0.01, 0.99]. Valor predeterminado: 0.5. En level=0.5 la función calcula mediana.

  • exprExpresion sobre una columna valores que devuelven un Flotante*-tipo número.

    - 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.
    

Exactitud

El cálculo es preciso si:

  • El número total de valores no supera los 5670.
  • El número total de valores supera los 5670, pero el tiempo de carga de la página es inferior a 1024 ms.

De lo contrario, el resultado del cálculo se redondea al múltiplo más cercano de 16 ms.

Valor devuelto

  • Cuantil del nivel especificado.

Tipo: Float32.

Ejemplo

Tabla de entrada:

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

Consulta:

SELECT quantileTiming(response_time) FROM t

Resultado:

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

Ver también

quantileTimingWeighted 

Con la precisión determinada calcula el cuantil de una secuencia de datos numéricos según el peso de cada miembro de secuencia.

El resultado es determinista (no depende del orden de procesamiento de la consulta). La función está optimizada para trabajar con secuencias que describen distribuciones como tiempos de carga de páginas web o tiempos de respuesta de back-end.

Cuando se utilizan múltiples quantile* funciones con diferentes niveles en una consulta, los estados internos no se combinan (es decir, la consulta funciona de manera menos eficiente de lo que podría). En este caso, use el cantiles función.

Sintaxis

quantileTimingWeighted(level)(expr, weight)

Apodo: medianTimingWeighted.

Parámetros

  • level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level valor en el rango de [0.01, 0.99]. Valor predeterminado: 0.5. En level=0.5 la función calcula mediana.

  • exprExpresion sobre una columna valores que devuelven un Flotante*-tipo número.

    - 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.

Exactitud

El cálculo es preciso si:

  • El número total de valores no supera los 5670.
  • El número total de valores supera los 5670, pero el tiempo de carga de la página es inferior a 1024 ms.

De lo contrario, el resultado del cálculo se redondea al múltiplo más cercano de 16 ms.

Valor devuelto

  • Cuantil del nivel especificado.

Tipo: Float32.

Ejemplo

Tabla de entrada:

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

Consulta:

SELECT quantileTimingWeighted(response_time, weight) FROM t

Resultado:

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

Ver también

quantileTDigest 

Calcula un aproximado cuantil de una secuencia de datos numéricos usando el T-digest algoritmo.

El error máximo es 1%. El consumo de memoria es log(n), donde n es un número de valores. El resultado depende del orden de ejecución de la consulta y no es determinista.

El rendimiento de la función es menor que el rendimiento de cuantil o quantileTiming. En términos de la relación entre el tamaño del estado y la precisión, esta función es mucho mejor que quantile.

Cuando se utilizan múltiples quantile* funciones con diferentes niveles en una consulta, los estados internos no se combinan (es decir, la consulta funciona de manera menos eficiente de lo que podría). En este caso, use el cantiles función.

Sintaxis

quantileTDigest(level)(expr)

Apodo: medianTDigest.

Parámetros

  • level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level valor en el rango de [0.01, 0.99]. Valor predeterminado: 0.5. En level=0.5 la función calcula mediana.
  • expr — Expression over the column values resulting in numeric tipos de datos, Fecha o FechaHora.

Valor devuelto

  • Cuantil aproximado del nivel especificado.

Tipo:

  • Float64 para la entrada de tipo de datos numéricos.
  • Fecha si los valores de entrada tienen Date tipo.
  • FechaHora si los valores de entrada tienen DateTime tipo.

Ejemplo

Consulta:

SELECT quantileTDigest(number) FROM numbers(10)

Resultado:

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

Ver también

quantileTDigestWeighted 

Calcula un aproximado cuantil de una secuencia de datos numéricos usando el T-digest algoritmo. La función tiene en cuenta el peso de cada miembro de secuencia. El error máximo es 1%. El consumo de memoria es log(n), donde n es un número de valores.

El rendimiento de la función es menor que el rendimiento de cuantil o quantileTiming. En términos de la relación entre el tamaño del estado y la precisión, esta función es mucho mejor que quantile.

El resultado depende del orden de ejecución de la consulta y no es determinista.

Cuando se utilizan múltiples quantile* funciones con diferentes niveles en una consulta, los estados internos no se combinan (es decir, la consulta funciona de manera menos eficiente de lo que podría). En este caso, use el cantiles función.

Sintaxis

quantileTDigest(level)(expr)

Apodo: medianTDigest.

Parámetros

  • level — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a level valor en el rango de [0.01, 0.99]. Valor predeterminado: 0.5. En level=0.5 la función calcula mediana.
  • expr — Expression over the column values resulting in numeric tipos de datos, Fecha o FechaHora.
  • weight — Column with weights of sequence elements. Weight is a number of value occurrences.

Valor devuelto

  • Cuantil aproximado del nivel especificado.

Tipo:

  • Float64 para la entrada de tipo de datos numéricos.
  • Fecha si los valores de entrada tienen Date tipo.
  • FechaHora si los valores de entrada tienen DateTime tipo.

Ejemplo

Consulta:

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

Resultado:

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

Ver también

mediana 

El median* funciones son los alias para el quantile* función. Calculan la mediana de una muestra de datos numéricos.

Función:

Ejemplo

Tabla de entrada:

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

Consulta:

SELECT medianDeterministic(val, 1) FROM t

Resultado:

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

quantiles(level1, level2, …)(x) 

Todas las funciones de cuantiles también tienen funciones de cuantiles correspondientes: quantiles, quantilesDeterministic, quantilesTiming, quantilesTimingWeighted, quantilesExact, quantilesExactWeighted, quantilesTDigest. Estas funciones calculan todos los cuantiles de los niveles enumerados en una sola pasada y devuelven una matriz de los valores resultantes.

Acerca de Nosotros) 

Calcula la cantidad Σ((x - x̅)^2) / (n - 1), donde n es el tamaño de la muestra y es el valor promedio de x.

Representa una estimación imparcial de la varianza de una variable aleatoria si los valores pasados forman su muestra.

Devoluciones Float64. Cuando n <= 1, devoluciones +∞.

Nombre de la red inalámbrica (SSID):) 

Calcula la cantidad Σ((x - x̅)^2) / n, donde n es el tamaño de la muestra y es el valor promedio de x.

En otras palabras, dispersión para un conjunto de valores. Devoluciones Float64.

Soporte técnico) 

El resultado es igual a la raíz cuadrada de varSamp(x).

stddevPop(x) 

El resultado es igual a la raíz cuadrada de varPop(x).

topK(N)(x) 

Devuelve una matriz de los valores aproximadamente más frecuentes de la columna especificada. La matriz resultante se ordena en orden descendente de frecuencia aproximada de valores (no por los valores mismos).

Implementa el Ahorro de espacio filtrado algoritmo para analizar TopK, basado en el algoritmo de reducción y combinación de Ahorro de espacio paralelo.

topK(N)(column)

Esta función no proporciona un resultado garantizado. En ciertas situaciones, pueden producirse errores y pueden devolver valores frecuentes que no son los valores más frecuentes.

Recomendamos usar el N < 10 valor; el rendimiento se reduce con grandes N valor. Valor máximo de N = 65536.

Parámetros

  • ‘N’ es el número de elementos a devolver.

Si se omite el parámetro, se utiliza el valor predeterminado 10.

Argumento

  • ' x ' – The value to calculate frequency.

Ejemplo

Tome el A tiempo conjunto de datos y seleccione los tres valores más frecuentes AirlineID columna.

SELECT topK(3)(AirlineID) AS res
FROM ontime
┌─res─────────────────┐
│ [19393,19790,19805] │
└─────────────────────┘

topKPeso 

Similar a topK pero toma un argumento adicional de tipo entero - weight. Cada valor se contabiliza weight veces para el cálculo de la frecuencia.

Sintaxis

topKWeighted(N)(x, weight)

Parámetros

  • N — The number of elements to return.

Argumento

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

Valor devuelto

Devuelve una matriz de los valores con la suma aproximada máxima de pesos.

Ejemplo

Consulta:

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

Resultado:

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

covarSamp(x, y) 

Calcula el valor de Σ((x - x̅)(y - y̅)) / (n - 1).

Devuelve Float64. Cuando n <= 1, returns +∞.

covarPop(x, y) 

Calcula el valor de Σ((x - x̅)(y - y̅)) / n.

corr(x, y) 

Calcula el coeficiente de correlación de Pearson: Σ((x - x̅)(y - y̅)) / sqrt(Σ((x - x̅)^2) * Σ((y - y̅)^2)).

categoricalInformationValue 

Calcula el valor de (P(tag = 1) - P(tag = 0))(log(P(tag = 1)) - log(P(tag = 0))) para cada categoría.

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

El resultado indica cómo una característica discreta (categórica [category1, category2, ...] contribuir a un modelo de aprendizaje que predice el valor de tag.

SimpleLinearRegression 

Realiza una regresión lineal simple (unidimensional).

simpleLinearRegression(x, y)

Parámetros:

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

Valores devueltos:

Constante (a, b) de la línea resultante y = a*x + b.

Ejemplos

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 

Esta función implementa la regresión lineal estocástica. Admite parámetros personalizados para la tasa de aprendizaje, el coeficiente de regularización L2, el tamaño de mini lote y tiene pocos métodos para actualizar los pesos (Adán (utilizado por defecto), SGD simple, Impulso, Nesterov).

Parámetros 

Hay 4 parámetros personalizables. Se pasan a la función secuencialmente, pero no es necesario pasar los cuatro; se usarán valores predeterminados, sin embargo, un buen modelo requirió algún ajuste de parámetros.

stochasticLinearRegression(1.0, 1.0, 10, 'SGD')
  1. learning rate es el coeficiente en la longitud del paso, cuando se realiza el paso de descenso de gradiente. Una tasa de aprendizaje demasiado grande puede causar pesos infinitos del modelo. El valor predeterminado es 0.00001.
  2. l2 regularization coefficient que puede ayudar a prevenir el sobreajuste. El valor predeterminado es 0.1.
  3. mini-batch size establece el número de elementos, cuyos gradientes se calcularán y sumarán para realizar un paso de descenso de gradiente. El descenso estocástico puro usa un elemento, sin embargo, tener lotes pequeños (aproximadamente 10 elementos) hace que los pasos de gradiente sean más estables. El valor predeterminado es 15.
  4. method for updating weights, son: Adam (predeterminada), SGD, Momentum, Nesterov. Momentum y Nesterov requieren un poco más de cálculos y memoria, sin embargo, resultan útiles en términos de velocidad de convergencia y estabilidad de los métodos de gradiente estocásticos.

Uso 

stochasticLinearRegression se utiliza en dos pasos: ajustar el modelo y predecir nuevos datos. Para ajustar el modelo y guardar su estado para su uso posterior, utilizamos -State combinador, que básicamente guarda el estado (pesos del modelo, etc.).
Para predecir usamos la función evalMLMethod, que toma un estado como argumento, así como características para predecir.

1. Accesorio

Dicha consulta puede ser utilizada.

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;

Aquí también tenemos que insertar datos en train_data tabla. El número de parámetros no es fijo, depende solo del número de argumentos, pasados a linearRegressionState. Todos deben ser valores numéricos.
Tenga en cuenta que la columna con valor objetivo (que nos gustaría aprender a predecir) se inserta como primer argumento.

2. Predecir

Después de guardar un estado en la tabla, podemos usarlo varias veces para la predicción, o incluso fusionarlo con otros estados y crear nuevos modelos aún mejores.

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

La consulta devolverá una columna de valores predichos. Tenga en cuenta que el primer argumento de evalMLMethod ser AggregateFunctionState objeto, siguiente son columnas de características.

test_data es una mesa como train_data pero puede no contener el valor objetivo.

Nota 

  1. Para fusionar dos modelos, el usuario puede crear dicha consulta:
    sql SELECT state1 + state2 FROM your_models
    donde your_models la tabla contiene ambos modelos. Esta consulta devolverá un nuevo AggregateFunctionState objeto.

  2. El usuario puede obtener pesos del modelo creado para sus propios fines sin guardar el modelo si no -State combinador se utiliza.
    sql SELECT stochasticLinearRegression(0.01)(target, param1, param2) FROM train_data
    Dicha consulta se ajustará al modelo y devolverá sus pesos: primero son los pesos, que corresponden a los parámetros del modelo, el último es el sesgo. Entonces, en el ejemplo anterior, la consulta devolverá una columna con 3 valores.

Ver también

stochasticLogisticRegression 

Esta función implementa la regresión logística estocástica. Se puede usar para problemas de clasificación binaria, admite los mismos parámetros personalizados que stochasticLinearRegression y funciona de la misma manera.

Parámetros 

Los parámetros son exactamente los mismos que en stochasticLinearRegression:
learning rate, l2 regularization coefficient, mini-batch size, method for updating weights.
Para obtener más información, consulte parámetros.

stochasticLogisticRegression(1.0, 1.0, 10, 'SGD')
  1. Accesorio
See the `Fitting` section in the [stochasticLinearRegression](#stochasticlinearregression-usage-fitting) description.

Predicted labels have to be in \[-1, 1\].
  1. Predecir
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.

Ver también

Método de codificación de datos: 

Calcula el AND de una columna de mapa de bits, devuelve la cardinalidad del tipo UInt64, si agrega el sufijo -State, luego devuelve objeto de mapa de bits.

groupBitmapAnd(expr)

Parámetros

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

Valor de retorno

Valor de la UInt64 tipo.

Ejemplo

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]                                         
└──────────────────────────────────────────────────┘

Método de codificación de datos: 

Calcula el OR de una columna de mapa de bits, devuelve la cardinalidad del tipo UInt64, si agrega el sufijo -State, luego devuelve objeto de mapa de bits. Esto es equivalente a groupBitmapMerge.

groupBitmapOr(expr)

Parámetros

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

Valor de retorno

Valor de la UInt64 tipo.

Ejemplo

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]           
└─────────────────────────────────────────────────┘

Método de codificación de datos: 

Calcula el XOR de una columna de mapa de bits, devuelve la cardinalidad del tipo UInt64, si agrega el sufijo -State, luego devuelve objeto de mapa de bits.

groupBitmapOr(expr)

Parámetros

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

Valor de retorno

Valor de la UInt64 tipo.

Ejemplo

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]                       
└──────────────────────────────────────────────────┘

Artículo Original

Rating: 4.3 - 3 votes

Was this content helpful?
★★★★☆