SQL mit AlloyDB AI in natürlicher Sprache generieren

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

Lernziele

  • Tabellen erstellen und füllen sowie Kontext automatisch generieren lassen
  • Erstellen Sie einen Wertindex für die Spalten in der Datenbank.
  • Erstellen und konfigurieren Sie ein Objekt für die Konfiguration von natürlicher Sprache (nl_config).
  • Erstellen Sie Vorlagen für eine Beispielabfrage in der Anwendung.
  • Verwenden Sie die Funktion get_sql(), um eine SQL-Abfrage zu erstellen, mit der eine Frage beantwortet wird.
  • Verwenden Sie die Funktion execute_nl_query(), um eine Frage in natürlicher Sprache mithilfe der Datenbank zu beantworten.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Neuen Google Cloud Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

Zugriff anfordern

Bevor Sie mit AlloyDB AI natürliche Sprache zum Generieren von SQL verwenden können, müssen Sie Zugriff auf AlloyDB AI natürliche Sprache anfordern und warten, bis Sie die Bestätigung der Aktivierung erhalten. Erst dann können Sie der Anleitung in diesem Tutorial folgen.

Abrechnung und erforderliche APIs aktivieren

  1. Wählen Sie in der Google Cloud -Console ein Projekt aus.

    Zur Projektauswahl

  2. Die Abrechnung für Ihr Google Cloud -Projekt muss aktiviert sein.

  3. Aktivieren Sie die Cloud APIs, die zum Erstellen einer Verbindung zu AlloyDB for PostgreSQL erforderlich sind.

    API aktivieren

    1. Klicken Sie im Schritt Projekt bestätigen auf Weiter, um den Namen des Projekts zu bestätigen, an dem Sie Änderungen vornehmen möchten.

    2. Klicken Sie im Schritt APIs aktivieren auf Aktivieren, um Folgendes zu aktivieren:

      • AlloyDB API

Erstellen und Verbindung zu einer Datenbank herstellen

  1. Cluster und primäre Instanz erstellen
  2. Verbindung zur Instanz herstellen und Datenbank erstellen
  3. Aktivieren Sie die Vertex AI-Einbindung. Weitere Informationen finden Sie unter Mit Vertex AI integrieren.

Erforderliche Erweiterung installieren

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

CREATE EXTENSION alloydb_ai_nl cascade;

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 so konzipiert, dass sie die grundlegenden Abläufe eines Online-Einzelhandelsunternehmens unterstützen. Mögliche Anwendungen erstrecken sich auf Kundenverwaltung, 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 in natürlicher Sprache.

  1. Erstellen Sie das Schema mit der folgenden Abfrage:

    CREATE SCHEMA nla_demo;

  2. Erstellen Sie Tabellen im Schema nla_demo. 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 Kundennummer, Name, Kontaktdaten, Adressreferenz, Geburtsdatum und 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 brands, in der Markennamen gespeichert werden.

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

  6. Erstellen Sie die Tabelle products, 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
);

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

  8. Erstellen Sie die Tabelle order_items. In dieser Tabelle werden die einzelnen Artikel in einer Bestellung, Links zur Bestellung und zur Produktvariante sowie 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“ mit Daten füllen

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

  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 brands aus.

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

  5. 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, 3, 3, 'CymbalShoe');

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

  7. 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 AlloyDB AI für natürliche Sprache verwenden möchten, muss der Vertex AI-Endpunkt konfiguriert sein. Anschließend erstellen Sie eine Konfiguration und registrieren ein Schema. Mit g_alloydb_ai_nl.g_create_configuration wird das Modell erstellt.

  1. Konfiguration für natürliche Sprache erstellen

    SELECT alloydb_ai_nl.g_create_configuration( 'nla_demo_cfg' );

  2. Registrieren Sie Tabellen für die 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.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. Mit der Funktion zur automatischen Kontexterstellung der AlloyDB AI Natural Language API können Sie Kontext aus Tabellen und Spalten generieren und den Kontext als COMMENTS an Tabellen, Ansichten und Spalten anhängen.

  1. Führen Sie den 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 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 Läufen ü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 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. So prüfen Sie den erstellten Kontext für eine Spalte wie nla_demo.products.name:

    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. Sehen Sie sich den generierten Kontext in der Ansicht alloydb_ai_nl.generated_schema_context_view an 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 angehängt 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 werden überschrieben.

Wertindex erstellen

Die AlloyDB AI Natural Language API generiert mithilfe der Wertverknüpfung genaue SQL-Abfragen. Durch die Wertverknüpfung werden Wertformulierungen in natürlichsprachlichen Anweisungen mit vorab registrierten Konzepttypen und Spaltennamen verknüpft, wodurch die natürlichsprachliche Frage angereichert werden kann.

