Intercalación

Se aplica a: marcado de sí Databricks SQL marcado con sí Databricks Runtime 16.1 y versiones posteriores

Una intercalación es un conjunto de reglas que determina cómo se realizan las comparaciones de cadenas. Las intercalaciones admiten comparaciones que no distinguen mayúsculas de minúsculas, no distinguen acentos y comparaciones que no distinguen espacios finales, así como ordenación de cadenas compatibles con el lenguaje.

Las cadenas de Azure Databricks se representan como caracteres UTF-8 codificados Unicode. De forma predeterminada, Azure Databricks compara cadenas por su representación UTF-8 binaria, conocida como UTF8_BINARY intercalación. UTF8_BINARY las comparaciones son rápidas y adecuadas en muchos casos, pero es posible que no sean adecuadas para las aplicaciones que requieren ordenación o comparaciones compatibles con el lenguaje.

Más allá de las comparaciones binarias, un caso de uso común no distingue mayúsculas de minúsculas. La UTF8_LCASE intercalación está diseñada para este fin. Convierte cadenas en minúsculas antes de compararlas con UTF8_BINARY.

Para las comparaciones con reconocimiento del lenguaje, Azure Databricks usa las siguientes tecnologías:

Biblioteca de componentes internacionales para unicode (ICU) para calcular la intercalación.
Tablas comunes del repositorio de datos de configuración regional (CLDR) para la intercalación compatible con la configuración regional.
Lenguaje de marcado de datos locales de Unicode (LDML) para codificar las intercalaciones internamente.

Estas tecnologías se encapsulan en un conjunto de intercalaciones con nombre disponibles para su uso en instrucciones SQL.

Nota:

Para conocer las limitaciones al usar intercalaciones con tablas de Delta Lake, consulte Limitaciones.

Nombres de intercalación

Azure Databricks proporciona intercalaciones del sistema con nombre para simplificar la identificación. Las especificaciones LDML pueden ser complejas para leer y usar directamente.

Sintaxis

{ UTF8_BINARY |
  UTF8_LCASE |
  { UNICODE | locale } [ _ modifier [...] ] }

locale
  language_code [ _ script_code ] [ _ country_code ]

modifier
  { CS | CI | AS | AI | RTRIM }

UTF8_BINARY

Intercalación binaria que compara cadenas byte byte en función de su representación UTF-8. UTF8_BINARY es la intercalación predeterminada y la mayoría ligera en Azure Databricks.

En esta intercalación: 'A' (x'65') <'B' (x'66') < ... < 'Z' (x'90'). Sin embargo, 'Z' (x'90') (x'97') <'a' y 'A' (x'65') <>'a' (x'97'). Los caracteres como 'Ä' (x'C384') son mayores que y 'z''Z' .
UTF8_LCASE

Intercalación ligera sin distinción entre mayúsculas y minúsculas que convierte cadenas en minúsculas antes de compararlas con UTF8_BINARY.

UTF8_LCASE es la intercalación utilizada para Identifiers en Azure Databricks.

Por ejemplo:
```
ORDER BY col COLLATE UTF8_LCASE
```
equivale a:
```
ORDER BY LOWER(col) COLLATE UTF8_BINARY
```
UNICODE

La configuración regional raíz de ICU, conocida en CLDR como configuración root regional (especificación LDML: und-u). Esta intercalación aplica un orden independiente del idioma que agrupa caracteres similares. Por ejemplo: 'a''b'<<'A'<'Ä'. Esta intercalación distingue mayúsculas de minúsculas y distingue acentos de forma predeterminada.
locale

Una intercalación compatible con la configuración regional basada en tablas CLDR. La configuración regional se especifica como un código de lenguaje, un código de script opcional y un código de país opcional. Los valores de configuración regional no distinguen mayúsculas de minúsculas.
- language_code: código de idioma ISO 639-1 de dos letras.
- script_code: código de script ISO 15924 de cuatro letras.
- country_code: código de país ISO 3166-1 alfa-3 de tres letras.
modifier

