web-dev-qa-db-fra.com

Quelle collation dois-je utiliser pour l'hébreu biblique?

Quel classement SQL Server dois-je utiliser pour l'hébreu biblique? La base de données à l'étude doit tenir compte des signes diacritiques (c.-à-d. Voyelles, accents, trope, etc.).

sql-serverdatabase-designconfigurationsql-server-2017collation
19
brian12345

Premièrement: Il n'y a aucune distinction, en termes de classement, entre l'hébreu biblique et l'hébreu moderne. Nous avons juste affaire à l'hébreu.

Deuxième:  Indépendamment de quoi que ce soit d'autre, vous souhaitez utiliser le dernier ensemble de classements, qui sont les _100_ séries car elles ont des poids de tri et des règles linguistiques plus récents/plus complets que les anciennes séries sans numéro de version dans le nom (techniquement, c'est la version 80). Normalement, je recommande fortement d'utiliser la dernière version du classement dont vous avez besoin, mais au moins dans ce cas, il y a de bonnes raisons d'utiliser la version sans numéro de version dans le nom. Les classements de la version 100 (ou plus récente) sont beaucoup plus complets et peuvent faire la distinction entre les caractères supplémentaires (ou même les prendre entièrement en charge si vous utilisez un SC ou 140 collation), mais en supposant que vous ne traitez pas avec des caractères supplémentaires, les collations de la version 80 (pas de numéro de version dans le nom) font un meilleur travail de gestion de l'hébreu (voir le point "Sixième" ci-dessous).

Troisièmement: Il n'y a pas de concept de "Kana" (ou de type Kana) en hébreu, vous pouvez donc ignorer toutes les variations de classement avec _KS dans leurs noms (car c'est une sensibilité que vous n'utiliserez jamais).

