Operadores de fluxo¶

Selecione uma lista de colunas para a saída de um comando SHOW¶

Execute um comando SHOW TABLES e use o operador de canal para limitar a saída às colunas created_on, name e owner para tabelas criadas após 15 de abril de 2025.

SHOW TABLES
  ->> SELECT "created_on" AS creation_date,
             "name" AS table_name,
             "owner" AS table_owner
        FROM $1
        WHERE creation_date > '2025-04-15'::DATE;

+-------------------------------+-------------+--------------+
| CREATION_DATE                 | TABLE_NAME  | TABLE_OWNER  |
|-------------------------------+-------------+--------------|
| 2025-04-16 08:46:16.130 -0700 | TEST_TABLE1 | ACCOUNTADMIN |
| 2025-04-16 09:44:13.701 -0700 | MYTABLE1    | USER_ROLE    |
| 2025-04-16 08:46:32.092 -0700 | MYTABLE2    | USER_ROLE    |
+-------------------------------+-------------+--------------+

Execução de consultas que recebem entradas de consultas em várias tabelas¶

Primeiro, crie uma tabela dept_pipe_demo e uma tabela emp_pipe_demo e insira dados em cada uma delas:

CREATE OR REPLACE TABLE dept_pipe_demo (
  deptno NUMBER(2),
  dname VARCHAR(14),
  loc VARCHAR(13)
  ) AS SELECT * FROM VALUES
     (10, 'ACCOUNTING', 'NEW YORK'),
     (20, 'RESEARCH', 'DALLAS'),
     (30, 'SALES', 'CHICAGO'),
     (40, 'OPERATIONS', 'BOSTON');

CREATE OR REPLACE TABLE emp_pipe_demo (
  empno NUMBER(4),
  ename VARCHAR(10),
  sal NUMBER(7,2),
  deptno NUMBER(2)
  ) AS SELECT * FROM VALUES
    (7369, 'SMITH', 800, 20),
    (7499, 'ALLEN', 1600, 30),
    (7521, 'WARD', 1250, 30),
    (7698, 'BLAKE', 2850, 30),
    (7782, 'CLARK', 2450, 10);

O exemplo a seguir usa o operador de canal para uma cadeia de instruções SQL que executam as seguintes operações:

1. Consulte a tabela dept_pipe_demo para retornar as linhas em que dname é igual a SALES.

2. Consulte na tabela emp_pipe_demo os funcionários com salário maior que 1500 no departamento SALES, usando os resultados da consulta anterior como entrada, especificando $1 na condição WHERE de uma cláusula FROM.

3. Execute uma consulta que retorne os valores ename e sal usando os resultados da consulta anterior como entrada, especificando $1 na cláusula FROM.

SELECT * FROM dept_pipe_demo WHERE dname = 'SALES'
  ->> SELECT * FROM emp_pipe_demo WHERE sal > 1500 AND deptno IN (SELECT deptno FROM $1)
  ->> SELECT ename, sal FROM $1 ORDER BY 2 DESC;

+-------+---------+
| ENAME |     SAL |
|-------+---------|
| BLAKE | 2850.00 |
| ALLEN | 1600.00 |
+-------+---------+

Retorno da contagem de linhas para as operações do DML em uma transação¶

Crie uma tabela e insira as linhas uma a uma. O encadeamento de todas as instruções permite que você use o operador de canal para examinar o resultado de cada instrução INSERT, que representa o número total de linhas inseridas.

Em cada uma das instruções SELECT do exemplo, o $1 na lista SELECT é uma referência abreviada para a primeira coluna, não um resultado anterior no canal. O parâmetro $n para um número de canal só é válido na cláusula FROM.

CREATE OR REPLACE TABLE test_sql_pipe_dml (a INT, b INT)
  ->> INSERT INTO test_sql_pipe_dml VALUES (1, 2)
  ->> INSERT INTO test_sql_pipe_dml VALUES (3, 4)
  ->> INSERT INTO test_sql_pipe_dml VALUES (5, 6)
  ->> INSERT INTO test_sql_pipe_dml VALUES (7, 8)
  ->> SELECT (SELECT $1 FROM $4) +
             (SELECT $1 FROM $3) +
             (SELECT $1 FROM $2) +
             (SELECT $1 FROM $1)
        AS "Number of rows";

+----------------+
| Number of rows |
|----------------|
|              4 |
+----------------+

O exemplo a seguir usa o operador de canal para uma cadeia de instruções SQL que executam as seguintes operações:

1. Iniciar uma transação.

2. Inserir uma linha na tabela criada anteriormente.

3. Excluir linhas da tabela.

4. Atualizar as linhas da tabela.

5. Confirmar a transação.

6. Consultar o número de linhas que foram afetadas por cada operação do DML.

EXECUTE IMMEDIATE $$
BEGIN TRANSACTION
  ->> INSERT INTO test_sql_pipe_dml VALUES (1, 2)
  ->> DELETE FROM test_sql_pipe_dml WHERE a = 1
  ->> UPDATE test_sql_pipe_dml SET b = 2
  ->> COMMIT
  ->> SELECT
        (SELECT $1 FROM $4) AS "Inserted rows",
        (SELECT $1 FROM $3) AS "Deleted rows",
        (SELECT $1 FROM $2) AS "Updated rows";
$$;

+---------------+--------------+--------------+
| Inserted rows | Deleted rows | Updated rows |
|---------------+--------------+--------------|
|             1 |            2 |            3 |
+---------------+--------------+--------------+

Retorno dos resultados das inserções em uma tabela que será descartada posteriormente¶

Este exemplo usa o operador de canal para uma cadeia de instruções SQL que executa as seguintes operações:

1. Criar uma tabela com uma coluna IDENTITY.

2. Inserir linhas na tabela.

3. Consultar a tabela.

4. Descartar a tabela.

5. Consultar os resultados do canal número $2 (a instrução SELECT).

O conjunto de resultados consumido na última instrução SELECT é equivalente ao conjunto de resultados retornado pela função RESULT_SCAN para o ID da consulta da instrução SELECT anterior.

CREATE OR REPLACE TABLE test_sql_pipe_drop (
    id INT IDENTITY START 10 INCREMENT 1,
    data VARCHAR)
  ->> INSERT INTO test_sql_pipe_drop (data) VALUES ('row1'), ('row2'), ('row3')
  ->> SELECT * FROM test_sql_pipe_drop
  ->> DROP TABLE test_sql_pipe_drop
  ->> SELECT COUNT(*) "Number of rows", MAX(id) AS "Last ID" FROM $2;

+----------------+---------+
| Number of rows | Last ID |
|----------------+---------|
|              3 |      12 |
+----------------+---------+