Mit der Pipe-Abfragesyntax arbeiten

Die Pipe-Abfragesyntax ist eine Erweiterung von GoogleSQL, die eine lineare Abfragestruktur unterstützt. Dadurch sollen Ihre Abfragen leichter zu lesen, zu schreiben und zu verwalten sein. Sie können die Pipe-Syntax überall dort verwenden, wo Sie GoogleSQL schreiben.

Die Pipe-Syntax unterstützt dieselben Vorgänge wie die vorhandene GoogleSQL-Abfragesyntax oder die Standardsyntax, z. B. Auswahl, Aggregation und Gruppierung, Zusammenführung und Filterung. Die Vorgänge können jedoch in beliebiger Reihenfolge und beliebig oft angewendet werden. Dank der linearen Struktur der Pipe-Syntax können Sie Abfragen so schreiben, dass die Reihenfolge der Abfragesyntax der Reihenfolge der logischen Schritte entspricht, die zum Erstellen der Ergebnistabelle ausgeführt werden.

Abfragen, die die Pipe-Syntax verwenden, werden auf dieselbe Weise bepreist, ausgeführt und optimiert wie die entsprechenden Abfragen mit Standardsyntax. Wenn Sie Abfragen mit Pipe-Syntax schreiben, beachten Sie die Richtlinien zum Schätzen von Kosten und zum Optimieren der Abfrageberechnung.

Die Standardsyntax hat Probleme, die das Lesen, Schreiben und Verwalten erschweren können. In der folgenden Tabelle sehen Sie, wie diese Probleme mit der Pipe-Syntax behoben werden:

Standard syntax Pipe-Syntax
Klauseln müssen in einer bestimmten Reihenfolge angegeben werden. Pipe-Operatoren können in beliebiger Reihenfolge angewendet werden.
Komplexere Abfragen, z. B. Abfragen mit mehrstufiger Aggregation, erfordern in der Regel CTEs oder verschachtelte Unterabfragen. Komplexere Abfragen werden in der Regel durch Hinzufügen von Pipe-Operatoren am Ende der Abfrage ausgedrückt.
Während der Aggregation werden Spalten in den Klauseln SELECT, GROUP BY und ORDER BY wiederholt. Spalten können nur einmal pro Aggregation aufgeführt werden.

Informationen zum schrittweisen Erstellen einer komplexen Abfrage in der Pipe-Syntax finden Sie unter Daten mit der Pipe-Syntax analysieren. Ausführliche Informationen zur Syntax finden Sie in der Referenzdokumentation zur Pipe-Abfragesyntax.

Grundlegende Syntax

In der Pipe-Syntax beginnen Abfragen mit einer Standard-SQL-Abfrage oder einer FROM-Klausel. Eine eigenständige FROM-Klausel wie FROM MyTable ist beispielsweise eine gültige Pipe-Syntax. Das Ergebnis der Standard-SQL-Abfrage oder die Tabelle aus der FROM-Klausel kann dann als Eingabe an ein Pipe-Symbol (|>) übergeben werden, gefolgt von einem Pipe-Operatornamen und allen Argumenten für diesen Operator. Der Pipe-Operator transformiert die Tabelle auf irgendeine Weise und das Ergebnis dieser Transformation kann an einen anderen Pipe-Operator übergeben werden.

Sie können in Ihrer Abfrage beliebig viele Pipe-Operatoren verwenden, um beispielsweise Spalten auszuwählen, zu sortieren, zu filtern, zusammenzuführen oder zu aggregieren. Die Namen der Pipe-Operatoren entsprechen ihren Standard-Syntax-Entsprechungen und haben im Allgemeinen dasselbe Verhalten. Der Hauptunterschied zwischen der Standardsyntax und der Pipe-Syntax besteht in der Strukturierung der Abfrage. Wenn die Logik Ihrer Abfrage komplexer wird, kann die Abfrage weiterhin als lineare Abfolge von Pipe-Operatoren ausgedrückt werden, ohne dass tief verschachtelte Unterabfragen verwendet werden müssen. Dadurch ist sie leichter zu lesen und zu verstehen.