Forth: Les classements se terminant par _SC prend en charge les caractères supplémentaires (c'est-à-dire UTF-16 complet), il est donc préférable de choisir l'un d'entre eux, si disponible (ce qui signifie: si vous utilisez SQL Server 2012 ou une version plus récente).

Cinquièmement: Vous ne voulez pas de classement binaire (_BIN ou _BIN2) car ceux-ci ne peuvent pas distinguer les lettres hébraïques avec des voyelles et des marques de cantillation qui sont les mêmes mais qui ont les caractères de combinaison dans des ordres différents, et ils ne peuvent pas ignorer les voyelles et autres marques pour assimiler des choses comme א et אֽ.

Par exemple (voyelle et marque de cantillation combinant des caractères dans l'ordre opposé):

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

Sixième: Cela dépend de la façon dont vous allez interagir avec les valeurs de chaîne. L'hébreu n'a pas de lettres majuscules/minuscules, mais il y a quelques points de code qui sont affectés par la sensibilité à la casse. Il y a même quelques points de code qui sont sensibles à la largeur. Les accents sensibles/insensibles affectent les signes diacritiques utilisés pour les voyelles, la prononciation et les marques de cantillation (c.-à-d. Trope).

  1. Avez-vous besoin de faire la distinction entre les formes finales et non finales de la même lettre? Il y a cinq lettres en hébreu qui semblent différentes lorsqu'elles sont utilisées comme dernière lettre d'un mot. SQL Server gère cela via la casse/_CS classements (bien que, malheureusement, il semble être rompu dans les versions plus récentes et généralement meilleures, la version 100 et les versions plus récentes):

    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. Avez-vous besoin de distinguer les marques de prononciation, les voyelles et les marques de cantillation? SQL Server gère cela via la sensibilité aux accents/_AS classements (bien que, malheureusement, il semble être rompu dans les versions plus récentes et généralement meilleures, la version 100 et les versions plus récentes). Veuillez noter que ces trois éléments sont regroupés sous la sensibilité à l'accent et ne peuvent pas être contrôlés séparément (c'est-à-dire que vous ne pouvez pas faire de voyelle mais pas de marque de cantillation).

    Marques de prononciation

    Il y a plusieurs lettres qui ont deux sons différents. Parfois, le seul indicateur pour lequel le son à utiliser est le contexte de quel mot est la lettre (et parfois même les mots environnants), comme dans la Torah réelle (où il n'y a pas de marques de prononciation ou de voyelles). Mais, ce même texte sous d'autres formes, ainsi que d'autres textes, aura des points placés soit à l'intérieur de la lettre, soit pour la lettre Shin, au-dessus de la lettre. La lettre Shin peut avoir un son "sh" ou "s". Pour indiquer le son "sh" (c'est-à-dire la lettre "shin"), il y a un point au-dessus à droite, tandis qu'un point au-dessus à gauche indique le son "s" (lettre "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)

    Voyelles 

    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)

    Marques de cantilation

    Techniquement, selon les données officielles Unicode, les marques de cantillation hébraïques sont ignorables et devrait ne s'inscrire ici que comme différence lors de l'utilisation d'un classement binaire. Cependant, SQL Server les traite de la même manière que les accents (malheureusement) et ne peut pas les ignorer séparément des marques de prononciation ou des voyelles.

    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. Avez-vous besoin de distinguer les formes larges et non larges de la même lettre? Il y a huit lettres en hébreu qui sont étirées (larges) mais uniquement dans le but d'utiliser dans les rouleaux de la Torah (manuscrits/réels ou imprimés) pour garder le format en colonnes entièrement justifié (qui est en fait comment il apparaît dans les rouleaux de la Torah ). SQL Server gère cela via la sensibilité à la largeur/_WS collations (curieusement, il semble que ce soit la seule sensibilité qui fonctionne correctement dans la nouvelle version 100 et les collations plus récentes, mais malheureusement, c'est la moins susceptible d'être utilisée):

    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)

Alors peut être Hebrew_CI_AI pour les colonnes, et vous pouvez remplacer par expression/prédicat via l'instruction COLLATE si vous devez utiliser une variante, telle que COLLATE Hebrew_CS_AI ou Hebrew_CI_AS ou Hebrew_CS_AS.

Notes supplémentaires

  1. Vous devrez stocker les données dans des colonnes/variables NVARCHAR. Vous pouvez accomplir la plupart de cela en 8 bits VARCHAR en utilisant la page de code Windows-1255 (qui est ce que tout Hebrew_* utilisation de collations), y compris la combinaison de caractères pour les voyelles et les points de prononciation:

    ;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

    Cependant, seul le bloc hébreu Unicode contient les marques de cantillation (c.-à-d. Trope; points de code U + 0591 à U + 05AF) plus quelques extras (points de code U + 05C4 à U + 05C7) et le bloc Formulaires de présentation alphabétique contient la variante large de plusieurs lettres ainsi que d'autres éléments.

  2. Veuillez consulter la norme Unicode officielle (version 12.1), chapitre 9: Moyen-Orient-I, section 9.1: hébreu, pages 361-366 (389-394 du PDF) pour une description plus détaillée. description de la façon dont Unicode gère le texte hébreu.

  3. Selon les règles officielles Unicode CLDR (adaptations locales spécifiques) pour la culture hébraïque ("il" et "il-IL"), U + 05F3 HEBREW PUNCTUATION GERESH doit soit correspondre ou venir = avant, U + 0027 APOSTROPHE. Normalement, U + 05F3 trie après apostrophe. Ce comportement est en effet observé lorsque vous utilisez la démonstration de classement ICU et que vous basculez entre "root"/ordre de tri standard (utilisé par l'anglais américain/"en-US") et "he". Cependant, ce comportement ne semble pas être disponible dans .NET ou 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

    Bien qu'il s'agisse d'une omission malheureuse, cela a du sens étant donné que je ne vois pas de personnalisation spécifique à "il" ou "il-IL" dans les fichiers de la table de poids de tri Windows. Cela pourrait très bien signifier qu'il n'y a pas de différence réelle entre le Hebrew_* et Latin1_General_* classements en dehors de la page de codes associée, qui n'est utilisée que pour les données VARCHAR, et qui ne s'applique pas ici.

  4. Veuillez consulter la question et la réponse connexes: Comment supprimer les marques d'accent hébreu

O.P. a répondu par:

Oui, je dois faire la distinction entre: 1) les formes finales et non finales de la même lettre 2) les marques de prononciation 3) les voyelles et 4) les marques de cantillation.

Dans ce cas, puisque vous n'avez pas besoin d'ignorer les différences entre ces propriétés, vous pouvez utiliser les classements de 100 niveaux. L'exemple ci-dessous montre une lettre hébraïque (Sin) avec une marque de prononciation, une marque de cantillation et une voyelle. Il existe six versions afin que chaque combinaison possible de classement des caractères de combinaison puisse être représentée. Il y a une septième entrée qui utilise l'autre point pour créer la lettre Shin avec la même lettre de base, voyelle et marque de cantillation. La requête montre que seules les six entrées "Sin" correspondent (même avec des ordres d'octets différents), mais pas le "Shin".

J'ai inclus l'utilisation de Latin1_General et Japanese_XJIS_140 collations pour montrer que les règles fonctionnent également avec celles-ci au cas où vous auriez besoin de les utiliser (le 140 les classements, uniquement en japonais, ont plus de correspondances majuscules/minuscules que les anciennes versions). Mais en général, il vaut probablement mieux s'en tenir aux classements hébraïques et utiliser un non100 version si vous devez ignorer les différences de voyelles, de marques, de points et de formes finales et non 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 rows
34
Solomon Rutzky

Cela dépend de beaucoup de choses. Le classement consiste à trier, comparer et page de codes non unicode.

Ce dépôt a une bonne liste d'options autour de l'hébreu.

+---------------------------+---------------------------------------------------------------------------------------------------------------------+
| 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         |
+---------------------------+---------------------------------------------------------------------------------------------------------------------+
8
scsimon