Leistung von Abfragen mit KI-Funktionen steigern

Mit dem Smart Batching für KI-Funktionen können Sie die Leistung optimieren, wenn Sie Abfragen ausführen, die KI-Funktionen in AlloyDB for PostgreSQL verwenden. Sie bietet die gleiche oder eine bessere Leistung als Array-basierte Funktionen, ohne dass Sie Abfragen in komplexe Array-Strukturen umschreiben müssen. Weitere Informationen zu KI-Funktionen finden Sie unter KI-Funktionen – Übersicht.

In Standard-PostgreSQL führt die zeilenweise Auswertung einer KI-Funktion zu Netzwerklatenz für jede einzelne Zeile. Mit Smart Batching in AlloyDB werden geeignete KI-Vorgänge automatisch in Batches zusammengefasst und für die asynchrone Auswertung ausgelagert. So können Sie standardmäßige, leicht lesbare SQL-Abfragen schreiben. Standardmäßige relationale Filter werden vor KI-Funktionen ausgewertet, um eine optimale Leistung und Modellnutzung zu gewährleisten.

Unterstützte KI-Funktionen

Das Smart Batching von AlloyDB unterstützt die folgenden KI-Funktionen, die sowohl im Schema ai als auch im Schema google_ml verfügbar sind:

Funktion Beschreibung Version der Erweiterung
ai.if(prompt text, ...)/google_ml.if(...) Wertet einen booleschen Prompt in natürlicher Sprache aus und gibt true oder false zurück. Unterstützt in SELECT-Projektionen, WHERE-Filtern und JOIN-Klauseln. Alle
ai.rank(prompt text, ...)/google_ml.rank(...) Berechnet einen numerischen Relevanzwert (float), der angibt, wie gut eine Eingabe mit bestimmten Kriterien übereinstimmt. Wird in WHERE-Filtern, ORDER BY-, SELECT- und JOIN-Klauseln unterstützt. Alle
ai.generate(prompt text, ...)/google_ml.generate(...) Generiert Antworten in natürlicher Sprache oder strukturierten Text mithilfe von Foundation Models. Unterstützt in SELECT-Projektionen, WHERE-Filtern und JOIN-Klauseln. Alle
ai.analyze_sentiment(input text, ...)/google_ml.analyze_sentiment(...) Analysiert das Sentiment des Eingabetexts und gibt 'positive', 'negative' oder 'neutral' zurück. Unterstützt in SELECT-Projektionen, WHERE-Filtern und JOIN-Klauseln. 1.6.3
ai.summarize(input text, ...)/google_ml.summarize(...) Fasst den Eingabetext zusammen. Unterstützt in SELECT-Projektionen, WHERE-Filtern und JOIN-Klauseln. 1.6.4
ai.extract(input text, output_schema text, ...) / google_ml.extract(...)

(in der Vorabversion; erfordert die Einstellung google_ml_integration.enable_preview_ai_functions=on)
Extrahiert strukturierte Entitäten oder Schlüssel/Wert-Attribute aus Text. Unterstützt in SELECT-Projektionen, WHERE-Filtern und JOIN-Klauseln. 1.6.1
ai.classify(input text, categories text[][], ...) / google_ml.classify(...)

(in der Vorabversion; erfordert die Einstellung google_ml_integration.enable_preview_ai_functions=on)
Klassifiziert Text in angegebene Kategorielabels. Unterstützt in SELECT-Projektionen, WHERE-Filtern und JOIN-Klauseln. 1.6.1

Weitere Informationen zur Syntax und zu den Parametern von KI-Funktionen finden Sie in der Referenz zur Verwaltung von Modellendpunkten.

Unterstützte Klauseln

Die Beschleunigung von KI-Funktionen funktioniert mit den wichtigsten SQL-Klauseln, entweder einzeln oder in Kombination:

  • WHERE-Klauseln: Filtern Zeilen mithilfe von booleschen KI-Bewertungen (ai.if) nach der Auswertung selektiver nicht-KI-bezogener relationaler Prädikate.
  • ORDER BY-Klauseln: Berechnet KI-Relevanzwerte (ai.rank) in Batches, bevor Sortier- oder Limitvorgänge ausgeführt werden.
  • SELECT-Projektionen: fasst skalare KI-Funktionen (ai.if, ai.rank, ai.generate, ai.analyze_sentiment, ai.summarize, ai.extract und ai.classify) über Ergebniszeilen hinweg zusammen.
  • JOIN ... ON-Bedingungen: Wertet tabellenübergreifende KI-Bedingungen in INNER JOIN-Vorgängen mithilfe von Smart Batching aus.
  • DML-Anweisungen: Beschleunigt KI-Funktionen in WHERE-Prädikaten, Ziellisten und SET-Ausdrücken für UPDATE-, DELETE- und INSERT ... SELECT-Vorgänge, z. B. INSERT INTO ... SELECT ai.generate(...) und UPDATE ... SET col = ai.generate(...).

