Questa pagina documenta la versione 18.1.0 di AlloyDB Omni utilizzando l'opzione di deployment RPM. Scegli un'altra opzione di implementazione.

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

Utilizza il linguaggio naturale di AlloyDB AI per generare SQL

Select a documentation version:

Questo tutorial descrive come configurare e utilizzare l'API di linguaggio naturale di AlloyDB AI. Scopri come configurare l'API di linguaggio naturale di AlloyDB AI in modo da poter porre domande in linguaggio naturale e ricevere query SQL e risultati.

Gli esempi in questo tutorial sono solo a scopo dimostrativo.

Obiettivi

Crea e compila le tabelle e utilizza la generazione automatica per creare il contesto.
Crea un indice di valori per le colonne del database.
Crea e configura un oggetto di configurazione del linguaggio naturale (nl_config).
Crea modelli per una query di esempio nell'applicazione.
Utilizza la funzione get_sql() per produrre una query SQL che risponda a una domanda.
Utilizza la funzione execute_nl_query() per rispondere a una domanda in linguaggio naturale utilizzando il database.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti.

Abilita fatturazione

Nellaconsole, seleziona un progetto. Google Cloud

Vai al selettore di progetti
Verifica che la fatturazione sia abilitata per il tuo Google Cloud progetto.

Installare e connettersi a un database

Abilitare e installare l'estensione richiesta

Per installare e utilizzare l'estensione alloydb_ai_nl, devi prima abilitarla eseguendo il seguente comando PostgreSQL:

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

Per installare l'estensione alloydb_ai_nl, che è l'API di supporto del linguaggio naturale di AlloyDB AI, esegui la seguente query:

CREATE EXTENSION alloydb_ai_nl cascade;

Eseguire l'upgrade dell'estensione `alloydb_ai_nl`

Se hai già installato l'estensione, esegui la seguente istruzione per aggiornarla alla versione più recente:

ALTER EXTENSION alloydb_ai_nl UPDATE;

Creare lo schema e le tabelle `nla_demo`

Ora crea lo schema e le tabelle nla_demo nello schema e compila le tabelle con dati sintetici. Lo schema e i dati forniti sono progettati per supportare le operazioni fondamentali di un'attività di vendita al dettaglio online, con potenziali applicazioni che si estendono alla gestione dei clienti, all'analisi, al marketing e agli aspetti operativi.

I dati di esempio mostrano come puoi utilizzare il linguaggio naturale di AlloyDB AI per scopi di sviluppo, test e dimostrazione, in particolare per funzionalità come le interfacce di linguaggio naturale.

Crea lo schema.
```
CREATE SCHEMA nla_demo;
```

Crea tabelle nello schema nla_demo. La tabella addresses memorizza le informazioni sull'indirizzo per le tabelle customers e orders.

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

Crea la tabella customers. Questa tabella memorizza i dati del cliente, inclusi ID cliente, nome, dati di contatto, riferimento all'indirizzo, data di nascita e ora di creazione del record.

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

Crea la tabella categories, che memorizza le categorie di prodotti.

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

Crea la tabella brands, che memorizza i nomi dei brand.

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

Crea la tabella products, che memorizza le informazioni sui prodotti, come ID prodotto, nome, descrizione, brand, collegamento alla categoria e ora di creazione del record.

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

Crea la tabella orders. Questa tabella memorizza le informazioni sugli ordini dei clienti, inclusi cliente, data, importo totale, indirizzi di spedizione e fatturazione e stato dell'ordine.

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

Crea la tabella order_items. Questa tabella registra i singoli articoli di un ordine, i link all'ordine e alla variante del prodotto e specifica quantità e prezzo.

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

Compilare le tabelle nello schema `nla_demo`

Compila la tabella addresses eseguendo la seguente query:

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

Compila la tabella 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');

Compila la tabella categories.

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

Compila la tabella brands.

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

Compila la tabella products.

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

Compila la tabella 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');

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

Creare una configurazione del linguaggio naturale

Per utilizzare il linguaggio naturale di AlloyDB AI, assicurati che AlloyDB AI sia installato per AlloyDB Omni. Poi crea una configurazione e registra uno schema. g_alloydb_ai_nl.g_create_configuration crea il modello.

Crea una configurazione del linguaggio naturale.

SELECT alloydb_ai_nl.g_create_configuration( 'nla_demo_cfg' );

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

Creare e applicare il contesto per tabelle e colonne

Per fornire risposte accurate alle domande in linguaggio naturale, utilizza l'API di linguaggio naturale di AlloyDB AI per fornire il contesto di tabelle, viste e colonne. Puoi utilizzare la funzionalità di generazione automatica del contesto dell'API di linguaggio naturale di AlloyDB AI per produrre il contesto da tabelle e colonne e applicarlo come COMMENTS allegati a tabelle, viste e colonne.

