Database
 sql >> Base de Dados >  >> RDS >> Database

12 Operadores SQL comumente usados


No SQL, um operador é um caractere especial ou palavra-chave que especifica uma ação que é executada em uma ou mais expressões.

Os operadores SQL são parte integrante do SQL e nos permitem escrever consultas que retornam resultados relevantes.

Neste artigo, apresento 12 dos operadores SQL mais usados ​​ao escrever consultas SQL.

Os Iguais (= ) Operador


O operador Equals (= ) é provavelmente o operador mais usado em SQL. Ele compara a igualdade de duas expressões. Mesmo que você não esteja mais do que vagamente familiarizado com o SQL, provavelmente conhecerá esse operador.

Imagine que temos um banco de dados para um hotel para animais de estimação e queremos obter informações sobre todos os animais de estimação chamados Fluffy.

Nesse caso, poderíamos fazer assim:
SELECT PetId, PetName, DOB 
FROM Pets
WHERE PetName = 'Fluffy';

Resultado:
+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
+---------+-----------+------------+

Nossa consulta usa o operador Equals (= ) para comparar a igualdade do valor do PetName coluna e a string Fluffy .

No nosso caso, podemos ver que o pet hotel atualmente possui dois pets chamados Fluffy.

O maior que (> ) Operador


O operador Maior que (> ) compara duas expressões e retorna TRUE se o operando esquerdo tiver um valor maior que o operando direito; caso contrário, o resultado é FALSE . 
SELECT PetName, DOB 
FROM Pets
WHERE DOB > '2020-01-01';

Resultado:
+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fluffy    | 2020-11-20 |
| Wag       | 2020-03-15 |
| Tweet     | 2020-11-28 |
| Fluffy    | 2020-09-17 |
+-----------+------------+

Neste caso, está comparando o valor do DOB coluna e a data 2020-01-01 para ver se o DOB coluna é maior.

O menor que (< ) Operador


O operador Menor que (< ) faz o contrário. Ele compara duas expressões e retorna TRUE se o operando esquerdo tiver valor inferior ao operando direito; caso contrário, o resultado é FALSE . 
SELECT PetName, DOB 
FROM Pets
WHERE DOB < '2020-01-01';

Resultado:
+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fetch     | 2019-08-16 |
| Scratch   | 2018-10-01 |
+-----------+------------+

O maior ou igual a (>= ) Operador


O operador Maior ou igual a (>= ) compara duas expressões e retorna TRUE se o operando esquerdo tiver valor maior ou igual ao operando direito; caso contrário, retorna FALSE . 
SELECT PetName, DOB 
FROM Pets
WHERE DOB >= '2020-09-17';

Resultado:
+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fluffy    | 2020-11-20 |
| Tweet     | 2020-11-28 |
| Fluffy    | 2020-09-17 |
+-----------+------------+

Observe que ele retornou 2020-09-17 e todas as datas maiores que isso. Se tivéssemos usado o operador Greater Than (> ), apenas as duas primeiras linhas teriam sido retornadas.

O menor ou igual a (<= ) Operador


O operador Menor ou igual a (<= ) compara duas expressões e retorna TRUE se o operando esquerdo tiver valor menor ou igual ao operando direito; caso contrário, o resultado é FALSE . 
SELECT PetName, DOB 
FROM Pets
WHERE DOB <= '2020-09-17';

Resultado:
+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fetch     | 2019-08-16 |
| Scratch   | 2018-10-01 |
| Wag       | 2020-03-15 |
| Fluffy    | 2020-09-17 |
+-----------+------------+

Observe que ele retornou 2020-09-17 e todas as datas inferiores a isso. Se tivéssemos usado o operador Menor que (< ), apenas as três primeiras linhas teriam sido retornadas.

O AND Operador


O AND operador combina duas expressões booleanas e retorna TRUE quando ambas as expressões são TRUE .

Aqui está um exemplo. 
SELECT PetId, DOB 
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';

Resultado:
+---------+------------+
| PetId   | DOB        |
|---------+------------|
| 1       | 2020-11-20 |
| 6       | 2020-09-17 |
+---------+------------+

