Extraire les données structurées

La fonction ai.extract est un outil d'IA AlloyDB intégré qui extrait des détails structurés spécifiés à partir d'un texte non structuré en fonction d'un schéma fourni. En intégrant cette fonctionnalité directement dans la base de données, AlloyDB pour PostgreSQL vous permet de traiter des données non structurées sans créer de pipelines ETL (extraction, transformation et chargement) complexes ni d'intégrations de services externes.

La fonction d'extraction de données offre les avantages suivants :

  • Évolutivité : compatible avec le traitement par lot intelligent pour les fonctions d'IA (également appelé accélération des fonctions d'IA), une fonctionnalité d'optimisation automatique de l'exécution des requêtes dans AlloyDB AI qui regroupe de manière transparente les appels de fonctions d'IA scalaires individuels, ligne par ligne, en requêtes de modèle par lot en arrière-plan lors de l'exécution des requêtes. Il est également compatible avec le traitement basé sur des tableaux et des curseurs pour traiter efficacement des milliers de lignes.
  • Abstraction : fournit une abstraction de haut niveau qui gère automatiquement l'appel du modèle et la préparation des données.

La fonction d'extraction de données d'AlloyDB AI est compatible avec plusieurs cas d'utilisation, y compris les suivants :

  • Santé : analyser des notes médicales en texte libre pour les convertir en champs de format structuré tels que les noms des patients, les symptômes et les médicaments.
  • Immobilier : transformez des descriptions de biens non structurées en points de données spécifiques, comme le type de bien et le nombre de chambres.
  • Technologie juridique : identifier et extraire automatiquement des termes essentiels tels que la loi applicable et les plafonds de responsabilité dans des documents juridiques longs.
  • Opérations financières : traitez le texte transcrit des factures pour extraire avec précision les métadonnées et les montants totaux dans un format cohérent.

Avant de commencer

Assurez-vous de remplir les conditions suivantes avant d'utiliser la fonction ai.extract :

  • Version de PostgreSQL : la fonction ai.extract est compatible avec PostgreSQL 18 et versions ultérieures. Assurez-vous que votre cluster AlloyDB exécute PostgreSQL 18 ou une version ultérieure. Pour en savoir plus, consultez la section Versions de base de données compatibles.
  • Version de l'extension : assurez-vous que la dernière version de l'extension google_ml_integration (version 1.6.1 ou ultérieure) est installée et que la fonctionnalité d'aperçu est activée.

Activer l'extension

Assurez-vous que la dernière version de l'extension google_ml_integration (version 1.6.1 ou ultérieure) est installée et que la fonctionnalité d'aperçu est activée.

Pour activer les options google_ml_integration.enable_ai_query_engine et google_ml_integration.enable_preview_ai_functions dans AlloyDB, utilisez la commande SET. Ces options contrôlent l'accès au moteur de requêtes d'IA et aux fonctions d'IA en preview telles que ai.extract. La valeur par défaut de ces options est off.

  1. Assurez-vous que votre extension google_ml_integration est de version 1.6.1 ou ultérieure. Vérifiez la version en exécutant la commande suivante :

    SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

  2. Pour activer les options pour votre session actuelle, l'intégralité de la base de données ou toutes les bases de données d'une instance, effectuez une ou plusieurs des tâches suivantes :

    • Pour activer les options pour votre session actuelle, exécutez la commande suivante :

      SET google_ml_integration.enable_ai_query_engine = 'on';
SET google_ml_integration.enable_preview_ai_functions = 'on';

      Cette modification ne nécessite pas de redémarrer la base de données.

    • Pour activer les options de manière persistante pour une base de données spécifique, exécutez la commande suivante :

      ALTER DATABASE DATABASE_NAME SET google_ml_integration.enable_ai_query_engine = 'on';
ALTER DATABASE DATABASE_NAME SET google_ml_integration.enable_preview_ai_functions = 'on';

    • Pour activer les indicateurs de base de données pour toutes les bases de données d'une instance, définissez les indicateurs de base de données google_ml_integration.enable_ai_query_engine et google_ml_integration.enable_preview_ai_functions sur on à l'aide de la commande gcloud alloydb instances update :

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

      Pour en savoir plus, consultez la page Configurer des indicateurs de base de données.

Activer le traitement par lot intelligent pour les fonctions AI

Pour accélérer l'exécution totale des requêtes lorsque vous exécutez des ai.extract scalaires sur plusieurs lignes, activez le traitement par lot intelligent pour les fonctions d'IA en définissant l'indicateur de base de données google_ml_integration.enable_ai_function_acceleration sur on :

SET google_ml_integration.enable_ai_function_acceleration = 'on';

Lorsque cette option est activée, AlloyDB regroupe automatiquement les appels scalaires ai.extract individuels en lots intelligents en arrière-plan.

Créer un exemple de table

Pour suivre les exemples de fonction d'extraction de ce document, créez une table et renseignez-la avec les exemples de données suivants.

CREATE TABLE IF NOT EXISTS sales_leads (
    lead_id INT PRIMARY KEY,
    raw_transcript TEXT,
    lead_status VARCHAR(20)
);

INSERT INTO sales_leads (lead_id, raw_transcript, lead_status) VALUES
(1, 'Spoke with Alex R., Director of IT at Example Organization. They are looking to upgrade their cloud storage.', 'new'),
(2, 'Call with Kai L., Senior DevOps Engineer at Example Organization. They are currently using MySQL and Redis. Interested in automating enterprise database backups, cross-region replication, and automated scaling.', 'new'),
(3, 'Meeting with Taylor K., VP of Engineering at Example Organization. They need a scalable managed PostgreSQL database for their analytics platform. Budget is approved for Q3 launch.', 'new');

Extraire des données structurées d'une seule chaîne

