Stern-Ausdruck

Syntax

Der Ausdruck * kann in einer SELECT-Anweisung verwendet werden, um alle Spalten auszuwählen, die in der Klausel FROM projeziert werden.

SELECT *
FROM tbl;

TABLE.* und STRUCT.*

Dem Ausdruck * kann ein Tabellenname vorangestellt werden, um nur Spalten dieser Tabelle auszuwählen.

SELECT tbl.*
FROM tbl
JOIN other_tbl USING (id);

Ebenso kann der Ausdruck * verwendet werden, um alle Schlüssel eines Structs als separate Spalten abzurufen. Das ist besonders nützlich, wenn eine vorherige Operation einen Struct unbekannter Form erzeugt oder eine Abfrage beliebige mögliche Struct-Schlüssel verarbeiten muss. Details zur Arbeit mit Structs finden Sie auf den Seiten zum Datentyp STRUCT und zu den STRUCT-Funktionen.

Zum Beispiel:

SELECT st.* FROM (SELECT {'x': 1, 'y': 2, 'z': 3} AS st);

x	y	z
1	2	3

Klausel EXCLUDE

EXCLUDE erlaubt es, bestimmte Spalten aus dem Ausdruck * auszuschließen.

SELECT * EXCLUDE (col)
FROM tbl;

Klausel REPLACE

REPLACE erlaubt es, bestimmte Spalten durch alternative Ausdrücke zu ersetzen.

SELECT * REPLACE (col1 / 1_000 AS col1, col2 / 1_000 AS col2)
FROM tbl;

Klausel RENAME

RENAME erlaubt es, bestimmte Spalten umzubenennen.

SELECT * RENAME (col1 AS height, col2 AS width)
FROM tbl;

Spaltenfilterung über Mustervergleichsoperatoren

Die Mustervergleichsoperatoren LIKE, GLOB, SIMILAR TO und ihre Varianten erlauben es, Spalten anhand der Übereinstimmung ihrer Namen mit Mustern auszuwählen.

SELECT * LIKE 'col%'
FROM tbl;

SELECT * GLOB 'col*'
FROM tbl;

SELECT * SIMILAR TO 'col.'
FROM tbl;

Die NOT-Varianten dieser Operatoren werden ebenfalls unterstützt, um Spalten auszuschließen, die dem Muster entsprechen:

SELECT * NOT SIMILAR TO 'col.'
FROM tbl;

COLUMNS-Ausdruck

Der Ausdruck COLUMNS ähnelt dem gewöhnlichen Stern-Ausdruck, erlaubt es aber zusätzlich, denselben Ausdruck auf den resultierenden Spalten auszuführen.

CREATE TABLE numbers (id INTEGER, number INTEGER);
INSERT INTO numbers VALUES (1, 10), (2, 20), (3, NULL);
SELECT min(COLUMNS(*)), count(COLUMNS(*)) FROM numbers;

id	number	id	number
1	10	3	2

SELECT
    min(COLUMNS(* REPLACE (number + id AS number))),
    count(COLUMNS(* EXCLUDE (number)))
FROM numbers;

id	min(number := (number + id))	id
1	11	3

COLUMNS-Ausdrücke können auch kombiniert werden, solange sie denselben Stern-Ausdruck enthalten:

SELECT COLUMNS(*) + COLUMNS(*) FROM numbers;

id	number
2	20
4	40
6	NULL

COLUMNS-Ausdruck in einer WHERE-Klausel

COLUMNS-Ausdrücke können auch in WHERE-Klauseln verwendet werden. Die Bedingungen werden auf alle Spalten angewendet und mit dem logischen Operator AND kombiniert.

SELECT *
FROM (
    SELECT 'a', 'a'
    UNION ALL
    SELECT 'a', 'b'
    UNION ALL
    SELECT 'b', 'b'
) _(x, y)
WHERE COLUMNS(*) = 'a'; -- equivalent to: x = 'a' AND y = 'a'

x	y
a	a

Um Bedingungen mit dem logischen Operator OR zu kombinieren, können Sie den COLUMNS-Ausdruck mit UNPACK in die variadische Funktion greatest entpacken.

SELECT *
FROM (
    SELECT 'a', 'a'
    UNION ALL
    SELECT 'a', 'b'
    UNION ALL
    SELECT 'b', 'b'
) _(x, y)
WHERE greatest(UNPACK(COLUMNS(*) = 'a')); -- equivalent to: x = 'a' OR y = 'a'

x	y
a	a
a	b

COLUMNS-Ausdruck in DISTINCT ON

COLUMNS-Ausdrücke können in Klauseln DISTINCT ON verwendet werden, um Distinct-Spalten per Muster anzugeben:

SELECT DISTINCT ON (COLUMNS('x|y')) *
FROM (VALUES (1, 2, 'a'), (1, 2, 'b'), (3, 4, 'c')) t(x, y, z);

