ACCUMULATE¶

Syntax¶

ACCUMULATE(
    <input_expr>,
    <initialize_lambda>,
    <accumulate_lambda>,
    <combine_lambda>,
    <terminate_lambda>
)

Argumente¶

input_expr

Ausdruck wird einmal pro Nicht-NULL-Eingabezeile ausgewertet. Der resultierende Wert wird jedem Lambda als Eingabewert übergeben.

initialize_lambda

Lambda mit Signatur (value) -> <state_expr>. Wird einmal pro Nicht-NULL-Eingabezeile aufgerufen, um den anfänglichen Teilstatus aus dem Wert dieser Zeile zu erzeugen.

accumulate_lambda

Lambda mit Signatur (state, value) -> <state_expr>. Ordnet einen neuen Eingabewert in einen vorhandenen Teilstatus ein und gibt den aktualisierten Status zurück.

combine_lambda

Lambda mit Signatur (state1, state2) -> <state_expr>. Führt zwei Teilstatus zusammen, die von parallelen Workern erstellt wurden. Muss assoziativ sein.

terminate_lambda

Lambda mit Signatur (state) -> <output_expr>. Konvertiert den endgültigen zusammengeführten Status in den Ergebniswert, der an die Abfrage zurückgegeben wird.

Lambda-Argumentnamen sind beliebig. Typanmerkungen sind optional; siehe`Typ-Inferenz`_ für Details.

Rückgabewerte¶

Gibt den von terminate_lambda erzeugten Wert zurück. Der Datentyp stimmt mit dem Rückgabetyp von terminate_lambda überein. Gibt NULL zurück, wenn alle Eingabezeilen NULL sind oder das Eingabeset leer ist.

Nutzungshinweise¶

• NULL-Eingabezeilen werden stillschweigend im Einklang mit dem Standard-SQL-Aggregatverhalten übersprungen, bevor ein Lambda aufgerufen wird. Wenn alle Eingabezeilen NULL sind oder das Eingabeset leer ist, ist das Ergebnis NULL.

• ACCUMULATE hat keine persistente Form. Es gibt keine CREATE AGGREGATE FUNCTION oder eine äquivalente DDL. Um eine Aggregation wiederzuverwenden, schließen Sie sie in eine Ansicht, CTE oder gespeicherte Prozedur ein.

• Lambdas können nur auf ihre deklarierten Parameter verweisen. Referenzen auf Spalten aus der äußeren Abfrage sind nicht erlaubt. Um einen Wert für die äußere Abfrage einzufügen, projizieren Sie ihn in den Eingabeausdruck oder berechnen ihn vorab in einem CTE.

  Das folgende Beispiel verursacht einen Kompilierungsfehler, weil column2 kein Lambda-Parameter ist:

  CopyExpand

  -- ERROR: column2 is a column reference, not a lambda parameter.
  SELECT ACCUMULATE(
      column1,
      (v INT) -> v + column2,
      ...
  ) FROM t;
  

  Show lessSee more

  Scroll to top

• Die folgenden Funktionsklassen sind in Lambdas nicht erlaubt:

  Funktionsklasse	Beispiele
  Aggregatfunktionen	SUM, AVG, COUNT
  Fensterfunktionen	ROW_NUMBER() OVER (…)
  Nicht deterministische Funktionen	RANDOM(), UUID_STRING()

  See moreShow less

  Expand

Typableitung¶

Lambda-Argumenttypen sind optional. Wenn sie weggelassen werden, werden die Typen aus dem Eingabeausdruck abgeleitet und über die Lambda-Kette weitergegeben.

• Explizite Typen werden nicht über Lambdas hinweg erzwungen. Wenn Sie einen Typ in einem beliebigen Lambda-Argument mit Anmerkungen versehen, ist diese Anmerkung verbindlich für den Zustandstyp an dieser Position. Wenn Anmerkungen über die vier Lambdas hinweg inkonsistent sind und nicht abgeglichen werden können (z. B. initialize gibt ARRAY zurück, aber accumulate deklariert den Status alsINT), schlägt die Kompilierung fehl.

