Auf dieser Seite wird die AlloyDB Omni-Version 18.1.1 mit der Bereitstellungsoption RPM dokumentiert. Wählen Sie eine andere Bereitstellungsoption aus.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

SQL mit AlloyDB AI in natürlicher Sprache generieren

Wählen Sie eine Dokumentenversion aus:

In dieser Anleitung wird beschrieben, wie Sie die AlloyDB AI Natural Language API einrichten und verwenden. Sie erfahren, wie Sie die AlloyDB AI Natural Language API so konfigurieren, dass Sie Fragen in natürlicher Sprache stellen und SQL-Abfragen und -Ergebnisse erhalten können.

Die Beispiele in dieser Anleitung dienen nur zu Demonstrationszwecken.

Ziele

Tabellen erstellen und füllen sowie die automatische Generierung verwenden, um Kontext zu erstellen.
Einen Werteindex für die Spalten in der Datenbank erstellen.
Ein Konfigurationsobjekt für natürliche Sprache (nl_config) erstellen und konfigurieren.
Vorlagen für eine Beispielabfrage in der Anwendung erstellen.
Mit der Funktion get_sql() eine SQL-Abfrage erstellen, die eine Frage beantwortet.
Mit der Funktion execute_nl_query() eine Frage in natürlicher Sprache mithilfe der Datenbank beantworten.

Hinweis

Sie müssen die folgenden Voraussetzungen erfüllen.

Abrechnung aktivieren

Wählen Sie in der Google Cloud console ein Projekt aus.

Zur Projektauswahl
Die Abrechnung für Ihr Google Cloud Projekt muss aktiviert sein.

Datenbank installieren und eine Verbindung herstellen

Erforderliche Erweiterung aktivieren und installieren

Wenn Sie die Erweiterung alloydb_ai_nl installieren und verwenden möchten, müssen Sie sie zuerst mit dem folgenden PostgreSQL-Befehl aktivieren:

ALTER SYSTEM SET alloydb_ai_nl.enabled=on;
SELECT pg_reload_conf();

Führen Sie die folgende Abfrage aus, um die Erweiterung alloydb_ai_nl zu installieren, die die AlloyDB AI Natural Language Support API ist:

CREATE EXTENSION alloydb_ai_nl cascade;

Erweiterung `alloydb_ai_nl` aktualisieren

Wenn Sie die Erweiterung bereits installiert haben, führen Sie die folgende Anweisung aus, um sie auf die neueste Version zu aktualisieren:

ALTER EXTENSION alloydb_ai_nl UPDATE;

Schema und Tabellen `nla_demo` erstellen

Erstellen Sie jetzt das Schema nla_demo und die Tabellen im Schema und füllen Sie die Tabellen mit synthetischen Daten. Das bereitgestellte Schema und die Daten sind so konzipiert, dass sie die grundlegenden Abläufe eines Online-Einzelhandelsunternehmens unterstützen. Die potenziellen Anwendungen erstrecken sich auf Kundenmanagement, Analysen, Marketing und betriebliche Aspekte.

Die Beispieldaten zeigen, wie Sie AlloyDB AI Natural Language für Entwicklungs-, Test- und Demonstrationszwecke verwenden können, insbesondere für Funktionen wie Schnittstellen für natürliche Sprache.

Schema erstellen.
```
CREATE SCHEMA nla_demo;
```

Tabellen im Schema nla_demo erstellen. In der Tabelle addresses werden die Adressinformationen für die Tabellen customers und orders 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)
);

Tabelle customers erstellen. In dieser Tabelle werden Kundendaten gespeichert, einschließlich der Kunden-ID, des Namens, der Kontaktdaten, der Adressreferenz, des Geburtsdatums und der Erstellungszeit des Datensatzes.

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

Tabelle categories erstellen, in der Produktkategorien gespeichert werden.

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

Tabelle brands erstellen, in der Markennamen gespeichert werden.

CREATE TABLE nla_demo.brands (
    brand_id      INTEGER        PRIMARY KEY,
    brand_name    VARCHAR(255)   NOT NULL
);

Tabelle products erstellen, in der Produktinformationen wie Produkt-ID, Name, Beschreibung, Marke, Kategorieverknüpfung und Erstellungszeit des Datensatzes gespeichert werden.

CREATE TABLE nla_demo.products (
    product_id    INTEGER        PRIMARY KEY,
    name          VARCHAR(255)   NOT NULL,
    description   TEXT           DEFAULT 'Not available',
    brand_id      INTEGER        REFERENCES nla_demo.brands(brand_id),
    category_id   INTEGER        REFERENCES nla_demo.categories(category_id),
    created_at    TIMESTAMP      DEFAULT CURRENT_TIMESTAMP,
    price         DECIMAL(10, 2),
    description_embedding        VECTOR(768)
);

