SELECT

SELECT pode ser usado como uma instrução ou como uma cláusula dentro de outras instruções:

  • Como uma instrução, a instrução SELECT é a instrução SQL mais comumente executada; ela consulta o banco de dados e recupera um conjunto de linhas.

  • Como uma cláusula, SELECT define o conjunto de colunas retornadas por uma consulta.

Consulte também:

Sintaxe de consulta

Sintaxe

As seções a seguir descrevem a sintaxe deste comando:

Como selecionar todas as colunas

[ ... ]
SELECT [ { ALL | DISTINCT } ]
       [ TOP <n> ]
       [{<object_name>|<alias>}.]*

       [ ILIKE '<pattern>' ]

       [ EXCLUDE
         {
           <col_name> | ( <col_name>, <col_name>, ... )
         }
       ]

       [ REPLACE
         {
           ( <expr> AS <col_name> [ , <expr> AS <col_name>, ... ] )
         }
       ]

       [ RENAME
         {
           <col_name> AS <col_alias>
           | ( <col_name> AS <col_alias>, <col_name> AS <col_alias>, ... )
         }
       ]
Copy

Você pode especificar as seguintes combinações de palavras-chave após SELECT *. As palavras-chave devem estar na ordem mostrada abaixo:

SELECT * ILIKE ... REPLACE ...
Copy
SELECT * ILIKE ... RENAME ...
Copy
SELECT * ILIKE ... REPLACE ... RENAME ...
Copy
SELECT * EXCLUDE ... REPLACE ...
Copy
SELECT * EXCLUDE ... RENAME ...
Copy
SELECT * EXCLUDE ... REPLACE ... RENAME ...
Copy
SELECT * REPLACE ... RENAME ...
Copy

Como selecionar colunas específicas

[ ... ]
SELECT [ { ALL | DISTINCT } ]
       [ TOP <n> ]
       {
         [{<object_name>|<alias>}.]<col_name>
         | [{<object_name>|<alias>}.]$<col_position>
         | <expr>
       }
       [ [ AS ] <col_alias> ]
       [ , ... ]
[ ... ]
Copy

Para obter mais informações sobre SELECT como uma instrução, e as outras cláusulas dentro da instrução, consulte Sintaxe de consulta.

Parâmetros

ALL | DISTINCT

Especifica se a eliminação duplicada deve ser feita no conjunto de resultados:

  • ALL inclui todos os valores no conjunto de resultados.

  • DISTINCT elimina os valores duplicados do conjunto de resultados.

Padrão: ALL

TOP n

Especifica o número máximo de resultados a serem retornados. Consulte TOP <n>.

object_name ou . alias

Especifica o identificador do objeto ou alias do objeto, conforme definido na cláusula FROM.

*

O asterisco é um asterisco para indicar que a saída deve incluir todas as colunas do objeto especificado, ou todas as colunas de todos os objetos se * não estiver qualificado com um nome ou alias do objeto.

Ao especificar *, você também pode especificar ILIKE, EXCLUDE, REPLACE e RENAME:

ILIKE 'pattern'

Especifica que apenas as colunas que correspondem a pattern devem ser incluídas nos resultados.

No pattern, você pode usar os seguintes curingas SQL:

  • Use um sublinhado (_) para corresponder a qualquer caractere único.

  • Use um sinal de porcentagem (%) para corresponder a qualquer sequência de zero ou mais caracteres.

Para corresponder uma sequência em qualquer lugar do nome da coluna, comece e termine o padrão com %.

A correspondência não diferencia maiúsculas e minúsculas.

Se nenhuma coluna corresponder ao padrão especificado, ocorrerá um erro de compilação (001080 (42601): ... SELECT with no columns).

EXCLUDE col_name . EXCLUDE (col_name, col_name, ...)

Especifica as colunas que devem ser excluídas dos resultados.

Se você estiver selecionando de várias tabelas, use SELECT table_name.* para especificar que deseja selecionar todas as colunas de uma tabela específica, e especifique o nome da coluna não qualificado em EXCLUDE. Por exemplo:

SELECT table_a.* EXCLUDE column_in_table_a ,
  table_b.* EXCLUDE column_in_table_b
  ...
Copy
REPLACE (expr AS col_name [ , expr AS col_name, ...] )

Substitui o valor de col_name pelo valor da expressão avaliada expr.

Por exemplo, para preceder a cadeia de caracteres 'DEPT-' aos valores na coluna department_id, use:

SELECT REPLACE ('DEPT-' || department_id AS department_id) ...
Copy

Para col_name:

  • A coluna deve existir e não pode ser filtrada por ILIKE ou EXCEPT.

  • Você não pode especificar a mesma coluna mais de uma vez na lista de substituições.

  • Se a coluna estiver em diversas tabelas (por exemplo, em ambas as tabelas em uma junção), a instrução falhará com um erro de «coluna ambígua».

expr deve avaliar como um único valor.

RENAME col_name AS col_alias . RENAME (col_name AS col_alias, col_name AS col_alias, ...)

Especifica os alias das colunas que devem ser usados nos resultados.

Se você estiver selecionando de várias tabelas, use SELECT table_name.* para especificar que deseja selecionar todas as colunas de uma tabela específica, e especifique o nome da coluna não qualificado em RENAME. Por exemplo:

SELECT table_a.* RENAME column_in_table_a AS col_alias_a,
  table_b.* RENAME column_in_table_b AS col_alias_b
  ...
Copy

Nota

Ao especificar uma combinação de palavras-chave após SELECT *:

  • Você não pode especificar ILIKE e EXCLUDE.

  • Se você especificar EXCLUDE com RENAME ou REPLACE:

    • Você deve especificar EXCLUDE antes de RENAME ou REPLACE:

      SELECT * EXCLUDE col_a RENAME col_b AS alias_b ...
      
      Copy
      SELECT * EXCLUDE employee_id REPLACE ('DEPT-' || department_id AS department_id) ...
      
      Copy
    • Não se pode especificar a mesma coluna em EXCLUDE e RENAME.

  • Se você especificar ILIKE com RENAME ou REPLACE, deverá especificar ILIKE primeiro:

    SELECT * ILIKE '%id%' RENAME department_id AS department ...
    
    Copy
    SELECT * ILIKE '%id%' REPLACE ('DEPT-' || department_id AS department_id) ...
    
    Copy
  • Se você especificar REPLACE e RENAME:

    • Você deve especificar REPLACE primeiro:

      SELECT * REPLACE ('DEPT-' || department_id AS department_id) RENAME employee_id as employee ...
      
      Copy
    • Você pode especificar o mesmo nome de coluna em REPLACE e RENAME:

      SELECT * REPLACE ('DEPT-' || department_id AS department_id) RENAME department_id as department ...
      
      Copy
col_name

Especifica o identificador da coluna, conforme definido na cláusula FROM.

$col_position

Especifica a posição da coluna (baseado em 1) conforme definido na cláusula FROM. Se uma coluna for referenciada a partir de uma tabela, este número não pode exceder o número máximo de colunas na tabela.

expr

Especifica uma expressão, como uma expressão matemática, que avalia como um valor específico para qualquer linha específica.

[ AS ] col_alias

Especifica o alias da coluna atribuída à expressão resultante. Isto é usado como o nome de exibição em uma lista SELECT de nível superior, e o nome da coluna em uma exibição em linha.

Não atribua um alias de coluna que seja igual ao nome de outra coluna referenciada na consulta. Por exemplo, se você estiver selecionando colunas denominadas prod_id e product_id, não use o alias prod_id como product_id. Consulte Caso de erro: especificação de um alias que corresponda a outro nome de coluna.

Uso da cláusula FOR UPDATE

Bloqueie os resultados para atualizações futuras usando a cláusula opcional FOR UPDATE.

SELECT ...
  FROM ...
  [ ... ]
  FOR UPDATE [ NOWAIT | WAIT <wait_time> ]
Copy

Parâmetros

WAIT

Um número inteiro especifica o tempo máximo (em segundos) que esta instrução aguarda para adquirir bloqueios.

Notas de uso

Nota

Como as tabelas híbridas oferecem suporte ao nível de isolamento READ COMMITTED, as cláusulas FOR UPDATE não podem garantir a estabilidade de leitura.

  • Uma tabela T com apenas a coluna ID começa com duas tuplas: 5 e 10.

  • SELECT * FROM T WHERE ID < 20 FOR UPDATE na transação T1 retornaria duas tuplas 5 e 10 e as bloquearia.

    • DELETE FROM T WHERE ID = 5 de outra transação T2 tem que esperar até que T1 seja concluído (confirmação ou reversão).

  • No entanto, INSERT INTO T VALUES 12 em outra transação T3 pode ser concluída, e um SELECT * FROM T WHERE ID < 20 subsequente em T1 verá três tuplas: 5, 10 e 12.

