SQL mit AlloyDB AI in natürlicher Sprache generieren

Schema und Tabellen für „nla_demo“ erstellen

In den folgenden Schritten erstellen Sie das nla_demo-Schema und die Tabellen im Schema. Sie füllen die Tabellen mit synthetischen Daten. Das bereitgestellte Schema und die Daten sind für die grundlegenden Abläufe eines Online-Einzelhandelsunternehmens konzipiert. Sie können auch für die Kundenverwaltung, Analysen, Marketing und betriebliche Aspekte verwendet werden.

Die Beispieldaten zeigen, wie Sie die AlloyDB-KI für die Entwicklung, Tests und Demonstrationen verwenden können, insbesondere für Funktionen wie Natural Language Interfaces.

1. Erstellen Sie das Schema mit der folgenden Abfrage:

   CREATE SCHEMA nla_demo;
   

2. Tabellen im Schema nla_demo erstellen. In der Tabelle addresses werden die Adressinformationen für Kunden und Bestellungen gespeichert.

   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. Erstellen Sie die Tabelle customers mit der folgenden Abfrage. In dieser Tabelle werden Kundeninformationen wie die Kundennummer, der Name, Kontaktdaten, die Adresse, das Geburtsdatum und die Erstellungszeit des Datensatzes gespeichert.

   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. Erstellen Sie die Tabelle categories, in der Produktkategorien gespeichert werden.

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

5. Erstellen Sie die Tabelle products. In dieser Tabelle werden Produktinformationen wie die Produkt-ID, der Name, die Beschreibung, die Marke, die Kategorieverknüpfung und die Erstellungszeit des Datensatzes gespeichert.

   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. Erstellen Sie die Tabelle orders. In dieser Tabelle werden Informationen zu Kundenbestellungen gespeichert, einschließlich Kunde, Datum, Gesamtbetrag, Versand- und Rechnungsadresse sowie Bestellstatus.

   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. Erstellen Sie die Tabelle order_items. In dieser Tabelle werden die einzelnen Artikel in einer Bestellung erfasst, Verknüpfungen zur Bestellung und zur Produktvariante erstellt sowie die Stückzahl und der Preis angegeben.

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

Tabellen im Schema „nla_demo“ befüllen

1. Führen Sie die folgende Abfrage aus, um die Tabelle addresses zu befüllen:

   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. Füllen Sie die Tabelle customers aus.

   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. Füllen Sie die Tabelle categories aus.

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

4. Füllen Sie die Tabelle products aus.

   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. Füllen Sie die Tabelle orders aus.

   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. Füllen Sie die Tabelle order_items aus.

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

Konfiguration für natürliche Sprache erstellen

Wenn Sie die natürliche Sprache von AlloyDB AI verwenden möchten, muss der Vertex AI-Endpunkt konfiguriert sein. Anschließend erstellen Sie eine Konfiguration und registrieren ein Schema. g_alloydb_ai_nl.g_create_configuration erstellt das Modell.

1. Erstellen Sie eine Natural Language-Konfiguration.

   SELECT alloydb_ai_nl.g_create_configuration( 'nla_demo_cfg' );
   

2. Registriere Tabellen in der nla_demo_cfg-Konfiguration.

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

Kontext für Tabellen und Spalten erstellen und anwenden

Um präzise Antworten auf Fragen in natürlicher Sprache zu liefern, verwenden Sie die AlloyDB AI Natural Language API, um Kontext zu Tabellen, Ansichten und Spalten bereitzustellen. Mit der Funktion zur automatischen Kontextgenerierung der AlloyDB AI Natural Language API können Sie Kontext aus Tabellen und Spalten generieren und als COMMENTS an Tabellen, Ansichten und Spalten anhängen.

1. Führen Sie folgenden Befehl aus, um Schemakontexte für die Tabellen und ihre Spalten zu generieren, die in der nla_demo_cfg-Konfiguration registriert sind:

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

   Mit der vorherigen Abfrage wird der Kontext in der Ansicht alloydb_ai_nl.generated_schema_context_view eingefügt. Wenn Sie TRUE übergeben, wird der Kontext in dieser Ansicht aus früheren Ausführungen überschrieben.

