3 Cara menggunakan SEMUA di SQL Server

Anda mungkin familiar dengan ALL pilihan di SQL Server. Mungkin Anda pernah menggunakannya bersama dengan UNION operator untuk menyertakan duplikat apa pun yang mungkin dikembalikan dalam kumpulan hasil.

Tapi tahukah Anda bahwa ALL juga dapat digunakan dalam dua konteks lain?

ALL dapat digunakan dalam tiga konteks berikut:

• Sebagai argumen untuk SELECT klausa.
• Sebagai argumen untuk UNION klausa.
• Sebagai operator logika saat membandingkan nilai skalar dengan kumpulan nilai satu kolom.

Contoh dari masing-masing konteks berikut.

ALL di SELECT Klausa

Saat digunakan dengan SELECT klausa, ALL menentukan bahwa nilai duplikat dikembalikan dalam kumpulan hasil.

Anda mungkin sudah menggunakan ini secara implisit bahkan tanpa mengetahuinya.

Dalam T-SQL, sintaks untuk SELECT klausanya seperti ini:

SELECT [ ALL | DISTINCT ]  
[ TOP ( expression ) [ PERCENT ] [ WITH TIES ] ]   
<select_list>   
<select_list> ::=   
    {   
      *   
      | { table_name | view_name | table_alias }.*   
      | {  
          [ { table_name | view_name | table_alias }. ]  
               { column_name | $IDENTITY | $ROWGUID }   
          | udt_column_name [ { . | :: } { { property_name | field_name }   
            | method_name ( argument [ ,...n] ) } ]  
          | expression  
          [ [ AS ] column_alias ]   
         }  
      | column_alias = expression   
    } [ ,...n ]

Bagian yang masuk [ ALL | DISTINCT ] berarti Anda mendapatkan pilihan antara ALL dan DISTINCT .

Tanda kurung siku berarti bagian ini opsional.

• ALL menentukan bahwa baris duplikat dapat muncul di kumpulan hasil.
• DISTINCT menentukan bahwa hanya baris unik yang dapat muncul di kumpulan hasil.

ALL adalah nilai default, jadi jika Anda tidak menentukan ALL atau DISTINCT , ALL digunakan.

Contoh

Jadi dua pernyataan berikut ini setara:

SELECT DogName 
FROM Dogs;

SELECT ALL DogName 
FROM Dogs;

Contoh hasil:

+-----------+
| DogName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
| Fetch     |
+-----------+
(4 rows affected)
+-----------+
| DogName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
| Fetch     |
+-----------+
(4 rows affected)

Kedua hasil tersebut menunjukkan bahwa ada dua anjing bernama “Ambil”.

Jika kita menukar ALL argumen untuk DISTINCT , hanya satu baris yang akan dikembalikan untuk "Ambil". Ini karena DISTINCT menghapus nilai duplikat dari kumpulan hasil.

SELECT DISTINCT DogName 
FROM Dogs;

Contoh hasil:

+-----------+
| DogName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
+-----------+
(3 rows affected)

ALL di UNION Klausa

ALL melakukan hal yang sama ketika digunakan dengan UNION ayat. Ini menentukan bahwa nilai duplikat dikembalikan dalam kumpulan hasil.

Tapi yang jelas, UNION adalah klausa yang berbeda dengan SELECT , jadi konteksnya sedikit berbeda.

UNION klausa menggabungkan hasil dari dua kueri menjadi satu set hasil. Anda dapat menggunakannya dengan atau tanpa ALL argumen:

• UNION ALL – Termasuk duplikat.
• UNION – Tidak termasuk duplikat.

Contoh

Berikut ini contoh penggunaan UNION ALL untuk menggabungkan dua kueri.

Mari tambahkan tabel bernama Cats . Jadi kami memiliki dua tabel:Dogs dan Cats

Dogs

+---------+-----------+
| DogId   | DogName   |
|---------+-----------|
| 1       | Fetch     |
| 2       | Fluffy    |
| 3       | Wag       |
| 1002    | Fetch     |
+---------+-----------+

Cats

