No SQL, 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, retorna FALSE . Exemplo
Aqui está um exemplo para demonstrar.
SELECT * FROM city
WHERE Population > 9000000;Resultado:
+------+-----------------+---------------+--------------+--------------+ | ID | Name | CountryCode | District | Population | |------+-----------------+---------------+--------------+--------------| | 206 | São Paulo | BRA | São Paulo | 9968485 | | 939 | Jakarta | IDN | Jakarta Raya | 9604900 | | 1024 | Mumbai (Bombay) | IND | Maharashtra | 10500000 | | 1890 | Shanghai | CHN | Shanghai | 9696300 | | 2331 | Seoul | KOR | Seoul | 9981619 | | 2822 | Karachi | PAK | Sindh | 9269265 | +------+-----------------+---------------+--------------+--------------+
Essa consulta retorna todas as cidades com população superior a 9 milhões.
Exclusivo
O operador maior que não inclui o valor especificado em sua avaliação.
Por exemplo, o exemplo a seguir não retorna Karachi, que, de acordo com esse banco de dados, possui uma população de exatamente 9269265:
SELECT * FROM city
WHERE Population > 9269265;Resultado:
+------+-----------------+---------------+--------------+--------------+ | ID | Name | CountryCode | District | Population | |------+-----------------+---------------+--------------+--------------| | 206 | São Paulo | BRA | São Paulo | 9968485 | | 939 | Jakarta | IDN | Jakarta Raya | 9604900 | | 1024 | Mumbai (Bombay) | IND | Maharashtra | 10500000 | | 1890 | Shanghai | CHN | Shanghai | 9696300 | | 2331 | Seoul | KOR | Seoul | 9981619 | +------+-----------------+---------------+--------------+--------------+
Para incluir cidades com uma população de 9269265, precisaríamos diminuir nosso valor especificado:
SELECT * FROM city
WHERE Population > 9269264;Resultado:
+------+-----------------+---------------+--------------+--------------+ | ID | Name | CountryCode | District | Population | |------+-----------------+---------------+--------------+--------------| | 206 | São Paulo | BRA | São Paulo | 9968485 | | 939 | Jakarta | IDN | Jakarta Raya | 9604900 | | 1024 | Mumbai (Bombay) | IND | Maharashtra | 10500000 | | 1890 | Shanghai | CHN | Shanghai | 9696300 | | 2331 | Seoul | KOR | Seoul | 9981619 | | 2822 | Karachi | PAK | Sindh | 9269265 | +------+-----------------+---------------+--------------+--------------+
Ou isso, ou podemos usar o maior ou igual a
(>= ) operador. SELECT * FROM city
WHERE Population >= 9269265;Resultado:
+------+-----------------+---------------+--------------+--------------+ | ID | Name | CountryCode | District | Population | |------+-----------------+---------------+--------------+--------------| | 206 | São Paulo | BRA | São Paulo | 9968485 | | 939 | Jakarta | IDN | Jakarta Raya | 9604900 | | 1024 | Mumbai (Bombay) | IND | Maharashtra | 10500000 | | 1890 | Shanghai | CHN | Shanghai | 9696300 | | 2331 | Seoul | KOR | Seoul | 9981619 | | 2822 | Karachi | PAK | Sindh | 9269265 | +------+-----------------+---------------+--------------+--------------+
Datas
Aqui está um exemplo para demonstrar o uso do operador maior que para comparar valores de data.
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 | +-----------+------------+
Cordas
Você também pode usar o operador maior que para comparar valores de string. Ao comparar com um valor de string, use aspas ao redor da string.
SELECT * FROM city
WHERE Name > 'Zukovski'
ORDER BY Name;Resultado:
+------+----------+---------------+------------+--------------+ | ID | Name | CountryCode | District | Population | |------+----------+---------------+------------+--------------| | 2669 | Zumpango | MEX | México | 99781 | | 2025 | Zunyi | CHN | Guizhou | 261862 | | 3245 | Zürich | CHE | Zürich | 336800 | | 3145 | Zwickau | DEU | Saksi | 104146 | | 28 | Zwolle | NLD | Overijssel | 105819 | | 3446 | Zytomyr | UKR | Zytomyr | 297000 | +------+----------+---------------+------------+--------------+
Várias Condições
Se você tiver várias condições, poderá usar vários operadores maiores que.
Assim:
SELECT * FROM city
WHERE Name > 'Zukovski' AND Population > 200000;Resultado:
+------+---------+---------------+------------+--------------+ | ID | Name | CountryCode | District | Population | |------+---------+---------------+------------+--------------| | 2025 | Zunyi | CHN | Guizhou | 261862 | | 3245 | Zürich | CHE | Zürich | 336800 | | 3446 | Zytomyr | UKR | Zytomyr | 297000 | +------+---------+---------------+------------+--------------+
Precedência
Você também pode usar uma combinação de operadores ao filtrar os resultados.
Observe que o SQL tem uma ordem de precedência que atribui a diferentes tipos de operadores. Por exemplo, ele avalia qualquer operador condicional antes de qualquer operador lógico, como
AND e OR . Ele também avalia qualquer AND operadores antes de qualquer OR operadores. Os parênteses têm precedência mais alta do que todos os operadores e, portanto, você pode usar parênteses para especificar a ordem na qual cada condição deve ser avaliada.
Considere o seguinte exemplo:
SELECT * FROM city
WHERE Name > 'Zukovski'
AND Population > 100000
OR District = 'Overijssel';Resultado:
+------+----------+---------------+------------+--------------+ | ID | Name | CountryCode | District | Population | |------+----------+---------------+------------+--------------| | 15 | Enschede | NLD | Overijssel | 149544 | | 28 | Zwolle | NLD | Overijssel | 105819 | | 2025 | Zunyi | CHN | Guizhou | 261862 | | 3145 | Zwickau | DEU | Saksi | 104146 | | 3245 | Zürich | CHE | Zürich | 336800 | | 3446 | Zytomyr | UKR | Zytomyr | 297000 | +------+----------+---------------+------------+--------------+
Nesta consulta, não forneci parênteses e, portanto, o
AND operador foi avaliado antes do OR operador. Portanto, obtivemos linhas que satisfizeram
Name > 'Zukovski' AND Population > 100000 ou District = 'Overijssel' . Podemos dizer apenas olhando para isso que todas as cidades do distrito de Overijssel serão devolvidas, além de quaisquer cidades que satisfaçam o primeiro critério. Isso é como fazer o seguinte:
SELECT * FROM city
WHERE (Name > 'Zukovski'
AND Population > 100000)
OR District = 'Overijssel';Isso nos daria o mesmo resultado da consulta anterior sem parênteses.
Mas veja o que acontece quando movemos os parênteses para o
OR doença. SELECT * FROM city
WHERE Name > 'Zukovski'
AND (Population > 100000
OR District = 'Overijssel');Resultado:
+------+---------+---------------+------------+--------------+ | ID | Name | CountryCode | District | Population | |------+---------+---------------+------------+--------------| | 28 | Zwolle | NLD | Overijssel | 105819 | | 2025 | Zunyi | CHN | Guizhou | 261862 | | 3145 | Zwickau | DEU | Saksi | 104146 | | 3245 | Zürich | CHE | Zürich | 336800 | | 3446 | Zytomyr | UKR | Zytomyr | 297000 | +------+---------+---------------+------------+--------------+
Desta vez, obtivemos apenas as cidades que satisfizeram tanto
Population > 100000 OR District = 'Overijssel' e Name > 'Overijssel' . Isso resultou em apenas uma cidade de Overijssel sendo retornada, em oposição a duas na consulta anterior.
Negando a condição
Você pode usar o
NOT operador para negar a condição fornecida pelo operador maior que. Aqui está um exemplo:SELECT PetName, DOB
FROM Pets
WHERE NOT DOB > '2019-12-31';Resultado:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
