Cette page décrit AlloyDB Omni version 18.3.0 avec l'option de déploiement RPM. Choisissez une autre option de déploiement.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Effectuer des requêtes SQL intelligentes à l'aide de fonctions d'IA

Sélectionnez une version de la documentation :

Cette page explique comment utiliser le moteur de requêtes AlloyDB Omni AI et effectuer des requêtes SQL intelligentes à l'aide de fonctions d'IA.

Les fonctions AlloyDB AI intègrent des grands modèles de langage (LLM, Large Language Models) comme Gemini directement à vos données AlloyDB Omni pour effectuer des opérations de données intelligentes. Cette fonctionnalité inclut des fonctions intégrées pour les éléments suivants :

Filtrage (ai.if)
Classement sémantique (ai.rank)
Génération de texte (ai.generate)

Ces fonctions d'IA utilisent le moteur de requêtes AlloyDB AI pour aider votre application à traiter les données à l'aide de modèles d'intelligence artificielle à différentes échelles, des réponses à une seule ligne aux opérations de base de données à grande échelle. Vous pouvez utiliser les opérateurs ai.if, ai.rank et ai.generate pour combiner le langage naturel avec des requêtes SQL. AlloyDB AI réserve et crée le ai schéma.

Il existe trois catégories de fonctions d'IA qui diffèrent en fonction de la manière dont elles gèrent les données d'entrée et l'allocation de mémoire : les fonctions scalaires, basées sur des tableaux et de curseur. Le choix de la fonction d'IA appropriée dépend de l'échelle de vos données et de vos exigences en matière de performances. Consultez le tableau suivant pour en savoir plus sur ces fonctions et leurs cas d'utilisation :

Catégorie	Description	Cas d'utilisation recommandé
Scalaire	Conçue pour le traitement de base, en tête-à-tête. Accepte une seule entrée et renvoie une seule sortie.	À utiliser lorsque vous souhaitez une fonction de base offrant des performances acceptables pour les requêtes qui effectuent un petit nombre d'appels de fonction scalaire (moins de 50).
Basée sur des tableaux	Traite les données sous forme de tableau de lignes dans un seul appel de fonction. Accepte un tableau en entrée et renvoie un tableau en sortie.	À utiliser pour les ensembles de données de petite à moyenne taille où l'ensemble du tableau de lignes éligibles peut tenir dans les limites de mémoire. Cela offre un haut débit pour les opérations basées sur des ensembles.
Curseur	Accepte un curseur en entrée et renvoie un curseur en sortie.	À utiliser pour traiter un grand nombre de lignes, par exemple 10 000 lignes.

Avant de commencer

Configurez l'accès des utilisateurs aux modèles Vertex AI.
Vérifiez que la dernière version de google_ml_integration est installée.
1. Pour vérifier la version installée, exécutez la commande suivante :
```
SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
extversion 
------------
1.5.2
(1 row)
```
2. Si l'extension n'est pas installée ou si la version installée est antérieure à la version 1.5.2, mettez à jour l'extension.
```
CREATE EXTENSION IF NOT EXISTS google_ml_integration;
ALTER EXTENSION google_ml_integration UPDATE;
```
  Si vous rencontrez des problèmes lors de l'exécution des commandes précédentes ou si l'extension n'est pas mise à jour vers la version 1.5.2 après l'exécution des commandes précédentes, contactez Google Cloud l'assistance.
Pour utiliser la fonctionnalité du moteur de requêtes AlloyDB AI, définissez l' google_ml_integration.enable_ai_query_engine indicateur sur on.
SQL
1. Activez le moteur de requêtes d'IA pour la session en cours.
  SET google_ml_integration.enable_ai_query_engine = on;
2. Activez des fonctionnalités pour une base de données spécifique entre les sessions.
  ALTER DATABASE DATABASE_NAME SET google_ml_integration.enable_ai_query_engine = 'on';
3. Activez le moteur de requêtes d'IA pour un utilisateur spécifique entre les sessions et les bases de données.
  ALTER ROLE postgres SET google_ml_integration.enable_ai_query_engine = 'on';

Utilisez un modèle Gemini compatible dans votre région. Gemini 2.5 Flash Lite est le modèle par défaut du moteur de requêtes d'IA. Si vous ne spécifiez pas de modèle Gemini dans la requête, le modèle par défaut du moteur de requêtes d'IA est choisi pour les requêtes.

Utiliser un modèle Gemini compatible dans votre région

Si votre cluster AlloyDB Omni se trouve dans une région où gemini-2.5-flash-lite n'est pas compatible, vous pouvez utiliser l'un des autres modèles Gemini disponibles dans votre région à l'aide du model_id parameter.

Vous pouvez également enregistrer un point de terminaison de modèle Gemini et fournir cet ID de modèle aux opérateurs d'IA. Pour en savoir plus, consultez Enregistrer et appeler des modèles d'IA distants à l'aide de la gestion des points de terminaison de modèle.

