Funciones para trabajar con matrices 

vaciar 

Devuelve 1 para una matriz vacía, o 0 para una matriz no vacía.
El tipo de resultado es UInt8.
La función también funciona para cadenas.

notEmpty 

Devuelve 0 para una matriz vacía, o 1 para una matriz no vacía.
El tipo de resultado es UInt8.
La función también funciona para cadenas.

longitud 

Devuelve el número de elementos de la matriz.
El tipo de resultado es UInt64.
La función también funciona para cadenas.

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

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

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

emptyArrayDate, emptyArrayDateTime 

emptyArrayString 

Acepta cero argumentos y devuelve una matriz vacía del tipo apropiado.

emptyArrayToSingle 

Acepta una matriz vacía y devuelve una matriz de un elemento que es igual al valor predeterminado.

rango(final), rango(inicio, fin [, paso]) 

Devuelve una matriz de números de principio a fin-1 por paso.
Si el argumento start no se especifica, el valor predeterminado es 0.
Si el argumento step no se especifica, el valor predeterminado es 1.
Se comporta casi como pitónico range. Pero la diferencia es que todos los tipos de argumentos deben ser UInt numero.
Por si acaso, se produce una excepción si se crean matrices con una longitud total de más de 100,000,000 de elementos en un bloque de datos.

array(x1, …), operator [x1, …] 

Crea una matriz a partir de los argumentos de la función.
Los argumentos deben ser constantes y tener tipos que tengan el tipo común más pequeño. Se debe pasar al menos un argumento, porque de lo contrario no está claro qué tipo de matriz crear. Es decir, no puede usar esta función para crear una matriz vacía (para hacerlo, use el ‘emptyArray*’ función descrita anteriormente).
Devuelve un ‘Array(T)’ tipo resultado, donde ‘T’ es el tipo común más pequeño de los argumentos pasados.

arrayConcat 

Combina matrices pasadas como argumentos.

arrayConcat(arrays)

Parámetros

  • arrays – Arbitrary number of arguments of Matriz tipo.
    Ejemplo
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
┌─res───────────┐
│ [1,2,3,4,5,6] │
└───────────────┘

Por ejemplo, el operador arr[n] 

Obtener el elemento con el índice n de la matriz arr. n debe ser de cualquier tipo entero.
Los índices de una matriz comienzan desde uno.
Los índices negativos son compatibles. En este caso, selecciona el elemento correspondiente numerado desde el final. Por ejemplo, arr[-1] es el último elemento de la matriz.

Si el índice cae fuera de los límites de una matriz, devuelve algún valor predeterminado (0 para números, una cadena vacía para cadenas, etc.), a excepción del caso con una matriz no constante y un índice constante 0 (en este caso habrá un error Array indices are 1-based).

Tiene(arr, elem) 

Comprueba si el ‘arr’ la matriz tiene el ‘elem’ elemento.
Devuelve 0 si el elemento no está en la matriz, o 1 si es.

NULL se procesa como un valor.

SELECT has([1, 2, NULL], NULL)
┌─has([1, 2, NULL], NULL)─┐
│                       1 │
└─────────────────────────┘

TieneTodo 

Comprueba si una matriz es un subconjunto de otra.

hasAll(set, subset)

Parámetros

  • set – Array of any type with a set of elements.
  • subset – Array of any type with elements that should be tested to be a subset of set.

Valores de retorno

  • 1, si set contiene todos los elementos de subset.
  • 0, de lo contrario.

Propiedades peculiares

  • Una matriz vacía es un subconjunto de cualquier matriz.
  • Null procesado como un valor.
  • El orden de los valores en ambas matrices no importa.

Ejemplos

SELECT hasAll([], []) devoluciones 1.

SELECT hasAll([1, Null], [Null]) devoluciones 1.

SELECT hasAll([1.0, 2, 3, 4], [1, 3]) devoluciones 1.

