Générer du code SQL à l'aide du langage naturel d'AlloyDB AI

Créer le schéma et les tables nla_demo

Dans les étapes suivantes, vous allez créer le schéma nla_demo et les tables du schéma. Vous remplissez les tables avec des données synthétiques. Le schéma et les données fournis sont conçus pour prendre en charge les opérations fondamentales d'une entreprise de vente au détail en ligne, avec des applications potentielles s'étendant à la gestion des clients, aux analyses, au marketing et aux aspects opérationnels.

L'exemple de données montre comment vous pouvez utiliser le langage naturel de l'IA AlloyDB à des fins de développement, de test et de démonstration, en particulier pour des fonctionnalités telles que les interfaces de langage naturel.

1. Créez le schéma en exécutant la requête suivante:

   CREATE SCHEMA nla_demo;
   

2. Créez des tables dans le schéma nla_demo. La table addresses stocke les informations d'adresse des clients et des commandes.

   CREATE TABLE nla_demo.addresses (
       address_id      SERIAL         PRIMARY KEY,
       street_address  VARCHAR(255)   NOT NULL,
       city            VARCHAR(255)   NOT NULL,
       country         VARCHAR(255)
   );
   

3. Créez la table customers en exécutant la requête suivante. Cette table stocke les informations sur le client, y compris son ID, son nom, ses coordonnées, sa référence d'adresse, sa date de naissance et l'heure de création de l'enregistrement.

   CREATE TABLE nla_demo.customers (
       customer_id     SERIAL         PRIMARY KEY,
       first_name      VARCHAR(255)   NOT NULL,
       last_name       VARCHAR(255)   NOT NULL,
       email           VARCHAR(255)   UNIQUE NOT NULL,
       address_id      INTEGER        REFERENCES nla_demo.addresses(address_id),
       date_of_birth   DATE,
       created_at      TIMESTAMP      DEFAULT CURRENT_TIMESTAMP
   );
   

4. Créez la table categories, qui stocke les catégories de produits.

   CREATE TABLE nla_demo.categories (
       category_id     INTEGER        PRIMARY KEY,
       category_name   VARCHAR(255)   UNIQUE NOT NULL
   );
   

5. Créez la table products. Ce tableau stocke des informations sur les produits, telles que l'ID, le nom, la description, la marque, l'association à la catégorie et l'heure de création de l'enregistrement.

   CREATE TABLE nla_demo.products (
       product_id    INTEGER        PRIMARY KEY,
       name          VARCHAR(255)   NOT NULL,
       description   TEXT           DEFAULT 'Not available',
       brand_id      INTEGER,
       category_id   INTEGER        REFERENCES nla_demo.categories(category_id),
       created_at    TIMESTAMP      DEFAULT CURRENT_TIMESTAMP
   );
   

6. Créez la table orders. Ce tableau stocke des informations sur les commandes des clients, y compris le client, la date, le montant total, les adresses de livraison et de facturation, ainsi que l'état de la commande.

   CREATE TABLE nla_demo.orders (
       order_id            INTEGER        PRIMARY KEY,
       customer_id         INTEGER        REFERENCES nla_demo.customers(customer_id),
       order_date          TIMESTAMP      DEFAULT CURRENT_TIMESTAMP,
       total_amount        DECIMAL(10, 2) NOT NULL,
       shipping_address_id INTEGER        REFERENCES nla_demo.addresses(address_id),
       billing_address_id  INTEGER        REFERENCES nla_demo.addresses(address_id),
       order_status        VARCHAR(50)
   );
   

7. Créez la table order_items. Ce tableau enregistre les articles individuels d'une commande, crée des liens vers la commande et la variante de produit, et spécifie la quantité et le prix.

   CREATE TABLE nla_demo.order_items (
       order_item_id   SERIAL         PRIMARY KEY,
       order_id        INTEGER        REFERENCES nla_demo.orders(order_id),
       product_id      INTEGER        REFERENCES nla_demo.products(product_id),
       quantity        INTEGER        NOT NULL,
       price           DECIMAL(10, 2) NOT NULL
   );
   

Remplir les tables du schéma nla_demo