Die Pipe-Syntax hat die folgenden Hauptmerkmale:

  • Jeder Pipe-Operator in der Pipe-Syntax besteht aus dem Pipe-Symbol |>, einem Operatornamen und beliebigen Argumenten:
    |> operator_name argument_list
  • Pipe-Operatoren können am Ende jeder gültigen Abfrage hinzugefügt werden.
  • Pipe-Operatoren können in beliebiger Reihenfolge und beliebig oft angewendet werden.
  • Die Pipe-Syntax funktioniert überall, wo die Standardsyntax unterstützt wird: in Abfragen, Ansichten, Tabellenwertfunktionen und anderen Kontexten.
  • Die Pipe-Syntax kann in derselben Abfrage mit der Standardsyntax kombiniert werden. Unterabfragen können beispielsweise eine andere Syntax als die übergeordnete Abfrage verwenden.
  • Ein Pipe-Operator kann jeden Alias sehen, der in der Tabelle vor der Pipe vorhanden ist.
  • Eine Abfrage kann mit einer FROM-Klausel beginnen und Pipe-Operatoren können optional nach der FROM-Klausel hinzugefügt werden.

Betrachten Sie die folgende Tabelle:

CREATE OR REPLACE TABLE mydataset.Produce AS (
  SELECT 'apples' AS item, 2 AS sales, 'fruit' AS category
  UNION ALL
  SELECT 'apples' AS item, 7 AS sales, 'fruit' AS category
  UNION ALL
  SELECT 'carrots' AS item, 0 AS sales, 'vegetable' AS category
  UNION ALL
  SELECT 'bananas' AS item, 15 AS sales, 'fruit' AS category);

Die folgenden Abfragen enthalten jeweils eine gültige Pipe-Syntax, die zeigt, wie Sie eine Abfrage sequenziell erstellen können.

Abfragen können mit einer FROM-Klausel beginnen und müssen kein Pipe-Symbol enthalten:

-- View the table.
FROM mydataset.Produce;

/*---------+-------+-----------+
 | item    | sales | category  |
 +---------+-------+-----------+
 | apples  | 7     | fruit     |
 | apples  | 2     | fruit     |
 | carrots | 0     | vegetable |
 | bananas | 15    | fruit     |
 +---------+-------+-----------*/

Sie können mit einem WHERE-Pipe-Operator filtern:

-- Filter items with no sales.
FROM mydataset.Produce
|> WHERE sales > 0;

/*---------+-------+-----------+
 | item    | sales | category  |
 +---------+-------+-----------+
 | apples  | 7     | fruit     |
 | apples  | 2     | fruit     |
 | bananas | 15    | fruit     |
 +---------+-------+-----------*/

Wenn Sie eine Aggregation durchführen möchten, verwenden Sie den Pipe-Operator AGGREGATE, gefolgt von einer beliebigen Anzahl von Aggregatfunktionen und einer GROUP BY-Klausel. Die GROUP BY-Klausel ist Teil des Pipe-Operators AGGREGATE und wird nicht durch ein Pipe-Symbol (|>) getrennt.

-- Compute total sales by item.
FROM mydataset.Produce
|> WHERE sales > 0
|> AGGREGATE SUM(sales) AS total_sales, COUNT(*) AS num_sales
   GROUP BY item;

/*---------+-------------+-----------+
 | item    | total_sales | num_sales |
 +---------+-------------+-----------+
 | apples  | 9           | 2         |
 | bananas | 15          | 1         |
 +---------+-------------+-----------*/

Angenommen, Sie haben die folgende Tabelle, die eine ID für jeden Artikel enthält:

CREATE OR REPLACE TABLE mydataset.ItemData AS (
  SELECT 'apples' AS item, '123' AS id
  UNION ALL
  SELECT 'bananas' AS item, '456' AS id
  UNION ALL
  SELECT 'carrots' AS item, '789' AS id
);

Sie können den Pipe-Operator JOIN verwenden, um die Ergebnisse der vorherigen Abfrage mit dieser Tabelle zu verknüpfen und die ID jedes Elements einzuschließen:

FROM mydataset.Produce
|> WHERE sales > 0
|> AGGREGATE SUM(sales) AS total_sales, COUNT(*) AS num_sales
   GROUP BY item
|> JOIN mydataset.ItemData USING(item);

/*---------+-------------+-----------+-----+
 | item    | total_sales | num_sales | id  |
 +---------+-------------+-----------+-----+
 | apples  | 9           | 2         | 123 |
 | bananas | 15          | 1         | 456 |
 +---------+-------------+-----------+-----*/