Unterstützte Argumentausdrücke

Prompt-Argumente unterstützen Standard-SQL-Ausdrücke, darunter:

  • Spaltenverweise, z. B. r.review
  • Stringliterale, die mit Spaltenreferenzen verkettet sind, z. B. 'Is this a positive review? Review: ' || r.review
  • Verkettung mehrerer Spalten, z. B. r.name || ' ' || r.review
  • Skalare SQL-Ausdrücke und -Funktionen wie COALESCE(r.review, '')-, LOWER(r.comments)-, SUBSTRING(description FROM 1 FOR 500)- und CASE-Anweisungen

Hinweis

Wenn Sie Smart Batching für KI-Funktionen in AlloyDB verwenden möchten, müssen die folgenden Voraussetzungen erfüllt sein:

  1. PostgreSQL-Version: Verwenden Sie PostgreSQL-Version 17 oder höher.
  2. In die Gemini Enterprise Agent Platform einbinden: Führen Sie die Schritte unter In die Gemini Enterprise Agent Platform einbinden aus.
  3. Regionale Verfügbarkeit: Smart Batching ist in Regionen verfügbar, die das Standardmodell (gemini-3.5-flash-lite) oder das mit google_ml_integration.default_llm_model konfigurierte Modell unterstützen. Weitere Informationen finden Sie unter Unterstützte Regionen.

Intelligentes Batching für KI-Funktionen aktivieren

In PostgreSQL 18 oder höher ist Smart Batching für KI-Funktionen standardmäßig aktiviert. In PostgreSQL 17 ist sie standardmäßig deaktiviert und muss explizit aktiviert werden. Sie können das Verhalten global über Datenbank-Flags auf Instanzebene oder pro Sitzung mit SQL-SET-Befehlen konfigurieren.

Konfigurationsparameter

Parametername Typ Standard Umfang Beschreibung
google_ml_integration.enable_ai_function_acceleration Boolesch PostgreSQL 18: on
PostgreSQL 17: off
Sitzung, Nutzer oder Instanz Steuert, ob der Abfrageplaner und der Executor geeignete KI-Vorgänge für das Smart Batching auslagern. Wenn der Wert auf off gesetzt ist, werden Abfragen mit der standardmäßigen zeilenweisen Ausführung von PostgreSQL ausgeführt.

Zusätzliche Einstellungen:

  • Vorabversionen von Funktionen: Wenn Sie Smart Batching für KI-Funktionen in der Vorabversion wie ai.extract und ai.classify aktivieren möchten, setzen Sie google_ml_integration.enable_preview_ai_functions auf on.
  • Modellauswahl: Wenn Sie ein anderes Modell als das Standardmodell gemini-3.5-flash-lite angeben möchten, setzen Sie google_ml_integration.default_llm_model auf die ID Ihres Zielmodells oder übergeben Sie den Parameter model_id in der KI-Funktion.

Auf Instanzebene konfigurieren

Verwenden Sie den Befehl gcloud alloydb instances update, um Datenbank-Flags auf Instanzebene in Ihrem AlloyDB-Cluster zu konfigurieren:

gcloud alloydb instances update INSTANCE_ID \
  --database-flags google_ml_integration.enable_ai_function_acceleration=on \
  --region=REGION_ID \
  --cluster=CLUSTER_ID \
  --project=PROJECT_ID

Ersetzen Sie Folgendes:

  • INSTANCE_ID: die ID der Instanz, die Sie aktualisieren möchten.
  • REGION_ID: die ID der Region, in der sich der Cluster befindet. Weitere Informationen finden Sie unter Unterstützte Regionen.
  • CLUSTER_ID: die ID des Clusters.
  • PROJECT_ID: die ID des Projekts.

Weitere Informationen finden Sie unter Datenbank-Flags konfigurieren.

Auf Sitzungsebene konfigurieren