SELECT hasAll(['a', 'b'], ['a']) devoluciones 1.

SELECT hasAll([1], ['a']) devuelve 0.

SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]]) devuelve 0.

TieneCualquier 

Comprueba si dos matrices tienen intersección por algunos elementos.

hasAny(array1, array2)

Parámetros

  • array1 – Array of any type with a set of elements.
  • array2 – Array of any type with a set of elements.

Valores de retorno

  • 1, si array1 y array2 tienen un elemento similar al menos.
  • 0, de lo contrario.

Propiedades peculiares

  • Null procesado como un valor.
  • El orden de los valores en ambas matrices no importa.

Ejemplos

SELECT hasAny([1], []) devoluciones 0.

SELECT hasAny([Null], [Null, 1]) devoluciones 1.

SELECT hasAny([-128, 1., 512], [1]) devoluciones 1.

SELECT hasAny([[1, 2], [3, 4]], ['a', 'c']) devoluciones 0.

SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]]) devoluciones 1.

¿Cómo puedo hacerlo?) 

Devuelve el índice de la primera ‘x’ elemento (comenzando desde 1) si está en la matriz, o 0 si no lo está.

Ejemplo:

SELECT indexOf([1, 3, NULL, NULL], NULL)
┌─indexOf([1, 3, NULL, NULL], NULL)─┐
│                                 3 │
└───────────────────────────────────┘

Elementos establecidos en NULL se manejan como valores normales.

Cuenta igual (arr, x) 

Devuelve el número de elementos de la matriz igual a x. Equivalente a arrayCount (elem -> elem = x, arr).

NULL los elementos se manejan como valores separados.

Ejemplo:

SELECT countEqual([1, 2, NULL, NULL], NULL)
┌─countEqual([1, 2, NULL, NULL], NULL)─┐
│                                    2 │
└──────────────────────────────────────┘

Información detallada) 

Returns the array [1, 2, 3, …, length (arr) ]

Esta función se utiliza normalmente con ARRAY JOIN. Permite contar algo solo una vez para cada matriz después de aplicar ARRAY JOIN . Ejemplo:

SELECT
    count() AS Reaches,
    countIf(num = 1) AS Hits
FROM test.hits
ARRAY JOIN
    GoalsReached,
    arrayEnumerate(GoalsReached) AS num
WHERE CounterID = 160656
LIMIT 10
┌─Reaches─┬──Hits─┐
│   95606 │ 31406 │
└─────────┴───────┘

En este ejemplo, Reaches es el número de conversiones (las cadenas recibidas después de aplicar ARRAY JOIN) y Hits es el número de páginas vistas (cadenas antes de ARRAY JOIN). En este caso particular, puede obtener el mismo resultado de una manera más fácil:

SELECT
    sum(length(GoalsReached)) AS Reaches,
    count() AS Hits
FROM test.hits
WHERE (CounterID = 160656) AND notEmpty(GoalsReached)
┌─Reaches─┬──Hits─┐
│   95606 │ 31406 │
└─────────┴───────┘

Esta función también se puede utilizar en funciones de orden superior. Por ejemplo, puede usarlo para obtener índices de matriz para elementos que coinciden con una condición.

arrayEnumerateUniq(arr, …) 

Devuelve una matriz del mismo tamaño que la matriz de origen, indicando para cada elemento cuál es su posición entre los elementos con el mismo valor.
Por ejemplo: arrayEnumerateUniq([10, 20, 10, 30]) = [1, 1, 2, 1].

Esta función es útil cuando se utiliza ARRAY JOIN y la agregación de elementos de matriz.
Ejemplo:

SELECT
    Goals.ID AS GoalID,
    sum(Sign) AS Reaches,
    sumIf(Sign, num = 1) AS Visits
FROM test.visits
ARRAY JOIN
    Goals,
    arrayEnumerateUniq(Goals.ID) AS num