Controla la distinción entre mayúsculas y minúsculas, la sensibilidad de énfasis y el comportamiento del espacio final. Los modificadores no distinguen mayúsculas de minúsculas y se pueden especificar en cualquier orden.
- CS: distingue mayúsculas de minúsculas. Comportamiento predeterminado.
- CI: no distingue mayúsculas de minúsculas.
- AS: distingue acentos. Comportamiento predeterminado.
- AI: no distingue acentos.
Se aplica a: Databricks SQL Databricks Runtime 16.2 y versiones posteriores
- RTRIM: no distingue espacio final. Recorta los espacios finales (u0020) antes de la comparación.
Se aplica a: Databricks SQL Databricks Runtime 16.2 y versiones posteriores

Puede especificar RTRIM, como máximo uno de CS o CI, y como máximo uno de AS o AI.

Cuando Azure Databricks procesa un nombre de intercalación, normaliza el nombre quitando los valores predeterminados. Por ejemplo, SR_CYR_SRN_CS_AS normaliza en SR.

Para obtener una lista de intercalaciones admitidas, consulte Intercalaciones admitidas.

Ejemplos

-- Fully qualified collation names are supported; case doesn't matter.
system.builtin.unicode

-- All collations are system-defined and do not require qualification.
unicode

-- Two-letter language code for German collation.
DE

-- Two-letter language code and three-letter country code for French Canadian collation.
fr_CAN

-- Two-letter language code, four-letter script code, and three-letter country code
-- for Traditional Chinese in Macao.
zh_Hant_MAC

-- German collation with case-insensitive and accent-insensitive modifiers.
-- 'Ä', 'A', and 'a' are all considered equal.
de_CI_AI

-- Backticks are allowed but not required for built-in collations.
`UTF8_BINARY`

Comparación `UTF8_LCASE` y intercalaciones UNICODE

Tanto UTF8_LCASE como las intercalaciones basadas en UNICODE, como UNICODE_CI y UNICODE_CI_AI admiten comparaciones que no distinguen mayúsculas de minúsculas, pero difieren en cómo controlan los caracteres acentuados y las reglas específicas de la configuración regional.

Diferencias de comportamiento

UTF8_LCASE convierte cadenas en minúsculas y las compara byte byte mediante UTF8_BINARY. Es ligero y rápido, pero trata los caracteres acentuados como distintos de sus formas sincentar.

Las intercalaciones basadas en UNICODE usan la biblioteca de ICU y los datos de configuración regional clDR. Los CI modificadores y AI extienden esto para tratar los caracteres como equivalentes incluso cuando difieren en mayúsculas y minúsculas, énfasis o ambos. Estas intercalaciones son más exhaustivas, pero tienen un mayor costo computacional.

Comportamiento	`UTF8_LCASE`	`UNICODE_CI`	`UNICODE_CI_AI`
`'A' = 'a'`	`true`	`true`	`true`
`'Café' = 'café'`	`true`	`true`	`true`
`'Cafe' = 'Café'`	`false`	`false`	`true`
`'ß' = 'ss'` (alemán afilado)	`false`	`false`	`false`
`'resume' = 'résumé'`	`false`	`false`	`true`
Admite `LIKE` y `RLIKE`	Sí	No	No
Admite reglas específicas de la configuración regional	No	Sí	Sí

Cuándo usar cada intercalación

Se usa UTF8_LCASE para comparaciones rápidas que no distinguen mayúsculas de minúsculas cuando los caracteres acentuados deben permanecer distintos. Esta intercalación es adecuada para migraciones de almacenamiento de datos desde sistemas que usan coincidencias de cadenas que distinguen mayúsculas de minúsculas simples.
Se usa UNICODE_CI para comparaciones que no distinguen mayúsculas de minúsculas que siguen las reglas Unicode, especialmente cuando los datos incluyen caracteres de varios lenguajes en los que la reducción simple no es suficiente.
Use UNICODE_CI_AI cuando se deben omitir las diferencias entre mayúsculas y minúsculas y énfasis. Por ejemplo, si una búsqueda "resume" debe coincidir con "résumé". Esto es habitual en las aplicaciones multilingües y de búsqueda orientadas al usuario.

Ejemplos

-- UTF8_LCASE lowercases then compares bytes.
-- Accented and unaccented characters are not equivalent.
> SELECT 'Cafe' = 'café' COLLATE UTF8_LCASE;
  false

