Intelligente SQL-Abfragen mit KI-Funktionen ausführen

Wählen Sie eine Dokumentationsversion aus:

Auf dieser Seite erfahren Sie, wie Sie die AlloyDB Omni AI-Abfrage-Engine verwenden und intelligente SQL-Abfragen mit KI-Funktionen ausführen.

AlloyDB KI-Funktionen binden Large Language Models (LLMs) wie Gemini direkt in Ihre AlloyDB Omni-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 mithilfe von Modellen für künstliche Intelligenz 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 die Arbeitsspeicherzuweisung verarbeiten: skalare, arraybasierte und Cursorfunktionen. Die Wahl 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 grundlegende, eins-zu-eins-Verarbeitung entwickelt. Nimmt eine einzelne Eingabe entgegen und gibt eine einzelne Ausgabe zurück.

Verwenden Sie diese Option, wenn Sie eine einfache Funktion benötigen, die eine akzeptable Leistung für Abfragen mit einer geringen Anzahl von Skalarfunktionsaufrufen (weniger als 50) bietet.

Arraybasiert

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

Verwenden Sie diese Option für kleine bis mittelgroße Datasets, bei denen das gesamte Array der infrage kommenden Zeilen innerhalb der Arbeitsspeicherlimits liegt. Dies ermöglicht einen hohen Durchsatz für satzbasierte 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.

Hinweis

  1. Nutzerzugriff auf Vertex AI-Modelle konfigurieren

  2. 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.

  3. Wenn Sie die AlloyDB AI-Abfrage-Engine-Funktion 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';

  4. Verwenden Sie ein Gemini-Modell, das in Ihrer Region unterstützt wird. Gemini 3.5 Flash-Lite ist das Standardmodell der KI-Abfrage-Engine. Wenn Sie in der Abfrage kein Gemini-Modell angeben, verwendet die KI-Abfrage-Engine das Standardmodell.

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

Das Standardmodell der KI-Abfrage-Engine ist gemini-3.5-flash-lite. Wenn Sie in Ihren KI-Funktionen kein model_id angeben, wird dieses Modell für Ihre Abfragen verwendet. Informationen zur Modellverfügbarkeit finden Sie unter Unterstützte Regionen. Preisdetails finden Sie unter Agent Platform – Preise.

Wenn sich Ihr AlloyDB Omni-Cluster in einer Region befindet, in der gemini-3.5-flash-lite nicht unterstützt wird, können Sie mit dem Parameter model_id ein anderes verfügbares Gemini-Modell angeben. Weitere Informationen finden Sie unter Standorte von Google-Modellendpunkten.

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 weiteren Gemini-Endpunkt registrieren. In diesem Beispiel ist der zweite Gemini-Endpunkt der globale Endpunkt für gemini-3.5-flash-lite. Sie können dieses registrierte Modell mit KI-Operatoren verwenden, indem Sie model_id => 'gemini-3.5-flash-lite-global' als zusätzliches Argument übergeben.

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

Gemini 3-Modelle verwenden

Einige Gemini-Modelle wie gemini-3-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 Vertex AI-KI-Modell verfügbar ist. Das AlloyDB Omni-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-gestützte SQL-Funktionen, mit denen Sie Natural Language Processing und LLMs direkt in Ihren Datenbankabfragen verwenden können, einschließlich der Operatoren ai.if und ai.rank.

Filterung mit Skalarfunktionen durchführen

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 nachvollziehen 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 In Ihrer Region unterstütztes Gemini-Modell verwenden 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-3.5-flash-lite')
GROUP BY r.name, r.location_city
HAVING COUNT(*) > 500;

Führen Sie einen Join für eine Abfrage aus, die den Operator „if“ verwendet.

Verwenden Sie für einen Join-Vorgang den Operator ai.if/google_ml.if mit „join“. Mit der folgenden Beispielabfrage wird die Anzahl der Rezensionen ermittelt, in denen die einzelnen Gerichte auf 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;

Filterung mit Array-basierten Funktionen durchführen

Im folgenden Beispiel werden Restaurants mit mehr als 10 positiven Rezensionen identifiziert. Dazu wird ein KI-Modell (gemini-3.5-flash-lite) verwendet, um die Stimmung in den Rezensionen zu analysieren und die Ergebnisse zu filtern. ARRAY_AGG wird verwendet, um einzelne Datenzeilen in strukturierte Arrays umzuwandeln, damit sie vom KI-Modell im Bulk 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-3.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.location_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.location_city, rest_review.name
HAVING COUNT(*) > 10;

Filterung mit Cursorn durchführen

Im folgenden Beispiel wird gezeigt, 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-3.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 für die Textgenerierung wie den skalaren ai.generate sowie den array- und cursorbasierten ai.generate.

Textgenerierung mit Skalarfunktionen durchführen

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 Abfrage können Sie beispielsweise eine kurze Zusammenfassung jeder Nutzerrezension generieren.

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

Text mit Array-basierten 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-3.5-flash-lite'
    )
  ) AS review_summary
FROM user_reviews;

Textgenerierung mit Cursorn durchführen

Wenn Sie Zusammenfassungen oder Übersetzungen für Millionen von Zeilen generieren möchten, ohne dass es zu Speicherengpässen kommt, verwenden Sie die Batchgenerierung mit Cursorn.

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 mithilfe von benutzerdefinierten Anweisungen in natürlicher Sprache sortieren müssen, verwenden Sie den Operator ai.rank.

Bewertung mit Skalarfunktionen durchführen

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

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

Mit der folgenden Abfrage werden beispielsweise die 20 positivsten Restaurantbewertungen anhand der Bewertungen eines LLM abgerufen.

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 Array-basierten Funktionen durchführen

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

FUNCTION ai.rank(prompts TEXT[], batch_size INT DEFAULT NULL, 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 Cursorn durchführen

Diese Funktion wird für die Bewertung großer Datasets verwendet, ohne dass Speicherlimits erreicht werden.

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

Im folgenden Beispiel wird gezeigt, wie Sie große Textmengen nach bestimmten 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 $$;

Nächste Schritte