WHERE CounterID = 160656
GROUP BY GoalID
ORDER BY Reaches DESC
LIMIT 10
┌──GoalID─┬─Reaches─┬─Visits─┐
│   53225 │    3214 │   1097 │
│ 2825062 │    3188 │   1097 │
│   56600 │    2803 │    488 │
│ 1989037 │    2401 │    365 │
│ 2830064 │    2396 │    910 │
│ 1113562 │    2372 │    373 │
│ 3270895 │    2262 │    812 │
│ 1084657 │    2262 │    345 │
│   56599 │    2260 │    799 │
│ 3271094 │    2256 │    812 │
└─────────┴─────────┴────────┘

En este ejemplo, cada ID de objetivo tiene un cálculo del número de conversiones (cada elemento de la estructura de datos anidados Objetivos es un objetivo alcanzado, al que nos referimos como conversión) y el número de sesiones. Sin ARRAY JOIN, habríamos contado el número de sesiones como sum(Sign) . Pero en este caso particular, las filas se multiplicaron por la estructura de Objetivos anidados, por lo que para contar cada sesión una vez después de esto, aplicamos una condición al valor de la función arrayEnumerateUniq(Goals.ID) .

La función arrayEnumerateUniq puede tomar varias matrices del mismo tamaño que los argumentos. En este caso, la singularidad se considera para tuplas de elementos en las mismas posiciones en todas las matrices.

SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]) AS res
┌─res───────────┐
│ [1,2,1,1,2,1] │
└───────────────┘

Esto es necesario cuando se utiliza ARRAY JOIN con una estructura de datos anidados y una agregación adicional a través de múltiples elementos de esta estructura.

arrayPopBack 

Quita el último elemento de la matriz.

arrayPopBack(array)

Parámetros

  • array – Array.

Ejemplo

SELECT arrayPopBack([1, 2, 3]) AS res
┌─res───┐
│ [1,2] │
└───────┘

arrayPopFront 

Quita el primer elemento de la matriz.

arrayPopFront(array)

Parámetros

  • array – Array.

Ejemplo

SELECT arrayPopFront([1, 2, 3]) AS res
┌─res───┐
│ [2,3] │
└───────┘

arrayPushBack 

Agrega un elemento al final de la matriz.

arrayPushBack(array, single_value)

Parámetros

  • array – Array.
  • single_value – A single value. Only numbers can be added to an array with numbers, and only strings can be added to an array of strings. When adding numbers, ClickHouse automatically sets the single_value tipo para el tipo de datos de la matriz. Para obtener más información sobre los tipos de datos en ClickHouse, consulte “Tipos de datos”. Puede ser NULL. La función agrega un NULL elemento de matriz a una matriz, y el tipo de elementos de matriz se convierte en Nullable.

Ejemplo

SELECT arrayPushBack(['a'], 'b') AS res
┌─res───────┐
│ ['a','b'] │
└───────────┘

arrayPushFront 

Agrega un elemento al principio de la matriz.

arrayPushFront(array, single_value)

Parámetros

  • array – Array.
  • single_value – A single value. Only numbers can be added to an array with numbers, and only strings can be added to an array of strings. When adding numbers, ClickHouse automatically sets the single_value tipo para el tipo de datos de la matriz. Para obtener más información sobre los tipos de datos en ClickHouse, consulte “Tipos de datos”. Puede ser NULL. La función agrega un NULL elemento de matriz a una matriz, y el tipo de elementos de matriz se convierte en Nullable.

Ejemplo

SELECT arrayPushFront(['b'], 'a') AS res
┌─res───────┐
│ ['a','b'] │
└───────────┘

arrayResize 

Cambia la longitud de la matriz.

arrayResize(array, size[, extender])

Parámetros:

  • array — Array.
  • size — Required length of the array.
    • Si size es menor que el tamaño original de la matriz, la matriz se trunca desde la derecha.
  • Si size es mayor que el tamaño inicial de la matriz, la matriz se extiende a la derecha con extender valores predeterminados para el tipo de datos de los elementos de la matriz.
  • extender — Value for extending an array. Can be NULL.

