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.extractundai.classify) über Ergebniszeilen hinweg zusammen.JOIN ... ON-Bedingungen: Wertet tabellenübergreifende KI-Bedingungen inINNER JOIN-Vorgängen mithilfe von Smart Batching aus.- DML-Anweisungen: Beschleunigt KI-Funktionen in
WHERE-Prädikaten, Ziellisten undSET-Ausdrücken fürUPDATE-,DELETE- undINSERT ... SELECT-Vorgänge, z. B.INSERT INTO ... SELECT ai.generate(...)undUPDATE ... 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)- undCASE-Anweisungen
Hinweis
Wenn Sie Smart Batching für KI-Funktionen in AlloyDB verwenden möchten, müssen die folgenden Voraussetzungen erfüllt sein:
- PostgreSQL-Version: Verwenden Sie PostgreSQL-Version 17 oder höher.
- In die Gemini Enterprise Agent Platform einbinden: Führen Sie die Schritte unter In die Gemini Enterprise Agent Platform einbinden aus.
- Regionale Verfügbarkeit: Smart Batching ist in Regionen verfügbar, die das Standardmodell (
gemini-3.5-flash-lite) oder das mitgoogle_ml_integration.default_llm_modelkonfigurierte 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.extractundai.classifyaktivieren möchten, setzen Siegoogle_ml_integration.enable_preview_ai_functionsaufon. - Modellauswahl: Wenn Sie ein anderes Modell als das Standardmodell
gemini-3.5-flash-liteangeben möchten, setzen Siegoogle_ml_integration.default_llm_modelauf die ID Ihres Zielmodells oder übergeben Sie den Parametermodel_idin 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_IDErsetzen 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 inLEFT-,RIGHT- oderFULL OUTER JOIN-Bedingungen platziert werden. Eine Behelfslösung besteht darin, den KI-Filter in derWHERE-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()oderclock_timestamp()). - Nicht konstante Argumente: Alle Argumente nach der ersten Texteingabe (z. B.
output_schema,categoriesundmodel_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:1bis20000) - 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_sizezwischen50und100fest. Bei kleineren Batchgrößen wird der erste Batch von Ergebnissen für Abfragen mitLIMIT-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_sizeauf einen Wert zwischen5000und20000. 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_gatherundmax_parallel_workersentsprechend 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 Wertonzurü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 SieSET client_min_messages TO DEBUG2;gefolgt vonEXPLAIN SELECT ...;aus, um den genauen Grund zu sehen, warum die Beschleunigung der KI-Funktion übersprungen wurde. Führen SieRESET client_min_messages;unmittelbar nachEXPLAINaus, 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
- Intelligente SQL-Abfragen mit KI-Funktionen ausführen
- KI-Abfragen mit optimierten Funktionen beschleunigen
- Vertex AI-Integration konfigurieren