> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > Documentación de las funciones de Tuple # Funciones de Tuple La siguiente documentación se genera a partir de la tabla del sistema `system.functions`. {/*AUTOGENERATED_START*/}
## dotProduct
Introducido en: v21.11.0 Calcula el [producto escalar](https://en.wikipedia.org/wiki/Dot_product) (también llamado producto punto) de dos vectores (tuplas o arrays del mismo tamaño). Devuelve la suma de los productos de los elementos correspondientes. **Sintaxis** ```sql theme={null} dotProduct(vector1, vector2) ``` **Alias**: `scalarProduct` **Argumentos** * `vector1` — Primer vector. [`Array(T)`](/es/reference/data-types/array) o [`Tuple(T)`](/es/reference/data-types/tuple) * `vector2` — Segundo vector. Debe tener el mismo tamaño que el primer vector. [`Array(T)`](/es/reference/data-types/array) o [`Tuple(T)`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve el producto escalar de ambos vectores. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal) **Ejemplos** **Uso básico** ```sql title=Query theme={null} SELECT dotProduct((1, 2), (3, 4)) ``` ```response title=Response theme={null} 11 ```
## flattenTuple
Introducido en: v22.6.0 Aplana una tupla nombrada y anidada. Los elementos de la tupla resultante son las rutas de la tupla de entrada. **Sintaxis** ```sql theme={null} flattenTuple(input) ``` **Argumentos** * `input` — Tupla nombrada y anidada que se va a aplanar. [`Tuple(n1 T1[, n2 T2, ... ])`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve una tupla de salida cuyos elementos son rutas de la entrada original. [`Tuple(T)`](/es/reference/data-types/tuple) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} CREATE TABLE tab(t Tuple(a UInt32, b Tuple(c String, d UInt32))) ENGINE = MergeTree ORDER BY tuple(); INSERT INTO tab VALUES ((3, ('c', 4))); SELECT flattenTuple(t) FROM tab; ``` ```response title=Response theme={null} ┌─flattenTuple(t)┐ │ (3, 'c', 4) │ └────────────────┘ ```
## tuple
Introducido en: v1.1.0 Devuelve una tupla agrupando los argumentos de entrada. Para las columnas C1, C2, ... con los tipos T1, T2, ..., devuelve una tupla con nombre de tipo Tuple(C1 T1, C2 T2, ...) que contiene estas columnas si sus nombres son únicos y pueden tratarse como identificadores sin comillas; de lo contrario, devuelve una Tuple(T1, T2, ...). La ejecución de la función no tiene ningún coste. Las tuplas se usan normalmente como valores intermedios para un argumento de los operadores IN o para crear una lista de parámetros formales de funciones lambda. Las tuplas no se pueden escribir en una tabla. La función implementa el operador `(x, y, ...)`. **Sintaxis** ```sql theme={null} tuple([t1[, t2[ ...]]) ``` **Argumentos** * Ninguno. **Valor devuelto** **Ejemplos** **habitual** ```sql title=Query theme={null} SELECT tuple(1, 2) ``` ```response title=Response theme={null} (1,2) ```
## tupleConcat
Introducido en: v23.8.0 Combina las tuplas que se pasan como argumentos. **Sintaxis** ```sql theme={null} tupleConcat(tuple1[, tuple2, [...]]) ``` **Argumentos** * `tupleN` — Número arbitrario de argumentos de tipo Tuple. [`Tuple(T)`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve una tupla que contiene todos los elementos de las tuplas de entrada. [`Tuple(T)`](/es/reference/data-types/tuple) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} SELECT tupleConcat((1, 2), ('a',), (true, false)) ``` ```response title=Response theme={null} (1, 2, 'a', true, false) ```
## tupleDivide
Introducido en: v21.11.0 Calcula la división elemento a elemento de dos o más tuplas del mismo tamaño, de izquierda a derecha. La división por cero devuelve `inf`. **Sintaxis** ```sql theme={null} tupleDivide(t1, t2[, tN, ...]) ``` **Argumentos** * `t1` — Primera tupla de entrada. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `t2, ..., tN` — Una o más tuplas de entrada adicionales. Todas las tuplas deben tener el mismo tamaño. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve una tupla que contiene los cocientes de cada elemento. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Dos tuplas** ```sql title=Query theme={null} SELECT tupleDivide((1, 2), (2, 3)) ``` ```response title=Response theme={null} (0.5, 0.6666666666666666) ``` **Tres tuplas** ```sql title=Query theme={null} SELECT tupleDivide((100.0, 60.0), (5.0, 3.0), (2.0, 4.0)) ``` ```response title=Response theme={null} (10, 5) ```
## tupleDivideByNumber
Introducido en: v21.11.0 Devuelve una tupla cuyos elementos se dividen por un número. La división por cero devuelve `inf`. **Sintaxis** ```sql theme={null} tupleDivideByNumber(tuple, number) ``` **Argumentos** * `tuple` — Tupla que se divide. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `number` — Divisor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal) **Valor devuelto** Devuelve una tupla con los elementos divididos. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Uso básico** ```sql title=Query theme={null} SELECT tupleDivideByNumber((1, 2), 0.5) ``` ```response title=Response theme={null} (2, 4) ```
## tupleElement
Introducido en: v1.1.0 Extrae un elemento de una tupla por índice o por nombre. Para acceder por índice, se espera un índice numérico que empieza en 1. Para acceder por nombre, el nombre del elemento puede proporcionarse como una cadena (solo funciona con tuplas con nombre). Se admiten índices negativos. En este caso, se selecciona el elemento correspondiente, numerado desde el final. Por ejemplo, `tuple.-1` es el último elemento de la tupla. Un tercer argumento opcional especifica un valor predeterminado que se devuelve en lugar de lanzar una excepción cuando el elemento al que se accede no existe. Todos los argumentos deben ser constantes. Esta función tiene un coste de ejecución nulo e implementa los operadores `x.index` y `x.name`. **Sintaxis** ```sql theme={null} tupleElement(tuple, index|name[, default_value]) ``` **Argumentos** * `tuple` — Una tupla o un array de tuplas. [`Tuple(T)`](/es/reference/data-types/tuple) o [`Array(Tuple(T))`](/es/reference/data-types/array) * `index` — Índice de columna, empezando por 1. [`const UInt8/16/32/64`](/es/reference/data-types/int-uint) * `name` — Nombre del elemento. [`const String`](/es/reference/data-types/string) * `default_value` — Valor predeterminado que se devuelve cuando el índice está fuera de rango o el elemento no existe. [`Any`](/es/reference/data-types/index) **Valor devuelto** Devuelve el elemento correspondiente al índice o nombre especificados. [`Any`](/es/reference/data-types/index) **Ejemplos** **Acceso por índice** ```sql title=Query theme={null} SELECT tupleElement((1, 'hello'), 2) ``` ```response title=Response theme={null} hello ``` **Índices negativos** ```sql title=Query theme={null} SELECT tupleElement((1, 'hello'), -1) ``` ```response title=Response theme={null} hello ``` **Tupla con nombre con una tabla** ```sql title=Query theme={null} CREATE TABLE example (values Tuple(name String, age UInt32)) ENGINE = Memory; INSERT INTO example VALUES (('Alice', 30)); SELECT tupleElement(values, 'name') FROM example; ``` ```response title=Response theme={null} Alice ``` **Con valor por defecto** ```sql title=Query theme={null} SELECT tupleElement((1, 2), 5, 'not_found') ``` ```response title=Response theme={null} not_found ``` **Sintaxis del operador** ```sql title=Query theme={null} SELECT (1, 'hello').2 ``` ```response title=Response theme={null} hello ```
## tupleHammingDistance
Introducido en: v21.1.0 Devuelve la [distancia de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre dos tuplas del mismo tamaño. El tipo del resultado se determina del mismo modo que en las [funciones aritméticas](/es/reference/functions/regular-functions/arithmetic-functions), en función del número de elementos de las tuplas de entrada. ```sql theme={null} SELECT toTypeName(tupleHammingDistance(tuple(0), tuple(0))) AS t1, toTypeName(tupleHammingDistance((0, 0), (0, 0))) AS t2, toTypeName(tupleHammingDistance((0, 0, 0), (0, 0, 0))) AS t3, toTypeName(tupleHammingDistance((0, 0, 0, 0), (0, 0, 0, 0))) AS t4, toTypeName(tupleHammingDistance((0, 0, 0, 0, 0), (0, 0, 0, 0, 0))) AS t5 ``` ```text theme={null} ┌─t1────┬─t2─────┬─t3─────┬─t4─────┬─t5─────┐ │ UInt8 │ UInt16 │ UInt32 │ UInt64 │ UInt64 │ └───────┴────────┴────────┴────────┴────────┘ ``` **Sintaxis** ```sql theme={null} tupleHammingDistance(t1, t2) ``` **Argumentos** * `t1` — Primera tupla. [`Tuple(*)`](/es/reference/data-types/tuple) * `t2` — Segunda tupla. [`Tuple(*)`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve la distancia de Hamming. [`UInt8/16/32/64`](/es/reference/data-types/int-uint) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} SELECT tupleHammingDistance((1, 2, 3), (3, 2, 1)) ``` ```response title=Response theme={null} 2 ``` **Con MinHash para detectar cadenas casi duplicadas** ```sql title=Query theme={null} SELECT tupleHammingDistance(wordShingleMinHash(string), wordShingleMinHashCaseInsensitive(string)) FROM (SELECT 'ClickHouse is a column-oriented database management system for online analytical processing of queries.' AS string) ``` ```response title=Response theme={null} 2 ```
## tupleIntDiv
Introducido en: v23.8.0 Realiza la división entera elemento por elemento de dos o más tuplas del mismo tamaño, de izquierda a derecha. Devuelve una tupla de cocientes. Si alguna tupla contiene elementos no enteros, el resultado se calcula redondeando al entero más cercano cada numerador o divisor no entero. La división por 0 genera una excepción. **Sintaxis** ```sql theme={null} tupleIntDiv(t1, t2[, tN, ...]) ``` **Argumentos** * `t1` — Primera tupla de entrada. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `t2, ..., tN` — Una o más tuplas de entrada adicionales. Todas las tuplas deben tener el mismo tamaño. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve una tupla de cocientes enteros. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Dos tuplas** ```sql title=Query theme={null} SELECT tupleIntDiv((15, 10, 5), (5, 5, 5)) ``` ```response title=Response theme={null} (3, 2, 1) ``` **Con decimales** ```sql title=Query theme={null} SELECT tupleIntDiv((15, 10, 5), (5.5, 5.5, 5.5)) ``` ```response title=Response theme={null} (2, 1, 0) ``` **Tres tuplas** ```sql title=Query theme={null} SELECT tupleIntDiv((120, 60), (4, 3), (2, 4)) ``` ```response title=Response theme={null} (15, 5) ```
## tupleIntDivByNumber
Introducido en: v23.8.0 Realiza la división entera de una tupla de numeradores entre un denominador dado y devuelve una tupla con los cocientes. Si alguno de los parámetros de entrada contiene elementos no enteros, el resultado se calcula redondeando al entero más cercano cada numerador o divisor no entero. Se generará un error en caso de división entre 0. **Sintaxis** ```sql theme={null} tupleIntDivByNumber(tuple_num, div) ``` **Argumentos** * `tuple_num` — Tuple de valores del numerador. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `div` — El valor del divisor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal) **Valor devuelto** Devuelve una Tuple con los cocientes. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Uso básico** ```sql title=Query theme={null} SELECT tupleIntDivByNumber((15, 10, 5), 5) ``` ```response title=Response theme={null} (3, 2, 1) ``` **Con decimales** ```sql title=Query theme={null} SELECT tupleIntDivByNumber((15.2, 10.7, 5.5), 5.8) ``` ```response title=Response theme={null} (2, 1, 0) ```
## tupleIntDivOrZero
Introducido en: v23.8.0 Al igual que [`tupleIntDiv`](#tupleIntDiv), realiza la división entera elemento por elemento de dos o más tuplas del mismo tamaño, aplicada de izquierda a derecha. En caso de división por 0, devuelve 0 para ese elemento en lugar de generar una excepción. Si alguna de las tuplas contiene elementos no enteros, el resultado se calcula redondeando al entero más cercano cada numerador o divisor no entero. **Sintaxis** ```sql theme={null} tupleIntDivOrZero(t1, t2[, tN, ...]) ``` **Argumentos** * `t1` — Primera Tuple de entrada. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `t2, ..., tN` — Una o más Tuple de entrada adicionales. Todas las Tuple deben tener el mismo tamaño. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve una Tuple de cocientes enteros, con 0 para cualquier elemento cuyo divisor sea 0. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Con divisores iguales a cero** ```sql title=Query theme={null} SELECT tupleIntDivOrZero((5, 10, 15), (0, 0, 0)) ``` ```response title=Response theme={null} (0, 0, 0) ``` **Tres tuplas** ```sql title=Query theme={null} SELECT tupleIntDivOrZero((120, 60), (4, 3), (2, 4)) ``` ```response title=Response theme={null} (15, 5) ```
## tupleIntDivOrZeroByNumber
Introducido en: v23.8.0 Al igual que [`tupleIntDivByNumber`](#tupleIntDivByNumber), realiza la división entera de una tupla de numeradores entre un denominador dado y devuelve una tupla con los cocientes. No genera un error si el divisor es cero, sino que devuelve el cociente como cero. Si la tupla o el divisor contienen elementos no enteros, el resultado se calcula redondeando al entero más cercano cada numerador o divisor no entero. **Sintaxis** ```sql theme={null} tupleIntDivOrZeroByNumber(tuple_num, div) ``` **Argumentos** * `tuple_num` — Tupla de valores del numerador. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `div` — El valor del divisor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal) **Valor devuelto** Devuelve una tupla con los cocientes y `0` en los casos en que el divisor es `0`. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Uso básico** ```sql title=Query theme={null} SELECT tupleIntDivOrZeroByNumber((15, 10, 5), 5) ``` ```response title=Response theme={null} (3, 2, 1) ``` **Con divisor cero** ```sql title=Query theme={null} SELECT tupleIntDivOrZeroByNumber((15, 10, 5), 0) ``` ```response title=Response theme={null} (0, 0, 0) ```
## tupleMinus
Introducido en: v21.11.0 Calcula la diferencia entre los elementos correspondientes de dos o más tuplas del mismo tamaño, de izquierda a derecha. **Sintaxis** ```sql theme={null} tupleMinus(t1, t2[, tN, ...]) ``` **Alias**: `vectorDifference` **Argumentos** * `t1` — Primera tupla de entrada. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `t2, ..., tN` — Una o más tuplas de entrada adicionales. Todas las tuplas deben tener el mismo tamaño. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve una tupla que contiene las diferencias elemento a elemento. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Dos tuplas** ```sql title=Query theme={null} SELECT tupleMinus((1, 2), (2, 3)) ``` ```response title=Response theme={null} (-1, -1) ``` **Tres tuplas** ```sql title=Query theme={null} SELECT tupleMinus((10, 10), (3, 4), (2, 1)) ``` ```response title=Response theme={null} (5, 5) ```
## tupleModulo
Introducido en: v23.8.0 Devuelve una tupla de restos, elemento por elemento, al dividir dos o más tuplas del mismo tamaño, de izquierda a derecha. **Sintaxis** ```sql theme={null} tupleModulo(t1, t2[, tN, ...]) ``` **Argumentos** * `t1` — Primera tupla de entrada. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `t2, ..., tN` — Una o más tuplas de entrada adicionales. Todas las tuplas deben tener el mismo tamaño. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve una tupla con los restos calculados elemento por elemento. Se lanza una excepción en caso de división por cero. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Dos tuplas** ```sql title=Query theme={null} SELECT tupleModulo((15, 10, 5), (5, 3, 2)) ``` ```response title=Response theme={null} (0, 1, 1) ``` **Tres tuplas** ```sql title=Query theme={null} SELECT tupleModulo((10, 20), (7, 9), (3, 5)) ``` ```response title=Response theme={null} (0, 2) ```
## tupleModuloByNumber
Introducido en: v23.8.0 Devuelve una tupla con los módulos (restos) de dividir una tupla entre un divisor dado. **Sintaxis** ```sql theme={null} tupleModuloByNumber(tuple_num, div) ``` **Argumentos** * `tuple_num` — Tupla con los elementos del numerador. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) or [`Tuple(Float*)`](/es/reference/data-types/tuple) or [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `div` — El valor del divisor. [`(U)Int*`](/es/reference/data-types/int-uint) or [`Float*`](/es/reference/data-types/float) or [`Decimal`](/es/reference/data-types/decimal) **Valor devuelto** Devuelve una tupla con los residuos de la división. Se produce un error si se divide entre cero. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) or [`Tuple(Float*)`](/es/reference/data-types/tuple) or [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Uso básico** ```sql title=Query theme={null} SELECT tupleModuloByNumber((15, 10, 5), 2) ``` ```response title=Response theme={null} (1, 0, 1) ```
## tupleMultiply
Introducido en: v21.11.0 Calcula el producto elemento por elemento de dos o más tuplas del mismo tamaño. **Sintaxis** ```sql theme={null} tupleMultiply(t1, t2[, tN, ...]) ``` **Argumentos** * `t1` — Primera tupla de entrada. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `t2, ..., tN` — Una o más tuplas de entrada adicionales. Todas las tuplas deben tener el mismo tamaño. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve una tupla que contiene los productos de los elementos correspondientes. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Dos tuplas** ```sql title=Query theme={null} SELECT tupleMultiply((1, 2), (2, 3)) ``` ```response title=Response theme={null} (2, 6) ``` **Tres tuplas** ```sql title=Query theme={null} SELECT tupleMultiply((1, 2), (2, 3), (1, 2)) ``` ```response title=Response theme={null} (2, 12) ```
## tupleMultiplyByNumber
Introducido en: v21.11.0 Devuelve una tupla con todos sus elementos multiplicados por un número. **Sintaxis** ```sql theme={null} tupleMultiplyByNumber(tuple, number) ``` **Argumentos** * `tuple` — Tupla que se va a multiplicar. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `number` — Multiplicador. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal) **Valor devuelto** Devuelve una tupla con los elementos multiplicados. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Uso básico** ```sql title=Query theme={null} SELECT tupleMultiplyByNumber((1, 2), -2.1) ``` ```response title=Response theme={null} (-2.1, -4.2) ```
## tupleNames
Introducido en: v24.8.0 Convierte una tupla en un array de nombres de columnas. Para una tupla con la forma `Tuple(a T, b T, ...)`, devuelve un array de cadenas que representan los nombres de las columnas de la tupla. Si los elementos de la tupla no tienen nombres explícitos, se usarán sus índices como nombres de columna. **Sintaxis** ```sql theme={null} tupleNames(tuple) ``` **Argumentos** * Ninguno. **Valor devuelto** **Ejemplos** **habitual** ```sql title=Query theme={null} SELECT tupleNames(tuple(1 as a, 2 as b)) ``` ```response title=Response theme={null} ['a','b'] ```
## tupleNegate
Introducido en: v21.11.0 Calcula la negación de los elementos de la tupla. **Sintaxis** ```sql theme={null} tupleNegate(t) ``` **Argumentos** * `t` — Tuple que se va a negar. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve un Tuple con el resultado de la negación. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Uso básico** ```sql title=Query theme={null} SELECT tupleNegate((1, 2)) ``` ```response title=Response theme={null} (-1, -2) ```
## tuplePlus
Introducido en: v21.11.0 Calcula la suma de los elementos correspondientes de dos o más tuplas del mismo tamaño. **Sintaxis** ```sql theme={null} tuplePlus(t1, t2[, tN, ...]) ``` **Aliases**: `vectorSum` **Argumentos** * `t1` — Primera tupla de entrada. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `t2, ..., tN` — Una o más tuplas de entrada adicionales. Todas las tuplas deben tener el mismo tamaño. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve una tupla que contiene las sumas de cada elemento. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Dos tuplas** ```sql title=Query theme={null} SELECT tuplePlus((1, 2), (2, 3)) ``` ```response title=Response theme={null} (3, 5) ``` **Tres tuplas** ```sql title=Query theme={null} SELECT tuplePlus((1, 2), (2, 3), (3, 4)) ``` ```response title=Response theme={null} (6, 9) ```
## tuplePositiveModuloByNumber
Introducido en: v26.4.0 Devuelve una tupla con los módulos positivos (restos) de las divisiones entre una tupla y un divisor dado. A diferencia de tupleModuloByNumber, el resultado siempre es no negativo. **Sintaxis** ```sql theme={null} tuplePositiveModuloByNumber(tuple_num, div) ``` **Argumentos** * `tuple_num` — Tuple de valores del numerador. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) * `div` — El valor del divisor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal) **Valor devuelto** Devuelve una Tuple de restos no negativos. [`Tuple((U)Int*)`](/es/reference/data-types/tuple) o [`Tuple(Float*)`](/es/reference/data-types/tuple) o [`Tuple(Decimal)`](/es/reference/data-types/tuple) **Ejemplos** **Uso básico** ```sql title=Query theme={null} SELECT tuplePositiveModuloByNumber((15, 10, 5), 2) ``` ```response title=Response theme={null} (1, 0, 1) ```
## tupleToNameValuePairs
Introducido en: v21.9.0 Convierte una tupla en un Array de pares `(name, value)`. Por ejemplo, la tupla `Tuple(n1 T1, n2 T2, ...)` se convierte en `Array(Tuple('n1', T1), Tuple('n2', T2), ...)`. Todos los valores de la tupla deben ser del mismo tipo. **Sintaxis** ```sql theme={null} tupleToNameValuePairs(tuple) ``` **Argumentos** * `tuple` — Tupla con nombre con valores de cualquier tipo. [`Tuple(n1 T1[, n2 T2, ...])`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve un array con pares `(name, value)`. [`Array(Tuple(String, T))`](/es/reference/data-types/array) **Ejemplos** **Tupla con nombre** ```sql title=Query theme={null} SELECT tupleToNameValuePairs(tuple(1593 AS user_ID, 2502 AS session_ID)) ``` ```response title=Response theme={null} [('1', 1593), ('2', 2502)] ``` **Tuple sin nombre** ```sql title=Query theme={null} SELECT tupleToNameValuePairs(tuple(3, 2, 1)) ``` ```response title=Response theme={null} [('1', 3), ('2', 2), ('3', 1)] ```
## untuple
Realiza la sustitución sintáctica de los elementos de [tuple](/es/reference/data-types/tuple) en el lugar donde se invoca. Los nombres de las columnas de resultado dependen de la implementación y pueden cambiar. No asuma nombres de columna específicos después de `untuple`. **Sintaxis** ```sql theme={null} untuple(x) ``` Puede usar la expresión `EXCEPT` para omitir columnas en el resultado de la consulta. **Argumentos** * `x` — Una función `tuple`, una columna o una tupla de elementos. [Tuple](/es/reference/data-types/tuple). **Valor devuelto** * Ninguno. **Ejemplos** Tabla de entrada: ```text theme={null} ┌─key─┬─v1─┬─v2─┬─v3─┬─v4─┬─v5─┬─v6────────┐ │ 1 │ 10 │ 20 │ 40 │ 30 │ 15 │ (33,'ab') │ │ 2 │ 25 │ 65 │ 70 │ 40 │ 6 │ (44,'cd') │ │ 3 │ 57 │ 30 │ 20 │ 10 │ 5 │ (55,'ef') │ │ 4 │ 55 │ 12 │ 7 │ 80 │ 90 │ (66,'gh') │ │ 5 │ 30 │ 50 │ 70 │ 25 │ 55 │ (77,'kl') │ └─────┴────┴────┴────┴────┴────┴───────────┘ ``` Ejemplo de cómo usar una columna de tipo `Tuple` como parámetro de la función `untuple`: ```sql title="Query" theme={null} SELECT untuple(v6) FROM kv; ``` ```text title="Response" theme={null} ┌─_ut_1─┬─_ut_2─┐ │ 33 │ ab │ │ 44 │ cd │ │ 55 │ ef │ │ 66 │ gh │ │ 77 │ kl │ └───────┴───────┘ ``` Ejemplo de uso de la expresión `EXCEPT`: ```sql title="Query" theme={null} SELECT untuple((* EXCEPT (v2, v3),)) FROM kv; ``` ```text title="Response" theme={null} ┌─key─┬─v1─┬─v4─┬─v5─┬─v6────────┐ │ 1 │ 10 │ 30 │ 15 │ (33,'ab') │ │ 2 │ 25 │ 40 │ 6 │ (44,'cd') │ │ 3 │ 57 │ 10 │ 5 │ (55,'ef') │ │ 4 │ 55 │ 80 │ 90 │ (66,'gh') │ │ 5 │ 30 │ 25 │ 55 │ (77,'kl') │ └─────┴────┴────┴────┴───────────┘ ```
## Funciones de distancia
Todas las funciones admitidas se describen en la [documentación sobre funciones de distancia](/es/reference/functions/regular-functions/distance-functions).