Die Frage „Gib mir den Preis eines Hoodies“ kann beispielsweise genauer beantwortet werden, wenn Hoodie mit dem Konzept product_name verknüpft ist, das wiederum mit nla_demo.products.name verknüpft ist. Spalte.

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

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

  2. Führen Sie die folgende Abfrage aus, um zu prüfen, ob der Konzepttyp product_name der Liste der Konzepttypen hinzugefügt wurde und ob 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. Führen Sie die folgenden Abfragen aus, um den Konzepttyp brand_name zu definieren und der Spalte nla_demo.brands.brand_name zuzuordnen:

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

  5. Nachdem Sie die Konzepttypen definiert und Spalten damit verknüpft haben, erstellen Sie einen Wertindex.

    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 erwartete Fragen hinzufügen möchten, für die eine hohe Genauigkeit erwartet wird, führen Sie die folgende Abfrage aus:

    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 die Liste der hinzugefügten Vorlagen aufrufen möchten, fragen Sie 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 neu hinzugefügten Vorlage kann sich je nach den zuvor hinzugefügten Vorlagen unterscheiden. Vorlagen werden verwendet, um sehr genaue Antworten auf Fragen zu geben.

SQL-Ergebnisse aus Fragen in natürlicher Sprache generieren

  1. 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 in Abfragevorlage definieren hinzugefügt haben.

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

    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"."order_items" AS t1
JOIN "nla_demo"."products" AS t2 ON t1."product_id" = t2."product_id"
WHERE t2."name" = 'CymbalShoe';

    Die AlloyDB AI Natural Language API erkennt anhand des Wertindex, dass CymbalShoe der Name des Produkts ist. Ersetzen Sie CymbalShoe durch einen Markennamen (CymbalPrime) in der folgenden Abfrage:

    SELECT
    alloydb_ai_nl.get_sql(
        'nla_demo_cfg',
        'List the maximum price of any CymbalPrime.'
    ) ->> 'sql';

    Dies führt zu folgender Ausgabe:

    SELECT max("price")
FROM "nla_demo"."order_items" AS "oi"
JOIN "nla_demo"."products" AS "p" ON "oi"."product_id" = "p"."product_id"
JOIN "nla_demo"."brands" AS "b" ON "p"."brand_id" = "b"."brand_id"
WHERE "b"."brand_name" = 'CymbalPrime';

    AlloyDB AI verwendet den in Wertindex erstellen erstellten Wertindex, um CymbalPrime in den Konzepttyp brand_name aufzulösen, und verwendet die Spalte nla_demo.brands.brand_name, die mit brand_name verknüpft ist.

  3. Wenn Sie die AlloyDB AI Natural Language API verwenden möchten, um das Ergebnis einer Frage zu generieren, 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."}

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

In den folgenden Abschnitten erfahren Sie, wie Sie diese Ressourcen und Objekte löschen.

Cluster löschen

Wenn Sie den Cluster löschen, den Sie unter Vorbereitung erstellt haben, werden auch alle Objekte gelöscht, die Sie erstellt haben.

  1. Rufen Sie in der Google Cloud Console die Seite Cluster auf.

    Zu den Clustern

  2. Klicken Sie in der Spalte Ressourcenname auf den Namen Ihres Clusters, my-cluster.

  3. Klicken Sie auf  Cluster löschen.

  4. Geben Sie in Cluster „my-cluster“ löschen my-cluster ein, um zu bestätigen, dass Sie den Cluster löschen möchten.

  5. Klicken Sie auf Löschen.

  6. Wenn Sie beim Erstellen eines Clusters eine private Verbindung erstellt haben, rufen Sie in der Google Cloud Console die Seite „VPC-Netzwerke“ auf und klicken Sie auf VPC-Netzwerk löschen.

Objekte löschen

Sie können die Ressourcen beibehalten, die Sie unter Vorbereitung eingerichtet haben, und nur die Objekte löschen, die Sie im Google Cloud Projekt erstellt haben.

  1. Führen Sie die folgende Abfrage aus, um die Vorlage zu entfernen, die Sie in Abfragevorlage definieren definiert haben:

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

  2. Wenn Sie den Konzepttyp product_name entfernen möchten, den Sie in Wertindex erstellen definiert haben, führen Sie die folgende Abfrage aus:

    SELECT alloydb_ai_nl.drop_concept_type('product_name');

  3. Führen Sie die folgende Abfrage aus, um den Wertindex zu aktualisieren, nachdem Sie den Konzepttyp product_name entfernt haben:

    SELECT alloydb_ai_nl.refresh_value_index();

  4. Führen Sie die folgende Abfrage aus, um die nla_demo_cfg-Konfiguration zu entfernen, die Sie in Konfiguration in natürlicher Sprache erstellen erstellt haben:

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

  5. Wenn Sie das Schema „nla_demo“ und die Tabellen entfernen möchten, die Sie in nla_demo-Schema und -Tabellen erstellen und Tabellen im nla_demo-Schema mit Daten füllen erstellt und mit Daten gefüllt haben, führen Sie die folgende Abfrage aus:

    DROP SCHEMA nla_demo CASCADE;

Nächste Schritte