5 sposobów znajdowania wierszy zawierających wielkie litery w SQL Server

Poniżej znajduje się pięć opcji zwracania wierszy zawierających duże litery w SQL Server.

Przykładowe dane

Załóżmy, że mamy tabelę z następującymi danymi:

SELECT c1 FROM t1;

Wynik:

+----------------+
| c1             |
|----------------|
| CAFÉ           |
| Café           |
| café           |
| 1café          |
| eCafé          |
| James Bond 007 |
| JB 007         |
| 007            |
| NULL           |
|                |
| É              |
| É 123          |
| é              |
| é 123          |
| ø              |
| Ø              |
+----------------+

Możemy użyć następujących metod, aby zwrócić wiersze zawierające duże litery.

Opcja 1:Porównaj z LOWER() Ciąg

Możemy użyć LOWER() funkcja do porównania oryginalnej wartości z jej odpowiednikiem małymi literami:

SELECT c1 FROM t1
WHERE LOWER(c1) COLLATE Latin1_General_CS_AS <> c1;

Wynik:

+----------------+
| c1             |
|----------------|
| CAFÉ           |
| Café           |
| eCafé          |
| James Bond 007 |
| JB 007         |
| É              |
| É 123          |
| Ø              |
+----------------+

Używając nie równego (<> ) operator (możesz alternatywnie użyć != zamiast <> jeśli wolisz), zwracamy tylko te wiersze, które różnią się od ich odpowiedników pisanych małymi literami. Powodem, dla którego to robimy, jest to, że jeśli wartość jest taka sama jak jej odpowiednik małymi literami, to na początku była już mała (i nie chcemy jej zwracać).

Używamy również COLLATE Latin1_General_CS_AS aby jawnie określić sortowanie z uwzględnieniem wielkości liter (i akcentu). Bez tego możesz uzyskać nieoczekiwane wyniki, w zależności od sortowania używanego w twoim systemie.

Opcja 2:Porównaj z rzeczywistymi znakami

Inną opcją jest użycie LIKE operatora i określ rzeczywiste wielkie litery, które chcemy dopasować:

SELECT c1 FROM t1
WHERE c1 LIKE '%[ABCDEFGHIJKLMNOPQRSTUVWXYZ]%'
COLLATE Latin1_General_CS_AS;

Wynik:

+----------------+
| c1             |
|----------------|
| CAFÉ           |
| Café           |
| eCafé          |
| James Bond 007 |
| JB 007         |
+----------------+

W takim przypadku zwracanych jest mniej wierszy niż w poprzednim przykładzie. Dzieje się tak, ponieważ nie określiłem znaków takich jak É i Ø , które zostały zwrócone w poprzednim przykładzie. Nasz wynik zawiera É ale ten wiersz został zwrócony tylko dlatego, że zawiera również inne wielkie litery, które wykonaj dopasuj.

Dlatego ta opcja jest bardziej ograniczona niż poprzednia, ale zapewnia większą kontrolę nad postaciami, które chcesz dopasować.

Opcja 3:Porównaj z zakresem znaków

Możemy alternatywnie określić zakres znaków, które chcemy dopasować:

SELECT * FROM t1
WHERE c1 LIKE '%[A-Z]%'
COLLATE Latin1_General_100_BIN2;

Wynik:

+----------------+
| c1             |
|----------------|
| CAFÉ           |
| Café           |
| eCafé          |
| James Bond 007 |
| JB 007         |
+----------------+

W tym przypadku użyłem zestawienia binarnego (Latin1_General_100_BIN2 ). Zrobiłem to, ponieważ układy binarne sortują każdy przypadek osobno (w ten sposób:AB....YZ...ab...yz ).

Inne porównania mają tendencję do przeplatania wielkich i małych liter (na przykład:AaBb...YyZz ), które w związku z tym pasują zarówno do wielkich, jak i małych liter.

Opcja 4:Znajdź pierwsze wystąpienie wielkiego znaku

Innym sposobem na to jest użycie PATINDEX() funkcja:

SELECT * FROM t1
WHERE PATINDEX('%[ABCDEFGHIJKLMNOPQRSTUVWXYZ]%', c1
COLLATE Latin1_General_CS_AS) > 0;

Wynik:

+----------------+
| c1             |
|----------------|
| CAFÉ           |
| Café           |
| eCafé          |
| James Bond 007 |
| JB 007         |
+----------------+

W tym przykładzie dokładnie określamy znaki, które chcemy dopasować, więc w tym przypadku nie otrzymaliśmy wierszy ze znakami jak É i Ø (inny niż ten, który zawiera również inne dopasowane znaki).

Jedną z zalet tej techniki jest to, że możemy jej użyć do zignorowania pierwszego znaku (lub określonej liczby znaków), jeśli sobie tego życzymy:

SELECT * FROM t1
WHERE PATINDEX('%[ABCDEFGHIJKLMNOPQRSTUVWXYZ]%', c1
COLLATE Latin1_General_CS_AS) > 1;

Wynik:

Time: 0.472s
+-------+
| c1    |
|-------|
| eCafé |
+-------+

Dlatego możemy zwrócić wszystkie wiersze, które zawierają wielkie litery, ale pierwszy znak nie jest wielkimi literami.

Dzieje się tak, ponieważ PATINDEX() zwraca pozycję początkową pierwszego wystąpienia wzorca (w naszym przypadku wzorzec jest listą wielkich liter). Jeśli pozycja początkowa pierwszego wystąpienia jest większa niż 1, to pierwszego znaku nie ma na naszej liście wielkich liter.

Opcja 5:Znajdź pierwszą instancję na podstawie zakresu

Możemy również użyć PATINDEX() z zakresem:

SELECT * FROM t1
WHERE PATINDEX('%[A-Z]%', c1
COLLATE Latin1_General_100_BIN2) > 1;

Wynik:

+-------+
| c1    |
|-------|
| eCafé |
+-------+

Ponownie użyłem zestawienia binarnego (jak w innym przykładzie zakresu).