Nesse caso, só obtemos detalhes dos animais de estimação cujo nome é Fofo e sua data de nascimento está entre as duas datas.

O OR Operador


O OR operador combina duas expressões booleanas e retorna TRUE quando uma das condições for TRUE .

Aqui está um exemplo. 
SELECT 
    PetId, 
    PetName,
    DOB 
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';

Resultado:
+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Isso é basicamente o oposto do AND operador. Se tivéssemos usado AND , nenhuma linha teria sido retornada, pois não podemos ter dois valores diferentes em uma coluna ao mesmo tempo.

O BETWEEN Operador


O BETWEEN operador nos permite especificar um intervalo para testar. Por exemplo, podemos usá-lo para devolver animais de estimação que nasceram entre duas datas. 
SELECT
    PetName,
    DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';

Resultado:
+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fetch     | 2019-08-16 |
| Scratch   | 2018-10-01 |
+-----------+------------+

O NOT Operador


O NOT O operador nega uma entrada booleana (inverte o valor de qualquer expressão booleana). Portanto, retorna TRUE quando a expressão é FALSE .

Veja o que acontece quando adicionamos o NOT operador para o nosso exemplo anterior. 
SELECT
    PetName,
    DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';

Resultado:
+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fluffy    | 2020-11-20 |
| Wag       | 2020-03-15 |
| Tweet     | 2020-11-28 |
| Fluffy    | 2020-09-17 |
+-----------+------------+

Desta vez, pegamos todos os outros animais de estimação – os animais que não eram nascidos entre essas datas.

No MariaDB, NOT está limitado a negar o IN , BETWEEN , e EXISTS cláusulas. A maioria dos outros SGBDs permite NOT para negar qualquer expressão.

O IN Operador


O IN O operador determina se um valor especificado corresponde a qualquer valor em uma subconsulta ou lista.

Aqui está um exemplo. 
SELECT 
    PetId, 
    PetName, 
    DOB 
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');

Resultado:
+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 4       | Wag       | 2020-03-15 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Poderíamos obter o mesmo resultado usando dois OR operadores:
SELECT 
    PetId, 
    PetName, 
    DOB 
FROM Pets
WHERE PetName = 'Fluffy' 
    OR PetName = 'Bark' 
    OR PetName = 'Wag';

No entanto, o IN operador é uma maneira mais concisa de fazê-lo. O IN O operador é especialmente benéfico quando você tem uma longa lista de valores para comparar.

O IN operador quase sempre executa mais rápido que vários OR operadores, especialmente em conjuntos de dados maiores.

Outro benefício do IN operador, é que ele pode conter outro SELECT Lista. Isso é conhecido como uma subconsulta . Uma subconsulta é uma consulta aninhada dentro de outra consulta (ou mesmo outra subconsulta).

Aqui está um exemplo. 
SELECT 
    PetTypeId,
    PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );

Resultado:
+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
+-------------+-----------+

Este exemplo nos mostra quantos tipos de animais de estimação existem em nosso hotel para animais de estimação.

Poderíamos usar o NOT operador para inverter isso e ver quantos tipos de animais de estimação não em nosso hotel para animais de estimação. 
SELECT 
    PetTypeId,
    PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );

Resultado:
+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 4           | Rabbit    |
+-------------+-----------+

Portanto, nosso banco de dados contém um tipo de animal de estimação de Rabbit , mas atualmente não temos coelhos como animais de estimação.

O + e || Operadores de concatenação de string


O + e || Os operadores de concatenação de strings permitem concatenar strings. A concatenação de strings é a operação de unir strings de caracteres de ponta a ponta.

A razão pela qual listei dois operadores que fazem a mesma coisa é porque, o + é suportado no SQL Server e o || O operador é suportado em DB2, Oracle, PostgreSQL, SQLite.

Aqui está um exemplo que funciona no SQL Server. 
SELECT 
    FirstName,
    LastName,
    FirstName + LastName
FROM Owners;