Valor devuelto:

Una matriz de longitud size.

Ejemplos de llamadas

SELECT arrayResize([1], 3)
┌─arrayResize([1], 3)─┐
│ [1,0,0]             │
└─────────────────────┘
SELECT arrayResize([1], 3, NULL)
┌─arrayResize([1], 3, NULL)─┐
│ [1,NULL,NULL]             │
└───────────────────────────┘

arraySlice 

Devuelve una porción de la matriz.

arraySlice(array, offset[, length])

Parámetros

  • array – Array of data.
  • offset – Indent from the edge of the array. A positive value indicates an offset on the left, and a negative value is an indent on the right. Numbering of the array items begins with 1.
  • length - La longitud de la porción requerida. Si especifica un valor negativo, la función devuelve un segmento abierto [offset, array_length - length). Si omite el valor, la función devuelve el sector [offset, the_end_of_array].

Ejemplo

SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res
┌─res────────┐
│ [2,NULL,4] │
└────────────┘

Elementos de matriz establecidos en NULL se manejan como valores normales.

arraySort([func,] arr, …) 

Ordena los elementos del arr matriz en orden ascendente. Si el func se especifica la función, el orden de clasificación está determinado por el resultado func función aplicada a los elementos de la matriz. Si func acepta múltiples argumentos, el arraySort función se pasa varias matrices que los argumentos de func corresponderá a. Los ejemplos detallados se muestran al final de arraySort descripci.

Ejemplo de clasificación de valores enteros:

SELECT arraySort([1, 3, 3, 0]);
┌─arraySort([1, 3, 3, 0])─┐
│ [0,1,3,3]               │
└─────────────────────────┘

Ejemplo de ordenación de valores de cadena:

SELECT arraySort(['hello', 'world', '!']);
┌─arraySort(['hello', 'world', '!'])─┐
│ ['!','hello','world']              │
└────────────────────────────────────┘

Considere el siguiente orden de clasificación NULL, NaN y Inf valor:

SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
┌─arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf])─┐
│ [-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]                     │
└───────────────────────────────────────────────────────────┘
  • -Inf los valores son los primeros en la matriz.
  • NULL los valores son los últimos en la matriz.
  • NaN los valores están justo antes NULL.
  • Inf los valores están justo antes NaN.

Tenga en cuenta que arraySort es una función de orden superior. Puede pasarle una función lambda como primer argumento. En este caso, el orden de clasificación está determinado por el resultado de la función lambda aplicada a los elementos de la matriz.

Consideremos el siguiente ejemplo:

SELECT arraySort((x) -> -x, [1, 2, 3]) as res;
┌─res─────┐
│ [3,2,1] │
└─────────┘

For each element of the source array, the lambda function returns the sorting key, that is, [1 –> -1, 2 –> -2, 3 –> -3]. Since the arraySort función ordena las teclas en orden ascendente, el resultado es [3, 2, 1]. Por lo tanto, el (x) –> -x la función lambda establece la orden descendente en una clasificación.

La función lambda puede aceptar múltiples argumentos. En este caso, debe pasar el arraySort función varias matrices de idéntica longitud a las que corresponderán los argumentos de la función lambda. La matriz resultante constará de elementos de la primera matriz de entrada; los elementos de la siguiente matriz de entrada especifican las claves de clasificación. Por ejemplo:

SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
┌─res────────────────┐
│ ['world', 'hello'] │
└────────────────────┘

