Qual agrupamento do SQL Server devo usar para o hebraico bíblico? O banco de dados em consideração precisa acomodar sinais diacríticos (ou seja, vogais, acentos, tropas etc.).
Qual agrupamento do SQL Server devo usar para o hebraico bíblico? O banco de dados em consideração precisa acomodar sinais diacríticos (ou seja, vogais, acentos, tropas etc.).
Respostas:
Primeiro: Não há distinção, em termos de agrupamento, entre o hebraico bíblico e o hebraico moderno. Estamos apenas lidando com hebraico.
Segundo: Independentemente de qualquer outra coisa, você deseja usar o conjunto mais recente de agrupamentos, que são as Normalmente, eu recomendo usar a versão mais recente de qualquer agrupamento necessário, mas pelo menos nesse caso, há um bom motivo para usar a versão sem número de versão no nome. Os agrupamentos da versão 100 (ou mais recente) são muito mais completos e podem distinguir entre caracteres suplementares (ou mesmo suportá-los totalmente se usar um _100_séries, pois possuem pesos de classificação e regras lingüísticas mais novos / mais completos do que as séries mais antigas sem número de versão no nome (tecnicamente, a versão are 80).SCou 140agrupamento), mas assumindo que você não está lidando com caracteres complementares, a versão 80 (sem versão agrupamentos de número no nome) fazem um trabalho melhor no manuseio de hebraico (consulte o item "Sexto" abaixo).
Terceiro: não existe o conceito de "Kana" (ou tipo Kana) em hebraico, portanto você pode ignorar qualquer variação de agrupamento _KSnos nomes (pois essa é uma sensibilidade que você nunca usará).
Quarto: Os agrupamentos que terminam em _SCcaracteres suplementares de suporte (ou seja, UTF-16 completo) geralmente são melhores para escolher um deles, se disponível (ou seja: se você estiver usando o SQL Server 2012 ou mais recente).
Quinto: você não deseja um agrupamento binário ( _BINou _BIN2), pois eles não conseguem distinguir entre letras hebraicas com vogais e sinais de cantilação iguais, mas possuem caracteres combinados em ordens diferentes, nem podem ignorar vogais e outras marcas para igualar coisas como אe אֽ.
Por exemplo (vogal e ponto de cantilação combinando caracteres na ordem oposta):
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 como você estará interagindo com os valores da string. O hebraico não possui letras maiúsculas / minúsculas, mas existem alguns pontos de código afetados pela distinção entre maiúsculas e minúsculas. Existem até alguns pontos de código sensíveis à largura. Sensível a sotaque / insensível afeta os diacríticos usados para vogais, pronúncia e marcas de cantilação (isto é, tropeço).
Você precisa distinguir entre as formas final e não final da mesma letra? Existem cinco letras em hebraico que parecem diferentes quando usadas como a letra final de uma palavra. O SQL Server lida com isso por meio de distinção entre maiúsculas e minúsculas / _CSagrupamentos (embora, infelizmente, pareça estar quebrado na versão mais recente e, geralmente, melhor, na versão 100 e nos agrupamentos mais recentes):
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)Você precisa distinguir entre marcas de pronúncia, vogais e marcas de cantilação? O SQL Server lida com isso por meio de sensibilidade ao acento / _ASagrupamentos (embora, infelizmente, pareça estar quebrado na versão mais recente e, geralmente melhor, na versão 100 e nos agrupamentos mais recentes). Observe que todos os três são agrupados sob sensibilidade ao sotaque e não podem ser controlados separadamente (ou seja, não é possível fazer a vogal sensível, mas o sinal de cantilação é insensível).
Marcas de pronúncia
Existem várias letras que têm dois sons diferentes. Às vezes, o único indicador para o qual o som usar é o contexto de qual palavra a letra está (e algumas vezes até as palavras ao redor), como na Torá real (onde não há marcas de pronúncia ou vogais). Mas, esse mesmo texto em outras formas, bem como em outro texto, terá pontos colocados dentro da letra ou para a letra Shin, acima da letra. A letra Shin pode ter um som "sh" ou "s". Para indicar o som "sh" (ou seja, letra "shin"), existe um ponto acima no lado direito, enquanto um ponto acima no lado esquerdo indica o som "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)Vogais
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 modulação
Tecnicamente, de acordo com os dados oficiais do Unicode, os sinais de cantilação hebraica são ignoráveis e só devem ser registrados aqui como diferença ao usar um agrupamento binário. No entanto, o SQL Server os trata da mesma forma que os acentos (infelizmente) e não pode ignorá-los separadamente das marcas ou vogais de pronúncia.
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)Você precisa distinguir entre formas amplas e não amplas da mesma letra? Existem oito letras em hebraico que são esticadas (largas), mas apenas com o objetivo de usar nos pergaminhos da Torá (escritos à mão / reais ou impressos) para manter o formato colunar totalmente justificado (que é realmente o que aparece nos pergaminhos da Torá ) O SQL Server lida com isso por sensibilidade à largura / _WSagrupamentos (curiosamente, parece ser a única sensibilidade que funciona corretamente na versão mais recente 100 e nos agrupamentos mais recentes, embora, infelizmente, seja o menos provável):
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)Portanto, talvez Hebrew_CI_AIpara as colunas, e você pode substituir por expressão / predicado por meio da COLLATEinstrução se precisar usar uma variação, como COLLATE Hebrew_CS_AIou Hebrew_CI_ASou Hebrew_CS_AS.
Notas Adicionais
Você precisará armazenar os dados em NVARCHARcolunas / variáveis. Você poderia realizar mais disso em regulares de 8 bits VARCHARusando o -1255 do Windows página de código (que é o que todos os Hebrew_*agrupamentos usar), incluindo combinando caracteres para as vogais e pronúncia pontos:
;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
No entanto, apenas o bloco hebraico Unicode contém os sinais de cantilação (ou seja, trope; pontos de código U + 0591 a U + 05AF) mais alguns extras (pontos de código U + 05C4 a U + 05C7), e o bloco de formas de apresentação alfabética contém a ampla variante de várias letras mais algumas outras coisas.
De acordo com as regras oficiais do Unicode CLDR (alfaiates específicos do código de idioma) para a cultura hebraica ("he" e "he-IL"), o U + 05F3 HEBREW PUNCTUATION GERESH deve corresponder ou vir antes do APOSTROPHE U + 0027. Normalmente, U + 05F3 é classificada após o apóstrofo. Esse comportamento é realmente observado ao usar a demonstração de agrupamento de ICU e alternar entre a ordem de classificação "raiz" / padrão (usada pelo inglês dos EUA / "en-US") e "ele". No entanto, esse comportamento não parece estar disponível no .NET ou no 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 rowsEmbora seja uma omissão infeliz, faz sentido, pois não vejo nenhum alfaiate específico para "he" ou "he-IL" nos arquivos da tabela de classificação de peso do Windows. Isso pode muito bem significar que não há diferença real entre os agrupamentos Hebrew_*e Latin1_General_*fora da página de código associada, que é usada apenas para VARCHARdados e que não se aplica aqui.
OP respondeu com:
Sim, preciso distinguir entre: 1) formas finais e não finais da mesma letra 2) marcas de pronúncia 3) vogais e 4) marcas de cantilação.
Nesse caso, como você não precisa ignorar as diferenças entre essas propriedades, é possível usar os agrupamentos de 100 níveis. O exemplo abaixo mostra uma letra hebraica (Sin) com uma marca de pronúncia, uma marca de cantilação e uma vogal. Existem seis versões para que cada combinação possível de ordenação dos caracteres combinados possa ser representada. Existe uma sétima entrada que usa o outro ponto para criar a letra Shin com a mesma letra de base, vogal e marca de cantilação. A consulta mostra que apenas as seis entradas "Sin" correspondem uma à outra (mesmo com ordens de bytes diferentes), mas não a "Shin".
Incluí o uso de Latin1_Generale Japanese_XJIS_140agrupamentos para mostrar que as regras funcionam com elas também, caso você precise usá-las (os 140agrupamentos, apenas em japonês, têm mais mapeamentos em maiúsculas / minúsculas do que nas versões anteriores). Mas, em geral, provavelmente é melhor seguir as ordenações hebraicas e usar uma não- 100versão se precisar ignorar as diferenças de vogais, marcas, pontos e formas final versus não final.
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 rowsIsso depende de muitas coisas. Agrupar é classificar, comparar e página de códigos não unicode.
Este repositório tem uma boa lista de opções em hebraico.
+---------------------------+---------------------------------------------------------------------------------------------------------------------+
| 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 |
+---------------------------+---------------------------------------------------------------------------------------------------------------------+