Verwenden Sie den Befehl SET, um die Parameter für die intelligente Batchverarbeitung für Ihre Sitzung anzupassen oder zu aktivieren bzw. zu deaktivieren:

-- Disable smart batching for the current session (runs standard row-by-row execution)
SET google_ml_integration.enable_ai_function_acceleration = off;

-- Re-enable smart batching
SET google_ml_integration.enable_ai_function_acceleration = on;

-- Enable preview functions (ai.extract, ai.classify)
SET google_ml_integration.enable_preview_ai_functions = on;

Smart Batching für KI-Funktionen überprüfen

Mit der Anweisung EXPLAIN können Sie Ihre Abfrage analysieren und prüfen, ob Smart Batching für KI-Funktionen aktiviert ist.

Wenn Smart Batching aktiviert ist, enthält der Ausführungsplan einen Custom Scan (AIFunctionApply)- oder Parallel Custom Scan (AIFunctionApply)-Knoten. Das Vorhandensein dieses Knotens gibt an, dass infrage kommende KI-Funktionsaufrufe aus der standardmäßigen zeilenweisen Verarbeitung extrahiert und in asynchronen Batches mit hohem Durchsatz ausgeführt werden. Wenn dieser Knoten nicht vorhanden ist, wird die Abfrage mit der standardmäßigen zeilenweisen PostgreSQL-Auswertung ausgeführt.

KI-Filterung in WHERE-Klauseln überprüfen

Wenn Sie eine boolesche KI-Funktion (z. B. ai.if) in einer WHERE-Klausel zusammen mit standardmäßigen relationalen SQL-Prädikaten verwenden, wertet AlloyDB zuerst selektive relationale Filter mithilfe von Index- oder Tabellenscans aus. Anschließend beschleunigt AlloyDB nur die Kandidatenzeilen für die KI-Bewertung. Beispiel:

EXPLAIN (COSTS OFF)
SELECT r.name, r.review
FROM restaurant_reviews r
WHERE ai.if('Is the following a positive review? Review: ' || r.review)
  AND r.city = 'Los Angeles';

Wenn Sie die Anweisung EXPLAIN verwenden, um Ihre Abfrage zu analysieren, wird im Abfrageplan ein Custom Scan (AIFunctionApply)-Knoten angezeigt:

                                       QUERY PLAN
----------------------------------------------------------------------------------------
 Custom Scan (AIFunctionApply)
   Filter: ai.if(('Is the following a positive review? Review: '::text || review), NULL::character varying)
   ->  Index Scan using idx_restaurant_reviews_city on restaurant_reviews r
         Index Cond: ((city)::text = 'Los Angeles'::text)

Der relationale Filter (city = 'Los Angeles') wird zuerst im Index ausgewertet. Nur übereinstimmende Zeilen werden im Batch verarbeitet und zur ai.if-Auswertung an das Modell gesendet.

KI-Projektion mit paralleler Abfrageausführung überprüfen

KI-Bewertungs- und Generierungsfunktionen in der Zielliste SELECT werden automatisch beschleunigt. Wenn Abfragen große Tabellen scannen, wird die intelligente Beschleunigung in die parallele Abfrage von PostgreSQL eingebunden, wodurch die Batchauswertung auf parallele Hintergrund-Worker verteilt wird:

EXPLAIN (COSTS OFF)
SELECT ai.generate('Summarize the customer sentiment for: ' || r.review) AS review_summary
FROM restaurant_reviews r
WHERE ai.if('Does this review mention food safety concerns? ' || r.review);

Beispiel für die Ausgabe eines Abfrageplans:

                            QUERY PLAN
------------------------------------------------------------------------------------------------------
 Gather
   Workers Planned: 4
   ->  Custom Scan (AIFunctionApply)
         ->  Parallel Custom Scan (AIFunctionApply)
               Filter: ai.if(('Does this review mention food safety concerns? '::text || r.review), NULL::character varying)
               ->  Parallel Seq Scan on restaurant_reviews r
(6 rows)

Fallback-Verhalten

Smart Batching bietet eine sichere Fallback-Semantik. Wenn eine Abfrage ein Konstrukt oder Muster enthält, das nicht sicher beschleunigt werden kann, schlägt die Abfrage nicht fehl. Stattdessen führt AlloyDB die Abfrage sicher mit der standardmäßigen zeilenweisen PostgreSQL-Ausführung aus.

Fallbacks mit DEBUG2 diagnostizieren