Tabelle orders erstellen. In dieser Tabelle werden Informationen zu Kundenbestellungen gespeichert, einschließlich Kunde, Datum, Gesamtbetrag, Liefer- 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)
);

Tabelle order_items erstellen. In dieser Tabelle werden einzelne Artikel in einer Bestellung erfasst, Links zur Bestell- und Produktvariante erstellt und Menge und 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` füllen

Füllen Sie die Tabelle addresses mit der folgenden Abfrage:

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

Tabelle customers füllen.

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

Tabelle categories füllen.

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

Tabelle brands füllen.

INSERT INTO nla_demo.brands (brand_id, brand_name)
VALUES
    (1, 'CymbalPrime'),
    (2, 'CymbalPro'),
    (3, 'CymbalSports');

Tabelle products füllen.

INSERT INTO nla_demo.products (product_id, brand_id, category_id, name, description, price)
VALUES
    (1, 1, 2, 'Hoodie', 'A comfortable, casual sweatshirt with an attached hood.', 79.99),
    (2, 1, 3, 'Running Shoes', 'Lightweight, cushioned footwear designed for the impact of running.', 99.99),
    (3, 2, 4, 'Swimsuit', 'A garment designed for swimming or other water activities.', 20.00),
    (4, 3, 1, 'Tote Bag', 'A large, unfastened bag with two parallel handles.', 69.99),
    (5, 3, 3, 'CymbalShoe', 'Footwear from Cymbal, designed for your life''s rhythm.', 89.99);

UPDATE nla_demo.products SET description_embedding = embedding('text-embedding-004', description);

Tabelle orders füllen.

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

Tabelle order_items füllen.

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

Konfiguration für natürliche Sprache erstellen

Wenn Sie AlloyDB AI Natural Language verwenden möchten, muss AlloyDB AI für AlloyDB Omniinstalliert sein. Erstellen Sie dann eine Konfiguration und registrieren Sie ein Schema. g_alloydb_ai_nl.g_create_configuration erstellt das Modell.

Konfiguration für natürliche Sprache erstellen.

SELECT alloydb_ai_nl.g_create_configuration( 'nla_demo_cfg' );

Tabellen in der Konfiguration nla_demo_cfg registrieren.

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.brands, nla_demo.products, nla_demo.categories, nla_demo.orders, nla_demo.order_items}'
);

Kontext für Tabellen und Spalten erstellen und anwenden

Um genaue Antworten auf Fragen in natürlicher Sprache zu geben, verwenden Sie die AlloyDB AI Natural Language API, um Kontext zu Tabellen, Ansichten und Spalten bereitzustellen. Sie können die Funktion zur automatischen Kontextgenerierung der AlloyDB AI Natural Language API verwenden, um Kontext aus Tabellen und Spalten zu erstellen und den Kontext als COMMENTS an Tabellen, Ansichten und Spalten anzuhängen.

Führen Sie Folgendes aus, um Schemakontexte für die Tabellen und ihre Spalten zu generieren, die in der Konfiguration nla_demo_cfg registriert sind:
```
SELECT alloydb_ai_nl.generate_schema_context(
  'nla_demo_cfg',
  TRUE
);
```
Mit der vorherigen Abfrage wird die Ansicht alloydb_ai_nl.generated_schema_context_view mit Kontext gefüllt. Wenn Sie TRUE übergeben, wird der Kontext in dieser Ansicht aus vorherigen Ausführungen überschrieben.

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

Führen Sie Folgendes aus, um den erstellten 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 Abfrageausgabe sieht 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.

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

Wenden Sie den generierten Kontext an, den Sie an die entsprechenden Objekte anhängen möchten:
```
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 Ansicht alloydb_ai_nl.generated_schema_context_view werden auf die entsprechenden Schemaobjekte angewendet und die Kommentare werden überschrieben.
Generierten Schemakontext anwenden.
```
SELECT alloydb_ai_nl.apply_generated_schema_context(
  'nla_demo_cfg',
  TRUE);
```
Wenn Sie TRUE übergeben, wird der vorhandene Kontext für Objekte überschrieben, die in nla_demo_cfg registriert sind.

Werteindex erstellen

Die AlloyDB AI Natural Language API erstellt genaue SQL-Abfragen mithilfe der Werteverknüpfung. Bei der Werteverknüpfung werden Wertausdrücke in Anweisungen in natürlicher Sprache mit vorregistrierten Konzepttypen und Spaltennamen verknüpft, wodurch die Frage in natürlicher Sprache angereichert werden kann.

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

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(''Hoodie'')" }'::jsonb
);
SELECT alloydb_ai_nl.associate_concept_type(
    'nla_demo.products.name',
    'product_name',
    'nla_demo_cfg'
);

