Categorias:: Funções de dados semiestruturados e estruturados (Ordem superior)

FILTER¶

Filtra uma matriz com base na lógica de uma expressão lambda.

Consulte também:: Usar funções lambda em dados com funções de ordem superior do Snowflake

Sintaxe¶

FILTER( <array> , <lambda_expression> )

Argumentos¶

array

A matriz que contém os elementos a serem filtrados. A matriz pode ser semiestruturada ou estruturada.

lambda_expression

Uma expressão lambda que define a condição do filtro em cada elemento da matriz.

A expressão lambda deve ter apenas um argumento especificado na seguinte sintaxe:

<arg> [ <datatype> ] -> <expr>

Retornos¶

O tipo de retorno desta função é uma matriz do mesmo tipo que a matriz de entrada. A matriz retornada contém os elementos para os quais a condição do filtro retorna TRUE.

Se qualquer dos argumentos for NULL, a função retorna NULL sem relatar um erro.

Notas de uso¶

Quando o tipo de dados para o argumento lambda é especificado explicitamente, o elemento da matriz é forçado para o tipo especificado antes da invocação da lambda. Para obter informações sobre coerção, consulte Conversão do tipo de dados.
Se a condição do filtro for avaliada como NULL, o elemento da matriz correspondente será filtrado.

Exemplos¶

Os exemplos a seguir usam a função FILTER.

Filtrar por elementos de matriz maiores que um valor¶

Use a função FILTER para retornar objetos em uma matriz que tenham um valor maior ou igual a 50:

SELECT FILTER(
  [
    {'name':'Pat', 'value': 50},
    {'name':'Terry', 'value': 75},
    {'name':'Dana', 'value': 25}
  ],
  a -> a:value >= 50
) AS "Filter >= 50";

+----------------------+
| Filter >= 50         |
|----------------------|
| [                    |
|   {                  |
|     "name": "Pat",   |
|     "value": 50      |
|   },                 |
|   {                  |
|     "name": "Terry", |
|     "value": 75      |
|   }                  |
| ]                    |
+----------------------+

Filtrar por elementos de matriz que não são NULL¶

Use a função FILTER para retornar elementos de matriz que não são NULL:

SELECT FILTER([1, NULL, 3, 5, NULL], a -> a IS NOT NULL) AS "Not NULL Elements";

+-------------------+
| Not NULL Elements |
|-------------------|
| [                 |
|   1,              |
|   3,              |
|   5               |
| ]                 |
+-------------------+

Filtrar por elementos de matriz em uma tabela que sejam maiores ou iguais a um valor¶

Suponha que você tenha uma tabela chamada orders com as colunas order_id, order_date e order_detail. A coluna order_detail é uma matriz dos itens de linha, sua quantidade de compra e subtotal. A tabela contém duas linhas de dados. A seguinte instrução SQL cria esta tabela e insere as linhas:

CREATE OR REPLACE TABLE orders AS
  SELECT 1 AS order_id, '2024-01-01' AS order_date, [
    {'item':'UHD Monitor', 'quantity':3, 'subtotal':1500},
    {'item':'Business Printer', 'quantity':1, 'subtotal':1200}
  ] AS order_detail
  UNION
  SELECT 2 AS order_id, '2024-01-02' AS order_date, [
    {'item':'Laptop', 'quantity':5, 'subtotal':7500},
    {'item':'Noise-canceling Headphones', 'quantity':5, 'subtotal':1000}
  ] AS order_detail;

SELECT * FROM orders;

+----------+------------+-------------------------------------------+
| ORDER_ID | ORDER_DATE | ORDER_DETAIL                              |
|----------+------------+-------------------------------------------|
|        1 | 2024-01-01 | [                                         |
|          |            |   {                                       |
|          |            |     "item": "UHD Monitor",                |
|          |            |     "quantity": 3,                        |
|          |            |     "subtotal": 1500                      |
|          |            |   },                                      |
|          |            |   {                                       |
|          |            |     "item": "Business Printer",           |
|          |            |     "quantity": 1,                        |
|          |            |     "subtotal": 1200                      |
|          |            |   }                                       |
|          |            | ]                                         |
|        2 | 2024-01-02 | [                                         |
|          |            |   {                                       |
|          |            |     "item": "Laptop",                     |
|          |            |     "quantity": 5,                        |
|          |            |     "subtotal": 7500                      |
|          |            |   },                                      |
|          |            |   {                                       |
|          |            |     "item": "Noise-canceling Headphones", |
|          |            |     "quantity": 5,                        |
|          |            |     "subtotal": 1000                      |
|          |            |   }                                       |
|          |            | ]                                         |
+----------+------------+-------------------------------------------+

Use a função FILTER para retornar pedidos com subtotais maiores ou iguais a 1500:

SELECT order_id,
       order_date,
       FILTER(o.order_detail, i -> i:subtotal >= 1500) AS order_detail_gt_equal_1500
  FROM orders o;

+----------+------------+----------------------------+
| ORDER_ID | ORDER_DATE | ORDER_DETAIL_GT_EQUAL_1500 |
|----------+------------+----------------------------|
|        1 | 2024-01-01 | [                          |
|          |            |   {                        |
|          |            |     "item": "UHD Monitor", |
|          |            |     "quantity": 3,         |
|          |            |     "subtotal": 1500       |
|          |            |   }                        |
|          |            | ]                          |
|        2 | 2024-01-02 | [                          |
|          |            |   {                        |
|          |            |     "item": "Laptop",      |
|          |            |     "quantity": 5,         |
|          |            |     "subtotal": 7500       |
|          |            |   }                        |
|          |            | ]                          |
+----------+------------+----------------------------+

Faça referência a uma coluna de tabela em uma expressão lambda para filtrar elementos de matriz em dados de tabela¶

Criar uma tabela com uma coluna do tipo ARRAY e outra coluna do tipo INT:

CREATE OR REPLACE TABLE filter_column_ref_demo AS
  SELECT [ 10, 15, 20 ] AS col1, 18 AS col2
  UNION
  SELECT [ 30, 50, 70 ] AS col1, 40 AS col2;

SELECT * FROM filter_column_ref_demo;

+-------+------+
| COL1  | COL2 |
|-------+------|
| [     |   18 |
|   10, |      |
|   15, |      |
|   20  |      |
| ]     |      |
| [     |   40 |
|   30, |      |
|   50, |      |
|   70  |      |
| ]     |      |
+-------+------+

Use a função FILTER para retornar os valores dos valores dos elementos de matriz em cada linha que são menores que o valor em col2:

SELECT FILTER(col1, v -> v < col2) AS filter_col_ref
  FROM filter_column_ref_demo;

+----------------+
| FILTER_COL_REF |
|----------------|
| [              |
|   10,          |
|   15           |
| ]              |
| [              |
|   30           |
| ]              |
+----------------+