Notas de uso

  • Os alias e identificadores diferenciam maiúsculas e minúsculas, por padrão. Para preservar o tipo de letra, coloque-os entre aspas duplas ("). Para obter mais informações, consulte Identificadores de objetos.

  • Sem uma cláusula ORDER BY, os resultados retornados por SELECT são um conjunto não ordenado. Executar a mesma consulta repetidamente com as mesmas tabelas pode resultar em uma ordem de saída diferente a cada vez. Se a ordem for importante, use a cláusula ORDER BY.

  • SELECT pode ser usado não apenas como uma instrução independente, mas também como uma cláusula em outras instruções, por exemplo INSERT INTO ... SELECT ...;. SELECT também pode ser usado em uma subconsulta dentro de uma instrução.

  • Em muitos casos, quando você usa um alias de coluna para uma expressão (ou seja, expr AS col_alias) em outras partes da mesma consulta (em JOIN, FROM, WHERE, GROUP BY, outras expressões de coluna etc.), a expressão é avaliada apenas uma vez.

    Entretanto, observe que, em alguns casos, a expressão pode ser avaliada várias vezes, o que pode resultar em valores diferentes para o alias usado em partes diferentes da mesma consulta.

Exemplos

Alguns exemplos simples são fornecidos abaixo.

Muitos exemplos adicionais estão incluídos em outras partes da documentação, incluindo as descrições detalhadas de Sintaxe de consulta.

Para obter exemplos relacionados à consulta de uma tabela de eventos (cujo esquema é predefinido pelo Snowflake), consulte Acesso a dados de mensagens registradas e Acesso a dados de rastreamento.

Configuração dos dados para os exemplos

Algumas das consultas abaixo utilizam as seguintes tabelas e dados:

CREATE TABLE employee_table (
    employee_ID INTEGER,
    last_name VARCHAR,
    first_name VARCHAR,
    department_ID INTEGER
    );

CREATE TABLE department_table (
    department_ID INTEGER,
    department_name VARCHAR
    );
Copy
INSERT INTO employee_table (employee_ID, last_name, first_name, department_ID) VALUES
    (101, 'Montgomery', 'Pat', 1),
    (102, 'Levine', 'Terry', 2),
    (103, 'Comstock', 'Dana', 2);

INSERT INTO department_table (department_ID, department_name) VALUES
    (1, 'Engineering'),
    (2, 'Customer Support'),
    (3, 'Finance');
Copy

Exemplos de seleção de todas as colunas (SELECT *)

Seleção de todas as colunas na tabela

Este exemplo mostra como selecionar todas as colunas em employee_table:

SELECT * FROM employee_table;
Copy
+-------------+------------+------------+---------------+
| EMPLOYEE_ID | LAST_NAME  | FIRST_NAME | DEPARTMENT_ID |
|-------------+------------+------------+---------------|
|         101 | Montgomery | Pat        |             1 |
|         102 | Levine     | Terry      |             2 |
|         103 | Comstock   | Dana       |             2 |
+-------------+------------+------------+---------------+

Seleção de todas as colunas com nomes que correspondem a um padrão

Este exemplo mostra como selecionar todas as colunas em employee_table com nomes que contenham id:

SELECT * ILIKE '%id%' FROM employee_table;
Copy
+-------------+---------------+
| EMPLOYEE_ID | DEPARTMENT_ID |
|-------------+---------------|
|         101 |             1 |
|         102 |             2 |
|         103 |             2 |
+-------------+---------------+

Seleção de todas as colunas exceto uma coluna

Este exemplo mostra como selecionar todas as colunas em employee_table, exceto a coluna department_id:

SELECT * EXCLUDE department_id FROM employee_table;
Copy
+-------------+------------+------------+
| EMPLOYEE_ID | LAST_NAME  | FIRST_NAME |
|-------------+------------+------------|
|         101 | Montgomery | Pat        |
|         102 | Levine     | Terry      |
|         103 | Comstock   | Dana       |
+-------------+------------+------------+

Seleção de todas as colunas exceto duas ou mais colunas

Este exemplo mostra como selecionar todas as colunas em employee_table, exceto as colunas department_id e employee_id:

SELECT * EXCLUDE (department_id, employee_id) FROM employee_table;
Copy
+------------+------------+
| LAST_NAME  | FIRST_NAME |
|------------+------------|
| Montgomery | Pat        |
| Levine     | Terry      |
| Comstock   | Dana       |
+------------+------------+

Seleção de todas as colunas e renomeação de uma coluna

Este exemplo mostra como selecionar todas as colunas em employee_table e renomear a coluna department_id:

SELECT * RENAME department_id AS department FROM employee_table;
Copy
+-------------+------------+------------+------------+
| EMPLOYEE_ID | LAST_NAME  | FIRST_NAME | DEPARTMENT |
|-------------+------------+------------+------------|
|         101 | Montgomery | Pat        |          1 |
|         102 | Levine     | Terry      |          2 |
|         103 | Comstock   | Dana       |          2 |
+-------------+------------+------------+------------+

Seleção de todas as colunas e renomeação de várias colunas

Este exemplo mostra como selecionar todas as colunas em employee_table e renomear as colunas department_id e employee_id:

SELECT * RENAME (department_id AS department, employee_id AS id) FROM employee_table;
Copy
+-----+------------+------------+------------+
|  ID | LAST_NAME  | FIRST_NAME | DEPARTMENT |
|-----+------------+------------+------------|
| 101 | Montgomery | Pat        |          1 |
| 102 | Levine     | Terry      |          2 |
| 103 | Comstock   | Dana       |          2 |
+-----+------------+------------+------------+

Seleção de todas as colunas, exclusão de uma coluna e renomeação de várias colunas

Este exemplo mostra como selecionar todas as colunas em employee_table, excluir a coluna first_name e renomear as colunas department_id e employee_id:

SELECT * EXCLUDE first_name RENAME (department_id AS department, employee_id AS id) FROM employee_table;
Copy
+-----+------------+------------+
|  ID | LAST_NAME  | DEPARTMENT |
|-----+------------+------------|
| 101 | Montgomery |          1 |
| 102 | Levine     |          2 |
| 103 | Comstock   |          2 |
+-----+------------+------------+

Seleção de todas as colunas com nomes que correspondam a um padrão e renomeação de uma coluna

Este exemplo mostra como selecionar todas as colunas em employee_table com nomes que contenham id e como renomear a coluna department_id:

SELECT * ILIKE '%id%' RENAME department_id AS department FROM employee_table;
Copy
+-------------+------------+
| EMPLOYEE_ID | DEPARTMENT |
|-------------+------------|
|         101 |          1 |
|         102 |          2 |
|         103 |          2 |
+-------------+------------+

Seleção de todas as colunas e substituição do valor de uma coluna

Este exemplo mostra como selecionar todas as colunas em employee_table e substituir o valor na coluna department_id por ID prefixado com DEPT-:

SELECT * REPLACE ('DEPT-' || department_id AS department_id) FROM employee_table;
Copy
+-------------+------------+------------+---------------+
| EMPLOYEE_ID | LAST_NAME  | FIRST_NAME | DEPARTMENT_ID |
|-------------+------------+------------+---------------|
|         101 | Montgomery | Pat        | DEPT-1        |
|         102 | Levine     | Terry      | DEPT-2        |
|         103 | Comstock   | Dana       | DEPT-2        |
+-------------+------------+------------+---------------+

Seleção de todas as colunas, substituição do valor de uma coluna e renomeação da coluna

Este exemplo mostra como selecionar todas as colunas em employee_table, substituir o valor na coluna department_id por ID prefixado com DEPT- e renomear a coluna:

SELECT * REPLACE ('DEPT-' || department_id AS department_id) RENAME department_id AS department FROM employee_table;
Copy
+-------------+------------+------------+------------+
| EMPLOYEE_ID | LAST_NAME  | FIRST_NAME | DEPARTMENT |
|-------------+------------+------------+------------|
|         101 | Montgomery | Pat        | DEPT-1     |
|         102 | Levine     | Terry      | DEPT-2     |
|         103 | Comstock   | Dana       | DEPT-2     |
+-------------+------------+------------+------------+

Seleção de todas as colunas com nomes que correspondam a um padrão e substituição do valor em uma coluna

Este exemplo mostra como selecionar todas as colunas em employee_table com nomes que contêm id e anexando DEPT- aos valores na coluna department_id:

SELECT * ILIKE '%id%' REPLACE('DEPT-' || department_id AS department_id) FROM employee_table;
Copy
+-------------+---------------+
| EMPLOYEE_ID | DEPARTMENT_ID |
|-------------+---------------|
|         101 | DEPT-1        |
|         102 | DEPT-2        |
|         103 | DEPT-2        |
+-------------+---------------+

Seleção de todas as colunas de várias tabelas, exclusão de uma coluna e renomeação de uma coluna

Este exemplo une duas tabelas e seleciona todas as colunas das duas tabelas, exceto uma coluna de employee_table. O exemplo também renomeia uma das colunas selecionadas de department_table.

SELECT
  employee_table.* EXCLUDE department_id,
  department_table.* RENAME department_name AS department
FROM employee_table INNER JOIN department_table
  ON employee_table.department_id = department_table.department_id
ORDER BY department, last_name, first_name;
Copy
+-------------+------------+------------+---------------+------------------+
| EMPLOYEE_ID | LAST_NAME  | FIRST_NAME | DEPARTMENT_ID | DEPARTMENT       |
|-------------+------------+------------+---------------+------------------|
|         103 | Comstock   | Dana       |             2 | Customer Support |
|         102 | Levine     | Terry      |             2 | Customer Support |
|         101 | Montgomery | Pat        |             1 | Engineering      |
+-------------+------------+------------+---------------+------------------+

Exemplos de seleção de colunas específicas (SELECT nome de coluna)

Seleção de uma única coluna por nome

Este exemplo mostra como procurar o sobrenome de um funcionário se você souber sua ID.

SELECT last_name FROM employee_table WHERE employee_ID = 101;
+------------+
| LAST_NAME  |
|------------|
| Montgomery |
+------------+
Copy

Seleção de várias colunas por nome a partir de tabelas unidas

Este exemplo lista cada funcionário e o nome do departamento em que cada funcionário trabalha. A saída está em ordem por nome de departamento, e dentro de cada departamento os funcionários estão ordenados por nome. Esta consulta usa uma junção para relacionar as informações em uma tabela com as informações em outra tabela.

SELECT department_name, last_name, first_name
    FROM employee_table INNER JOIN department_table
        ON employee_table.department_ID = department_table.department_ID
    ORDER BY department_name, last_name, first_name;
+------------------+------------+------------+
| DEPARTMENT_NAME  | LAST_NAME  | FIRST_NAME |
|------------------+------------+------------|
| Customer Support | Comstock   | Dana       |
| Customer Support | Levine     | Terry      |
| Engineering      | Montgomery | Pat        |
+------------------+------------+------------+
Copy

Seleção de uma coluna por posição

Este exemplo mostra como usar $ para especificar uma coluna por número de coluna, em vez de por nome de coluna:

SELECT $2 FROM employee_table ORDER BY $2;
+------------+
| $2         |
|------------|
| Comstock   |
| Levine     |
| Montgomery |
+------------+
Copy

Especificação de um alias para uma coluna na saída

Este exemplo mostra que as colunas de saída não precisam ser retiradas diretamente das tabelas da cláusula FROM; as colunas de saída podem ser expressões gerais. Este exemplo calcula a área de um círculo que tem um raio de 2,0. Este exemplo também mostra como usar um alias de coluna para que a saída tenha um nome de coluna significativo:

SELECT pi() * 2.0 * 2.0 AS area_of_circle;
+----------------+
| AREA_OF_CIRCLE |
|----------------|
|   12.566370614 |
+----------------+
Copy

Caso de erro: especificação de um alias que corresponda a outro nome de coluna

Este exemplo demonstra por que não é recomendado usar um alias de coluna que corresponda ao nome de outra coluna usada na consulta. Esta consulta GROUP BY resulta em um erro de compilador SQL, não em um erro de coluna ambígua. O alias prod_id atribuído a product_id em table1 corresponde ao nome da coluna prod_id em table2. A solução mais simples para esse erro é atribuir um alias diferente à coluna.

CREATE OR REPLACE TABLE table1 (product_id NUMBER);

CREATE OR REPLACE TABLE table2 (prod_id NUMBER);

SELECT t1.product_id AS prod_id, t2.prod_id
  FROM table1 AS t1 JOIN table2 AS t2
    ON t1.product_id=t2.prod_id
  GROUP BY prod_id, t2.prod_id;
Copy
001104 (42601): SQL compilation error: error line 1 at position 7
'T1.PRODUCT_ID' in select clause is neither an aggregate nor in the group by clause.