Resultado:
+-------------+------------+--------------------+
| FirstName   | LastName   | (No column name)   |
|-------------+------------+--------------------|
| Homer       | Connery    | HomerConnery       |
| Bart        | Pitt       | BartPitt           |
| Nancy       | Simpson    | NancySimpson       |
| Boris       | Trump      | BorisTrump         |
+-------------+------------+--------------------+

Nesse caso, os proprietários têm seu nome e sobrenome armazenados em colunas diferentes. Em nosso SELECT list, primeiro os recuperamos individualmente, mas também os recuperamos novamente, usando um operador de concatenação para juntá-los.

No entanto, existem alguns problemas com nossos resultados.
  • Não há espaço entre o nome e o sobrenome.
  • Não há nome de coluna.

Felizmente, isso é fácil de corrigir.

Podemos usar a mesma operação de concatenação para incluir espaço entre o nome e o sobrenome.

E podemos usar um alias de coluna para o resultado concatenado para fornecer um nome de coluna no conjunto de resultados. 
SELECT 
    FirstName,
    LastName,
    FirstName + ' ' + LastName AS FullName
FROM Owners;

Resultado:
+-------------+------------+---------------+
| FirstName   | LastName   | FullName      |
|-------------+------------+---------------|
| Homer       | Connery    | Homer Connery |
| Bart        | Pitt       | Bart Pitt     |
| Nancy       | Simpson    | Nancy Simpson |
| Boris       | Trump      | Boris Trump   |
+-------------+------------+---------------+

Se você estiver usando DB2, Oracle, PostgreSQL, SQLite, troque o + para || e deve funcionar bem.

Se você estiver usando MySQL ou MariaDB, você precisará usar o CONCAT() função para concatenar strings.

O LIKE Operador


O LIKE operador permite que você faça a correspondência de padrões. Ele determina se uma cadeia de caracteres específica corresponde a um padrão especificado. Um padrão pode incluir caracteres regulares e caracteres curinga. 
SELECT 
    FirstName,
    LastName,
    Email
FROM Owners
WHERE Email LIKE '%.com';

Resultado:
+-------------+------------+-------------------+
| FirstName   | LastName   | Email             |
|-------------+------------+-------------------|
| Homer       | Connery    | [email protected] |
| Bart        | Pitt       | [email protected]  |
+-------------+------------+-------------------+

Neste exemplo, usei o LIKE operador em conjunto com o % operador curinga para retornar proprietários cujos endereços de e-mail terminam em .com .

Operador de bônus! O % Operador curinga


O % operador curinga corresponde a qualquer cadeia de zero ou mais caracteres. Ele pode ser usado como prefixo ou sufixo, e também pode ser usado no meio de uma string.

Ele tende a ser mais comumente usado como sufixo e tem uso limitado no meio de padrões, embora existam alguns casos de uso válidos para usá-lo no meio de um padrão, como o seguinte:
SELECT 
    FirstName,
    LastName,
    Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';

Resultado:
+-------------+------------+------------------+
| FirstName   | LastName   | Email            |
|-------------+------------+------------------|
| Bart        | Pitt       | [email protected] |
+-------------+------------+------------------+

Nesse caso, não sabíamos o endereço de e-mail do bart, mas sabíamos que começava com [email protected] e terminou em .com . Portanto, pudemos usar LIKE em conjunto com o % operador curinga para preencher o resto.

Lembre-se de que essa técnica pode retornar muitas linhas irrelevantes, dependendo dos dados e de como você constrói sua instrução SQL.

Esteja ciente também de que as consultas que contêm o LIKE A cláusula pode ser executada muito mais lentamente do que outras consultas, e você provavelmente deve evitar usar o LIKE cláusula a menos que você realmente precise dela. Usando o % operador como um prefixo pode ser particularmente lento.

Isso não quer dizer que você não deve usá-lo em tudo. O LIKE O operador é parte integrante do SQL e você encontrará muitos cenários em que será a única opção (ou pelo menos a melhor opção).

Mais operadores SQL


Veja minha lista completa de operadores SQL para vários outros operadores que não estão incluídos aqui.