Aquí, los elementos que se pasan en la segunda matriz ([2, 1]) definen una clave de ordenación para el elemento correspondiente de la matriz de origen ([‘hello’, ‘world’Es decir,, [‘hello’ –> 2, ‘world’ –> 1]. Since the lambda function doesn't use x, los valores reales de la matriz de origen no afectan el orden en el resultado. Tan, ‘hello’ será el segundo elemento en el resultado, y ‘world’ será la primera.

Otros ejemplos se muestran a continuación.

SELECT arraySort((x, y) -> y, [0, 1, 2], ['c', 'b', 'a']) as res;
┌─res─────┐
│ [2,1,0] │
└─────────┘
SELECT arraySort((x, y) -> -y, [0, 1, 2], [1, 2, 3]) as res;
┌─res─────┐
│ [2,1,0] │
└─────────┘

arrayReverseSort([func,] arr, …) 

Ordena los elementos del arr matriz en orden descendente. Si el func se especifica la función, arr se ordena de acuerdo con el resultado de la func función aplicada a los elementos de la matriz, y luego la matriz ordenada se invierte. Si func acepta múltiples argumentos, el arrayReverseSort función se pasa varias matrices que los argumentos de func corresponderá a. Los ejemplos detallados se muestran al final de arrayReverseSort descripci.

Ejemplo de clasificación de valores enteros:

SELECT arrayReverseSort([1, 3, 3, 0]);
┌─arrayReverseSort([1, 3, 3, 0])─┐
│ [3,3,1,0]                      │
└────────────────────────────────┘

Ejemplo de ordenación de valores de cadena:

SELECT arrayReverseSort(['hello', 'world', '!']);
┌─arrayReverseSort(['hello', 'world', '!'])─┐
│ ['world','hello','!']                     │
└───────────────────────────────────────────┘

Considere el siguiente orden de clasificación NULL, NaN y Inf valor:

SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]) as res;
┌─res───────────────────────────────────┐
│ [inf,3,2,1,-4,-inf,nan,nan,NULL,NULL] │
└───────────────────────────────────────┘
  • Inf los valores son los primeros en la matriz.
  • NULL los valores son los últimos en la matriz.
  • NaN los valores están justo antes NULL.
  • -Inf los valores están justo antes NaN.

Tenga en cuenta que el arrayReverseSort es una función de orden superior. Puede pasarle una función lambda como primer argumento. Ejemplo se muestra a continuación.

SELECT arrayReverseSort((x) -> -x, [1, 2, 3]) as res;
┌─res─────┐
│ [1,2,3] │
└─────────┘

La matriz se ordena de la siguiente manera:

  1. Al principio, la matriz de origen ([1, 2, 3]) se ordena de acuerdo con el resultado de la función lambda aplicada a los elementos de la matriz. El resultado es una matriz [3, 2, 1].
  2. Matriz que se obtiene en el paso anterior, se invierte. Entonces, el resultado final es [1, 2, 3].

La función lambda puede aceptar múltiples argumentos. En este caso, debe pasar el arrayReverseSort función varias matrices de idéntica longitud a las que corresponderán los argumentos de la función lambda. La matriz resultante constará de elementos de la primera matriz de entrada; los elementos de la siguiente matriz de entrada especifican las claves de clasificación. Por ejemplo:

SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
┌─res───────────────┐
│ ['hello','world'] │
└───────────────────┘

En este ejemplo, la matriz se ordena de la siguiente manera:

  1. Al principio, la matriz de origen ([‘hello’, ‘world’]) se ordena de acuerdo con el resultado de la función lambda aplicada a los elementos de las matrices. Los elementos que se pasan en la segunda matriz ([2, 1]), definen las claves de ordenación para los elementos correspondientes de la matriz de origen. El resultado es una matriz [‘world’, ‘hello’].
  2. Matriz que se ordenó en el paso anterior, se invierte. Entonces, el resultado final es [‘hello’, ‘world’].

Otros ejemplos se muestran a continuación.

SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
┌─res─────┐
│ [5,3,4] │
└─────────┘
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
┌─res─────┐
│ [4,3,5] │
└─────────┘

arrayUniq(arr, …) 

