Intelligente SQL-Abfragen mit KI-Funktionen ausführen

AlloyDB AI-Funktionen integrieren Large Language Models (LLMs) wie Gemini direkt in Ihre AlloyDB for PostgreSQL-Daten, um intelligente Datenoperationen auszuführen. Diese Funktion umfasst integrierte Funktionen für Folgendes:

  • Filtern (ai.if)
  • Semantische Rangfolge (ai.rank)
  • Textgenerierung (ai.generate)

Diese KI-Funktionen verwenden die AlloyDB AI-Abfrage-Engine, um Ihre Anwendung bei der Verarbeitung von Daten mit KI-Modellen in verschiedenen Größenordnungen zu unterstützen – von Antworten mit einer einzelnen Zeile bis hin zu umfangreichen Datenbankoperationen. Mit den Operatoren ai.if, ai.rank und ai.generate können Sie natürliche Sprache mit SQL-Abfragen kombinieren. AlloyDB AI reserviert und erstellt das ai-Schema.

Es gibt drei Kategorien von KI-Funktionen, die sich darin unterscheiden, wie sie Eingabedaten und die Arbeitsspeicherzuweisung verarbeiten: Skalar-, Array-basierte und Cursor-Funktionen. Die Wahl der richtigen KI-Funktion hängt von der Größe Ihrer Daten und Ihren Leistungsanforderungen ab. In der folgenden Tabelle finden Sie Informationen zu diesen Funktionen und ihren Anwendungsfällen:

Kategorie

Beschreibung

Empfohlener Anwendungsfall

Skalar

Für die einfache 1:1-Verarbeitung konzipiert. Akzeptiert eine einzelne Eingabe und gibt eine einzelne Ausgabe zurück.

Verwenden Sie diese Funktion, wenn Sie eine einfache Funktion benötigen, die eine akzeptable Leistung für Abfragen bietet, die eine geringe Anzahl – weniger als 50 – von Skalarfunktionsaufrufen ausführen.

Array-basiert

Verarbeitet Daten als Array von Zeilen in einem einzigen Funktionsaufruf. Akzeptiert ein Array als Eingabe und gibt ein Array als Ausgabe zurück.

Verwenden Sie diese Funktion für kleine bis mittelgroße Datasets, bei denen das gesamte Array der infrage kommenden Zeilen in die Speicherlimits passt. Dies bietet einen hohen Durchsatz für setbasierte Vorgänge.

Cursor

Akzeptiert einen Cursor als Eingabe und gibt einen Cursor als Ausgabe zurück.

Verwenden Sie diese Funktion, um eine große Anzahl von Zeilen zu verarbeiten,z. B. 10.000 Zeilen.

Hinweis

In die Agent Platform einbinden und die Erweiterung installieren

  1. Nutzerzugriff auf Agent Platform-Modelle konfigurieren.
  2. Prüfen Sie, ob die neueste Version von google_ml_integration installiert ist.

    1. Führen Sie den folgenden Befehl aus, um die installierte Version zu prüfen:

      SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
extversion 
------------
1.5.2
(1 row)

    2. Wenn die Erweiterung nicht installiert ist oder die installierte Version älter als 1.5.2 ist, aktualisieren Sie die Erweiterung.

      CREATE EXTENSION IF NOT EXISTS google_ml_integration;
ALTER EXTENSION google_ml_integration UPDATE;

      Wenn beim Ausführen der vorherigen Befehle Probleme auftreten oder die Erweiterung nach dem Ausführen der vorherigen Befehle nicht auf Version 1.5.2 aktualisiert wird, wenden Sie sich an den Google Cloud Support.

  3. Wenn Sie die Funktion der AlloyDB AI-Abfrage-Engine verwenden möchten, setzen Sie das google_ml_integration.enable_ai_query_engine Flag auf on.

    SQL

    1. Aktivieren Sie die KI-Abfrage-Engine für die aktuelle Sitzung.
      SET google_ml_integration.enable_ai_query_engine = on;
    2. Aktivieren Sie Funktionen für eine bestimmte Datenbank sitzungsübergreifend.
      ALTER DATABASE DATABASE_NAME SET google_ml_integration.enable_ai_query_engine = 'on';
    3. Aktivieren Sie die KI-Abfrage-Engine für einen bestimmten Nutzer sitzungs- und datenbankübergreifend.
      ALTER ROLE postgres SET google_ml_integration.enable_ai_query_engine = 'on';

    Console

    Wenn Sie den Wert des Flags google_ml_integration.enable_ai_query_engine ändern möchten, folgen Sie der Anleitung unter Datenbank-Flags einer Instanz konfigurieren.

    gcloud

    Wenn Sie die gcloud CLI verwenden möchten, können Sie die Google Cloud CLI installieren und initialisieren oder Sie können Cloud Shell verwenden.

    Sie können den Wert des Flags google_ml_integration.enable_ai_query_engine ändern. Weitere Informationen finden Sie unter Datenbank-Flags einer Instanz konfigurieren. 

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

