> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8a08bda2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Documentación de las funciones de bits

# Funciones de bits

Las funciones de bits funcionan con cualquier par de tipos entre `UInt8`, `UInt16`, `UInt32`, `UInt64`, `Int8`, `Int16`, `Int32`, `Int64`, `Float32` o `Float64`. Algunas funciones admiten los tipos `String` y `FixedString`.

El tipo de resultado es un entero cuyo número de bits es igual al número máximo de bits de sus argumentos. Si al menos uno de los argumentos es de tipo con signo, el resultado será un número con signo. Si un argumento es un número de coma flotante, se convierte a Int64.

{/*AUTOGENERATED_START*/}

<div id="bitAnd">
  ## bitAnd
</div>

Introducido en: v1.1.0

Realiza una operación AND bit a bit entre dos valores.

**Sintaxis**

```sql theme={null}
bitAnd(a, b)
```

**Argumentos**

* `a` — Primer valor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `b` — Segundo valor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve el resultado de la operación bit a bit `a AND b`

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
CREATE TABLE bits
(
    `a` UInt8,
    `b` UInt8
)
ENGINE = Memory;

INSERT INTO bits VALUES (0, 0), (0, 1), (1, 0), (1, 1);

SELECT
    a,
    b,
    bitAnd(a, b)