1. Renseignez la table addresses en exécutant la requête suivante:

   INSERT INTO nla_demo.addresses (street_address, city, country)
   VALUES
       ('1800 Amphibious Blvd', 'Mountain View', 'USA'),
       ('Avenida da Pastelaria, 1903', 'Lisbon', 'Portugal'),
       ('8 Rue du Nom Fictif 341', 'Paris', 'France');
   

2. Remplissez la table customers.

   INSERT INTO nla_demo.customers (first_name, last_name, email, address_id, date_of_birth)
   VALUES
       ('Alex', 'B.', 'alex.b@example.com', 1, '2003-02-20'),
       ('Amal', 'M.', 'amal.m@example.com', 2, '1998-11-08'),
       ('Dani', 'G.', 'dani.g@example.com', 3, '2002-07-25');
   

3. Remplissez la table categories.

   INSERT INTO nla_demo.categories (category_id, category_name)
   VALUES
       (1, 'Accessories'),
       (2, 'Apparel'),
       (3, 'Footwear'),
       (4, 'Swimwear');
   

4. Remplissez la table products.

   INSERT INTO nla_demo.products (product_id, brand_id, category_id, name)
   VALUES
       (1, 1, 2, 'Hoodie'),
       (2, 1, 3, 'Running Shoes'),
       (3, 2, 4, 'Swimsuit'),
       (4, 3, 1, 'Tote Bag');
   

5. Remplissez la table orders.

   INSERT INTO nla_demo.orders (order_id, customer_id, total_amount, shipping_address_id, billing_address_id, order_status)
   VALUES
       (1, 1, 99.99, 1, 1, 'Shipped'),
       (2, 1, 69.99, 1, 1, 'Delivered'),
       (3, 2, 20.99, 2, 2, 'Processing'),
       (4, 3, 79.99, 3, 3, 'Shipped');
   

6. Remplissez la table order_items.

   INSERT INTO nla_demo.order_items (order_id, product_id, quantity, price)
   VALUES
       (1, 1, 1, 79.99),
       (1, 3, 1, 20.00),
       (2, 4, 1, 69.99),
       (3, 3, 1, 20.00),
       (4, 2, 1, 79.99);
   

Créer une configuration en langage naturel

Pour utiliser le langage naturel de l'IA AlloyDB, assurez-vous que le point de terminaison Vertex AI est configuré. Vous créez ensuite une configuration et enregistrez un schéma. g_alloydb_ai_nl.g_create_configuration crée le modèle.

1. Créez une configuration en langage naturel.

   SELECT alloydb_ai_nl.g_create_configuration( 'nla_demo_cfg' );
   

2. Enregistrez les tables dans la configuration nla_demo_cfg.

   SELECT alloydb_ai_nl.g_manage_configuration(
       operation => 'register_table_view',
       configuration_id_in => 'nla_demo_cfg',
       table_views_in=>'{nla_demo.customers, nla_demo.addresses, nla_demo.products, nla_demo.categories, nla_demo.orders, nla_demo.order_items}'
   );
   

Créer et appliquer un contexte pour les tables et les colonnes

Pour fournir des réponses précises à des questions en langage naturel, vous utilisez l'API AlloyDB AI Natural Language pour fournir du contexte sur les tables, les vues et les colonnes. Vous pouvez utiliser la fonctionnalité de génération automatique de contexte de l'API AlloyDB AI Natural Language pour générer du contexte à partir de tables et de colonnes, et appliquer le contexte en tant que COMMENTS associé aux tables, aux vues et aux colonnes.

1. Pour générer des contextes de schéma pour les tables et leurs colonnes enregistrées dans la configuration nla_demo_cfg, exécutez la commande suivante:

   SELECT alloydb_ai_nl.generate_schema_context(
     'nla_demo_cfg',
     TRUE
   );
   

   La requête précédente renseigne la vue alloydb_ai_nl.generated_schema_context_view avec du contexte. Transmettre TRUE écrase le contexte de cette vue à partir des exécutions précédentes.