> SELECT 'Café' = 'café' COLLATE UTF8_LCASE;
  true

-- UNICODE_CI is case-insensitive but accent-sensitive.
-- 'Café' equals 'café' (case differs) but not 'Cafe' (accent differs).
> SELECT 'Café' = 'cafe' COLLATE UNICODE_CI;
  false

> SELECT 'Café' = 'café' COLLATE UNICODE_CI;
  true

-- UNICODE_CI_AI is case-insensitive and accent-insensitive.
-- 'Café' matches 'cafe' because both case and accent differences are ignored.
> SELECT 'Cafe' = 'café' COLLATE UNICODE_CI_AI;
  true

> SELECT 'resume' = 'résumé' COLLATE UNICODE_CI_AI;
  true

-- UTF8_LCASE sorts by lowercase byte order.
-- UNICODE collations sort by linguistic similarity.
> SELECT col FROM VALUES('Banana'), ('apple'), ('Ångström'), ('äpfel') AS t(col)
    ORDER BY col COLLATE UTF8_LCASE;
  apple
  Banana
  Ångström
  äpfel

> SELECT col FROM VALUES('Banana'), ('apple'), ('Ångström'), ('äpfel') AS t(col)
    ORDER BY col COLLATE UNICODE_CI;
  apple
  Ångström
  äpfel
  Banana

Intercalación predeterminada

La intercalación predeterminada se aplica a STRING literales, marcadores de parámetros, funciones sin STRING parámetros que generan cadenas y definiciones de tipo de columna, campo o variable sin una COLLATE cláusula .

La intercalación predeterminada se deriva de la siguiente manera:

Para instrucciones DDL como ALTER TABLE, CREATE VIEW, CREATE TABLEy CREATE FUNCTION:
- La intercalación predeterminada es la intercalación predeterminada del objeto que se va a crear o modificar.
- Si no se especifica ninguna cláusula DEFAULT COLLATION, la intercalación predeterminada es UTF8_BINARY.
Para las instrucciones DML (UPDATE, DELETE FROM, INSERT, MERGE INTO) y Query, la intercalación predeterminada es UTF8_BINARY.

Prioridad de intercalación

Azure Databricks aplica reglas de precedencia de intercalación para determinar qué intercalación usar para una cadena determinada. Se definen cuatro niveles de precedencia:

Explícito

La intercalación se asigna explícitamente mediante collate expresión.

-- Force binary collation to check whether a VIN matches a Ferrari.
vin COLLATE UTF8_BINARY LIKE 'ZFF%'

-- Force German collation to order German first names.
ORDER BY vorname COLLATE DE

Implícito

La intercalación se asigna implícitamente mediante un nombre de columna, nombre de campo, alias de columna, nombre de variable o referencia de nombre de parámetro , incluido el resultado de una subconsulta donde la intercalación no es None.
```
-- Use the collation of the column as defined.
employee.name LIKE 'Mc%'

-- Use the collation of the variable as defined.
translate(session.tempvar, 'Z', ',')
```

Predeterminado

Literal STRING , marcador de parámetro con nombre o sin nombre, o generado STRING por una función de otro tipo.

-- A literal string has the default collation.
'Hello'

-- :parm1 is a parameter marker using the session default collation.
EXECUTE IMMEDIATE 'SELECT :parm1' USING 'Hello' AS parm1;

-- ? is a parameter marker using the session default collation.
EXECUTE IMMEDIATE 'SELECT ?' USING 'Hello';

-- The result of casting a non-STRING to STRING uses the default collation.
CAST(5 AS STRING)

-- The date is converted to a string using the default collation.
to_char(DATE'2016-04-08', 'y')

-- session_user() returns a STRING with the default collation.
session_user()

La intercalación asignada es la intercalación predeterminada.

Ninguno

Resultado STRING de una operación de función, operador o conjunto, como UNION que toma más de un STRING argumento con intercalaciones implícitas diferentes.

-- Concatenating two strings with different explicit collations results in no collation.
SELECT fr || de AS freutsch FROM VALUES('Voulez vous ' COLLATE FR, 'Kartoffelsupp...' COLLATE DE) AS T(fr, de)