Wichtige Unterschiede zur Standardsyntax

Die Pipe-Syntax unterscheidet sich in folgenden Punkten von der Standardsyntax:

  • Abfragen können mit einer FROM-Klausel beginnen.
  • Der Pipe-Operator SELECT führt keine Aggregation durch. Sie müssen stattdessen den Pipe-Operator AGGREGATE verwenden.
  • Die Filterung erfolgt immer mit dem Pipe-Operator WHERE, der überall angewendet werden kann. Der Pipe-Operator WHERE, der HAVING und QUALIFY ersetzt, kann die Ergebnisse von Aggregations- oder Fensterfunktionen filtern.

Weitere Informationen finden Sie in der vollständigen Liste der Pipe-Operatoren.

Anwendungsfälle

Zu den häufigsten Anwendungsfällen für die Pipe-Syntax gehören:

  • Ad-hoc-Analyse und inkrementelle Abfrageerstellung: Die logische Reihenfolge der Vorgänge erleichtert das Schreiben und Debuggen von Abfragen. Das Präfix einer beliebigen Abfrage bis zu einem Pipe-Symbol |> ist eine gültige Abfrage, mit der Sie Zwischenergebnisse in einer langen Abfrage aufrufen können. Die Produktivitätssteigerungen können den Entwicklungsprozess in Ihrem gesamten Unternehmen beschleunigen.
  • Loganalyse: Es gibt andere Arten von Pipe-ähnlicher Syntax, die bei Nutzern von Loganalysen beliebt sind. Die Pipe-Syntax bietet eine vertraute Struktur, die diesen Nutzern den Einstieg in Observability Analytics und BigQuery erleichtert.

Zusätzliche Funktionen in der Pipe-Syntax

Mit wenigen Ausnahmen unterstützt die Pipe-Syntax alle Operatoren, die die Standardsyntax mit derselben Syntax unterstützt. Darüber hinaus werden mit der Pipe-Syntax zusätzliche Pipe-Operatoren eingeführt und eine modifizierte Syntax für Aggregationen und Joins verwendet. In den folgenden Abschnitten werden einige dieser Operatoren erläutert. Eine vollständige Liste aller unterstützten Pipe-Operatoren finden Sie in der Liste der Pipe-Operatoren.

EXTEND-Pipe-Operator

Mit dem EXTEND-Pipe-Operator können Sie der aktuellen Tabelle berechnete Spalten hinzufügen. Der Pipe-Operator EXTEND ähnelt der Anweisung SELECT *, new_column, bietet aber mehr Flexibilität beim Verweisen auf Spalten-Aliasse.

Sehen Sie sich die folgende Tabelle an, die zwei Testergebnisse für jede Person enthält:

CREATE OR REPLACE TABLE mydataset.Scores AS (
  SELECT 'Alex' AS student, 9 AS score1, 10 AS score2, 10 AS points_possible
  UNION ALL
  SELECT 'Dana' AS student, 5 AS score1, 7 AS score2, 10 AS points_possible);

/*---------+--------+--------+-----------------+
 | student | score1 | score2 | points_possible |
 +---------+--------+--------+-----------------+
 | Alex    | 9      | 10     | 10              |
 | Dana    | 5      | 7      | 10              |
 +---------+--------+--------+-----------------*/

Angenommen, Sie möchten die durchschnittliche Rohpunktzahl und die durchschnittliche prozentuale Punktzahl berechnen, die jeder Schüler oder Student im Test erreicht hat. In der Standardsyntax haben spätere Spalten in einer SELECT-Anweisung keinen Zugriff auf frühere Aliasse. Um eine Unterabfrage zu vermeiden, müssen Sie den Ausdruck für den Durchschnitt wiederholen:

SELECT student,
  (score1 + score2) / 2 AS average_score,
  (score1 + score2) / 2 / points_possible AS average_percent
FROM mydataset.Scores;

Der Pipe-Operator EXTEND kann auf zuvor verwendete Aliase verweisen, was die Abfrage leichter lesbar und weniger fehleranfällig macht:

FROM mydataset.Scores
|> EXTEND (score1 + score2) / 2 AS average_score
|> EXTEND average_score / points_possible AS average_percent
|> SELECT student, average_score, average_percent;