Per generare i contesti dello schema per le tabelle e le relative colonne registrate nella configurazione nla_demo_cfg, esegui il comando seguente:
```
SELECT alloydb_ai_nl.generate_schema_context(
  'nla_demo_cfg',
  TRUE
);
```
La query precedente compila la vista alloydb_ai_nl.generated_schema_context_view con il contesto. Se passi TRUE, il contesto in questa vista viene sovrascritto dalle esecuzioni precedenti.

Per verificare il contesto generato per la tabella nla_demo.products, esegui la seguente query:

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

Il contesto risultante è simile al seguente:

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

Per verificare il contesto prodotto per una colonna, ad esempio nla_demo.products.name, esegui il comando seguente:

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

L'output della query è simile al seguente:

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.

Esamina il contesto generato nella vista alloydb_ai_nl.generated_schema_context_view e aggiorna il contesto che deve essere rivisto.

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

Applica il contesto generato che vuoi allegare agli oggetti corrispondenti:
```
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
);
```
Le voci di contesto risultanti nella vista alloydb_ai_nl.generated_schema_context_view vengono applicate agli oggetti dello schema corrispondenti e i commenti vengono sovrascritti.
Applica il contesto dello schema generato.
```
SELECT alloydb_ai_nl.apply_generated_schema_context(
  'nla_demo_cfg',
  TRUE);
```
Se passi TRUE, il contesto esistente per gli oggetti registrati in nla_demo_cfg viene sovrascritto.

Costruire l'indice di valori

L'API di linguaggio naturale di AlloyDB AI produce query SQL accurate utilizzando il collegamento dei valori. Il collegamento dei valori associa le frasi di valore nelle istruzioni in linguaggio naturale ai tipi di concetti e ai nomi delle colonne preregistrati che possono arricchire la domanda in linguaggio naturale.

Ad esempio, alla domanda "Dammi il prezzo di una felpa con cappuccio" è possibile rispondere in modo più accurato se Hoodie è associato a un concetto product_name, che a sua volta è associato alla colonna nla_demo.products.name.

Per definire il tipo di concetto product_name e associarlo alla colonna nla_demo.products.name, esegui le seguenti query:

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

Per verificare che il tipo di concetto product_name sia stato aggiunto all'elenco dei tipi di concetti, esegui la seguente query per assicurarti che product_name sia incluso nel risultato di questa query:
```
SELECT alloydb_ai_nl.list_concept_types();
```
Per verificare che la colonna nla_demo.products.name sia associata al tipo di concetto product_name, esegui la seguente query:
```
SELECT *
FROM alloydb_ai_nl.value_index_columns
WHERE column_names = 'nla_demo.products.name';
```

Per definire il tipo di concetto brand_name e associarlo alla colonna nla_demo.brands.brand_name, esegui le seguenti query:

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

Dopo aver definito i tipi di concetti e aver associato le colonne, crea un indice di valori.

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

Generare automaticamente le associazioni dei tipi di concetti

Utilizzando il linguaggio naturale di AlloyDB AI, puoi generare automaticamente le associazioni in base ai tipi di concetti esistenti, anziché dover associare manualmente un tipo di concetto alle colonne, ad esempio chiamando manualmente alloydb_ai_nl.associate_concept_type.

Per generare automaticamente un'associazione di tipi di concetti:

Genera le associazioni per tutte le relazioni nell'ambito di nla_demo_cfg:

SELECT alloydb_ai_nl.generate_concept_type_associations('nla_demo_cfg');

Esamina le associazioni generate.

SELECT * from alloydb_ai_nl.generated_value_index_columns_view;

Il risultato è simile al seguente. Vengono presi in considerazione sia i concetti integrati sia quelli definiti dall'utente.

