Trong SQL, toán tử là một ký tự hoặc từ khóa đặc biệt chỉ định một hành động được thực hiện trên một hoặc nhiều biểu thức.
Các toán tử SQL là một phần không thể thiếu của SQL và chúng cho phép chúng tôi viết các truy vấn trả về các kết quả có liên quan.
Trong bài viết này, tôi trình bày 12 toán tử SQL được sử dụng phổ biến nhất khi viết truy vấn SQL.
The Equals (= ) Nhà điều hành
Toán tử Equals (= ) có lẽ là toán tử được sử dụng phổ biến nhất trong SQL. Nó so sánh sự bằng nhau của hai biểu thức. Ngay cả khi bạn không quá quen thuộc với SQL, bạn có thể sẽ biết toán tử này.
Hãy tưởng tượng chúng ta có một cơ sở dữ liệu cho một khách sạn vật nuôi và chúng ta muốn lấy thông tin về tất cả các vật nuôi có tên là Fluffy.
Trong trường hợp đó, chúng tôi có thể làm điều này:
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Kết quả:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Truy vấn của chúng tôi sử dụng toán tử Equals (= ) để so sánh sự bình đẳng về giá trị của PetName cột và chuỗi Fluffy .
Trong trường hợp của chúng tôi, chúng tôi có thể thấy rằng khách sạn vật nuôi hiện có hai vật nuôi tên là Fluffy.
The Greater Than (> ) Nhà điều hành
Toán tử Greater Than (> ) so sánh hai biểu thức và trả về TRUE nếu toán hạng bên trái có giá trị cao hơn toán hạng bên phải; nếu không, kết quả là FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Kết quả:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Trong trường hợp này, nó so sánh giá trị của DOB cột và ngày 2020-01-01 để xem liệu DOB cột lớn hơn.
Càng ít hơn (< ) Nhà điều hành
Toán tử Ít hơn (< ) làm ngược lại. Nó so sánh hai biểu thức và trả về TRUE nếu toán hạng bên trái có giá trị thấp hơn toán hạng bên phải; nếu không, kết quả là FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB < '2020-01-01';Kết quả:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Lớn hơn hoặc Bằng (>= ) Nhà điều hành
Toán tử Greater Than hoặc Equal To (>= ) so sánh hai biểu thức và trả về TRUE nếu toán hạng bên trái có giá trị lớn hơn hoặc bằng toán hạng bên phải; nếu không, nó trả về FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB >= '2020-09-17';Kết quả:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Lưu ý rằng nó đã trả về 2020-09-17 và tất cả các ngày lớn hơn thế. Nếu chúng ta đã sử dụng toán tử Greater Than (> ), chỉ hai hàng đầu tiên sẽ được trả về.
Nhỏ hơn hoặc Bằng (<= ) Nhà điều hành
Toán tử Nhỏ hơn hoặc Bằng Với (<= ) so sánh hai biểu thức và trả về TRUE nếu toán hạng bên trái có giá trị nhỏ hơn hoặc bằng toán hạng bên phải; nếu không, kết quả là FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB <= '2020-09-17';Kết quả:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | | Wag | 2020-03-15 | | Fluffy | 2020-09-17 | +-----------+------------+
Lưu ý rằng nó đã trả về 2020-09-17 và tất cả các ngày ít hơn thế. Nếu chúng ta đã sử dụng toán tử Less Than (< ), chỉ ba hàng đầu tiên sẽ được trả về.
AND Nhà điều hành
AND toán tử kết hợp hai biểu thức Boolean và trả về TRUE khi cả hai biểu thức đều TRUE .
Đây là một ví dụ.
SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';Kết quả:
+---------+------------+ | PetId | DOB | |---------+------------| | 1 | 2020-11-20 | | 6 | 2020-09-17 | +---------+------------+
Trong trường hợp này, chúng tôi chỉ nhận được thông tin chi tiết về những vật nuôi có tên là Fluffy and ngày sinh của họ nằm giữa hai ngày đó.
OR Nhà điều hành
OR toán tử kết hợp hai biểu thức Boolean và trả về TRUE khi một trong hai điều kiện là TRUE .
Đây là một ví dụ.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';Kết quả:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Về cơ bản, điều này ngược lại với AND nhà điều hành. Nếu chúng tôi đã sử dụng AND , sẽ không có hàng nào được trả lại, bởi vì chúng ta không thể có hai giá trị khác nhau trong một cột cùng một lúc.
BETWEEN Nhà điều hành
BETWEEN toán tử cho phép chúng tôi chỉ định một phạm vi để kiểm tra. Ví dụ:chúng tôi có thể sử dụng nó để trả lại những con vật cưng được sinh ra giữa hai ngày.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Kết quả:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
NOT Nhà điều hành
NOT toán tử phủ định đầu vào Boolean (nó đảo ngược giá trị của bất kỳ biểu thức Boolean nào). Do đó trả về TRUE khi biểu thức là FALSE .
Đây là những gì sẽ xảy ra khi chúng tôi thêm NOT cho ví dụ trước của chúng tôi.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';Kết quả:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Lần này, chúng tôi có tất cả các vật nuôi khác - những vật nuôi thì không sinh giữa những ngày đó.
Trong MariaDB, NOT được giới hạn ở việc phủ định IN , BETWEEN và EXISTS điều khoản. Hầu hết các DBMS khác đều cho phép NOT để phủ định bất kỳ biểu thức nào.
IN Nhà điều hành
IN toán tử xác định xem một giá trị được chỉ định có khớp với bất kỳ giá trị nào trong một truy vấn con hoặc một danh sách hay không.
Đây là một ví dụ.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Kết quả:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Chúng tôi có thể đạt được kết quả tương tự bằng cách sử dụng hai OR toán tử:
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR PetName = 'Bark'
OR PetName = 'Wag';
Tuy nhiên, IN toán tử là một cách ngắn gọn hơn để làm điều đó. IN toán tử đặc biệt có lợi khi bạn có một danh sách dài các giá trị để so sánh với.
IN toán tử hầu như luôn thực thi nhanh hơn nhiều OR , đặc biệt là trên các tập dữ liệu lớn hơn.
Một lợi ích khác của IN là toán tử có thể chứa một SELECT khác danh sách. Đây được gọi là truy vấn con . Truy vấn con là một truy vấn được lồng bên trong một truy vấn khác (hoặc thậm chí là một truy vấn con khác).
Đây là một ví dụ.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Kết quả:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Ví dụ này cho chúng tôi thấy có bao nhiêu loại vật nuôi trong khách sạn vật nuôi của chúng tôi.
Chúng tôi có thể sử dụng NOT để lật điều này và xem có bao nhiêu loại vật nuôi không trong khách sạn thú cưng của chúng tôi.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );Kết quả:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 4 | Rabbit | +-------------+-----------+
Vì vậy, cơ sở dữ liệu của chúng tôi chứa một loại vật nuôi là Rabbit , nhưng chúng tôi hiện không có bất kỳ con thỏ nào làm thú cưng.
+ và || Toán tử nối chuỗi
+ và || các toán tử nối chuỗi cho phép bạn nối các chuỗi. Nối chuỗi là thao tác nối các chuỗi ký tự từ đầu đến cuối.
Lý do tôi liệt kê hai toán tử hoạt động tương tự là vì, + được hỗ trợ trong SQL Server và || toán tử được hỗ trợ trong DB2, Oracle, PostgreSQL, SQLite.
Đây là một ví dụ hoạt động trong SQL Server.
SELECT
FirstName,
LastName,
FirstName + LastName
FROM Owners;Kết quả:
+-------------+------------+--------------------+ | FirstName | LastName | (No column name) | |-------------+------------+--------------------| | Homer | Connery | HomerConnery | | Bart | Pitt | BartPitt | | Nancy | Simpson | NancySimpson | | Boris | Trump | BorisTrump | +-------------+------------+--------------------+
Trong trường hợp này, chủ sở hữu có họ và tên được lưu trữ trong các cột khác nhau. Trong SELECT của chúng tôi danh sách, trước tiên chúng tôi truy xuất chúng một cách riêng lẻ, nhưng chúng tôi cũng truy xuất chúng một lần nữa, sử dụng toán tử nối để nối chúng lại với nhau.
Tuy nhiên, có một số vấn đề với kết quả của chúng tôi.
- Không có khoảng cách giữa họ và tên.
- Không có tên cột.
May mắn thay, điều này rất dễ sửa chữa.
Chúng ta có thể sử dụng cùng một thao tác nối để bao gồm khoảng cách giữa tên và họ.
Và chúng ta có thể sử dụng bí danh cột cho kết quả được nối để cung cấp tên cột trong tập kết quả.
SELECT
FirstName,
LastName,
FirstName + ' ' + LastName AS FullName
FROM Owners;Kết quả:
+-------------+------------+---------------+ | FirstName | LastName | FullName | |-------------+------------+---------------| | Homer | Connery | Homer Connery | | Bart | Pitt | Bart Pitt | | Nancy | Simpson | Nancy Simpson | | Boris | Trump | Boris Trump | +-------------+------------+---------------+
Nếu bạn đang sử dụng DB2, Oracle, PostgreSQL, SQLite, hãy hoán đổi + cho || và nó sẽ hoạt động tốt.
Nếu bạn đang sử dụng MySQL hoặc MariaDB, bạn sẽ cần sử dụng CONCAT() hàm để nối các chuỗi.
LIKE Nhà điều hành
LIKE cho phép bạn thực hiện đối sánh mẫu. Nó xác định xem một chuỗi ký tự cụ thể có khớp với một mẫu được chỉ định hay không. Một mẫu có thể bao gồm các ký tự thông thường và các ký tự đại diện.
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '%.com';Kết quả:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
Trong ví dụ này, tôi đã sử dụng LIKE toán tử kết hợp với % toán tử ký tự đại diện để trả lại chủ sở hữu có địa chỉ email kết thúc bằng .com .
Nhà điều hành tiền thưởng! % Toán tử ký tự đại diện
% toán tử ký tự đại diện khớp với bất kỳ chuỗi nào không hoặc nhiều ký tự. Nó có thể được sử dụng như một tiền tố hoặc một hậu tố, và nó cũng có thể được sử dụng ở giữa một chuỗi.
Nó có xu hướng được sử dụng phổ biến hơn như một hậu tố và nó bị hạn chế sử dụng ở giữa các mẫu, mặc dù có một số trường hợp sử dụng hợp lệ để sử dụng nó ở giữa mẫu, chẳng hạn như sau:
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';Kết quả:
+-------------+------------+------------------+ | FirstName | LastName | Email | |-------------+------------+------------------| | Bart | Pitt | [email protected] | +-------------+------------+------------------+
Trong trường hợp này, chúng tôi không biết địa chỉ email của bart, nhưng chúng tôi biết địa chỉ này bắt đầu bằng [email protected] và kết thúc bằng .com . Do đó, chúng tôi có thể sử dụng LIKE kết hợp với % toán tử ký tự đại diện để điền vào phần còn lại.
Hãy nhớ rằng kỹ thuật này có thể trả về rất nhiều hàng không liên quan, tùy thuộc vào dữ liệu và cách bạn xây dựng câu lệnh SQL của mình.
Cũng lưu ý rằng các truy vấn có chứa LIKE mệnh đề có thể chạy chậm hơn nhiều so với các truy vấn khác và bạn có thể nên tránh sử dụng LIKE trừ khi bạn thực sự cần nó. Sử dụng % toán tử làm tiền tố có thể đặc biệt chậm.
Điều đó không có nghĩa là bạn hoàn toàn không nên sử dụng nó. LIKE toán tử là một phần không thể thiếu của SQL và bạn sẽ gặp phải nhiều trường hợp trong đó nó sẽ là lựa chọn duy nhất (hoặc ít nhất, là lựa chọn tốt nhất).
Các toán tử SQL khác
Xem danh sách đầy đủ các toán tử SQL của tôi để biết toàn bộ các toán tử khác không có ở đây.