Si se pasa un argumento, cuenta el número de elementos diferentes en la matriz.
Si se pasan varios argumentos, cuenta el número de tuplas diferentes de elementos en las posiciones correspondientes en múltiples matrices.

Si desea obtener una lista de elementos únicos en una matriz, puede usar arrayReduce(‘groupUniqArray’ arr).

Información adicional) 

Una función especial. Vea la sección “ArrayJoin function”.

arrayDifference 

Calcula la diferencia entre los elementos de matriz adyacentes. Devuelve una matriz donde el primer elemento será 0, el segundo es la diferencia entre a[1] - a[0], etc. The type of elements in the resulting array is determined by the type inference rules for subtraction (e.g. UInt8 - UInt8 = Int16).

Sintaxis

arrayDifference(array)

Parámetros

Valores devueltos

Devuelve una matriz de diferencias entre los elementos adyacentes.

Tipo: UInt*, En*, Flotante*.

Ejemplo

Consulta:

SELECT arrayDifference([1, 2, 3, 4])

Resultado:

┌─arrayDifference([1, 2, 3, 4])─┐
│ [0,1,1,1]                     │
└───────────────────────────────┘

Ejemplo del desbordamiento debido al tipo de resultado Int64:

Consulta:

SELECT arrayDifference([0, 10000000000000000000])

Resultado:

┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616]                   │
└────────────────────────────────────────────┘

arrayDistinct 

Toma una matriz, devuelve una matriz que contiene solo los elementos distintos.

Sintaxis

arrayDistinct(array)

Parámetros

Valores devueltos

Devuelve una matriz que contiene los elementos distintos.

Ejemplo

Consulta:

SELECT arrayDistinct([1, 2, 2, 3, 1])

Resultado:

┌─arrayDistinct([1, 2, 2, 3, 1])─┐
│ [1,2,3]                        │
└────────────────────────────────┘

Aquí hay algunas opciones) 

Devuelve una matriz del mismo tamaño que la matriz de origen, lo que indica dónde aparece cada elemento por primera vez en la matriz de origen.

Ejemplo:

SELECT arrayEnumerateDense([10, 20, 10, 30])
┌─arrayEnumerateDense([10, 20, 10, 30])─┐
│ [1,2,1,3]                             │
└───────────────────────────────────────┘

Información detallada) 

Toma varias matrices, devuelve una matriz con elementos que están presentes en todas las matrices de origen. El orden de los elementos en la matriz resultante es el mismo que en la primera matriz.

Ejemplo:

SELECT
    arrayIntersect([1, 2], [1, 3], [2, 3]) AS no_intersect,
    arrayIntersect([1, 2], [1, 3], [1, 4]) AS intersect
┌─no_intersect─┬─intersect─┐
│ []           │ [1]       │
└──────────────┴───────────┘

arrayReduce 

Aplica una función de agregado a los elementos de la matriz y devuelve su resultado. El nombre de la función de agregación se pasa como una cadena entre comillas simples 'max', 'sum'. Cuando se utilizan funciones de agregado paramétrico, el parámetro se indica después del nombre de la función entre paréntesis 'uniqUpTo(6)'.

Sintaxis

arrayReduce(agg_func, arr1, arr2, ..., arrN)

Parámetros

  • agg_func — The name of an aggregate function which should be a constant cadena.
  • arr — Any number of matriz escriba columnas como los parámetros de la función de agregación.

Valor devuelto

Ejemplo

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

Si una función agregada toma varios argumentos, esta función debe aplicarse a varias matrices del mismo tamaño.

SELECT arrayReduce('maxIf', [3, 5], [1, 0])
┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│                                    3 │
└──────────────────────────────────────┘

Ejemplo con una función de agregado paramétrico:

SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│                                                           4 │
└─────────────────────────────────────────────────────────────┘

arrayReduceInRanges 

