> ## 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 del tipo de dato Enum en ClickHouse, que representa un conjunto de valores constantes con nombre

# Enum

Tipo enumerado compuesto por valores con nombre.

Los valores con nombre pueden declararse como pares `'string' = integer` o como nombres `'string'`. ClickHouse solo almacena números, pero permite operar con los valores a través de sus nombres.

ClickHouse admite:

* `Enum` de 8 bits. Puede contener hasta 256 valores enumerados en el intervalo `[-128, 127]`.
* `Enum` de 16 bits. Puede contener hasta 65536 valores enumerados en el intervalo `[-32768, 32767]`.

ClickHouse elige automáticamente el tipo de `Enum` al insertar los datos. También puede usar los tipos `Enum8` o `Enum16` para asegurarse del tamaño de almacenamiento.

<div id="usage-examples">
  ## Ejemplos de uso
</div>

Aquí se crea una tabla con una columna de tipo `Enum8('hello' = 1, 'world' = 2)`:

```sql theme={null}
CREATE TABLE t_enum
(
    x Enum('hello' = 1, 'world' = 2)
)
ENGINE = TinyLog
```

Asimismo, puedes omitir los números. ClickHouse asignará automáticamente números consecutivos. De forma predeterminada, los números se asignan a partir de 1.

```sql theme={null}
CREATE TABLE t_enum
(
    x Enum('hello', 'world')
)
ENGINE = TinyLog
```

También puedes especificar un número inicial permitido para el primer nombre.

```sql theme={null}
CREATE TABLE t_enum
(
    x Enum('hello' = 1, 'world')
)
ENGINE = TinyLog
```

```sql theme={null}
CREATE TABLE t_enum
(
    x Enum8('hello' = -129, 'world')
)
ENGINE = TinyLog
```

```text theme={null}
Exception on server:
Code: 69. DB::Exception: Value -129 for element 'hello' exceeds range of Enum8.
```

La columna `x` solo puede almacenar valores incluidos en la definición del tipo: `'hello'` o `'world'`. Si intenta guardar cualquier otro valor, ClickHouse generará una excepción. El tamaño de 8 bits para este `Enum` se elige automáticamente.

```sql theme={null}
INSERT INTO t_enum VALUES ('hello'), ('world'), ('hello')
```

```text theme={null}
Ok.
```

```sql theme={null}
INSERT INTO t_enum VALUES('a')
```

```text theme={null}
Exception on client:
Code: 49. DB::Exception: Unknown element 'a' for type Enum('hello' = 1, 'world' = 2)
```

Cuando consultas datos de la tabla, ClickHouse muestra los valores de texto de `Enum`.

```sql theme={null}
SELECT * FROM t_enum
```

```text theme={null}
┌─x─────┐
│ hello │
│ world │
│ hello │
└───────┘
```

Si necesita ver los equivalentes numéricos de las filas, debe convertir el valor `Enum` a un tipo entero.

```sql theme={null}
SELECT CAST(x, 'Int8') FROM t_enum
```

```text theme={null}
┌─CAST(x, 'Int8')─┐
│               1 │
│               2 │
│               1 │
└─────────────────┘
```

Para crear un valor de tipo Enum en una consulta, también debes usar `CAST`.

```sql theme={null}
SELECT toTypeName(CAST('a', 'Enum(\'a\' = 1, \'b\' = 2)'))
```

```text theme={null}
┌─toTypeName(CAST('a', 'Enum(\'a\' = 1, \'b\' = 2)'))─┐
│ Enum8('a' = 1, 'b' = 2)                             │
└─────────────────────────────────────────────────────┘
```

<div id="general-rules-and-usage">
  ## Reglas generales y uso
</div>

A cada uno de los valores se le asigna un número en el intervalo `-128 ... 127` para `Enum8` o en el intervalo `-32768 ... 32767` para `Enum16`. Todas las cadenas y todos los números deben ser diferentes. Se permite una cadena vacía. Si se especifica este tipo (en una definición de tabla), los números pueden estar en cualquier orden. Sin embargo, el orden no importa.