-[ 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 | {}

....

(Facoltativo) Aggiorna o elimina le associazioni generate.

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

Applica le associazioni generate.

SELECT alloydb_ai_nl.apply_generated_concept_type_associations('nla_demo_cfg');

Per riflettere le modifiche, aggiorna l'indice di valori.

SELECT alloydb_ai_nl.refresh_value_index('nla_demo_cfg');

Definire i modelli di query

Puoi definire i modelli per migliorare la qualità delle risposte prodotte dall'API di linguaggio naturale di AlloyDB AI.

Per fornire modelli di esempio per le domande business-critical e per fornire le domande previste per le quali è prevista un'elevata accuratezza, esegui la seguente query per aggiungere un modello:

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

Per visualizzare l'elenco dei modelli aggiunti, esegui una query sulla vista alloydb_ai_nl.template_store_view:

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

Viene restituito il seguente output:

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 questo modello, il valore corrispondente all'attributo psql è la query SQL con parametri e il valore della colonna pintent è l'istruzione di intent con parametri. L'ID di un modello aggiunto di recente può essere diverso, in base ai modelli aggiunti in precedenza. I modelli forniscono risposte molto accurate alle domande.

Per creare un modello che utilizzi la ricerca semantica, esegui la seguente istruzione di esempio:

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

Il modello precedente aggiunge la seguente riga alla vista alloydb_ai_nl.template_store_view:

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.

Definire un frammento di query

Puoi definire i frammenti per migliorare la qualità delle risposte prodotte dall'API di linguaggio naturale di AlloyDB AI.

Per fornire un frammento per i predicati business-critical e per fornire le domande previste per le quali è prevista un'elevata accuratezza, esegui la seguente query:

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

Per visualizzare l'elenco dei frammenti aggiunti, esegui una query sulla vista alloydb_ai_nl.fragment_store_view:

SELECT intent, fragment, pintent
FROM alloydb_ai_nl.fragment_store_view;

Viene restituito il seguente output:

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

Generare risultati SQL da domande in linguaggio naturale

Per utilizzare l'API di linguaggio naturale di AlloyDB AI per produrre query SQL e set di risultati, esegui la seguente query:

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

Viene restituito il seguente output:

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

L'output JSON è una query SQL che utilizza il modello che hai aggiunto in Definire un modello di query.

Per utilizzare l'API di linguaggio naturale di AlloyDB AI per produrre query SQL, esegui la seguente query:
```
SELECT
    alloydb_ai_nl.get_sql(
        'nla_demo_cfg',
        'List the maximum price of any CymbalShoe.'
    ) ->> 'sql';
```
Viene restituito il seguente output:
```
SELECT max("price")
FROM "nla_demo"."products"
WHERE "name" = 'CymbalShoe'
```
L'API di linguaggio naturale di AlloyDB AI riconosce che CymbalShoe è il nome del prodotto utilizzando l'indice di valori. Esegui la seguente query per sostituire CymbalShoe con un nome di brand (CymbalPrime):
```
SELECT
    alloydb_ai_nl.get_sql(
        'nla_demo_cfg',
        'List the maximum price of any CymbalPrime.'
    ) ->> 'sql';
```
Viene prodotto il seguente output:
```
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 utilizza l'indice di valori creato in Costruire l'indice di valori per risolvere CymbalPrime nel tipo di concetto brand_name e utilizza la colonna nla_demo.brands.brand_name associata a brand_name.

Per utilizzare l'API di linguaggio naturale di AlloyDB AI per produrre il risultato di una domanda, esegui la seguente query:

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

Viene restituito il seguente output:

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

Per utilizzare l'API di linguaggio naturale di AlloyDB AI per produrre istruzioni SQL che utilizzano la ricerca semantica, esegui la seguente query:

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

Viene restituita la seguente istruzione SQL:

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

Ottenere riepiloghi SQL

Puoi produrre un riepilogo dei risultati da una domanda in linguaggio naturale in base ai dati archiviati nel database. In questo modo gli utenti finali possono comprendere i dati ponendo direttamente domande in linguaggio naturale.

Per ottenere un riepilogo SQL, esegui la seguente query di esempio:

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

Questa query restituisce un oggetto JSON come output, simile al seguente:

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

Libera spazio

Per liberare spazio, puoi disinstallare l'istanza AlloyDB Omni oppure mantenerla ed eliminare i singoli oggetti.

Eliminare gli oggetti

Puoi scegliere di conservare le risorse che hai configurato in Prima di iniziare ed eliminare solo gli oggetti che hai creato nell'istanza.

Rimuovi il modello definito in Definire un modello di query.

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

Rimuovi le associazioni di concetti generate automaticamente in Generare automaticamente le associazioni dei tipi di concetti.

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

Rimuovi il tipo di concetto product_name definito in Costruire l'indice di valori.
```
SELECT alloydb_ai_nl.drop_concept_type('product_name');
```
Aggiorna l'indice di valori dopo aver rimosso il tipo di concetto product_name.
```
SELECT alloydb_ai_nl.refresh_value_index();
```

Rimuovi la configurazione nla_demo_cfg creata in Creare una configurazione del linguaggio naturale.

SELECT
alloydb_ai_nl.g_manage_configuration(
    'drop_configuration',
    'nla_demo_cfg'
);

Rimuovi lo schema e le tabelle nla_demo che hai creato e compilato in Creare lo schema e le tabelle nla_demo e Compilare le tabelle nello schema nla_demo, esegui la seguente query:
```
DROP SCHEMA nla_demo CASCADE;
```

Utilizza il linguaggio naturale di AlloyDB AI per generare SQL Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Prima di iniziare

Abilita fatturazione

Installare e connettersi a un database

Abilitare e installare l'estensione richiesta

Eseguire l'upgrade dell'estensione alloydb_ai_nl

Creare lo schema e le tabelle nla_demo

Compilare le tabelle nello schema nla_demo

Creare una configurazione del linguaggio naturale

Creare e applicare il contesto per tabelle e colonne

Costruire l'indice di valori

Generare automaticamente le associazioni dei tipi di concetti

Definire i modelli di query

Definire un frammento di query

Generare risultati SQL da domande in linguaggio naturale

Ottenere riepiloghi SQL

Libera spazio

Eliminare gli oggetti

Passaggi successivi

Utilizza il linguaggio naturale di AlloyDB AI per generare SQL

Eseguire l'upgrade dell'estensione `alloydb_ai_nl`

Creare lo schema e le tabelle `nla_demo`

Compilare le tabelle nello schema `nla_demo`