Aplica una función de agregado a los elementos de matriz en rangos dados y devuelve una matriz que contiene el resultado correspondiente a cada rango. La función devolverá el mismo resultado que múltiples arrayReduce(agg_func, arraySlice(arr1, index, length), ...).

Sintaxis

arrayReduceInRanges(agg_func, ranges, arr1, arr2, ..., arrN)

Parámetros

  • agg_func — The name of an aggregate function which should be a constant cadena.
  • ranges — The ranges to aggretate which should be an matriz de tuplas que contiene el índice y la longitud de cada rango.
  • arr — Any number of matriz escriba columnas como los parámetros de la función de agregación.

Valor devuelto

Ejemplo

SELECT arrayReduceInRanges(
    'sum',
    [(1, 5), (2, 3), (3, 4), (4, 4)],
    [1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res
┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘

arrayReverse (arr) 

Devuelve una matriz del mismo tamaño que la matriz original que contiene los elementos en orden inverso.

Ejemplo:

SELECT arrayReverse([1, 2, 3])
┌─arrayReverse([1, 2, 3])─┐
│ [3,2,1]                 │
└─────────────────────────┘

inversa(arr) 

Sinónimo de “arrayReverse”

arrayFlatten 

Convierte una matriz de matrices en una matriz plana.

Función:

  • Se aplica a cualquier profundidad de matrices anidadas.
  • No cambia las matrices que ya son planas.

La matriz aplanada contiene todos los elementos de todas las matrices de origen.

Sintaxis

flatten(array_of_arrays)

Apodo: flatten.

Parámetros

  • array_of_arraysMatriz de matrices. Por ejemplo, [[1,2,3], [4,5]].

Ejemplos

SELECT flatten([[[1]], [[2], [3]]])
┌─flatten(array(array([1]), array([2], [3])))─┐
│ [1,2,3]                                     │
└─────────────────────────────────────────────┘

arrayCompact 

Elimina elementos duplicados consecutivos de una matriz. El orden de los valores de resultado está determinado por el orden de la matriz de origen.

Sintaxis

arrayCompact(arr)

Parámetros

arr — The matriz inspeccionar.

Valor devuelto

La matriz sin duplicado.

Tipo: Array.

Ejemplo

Consulta:

SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3])

Resultado:

┌─arrayCompact([1, 1, nan, nan, 2, 3, 3, 3])─┐
│ [1,nan,nan,2,3]                            │
└────────────────────────────────────────────┘

arrayZip 

Combina varias matrices en una sola matriz. La matriz resultante contiene los elementos correspondientes de las matrices de origen agrupadas en tuplas en el orden de argumentos enumerado.

Sintaxis

arrayZip(arr1, arr2, ..., arrN)

Parámetros

La función puede tomar cualquier cantidad de matrices de diferentes tipos. Todas las matrices de entrada deben ser del mismo tamaño.

Valor devuelto

  • Matriz con elementos de las matrices de origen agrupadas en tuplas. Los tipos de datos en la tupla son los mismos que los tipos de las matrices de entrada y en el mismo orden en que se pasan las matrices.

Tipo: Matriz.

Ejemplo

Consulta:

SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1])

Resultado:

┌─arrayZip(['a', 'b', 'c'], [5, 2, 1])─┐
│ [('a',5),('b',2),('c',1)]            │
└──────────────────────────────────────┘

arrayAUC 

Calcule AUC (Área bajo la curva, que es un concepto en el aprendizaje automático, vea más detalles: https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve ).

Sintaxis

arrayAUC(arr_scores, arr_labels)

Parámetros
- arr_scores — scores prediction model gives.
- arr_labels — labels of samples, usually 1 for positive sample and 0 for negtive sample.

Valor devuelto
Devuelve el valor AUC con el tipo Float64.

Ejemplo
Consulta:

select arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])

Resultado:

┌─arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│                                          0.75 │
└────────────────────────────────────────---──┘

Artículo Original

Rating: 4.2 - 5 votes

Was this content helpful?
★★★★☆