Ein Gemini-Modell verwenden, das in Ihrer Region unterstützt wird

Wenn sich Ihr AlloyDB for PostgreSQL-Cluster in einer Region befindet, in der gemini-2.5-flash-lite nicht unterstützt wird, können Sie eines der anderen verfügbaren Gemini-Modelle in Ihrer Region mit dem model_id parameter verwenden.

Alternativ können Sie einen Gemini-Modellendpunkt registrieren und diese Modell-ID den KI-Operatoren zur Verfügung stellen. Weitere Informationen finden Sie unter Remote-KI-Modelle mit der Modellendpunktverwaltung registrieren und aufrufen.

Das folgende Beispiel zeigt, wie Sie einen anderen Gemini-Endpunkt registrieren. In diesem Beispiel ist dieser zweite Gemini-Endpunkt der globale Endpunkt für gemini-2.5-flash-lite. Sie können dieses registrierte Modell mit KI-Operatoren verwenden, indem Sie model_id => 'gemini-2.5-flash-lite-global' als ein zusätzliches Argument übergeben.

CALL
  google_ml.create_model(
    model_id => 'gemini-2.5-flash-lite-global',
    model_type => 'llm',
    model_provider => 'google',
    model_qualified_name => 'gemini-2.5-flash-lite',
    model_request_url =>  'https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-2.5-flash-lite:generateContent',
    model_auth_type => 'alloydb_service_agent_iam'
);

Gemini 3.0-Modelle verwenden

Einige Gemini-Modelle wie gemini-3.0-pro-preview sind nur über den globalen Endpunkt verfügbar. Sie müssen solche Modelle so registrieren:

CALL
  google_ml.create_model(
    model_id => 'gemini-3-preview-model',
    model_request_url => 'https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3-pro-preview:generateContent',
    model_qualified_name => 'gemini-3-pro-preview',
    model_provider => 'google',
    model_type => 'llm',
    model_auth_type => 'alloydb_service_agent_iam'
);

Ersetzen Sie PROJECT_ID durch die ID des Projekts, in dem das Agent Platform-Modell verfügbar ist. Das AlloyDB-Dienstkonto muss in diesem Projekt die Rolle „Vertex AI-Nutzer“ haben.

Nachdem Sie das Modell registriert haben, können Sie es so in KI-Funktionen verwenden:

SELECT ai.generate(prompt => 'What is AlloyDB?', model_id => 'gemini-3-preview-model');

Filter in Abfragen verwenden

AlloyDB AI bietet KI-basierte SQL-Funktionen, mit denen Sie die Verarbeitung natürlicher Sprache und LLMs direkt in Ihren Datenbankabfragen verwenden können, einschließlich der Operatoren ai.if und ai.rank.

Mit Skalarfunktionen filtern

Verwenden Sie den Operator ai.if/google_ml.if, um zu prüfen, ob eine in natürlicher Sprache angegebene Bedingung erfüllt ist. Die Funktion gibt einen booleschen Wert zurück: „true“ oder „false“. Wenn die Ausgabe nicht eindeutig erkannt wird, wird false zurückgegeben.

- Function signature
FUNCTION ai.if(prompt TEXT, model_id VARCHAR(100) DEFAULT NULL) RETURNS bool

Das folgende Beispiel zeigt die Verwendung des Operators ai.if als Filter,um Restaurants mit mehr als 500 positiven Bewertungen in Städten mit mehr als 100.000 Einwohnern zu finden. Das Beispiel verwendet restaurant_reviews und enthält Daten wie Bewertungen und den Standort der Stadt. Mit dem Operator ai.if können Sie die Stimmung in der Bewertung analysieren und die Standorte aus der Datenbank mit dem allgemeinen Wissen von Gemini über die Bevölkerung an diesen Standorten kombinieren.

SELECT r.name, r.location_city
FROM restaurant_reviews r
WHERE
  AI.IF(r.location_city || ' has a population OF more than 100,000 AND the following is a positive review; Review: ' || r.review)
GROUP BY r.name, r.location_city
HAVING COUNT(*) > 500;

