- Kategorien:
Funktionen für semistrukturierte und strukturierte Daten (höhere Ordnung)
FILTER¶
Filtert ein Array basierend auf der Logik eines Lambda-Ausdrucks.
Syntax¶
FILTER( <array> , <lambda_expression> )
Argumente¶
arrayDas Array, das die zu filternden Elemente enthält. Das Feld kann semistrukturiert oder strukturiert sein.
lambda_expressionEin Lambda-Ausdruck, der die Filterbedingung für jedes Array-Element definiert.
Der Lambda-Ausdruck darf nur ein Argument haben, das in der folgenden Syntax angegeben wird:
<arg> [ <datatype> ] -> <expr>
Rückgabewerte¶
Der Rückgabetyp dieser Funktion ist ein Array vom gleichen Typ wie das Eingabe-Array. Das zurückgegebene Array enthält die Elemente, für die Filterbedingung TRUE zurückgibt.
Wenn eines der beiden Argumente NULL ist, gibt die Funktion NULL zurück, ohne einen Fehler zu melden.
Nutzungshinweise¶
Wenn der Datentyp für das Lambda-Argument explizit angegeben ist, wird das Array-Element vor dem Lambda-Aufruf in den angegebenen Typ implizit umgewandelt (Koersion). Weitere Informationen zur Koersion finden Sie unter Datentypkonvertierung.
Wenn die Filterbedingung den Wert NULL ergibt, wird das entsprechende Array-Element herausgefiltert.
Beispiele¶
Die folgenden Beispiele verwenden die Funktion FILTER.
Filter für Array-Elemente größer als ein Wert¶
Verwenden Sie die Funktion FILTER, um Objekte eines Array zurückzugeben, die einen Wert größer oder gleich 50 haben:
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 |
| } |
| ] |
+----------------------+
Filter für Array-Elemente, die nicht NULL sind¶
Verwenden Sie die Funktion FILTER, um Array-Elemente zurückzugeben, die nicht NULL sind:
SELECT FILTER([1, NULL, 3, 5, NULL], a -> a IS NOT NULL) AS "Not NULL Elements";
+-------------------+
| Not NULL Elements |
|-------------------|
| [ |
| 1, |
| 3, |
| 5 |
| ] |
+-------------------+
Filter für Array-Elemente in einer Tabelle, die größer oder gleich einem Wert sind¶
Angenommen, Sie haben eine Tabelle namens orders mit den Spalten order_id, order_date und order_detail. Die Spalte order_detail ist ein Array mit den Einzelposten, deren Einkaufsmenge und der Zwischensumme. Die Tabelle enthält zwei Zeilen mit Daten. Die folgende SQL-Anweisung erstellt diese Tabelle und fügt die Zeilen ein:
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 |
| | | } |
| | | ] |
+----------+------------+-------------------------------------------+
Verwenden Sie die Funktion FILTER, um Bestellungen mit Zwischensummen größer oder gleich 1500 zurückzugeben:
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 |
| | | } |
| | | ] |
+----------+------------+----------------------------+
Referenzieren einer Tabellenspalte in einem Lambda-Ausdruck, um Array-Elemente in Tabellendaten zu filtern¶
Erstellen Sie eine Tabelle mit einer Spalte vom Typ ARRAY und einer weiteren Spalte vom Typ 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 | |
| ] | |
+-------+------+
Verwenden Sie die FILTER-Funktion, um die Werte der Array-Elementwerte in jeder Zeile zurückzugeben, die kleiner sind als der Wert in col2 sind:
SELECT FILTER(col1, v -> v < col2) AS filter_col_ref
FROM filter_column_ref_demo;
+----------------+
| FILTER_COL_REF |
|----------------|
| [ |
| 10, |
| 15 |
| ] |
| [ |
| 30 |
| ] |
+----------------+