/*---------+---------------+-----------------+
 | student | average_score | average_percent |
 +---------+---------------+-----------------+
 | Alex    | 9.5           | .95             |
 | Dana    | 6.0           | 0.6             |
 +---------+---------------+-----------------*/

SET-Pipe-Operator

Mit dem Pipe-Operator SET können Sie den Wert von Spalten in der aktuellen Tabelle ersetzen. Der Pipe-Operator SET ähnelt der Anweisung SELECT * REPLACE (expression AS column). Sie können auf den ursprünglichen Wert verweisen, indem Sie den Spaltennamen mit einem Tabellenalias qualifizieren.

FROM (SELECT 3 AS x, 5 AS y)
|> SET x = 2 * x;

/*---+---+
 | x | y |
 +---+---+
 | 6 | 5 |
 +---+---*/

DROP-Pipe-Operator

Mit dem Pipe-Operator DROP können Sie Spalten aus der aktuellen Tabelle entfernen. Der Pipe-Operator DROP ähnelt der Anweisung SELECT * EXCEPT(column). Nachdem eine Spalte gelöscht wurde, können Sie weiterhin auf den ursprünglichen Wert verweisen, indem Sie den Spaltennamen mit einem Tabellenalias qualifizieren.

FROM (SELECT 1 AS x, 2 AS y) AS t
|> DROP x;

/*---+
 | y |
 +---+
 | 2 |
 +---*/

RENAME-Pipe-Operator

Mit dem Pipe-Operator RENAME können Sie Spalten aus der aktuellen Tabelle umbenennen. Der Pipe-Operator RENAME ähnelt der Anweisung SELECT * EXCEPT(old_column), old_column AS new_column.

FROM (SELECT 1 AS x, 2 AS y, 3 AS z) AS t
|> RENAME y AS w;

/*---+---+---+
 | x | w | z |
 +---+---+---+
 | 1 | 2 | 3 |
 +---+---+---*/

AGGREGATE-Pipe-Operator

Wenn Sie eine Aggregation in der Pipe-Syntax ausführen möchten, verwenden Sie den Pipe-Operator AGGREGATE, gefolgt von einer beliebigen Anzahl von Aggregatfunktionen und einer GROUP BY-Klausel. Sie müssen Spalten in einer SELECT-Klausel nicht wiederholen.

In den Beispielen in diesem Abschnitt wird die Tabelle Produce verwendet:

CREATE OR REPLACE TABLE mydataset.Produce AS (
  SELECT 'apples' AS item, 2 AS sales, 'fruit' AS category
  UNION ALL
  SELECT 'apples' AS item, 7 AS sales, 'fruit' AS category
  UNION ALL
  SELECT 'carrots' AS item, 0 AS sales, 'vegetable' AS category
  UNION ALL
  SELECT 'bananas' AS item, 15 AS sales, 'fruit' AS category);

/*---------+-------+-----------+
 | item    | sales | category  |
 +---------+-------+-----------+
 | apples  | 7     | fruit     |
 | apples  | 2     | fruit     |
 | carrots | 0     | vegetable |
 | bananas | 15    | fruit     |
 +---------+-------+-----------*/

FROM mydataset.Produce
|> AGGREGATE SUM(sales) AS total, COUNT(*) AS num_records
   GROUP BY item, category;

/*---------+-----------+-------+-------------+
 | item    | category  | total | num_records |
 +---------+-----------+-------+-------------+
 | apples  | fruit     | 9     | 2           |
 | carrots | vegetable | 0     | 1           |
 | bananas | fruit     | 15    | 1           |
 +---------+-----------+-------+-------------*/

Wenn Sie die Ergebnisse unmittelbar nach der Aggregation sortieren möchten, können Sie die Spalten in der GROUP BY-Klausel, die Sie sortieren möchten, mit ASC oder DESC markieren. Nicht markierte Spalten sind nicht sortiert.

Wenn Sie alle Spalten sortieren möchten, können Sie die GROUP BY-Klausel durch eine GROUP AND ORDER BY-Klausel ersetzen, die jede Spalte standardmäßig in aufsteigender Reihenfolge sortiert. Sie können DESC nach den Spalten angeben, die Sie in absteigender Reihenfolge sortieren möchten. Die folgenden drei Abfragen entsprechen beispielsweise einander:

-- Use a separate ORDER BY clause.
FROM mydataset.Produce
|> AGGREGATE SUM(sales) AS total, COUNT(*) AS num_records
   GROUP BY category, item