2. Pour vérifier le contexte généré pour la table nla_demo.products, exécutez la requête suivante:

   SELECT object_context
   FROM alloydb_ai_nl.generated_schema_context_view
   WHERE schema_object = 'nla_demo.products';
   

   Le contexte obtenu est semblable à celui-ci:

   The products table stores information about products, including their name,
   a brief description, the brand they belong to (referenced by brand_id),
   and the category they fall under (referenced by category_id). Each product
   has a unique identifier (product_id) and a timestamp indicating its creation
   time (created_at).
   

3. Pour vérifier le contexte produit pour une colonne, telle que nla_demo.products.name, exécutez la commande suivante:

   SELECT object_context
   FROM alloydb_ai_nl.generated_schema_context_view
   WHERE schema_object = 'nla_demo.products.name';
   

   Le résultat de la requête se présente comme suit:

   The name column in the nla_demo.products table contains the specific
   name or title of each product. This is a short, descriptive text string
   that clearly identifies the product, like "Hoodie," "Tote Bag,"
   "Running Shoes," or "Swimsuit." It helps distinguish individual products
   within the broader context of their brand and category. The name column
   specifies the exact product. This column is essential for users and
   systems to identify and refer to specific products within the database.
   

4. Examinez le contexte généré dans la vue alloydb_ai_nl.generated_schema_context_view, puis mettez à jour le contexte qui doit être révisé.

   SELECT alloydb_ai_nl.update_generated_relation_context(
     'nla_demo.products',
     'The "nla_demo.products" table stores product details such as ID, name, description, brand, category linkage, and record creation time.'
   );
   
   SELECT alloydb_ai_nl.update_generated_column_context(
     'nla_demo.products.name',
     'The "name" column in the "nla_demo.products" table contains the specific name or title of each product.'
   );
   

5. Appliquez le contexte généré qui sera associé aux objets correspondants:

   SELECT alloydb_ai_nl.apply_generated_relation_context(
     'nla_demo.products', true
   );
   
   SELECT alloydb_ai_nl.apply_generated_column_context(
     'nla_demo.products.name',
     true
   );
   

   Les entrées de contexte générées dans la vue alloydb_ai_nl.generated_schema_context_view sont appliquées aux objets de schéma correspondants, et les commentaires sont écrasés.

Créer l'indice de valeur

L'API AlloyDB AI en langage naturel produit des requêtes SQL précises à l'aide de l'association de valeurs. L'association de valeurs associe des expressions de valeur dans des instructions en langage naturel à des types de concepts et des noms de colonnes préenregistrés, ce qui peut enrichir la question en langage naturel.

Par exemple, la question "Donnez-moi le prix d'un sweat à capuche" peut être répondue plus précisément si Hoodie est associé à un concept product_name, qui est associé à nla_demo.products.name. colonne.

1. Pour définir le type de concept product_name et l'associer à la colonne nla_demo.products.name, exécutez les requêtes suivantes:

   SELECT alloydb_ai_nl.add_concept_type(
       concept_type_in => 'product_name',
       match_function_in => 'alloydb_ai_nl.get_concept_and_value_generic_entity_name',
       additional_info_in => '{
         "description": "Concept type for product name.",
         "examples": "SELECT alloydb_ai_nl.get_concept_and_value_generic_entity_name(''Camera'')" }'::jsonb
   );
   SELECT alloydb_ai_nl.associate_concept_type(
       'nla_demo.products.name',
       'product_name'
   );
   

2. Pour vérifier que le type de concept product_name est ajouté à la liste des types de concepts, exécutez la requête suivante pour vous assurer que product_name est inclus dans le résultat de cette requête:

   SELECT alloydb_ai_nl.list_concept_types();
   

3. Pour vérifier que la colonne nla_demo.products.name est associée au type de concept product_name, exécutez la requête suivante:

   SELECT *
   FROM alloydb_ai_nl.value_index_columns
   WHERE column_names = 'nla_demo.products.name';
   

4. Après avoir défini les types de concepts et associé des colonnes à ceux-ci, créez un indice de valeur.

   SELECT alloydb_ai_nl.create_value_index('nla_demo_cfg');
   SELECT alloydb_ai_nl.refresh_value_index('nla_demo_cfg');
   

Définir un modèle de requête

Vous pouvez définir des modèles pour améliorer la qualité des réponses produites par l'API de langage naturel d'IA AlloyDB.

