¿Qué clasificación de SQL Server debo usar para el hebreo bíblico? La base de datos bajo consideración necesita acomodar diacríticos (es decir, vocales, acentos, tropos, etc.).
¿Qué clasificación de SQL Server debo usar para el hebreo bíblico? La base de datos bajo consideración necesita acomodar diacríticos (es decir, vocales, acentos, tropos, etc.).
Respuestas:
Primero: No hay distinción, en cuanto a cotejo, entre el hebreo bíblico y el hebreo moderno. Solo estamos tratando con el hebreo.
Segundo: Independientemente de cualquier otra cosa, desea utilizar el conjunto de colaciones más nuevo, que son las Normalmente recomiendo usar la versión más nueva de cualquier intercalación que necesite, pero al menos en este caso, hay una buena razón para usar la versión sin número de versión en el nombre. Las intercalaciones de la versión 100 (o más recientes) son mucho más completas y pueden distinguir entre caracteres suplementarios (o incluso son totalmente compatibles si se usa una _100_series, ya que tienen pesos de clasificación y reglas lingüísticas más nuevas / más completas que las series anteriores sin número de versión en el nombre (técnicamente son la versión 80).SCo 140intercalación), pero suponiendo que no se trate de caracteres suplementarios, entonces la versión 80 (sin versión número en nombre) las intercalaciones hacen un mejor trabajo al manejar el hebreo (vea el ítem "Sexto" más abajo).
Tercero: no hay un concepto de "Kana" (o tipo Kana) en hebreo, por lo que puede ignorar cualquiera de las variaciones de intercalación _KSen sus nombres (ya que esa es una sensibilidad que nunca usará).
Adelante: las intercalaciones que terminan en _SCcaracteres complementarios de soporte (es decir, UTF-16 completo), por lo que generalmente es mejor elegir una de ellas, si está disponible (es decir: si está utilizando SQL Server 2012 o posterior).
Quinto: no desea una intercalación binaria ( _BINo _BIN2) ya que esas no pueden distinguir entre letras hebreas con vocales y marcas de cantilación que son iguales pero tienen los caracteres combinados en diferentes órdenes, ni pueden ignorar las vocales y otras marcas para equiparar cosas como אy אֽ.
Por ejemplo (vocal y cantilation combinando caracteres en orden opuesto):
SELECT NCHAR(0x05D0) + NCHAR(0x059C) + NCHAR(0x05B8),
NCHAR(0x05D0) + NCHAR(0x05B8) + NCHAR(0x059C)
WHERE NCHAR(0x05D0) + NCHAR(0x059C) + NCHAR(0x05B8) =
NCHAR(0x05D0) + NCHAR(0x05B8) + NCHAR(0x059C) COLLATE Hebrew_100_CS_AS_SC;
-- אָ֜ אָ֜
SELECT NCHAR(0x05D0) + NCHAR(0x059C) + NCHAR(0x05B8),
NCHAR(0x05D0) + NCHAR(0x05B8) + NCHAR(0x059C)
WHERE NCHAR(0x05D0) + NCHAR(0x059C) + NCHAR(0x05B8) =
NCHAR(0x05D0) + NCHAR(0x05B8) + NCHAR(0x059C) COLLATE Hebrew_100_BIN2;
-- no rowsSexto: depende de cómo va a interactuar con los valores de cadena. El hebreo no tiene letras mayúsculas / minúsculas, sin embargo, hay algunos puntos de código que se ven afectados por mayúsculas y minúsculas. Incluso hay algunos puntos de código que son sensibles al ancho. El acento sensible / insensible afecta los signos diacríticos utilizados para las vocales, la pronunciación y las marcas de cantilación (es decir, tropo).
¿Necesita distinguir entre las formas finales y no finales de la misma letra? Hay cinco letras en hebreo que se ven diferentes cuando se usan como la letra final de una palabra. SQL Server maneja esto a través de mayúsculas y minúsculas _CS(aunque, desafortunadamente, parece estar roto en las colaciones más nuevas, y generalmente mejores, versión 100 y más nuevas):
SELECT NCHAR(0x05DE) AS [Mem],
NCHAR(0x05DD) AS [Final Mem]
WHERE NCHAR(0x05DE) = NCHAR(0x05DD) COLLATE Hebrew_CI_AS_KS_WS;
-- 1 row (expected; all sensitive except case)
-- Mem Final Mem
-- מ ם
SELECT NCHAR(0x05DE) AS [Mem],
NCHAR(0x05DD) AS [Final Mem]
WHERE NCHAR(0x05DE) = NCHAR(0x05DD) COLLATE Hebrew_CS_AI;
-- no rows (expected; all insensitive except case)
SELECT NCHAR(0x05DE) AS [Mem],
NCHAR(0x05DD) AS [Final Mem]
WHERE NCHAR(0x05DE) = NCHAR(0x05DD) COLLATE Hebrew_100_CI_AI;
-- no rows (expected 1 row; all insensitive)¿Necesita distinguir entre marcas de pronunciación, vocales y marcas de cantilación? SQL Server maneja esto mediante acento-sensibilidad / _AScolaciones (aunque, desafortunadamente, parece estar roto en las colaciones más nuevas, y generalmente mejores, de la versión 100 y más nuevas). Tenga en cuenta que los tres están agrupados bajo sensibilidad de acento y no se pueden controlar por separado (es decir, no puede hacer vocales sensibles pero insensibles a las marcas de cantilación).
Marcas de pronunciación
Hay varias letras que tienen dos sonidos diferentes. A veces, el único indicador para el que se usa el sonido es el contexto de la palabra en la que se encuentra la letra (y a veces incluso las palabras que la rodean), como en la Torá real (donde no hay marcas de pronunciación o vocales). Pero, ese mismo texto en otras formas, así como otro texto, tendrá puntos colocados dentro de la letra, o para la letra Shin, encima de la letra. La letra Shin puede tener un sonido "sh" o "s". Para indicar el sonido "sh" (es decir, la letra "shin"), hay un punto arriba en el lado derecho, mientras que un punto arriba en el lado izquierdo denota el sonido "s" (letra "sin"):
SELECT NCHAR(0x05E9) AS [Shin], -- ש
NCHAR(0x05E9) + NCHAR(0x05C1) AS [Shin + Shin Dot], -- שׁ
NCHAR(0x05E9) + NCHAR(0x05C2) AS [Shin + Sin Dot] -- שׂ
WHERE NCHAR(0x05E9) = NCHAR(0x05E9) + NCHAR(0x05C1) COLLATE Hebrew_CS_AI_KS_WS
AND NCHAR(0x05E9) = NCHAR(0x05E9) + NCHAR(0x05C2) COLLATE Hebrew_CS_AI_KS_WS;
-- 1 row (expected; all sensitive except accent)
SELECT NCHAR(0x05E9) AS [Shin], -- ש
NCHAR(0x05E9) + NCHAR(0x05C1) AS [Shin + Shin Dot], -- שׁ
NCHAR(0x05E9) + NCHAR(0x05C2) AS [Shin + Sin Dot] -- שׂ
WHERE NCHAR(0x05E9) = NCHAR(0x05E9) + NCHAR(0x05C1) COLLATE Hebrew_CI_AS
OR NCHAR(0x05E9) = NCHAR(0x05E9) + NCHAR(0x05C2) COLLATE Hebrew_CI_AS;
-- no rows (expected; all insensitive except accent)
SELECT NCHAR(0x05E9) AS [Shin], -- ש
NCHAR(0x05E9) + NCHAR(0x05C1) AS [Shin + Shin Dot], -- שׁ
NCHAR(0x05E9) + NCHAR(0x05C2) AS [Shin + Sin Dot] -- שׂ
WHERE NCHAR(0x05E9) = NCHAR(0x05E9) + NCHAR(0x05C1) COLLATE Hebrew_100_CI_AI_SC
OR NCHAR(0x05E9) = NCHAR(0x05E9) + NCHAR(0x05C2) COLLATE Hebrew_100_CI_AI_SC;
-- no rows (expected 1 row; all insensitive)Vocales
SELECT NCHAR(0x05D0) AS [Aleph], -- א
NCHAR(0x05D0) + NCHAR(0x05B8) AS [Aleph with vowel] -- אָ
WHERE NCHAR(0x05D0) =
NCHAR(0x05D0) + NCHAR(0x05B8) COLLATE Hebrew_CS_AI_KS_WS;
-- 1 row (expected; all sensitive except accent)
SELECT NCHAR(0x05D0) AS [Aleph], -- א
NCHAR(0x05D0) + NCHAR(0x05B8) AS [Aleph with vowel] -- אָ
WHERE NCHAR(0x05D0) =
NCHAR(0x05D0) + NCHAR(0x05B8) COLLATE Hebrew_CI_AS;
-- no rows (expected; all insensitive except accent)
SELECT NCHAR(0x05D0) AS [Aleph], -- א
NCHAR(0x05D0) + NCHAR(0x05B8) AS [Aleph with vowel] -- אָ
WHERE NCHAR(0x05D0) =
NCHAR(0x05D0) + NCHAR(0x05B8) COLLATE Hebrew_100_CI_AI_SC;
-- no rows (expected 1 row; all insensitive)Marcas de cantilacion
Técnicamente, de acuerdo con los datos oficiales de Unicode, las marcas en hebreo son ignorables y solo deben registrarse como una diferencia aquí cuando se utiliza una intercalación binaria. Sin embargo, SQL Server los trata igual que los acentos (desafortunadamente) y no puede ignorarlos por separado de las marcas de pronunciación o las vocales.
SELECT NCHAR(0x05D0) AS [Aleph], -- א
NCHAR(0x05D0) + NCHAR(0x05A8) AS [Aleph with cantillation mark] -- א֨
WHERE NCHAR(0x05D0) =
NCHAR(0x05D0) + NCHAR(0x05A8) COLLATE Hebrew_CS_AI_KS_WS;
-- 1 row (expected; all sensitive except accent)
SELECT NCHAR(0x05D0) AS [Aleph], -- א
NCHAR(0x05D0) + NCHAR(0x05A8) AS [Aleph with cantillation mark] -- א֨
WHERE NCHAR(0x05D0) =
NCHAR(0x05D0) + NCHAR(0x05A8) COLLATE Hebrew_CI_AS;
-- no rows (expected; all insensitive except accent)
SELECT NCHAR(0x05D0) AS [Aleph], -- א
NCHAR(0x05D0) + NCHAR(0x05A8) AS [Aleph with cantillation mark] -- א֨
WHERE NCHAR(0x05D0) =
NCHAR(0x05D0) + NCHAR(0x05A8) COLLATE Hebrew_100_CI_AI_SC;
-- no rows (expected 1 row; all insensitive)¿Necesita distinguir entre formas anchas y no anchas de la misma letra? Hay ocho letras en hebreo que se estiran (ancho) pero solo con el propósito de usar en los rollos de la Torá (ya sea escritos a mano / reales o impresos) para mantener el formato de columna completamente justificado (que en realidad es como aparece en los rollos de la Torá ) SQL Server maneja esto a través de la sensibilidad de ancho / _WSintercalaciones (curiosamente, parece ser la única sensibilidad que funciona correctamente en la versión más reciente 100 y colaciones más nuevas, aunque lamentablemente, es la menos probable que se use):
SELECT NCHAR(0x05DC) AS [Lamed],
NCHAR(0xFB25) AS [Wide Lamed]
WHERE NCHAR(0x05DC) = NCHAR(0xFB25) COLLATE Hebrew_CI_AI;
-- no rows (expected 1 row; all insensitive)
SELECT NCHAR(0x05DC) AS [Lamed],
NCHAR(0xFB25) AS [Wide Lamed]
WHERE NCHAR(0x05DC) = NCHAR(0xFB25) COLLATE Hebrew_100_CS_AS_KS_SC;
-- 1 row (expected; all sensitive except width)
-- Lamed Wide Lamed
-- ל ﬥ
SELECT NCHAR(0x05DC) AS [Lamed],
NCHAR(0xFB25) AS [Wide Lamed]
WHERE NCHAR(0x05DC) = NCHAR(0xFB25) COLLATE Hebrew_100_CI_AI_WS_SC;
-- no rows (expected; all insensitive except width)Entonces, tal vez Hebrew_CI_AIpara las columnas, y puede anular por expresión / predicado a través de la COLLATEinstrucción si necesita usar una variación, como COLLATE Hebrew_CS_AIor Hebrew_CI_ASo Hebrew_CS_AS.
Notas adicionales
Deberá almacenar los datos en NVARCHARcolumnas / variables. Puede lograr la mayor parte de esto en 8 bits normales VARCHARutilizando la página de códigos de Windows-1255 (que es lo que Hebrew_*usan todas las intercalaciones), incluida la combinación de caracteres para vocales y puntos de pronunciación:
;WITH Hebrew AS
(
SELECT NCHAR(0x05E9) + NCHAR(0x05C1) + NCHAR(0x05B8)
COLLATE Hebrew_100_CS_AS AS [Shin]
)
SELECT
Hebrew.[Shin] AS [Unicode],
CONVERT(VARCHAR(20), Hebrew.[Shin]) AS [CodePage1255],
CONVERT(VARBINARY(10), CONVERT(VARCHAR(20), Hebrew.[Shin])) AS [CodePage1255_bytes]
FROM Hebrew;
-- Unicode CodePage1255 CodePage1255_bytes
-- שָׁ שָׁ F9D1C8
Sin embargo, solo el bloque hebreo Unicode contiene las marcas de cantilación (es decir, tropo; puntos de código U + 0591 a U + 05AF) más algunos extras (puntos de código U + 05C4 a U + 05C7), y el bloque de formularios de presentación alfabética contiene el ancho variante de varias letras más algunas otras cosas.
De acuerdo con las reglas oficiales de Unicode CLDR (adaptaciones específicas de la localidad) para la cultura hebrea ("he" y "he-IL"), U + 05F3 HEBREW PUNCTUATION GERESH debe coincidir o venir antes , U + 0027 APOSTROPHE. Normalmente, U + 05F3 se ordena después del apóstrofe. Este comportamiento se ve de hecho cuando se usa la demostración de intercalación de la UCI y se cambia entre el orden de clasificación "raíz" / estándar (utilizado por el inglés de EE. UU. / "En-US") y "él". Sin embargo, este comportamiento no parece estar disponible en .NET o SQL Server:
SELECT NCHAR(0x05F3)
WHERE NCHAR(0x05F3) <= N'''' COLLATE Hebrew_100_CS_AS_KS_WS;
-- no rows
SELECT NCHAR(0x05F3)
WHERE NCHAR(0x05F3) <= N'''' COLLATE Hebrew_CS_AS_KS_WS;
-- no rowsSi bien es una omisión desafortunada, tiene sentido dado que no veo ninguna adaptación específica de "él" o "él-IL" en los archivos de la tabla de clasificación de peso de Windows. Esto bien podría significar que no hay una diferencia real entre las intercalaciones Hebrew_*y Latin1_General_*fuera de la página de códigos asociada, que solo se usa para VARCHARdatos, y que no se aplica aquí.
OP respondió con:
Sí, necesito distinguir entre: 1) formas finales y no finales de la misma letra 2) marcas de pronunciación 3) vocales y 4) marcas de cantilación.
En ese caso, dado que no necesita ignorar las diferencias entre esas propiedades, puede usar las intercalaciones de 100 niveles. El siguiente ejemplo muestra una letra hebrea (Sin) con una marca de pronunciación, una marca de cantilación y una vocal. Hay seis versiones para poder representar cada combinación posible de ordenación de los caracteres combinados. Hay una séptima entrada que usa el otro punto para crear la letra Shin con la misma letra base, vocal y marca de cantilación. La consulta muestra que solo las seis entradas "Sin" coinciden entre sí (incluso con diferentes órdenes de bytes), pero no el "Shin".
Incluí el uso de Latin1_Generaly Japanese_XJIS_140colaciones para mostrar que las reglas también funcionan con ellas en caso de que necesite utilizarlas (las 140colaciones, solo en japonés, tienen más asignaciones en mayúsculas / minúsculas que las versiones anteriores). Pero en general, probablemente sea mejor quedarse con las colaciones hebreas, y usar una no 100versión si necesita ignorar las diferencias en vocales, marcas, puntos y formas finales versus formas no finales.
DECLARE @Shin NVARCHAR(5) = NCHAR(0x05E9), -- base Hebrew letter
@Dot NVARCHAR(5) = NCHAR(0x05C2), -- Sin Dot
@Mark NVARCHAR(5) = NCHAR(0x05A8), -- Cantillation Mark (i.e. trope)
@Vowel NVARCHAR(5) = NCHAR(0x05B8); -- Vowel
DECLARE @Dot_Mark_Vowel NVARCHAR(20) = @Shin + @Dot + @Mark + @Vowel,
@Dot_Vowel_Mark NVARCHAR(20) = @Shin + @Dot + @Vowel + @Mark,
@Vowel_Dot_Mark NVARCHAR(20) = @Shin + @Vowel + @Dot + @Mark,
@Vowel_Mark_Dot NVARCHAR(20) = @Shin + @Vowel + @Mark + @Dot,
@Mark_Vowel_Dot NVARCHAR(20) = @Shin + @Mark + @Vowel + @Dot,
@Mark_Dot_Vowel NVARCHAR(20) = @Shin + @Mark + @Dot + @Vowel,
@ShinDot_Mark_Vowel NVARCHAR(20) = @Shin + NCHAR(0x05C1) + @Mark + @Vowel;
SELECT @Dot_Mark_Vowel AS [Sin], @ShinDot_Mark_Vowel AS [Shin];
;WITH chr AS
(
SELECT *
FROM (VALUES
(@Dot_Mark_Vowel, 'Dot + Mark + Vowel'),
(@Dot_Vowel_Mark, 'Dot + Vowel + Mark'),
(@Vowel_Dot_Mark, 'Vowel + Dot + Mark'),
(@Vowel_Mark_Dot, 'Vowel + Mark + Dot'),
(@Mark_Vowel_Dot, 'Mark + Vowel + Dot'),
(@Mark_Dot_Vowel, 'Mark + Dot + Vowel'),
(@ShinDot_Mark_Vowel, 'ShinDot + Mark + Vowel')
) tmp([Hebrew], [Description])
) SELECT chr1.[Hebrew],
'--' AS [---],
chr1.[Description] AS [Description_1],
CONVERT(VARBINARY(20), RIGHT(chr1.[Hebrew], 3)) AS [Bytes_1],
'--' AS [---],
chr2.[Description] AS [Description_2],
CONVERT(VARBINARY(20), RIGHT(chr2.[Hebrew], 3)) AS [Bytes_2]
FROM chr chr1
CROSS JOIN chr chr2
WHERE chr1.[Description] <> chr2.[Description] -- do not compare item to itself
AND chr1.[Hebrew] = chr2.[Hebrew] COLLATE Hebrew_100_CS_AS_SC
AND chr1.[Hebrew] = chr2.[Hebrew] COLLATE Latin1_General_100_CS_AS_SC
AND chr1.[Hebrew] = chr2.[Hebrew] COLLATE Japanese_XJIS_140_CS_AS;
-- this query returns 30 rowsDepende de muchas cosas. La clasificación es una página de códigos de clasificación, comparación y no Unicode.
Este repositorio tiene una buena lista de opciones en hebreo.
+---------------------------+---------------------------------------------------------------------------------------------------------------------+
| Hebrew_BIN | Hebrew, binary sort |
| Hebrew_BIN2 | Hebrew, binary code point comparison sort |
| Hebrew_CI_AI | Hebrew, case-insensitive, accent-insensitive, kanatype-insensitive, width-insensitive |
| Hebrew_CI_AI_WS | Hebrew, case-insensitive, accent-insensitive, kanatype-insensitive, width-sensitive |
| Hebrew_CI_AI_KS | Hebrew, case-insensitive, accent-insensitive, kanatype-sensitive, width-insensitive |
| Hebrew_CI_AI_KS_WS | Hebrew, case-insensitive, accent-insensitive, kanatype-sensitive, width-sensitive |
| Hebrew_CI_AS | Hebrew, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive |
| Hebrew_CI_AS_WS | Hebrew, case-insensitive, accent-sensitive, kanatype-insensitive, width-sensitive |
| Hebrew_CI_AS_KS | Hebrew, case-insensitive, accent-sensitive, kanatype-sensitive, width-insensitive |
| Hebrew_CI_AS_KS_WS | Hebrew, case-insensitive, accent-sensitive, kanatype-sensitive, width-sensitive |
| Hebrew_CS_AI | Hebrew, case-sensitive, accent-insensitive, kanatype-insensitive, width-insensitive |
| Hebrew_CS_AI_WS | Hebrew, case-sensitive, accent-insensitive, kanatype-insensitive, width-sensitive |
| Hebrew_CS_AI_KS | Hebrew, case-sensitive, accent-insensitive, kanatype-sensitive, width-insensitive |
| Hebrew_CS_AI_KS_WS | Hebrew, case-sensitive, accent-insensitive, kanatype-sensitive, width-sensitive |
| Hebrew_CS_AS | Hebrew, case-sensitive, accent-sensitive, kanatype-insensitive, width-insensitive |
| Hebrew_CS_AS_WS | Hebrew, case-sensitive, accent-sensitive, kanatype-insensitive, width-sensitive |
| Hebrew_CS_AS_KS | Hebrew, case-sensitive, accent-sensitive, kanatype-sensitive, width-insensitive |
| Hebrew_CS_AS_KS_WS | Hebrew, case-sensitive, accent-sensitive, kanatype-sensitive, width-sensitive |
| Hebrew_100_BIN | Hebrew-100, binary sort |
| Hebrew_100_BIN2 | Hebrew-100, binary code point comparison sort |
| Hebrew_100_CI_AI | Hebrew-100, case-insensitive, accent-insensitive, kanatype-insensitive, width-insensitive |
| Hebrew_100_CI_AI_WS | Hebrew-100, case-insensitive, accent-insensitive, kanatype-insensitive, width-sensitive |
| Hebrew_100_CI_AI_KS | Hebrew-100, case-insensitive, accent-insensitive, kanatype-sensitive, width-insensitive |
| Hebrew_100_CI_AI_KS_WS | Hebrew-100, case-insensitive, accent-insensitive, kanatype-sensitive, width-sensitive |
| Hebrew_100_CI_AS | Hebrew-100, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive |
| Hebrew_100_CI_AS_WS | Hebrew-100, case-insensitive, accent-sensitive, kanatype-insensitive, width-sensitive |
| Hebrew_100_CI_AS_KS | Hebrew-100, case-insensitive, accent-sensitive, kanatype-sensitive, width-insensitive |
| Hebrew_100_CI_AS_KS_WS | Hebrew-100, case-insensitive, accent-sensitive, kanatype-sensitive, width-sensitive |
| Hebrew_100_CS_AI | Hebrew-100, case-sensitive, accent-insensitive, kanatype-insensitive, width-insensitive |
| Hebrew_100_CS_AI_WS | Hebrew-100, case-sensitive, accent-insensitive, kanatype-insensitive, width-sensitive |
| Hebrew_100_CS_AI_KS | Hebrew-100, case-sensitive, accent-insensitive, kanatype-sensitive, width-insensitive |
| Hebrew_100_CS_AI_KS_WS | Hebrew-100, case-sensitive, accent-insensitive, kanatype-sensitive, width-sensitive |
| Hebrew_100_CS_AS | Hebrew-100, case-sensitive, accent-sensitive, kanatype-insensitive, width-insensitive |
| Hebrew_100_CS_AS_WS | Hebrew-100, case-sensitive, accent-sensitive, kanatype-insensitive, width-sensitive |
| Hebrew_100_CS_AS_KS | Hebrew-100, case-sensitive, accent-sensitive, kanatype-sensitive, width-insensitive |
| Hebrew_100_CS_AS_KS_WS | Hebrew-100, case-sensitive, accent-sensitive, kanatype-sensitive, width-sensitive |
| Hebrew_100_CI_AI_SC | Hebrew-100, case-insensitive, accent-insensitive, kanatype-insensitive, width-insensitive, supplementary characters |
| Hebrew_100_CI_AI_WS_SC | Hebrew-100, case-insensitive, accent-insensitive, kanatype-insensitive, width-sensitive, supplementary characters |
| Hebrew_100_CI_AI_KS_SC | Hebrew-100, case-insensitive, accent-insensitive, kanatype-sensitive, width-insensitive, supplementary characters |
| Hebrew_100_CI_AI_KS_WS_SC | Hebrew-100, case-insensitive, accent-insensitive, kanatype-sensitive, width-sensitive, supplementary characters |
| Hebrew_100_CI_AS_SC | Hebrew-100, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive, supplementary characters |
| Hebrew_100_CI_AS_WS_SC | Hebrew-100, case-insensitive, accent-sensitive, kanatype-insensitive, width-sensitive, supplementary characters |
| Hebrew_100_CI_AS_KS_SC | Hebrew-100, case-insensitive, accent-sensitive, kanatype-sensitive, width-insensitive, supplementary characters |
| Hebrew_100_CI_AS_KS_WS_SC | Hebrew-100, case-insensitive, accent-sensitive, kanatype-sensitive, width-sensitive, supplementary characters |
| Hebrew_100_CS_AI_SC | Hebrew-100, case-sensitive, accent-insensitive, kanatype-insensitive, width-insensitive, supplementary characters |
| Hebrew_100_CS_AI_WS_SC | Hebrew-100, case-sensitive, accent-insensitive, kanatype-insensitive, width-sensitive, supplementary characters |
| Hebrew_100_CS_AI_KS_SC | Hebrew-100, case-sensitive, accent-insensitive, kanatype-sensitive, width-insensitive, supplementary characters |
| Hebrew_100_CS_AI_KS_WS_SC | Hebrew-100, case-sensitive, accent-insensitive, kanatype-sensitive, width-sensitive, supplementary characters |
| Hebrew_100_CS_AS_SC | Hebrew-100, case-sensitive, accent-sensitive, kanatype-insensitive, width-insensitive, supplementary characters |
| Hebrew_100_CS_AS_WS_SC | Hebrew-100, case-sensitive, accent-sensitive, kanatype-insensitive, width-sensitive, supplementary characters |
| Hebrew_100_CS_AS_KS_SC | Hebrew-100, case-sensitive, accent-sensitive, kanatype-sensitive, width-insensitive, supplementary characters |
| Hebrew_100_CS_AS_KS_WS_SC | Hebrew-100, case-sensitive, accent-sensitive, kanatype-sensitive, width-sensitive, supplementary characters |
+---------------------------+---------------------------------------------------------------------------------------------------------------------+