Führen Sie die folgende Abfrage aus, um zu prüfen, ob der Konzepttyp product_name der Liste der Konzepttypen hinzugefügt wurde. Achten Sie darauf, dass product_name im Ergebnis dieser Abfrage enthalten ist:
```
SELECT alloydb_ai_nl.list_concept_types();
```
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';
```

Führen Sie die folgenden Abfragen aus, um den brand_name Konzepttyp zu definieren und mit der nla_demo.brands.brand_name Spalte zu verknüpfen:

SELECT alloydb_ai_nl.add_concept_type(
    concept_type_in => 'brand_name',
    match_function_in => 'alloydb_ai_nl.get_concept_and_value_generic_entity_name',
    additional_info_in => '{
      "description": "Concept type for brand name.",
      "examples": "SELECT alloydb_ai_nl.get_concept_and_value_generic_entity_name(''CymbalPrime'')" }'::jsonb
);
SELECT alloydb_ai_nl.associate_concept_type(
    'nla_demo.brands.brand_name',
    'brand_name',
    'nla_demo_cfg'
);

Nachdem Sie die Konzepttypen definiert und Spalten damit 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');

Konzepttypverknüpfungen automatisch generieren

Mit AlloyDB AI Natural Language können Sie Verknüpfungen basierend auf den vorhandenen Konzepttypen automatisch generieren, anstatt einen Konzepttyp manuell mit Spalten zu verknüpfen, z. B. durch manuelles Aufrufen von alloydb_ai_nl.associate_concept_type.

So generieren Sie automatisch eine Konzepttypverknüpfung:

Verknüpfungen für alle Beziehungen im Bereich von nla_demo_cfg generieren:

SELECT alloydb_ai_nl.generate_concept_type_associations('nla_demo_cfg');

Generierte Verknüpfungen prüfen.

SELECT * from alloydb_ai_nl.generated_value_index_columns_view;

Das Ergebnis sieht etwa so aus. Sowohl integrierte als auch benutzerdefinierte Konzepte werden berücksichtigt.

-[ RECORD 1 ]---+-----------------------------------------------------------
id              | 1
config          | nla_demo_cfg
column_names    | nla_demo.addresses.city
concept_type    | city_name
additional_info | {}
-[ RECORD 2 ]---+-----------------------------------------------------------
id              | 2
config          | nla_demo_cfg
column_names    | nla_demo.addresses.country
concept_type    | country_name
additional_info | {}
-[ RECORD 3 ]---+-----------------------------------------------------------
id              | 3
config          | nla_demo_cfg
column_names    | nla_demo.customers.first_name,nla_demo.customers.last_name
concept_type    | full_person_name
additional_info | {}
-[ RECORD 4 ]---+-----------------------------------------------------------
id              | 4
config          | nla_demo_cfg
column_names    | nla_demo.brands.brand_name
concept_type    | brand_name
additional_info | {}
-[ RECORD 5 ]---+-----------------------------------------------------------
id              | 5
config          | nla_demo_cfg
column_names    | nla_demo.products.name
concept_type    | product_name
additional_info | {}

....

Optional: Generierte Verknüpfungen aktualisieren oder löschen.

-- Update, NULL means keeping the original value.
SELECT alloydb_ai_nl.update_generated_concept_type_associations(
id => 1,
column_names => NULL,
concept_type => 'generic_entity_name',
additional_info => NULL
);

-- Drop
SELECT alloydb_ai_nl.drop_generated_concept_type_association(id => 1);

Generierte Verknüpfungen anwenden.

SELECT alloydb_ai_nl.apply_generated_concept_type_associations('nla_demo_cfg');

Aktualisieren Sie den Werteindex, damit die Änderungen übernommen werden.
```
SELECT alloydb_ai_nl.refresh_value_index('nla_demo_cfg');
```

Abfragevorlagen definieren

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

Wenn Sie Beispielvorlagen für geschäftskritische Fragen und erwartete Fragen bereitstellen möchten, für die 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 rows with p.name = ''Swimsuit''. Return the `first_name` and the `last_name` of the customers with matching records.',
    check_intent => TRUE
);

Wenn Sie die Liste der hinzugefügten Vorlagen aufrufen möchten, fragen Sie die Ansicht alloydb_ai_nl.template_store_view ab:

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, der dem Attribut psql entspricht, die parametrisierte SQL-Abfrage und der Wert für die Spalte pintent die parametrisierte Intent-Anweisung. Die ID einer kürzlich hinzugefügten Vorlage kann sich je nach den zuvor hinzugefügten Vorlagen unterscheiden. Vorlagen liefern sehr genaue Antworten auf Fragen.

Führen Sie die folgende Beispielanweisung aus, um eine Vorlage zu erstellen, die die semantische Suche verwendet:

SELECT alloydb_ai_nl.add_template(
nl_config_id => 'nla_demo_cfg',
intent => 'List 3 products most similar to a Swimwear.',
sql => $$SELECT name FROM nla_demo.products
        ORDER BY description_embedding <=> embedding('text-embedding-004', 'Swimwear')::vector$$,
sql_explanation => $$To answer this question, ORDER products in `nla_demo.products` , based by their distance of the description_embedding of the product with the embedding of 'Swimwear'.$$,
check_intent => TRUE
);

Mit der vorherigen Vorlage wird der Ansicht alloydb_ai_nl.template_store_view die folgende Zeile hinzugefügt:

nl      | List 3 products most similar to a Swimwear.
sql     | SELECT name FROM nla_demo.products
        | ORDER BY description_embedding <=>
        | embedding('text-embedding-004', 'Swimwear')::vector
intent  | List 3 products most similar to a Swimwear.
psql    | SELECT name FROM nla_demo.products
        | ORDER BY description_embedding <=>
        | embedding('text-embedding-004', $1)::vector
pintent | List 3 products most similar to a $1.

Abfragefragment definieren

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

Wenn Sie ein Fragment für geschäftskritische Prädikate und erwartete Fragen bereitstellen möchten, für die eine hohe Genauigkeit erwartet wird, führen Sie die folgende Abfrage aus:

SELECT alloydb_ai_nl.add_fragment(
  nl_config_id => 'nla_demo_cfg',
  table_aliases => ARRAY['nla_demo.products AS T'],
  intent => 'luxury product',
  fragment => $$description LIKE '%luxury%' OR description LIKE '%premium%' OR description LIKE '%exclusive%' OR description LIKE '%high-end%' OR description LIKE '%finest%' OR description LIKE '%elite%' OR description LIKE '%deluxe%'$$);

Wenn Sie die Liste der hinzugefügten Fragmente aufrufen möchten, fragen Sie die Ansicht alloydb_ai_nl.fragment_store_view ab:

SELECT intent, fragment, pintent
FROM alloydb_ai_nl.fragment_store_view;

Die folgende Ausgabe wird zurückgegeben:

intent    | luxury product
fragment  | description LIKE '%luxury%' OR description LIKE '%premium%' OR description LIKE '%exclusive%' OR description LIKE '%high-end%' OR description LIKE '%finest%' OR description LIKE '%elite%' OR description LIKE '%deluxe%'
pintent   | luxury product

SQL-Ergebnisse aus Fragen in natürlicher Sprache generieren

Führen Sie die folgende Abfrage aus, um mit der AlloyDB AI Natural Language API SQL-Abfragen und Ergebnismengen zu erstellen:

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, die die Vorlage verwendet, die Sie unter Abfragevorlage definierenhinzugefügt haben.

Führen Sie die folgende Abfrage aus, um mit der AlloyDB AI Natural Language API SQL-Abfragen zu erstellen:
```
SELECT
    alloydb_ai_nl.get_sql(
        'nla_demo_cfg',
        'List the maximum price of any CymbalShoe.'
    ) ->> 'sql';