• Sie können alle Typanmerkungen weglassen oder nur einige Argumente kommentieren. Der Compiler leitet ab und erweitert Typen automatisch. Das Mischen von kommentierten und nicht kommentierten Argumenten ist zulässig, solange die expliziten Anmerkungen konsistent sind.

• Der Zustandstyp (der Typ, der zwischen Initialisieren, Akkumulieren und Kombinieren übergeben wird) und der Ausgabetyp (der Rückgabetyp bei Beendigung) werden unabhängig voneinander verfolgt und können sich unterscheiden.

• Der Eingabeausdruck wird implizit in den Typ umgewandelt, der von dem initialisierten Lambda value-Argument erwartet wird. Beispiel: Wenn die Eingabespalte INT lautet und value als STRING deklariert ist, wird die Umwandlung automatisch angewendet.

Beispiele¶

Berechnen Sie die Summe einer Spalte und simulieren Sie das entsprechende Verhalten der vorhandenen SUM(c1)-Aggregatfunktion:

SELECT
    ACCUMULATE(
        c1,
        (v INT)                      -> v,
        (state INT, v INT)           -> state + v,
        (state1 INT, state2 INT)     -> state1 + state2,
        (state INT)                  -> state
    ) AS total
FROM t;

Berechnen Sie das Produkt aller Werte in einer Gruppe.

SELECT
    ACCUMULATE(
        c1,
        (v INT)                      -> v,
        (state INT, v INT)           -> state * v,
        (state1 INT, state2 INT)     -> state1 * state2,
        (state INT)                  -> state
    ) AS total
FROM t;

Berechnen Sie den Mittelwert mit einem ARRAY, um die laufende Summe zu verfolgen und zu zählen:

SELECT ACCUMULATE(
    c1,
    (v INT)                        -> [v, 1],
    (state ARRAY, v INT)           -> [state[0] + v, state[1] + 1],
    (state1 ARRAY, state2 ARRAY)   -> [state1[0] + state2[0], state1[1] + state2[1]],
    (state ARRAY)                  -> state[0] / state[1]
) AS mean
FROM t;

Berechnen Sie den Mittelwert mit einem strukturierten OBJECT als Zustand:

SELECT ACCUMULATE(
    c1,
    (v INT) -> {'sum': v, 'count': 1}::OBJECT(sum INT, count INT),
    (state OBJECT(sum INT, count INT), v) ->
        {'sum': state:sum + v, 'count': state:count + 1}::OBJECT(sum INT, count INT),
    (state1, state2) ->
        {'sum': state1:sum + state2:sum, 'count': state1:count + state2:count}::OBJECT(sum INT, count INT),
    (state) -> state:sum / state:count
) AS mean
FROM t;

Suchen Sie die kürzeste Zeichenfolge in einer Spalte:

SELECT ACCUMULATE(
    c1,
    (v STRING) -> v,
    (state STRING, v STRING) ->
        CASE WHEN LENGTH(v) < LENGTH(state) THEN v ELSE state END,
    (state1 STRING, state2 STRING) ->
        CASE WHEN LENGTH(state1) <= LENGTH(state2) THEN state1 ELSE state2 END,
    (state STRING) -> state
) AS shortest
FROM t;

Verwenden Sie ACCUMULATE mit GROUP BY:

SELECT
    category,
    ACCUMULATE(
        amount,
        (v INT)                      -> v,
        (state INT, v INT)           -> state + v,
        (state1 INT, state2 INT)     -> state1 + state2,
        (state INT)                  -> state
    ) AS category_total
FROM orders
GROUP BY category;

Rufen Sie eine UDF innerhalb eines Lambda auf:

SELECT ACCUMULATE(
    c1,
    (v NUMBER)       -> v,
    (state, v)       -> my_sum_udf(state, v),
    (state1, state2) -> my_sum_udf(state1, state2),
    (state)          -> state
) AS total
FROM t;