1. Pour fournir des exemples de modèles pour les questions critiques pour l'entreprise et pour fournir des questions anticipées pour lesquelles une précision élevée est attendue, exécutez la requête suivante pour ajouter un modèle:

   SELECT alloydb_ai_nl.add_template(
       nl_config_id => 'nla_demo_cfg',
       intent => 'List the first names and the last names of all customers who ordered Swimsuit.',
       sql => 'SELECT c.first_name, c.last_name FROM nla_demo.Customers c JOIN nla_demo.orders o ON c.customer_id = o.customer_id JOIN nla_demo.order_items oi ON o.order_id = oi.order_id JOIN nla_demo.products p ON oi.product_id = p.product_id  AND p.name = ''Swimsuit''',
       sql_explanation => 'To answer this question, JOIN `nla_demo.Customers` with `nla_demo.orders` on having the same `customer_id`, and JOIN the result with nla_demo.order_items on having the same `order_id`. Then JOIN the result with `nla_demo.products` on having the same `product_id`, and filter rwos that with p.name = ''Swimsuit''. Return the `first_name` and the `last_name` of the customers with matching records.',
       check_intent => TRUE
   );
   

2. Pour afficher la liste des modèles ajoutés, interrogez alloydb_ai_nl.template_store_view:

   SELECT nl, sql, intent, psql, pintent
   FROM alloydb_ai_nl.template_store_view
   WHERE config = 'nla_demo_cfg';
   

   Le résultat suivant s'affiche :

   nl      | List the first names and the last names of all customers who ordered Swimsuit.
   sql     | SELECT c.first_name, c.last_name
           | FROM nla_demo.Customers c
           | JOIN nla_demo.orders o ON c.customer_id = o.customer_id
           | JOIN nla_demo.order_items oi ON o.order_id = oi.order_id
           | JOIN nla_demo.products p ON oi.product_id = p.product_id
           | AND p.name = 'Swimsuit'
   intent  | List the first names and the last names of all customers who ordered
           | Swimsuit.
   psql    | SELECT c.first_name, c.last_name
           | FROM nla_demo.Customers c JOIN nla_demo.orders o
           | ON c.customer_id = o.customer_id 
           | JOIN nla_demo.order_items oi ON o.order_id = oi.order_id
           | JOIN nla_demo.products p ON oi.product_id = p.product_id
           | AND p.name = $1
   pintent | List the first names and the last names of all customers who ordered
           | $1.
   

   Dans ce modèle, la valeur correspondant à l'attribut psql est la requête SQL paramétrée, et la valeur de la colonne pintent est l'instruction d'intent paramétrée. L'id d'un modèle récemment ajouté peut être différent, en fonction des modèles ajoutés précédemment. Les modèles sont utilisés pour fournir des réponses très précises aux questions.

Générer des résultats SQL à partir de questions en langage naturel

1. Pour utiliser l'API AlloyDB AI Natural Language pour générer des requêtes SQL et des ensembles de résultats, exécutez la requête suivante:

   SELECT
       alloydb_ai_nl.get_sql(
           'nla_demo_cfg',
           'Find the customers who purchased Tote Bag.'
       ) ->> 'sql';
   

   Le résultat suivant s'affiche :

   SELECT DISTINCT "c"."first_name", "c"."last_name"
   FROM "nla_demo"."customers" AS "c"
   JOIN "nla_demo"."orders" AS "o" ON "c"."customer_id" = "o"."customer_id"
   JOIN "nla_demo"."order_items" AS "oi" ON "o"."order_id" = "oi"."order_id"
   JOIN "nla_demo"."products" AS "p" ON "oi"."product_id" = "p"."product_id"
   WHERE "p"."name" = 'Tote Bag';
   

   La sortie JSON est une requête SQL utilisant le modèle que vous avez ajouté dans Définir un modèle de requête.

2. Pour utiliser l'API AlloyDB AI Natural Language afin de générer le résultat d'une question, exécutez la requête suivante:

   SELECT
   alloydb_ai_nl.execute_nl_query(
       'Find the last name of the customers who live in Lisbon.',
       'nla_demo_cfg'
   );
   

   Le résultat suivant s'affiche :

   execute_nl_query     
   --------------------------
   {"last_name":"M."}