Amazon Redshift dejará de admitir la creación de nuevas UDF de Python a partir del parche 198. Las UDF de Python existentes seguirán funcionando hasta el 30 de junio de 2026. Para obtener más información, consulte la [publicación del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

# Función COLLATE
<a name="r_COLLATE"></a>

La función COLLATE anula la intercalación de una expresión o una columna de cadenas. 

Para obtener información sobre cómo crear tablas mediante la intercalación de bases de datos, consulte [CREATE TABLE](r_CREATE_TABLE_NEW.md).

Para obtener información sobre cómo crear bases de datos mediante la intercalación de bases de datos, consulte [CREATE DATABASE](r_CREATE_DATABASE.md).

## Sintaxis
<a name="r_COLLATE-synopsis"></a>

```
COLLATE( string, 'case_sensitive' | 'cs' | 'case_insensitive' | 'ci');
```

## Argumentos
<a name="r_COLLATE-argument"></a>

 *cadena*   
Una expresión o una columna de cadenas que desea invalidar.

 *'case\_sensitive'* \| *'cs'* \| *'case\_insensitive'* \| *'ci'*   
Una constante de cadena de un nombre de intercalación. Amazon Redshift solo admite los siguientes valores para este parámetro:  
+  *case\_sensitive* 
+  *cs* 
+  *case\_insensitive* 
+  *ci* 
*case\_sensitive* y *cs* son intercambiables y producen los mismos resultados. Del mismo modo, *case\_insensitive* y *ci* son intercambiables y producen los mismos resultados.

## Tipo de retorno
<a name="r_COLLATE-return-type"></a>

La función COLLATE devuelve `VARCHAR`, `CHAR` o `SUPER` de acuerdo con el primer tipo de expresión de entrada. Esta función solo cambia la intercalación del primer argumento de entrada y no modifica su valor de salida.

## Ejemplos
<a name="r_COLLATE-example"></a>

Para crear la tabla T y definir col1 en la tabla T como `case_sensitive`, utilice el ejemplo siguiente.

```
CREATE TABLE T ( col1 Varchar(20) COLLATE case_sensitive );

INSERT INTO T VALUES ('john'),('JOHN');
```

 Al ejecutar la primera consulta, Amazon Redshift solo devuelve `john`. Después de que la función COLLATE se ejecuta en col1, la intercalación se vuelve `case_insensitive`. La segunda consulta devuelve `john` y `JOHN`. 

```
SELECT * FROM T WHERE col1 = 'john';

+------+
| col1 |
+------+
| john |
+------+

SELECT * FROM T WHERE COLLATE(col1, 'case_insensitive') = 'john';

+------+
| col1 |
+------+
| john |
| JOHN |
+------+
```

Para crear la tabla A y definir col1 en la tabla A como `case_insensitive`, utilice el ejemplo siguiente.

```
CREATE TABLE A ( col1 Varchar(20) COLLATE case_insensitive );

INSERT INTO A VALUES ('john'),('JOHN');
```

 Al ejecutar la primera consulta, Amazon Redshift devuelve `john` y `JOHN`. Después de que la función COLLATE se ejecuta en col1, la intercalación se vuelve `case_sensitive`. La segunda consulta solo devuelve `john`. 

```
SELECT * FROM A WHERE col1 = 'john';

+------+
| col1 |
+------+
| john |
| JOHN |
+------+

SELECT * FROM A WHERE COLLATE(col1, 'case_sensitive') = 'john';

+------+
| col1 |
+------+
| john |
+------+
```