x	y	z
1	2	a
3	4	c

Reguläre Ausdrücke in einem COLUMNS-Ausdruck

COLUMNS-Ausdrücke unterstützen derzeit die Mustervergleichsoperatoren nicht, aber sie unterstützen den Abgleich mit regulären Ausdrücken, indem statt des Sterns einfach eine Zeichenkettenkonstante übergeben wird:

SELECT COLUMNS('(id|numbers?)') FROM numbers;

id	number
1	10
2	20
3	NULL

Spalten mit regulären Ausdrücken in einem COLUMNS-Ausdruck umbenennen

Die Treffer von Capture-Gruppen in regulären Ausdrücken können verwendet werden, um passende Spalten umzubenennen. Die Capture-Gruppen sind 1-indiziert; \0 ist der ursprüngliche Spaltenname.

Um beispielsweise die ersten drei Buchstaben von Spaltennamen auszuwählen, führen Sie aus:

SELECT COLUMNS('(\w{3}).*') AS '\1' FROM numbers;

id	num
1	10
2	20
3	NULL

Um ein Doppelpunktzeichen (:) in der Mitte eines Spaltennamens zu entfernen, führen Sie aus:

CREATE TABLE tbl ("Foo:Bar" INTEGER, "Foo:Baz" INTEGER, "Foo:Qux" INTEGER);
SELECT COLUMNS('(\w*):(\w*)') AS '\1\2' FROM tbl;

Um den ursprünglichen Spaltennamen zum Ausdrucksalias hinzuzufügen, führen Sie aus:

SELECT min(COLUMNS(*)) AS "min_\0" FROM numbers;

min_id	min_number
1	10

COLUMNS-Lambda-Funktion

COLUMNS unterstützt auch die Übergabe einer Lambda-Funktion. Die Lambda-Funktion wird für alle in der Klausel FROM vorhandenen Spalten ausgewertet. Nur Spalten, für die die Lambda-Funktion zu TRUE auswertet, bleiben erhalten, die übrigen werden verworfen.

Lambdas in der COLUMNS-Klausel haben einen Pflichtparameter, der den Spaltennamen erhält. Optional kann ein zweiter Parameter deklariert werden, der den (1-basierten) Index der Spalte erhält. Lambdas in der COLUMNS-Klausel erlauben die Ausführung beliebiger Ausdrücke, um Spalten auszuwählen und umzubenennen.

SELECT COLUMNS(lambda c: c LIKE '%num%') FROM numbers;

number
10
20
NULL

COLUMNS-Liste

COLUMNS unterstützt auch die Übergabe einer Liste von Spaltennamen.

SELECT COLUMNS(['id', 'num']) FROM numbers;

id	num
1	10
2	20
3	NULL

Entpacken eines COLUMNS-Ausdrucks

Indem Sie einen COLUMNS-Ausdruck in UNPACK wrappen, werden die Spalten in einen übergeordneten Ausdruck expandiert, ähnlich dem Entpacken von Iterables in Python.

Ohne UNPACK werden Operationen auf dem COLUMNS-Ausdruck auf jede Spalte einzeln angewendet:

SELECT coalesce(COLUMNS(['a', 'b', 'c'])) AS result
FROM (SELECT NULL a, 42 b, true c);

result	result	result
NULL	42	true

Mit UNPACK wird der COLUMNS-Ausdruck in seinen übergeordneten Ausdruck expandiert, im Beispiel oben coalesce, was zu einer einzelnen Spalte führt:

SELECT coalesce(UNPACK(COLUMNS(['a', 'b', 'c']))) AS result
FROM (SELECT NULL AS a, 42 AS b, true AS c);

result
42

Das Schlüsselwort UNPACK kann durch * ersetzt werden, entsprechend der Python-Syntax, wenn es direkt auf den COLUMNS-Ausdruck ohne dazwischenliegende Operationen angewendet wird.

SELECT coalesce(*COLUMNS(*)) AS result
FROM (SELECT NULL a, 42 AS b, true AS c);

result
42

Warnung Im folgenden Beispiel führt das Ersetzen von UNPACK durch * zu einem Syntaxfehler:

SELECT greatest(UNPACK(COLUMNS(*) + 1)) AS result
FROM (SELECT 1 AS a, 2 AS b, 3 AS c);

result
4

STRUCT.*

Der Ausdruck * kann auch verwendet werden, um alle Schlüssel eines Structs als separate Spalten abzurufen. Das ist besonders nützlich, wenn eine vorherige Operation einen Struct unbekannter Form erzeugt oder eine Abfrage beliebige mögliche Struct-Schlüssel verarbeiten muss. Details zur Arbeit mit Structs finden Sie auf den Seiten zum Datentyp STRUCT und zu den STRUCT-Funktionen.

Zum Beispiel:

SELECT st.* FROM (SELECT {'x': 1, 'y': 2, 'z': 3} AS st);

x	y	z
1	2	3