Quali regole di confronto di SQL Server dovrei usare per l'ebraico biblico? Il database in esame deve accogliere i segni diacritici (ad esempio vocali, accenti, trope, ecc.).
Quali regole di confronto di SQL Server dovrei usare per l'ebraico biblico? Il database in esame deve accogliere i segni diacritici (ad esempio vocali, accenti, trope, ecc.).
Risposte:
Primo: non c'è distinzione, dal punto di vista della collazione, tra l'ebraico biblico e l'ebraico moderno. Abbiamo solo a che fare con l'ebraico.
Secondo: Indipendentemente da qualsiasi altra cosa, si desidera utilizzare la più recente serie di regole di confronto, che sono le Normalmente consiglio vivamente di utilizzare la versione più recente di qualsiasi fascicolo di cui hai bisogno, ma almeno in questo caso vi sono buone ragioni per utilizzare la versione senza numero di versione nel nome. Le regole di confronto versione 100 (o più recenti) sono molto più complete e possono distinguere tra caratteri supplementari (o persino supportarli completamente se si utilizza uno _100_ serie in quanto hanno pesi di ordinamento e regole linguistiche più recenti / più completi rispetto alle serie precedenti senza numero di versione nel nome (tecnicamente sono la versione 80).SCo 140regole di confronto), ma supponendo che non si tratti di caratteri supplementari, quindi la versione 80 (nessuna versione numero in nome) le regole di confronto fanno un lavoro migliore nella gestione dell'ebraico (vedi la voce "Sesta" di seguito).
Terzo: non esiste il concetto di "Kana" (o tipo Kana) in ebraico, quindi puoi ignorare qualsiasi delle varianti di confronto con _KSnei loro nomi (in quanto questa è una sensibilità che non userai mai).
Avanti: le regole di confronto che _SCsupportano i caratteri supplementari (ovvero UTF-16 completo), quindi di solito è meglio sceglierne uno, se disponibile (ovvero: se si utilizza SQL Server 2012 o versioni successive).
Quinto: non si desidera un confronto binario ( _BINo _BIN2) in quanto quelli non sono in grado di distinguere tra lettere ebraiche con vocali e segni di cantillazione che sono uguali ma che hanno i caratteri combinati in ordini diversi, né possono ignorare vocali e altri segni per equiparare cose come אe אֽ.
Ad esempio (vocale e segno di cantillazione che combinano caratteri in ordine opposto):
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 rowsSesto: dipende da come interagirai con i valori di stringa. L'ebraico non ha lettere maiuscole / minuscole, tuttavia ci sono alcuni punti di codice che sono influenzati dalla distinzione tra maiuscole e minuscole. Ci sono anche alcuni punti di codice sensibili alla larghezza. Sensibile all'accento / insensibile colpisce i segni diacritici usati per vocali, pronuncia e segni di cantillazione (cioè trope).
Devi distinguere tra le forme finali e non finali della stessa lettera? Ci sono cinque lettere in ebraico che sembrano diverse se usate come l'ultima lettera di una parola. SQL Server gestisce questo tramite maiuscole / minuscole _CS(anche se, sfortunatamente, sembra essere rotto nelle versioni più recenti, e di solito migliori, nella versione 100 e nelle versioni più recenti):
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)Devi distinguere tra segni di pronuncia, vocali e segni di cantillazione? SQL Server gestisce questo tramite l'accento-sensibilità / _ASregole di confronto (anche se, sfortunatamente, sembra essere rotto nelle versioni più recenti e di solito migliori, versione 100 e regole più recenti). Si noti che tutti e tre questi sono raggruppati in base alla sensibilità all'accento e non possono essere controllati separatamente (cioè non si può fare la vocale vocale ma il segno di cantillazione è insensibile).
Segni di pronuncia
Esistono diverse lettere che hanno due suoni diversi. A volte l'unico indicatore per cui utilizzare il suono è il contesto di quale parola si trova la lettera (e talvolta anche le parole circostanti), come nella Torà reale (dove non ci sono segni di pronuncia o vocali). Ma lo stesso testo in altre forme, così come altri testi, avrà dei punti posizionati all'interno della lettera, o per la lettera Shin, sopra la lettera. La lettera Shin può avere un suono "sh" o "s". Per indicare il suono "sh" (cioè la lettera "shin"), c'è un punto sopra sul lato destro, mentre un punto sopra sul lato sinistro indica il suono "s" (lettera "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)vocali
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)Segni di cantilazione
Tecnicamente, secondo i dati Unicode ufficiali, i segni di cantillazione ebraici sono ignorabili e dovrebbero registrarsi come differenza qui solo quando si usa un confronto binario. Tuttavia, SQL Server li tratta allo stesso modo degli accenti (sfortunatamente) e non può ignorarli separatamente dai segni di pronuncia o vocali.
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)Devi distinguere tra forme larghe e non larghe della stessa lettera? Ci sono otto lettere in ebraico che sono allungate (larghe) ma solo allo scopo di usare nei rotoli della Torah (scritti a mano / reali o stampati) per mantenere il formato colonnare pienamente giustificato (che è in realtà come appare nei rotoli della Torah ). SQL Server gestisce questa funzione tramite la larghezza di sensibilità / _WSregole di confronto (abbastanza interessante, sembra essere l'unica sensibilità che funziona correttamente nella versione 100 più recente e nelle regole di confronto più recenti, sebbene purtroppo sia la meno probabile che venga utilizzata):
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)Quindi, forse Hebrew_CI_AIper le colonne, e puoi eseguire l'override per espressione / predicato tramite l' COLLATEistruzione se devi utilizzare una variazione, come COLLATE Hebrew_CS_AIo Hebrew_CI_ASo Hebrew_CS_AS.
Note aggiuntive
Dovrai archiviare i dati in NVARCHARcolonne / variabili. Puoi ottenere la maggior parte di questo in 8 bit regolari VARCHARusando la codepage di Windows 1255 (che è quella che Hebrew_*usano tutte le regole di confronto), inclusa la combinazione di caratteri per vocali e punti di pronuncia:
;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
Tuttavia, solo il blocco ebraico Unicode contiene i segni di cantillazione (cioè trope; punti di codice da U + 0591 a U + 05AF) più alcuni extra (punti di codice da U + 05C4 a U + 05C7) e il blocco Alphabetic Presentation Forms contiene l'ampio variante di più lettere più alcune altre cose.
Secondo le regole ufficiali Unicode CLDR (tailorings specifiche del locale) per la cultura ebraica ("lui" e "he-IL"), U + 05F3 HEBREW PUNCTUATION GERESH dovrebbe corrispondere o venire prima , U + 0027 APOSTROPHE. Normalmente, U + 05F3 ordina dopo l' apostrofo. Questo comportamento si vede infatti quando si utilizza la demo delle regole di confronto ICU e si passa dall'ordinamento "root" / standard (utilizzato dall'inglese americano / "en-US") a "lui". Tuttavia, questo comportamento non sembra essere disponibile in .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 rowsSebbene sia una sfortunata omissione, ha senso dato che non vedo alcun adattamento specifico per "lui" o "he-IL" nei file della tabella dei pesi di ordinamento di Windows. Ciò potrebbe benissimo significare che non esiste alcuna differenza effettiva tra Hebrew_*e Latin1_General_*regole di confronto al di fuori della tabella codici associata, che viene utilizzata solo per i VARCHARdati e che non si applica qui.
OP ha risposto con:
Sì, devo distinguere tra: 1) forme finali e non finali della stessa lettera 2) segni di pronuncia 3) vocali e 4) segni di cantillazione.
In tal caso, poiché non è necessario ignorare le differenze tra tali proprietà, è possibile utilizzare le regole di confronto di livello 100. L'esempio seguente mostra una lettera ebraica (Sin) con un segno di pronuncia, un segno di cantillazione e una vocale. Esistono sei versioni in modo che ogni possibile combinazione di ordinamento dei caratteri combinati possa essere rappresentata. C'è una settima voce che usa l'altro punto per creare la lettera Shin con la stessa lettera di base, vocale e segno di cantillazione. La query mostra che solo le sei voci "Sin" corrispondono (anche con ordini di byte diversi), ma non "Shin".
Ho incluso l'uso Latin1_Generale le Japanese_XJIS_140regole di confronto per dimostrare che le regole funzionano anche con quelle nel caso in cui sia necessario utilizzarle (le 140regole di confronto, solo in giapponese, hanno più mappature maiuscole / minuscole rispetto alle versioni precedenti). Ma in generale, probabilmente è meglio attenersi alle regole di confronto ebraiche e utilizzare una non 100versione se è necessario ignorare le differenze di vocali, segni, punti e forme finali e non finali.
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 rowsDipende da molte cose. Fascicolazione è ordinamento, confronto e code page non Unicode.
Questo repository ha una buona lista di opzioni intorno all'ebraico.
+---------------------------+---------------------------------------------------------------------------------------------------------------------+
| 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 |
+---------------------------+---------------------------------------------------------------------------------------------------------------------+