FROM bits
```

```response title=Response theme={null}
┌─a─┬─b─┬─bitAnd(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            0 │
│ 1 │ 0 │            0 │
│ 1 │ 1 │            1 │
└───┴───┴──────────────┘
```

<div id="bitCount">
  ## bitCount
</div>

Introducido en: v20.3.0

Calcula la cantidad de bits con valor uno en la representación binaria de un número.

**Sintaxis**

```sql theme={null}
bitCount(x)
```

**Argumentos**

* `x` — Un valor entero o de punto flotante. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve el número de bits establecidos en uno en `x`. [`UInt8`](/es/reference/data-types/int-uint).

<Note>
  La función no convierte el valor de entrada a un tipo de mayor tamaño ([extensión de signo](https://en.wikipedia.org/wiki/Sign_extension)).
  Por ejemplo: `bitCount(toUInt8(-1)) = 8`.
</Note>

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT bin(333), bitCount(333);
```

```response title=Response theme={null}
┌─bin(333)─────────┬─bitCount(333)─┐
│ 0000000101001101 │             5 │
└──────────────────┴───────────────┘
```

<div id="bitHammingDistance">
  ## bitHammingDistance
</div>

Introducido en: v21.1.0

Devuelve la [distancia de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre las representaciones en bits de dos números.
Puede utilizarse con las funciones [`SimHash`](/es/reference/functions/regular-functions/hash-functions#ngramSimHash) para detectar cadenas casi duplicadas.
Cuanto menor sea la distancia, más similares serán las cadenas.

**Sintaxis**

```sql theme={null}
bitHammingDistance(x, y)
```

**Argumentos**

* `x` — Primer número para calcular la distancia de Hamming. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `y` — Segundo número para calcular la distancia de Hamming. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve la distancia de Hamming entre `x` e `y` [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT bitHammingDistance(111, 121);
```

```response title=Response theme={null}
┌─bitHammingDistance(111, 121)─┐
│                            3 │
└──────────────────────────────┘
```

<div id="bitNot">
  ## bitNot
</div>

Introducido en: v1.1.0

Realiza la operación NOT bit a bit.

**Sintaxis**

```sql theme={null}
bitNot(a)
```

**Argumentos**

* `a` — Valor al que se aplicará la operación NOT bit a bit. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el resultado de `~a`, es decir, `a` con los bits invertidos.

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT
    CAST('5', 'UInt8') AS original,
    bin(original) AS original_binary,
    bitNot(original) AS result,
    bin(bitNot(original)) AS result_binary;
```

```response title=Response theme={null}
┌─original─┬─original_binary─┬─result─┬─result_binary─┐
│        5 │ 00000101        │    250 │ 11111010      │
└──────────┴─────────────────┴────────┴───────────────┘
```

<div id="bitOr">
  ## bitOr
</div>

Introducido en: v1.1.0

Realiza una operación OR bit a bit entre dos valores.

**Sintaxis**

```sql theme={null}
bitOr(a, b)
```

**Argumentos**

* `a` — Primer valor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `b` — Segundo valor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve el resultado de la operación bit a bit `a OR b`

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
CREATE TABLE bits
(
    `a` UInt8,
    `b` UInt8
)
ENGINE = Memory;

INSERT INTO bits VALUES (0, 0), (0, 1), (1, 0), (1, 1);

SELECT
    a,
    b,
    bitOr(a, b)
FROM bits;
```

```response title=Response theme={null}
┌─a─┬─b─┬─bitOr(a, b)─┐
│ 0 │ 0 │           0 │
│ 0 │ 1 │           1 │
│ 1 │ 0 │           1 │
│ 1 │ 1 │           1 │
└───┴───┴─────────────┘
```

<div id="bitRotateLeft">
  ## bitRotateLeft
</div>

Introducido en: v1.1.0

Rota los bits hacia la izquierda un número determinado de posiciones. Los bits que se desplazan fuera reaparecen por la derecha.

**Sintaxis**

```sql theme={null}
bitRotateLeft(a, N)
```

**Argumentos**

* `a` — Un valor que se va a rotar. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint)
* `N` — El número de posiciones que se rota a la izquierda. [`UInt8/16/32/64`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el valor rotado con el mismo tipo que `a`. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT 99 AS a, bin(a), bitRotateLeft(a, 2) AS a_rotated, bin(a_rotated);
```

```response title=Response theme={null}
┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       141 │ 10001101       │
└────┴──────────┴───────────┴────────────────┘
```

<div id="bitRotateRight">
  ## bitRotateRight
</div>

Introducido en: v1.1.0

Rota los bits a la derecha un número determinado de posiciones. Los bits que se desplazan fuera vuelven al lado izquierdo.

**Sintaxis**

```sql theme={null}
bitRotateRight(a, N)
```

**Argumentos**

* `a` — Un valor que se va a rotar. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint)
* `N` — El número de posiciones que se rota a la derecha. [`UInt8/16/32/64`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el valor rotado, con el mismo tipo que `a`. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT 99 AS a, bin(a), bitRotateRight(a, 2) AS a_rotated, bin(a_rotated);
```

```response title=Response theme={null}
┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       216 │ 11011000       │
└────┴──────────┴───────────┴────────────────┘
```

<div id="bitShiftLeft">
  ## bitShiftLeft
</div>

Introducido en: v1.1.0

Desplaza la representación binaria de un valor hacia la izquierda el número de posiciones de bit especificado.

Un `FixedString` o un `String` se trata como un único valor multibyte.

Los bits de un valor `FixedString` se pierden al desplazarse fuera.
Por el contrario, un valor `String` se amplía con bytes adicionales, por lo que no se pierde ningún bit.

**Sintaxis**

```sql theme={null}
bitShiftLeft(a, N)
```

**Argumentos**

* `a` — Un valor que desplazar. [`(U)Int*`](/es/reference/data-types/int-uint) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `N` — El número de posiciones que se van a desplazar. [`UInt8/16/32/64`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el valor desplazado con el mismo tipo que `a`.

**Ejemplos**

**Ejemplo de uso con codificación binaria**

```sql title=Query theme={null}
SELECT 99 AS a, bin(a), bitShiftLeft(a, 2) AS a_shifted, bin(a_shifted);
```

```response title=Response theme={null}
┌──a─┬─bin(99)──┬─a_shifted─┬─bin(bitShiftLeft(99, 2))─┐
│ 99 │ 01100011 │       140 │ 10001100                 │
└────┴──────────┴───────────┴──────────────────────────┘
```

**Ejemplo de uso con codificación hexadecimal**

```sql title=Query theme={null}
SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftLeft('abc', 4))─┐
│ abc │ 616263     │ &0        │ 06162630                    │
└─────┴────────────┴───────────┴─────────────────────────────┘
```

**Ejemplo de uso con codificación Fixed String**

```sql title=Query theme={null}
SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftLeft(toFixedString('abc', 3), 4))─┐
│ abc │ 616263                       │ &0        │ 162630                                        │
└─────┴──────────────────────────────┴───────────┴───────────────────────────────────────────────┘
```

<div id="bitShiftRight">
  ## bitShiftRight
</div>

Introducido en: v1.1.0

Desplaza la representación binaria de un valor hacia la derecha el número especificado de posiciones de bit.

Un `FixedString` o un `String` se trata como un único valor multibyte.

Los bits de un valor `FixedString` se pierden al desplazarse fuera.
En cambio, un valor `String` se extiende con bytes adicionales, por lo que no se pierde ningún bit.

**Sintaxis**

```sql theme={null}
bitShiftRight(a, N)
```

**Argumentos**

* `a` — Un valor que se va a desplazar. [`(U)Int*`](/es/reference/data-types/int-uint) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `N` — El número de posiciones que se desplazan. [`UInt8/16/32/64`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el valor desplazado con el mismo tipo que `a`.

**Ejemplos**

**Ejemplo de uso con codificación binaria**

```sql title=Query theme={null}
SELECT 101 AS a, bin(a), bitShiftRight(a, 2) AS a_shifted, bin(a_shifted);
```

```response title=Response theme={null}
┌───a─┬─bin(101)─┬─a_shifted─┬─bin(bitShiftRight(101, 2))─┐
│ 101 │ 01100101 │        25 │ 00011001                   │
└─────┴──────────┴───────────┴────────────────────────────┘
```

**Ejemplo de uso con codificación hexadecimal**

```sql title=Query theme={null}
SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftRight('abc', 12))─┐
│ abc │ 616263     │           │ 0616                          │
└─────┴────────────┴───────────┴───────────────────────────────┘
```

**Ejemplo de uso con codificación de Fixed String**

```sql title=Query theme={null}
SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftRight(a, 12) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftRight(toFixedString('abc', 3), 12))─┐
│ abc │ 616263                       │           │ 000616                                          │
└─────┴──────────────────────────────┴───────────┴─────────────────────────────────────────────────┘
```

<div id="bitSlice">
  ## bitSlice
</div>

Introducido en: v22.2.0

Devuelve una subcadena que comienza en el bit del índice 'offset' y tiene una longitud de 'length' bits.

**Sintaxis**

```sql theme={null}
bitSlice(s, offset[, length])
```

**Argumentos**

* `s` — La String o Fixed String que se va a dividir. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring)
* `offset` —
  Devuelve la posición inicial del bit (indexación basada en 1).
* Valores positivos: cuentan desde el principio de la cadena.
* Valores negativos: cuentan desde el final de la cadena.

  [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `length` —
  Opcional. El número de bits que se van a extraer.
* Valores positivos: extraen `length` bits.
* Valores negativos: extraen desde el desplazamiento hasta `(string_length - |length|)`.
* Si se omite: extrae desde el desplazamiento hasta el final de la cadena.
* Si `length` no es un múltiplo de 8, el resultado se rellena con ceros a la derecha.
  [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve una cadena que contiene los bits extraídos, representados como una secuencia binaria. El resultado siempre se rellena hasta los límites de byte (múltiplos de 8 bits) [`String`](/es/reference/data-types/string)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 8));
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 2));
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 9));
SELECT bin('Hello'), bin(bitSlice('Hello', -4, 8));
```