Wenn Sie herausfinden möchten, warum eine Abfrage mit der Standardausführung und nicht mit Smart Batching ausgeführt wurde, setzen Sie client_min_messages auf DEBUG2 und führen Sie EXPLAIN aus:

SET client_min_messages TO DEBUG2;
EXPLAIN SELECT ...;
RESET client_min_messages;

Prüfen Sie die Ausgabe auf Diagnosemeldungen mit dem Präfix AI function acceleration is not applied.

Nicht unterstützte Abfragemuster

Die folgenden Abfragemuster können nicht beschleunigt werden und werden automatisch auf die standardmäßige zeilenweise Ausführung zurückgesetzt:

  • Verschachtelte KI-Funktionen: KI-Funktionen können keinen anderen KI-Funktionsaufruf als Argument verwenden (z. B. ai.if(ai.if(...))).
  • ON-Klauseln für Outer Joins: KI-Funktionen, die in LEFT-, RIGHT- oder FULL OUTER JOIN-Bedingungen platziert werden. Eine Behelfslösung besteht darin, den KI-Filter in der WHERE-Klausel oder in einer Unterabfrage zu platzieren.
  • Aggregatfunktionen, die KI-Funktionen umschließen: direkte Aggregatfunktionen über KI-Funktionen (z. B. AVG(ai.rank(...))). Eine Problemumgehung besteht darin, die KI-Funktion zuerst in einem CTE oder einer Unterabfrage zu berechnen und dann zu aggregieren.
  • Argumente mit veränderlichen Funktionen: Argumentausdrücke, die veränderliche Funktionen enthalten (z. B. random() oder clock_timestamp()).
  • Nicht konstante Argumente: Alle Argumente nach der ersten Texteingabe (z. B. output_schema, categories und model_id) müssen konstante Literale sein, keine Spaltenverweise oder Ausdrücke.
  • Korrelierte Unterabfragen oder äußere Parameter: KI-Ausdrücke, die auf Variablen aus einem äußeren Abfrageblock verweisen.
  • Nicht-Basisbeziehungen: Scans über Fremdtabellen (postgres_fdw) oder materialisierte CTEs (WITH ... AS MATERIALIZED).
  • Mehr als fünf verschiedene KI-Funktionen: Ein einzelner Tabellenscan unterstützt bis zu fünf verschiedene KI-Funktionsaufrufe.

Leistung optimieren

Sie können die AlloyDB-Instanz- und Sitzungsparameter optimieren, um den Durchsatz zu maximieren und die Latenz für KI-Arbeitslasten zu minimieren.

Batchgruppengröße

Der Parameter google_ml_integration.ai_function_acceleration_group_size legt die maximale Anzahl von Zeilen fest, die in einem einzelnen Remote-RPC-Aufruf an Vertex AI zusammengefasst werden:

  • Standardwert: 4000 (Bereich: 1 bis 20000)
  • Gültigkeitsbereich: Sitzungs-, Nutzer- oder Datenbankebene
SET google_ml_integration.ai_function_acceleration_group_size = 10000;

Richtlinien zur Größenanpassung von Arbeitslasten:

  • Interaktive Abfragen (für die Online-Transaktionsverarbeitung (OLTP) oder niedrige Latenz): Legen Sie group_size zwischen 50 und 100 fest. Bei kleineren Batchgrößen wird der erste Batch von Ergebnissen für Abfragen mit LIMIT-Klauseln schneller zurückgegeben.
  • Bulk-Verarbeitung oder analytische Pipelines (für OLAP-Arbeitslasten (Online Analytical Processing) oder ETL-Arbeitslasten (Extract, Transform, Load)): Setzen Sie group_size auf einen Wert zwischen 5000 und 20000. Größere Batches maximieren den Modelldurchsatz und minimieren die Gesamtausführungszeit von Abfragen für große Datasets.

Nebenläufigkeit und Worker verwalten

Bei der parallelen Abfrageausführung wird die Batch-Bewertung auf Hintergrund-Worker unter einem Gather-Knoten verteilt. Beachten Sie Folgendes, um den parallelen Durchsatz zu optimieren:

  • Achten Sie bei umfangreichen analytischen Scans darauf, dass max_parallel_workers_per_gather und max_parallel_workers entsprechend festgelegt sind, um den parallelen Durchsatz zu maximieren.
  • Bei interaktiven Arbeitslasten oder Umgebungen mit strengen Vertex AI-Ratenbegrenzungen verhindert die Reduzierung der Worker-Anzahl, dass gleichzeitige Abfragen um Modellkontingente konkurrieren.