+---------+-----------+
| CatId   | CatName   |
|---------+-----------|
| 1       | Meow      |
| 2       | Fluffy    |
| 3       | Scratch   |
+---------+-----------+

Sekarang mari kita pilih nama anjing/kucing dari setiap tabel dan gunakan UNION ALL untuk menggabungkan hasil dari kedua tabel.

SELECT DogName AS PetName
FROM Dogs
UNION ALL
SELECT CatName
FROM Cats;

Hasil:

+-----------+
| PetName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
| Fetch     |
| Meow      |
| Fluffy    |
| Scratch   |
+-----------+
(7 rows affected)

Dalam hal ini, tujuh baris dikembalikan. Kita dapat melihat bahwa "Ambil" dikembalikan dua kali. Ini karena ada dua anjing bernama Fetch.

Ada juga kucing dan anjing dengan nama yang sama:Fluffy. (Kami tahu yang satunya adalah kucing karena hanya ada satu anjing bernama Fluffy pada contoh sebelumnya).

Mari kita lihat apa yang terjadi ketika saya menghapus ALL argumen.

SELECT DogName AS PetName
FROM Dogs
UNION
SELECT CatName
FROM Cats;

Hasil:

+-----------+
| PetName   |
|-----------|
| Fetch     |
| Fluffy    |
| Meow      |
| Scratch   |
| Wag       |
+-----------+
(5 rows affected)

Kali ini hanya lima baris yang dikembalikan. Kedua duplikat dihapus.

Perhatikan bahwa ini berbeda dengan menerapkan DISTINCT untuk setiap individu SELECT penyataan. Jika kita melakukannya, Fluffy akan dikembalikan dua kali, karena ALL hanya akan berlaku untuk SELECT pernyataan bahwa itu diterapkan (bukan pada hasil gabungan).

Berikut ini contoh untuk menggambarkan apa yang saya maksud.

SELECT DISTINCT DogName AS PetName
FROM Dogs
UNION ALL
SELECT DISTINCT CatName
FROM Cats;

Hasil:

+-----------+
| PetName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
| Fluffy    |
| Meow      |
| Scratch   |
+-----------+
(6 rows affected)

ALL Operator

ALL operator dapat digunakan dengan subkueri untuk membandingkan nilai skalar dengan kumpulan nilai kolom tunggal yang dikembalikan oleh subkueri.

Contoh

Sebagai penyegaran, berikut adalah dua tabel kami:

Dogs

+---------+-----------+
| DogId   | DogName   |
|---------+-----------|
| 1       | Fetch     |
| 2       | Fluffy    |
| 3       | Wag       |
| 1002    | Fetch     |
+---------+-----------+

Cats

+---------+-----------+
| CatId   | CatName   |
|---------+-----------|
| 1       | Meow      |
| 2       | Fluffy    |
| 3       | Scratch   |
+---------+-----------+

Sekarang mari kita jalankan subquery menggunakan ALL operator.

SELECT 
    CatId,
    CatName
FROM Cats c 
WHERE c.CatName = ALL (SELECT DogName FROM Dogs);

Hasil:

(0 rows affected)

Dalam hal ini, tidak ada baris yang dikembalikan. Ini karena ALL membutuhkan ekspresi skalar untuk membandingkan secara positif dengan setiap nilai yang dikembalikan oleh subquery.

Dalam hal ini, subkueri sangat luas sehingga semua baris dari Dogs meja dikembalikan. Ini akan mengharuskan setiap anjing memiliki setidaknya satu kucing yang sesuai dengan nama yang sama.

Mari kita ubah sedikit subquery.

SELECT 
    CatId,
    CatName
FROM Cats c 
WHERE c.CatName = ALL (
    SELECT DogName FROM Dogs 
    WHERE DogId = 2
    );

Hasil:

+---------+-----------+
| CatId   | CatName   |
|---------+-----------|
| 2       | Fluffy    |
+---------+-----------+

Kali ini saya mendapatkan hasil yang positif, karena semua baris yang dikembalikan oleh subquery memiliki baris yang sesuai di Cats tabel (dalam hal ini, hanya satu baris).