Im Folgenden sehen Sie dasselbe Beispiel mit dem Modell, das Sie unter Ein Gemini-Modell verwenden, das in Ihrer Region unterstützt wird registriert haben.

SELECT r.name, r.location_city
FROM restaurant_reviews r
WHERE
  AI.IF(r.location_city || ' has a population of more than 100,000 AND the following is a positive review; Review: ' || r.review, model_id => 'gemini-2.5-flash-lite')
GROUP BY r.name, r.location_city
HAVING COUNT(*) > 500;

Join für eine Abfrage ausführen, die den Operator „if“ verwendet

Verwenden Sie den Operator ai.if/google_ml.if mit „join“, um einen Join-Vorgang auszuführen. Die folgende Beispielabfrage ermittelt die Anzahl der Bewertungen, in denen die einzelnen Menüpunkte aus der Speisekarte des Restaurants erwähnt werden.

    SELECT item_name, COUNT(*)
    FROM menu_items JOIN user_reviews
      ON ai.if(
        prompt => 'Does the following user review talk about the menu item mentioned ? review: ' || user_reviews.review_text || ' menu item: ' || item_name)
    GROUP BY item_name;

Mit Array-basierten Funktionen filtern

Im folgenden Beispiel werden Restaurants mit mehr als 10 positiven Bewertungen ermittelt, indem ein KI-Modell (gemini-2.5-flash-lite) verwendet wird, um die Stimmung in den Bewertungen zu analysieren und die Ergebnisse zu filtern. ARRAY_AGG wird verwendet, um einzelne Datenzeilen in strukturierte Arrays umzuwandeln, damit sie vom KI-Modell in großen Mengen und nicht zeilenweise verarbeitet werden können.

WITH initial_arrays AS (
  SELECT
    ARRAY_AGG(r.id ORDER BY r.id) AS review_ids,
    -- Assuming ai.if takes an array of prompts and returns a boolean array
    ai.if(
      prompts => ARRAY_AGG('Is the review positive: ' || r.review ORDER BY r.id),
      model_id => 'gemini-2.5-flash-lite',
      batch_size => 20
    ) AS truth_values
  FROM restaurant_reviews r
),
reviews AS (
SELECT
  initial_arrays.review_ids[i] AS review_id,
  initial_arrays.truth_values[i] AS truth_value
FROM
  initial_arrays,
  generate_series(1, array_length(initial_arrays.review_ids, 1)) AS i
)
SELECT rest_review.city, rest_review.name
FROM restaurant_reviews rest_review JOIN reviews review ON rest_review.id=review.review_id
WHERE review.truth_value = 't'
GROUP BY rest_review.city, rest_review.name
HAVING COUNT(*) > 10;

Mit Cursors filtern

Das folgende Beispiel zeigt, wie Sie eine große Anzahl von Restaurantbewertungen filtern, indem Sie sie über einen Cursor streamen.

CREATE TABLE filtered_results(input text, result bool);

DO $$
DECLARE
    prompt_cursor REFCURSOR;
    result_cursor REFCURSOR;
    rec RECORD;
BEGIN
    -- 1. Open a cursor for the input data
    OPEN prompt_cursor FOR
        SELECT r.location_city || ' has a population of > 100,000 and is a positive review; Review: ' || r.review
        FROM restaurant_reviews r;

    -- 2. Call the array-based function using the input cursor
    result_cursor := ai.if(
        'Is the given statement true? ',
        prompt_cursor,
        model_id => 'gemini-2.5-flash-lite'
    );

    -- 3. Fetch results from the output cursor and store them
    LOOP
        FETCH result_cursor INTO rec;
        EXIT WHEN NOT FOUND;
        INSERT INTO filtered_results VALUES(rec.input, rec.output);
    END LOOP;

    CLOSE result_cursor;
END $$;

Textgenerierung und -zusammenfassung

AlloyDB AI bietet Operatoren zur Textgenerierung wie die Skalarfunktion ai.generate und die Array- und Cursor-basierten Funktionen ai.generate.

Mit Skalarfunktionen Text generieren

Die Funktion ai.generate erstellt Text, indem sie die bereitgestellten Daten mit dem Prompt des Nutzers kombiniert.

-- Function Signature
FUNCTION ai.generate(prompt TEXT, model_id VARCHAR(100) DEFAULT NULL) RETURNS TEXT

Mit der folgenden Abfrage können Sie beispielsweise eine kurze Zusammenfassung jeder Nutzerbewertung erstellen.

SELECT
  ai.generate(
    prompt => 'Summarize the review in 20 words or less. Review: ' || review) AS review_summary