|> ORDER BY category DESC, item;

-- Explicitly mark how to order columns in the GROUP BY clause.
FROM mydataset.Produce
|> AGGREGATE SUM(sales) AS total, COUNT(*) AS num_records
   GROUP BY category DESC, item ASC;

-- Only mark descending columns in the GROUP AND ORDER BY clause.
FROM mydataset.Produce
|> AGGREGATE SUM(sales) AS total, COUNT(*) AS num_records
   GROUP AND ORDER BY category DESC, item;

Der Vorteil einer GROUP AND ORDER BY-Klausel besteht darin, dass Sie Spaltennamen nicht an zwei Stellen wiederholen müssen.

Wenn Sie eine vollständige Tabellenaggregation durchführen möchten, verwenden Sie GROUP BY() oder lassen Sie die GROUP BY-Klausel ganz weg:

FROM mydataset.Produce
|> AGGREGATE SUM(sales) AS total, COUNT(*) AS num_records;

/*-------+-------------+
 | total | num_records |
 +-------+-------------+
 | 24    | 4           |
 +-------+-------------*/

JOIN-Pipe-Operator

Mit dem Pipe-Operator JOIN können Sie die aktuelle Tabelle mit einer anderen Tabelle verknüpfen. Er unterstützt die standardmäßigen Join-Vorgänge, einschließlich CROSS, INNER, LEFT, RIGHT und FULL.

In den folgenden Beispielen wird auf die Tabellen Produce und ItemData verwiesen:

CREATE OR REPLACE TABLE mydataset.Produce AS (
  SELECT 'apples' AS item, 2 AS sales, 'fruit' AS category
  UNION ALL
  SELECT 'apples' AS item, 7 AS sales, 'fruit' AS category
  UNION ALL
  SELECT 'carrots' AS item, 0 AS sales, 'vegetable' AS category
  UNION ALL
  SELECT 'bananas' AS item, 15 AS sales, 'fruit' AS category);

CREATE OR REPLACE TABLE mydataset.ItemData AS (
  SELECT 'apples' AS item, '123' AS id
  UNION ALL
  SELECT 'bananas' AS item, '456' AS id
  UNION ALL
  SELECT 'carrots' AS item, '789' AS id
);

Im folgenden Beispiel wird eine USING-Klausel verwendet und die Mehrdeutigkeit von Spalten vermieden:

FROM mydataset.Produce
|> JOIN mydataset.ItemData USING(item)
|> WHERE item = 'apples';

/*--------+-------+----------+-----+
 | item   | sales | category | id  |
 +--------+-------+----------+-----+
 | apples | 2     | fruit    | 123 |
 | apples | 7     | fruit    | 123 |
 +--------+-------+----------+-----*/

Wenn Sie auf Spalten in der aktuellen Tabelle verweisen möchten, z. B. um Spalten in einer ON-Klausel eindeutig zu machen, müssen Sie der aktuellen Tabelle mit dem Pipe-Operator AS einen Alias zuweisen. Optional können Sie einen Alias für die verknüpfte Tabelle angeben. Sie können auf beide Aliase nach nachfolgenden Pipe-Operatoren verweisen:

FROM mydataset.Produce
|> AS produce_table
|> JOIN mydataset.ItemData AS item_table
   ON produce_table.item = item_table.item
|> WHERE produce_table.item = 'bananas'
|> SELECT item_table.item, sales, id;

/*---------+-------+-----+
 | item    | sales | id  |
 +---------+-------+-----+
 | bananas | 15    | 123 |
 +---------+-------+-----*/

Die rechte Seite des Joins hat keine Sichtbarkeit für die linke Seite des Joins. Das bedeutet, dass Sie die aktuelle Tabelle nicht mit sich selbst verknüpfen können. Die folgende Abfrage schlägt beispielsweise fehl:

-- This query doesn't work.
FROM mydataset.Produce
|> AS produce_table
|> JOIN produce_table AS produce_table_2 USING(item);

Wenn Sie einen Self-Join mit einer geänderten Tabelle ausführen möchten, können Sie einen allgemeinen Tabellenausdruck (Common Table Expression, CTE) in einer WITH-Klausel verwenden.

WITH cte_table AS (
  FROM mydataset.Produce
  |> WHERE item = 'carrots'
)
FROM cte_table
|> JOIN cte_table AS cte_table_2 USING(item);

