5 Cara Menemukan Baris yang Mengandung Huruf Besar di SQL Server

Di bawah ini adalah lima opsi untuk mengembalikan baris yang berisi huruf besar di SQL Server.

Contoh Data

Misalkan kita memiliki tabel dengan data berikut:

SELECT c1 FROM t1;

Hasil:

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

Kita dapat menggunakan metode berikut untuk mengembalikan baris yang berisi huruf besar.

Opsi 1:Bandingkan dengan LOWER() String

Kita dapat menggunakan LOWER() fungsi untuk membandingkan nilai asli dengan ekuivalen huruf kecilnya:

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

Hasil:

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

Dengan menggunakan tidak sama dengan (<> ) operator (sebagai alternatif, Anda dapat menggunakan != bukannya <> jika Anda mau), kami hanya mengembalikan baris yang berbeda dengan persamaan huruf kecilnya. Alasan kami melakukan ini adalah karena, jika suatu nilai sama dengan ekuivalen huruf kecilnya, maka itu adalah huruf kecil untuk memulainya (dan kami tidak ingin mengembalikannya).

Kami juga menggunakan COLLATE Latin1_General_CS_AS untuk secara eksplisit menentukan susunan peka huruf besar/kecil (dan peka aksen). Tanpa ini, Anda bisa mendapatkan hasil yang tidak diharapkan, tergantung pada susunan yang digunakan pada sistem Anda.

Opsi 2:Bandingkan dengan Karakter Sebenarnya

Pilihan lainnya adalah dengan menggunakan LIKE operator dan tentukan karakter huruf besar sebenarnya yang ingin kita cocokkan:

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

Hasil:

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

Dalam hal ini, lebih sedikit baris yang dikembalikan daripada contoh sebelumnya. Ini karena saya tidak menentukan karakter seperti É dan Ø , yang dikembalikan dalam contoh sebelumnya. Hasil kami memang mengandung É tetapi baris itu hanya dikembalikan karena juga berisi karakter huruf besar lain yang lakukan cocok.

Oleh karena itu, opsi ini lebih terbatas daripada yang sebelumnya, tetapi memberikan Anda kontrol lebih besar atas karakter yang ingin Anda cocokkan.

Opsi 3:Bandingkan dengan Rentang Karakter

Sebagai alternatif, kita dapat menentukan rentang karakter yang ingin kita cocokkan:

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

Hasil:

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

Dalam hal ini, saya menggunakan susunan biner (Latin1_General_100_BIN2 ). Saya melakukan ini karena susunan biner mengurutkan setiap kasus secara terpisah (seperti ini:AB....YZ...ab...yz ).

Susunan lain cenderung mencampurkan huruf besar dan huruf kecil (seperti ini:AaBb...YyZz ), yang karenanya akan cocok dengan karakter huruf besar dan kecil.

Opsi 4:Temukan Instance Pertama dari Karakter Huruf Besar

Cara lain untuk melakukannya adalah dengan menggunakan PATINDEX() fungsi:

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

Hasil:

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

Dalam contoh ini, kami menentukan karakter persis yang ingin kami cocokkan, dan dalam hal ini, kami tidak mendapatkan baris dengan karakter seperti É dan Ø (selain yang juga berisi karakter lain yang cocok).

Salah satu manfaat dari teknik ini adalah kita dapat menggunakannya untuk mengabaikan karakter pertama (atau jumlah karakter tertentu) jika kita menginginkannya:

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

Hasil:

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

Oleh karena itu, kami dapat mengembalikan semua baris yang berisi karakter huruf besar, tetapi karakter pertama bukan huruf besar.

Ini karena PATINDEX() mengembalikan posisi awal kemunculan pola pertama (dalam kasus kami, pola adalah daftar karakter huruf besar). Jika posisi awal kemunculan pertama lebih besar dari 1, maka karakter pertama tidak ada dalam daftar karakter huruf besar kami.

Opsi 5:Temukan Instance Pertama Berdasarkan Rentang

Kita juga bisa menggunakan PATINDEX() dengan rentang:

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

Hasil:

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

Saya kembali menggunakan susunan biner (seperti dengan contoh rentang lainnya).