Em SQL, o
OR O operador permite que você use condições alternativas ao filtrar suas consultas. O
OR operador combina duas condições e retorna TRUE quando uma das condições for TRUE . Tabela de origem
A tabela a seguir é usada para os exemplos nesta página.
SELECT * FROM Pets;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+ (8 rows affected)
Exemplo
Aqui está um exemplo simples para demonstrar o
OR operador. SELECT * FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Tweet';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Podemos ver que ele realmente retornou as linhas onde o
PetName coluna era Fluffy ou Tweet . Nenhuma outra linha foi retornada. Colunas diferentes
No exemplo anterior, ambas as condições estavam comparando valores com a mesma coluna, mas isso não é um requisito. As expressões em ambos os lados do
OR O operador pode usar colunas diferentes para comparar valores. O OR operador simplesmente retornará TRUE quando uma dessas condições for TRUE . SELECT * FROM Pets
WHERE PetName = 'Fluffy' OR DOB < '2020-01-01';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Combinado com outros operadores
Seus critérios de filtragem podem combinar expressões que usam outros operadores além do
OR operador. Aqui está um exemplo que inclui o
AND operador. SELECT * FROM Pets
WHERE (PetName = 'Fluffy' OR PetName = 'Tweet')
AND DOB >= '2020-11-20';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +---------+-------------+-----------+-----------+------------+
Observe que eu cerquei o
OR condição entre parênteses. O motivo pelo qual fiz isso foi porque, por padrão, OR os operadores são avaliados após AND operadores. SQL tem uma ordem definida de precedência dos operadores em uma expressão, e isso determina que o AND operador é avaliado antes do OR operador. No entanto, você pode usar parênteses para substituir a precedência definida dos operadores em uma expressão. Tudo entre parênteses é avaliado para retornar um único valor. Esse valor pode ser usado por qualquer operador fora desses parênteses.
Em outras palavras, você pode usar parênteses para especificar a ordem na qual deseja que cada operador lógico seja avaliado em uma expressão.
Por que isso é um problema?
Dê uma olhada nos resultados quando removemos os parênteses.
SELECT * FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Tweet'
AND DOB >= '2020-11-20';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +---------+-------------+-----------+-----------+------------+
Na verdade, obtemos um resultado diferente.
Isso ocorre porque a consulta agora verifica
PetName = 'Tweet' AND DOB >= '2020-11-20' primeiro, depois verifica o OR expressão PetName = 'Fluffy' . É como se pudéssemos colocar parênteses em
AND expressão, assim:SELECT * FROM Pets
WHERE PetName = 'Fluffy' OR (PetName = 'Tweet'
AND DOB >= '2020-11-20');No entanto, para confundir ainda mais as coisas, podemos reorganizar nossa consulta para que não usemos parênteses e ainda assim obter o mesmo resultado do nosso primeiro exemplo com parênteses.
Assim:
SELECT * FROM Pets
WHERE DOB >= '2020-11-20'
AND PetName = 'Fluffy' OR PetName = 'Tweet';Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +---------+-------------+-----------+-----------+------------+
Neste caso, o
AND expressão foi avaliada primeiro, como esperado. A ordem das expressões acabou de se alinhar para que DOB >= '2020-11-20' AND PetName = 'Fluffy' foi avaliado primeiro, então excluímos o outro pet chamado Fluffy devido ao seu DOB caindo fora desse intervalo. Só depois disso, foi o OR expressão avaliada como uma condição alternativa ao nosso AND existente resultado. A moral desta história? Use parênteses ao usar vários operadores. Dessa forma, você pode especificar a ordem exata na qual deseja que cada expressão seja avaliada.