```response title=Response theme={null}
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', 1, 8))─┐
│ 0100100001100101011011000110110001101111 │ 01001000                     │
└──────────────────────────────────────────┴──────────────────────────────┘
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', 1, 2))─┐
│ 0100100001100101011011000110110001101111 │ 01000000                     │
└──────────────────────────────────────────┴──────────────────────────────┘
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', 1, 9))─┐
│ 0100100001100101011011000110110001101111 │ 0100100000000000             │
└──────────────────────────────────────────┴──────────────────────────────┘
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', -4, 8))─┐
│ 0100100001100101011011000110110001101111 │ 11110000                      │
└──────────────────────────────────────────┴───────────────────────────────┘
```

<div id="bitTest">
  ## bitTest
</div>

Introducido en: v1.1.0

Toma cualquier número y lo convierte a [binario](https://en.wikipedia.org/wiki/Binary_number); luego devuelve el valor del bit en una posición especificada. El conteo se realiza de derecha a izquierda, empezando en 0.

**Sintaxis**

```sql theme={null}
bitTest(a, i)
```

**Argumentos**

* `a` — Número que se va a evaluar. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `i` — Posición del bit que se devolverá. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve el valor del bit situado en la posición `i` en la representación binaria de `a` [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
SELECT bin(2), bitTest(2, 1);
```

```response title=Response theme={null}
┌─bin(2)───┬─bitTest(2, 1)─┐
│ 00000010 │             1 │
└──────────┴───────────────┘
```

<div id="bitTestAll">
  ## bitTestAll
</div>

Introducido en: v1.1.0

Devuelve el resultado de la [conjunción lógica](https://en.wikipedia.org/wiki/Logical_conjunction) (operador AND) de todos los bits en las posiciones especificadas.
Cuenta de derecha a izquierda, empezando en 0.

El AND lógico entre dos bits es verdadero si y solo si ambos bits de entrada son verdaderos.

**Sintaxis**

```sql theme={null}
bitTestAll(a, index1[, index2, ... , indexN])
```

**Argumentos**

* `a` — Un valor entero. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint)
* `index1, ...` — Una o varias posiciones de bits. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el resultado de la conjunción lógica [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso 1**

```sql title=Query theme={null}
SELECT bitTestAll(43, 0, 1, 3, 5);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAll(43, 0, 1, 3, 5)─┐
│ 00101011 │                          1 │
└──────────┴────────────────────────────┘
```

**Ejemplo de uso 2**

```sql title=Query theme={null}
SELECT bitTestAll(43, 0, 1, 3, 5, 2);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAll(4⋯1, 3, 5, 2)─┐
│ 00101011 │                        0 │
└──────────┴──────────────────────────┘
```

<div id="bitTestAny">
  ## bitTestAny
</div>

Introducido en: v1.1.0

Devuelve el resultado de la [disyunción lógica](https://en.wikipedia.org/wiki/Logical_disjunction) (operador OR) de todos los bits situados en las posiciones indicadas de un número.
Se cuenta de derecha a izquierda, comenzando en 0.

El OR lógico entre dos bits es verdadero si al menos uno de los bits de entrada es verdadero.

**Sintaxis**

```sql theme={null}
bitTestAny(a, index1[, index2, ... , indexN])
```

**Argumentos**

* `a` — Un valor entero. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint)
* `index1, ...` — Una o varias posiciones de bits. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el resultado de la disyunción lógica [`UInt8`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso 1**

```sql title=Query theme={null}
SELECT bitTestAny(43, 0, 2);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAny(43, 0, 2)─┐
│ 00101011 │                    1 │
└──────────┴──────────────────────┘
```

**Ejemplo de uso 2**

```sql title=Query theme={null}
SELECT bitTestAny(43, 4, 2);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAny(43, 4, 2)─┐
│ 00101011 │                    0 │
└──────────┴──────────────────────┘
```

<div id="bitXor">
  ## bitXor
</div>

Introducido en: v1.1.0

Realiza una operación de o exclusiva bit a bit (XOR) entre dos valores.

**Sintaxis**

```sql theme={null}
bitXor(a, b)
```

**Argumentos**

* `a` — Primer valor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `b` — Segundo valor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)

**Valor devuelto**

Devuelve el resultado de la operación bit a bit `a XOR b`

**Ejemplos**

**Ejemplo de uso**

```sql title=Query theme={null}
CREATE TABLE bits
(
    `a` UInt8,
    `b` UInt8
)
ENGINE = Memory;

INSERT INTO bits VALUES (0, 0), (0, 1), (1, 0), (1, 1);

SELECT
    a,
    b,
    bitXor(a, b)
FROM bits;
```

```response title=Response theme={null}
┌─a─┬─b─┬─bitXor(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            1 │
│ 1 │ 0 │            1 │
│ 1 │ 1 │            0 │
└───┴───┴──────────────┘
```