Que agrupamento devo usar para o hebraico bíblico?

Respostas:

34

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 _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).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 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 rows

Sexto: 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).

  1. 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)
  2. 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)
  3. 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

  1. 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.

  2. Consulte o Padrão Unicode oficial (Versão 12.1), Capítulo 9: Oriente Médio-I, Seção 9.1: Hebraico, páginas 361-366 (389-394 do PDF) para obter uma descrição mais detalhada de como o Unicode lida com texto hebraico.
  3. 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 rows

    Embora 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.

  4. Consulte as perguntas e respostas relacionadas: Como remover marcas de acento hebraico

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 rows
Solomon Rutzky
fonte
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.
brian12345 23/10
1
@ brian12345 Obrigado por essa atualização. Atualizo minha resposta para abordar esse esclarecimento em uma nova seção final da resposta. Por favor revise.
Solomon Rutzky 23/10
Obrigado, Salomão. Muito útil.
brian12345 28/10
8

Isso 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         |
+---------------------------+---------------------------------------------------------------------------------------------------------------------+
scsimon
fonte