L'exemple suivant montre comment enregistrer un autre point de terminaison Gemini. Dans cet exemple, ce deuxième point de terminaison Gemini est le point de terminaison mondial pour gemini-2.5-flash-lite. Vous pouvez utiliser ce modèle enregistré avec des opérateurs d'IA en transmettant model_id => 'gemini-2.5-flash-lite-global' comme argument supplémentaire.

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'
);

Utiliser les modèles Gemini 3.0

Certains modèles Gemini, tels que gemini-3.0-pro-preview, ne sont disponibles que via le point de terminaison mondial. Vous devez enregistrer ces modèles comme suit :

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'
);

Remplacez PROJECT_ID par l'ID du projet dans lequel le modèle Vertex AI est disponible. Notez que le compte de service AlloyDB Omni doit disposer du rôle d'utilisateur Vertex AI dans ce projet.

Après avoir enregistré le modèle, vous pouvez l'utiliser dans des fonctions d'IA comme suit :

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

Utiliser des filtres dans vos requêtes

AlloyDB AI propose des fonctions SQL basées sur l'IA qui vous permettent d'utiliser le traitement du langage naturel et les LLM directement dans vos requêtes de base de données, y compris les opérateurs ai.if et ai.rank.

Effectuer un filtrage à l'aide de fonctions scalaires

Pour déterminer si une condition exprimée en langage naturel est remplie, utilisez l'opérateur ai.if/google_ml.if. La fonction renvoie la valeur booléenne "true" ou "false", et renvoie false si la sortie n'est pas clairement détectée.

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

L'exemple suivant montre l'utilisation de l'opérateur ai.if comme filtre pour trouver les restaurants ayant plus de 500 avis positifs situés dans des villes de plus de 100 000 habitants. L'exemple utilise restaurant_reviews et contient des données telles que les avis et l'emplacement de la ville. L'opérateur ai.if vous aide à comprendre le sentiment des avis et à combiner les emplacements de la base de données avec les connaissances générales de Gemini sur la population de ces emplacements.

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;

L'exemple suivant montre le même exemple à l'aide du modèle que vous avez enregistré dans Utiliser un modèle Gemini compatible dans votre région.

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;

Effectuer une jointure sur une requête qui utilise l'opérateur if

Pour effectuer une opération de jointure, utilisez l'opérateur ai.if/google_ml.if avec la jointure. L'exemple de requête suivant recherche le nombre d'avis qui mentionnent chaque élément du menu du restaurant.

    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;

Effectuer un filtrage à l'aide de fonctions basées sur des tableaux

L'exemple suivant identifie les restaurants ayant plus de 10 avis positifs en utilisant un modèle d'IA (gemini-2.5-flash-lite) pour analyser le sentiment des avis et filtrer les résultats. ARRAY_AGG permet de transformer des lignes de données individuelles en tableaux structurés afin qu'elles puissent être traitées par le modèle d'IA en bloc plutôt qu'une ligne à la fois.

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-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;

Effectuer un filtrage à l'aide de curseurs

L'exemple suivant montre comment filtrer un grand ensemble d'avis sur des restaurants en les diffusant via un curseur.

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 $$;

Génération et synthèse de texte

AlloyDB AI propose des opérateurs de génération de texte tels que ai.generate scalaire, basé sur des tableaux et basé sur des curseurs ai.generate.

Effectuer une génération de texte à l'aide de fonctions scalaires

La fonction ai.generate génère du texte en combinant les données fournies avec l'invite de l'utilisateur.

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

Par exemple, vous pouvez utiliser la requête suivante pour générer un résumé concis de chaque avis d'utilisateur.

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

Effectuer une génération de texte à l'aide de fonctions basées sur des tableaux

La requête suivante utilise UNNEST et ai.generate pour synthétiser efficacement plusieurs avis.

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;

Effectuer une génération de texte à l'aide de curseurs

Pour générer des résumés ou des traductions pour des millions de lignes sans rencontrer de goulots d'étranglement de mémoire, utilisez la génération par lot avec des curseurs.

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 $$;

Attribuer un score à vos résultats de requête

Si vous devez trier les résultats de requête à l'aide d'instructions personnalisées en langage naturel, utilisez l'opérateur ai.rank.

Effectuer une attribution de score à l'aide de fonctions scalaires

La fonction suivante vous permet de fournir une invite qui décrit les critères de classement et renvoie un score pour chaque élément.

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

Par exemple, la requête suivante obtient les 20 avis les plus positifs sur les restaurants, à l'aide des scores d'un 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;

Effectuer une attribution de score à l'aide de fonctions basées sur des tableaux

Cette fonction ai.rank vous permet d'attribuer un score et de classer les résultats de requête en fonction d'instructions personnalisées en langage naturel.

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

La requête suivante utilise UNNEST et ai.rank pour attribuer efficacement un score à plusieurs avis.

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;

Effectuer une attribution de score à l'aide de curseurs

Cette fonction permet d'attribuer un score à de grands ensembles de données sans atteindre les limites de mémoire.

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

L'exemple suivant montre comment attribuer un score à de grands volumes de texte en fonction de critères spécifiques en langage naturel.

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 $$;