Usa el lenguaje natural de AlloyDB AI para generar SQL

Crea el esquema y las tablas de nla_demo

En los siguientes pasos, crearás el esquema nla_demo y las tablas en él. Completas las tablas con datos sintéticos. El esquema y los datos proporcionados están diseñados para respaldar las operaciones fundamentales de una empresa de venta minorista en línea, con posibles aplicaciones que se extienden a la administración de clientes, el análisis, el marketing y los aspectos operativos.

Los datos de muestra muestran cómo puedes usar el lenguaje natural de la IA de AlloyDB para fines de desarrollo, pruebas y demostración, en particular para funciones como las interfaces de lenguaje natural.

1. Ejecuta la siguiente consulta para crear el esquema:

   CREATE SCHEMA nla_demo;
   

2. Crea tablas en el esquema nla_demo. La tabla addresses almacena la información de la dirección de los clientes y los pedidos.

   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. Ejecuta la siguiente consulta para crear la tabla customers. En esta tabla, se almacena la información del cliente, incluido el ID, el nombre, los detalles de contacto, la referencia de la dirección, la fecha de nacimiento y la hora de creación del registro.

   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. Crea la tabla categories, que almacena las categorías de productos.

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

5. Crea la tabla products. En esta tabla, se almacena información del producto, como el ID, el nombre, la descripción, la marca, la vinculación de categorías y la hora de creación del registro.

   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. Crea la tabla orders. En esta tabla, se almacena información sobre los pedidos de los clientes, como el cliente, la fecha, el importe total, las direcciones de envío y facturación, y el estado del pedido.

   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. Crea la tabla order_items. En esta tabla, se registran los artículos individuales de un pedido, se vinculan al pedido y a la variante del producto, y se especifican la cantidad y el precio.

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

Cómo propagar tablas en el esquema nla_demo

1. Ejecuta la siguiente consulta para propagar la tabla addresses:

   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. Propaga la tabla 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. Propaga la tabla categories.

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

4. Propaga la tabla 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. Propaga la tabla 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. Propaga la tabla 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);
   

Crea una configuración de lenguaje natural

Para usar el lenguaje natural de IA de AlloyDB, asegúrate de que el extremo de Vertex AI esté configurado. Luego, creas una configuración y registras un esquema. g_alloydb_ai_nl.g_create_configuration crea el modelo.

1. Crea una configuración de lenguaje natural.

   SELECT alloydb_ai_nl.g_create_configuration( 'nla_demo_cfg' );
   

2. Registra tablas en la configuración de 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}'
   );
   

Crea y aplica contexto para tablas y columnas

Para proporcionar respuestas precisas a preguntas en lenguaje natural, usa la API de lenguaje natural de IA de AlloyDB para proporcionar contexto sobre las tablas, las vistas y las columnas. Puedes usar la función de generación de contexto automatizada de la API de lenguaje natural de IA de AlloyDB para producir contexto a partir de tablas y columnas, y aplicarlo como COMMENTS adjunto a tablas, vistas y columnas.

1. Para generar contextos de esquemas para las tablas y sus columnas que están registrados en la configuración de nla_demo_cfg, ejecuta lo siguiente:

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

   La consulta anterior propaga la vista alloydb_ai_nl.generated_schema_context_view con contexto. Si pasas TRUE, se reemplazará el contexto de esta vista de ejecuciones anteriores.

2. Para verificar el contexto generado para la tabla nla_demo.products, ejecuta la siguiente consulta:

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

   El contexto resultante es similar al siguiente:

   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. Para verificar el contexto producido para una columna, como nla_demo.products.name, ejecuta lo siguiente:

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

   El resultado de la consulta es similar al siguiente:

   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. Revisa el contexto generado en la vista alloydb_ai_nl.generated_schema_context_view y actualiza el contexto que necesita revisión.

   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. Aplica el contexto generado que se adjuntará a los objetos correspondientes:

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

   Las entradas de contexto resultantes en la vista alloydb_ai_nl.generated_schema_context_view se aplican a los objetos de esquema correspondientes, y los comentarios se reemplazan.

Cómo construir el índice de valor

La API de lenguaje natural de AlloyDB AI produce consultas SQL precisas mediante la vinculación de valores. La vinculación de valores asocia frases de valor en las afirmaciones de lenguaje natural con tipos de conceptos y nombres de columnas registrados previamente que pueden enriquecer la pregunta en lenguaje natural.

Por ejemplo, la pregunta "Dime el precio de una sudadera con capucha" se puede responder con mayor precisión si Hoodie está asociado con un concepto product_name, que está asociado con nla_demo.products.name. columna.

1. Para definir el tipo de concepto product_name y asociarlo con la columna nla_demo.products.name, ejecuta las siguientes consultas:

   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. Para verificar que el tipo de concepto product_name se agregue a la lista de tipos de conceptos, ejecuta la siguiente consulta para asegurarte de que product_name se incluya en el resultado de esta consulta:

   SELECT alloydb_ai_nl.list_concept_types();
   

3. Para verificar que la columna nla_demo.products.name esté asociada con el tipo de concepto product_name, ejecuta la siguiente consulta:

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

4. Después de definir los tipos de conceptos y asociar columnas con ellos, crea un índice de valores.

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

Define una plantilla de consulta

Puedes definir plantillas para mejorar la calidad de las respuestas que produce la API de lenguaje natural de IA de AlloyDB.

1. Para proporcionar plantillas de ejemplo para preguntas fundamentales para la empresa y para proporcionar preguntas anticipadas para las que se espera una alta precisión, ejecuta la siguiente consulta para agregar una plantilla:

   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. Para ver la lista de plantillas agregadas, consulta alloydb_ai_nl.template_store_view:

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

   Se mostrará el siguiente resultado:

   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.
   

   En esta plantilla, el valor correspondiente al atributo psql es la consulta de SQL parametrizada, y el valor de la columna pintent es la sentencia de intent parametrizada. El id de una plantilla agregada recientemente puede ser diferente, según las plantillas que se agregaron antes. Las plantillas se usan para proporcionar respuestas muy precisas a las preguntas.

Genera resultados de SQL a partir de preguntas en lenguaje natural

1. Para usar la API de lenguaje natural de IA de AlloyDB y generar consultas y conjuntos de resultados de SQL, ejecuta la siguiente consulta:

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

   Se mostrará el siguiente resultado:

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

   El resultado JSON es una consulta de SQL que usa la plantilla que agregaste en Define una plantilla de consulta.

2. Para usar la API de lenguaje natural de IA de AlloyDB y generar el resultado de una pregunta, ejecuta la siguiente consulta:

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

   Se mostrará el siguiente resultado:

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