Ni la cadena ni el valor numérico de un `Enum` pueden ser [NULL](/es/reference/syntax).

Un `Enum` puede estar contenido en el tipo [Nullable](/es/reference/data-types/nullable). Por lo tanto, si crea una tabla usando la consulta

```sql theme={null}
CREATE TABLE t_enum_nullable
(
    x Nullable( Enum8('hello' = 1, 'world' = 2) )
)
ENGINE = TinyLog
```

puede almacenar no solo `'hello'` y `'world'`, sino también `NULL`.

```sql theme={null}
INSERT INTO t_enum_nullable VALUES('hello'),('world'),(NULL)
```

En RAM, una columna `Enum` se almacena de la misma forma que `Int8` o `Int16` con los valores numéricos correspondientes.

Al leer en formato de texto, ClickHouse interpreta el valor como una cadena y busca la cadena correspondiente en el conjunto de valores del Enum. Si no la encuentra, se genera una excepción. Al leer en formato de texto, se lee la cadena y se busca el valor numérico correspondiente. Si no se encuentra, se generará una excepción.
Al escribir en formato de texto, escribe el valor como la cadena correspondiente. Si los datos de la columna contienen valores no válidos (números que no pertenecen al conjunto válido), se genera una excepción. Al leer y escribir en formato binario, funciona igual que con los tipos de datos Int8 e Int16.
El valor predeterminado implícito es el valor con el número más bajo.

Durante `ORDER BY`, `GROUP BY`, `IN`, `DISTINCT`, etc., los Enum se comportan igual que los números correspondientes. Por ejemplo, ORDER BY los ordena numéricamente. Los operadores de igualdad y comparación funcionan con los Enum igual que con los valores numéricos subyacentes.

Los valores Enum no pueden compararse con números. Los Enum pueden compararse con una cadena constante. Si la cadena con la que se comparan no es un valor válido para el Enum, se generará una excepción. El operador IN es compatible cuando el Enum está en el lado izquierdo y un conjunto de cadenas en el lado derecho. Las cadenas son los valores del Enum correspondiente.

La mayoría de las operaciones numéricas y con cadenas no están definidas para los valores Enum; por ejemplo, sumar un número a un Enum o concatenar una cadena a un Enum.
Sin embargo, el Enum tiene una función `toString` nativa que devuelve su valor en cadena.

Los valores Enum también pueden convertirse a tipos numéricos mediante la función `toT`, donde T es un tipo numérico. Cuando T corresponde al tipo numérico subyacente del Enum, esta conversión no tiene coste.
El tipo Enum puede cambiarse sin coste mediante ALTER si solo se modifica el conjunto de valores. Es posible tanto añadir como eliminar miembros del Enum mediante ALTER (eliminarlos es seguro solo si el valor eliminado nunca se ha usado en la tabla). Como medida de seguridad, cambiar el valor numérico de un miembro del Enum definido previamente generará una excepción.

Con ALTER, es posible cambiar un Enum8 por un Enum16 o viceversa, igual que al cambiar un Int8 por un Int16.

<div id="add-enum-values">
  ## AGREGAR VALORES A ENUM
</div>

Existe un atajo sintáctico para agregar nuevos valores a enum mediante ALTER [MODIFY COLUMN ADD ENUM VALUES](/es/reference/statements/alter/column#modify-column-add-enum-values)

```sql theme={null}
CREATE TABLE enum
(
    x Enum('One' = 1, 'Two', 'Three')
) ENGINE = Memory;
ALTER TABLE enum MODIFY COLUMN x ADD ENUM VALUES ('Zero' = 0, 'Four' = 4);
SHOW CREATE TABLE enum;
```

```text theme={null}
┌─statement────────────────────────────────────────────────────────────────┐
│CREATE TABLE default.enum                                                 │
│(                                                                         │
│    `x` Enum8('Zero' = 0, 'One' = 1, 'Two' = 2, 'Three' = 3, 'Four' = 4)  │
│)                                                                         │
│ENGINE = Memory                                                           │
└──────────────────────────────────────────────────────────────────────────┘
```