Beispiel

Sehen Sie sich die folgende Tabelle mit Informationen zu Kundenbestellungen an:

CREATE OR REPLACE TABLE mydataset.CustomerOrders AS (
  SELECT 1 AS customer_id, 100 AS order_id, 'WA' AS state, 5 AS cost, 'clothing' AS item_type
  UNION ALL
  SELECT 1 AS customer_id, 101 AS order_id, 'WA' AS state, 20 AS cost, 'clothing' AS item_type
  UNION ALL
  SELECT 1 AS customer_id, 102 AS order_id, 'WA' AS state, 3 AS cost, 'food' AS item_type
  UNION ALL
  SELECT 2 AS customer_id, 103 AS order_id, 'NY' AS state, 16 AS cost, 'clothing' AS item_type
  UNION ALL
  SELECT 2 AS customer_id, 104 AS order_id, 'NY' AS state, 22 AS cost, 'housewares' AS item_type
  UNION ALL
  SELECT 2 AS customer_id, 104 AS order_id, 'WA' AS state, 45 AS cost, 'clothing' AS item_type
  UNION ALL
  SELECT 3 AS customer_id, 105 AS order_id, 'MI' AS state, 29 AS cost, 'clothing' AS item_type);

Angenommen, Sie möchten für jeden Bundesstaat und Artikeltyp den durchschnittlichen Betrag ermitteln, den Bestandskunden ausgeben. Sie könnten die Abfrage so schreiben:

SELECT state, item_type, AVG(total_cost) AS average
FROM
  (
    SELECT
      SUM(cost) AS total_cost,
      customer_id,
      state,
      item_type,
      COUNT(*) OVER (PARTITION BY customer_id) AS num_orders
    FROM mydataset.CustomerOrders
    GROUP BY customer_id, state, item_type
    QUALIFY num_orders > 1
  )
GROUP BY state, item_type
ORDER BY state DESC, item_type ASC;

Wenn Sie die Abfrage von oben nach unten lesen, stoßen Sie auf die Spalte total_cost, bevor sie definiert wurde. Auch in der Unterabfrage lesen Sie die Namen der Spalten, bevor Sie sehen, aus welcher Tabelle sie stammen.

Um diese Abfrage zu verstehen, müssen Sie sie von innen nach außen lesen. Die Spalten state und item_type werden in den Klauseln SELECT und GROUP BY und dann noch einmal in der Klausel ORDER BY wiederholt.

Die folgende entsprechende Abfrage wird mit der Pipe-Syntax geschrieben:

FROM mydataset.CustomerOrders
|> AGGREGATE SUM(cost) AS total_cost, GROUP BY customer_id, state, item_type
|> EXTEND COUNT(*) OVER (PARTITION BY customer_id) AS num_orders
|> WHERE num_orders > 1
|> AGGREGATE AVG(total_cost) AS average GROUP BY state DESC, item_type ASC;

/*-------+------------+---------+
 | state | item_type  | average |
 +-------+------------+---------+
 | WA    | clothing   | 35.0    |
 | WA    | food       | 3.0     |
 | NY    | clothing   | 16.0    |
 | NY    | housewares | 22.0    |
 +-------+------------+---------*/

Mit der Pipe-Syntax können Sie die Abfrage so schreiben, dass sie den logischen Schritten folgt, die Sie zur Lösung des ursprünglichen Problems durchgehen würden. Die Syntaxzeilen in der Abfrage entsprechen den folgenden logischen Schritten:

  • Beginnen Sie mit der Tabelle der Kundenbestellungen.
  • Finden Sie heraus, wie viel jeder Kunde für jeden Artikeltyp nach Bundesstaat ausgegeben hat.
  • Zählen Sie die Anzahl der Bestellungen für jeden Kunden.
  • Die Ergebnisse auf Bestandskunden beschränken.
  • Ermitteln Sie den durchschnittlichen Betrag, den Bestandskunden pro Bundesstaat und Artikeltyp ausgeben.

Beschränkungen

  • Sie können keine Differential Privacy-Klausel in eine SELECT-Anweisung nach einem Pipe-Operator einfügen. Verwenden Sie stattdessen eine Differential Privacy-Klausel in der Standardsyntax und wenden Sie Pipe-Operatoren nach der Abfrage an.

Nächste Schritte