In MariaDB die BINARY -Operator wandelt die ihm folgende Zeichenfolge in eine binäre Zeichenfolge um.
Der BINARY -Operator können Sie einen Spaltenvergleich Byte für Byte statt Zeichen für Zeichen durchführen. Dadurch wird beim Vergleich zwischen Groß- und Kleinschreibung unterschieden, auch wenn die Spalte nicht als BINARY definiert ist oder BLOB . Es bedeutet auch, dass vorangestellte/nachgestellte Leerzeichen signifikant werden.
Beispiel
Hier ist ein einfaches Beispiel:
SELECT BINARY 'Cat';Ergebnis:
+--------------+ | BINARY 'Cat' | +--------------+ | Cat | +--------------+
Dieses Beispiel zeigt nicht wirklich, wie die BINARY -Operator kann Zeichenfolgenvergleiche beeinflussen. Die folgenden Beispiele tun dies.
Führende/nachgestellte Leerzeichen
Wie bereits erwähnt, sind führende und abschließende Leerzeichen wichtig, wenn Zeichenketten byteweise verglichen werden (z. B. mit BINARY ).
Hier ist zunächst ein Zeichenfolgenvergleich ohne führende oder abschließende Leerzeichen:
SELECT
'Cat' = 'Cat',
BINARY 'Cat' = 'Cat';Ergebnis:
+---------------+----------------------+ | 'Cat' = 'Cat' | BINARY 'Cat' = 'Cat' | +---------------+----------------------+ | 1 | 1 | +---------------+----------------------+
Wir erhalten den gleichen Rückgabewert, egal ob wir BINARY verwenden oder nicht.
Aber Folgendes passiert, wenn wir einem der Strings nachgestellte Leerzeichen hinzufügen:
SELECT
'Cat' = 'Cat ',
BINARY 'Cat' = 'Cat ',
'Cat' = BINARY 'Cat ',
BINARY 'Cat' = BINARY 'Cat ';Ergebnis:
+----------------+-----------------------+-----------------------+------------------------------+ | 'Cat' = 'Cat ' | BINARY 'Cat' = 'Cat ' | 'Cat' = BINARY 'Cat ' | BINARY 'Cat' = BINARY 'Cat ' | +----------------+-----------------------+-----------------------+------------------------------+ | 1 | 0 | 0 | 0 | +----------------+-----------------------+-----------------------+------------------------------+
Der erste gibt 1 zurück während die anderen (also die mit BINARY ) gibt 0 zurück .
Um sicherzugehen, vergleichen wir Strings, die beide Leerzeichen am Ende haben:
SELECT
'Cat ' = BINARY 'Cat ',
BINARY 'Cat ' = BINARY 'Cat ';Ergebnis:
+------------------------+-------------------------------+ | 'Cat ' = BINARY 'Cat ' | BINARY 'Cat ' = BINARY 'Cat ' | +------------------------+-------------------------------+ | 1 | 1 | +------------------------+-------------------------------+
Denken Sie daran, dass wir hier nur über führende und nachfolgende Leerzeichen sprechen. Dieses Konzept gilt nicht für Leerzeichen in der Mitte einer Zeichenfolge.
Beispielsweise sind zwei Leerzeichen in einem String nicht gleich einem Leerzeichen – auch ohne Verwendung des BINARY Betreiber:
SELECT 'Homer Jay' = 'Homer Jay';Ergebnis:
+----------------------------+ | 'Homer Jay' = 'Homer Jay' | +----------------------------+ | 0 | +----------------------------+
In diesem Fall enthält die erste Zeichenfolge ein Leerzeichen und die zweite zwei Leerzeichen. Das reicht aus, damit sie ungleich sind, selbst wenn ein Zeichen-für-Zeichen-Vergleich verwendet wird.
Groß-/Kleinschreibung
Der BINARY -Operator erzwingt einen Vergleich mit Berücksichtigung der Groß-/Kleinschreibung, selbst wenn bei der Sortierung die Groß-/Kleinschreibung nicht beachtet wird.
Hier ist zum Beispiel meine Verbindungssortierung:
SELECT @@collation_connection;Ergebnis:
+------------------------+ | @@collation_connection | +------------------------+ | utf8_general_ci | +------------------------+
Die ci am Ende bedeutet Groß-/Kleinschreibung .
Hier ist ein Beispiel für einen Zeichenfolgenvergleich von Groß- und Kleinbuchstaben:
SELECT
'cat' = 'CAT',
BINARY 'cat' = 'CAT';Ergebnis:
+---------------+----------------------+ | 'cat' = 'CAT' | BINARY 'cat' = 'CAT' | +---------------+----------------------+ | 1 | 0 | +---------------+----------------------+
Der erste Vergleich hat 1 zurückgegeben, da bei meiner Sortierung die Groß-/Kleinschreibung nicht beachtet wird. Der zweite gab 0 zurück , weil wir den BINARY verwenden Betreiber.
Die Ergebnisse, die man mit solchen String-Vergleichen erhält (ohne die BINARY Operator) hängt von Ihrer Sortierung ab. Die Verwendung einer Sortierung mit Berücksichtigung der Groß-/Kleinschreibung gibt das gleiche Ergebnis zurück, das wir mit BINARY erhalten haben .
Hier ist ein Beispiel zur Veranschaulichung:
SELECT
_latin1'cat' COLLATE latin1_general_ci = 'CAT' AS 'ci',
_latin1'cat' COLLATE latin1_general_cs = 'CAT' AS 'cs',
BINARY 'cat' = 'CAT';Ergebnis:
+------+------+----------------------+ | ci | cs | BINARY 'cat' = 'CAT' | +------+------+----------------------+ | 1 | 0 | 0 | +------+------+----------------------+
Hier habe ich den Zeichensatz und die Sortierung explizit auf Stringebene angegeben. Die Syntax dafür sieht folgendermaßen aus:
[_charset_name]'string' [COLLATE collation_name]
Wir können sehen, dass die Sortierung ohne Berücksichtigung der Groß-/Kleinschreibung ein anderes Ergebnis zurückgegeben hat als die Sortierung mit Berücksichtigung der Groß- und Kleinschreibung. Und die Sortierung mit Berücksichtigung der Groß-/Kleinschreibung hat das gleiche Ergebnis zurückgegeben, das wir erhalten, wenn wir BINARY verwenden Betreiber.