2. Führen Sie die folgende Abfrage aus, um den generierten Kontext für die Tabelle nla_demo.products zu prüfen:

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

   Der resultierende Kontext sieht in etwa so aus:

   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. Führen Sie den folgenden Befehl aus, um den generierten Kontext für eine Spalte wie nla_demo.products.name zu prüfen:

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

   Die Ausgabe der Abfrage sieht in etwa so aus:

   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. Prüfen Sie den generierten Kontext in der Ansicht alloydb_ai_nl.generated_schema_context_view und aktualisieren Sie den Kontext, der überarbeitet werden muss.

   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. Wenden Sie den generierten Kontext an, der den entsprechenden Objekten zugeordnet wird:

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

   Die resultierenden Kontexteinträge in der alloydb_ai_nl.generated_schema_context_view-Ansicht werden auf die entsprechenden Schemaobjekte angewendet und die Kommentare überschrieben.

Wertindex erstellen

Die AlloyDB AI Natural Language API generiert mithilfe der Wertverknüpfung genaue SQL-Abfragen. Bei der Werteverknüpfung werden Wertbegriffe in natürlicher Sprache mit vorab registrierten Konzepttypen und Spaltennamen verknüpft, um die Frage in natürlicher Sprache zu ergänzen.

Die Frage „Wie viel kostet ein Hoodie?“ kann beispielsweise genauer beantwortet werden, wenn „Hoodie“ mit einem product_name-Konzept verknüpft ist, das mit dem nla_demo.products.name verknüpft ist.Hoodie Spalte.

1. Führen Sie die folgenden Abfragen aus, um den Konzepttyp product_name zu definieren und mit der Spalte nla_demo.products.name zu verknüpfen:

   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. Um zu prüfen, ob der Begriffstyp product_name der Liste der Begriffstypen hinzugefügt wurde, führen Sie die folgende Abfrage aus, um sicherzustellen, dass product_name im Ergebnis dieser Abfrage enthalten ist:

   SELECT alloydb_ai_nl.list_concept_types();
   

3. Führen Sie die folgende Abfrage aus, um zu prüfen, ob die Spalte nla_demo.products.name mit dem Konzepttyp product_name verknüpft ist:

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

4. Nachdem Sie die Konzepttypen definiert und Spalten mit ihnen verknüpft haben, erstellen Sie einen Werteindex.

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

Abfragevorlage definieren

Sie können Vorlagen definieren, um die Qualität der Antworten zu verbessern, die von der AlloyDB AI Natural Language API generiert werden.

1. Wenn Sie Beispielvorlagen für geschäftskritische Fragen und für Fragen bereitstellen möchten, bei denen eine hohe Genauigkeit erwartet wird, führen Sie die folgende Abfrage aus, um eine Vorlage hinzuzufügen:

   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. Wenn Sie eine Liste der hinzugefügten Vorlagen aufrufen möchten, stellen Sie eine Abfrage an den alloydb_ai_nl.template_store_view:

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

   Die folgende Ausgabe wird zurückgegeben:

   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.
   

   In dieser Vorlage ist der Wert für das psql-Attribut die parametrisierte SQL-Abfrage und der Wert für die Spalte pintent die parametrisierte Intent-Anweisung. Die id einer vor Kurzem hinzugefügten Vorlage kann sich je nach den zuvor hinzugefügten Vorlagen unterscheiden. Vorlagen werden verwendet, um Fragen möglichst genau zu beantworten.

SQL-Ergebnisse aus Fragen in natürlicher Sprache generieren

1. Wenn Sie die AlloyDB AI Natural Language API verwenden möchten, um SQL-Abfragen und Ergebnismengen zu generieren, führen Sie die folgende Abfrage aus:

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

   Die folgende Ausgabe wird zurückgegeben:

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

   Die JSON-Ausgabe ist eine SQL-Abfrage mit der Vorlage, die Sie unter Abfragevorlage definieren hinzugefügt haben.

2. Wenn Sie die AlloyDB AI Natural Language API verwenden möchten, um das Ergebnis einer Frage zu erhalten, führen Sie die folgende Abfrage aus:

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

   Die folgende Ausgabe wird zurückgegeben:

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