```
Die folgende Ausgabe wird zurückgegeben:
```
SELECT max("price")
FROM "nla_demo"."products"
WHERE "name" = 'CymbalShoe'
```
Die AlloyDB AI Natural Language API erkennt anhand des Werteindex, dass CymbalShoe der Name des Produkts ist. Führen Sie die folgende Abfrage aus, um CymbalShoe durch einen Markennamen (CymbalPrime) zu ersetzen:
```
SELECT
    alloydb_ai_nl.get_sql(
        'nla_demo_cfg',
        'List the maximum price of any CymbalPrime.'
    ) ->> 'sql';
```
Die folgende Ausgabe wird erstellt:
```
SELECT max("price")
FROM "nla_demo"."products" AS t1
JOIN "nla_demo"."brands" AS t2
ON t1."brand_id" = t2."brand_id"
WHERE t2."brand_name" = 'CymbalPrime';
```
AlloyDB AI verwendet den Werteindex, der unter Werteindex erstellen erstellt wurde, um CymbalPrime in den brand_name Konzepttyp aufzulösen, und verwendet die nla_demo.brands.brand_name Spalte, die mit brand_name verknüpft ist.

Führen Sie die folgende Abfrage aus, um mit der AlloyDB AI Natural Language API das Ergebnis einer Frage zu erstellen:

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

Die folgende Ausgabe wird zurückgegeben:

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

Führen Sie die folgende Abfrage aus, um mit der AlloyDB AI Natural Language API SQL-Anweisungen zu erstellen, die die semantische Suche verwenden:

SELECT
 alloydb_ai_nl.get_sql(
     'nla_demo_cfg',
     'List 2 products similar to a Tote Bag.');

Die folgende SQL-Anweisung wird zurückgegeben:

SELECT name FROM nla_demo.products
ORDER BY description_embedding <=> embedding(
    'text-embedding-004', 'Tote Bag')::vector
LIMIT 2;

SQL-Zusammenfassungen abrufen

Sie können eine Ergebniszusammenfassung aus einer Frage in natürlicher Sprache basierend auf den in der Datenbank gespeicherten Daten erstellen. So können Endnutzer Daten besser verstehen, indem sie direkt Fragen in natürlicher Sprache stellen.

Führen Sie die folgende Beispielabfrage aus, um eine SQL-Zusammenfassung zu erhalten:

SELECT
   alloydb_ai_nl.get_sql_summary(
      nl_config_id => 'nla_demo_cfg',
      nl_question => 'which brands have the largest number of products?'
);

Diese Abfrage gibt ein JSON-Objekt als Ausgabe zurück, das etwa so aussieht:

   "answer": "The result set lists three brands: CymbalSports, CymbalPro, and CymbalPrime. Each brand is represented once, suggesting an equal distribution of products across these three brands within the dataset."

Bereinigen

Zum Bereinigen können Sie entweder die AlloyDB Omni-Instanz deinstallieren oder die Instanz beibehalten und die einzelnen Objekte löschen.

Objekte löschen

Sie können die Ressourcen beibehalten, die Sie unter Hinweis eingerichtet haben, und nur die Objekte löschen, die Sie in der Instanz erstellt haben.

Entfernen Sie die Vorlage, die Sie unter Abfragevorlage definieren definiert haben.

SELECT alloydb_ai_nl.drop_template(id)
FROM alloydb_ai_nl.template_store_view
WHERE config = 'nla_demo_cfg';

Entfernen Sie die automatisch generierten Konzeptverknüpfungen, die unter Konzepttypverknüpfungen automatisch generieren erstellt wurden.

SELECT alloydb_ai_nl.drop_generated_concept_type_association(id)
FROM alloydb_ai_nl.generated_value_index_columns_view
WHERE config = 'nla_demo_cfg';

Entfernen Sie den product_name Konzepttyp, den Sie unter Werteindex erstellen definiert haben.
```
SELECT alloydb_ai_nl.drop_concept_type('product_name');
```
Aktualisieren Sie den Werteindex, nachdem Sie den Konzepttyp product_name entfernt haben.
```
SELECT alloydb_ai_nl.refresh_value_index();
```
Entfernen Sie die Konfiguration nla_demo_cfg, die Sie unter Konfiguration für natürliche Sprache erstellen erstellt haben.
```
SELECT
alloydb_ai_nl.g_manage_configuration(
    'drop_configuration',
    'nla_demo_cfg'
);
```
Entfernen Sie das nla_demo Schema und die Tabellen, die Sie erstellt und gefüllt haben unter Schema und Tabellen nla_demo erstellen und Tabellen im Schema nla_demo füllen, indem Sie die folgende Abfrage ausführen:
```
DROP SCHEMA nla_demo CASCADE;
```

SQL mit AlloyDB AI in natürlicher Sprache generieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Ziele

Hinweis

Abrechnung aktivieren

Datenbank installieren und eine Verbindung herstellen

Erforderliche Erweiterung aktivieren und installieren

Erweiterung alloydb_ai_nl aktualisieren

Schema und Tabellen nla_demo erstellen

Tabellen im Schema nla_demo füllen

Konfiguration für natürliche Sprache erstellen

Kontext für Tabellen und Spalten erstellen und anwenden

Werteindex erstellen

Konzepttypverknüpfungen automatisch generieren

Abfragevorlagen definieren

Abfragefragment definieren

SQL-Ergebnisse aus Fragen in natürlicher Sprache generieren

SQL-Zusammenfassungen abrufen

Bereinigen

Objekte löschen

Nächste Schritte

SQL mit AlloyDB AI in natürlicher Sprache generieren

Erweiterung `alloydb_ai_nl` aktualisieren

Schema und Tabellen `nla_demo` erstellen

Tabellen im Schema `nla_demo` füllen