FROM user_reviews;

Mit Array-basierten Funktionen Text generieren

Die folgende Abfrage verwendet UNNEST und ai.generate, um mehrere Bewertungen effizient zusammenzufassen.

SELECT
  UNNEST(
    ai.generate(
      prompts => ARRAY_AGG('Summarize the review in 20 words or less. Review: ' || review),
      model_id => 'gemini-2.5-flash-lite',
    )
  ) AS review_summary
FROM user_reviews;

Mit Cursors Text generieren

Wenn Sie Zusammenfassungen oder Übersetzungen für Millionen von Zeilen erstellen möchten, ohne an Speicherengpässe zu stoßen, verwenden Sie die Batchgenerierung mit Cursors.

CREATE TABLE summary_results(summary text);

DO $$
DECLARE
    prompt_cursor REFCURSOR;
    summary_cursor REFCURSOR;
    rec RECORD;
BEGIN
    OPEN prompt_cursor FOR SELECT review_text FROM user_reviews ORDER BY id;

    summary_cursor := ai.generate(
        'Summarize the review in 20 words or less. Review:',
        prompt_cursor,
    );

    LOOP
        FETCH summary_cursor INTO rec;
        EXIT WHEN NOT FOUND;
        INSERT INTO summary_results VALUES(rec.output);
    END LOOP;

    CLOSE summary_cursor;
END $$;

Abfrageergebnisse bewerten

Wenn Sie Abfrageergebnisse mit benutzerdefinierten Anweisungen in natürlicher Sprache sortieren müssen, verwenden Sie den Operator ai.rank.

Mit Skalarfunktionen bewerten

Mit der folgenden Funktion können Sie einen Prompt angeben, der die Rankingkriterien beschreibt, und für jedes Element eine Bewertung zurückgeben.

-- Function signature
FUNCTION ai.rank(prompt TEXT, model_id VARCHAR(100) DEFAULT NULL) RETURNS real

Die folgende Abfrage ruft beispielsweise die 20 positivsten Restaurantbewertungen ab und verwendet dabei Bewertungen aus einem LLM.

SELECT review AS top20
FROM user_reviews
ORDER BY ai.rank(
  'Score the following review according to these rules:
  (1) Score OF 8 to 10 IF the review says the food IS excellent.
  (2) 4 to 7 IF the review says the food is ok.
  (3) 1 to 3 IF the review says the food is not good. Here is the review:' || review) DESC
LIMIT 20;

Mit Array-basierten Funktionen bewerten

Mit dieser Funktion ai.rank können Sie Abfrageergebnisse anhand benutzerdefinierter Anweisungen in natürlicher Sprache bewerten und einstufen.

FUNCTION ai.rank(prompts TEXT[], model_id VARCHAR(100) DEFAULT NULL) RETURNS real[]

Die folgende Abfrage verwendet UNNEST und ai.rank, um mehrere Bewertungen effizient zu bewerten.

SELECT
  UNNEST(
    ai.rank(
      ARRAY_AGG('Score the following review according to these rules:
  (1) Score OF 8 to 10 IF the review says the food IS excellent.
  (2) 4 to 7 IF the review says the food is ok.
  (3) 1 to 3 IF the review says the food is not good. Here is the review:' || review),
    )
  ) as review_scores
FROM user_reviews;

Mit Cursors bewerten

Diese Funktion wird verwendet, um große Datasets zu bewerten, ohne an Speicherlimits zu stoßen.

FUNCTION ai.rank(context TEXT, input_cursor REFCURSOR, model_id VARCHAR(100) DEFAULT NULL) RETURNS REFCURSOR

Das folgende Beispiel zeigt, wie Sie große Textmengen anhand bestimmter Kriterien in natürlicher Sprache bewerten.

CREATE TABLE scored_results(input text, score real);

DO $$
DECLARE
    prompt_cursor REFCURSOR;
    score_cursor REFCURSOR;
    rec RECORD;
BEGIN
    OPEN prompt_cursor FOR SELECT review FROM user_reviews ORDER BY id;

    score_cursor := ai.rank(
        'Score the following review: (1) 8-10 if excellent, (2) 4-7 if ok, (3) 1-3 if not good. Review:',
        prompt_cursor,
    );

    LOOP
        FETCH score_cursor INTO rec;
        EXIT WHEN NOT FOUND;
        INSERT INTO scored_results VALUES(rec.input, rec.output);
    END LOOP;

    CLOSE score_cursor;
END $$;

Nächste Schritte