Nachfolgend finden Sie fünf Optionen zum Zurückgeben von Zeilen, die in SQL Server Großbuchstaben enthalten.
Beispieldaten
Angenommen, wir haben eine Tabelle mit den folgenden Daten:
SELECT c1 FROM t1;Ergebnis:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | café | | 1café | | eCafé | | James Bond 007 | | JB 007 | | 007 | | NULL | | | | É | | É 123 | | é | | é 123 | | ø | | Ø | +----------------+
Wir können die folgenden Methoden verwenden, um die Zeilen zurückzugeben, die Großbuchstaben enthalten.
Option 1:Vergleichen Sie mit LOWER() Zeichenkette
Wir können den LOWER() verwenden Funktion, um den ursprünglichen Wert mit seinem Äquivalent in Kleinbuchstaben zu vergleichen:
SELECT c1 FROM t1
WHERE LOWER(c1) COLLATE Latin1_General_CS_AS <> c1;Ergebnis:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | | É | | É 123 | | Ø | +----------------+
Durch die Verwendung von ungleich (<> )-Operator (Sie können alternativ != verwenden statt <> Wenn Sie möchten), geben wir nur die Zeilen zurück, die sich von ihren Kleinbuchstaben-Äquivalenten unterscheiden. Der Grund dafür ist, dass, wenn ein Wert mit seinem kleingeschriebenen Äquivalent identisch ist, er bereits von Anfang an kleingeschrieben war (und wir ihn nicht zurückgeben möchten).
Wir verwenden auch COLLATE Latin1_General_CS_AS um explizit eine Kollatierung anzugeben, bei der die Groß-/Kleinschreibung (und Akzente) beachtet werden. Ohne dies könnten Sie abhängig von der auf Ihrem System verwendeten Sortierung unerwartete Ergebnisse erhalten.
Option 2:Mit den tatsächlichen Zeichen vergleichen
Eine weitere Möglichkeit ist die Verwendung des LIKE -Operator und geben Sie die eigentlichen Großbuchstaben an, die wir abgleichen möchten:
SELECT c1 FROM t1
WHERE c1 LIKE '%[ABCDEFGHIJKLMNOPQRSTUVWXYZ]%'
COLLATE Latin1_General_CS_AS;Ergebnis:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | +----------------+
In diesem Fall werden weniger Zeilen zurückgegeben als im vorherigen Beispiel. Das liegt daran, dass ich keine Zeichen wie É angegeben habe und Ø , die im vorherigen Beispiel zurückgegeben wurden. Unser Ergebnis enthält É aber diese Zeile wurde nur zurückgegeben, weil sie auch andere Großbuchstaben enthält, die tun übereinstimmen.
Daher ist diese Option eingeschränkter als die vorherige, bietet Ihnen jedoch mehr Kontrolle über die Zeichen, die Sie abgleichen möchten.
Option 3:Mit einer Reihe von Zeichen vergleichen
Wir können alternativ den Zeichenbereich angeben, den wir abgleichen möchten:
SELECT * FROM t1
WHERE c1 LIKE '%[A-Z]%'
COLLATE Latin1_General_100_BIN2;Ergebnis:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | +----------------+
In diesem Fall habe ich eine binäre Sortierung verwendet (Latin1_General_100_BIN2 ). Ich habe das gemacht, weil binäre Sortierungen jeden Fall separat sortieren (wie hier:AB....YZ...ab...yz ).
Andere Sortierungen neigen dazu, Groß- und Kleinbuchstaben zu vermischen (wie hier:AaBb...YyZz ), die daher sowohl Groß- als auch Kleinbuchstaben entsprechen würde.
Option 4:Finden Sie das erste Vorkommen eines Großbuchstabens
Eine andere Möglichkeit ist die Verwendung von PATINDEX() Funktion:
SELECT * FROM t1
WHERE PATINDEX('%[ABCDEFGHIJKLMNOPQRSTUVWXYZ]%', c1
COLLATE Latin1_General_CS_AS) > 0;Ergebnis:
+----------------+ | c1 | |----------------| | CAFÉ | | Café | | eCafé | | James Bond 007 | | JB 007 | +----------------+
In diesem Beispiel geben wir genau die Zeichen an, die wir abgleichen möchten, und daher haben wir in diesem Fall keine Zeilen mit Zeichen wie É und Ø (mit Ausnahme derjenigen, die auch andere übereinstimmende Zeichen enthält).
Ein Vorteil dieser Technik ist, dass wir sie verwenden können, um das erste Zeichen (oder eine bestimmte Anzahl von Zeichen) zu ignorieren, wenn wir dies wünschen:
SELECT * FROM t1
WHERE PATINDEX('%[ABCDEFGHIJKLMNOPQRSTUVWXYZ]%', c1
COLLATE Latin1_General_CS_AS) > 1;Ergebnis:
Time: 0.472s +-------+ | c1 | |-------| | eCafé | +-------+
Daher können wir alle Zeilen zurückgeben, die Großbuchstaben enthalten, bei denen das erste Zeichen jedoch kein Großbuchstabe ist.
Das liegt daran, dass PATINDEX() gibt die Startposition des ersten Vorkommens des Musters zurück (in unserem Fall ist das Muster eine Liste von Großbuchstaben). Wenn die Anfangsposition des ersten Vorkommens größer als 1 ist, dann ist das erste Zeichen nicht in unserer Liste der Großbuchstaben.
Option 5:Finden Sie die erste Instanz basierend auf einem Bereich
Wir können auch PATINDEX() verwenden mit einem Bereich:
SELECT * FROM t1
WHERE PATINDEX('%[A-Z]%', c1
COLLATE Latin1_General_100_BIN2) > 1;Ergebnis:
+-------+ | c1 | |-------| | eCafé | +-------+
Ich habe wieder eine binäre Sortierung verwendet (wie beim anderen Bereichsbeispiel).