Pour extraire des détails structurés d'une seule entrée de texte, utilisez la version scalaire de ai.extract. Pour en savoir plus, consultez la documentation de référence sur ai.extract.

SELECT ai.extract(
  input => 'TEXT_CONTENT',
  output_schema => 'OUTPUT_SCHEMA',
  model_id => 'MODEL_ID' -- Optional. The default value is gemini-3.5-flash-lite.
);

Extraire des données d'une table

L'exemple suivant extrait des informations structurées de la colonne de table raw_transcript :

SELECT
  lead_id,
  ai.extract(
    input => raw_transcript,
    output_schema => '{"contact_name": {"type": "string"}, "company_name": {"type": "string"}, "job_title": {"type": "string"}}'
   ) AS extracted_info
FROM
  sales_leads
WHERE
  lead_status = 'new';

Extraire des champs en fonction du schéma JSON fourni

L'exemple suivant extrait des champs spécifiques du texte d'entrée en fonction du schéma JSON fourni :

SELECT ai.extract(
  input => 'Spoke with Alex R., Director of IT at Example Organization. They are looking to upgrade their cloud storage.',
  output_schema => '{"contact_name": {"type": "string"}, "job_title": {"type": "string"}, "company_name": {"type": "string"}, "need": {"type": "string"}}'
);

Voici un exemple de résultat :

{
  "contact_name": "Alex R.",
  "job_title": "Director of IT",
  "company_name": "Example Organization",
  "need": "upgrade cloud storage"
}

Extraire des champs à partir d'un prompt en langage naturel

L'exemple suivant extrait les détails d'un lead commercial à l'aide d'un schéma de texte descriptif :

SELECT ai.extract(
  input => 'Meeting with Taylor K., VP of Engineering at Example Organization. They need a scalable managed PostgreSQL database for their analytics platform. Budget is approved for Q3 launch.',
  output_schema => 'Extract the following details as a clean, line-by-line list: Contact Name, Job Title, Company Name, Technical Requirement, Target Use Case, and Timeline.'
);

Voici un exemple de résultat :

Contact Name: Taylor K.
Job Title: VP of Engineering
Company Name: Example Organization
Technical Requirement: Scalable managed PostgreSQL database
Target Use Case: Analytics platform
Timeline: Q3 launch

Extraire des champs avec des tableaux

L'exemple suivant extrait plusieurs valeurs dans des champs de tableau en fonction du schéma de sortie :

SELECT ai.extract(
  input => 'Call with Kai L., Senior DevOps Engineer at Example Organization. They are currently using MySQL and Redis. Interested in automating enterprise database backups, cross-region replication, and automated scaling.',
  output_schema => '{"contact_name": {"type": "string"}, "company_name": {"type": "string"}, "current_technologies": {"type": "array", "items": {"type": "string"}}, "interested_features": {"type": "array", "items": {"type": "string"}}}'
);

Voici un exemple de résultat :

{
  "contact_name": "Kai L.",
  "company_name": "Example Organization",
  "current_technologies": ["MySQL", "Redis"],
  "interested_features": ["enterprise database backups", "cross-region replication", "automated scaling"]
}

Extraire des données structurées par lot

Pour accélérer l'exécution totale des requêtes sur des ensembles de données plus volumineux, utilisez la version de la fonction basée sur un tableau pour traiter plusieurs entrées en un seul appel. Pour en savoir plus, consultez la documentation de référence sur ai.extract.

SELECT ai.extract(
  inputs => TEXT[],
  output_schema => TEXT,
  batch_size => INT, -- Optional. The default value is 10.
  model_id => VARCHAR(100) -- Optional. The default value is gemini-3.5-flash-lite.
);

L'exemple suivant extrait des détails structurés de plusieurs enregistrements :

SELECT
  ai.extract(
    inputs => array_agg(raw_transcript ORDER BY lead_id),
    output_schema => '{"contact_name": {"type": "string"}, "company_name": {"type": "string"}, "job_title": {"type": "string"}}',
    batch_size => 4
  )
FROM sales_leads;

Extraire des données structurées à l'aide de curseurs

La fonction basée sur un curseur est bien adaptée au traitement de grands ensembles de données, car elle permet au système de diffuser des données via le modèle d'IA par lots gérables sans nécessiter le chargement de toutes les données en mémoire en même temps. Pour en savoir plus, consultez la documentation de référence sur ai.extract.

La signature de la fonction pour la version basée sur un curseur de ai.extract est la suivante :

CREATE OR REPLACE FUNCTION ai.extract(
    input_cursor REFCURSOR,
    output_schema TEXT,
    batch_size INT DEFAULT NULL,
    model_id VARCHAR(100) DEFAULT NULL)
  RETURNS REFCURSOR

L'exemple suivant montre comment transmettre des données à la fonction ai.extract ligne par ligne à l'aide d'un curseur :

DO $$
DECLARE
    input_cur REFCURSOR;
    output_cur REFCURSOR;
    result_record RECORD;
BEGIN
    -- Open the input cursor with the data to process
    OPEN input_cur FOR
        SELECT raw_transcript
        FROM sales_leads
        WHERE lead_status = 'new';

    -- Call ai.extract passing the input cursor
    output_cur := ai.extract(
        input_cursor => input_cur,
        output_schema => '{"contact_name": "string", "company_name": "string", "job_title": "string"}',
        batch_size => 10
    );

    -- Loop through the output cursor (columns: input TEXT, output TEXT)
    LOOP
        FETCH output_cur INTO result_record;
        EXIT WHEN NOT FOUND;

        RAISE NOTICE 'Extracted Data: %', result_record.output;
    END LOOP;

    CLOSE input_cur;
    CLOSE output_cur;
END $$;

Étapes suivantes