Arbeitsspeicher verwalten

Beim Smart Batching wird die Speichernutzung automatisch über die PostgreSQL-Einstellung work_mem begrenzt. Batches werden dynamisch gesendet, wenn Speicherschwellenwerte erreicht werden, um einen übermäßigen Ressourcenverbrauch zu verhindern. Achten Sie darauf, dass work_mem die richtige Größe hat, wenn Sie sehr große Text-Prompts oder Batches verarbeiten.

Kostenoptimierung

Nur Zeilen, die alle nicht-KI-bezogenen relationalen Prädikate erfüllen, werden an das Modell gesendet. Wenn die Abfragesemantik es zulässt, können Sie selektive relationale SQL-Filter wie Zeiträume, Statuscodes oder kategoriale Filter anwenden, um die Anzahl der Kandidatenzeilen zu reduzieren, die an das Modell gesendet werden. Dadurch werden die Kosten für den Modellaufruf und die Ausführungslatenz reduziert.

Fehlerbehebung

In den folgenden Abschnitten werden häufige Probleme und Schritte zur Behebung beim Ausführen von beschleunigten KI-Abfragen beschrieben.

Abfrage verwendet keine Beschleunigung

Wenn Ihre Abfrage kein Smart Batching verwendet, Sie dies aber erwarten, sollten Sie Folgendes beachten:

  • Prüfen Sie das Erweiterungs-Flag: Prüfen Sie, ob SHOW google_ml_integration.enable_ai_function_acceleration; den Wert on zurückgibt.
  • Nicht unterstützte Muster prüfen: Prüfen Sie, ob Ihre Abfrage keine nicht unterstützten Abfragemuster enthält.
  • Führen Sie die DEBUG2-Diagnose aus: Führen Sie SET client_min_messages TO DEBUG2; gefolgt von EXPLAIN SELECT ...; aus, um den genauen Grund zu sehen, warum die Beschleunigung der KI-Funktion übersprungen wurde. Führen Sie RESET client_min_messages; unmittelbar nach EXPLAIN aus, um zu verhindern, dass Ihre Sitzung während normaler Abfragevorgänge mit Debug-Nachrichten überflutet wird. Beispiel:

    SET client_min_messages TO DEBUG2;
    EXPLAIN SELECT ...;
    RESET client_min_messages;
    

  • Vorbereitete Anweisungen: PostgreSQL speichert Abfragepläne für vorbereitete Anweisungen im Cache. Wenn Sie Beschleunigungs-Flags aktiviert haben, führen Sie DEALLOCATE ALL; aus, um im Cache gespeicherte Pläne neu zu kompilieren.

Ausschöpfung des Kontingents handhaben

Wenn HTTP 429- oder Ratenbegrenzungsfehler auftreten, liegt das wahrscheinlich daran, dass beim Smart Batching zu viele Zeilen gleichzeitig verarbeitet werden und der API-Verbrauch steigt. Beachten Sie Folgendes, um eine Ausschöpfung des Kontingents zu vermeiden:

  • Tokenkontingente (TPM): Prüfen Sie, ob Ihr Google Cloud -Projekt ein ausreichendes TPM-Kontingent (Tokens Per Minute) für Ihr Zielmodell in der Zielregion hat. Informationen zum Erhöhen Ihres TPM-Kontingents finden Sie unter TPM-Kontingentanpassung anfordern.
  • Ratenbegrenzungen für die Agent Platform API: Achten Sie darauf, dass Ihr Google Cloud -Projekt ein ausreichendes Kontingent für die Agent Platform API hat. Wenn Sie eine Kontingenterhöhung für Ihr Agent Platform-Modell beantragen möchten, lesen Sie den Hilfeartikel Erhöhung des API-Kontingents beantragen.
  • Parallele Abfragen: Wenn parallele Worker die Kontingente der Agent-Plattform ausschöpfen, reduzieren Sie die Parallelität für die Sitzung:

    SET max_parallel_workers_per_gather = 0;
    

  • Nicht parallele Abfragen: Reduzieren Sie bei nicht parallelen Abfragen, für die Ratenbegrenzungen gelten, die Batchgruppengröße:

    SET google_ml_integration.ai_function_acceleration_group_size = 500;
    

Nächste Schritte