-- A union of two strings with different explicit collations results in no collation.
SELECT 'Voulez vous ' COLLATE FR UNION ALL SELECT 'Kartoffelsupp...' COLLATE DE

Derivación de intercalación

Al derivar la intercalación de un STRING resultado, las reglas de precedencia se aplican de la siguiente manera:

Si la expresión coincide con una de las definiciones anteriores, la intercalación y la precedencia son las definidas.
Si la expresión es una función o operador con un único STRING parámetro que devuelve un STRING, la intercalación y la prioridad son las del STRING parámetro .
Si la expresión es una función o operador con dos o más STRING parámetros:
1. Si todos los parámetros tienen la misma intercalación y precedencia, el resultado usa esa intercalación y prioridad.
2. Si los parámetros tienen intercalaciones o precedencia diferentes, deje C1 que y C2 sean intercalaciones distintas y D sean la intercalación predeterminada. El resultado viene determinado por la tabla siguiente:

Intercalación y prioridad	C1 Explícito	C1 Implícito	D Valor predeterminado	Ninguno
C2 Explícito	Error	C2 Explícito	C2 Explícito	C2 Explícito
C2 Implícito	C1 Explícito	Ninguno	C2 Implícito	Ninguno
D Valor predeterminado	C1 Explícito	C1 Implícito	D Valor predeterminado	Ninguno
Ninguno	C1 Explícito	Ninguno	Ninguno	Ninguno

Ejemplos

> SELECT 'hello' = 'hello   ' COLLATE UNICODE_RTRIM;
  true

> CREATE TABLE words(fr STRING COLLATE FR, de STRING COLLATE DE, en STRING COLLATE EN);
> INSERT INTO words VALUES ('Salut', 'Hallo', 'Hello');

-- A literal string has the default collation.
> SELECT collation('Ciao');
  UTF8_BINARY

-- A function producing a STRING has the default collation.
> SELECT collation(user());
  UTF8_BINARY

-- A function that modifies a STRING passes the collation through.
> SELECT collation(upper('Ciao'));
  UTF8_BINARY

-- Implicit collation (French) wins over default collation.
> SELECT collation(fr || 'Ciao') FROM words;
  FR

-- Explicit collation (French) wins over implicit collation (German).
> SELECT collation('Salut' COLLATE FR || de) FROM words;
  FR

-- Implicit German collides with implicit French; the result has no collation.
> SELECT collation(de || fr) FROM words;
  null

-- Explicit collation (French) wins over default collation (Italian).
> SELECT collation('Salut' COLLATE FR || 'Ciao');
  FR

-- Explicit collation (French) collides with explicit collation (German).
> SELECT collation('Salut' COLLATE FR || 'Hallo' COLLATE DE);
  COLLATION_MISMATCH.EXPLICIT

-- Explicit collation wins over no collation.
> SELECT collation('Ciao' COLLATE IT || (fr || de)) FROM words;
  IT

-- Implicit collation (English) does not win over None.
> SELECT collation(en || (fr || de)) FROM words;
  null

-- Explicit collation (English) wins over implicit collation anywhere in the expression.
> SELECT collation((fr || ltrim('H' COLLATE EN, fr)) || fr) FROM words;
  EN

Limitaciones

Muchas funciones de coincidencia de patrones y regex solo UTF8_BINARY admiten intercalaciones y UTF8_LCASE . Azure Databricks genera un error cuando estas funciones se usan con otras intercalaciones, como UNICODE o intercalaciones específicas de la configuración regional, como DE o FR_CI_AI.

Las funciones afectadas incluyen LIKE, ILIKE, RLIKEy la familia de regexp_* funciones. Para la coincidencia de cadenas en columnas con otras intercalaciones, use contains function, startswith function o endswith function.

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-04-11

Compartir a través de

Intercalación

Nombres de intercalación

Sintaxis

Ejemplos

Comparación UTF8_LCASE y intercalaciones UNICODE

Diferencias de comportamiento

Cuándo usar cada intercalación

Ejemplos

Intercalación predeterminada

Prioridad de intercalación

Derivación de intercalación

Ejemplos

Limitaciones

Temas relacionados

Comentarios

Recursos adicionales

Comparación `UTF8_LCASE` y intercalaciones UNICODE