Intelligente SQL-Abfragen mit KI-Funktionen ausführen

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

Filtern (ai.if)
Semantisches Ranking (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 Datenbankvorgängen. 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 Schema ai.

Es gibt drei Kategorien von KI-Funktionen, die sich darin unterscheiden, wie sie Eingabedaten und Speicherzuweisung verarbeiten: skalare, arraybasierte und Cursorfunktionen. Die Auswahl der richtigen KI-Funktion hängt vom Umfang 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 Verarbeitung von Eins-zu-eins-Beziehungen konzipiert. Akzeptiert eine einzelne Eingabe und gibt eine einzelne Ausgabe zurück.	Verwenden Sie diese Option, wenn Sie eine einfache Funktion mit akzeptabler Leistung für Abfragen benötigen, die eine geringe Anzahl (weniger als 50) von Skalarfunktionsaufrufen enthalten.
Arraybasiert	Verarbeitet Daten als Array von Zeilen in einem einzelnen Funktionsaufruf. Nimmt ein Array als Eingabe und gibt es als Ausgabe zurück.	Für kleine bis mittelgroße Datasets, bei denen das gesamte Array der infrage kommenden Zeilen in den Speicher passt. Dies ermöglicht einen hohen Durchsatz für setbasierte Vorgänge.
Cursor	Nimmt einen Cursor als Eingabe und gibt einen Cursor als Ausgabe zurück.	Verwenden Sie diese Option, um eine große Anzahl von Zeilen zu verarbeiten,z. B. 10.000 Zeilen.

Hinweise

Prüfen Sie, ob die google_ml_integration-Erweiterung installiert ist und ob Sie Version 1.5.2 oder höher verwenden. Wenn Sie mit arraybasierten Funktionen eine noch bessere Leistung erzielen möchten, verwenden Sie Version 1.5.4 oder höher.
Prüfen Sie, ob das Flag google_ml_integration.enable_ai_query_engine auf on gesetzt ist.
In Vertex AI einbinden
Verwenden Sie ein Gemini-Modell, das in Ihrer Region unterstützt wird. Gemini 2.0 Flash ist das Standardmodell der KI-Suchmaschine. Wenn Sie in der Anfrage kein Gemini-Modell angeben, wird das Standardmodell der KI-Anfrage-Engine für die Anfragen ausgewählt.

In Vertex AI einbinden und Erweiterung installieren

Nutzerzugriff auf Vertex AI-Modelle konfigurieren
Prüfen Sie, ob die aktuelle 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.
Wenn Sie die Funktionen der AlloyDB AI-Abfrage-Engine verwenden möchten, setzen Sie das Flag google_ml_integration.enable_ai_query_engine 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. Funktionen für eine bestimmte Datenbank sitzungsübergreifend aktivieren
  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 über Sitzungen und Datenbanken hinweg.
  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 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 in Ihrer Region unterstütztes Gemini-Modell verwenden

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

Alternativ können Sie einen Gemini-Modellendpunkt registrieren und diese Modell-ID für die KI-Operatoren angeben. Weitere Informationen finden Sie unter Remote-KI-Modelle mit der Verwaltung von Modellendpunkten registrieren und aufrufen.

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

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

Gemini 3.0-Modelle verwenden

Einige Gemini-Modelle, z. B. gemini-3.0-pro-preview, sind nur über den globalen Endpunkt verfügbar. So registrieren Sie solche Modelle:

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 Vertex AI-Modell verfügbar ist. Das AlloyDB-Dienstkonto muss in diesem Projekt die Rolle „Vertex AI User“ haben.

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

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

Filter in Abfragen verwenden

AlloyDB AI bietet KI-gestützte 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

Mit dem Operator ai.if/google_ml.if können Sie prüfen, ob eine in natürlicher Sprache formulierte Bedingung erfüllt ist. Die Funktion gibt den booleschen Wert „true“ oder „false“ zurück. 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

Im folgenden Beispiel wird der Operator ai.if als Filter verwendet,um Restaurants mit mehr als 500 positiven Rezensionen in Städten mit mehr als 100.000 Einwohnern zu finden. Im Beispiel wird restaurant_reviews verwendet und es enthält Daten wie Rezensionen und den Standort der Stadt. Mit dem Operator ai.if können Sie die Stimmung in den Rezensionen 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 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')
GROUP BY r.name, r.location_city
HAVING COUNT(*) > 500;

Join für eine Abfrage ausführen, in der der IF-Operator verwendet wird

Verwenden Sie den Operator ai.if/google_ml.if mit „join“, um einen Join-Vorgang auszuführen. Mit der folgenden Beispielabfrage wird die Anzahl der Rezensionen ermittelt, 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 Rezensionen identifiziert. Dazu wird ein KI-Modell (gemini-2.0-flash) verwendet, um die Stimmung der Rezensionen zu analysieren und die Ergebnisse zu filtern. Mit ARRAY_AGG werden einzelne Datenzeilen in strukturierte Arrays umgewandelt, damit sie vom KI-Modell als Ganzes und nicht zeilenweise verarbeitet werden können.

WITH initial_arrays AS (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',
      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

Im folgenden Beispiel wird gezeigt, wie Sie eine große Menge von Restaurantrezensionen 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'
    );

    -- 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 skalare ai.generate sowie array- und cursorbasierte ai.generate.

Text mit Skalarfunktionen generieren

Die Funktion ai.generate generiert 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 Anfrage können Sie beispielsweise eine kurze Zusammenfassung der einzelnen Nutzerrezensionen erstellen.

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

Text mit arraybasierten Funktionen generieren

In der folgenden Abfrage werden UNNEST und ai.generate verwendet, um mehrere Rezensionen 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',
    )
  ) AS review_summary
FROM user_reviews;

Textgenerierung mit Cursors durchführen

Wenn Sie Zusammenfassungen oder Übersetzungen für Millionen von Zeilen generieren möchten, ohne dass es zu Engpässen beim Arbeitsspeicher kommt, 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öchten, verwenden Sie den Operator ai.rank.

Bewertung mit Skalarfunktionen durchführen

Mit der folgenden Funktion können Sie einen Prompt mit den Ranking-Kriterien angeben und für jedes Element einen Wert zurückgeben.

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

Mit der folgenden Abfrage werden beispielsweise die 20 positivsten Restaurantrezensionen abgerufen, wobei die Bewertungen eines LLM verwendet werden.

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;

Bewertung mit arraybasierten Funktionen durchführen

Mit dieser ai.rank-Funktion 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[]

In der folgenden Abfrage werden UNNEST und ai.rank verwendet, um mehrere Rezensionen 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;

Bewertung mit Cursors durchführen

Diese Funktion wird verwendet, um große Datasets zu bewerten, ohne Arbeitsspeicherlimits zu überschreiten.

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

Im folgenden Beispiel wird gezeigt, wie Sie große Textmengen anhand bestimmter Kriterien für natürliche 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 $$;