SQL-Abfragen mit Fragen in natürlicher Sprache generieren

Auf dieser Seite wird beschrieben, wie Sie SQL-Anweisungen mit AlloyDB AI-Natursprache einrichten, konfigurieren und generieren. Mit natürlicher Sprache können Sie nutzerorientierte generative KI-Anwendungen erstellen, indem Sie Datenbanken mit natürlicher Sprache abfragen.

Wenn Sie die alloydb_ai_nl-Erweiterung aktivieren möchten, die die API zur Unterstützung natürlicher Sprache für AlloyDB for PostgreSQL ist, führen Sie die folgenden allgemeinen Schritte aus:

  1. Installieren Sie die alloydb_ai_nl-Erweiterung.
  2. Konfiguration in natürlicher Sprache für Ihre Anwendung definieren
  3. Schema registrieren
  4. Kontext hinzufügen
  5. Fügen Sie Abfragevorlagen hinzu.
  6. Konzepttypen definieren und einen Wertindex erstellen
  7. SQL-Anweisungen mit einer Benutzeroberfläche in natürlicher Sprache generieren

Hinweise

  • Hier erfahren Sie, wie Sie eine Verbindung zur AlloyDB-Datenbank herstellen und PostgreSQL-Befehle ausführen. Weitere Informationen finden Sie unter Verbindungsübersicht.
  • Füllen Sie die Datenbank mit den Daten und dem Schema, auf die der Endnutzer zugreifen möchte.

Erforderliche Erweiterung aktivieren

Bevor Sie die AlloyDB AI-Erweiterung für natürliche Sprache installieren und verwenden können, müssen Sie sie aktivieren, indem Sie das Flag alloydb_ai_nl.enabled hinzufügen. Weitere Informationen finden Sie unter Datenbank-Flags einer Instanz konfigurieren.

Cluster erstellen und Vertex AI-Integration aktivieren

  1. AlloyDB-Cluster und ‑Instanz erstellen Sie verwenden die AlloyDB-Instanz, um die Anwendungsdatenbank und das Schema zu erstellen.
  2. Aktivieren Sie die Vertex AI-Einbindung. Weitere Informationen finden Sie unter Mit Vertex AI integrieren.

Erforderliche Rollen

Wenn Sie die alloydb_ai_nl-Erweiterung installieren und anderen Nutzern Zugriff gewähren möchten, benötigen Sie die folgende IAM-Rolle (Identity and Access Management) im Google Cloud -Projekt, das Sie verwenden:

Weitere Informationen finden Sie unter PostgreSQL-Nutzer mit Standardauthentifizierung verwalten.

Umgebung vorbereiten

Bevor Sie Abfragen in natürlicher Sprache generieren können, müssen Sie die erforderliche Erweiterung installieren, eine Konfiguration erstellen und ein Schema registrieren.

alloydb_nl_ai-Erweiterung installieren

Die alloydb_ai_nl-Erweiterung verwendet die google_ml_integration-Erweiterung, die mit Large Language Models (LLMs) interagiert, einschließlich Gemini-Modellen in Vertex AI.

Stellen Sie eine Verbindung zur Datenbank her und führen Sie den folgenden Befehl aus, um die Erweiterung alloydb_ai_nl zu installieren:

CREATE EXTENSION alloydb_ai_nl cascade;

alloydb_ai_nl-Erweiterung aktualisieren

Achten Sie darauf, dass Sie die aktuelle Version der alloydb_ai_nl-Erweiterung verwenden. Wenn Sie die Erweiterung bereits installiert haben, prüfen Sie, ob eine neue Version verfügbar ist, und aktualisieren Sie die Erweiterung, falls Sie nicht die neueste Version verwenden. Weitere Informationen zur alloydb_ai_nl-Erweiterung finden Sie in der Übersicht über die Verarbeitung natürlicher Sprache in AlloyDB AI.

  1. Prüfen Sie, ob Sie die Erweiterung aktualisieren müssen. Wenn default_version nach installed_version liegt, aktualisieren Sie die Erweiterung.

    SELECT * FROM pg_available_extensions where name = 'alloydb_ai_nl';

  2. Führen Sie ein Upgrade der Erweiterung durch.

    ALTER EXTENSION alloydb_ai_nl UPDATE;

Konfiguration in natürlicher Sprache erstellen und Schema registrieren

AlloyDB AI Natural Language verwendet nl_config, um Anwendungen bestimmten Schemas, Abfragevorlagen und Modellendpunkten zuzuordnen. nl_config ist eine Konfiguration, die eine Anwendung mit Schemas, Vorlagen und anderen Kontexten verknüpft. Eine große Anwendung kann auch verschiedene Konfigurationen für verschiedene Teile der Anwendung verwenden, sofern Sie die richtige Konfiguration angeben, wenn eine Frage von diesem Teil der Anwendung gesendet wird. Sie können ein ganzes Schema oder bestimmte Schemaobjekte wie Tabellen, Ansichten und Spalten registrieren.

  1. Verwenden Sie das folgende Beispiel, um eine Konfiguration in natürlicher Sprache zu erstellen:

    SELECT
  alloydb_ai_nl.g_create_configuration(
    'my_app_config'        -- configuration_id
  );

    gemini-2.0-flash:generateContent ist der Modellendpunkt.

  2. Registrieren Sie ein Schema für eine bestimmte Konfiguration mit dem folgenden Beispiel:

    SELECT
  alloydb_ai_nl.g_manage_configuration(
    operation => 'register_schema',
    configuration_id_in => 'my_app_config',
    schema_names_in => '{my_schema}'
  );

Kontext hinzufügen

Kontext umfasst alle Arten von Informationen, die Sie zur Beantwortung einer Frage des Endnutzers verwenden können, z. B.:

  • Schemastruktur und ‑beziehungen
  • Zusammenfassungen und Beschreibungen von Spalten
  • Spaltenwerte und ihre Semantik
  • Regeln oder Anweisungen der Geschäftslogik, die für die Anwendung oder Domain spezifisch sind

Allgemeinen Kontext für anwendungsspezifische Regeln hinzufügen

Allgemeine Kontext-Elemente umfassen anwendungsspezifische Regeln, Aussagen zur Geschäftslogik oder anwendungs- und domänenspezifische Terminologie, die nicht mit einem bestimmten Schemaobjekt verknüpft ist.

So fügen Sie allgemeinen Kontext für anwendungsspezifische Regeln und anwendungs- oder domänenspezifische Terminologie hinzu:

  1. Führen Sie die folgende Abfrage aus, um ein allgemeines Kontextelement für die angegebene Konfiguration hinzuzufügen:

    SELECT
  alloydb_ai_nl.g_manage_configuration(
    'add_general_context',
    'my_app_config',
    general_context_in => '{"If the user asks for a good seat, assume that means a window or aisle seat."}'
  );

    Die vorherige Anweisung hilft AlloyDB AI, qualitativ hochwertigere Antworten auf Fragen von Nutzern in natürlicher Sprache zu geben.

  2. Führen Sie die folgende Abfrage aus, um die allgemeinen Kontexte für die angegebene Konfiguration aufzurufen:

    SELECT alloydb_ai_nl.list_general_context(nl_config TEXT);

Schemakontext generieren und prüfen

Der Schemakontext beschreibt Schemaobjekte wie Tabellen, Ansichten, materialisierte Ansichten und Spalten. Dieser Kontext wird als COMMENT jedes Schemaobjekts gespeichert.

  1. Rufen Sie die folgenden APIs auf, um Kontexte für Schemaobjekte zu generieren. Die besten Ergebnisse erzielen Sie, wenn die Datenbanktabellen repräsentative Daten enthalten.

    -- For all schema objects (tables, views, materialized views and columns)
-- within the scope of a provided nl_config.
SELECT
  alloydb_ai_nl.generate_schema_context(
    'my_app_config' -- nl_config
  );

  2. Prüfen Sie die generierten Schemakontexte, indem Sie die folgende Abfrage ausführen:

    SELECT schema_object, object_context
FROM alloydb_ai_nl.generated_schema_context_view;

    Die generierten Schemakontexte werden in der vorherigen Ansicht gespeichert.

  3. Optional: Aktualisieren Sie die generierten Schemakontexte.

    SELECT
  alloydb_ai_nl.update_generated_relation_context(
    'my_schema.my_table',
    'This table contains archival records, if you need latest records use records_new table.'
  );

SELECT
  alloydb_ai_nl.update_generated_column_context(
    'my_schema.my_table.column1',
    'The seat_class column takes single letters like "E" for economy, "P" for premium economy, "B" for business and "F" for First.'
  );

  4. Kontext anwenden Wenn Sie den Kontext anwenden, wird er sofort wirksam und aus der Ansicht generated_schema_context_view gelöscht.

    -- For all schema objects (tables, views, materialized views and columns)
-- within the scope of nl_config.
SELECT
  alloydb_ai_nl.apply_generated_schema_context(
    'my_app_config' --nl_config
  );

  5. Optional: Überprüfen Sie den generierten Kontext. Mit der folgenden API können Sie die Schemakontexte prüfen, die beim Generieren von SQL-Anweisungen verwendet werden.

    -- For table, view or materialized view.
SELECT
  alloydb_ai_nl.get_relation_context(
    'my_schema.my_table'
  );

-- For column.
SELECT
  alloydb_ai_nl.get_column_context(
    'my_schema.my_table.column1'
  );

  6. Optional: Schemakontext manuell festlegen

    -- For table, view or materialized view.
SELECT
  alloydb_ai_nl.set_relation_context(
    'my_schema.my_table',
    'One-to-many mapping from product to categories'
  );

-- For column.
SELECT
  alloydb_ai_nl.set_column_context(
    'my_schema.my_table.column1',
    'This column provides additional tagged info for the product in  Json format, e.g., additional color or size information of the product - tags: { "color": "red", "size": "XL"}'
  );

Abfragevorlagen erstellen

Um die Qualität von generativen KI-Anwendungen zu verbessern, die mit LLMs erstellt wurden, können Sie Vorlagen hinzufügen. Eine Abfragevorlage ist eine kuratierte Sammlung repräsentativer oder häufiger Fragen in natürlicher Sprache mit entsprechenden SQL-Abfragen sowie Erläuterungen, die eine deklarative Begründung für die Generierung von natürlicher Sprache zu SQL (NL2SQL) liefern. Vorlagen sind in erster Linie für die Angabe durch die Anwendung vorgesehen. Sie können aber auch automatisch von der alloydb_ai_nl-Erweiterung auf Grundlage häufig verwendeter SQL-Abfragen generiert werden. Jede Vorlage muss einem nl_config zugeordnet sein.

Die alloydb_ai_nl-Erweiterung verwendet eine template_store, um relevante SQL-Vorlagen dynamisch in den Prozess der Generierung einer SQL-Anweisung zur Beantwortung der Frage des Endnutzers einzubinden. Die template_store führt folgende Schritte aus:

  • Ermittelt Vorlagen mit ähnlichen Intentionen wie die Frage in natürlicher Sprache, die der Endnutzer gestellt hat.
  • Gibt die entsprechende parametrisierte SQL-Anweisung an.
  • Erstellt eine SQL-Anweisung, indem Parameter mit Werten aus der Frage in natürlicher Sprache instanziiert werden.

Wenn es keine Vorlage mit derselben Intention wie die Frage des Endnutzers gibt, verwendet alloydb_ai_nl alle relevanten Vorlagen und den Kontext, um eine SQL-Anweisung zu erstellen.

Vorlage zum Vorlagenspeicher hinzufügen

Sie fügen Vorlagen hinzu, indem Sie die Frage mit einem Parameter namens intent und die SQL-Abfrage angeben.

Führen Sie die folgende Abfrage aus, um dem Vorlagenspeicher eine Vorlage hinzuzufügen:

SELECT
  alloydb_ai_nl.add_template(
    nl_config_id => 'my_app_config',
    intent => 'How many accounts associated with loans are located in the Prague region?',
    sql => 'SELECT COUNT(T1.account_id)
            FROM bird_dev_financial.account AS T1
            INNER JOIN bird_dev_financial.loan AS T2
              ON T1.account_id = T2.account_id
            INNER JOIN bird_dev_financial.district AS T3
              ON T1.district_id = T3.district_id
            WHERE T3."A3" = ''Prague''',
    check_intent => TRUE
  );

Wenn check_intent TRUE ist, führt alloydb_ai_nl eine semantische Prüfung durch, um zu bestätigen, dass die angegebene Intention mit der übergebenen SQL-Anweisung übereinstimmt. Wenn die Intention nicht mit der SQL-Anweisung übereinstimmt, wird die Vorlage nicht hinzugefügt.

SQL und Intent werden durch alloydb_ai_nl parametrisiert. In der Ansicht alloydb_ai_nl.template_store_view werden die parametrisierten SQL-Anweisungen und ihre Intentionen angezeigt.

SELECT psql
FROM alloydb_ai_nl.template_store_view
WHERE intent = 'How many accounts associated with loans are located in the Prague region?';

Diese Anweisung gibt Folgendes zurück:

SELECT COUNT(T1.account_id)
FROM account AS T1 INNER JOIN loan AS T2
  ON T1.account_id = T2.account_id
INNER JOIN district AS T3
  ON T1.district_id = T3.district_id WHERE T3."A3" = $1

Benutzerdefinierte Parametrisierung bereitstellen

Wenn Sie eine benutzerdefinierte Parametrisierung für eine SQL-Anweisung über die manuelle Schnittstelle der Funktion add_template bereitstellen möchten, führen Sie die Anweisung im folgenden Beispiel aus:

SELECT
  alloydb_ai_nl.add_template(
     nl_config_id => 'my_app_config',
     intent => 'Among the accounts opened, how many customers born before 1950 resided in Slokolov at the time of account opening?',
     sql => $$SELECT COUNT(DISTINCT T2.client_id)
              FROM district AS T1 INNER JOIN client AS T2
                ON T1.district_id = T2.district_id
             INNER JOIN account AS T3 ON T2.client_id IN (
                   SELECT client_id FROM disp WHERE account_id = T3.account_id)
             WHERE to_char(T2.birth_date::timestamp, 'YYYY') < '1950'
               AND T1."A2" = 'Slokolov'$$,
  parameterized_sql => $$SELECT COUNT(DISTINCT T2.client_id)
                         FROM district AS T1 INNER JOIN client AS T2
                           ON T1.district_id = T2.district_id
                   INNER JOIN account AS T3 ON T2.client_id IN (
                         SELECT client_id FROM disp WHERE account_id = T3.account_id)
                   WHERE to_char(T2.birth_date::timestamp, 'YYYY') < $2
                     AND T1."A2" = $1$$,
  parameterized_intent => $$Among the accounts opened, how many customers born before $2 resided in $1 at the time of account opening?$$,
  manifest => $$Among the accounts opened, how many customers born before a given date resided in a given city at the time of account opening?$$,
  check_intent => TRUE);

In der vorherigen Definition wird die Parametrisierung der SQL-Anweisung angegeben. Die Parameter sind $1 und $2 für Slokolov bzw. 1950. Ein Manifest wird als verallgemeinerte Version der Intention bereitgestellt, wobei die Werte von Literalen durch generische Beschreibungen der Werte ersetzt werden.

In diesem Beispiel wird der Wert von 1950 im Intent durch a given date ersetzt und der Wert von Slokolov im Manifest durch a given city. Wenn für das optionale Argument check_intent der Wert TRUE angegeben wird, erfolgt während add_template eine LLM-basierte Intent-Bestätigung. Wenn die angegebene SQL-Anweisung während dieser Prüfung nicht den Zweck und das Ziel der angegebenen Intention erfasst, schlägt add_template fehl und der Grund wird als Ausgabe angegeben.

Im folgenden Beispiel besteht der Zweck der Vorlage – wie im Intent angegeben – darin, die Konto-ID der Konten abzurufen, die mit dem Load verknüpft sind und sich in einer Region befinden. Die angegebene SQL-Anweisung gibt die Anzahl der Konten zurück, nicht die Liste der Konto-IDs, wie im folgenden Beispiel gezeigt.

SELECT
  alloydb_ai_nl.add_template(
    nl_config_id => 'my_app_config',
    intent => 'List the account id for all accounts that associated with loans and are located in the Prague region.',
    sql => 'SELECT COUNT(T1.account_id)
            FROM account AS T1 INNER JOIN loan AS T2
              ON T1.account_id = T2.account_id
            INNER JOIN district AS T3
              ON T1.district_id = T3.district_id
            WHERE T3."A3" = ''Prague''',
    check_intent => TRUE
  );

Wenn check_intent auf TRUE festgelegt ist, können Sie die vorherige Vorlage nicht dem Vorlagenspeicher hinzufügen. Wenn Sie die vorherige Anweisung ausführen, wird ein Fehler ähnlich dem folgenden zurückgegeben:

ERROR:  Checking intent failed, for nl_question:List the account id for all accounts that associated with loans and are located in the Prague region...reason:The SQL query only counts the number of account IDs, but the question asks for a list of the account IDs.

Vorlagen verwalten

Sie können Vorlagen im Vorlagenspeicher mit den folgenden APIs verwalten:

-- To disable a template:
SELECT alloydb_ai_nl.disable_template(INPUT template_id);

-- To enable a template which has been disabled:
SELECT alloydb_ai_nl.enable_template(INPUT template_id);

-- To permanently remove a template:
SELECT alloydb_ai_nl.drop_template(INPUT template_id);

Wenn Sie eine Vorlage erstellen, ist sie standardmäßig aktiviert. Eine deaktivierte Vorlage verbleibt im Vorlagenspeicher, wird aber nicht von alloydb_ai_nl für die Abfragesynthese verwendet. Sie können eine deaktivierte Vorlage mit alloydb_ai_nl.enable_template aktivieren. Wenn Sie alloydb_ai_nl.drop_template ausführen, wird die Vorlage dauerhaft aus dem Vorlagenspeicher entfernt.

Mit alloydb_ai_nl.template_store_view können Sie die template_id einer Vorlage anhand ihres Inhalts extrahieren. Wenn Sie beispielsweise die ID von Vorlagen mit der Intention accounts that associated with loans ermitteln möchten, führen Sie die folgende Abfrage aus. Sie gibt eine Vorlagen-ID zurück und gibt an, ob die Vorlage über alloydb_ai_nl.template_store_view aktiviert ist:

SELECT id, enabled
FROM alloydb_ai_nl.template_store_view
WHERE intent ILIKE '%accounts that associated with loans%';

Vorlage aktualisieren

Wenn Sie die Vorlagen in alloydb_ai_nl.template_store_view verwenden, muss die Intention jeder Vorlage mit den folgenden Punkten übereinstimmen:

  • Die SQL-Anweisung
  • Die parametrisierte SQL-Anweisung
  • Die parametrisierte Intention
  • Das Manifest der Vorlage

alloydb_ai_nl kann relevante Vorlagen abrufen, wenn das für Vorlagen verwaltete Embedding mit dem Vorlageninhalt übereinstimmt.

So aktualisieren Sie eine Vorlage:

  1. Ermitteln Sie die template_id mit alloydb_ai_nl.template_store_view.
  2. Entfernen Sie die Vorlage.
  3. Definieren Sie die neue Vorlage mit der erforderlichen Änderung mithilfe der Funktion alloydb_ai_nl.add_template neu.

Abfragefragmente erstellen

Sie können Vorlagen zur Abfragezeit mithilfe von Fragmenten spezialisieren. So können mit Abfragevorlagen Attributsuchen wie bei Fragen in natürlicher Sprache durchgeführt werden. Ein Fragment ist eine kuratierte Gruppe repräsentativer oder häufig verwendeter Bedingungen in natürlicher Sprache mit entsprechenden SQL-Prädikaten. Fragmente sollen von der Anwendung angegeben werden.

Jedes Fragment muss mit einem nl_config_id und einem Array von Tabellen und Ansichten mit Aliasen verknüpft sein, auf die das Fragmentprädikat angewendet wird. Sie können den Zweck eines Fragments überprüfen, wenn das Argument check_intent auf TRUE festgelegt ist. Die alloydb_ai_nl-Erweiterung kann eine Vorlage mit einer Kombination aus Fragmenten verwenden, um die Antwort auf eine Anfrage in natürlicher Sprache zu erstellen.

Die alloydb_ai_nl-Erweiterung verwendet fragment_store, um die Bedingungen dynamisch in relevante Fragmente einzubinden, wenn eine SQL-Anweisung generiert wird, um die Frage des Endnutzers zu beantworten. Zuerst werden mit template_store Vorlagen mit ähnlichen Intentionen wie die Frage in natürlicher Sprache des Endnutzers identifiziert. Als Nächstes werden die Fragmente abgerufen, die die identifizierten Vorlagen spezialisieren können. Die Parameterersetzung wird sowohl auf Vorlagen als auch auf Fragmente angewendet, um eine SQL-Anweisung zu erstellen.

Parameterwerte werden aus der Frage in natürlicher Sprache extrahiert und vom LLM anhand der Muster ersetzt, die aus relevanten Vorlagen und Fragmenten abgeleitet werden. Wenn die Kombination aus Vorlagen und Fragmenten jedoch nicht denselben Zweck für die Frage des Endnutzers hat, verwendet alloydb_ai_nl jede relevante Vorlage und jeden relevanten Kontext, um eine SQL-Anweisung zu erstellen.

Fragment hinzufügen

Führen Sie die folgenden Beispielabfragen mit der Funktion alloydb_ai_nl.add_fragment aus, um ein Fragment hinzuzufügen. Jedes Fragment muss mit einer nl_config_id-Kennung aus der Anwendung verknüpft sein.

-- A fragment that cannot be parameterized.
SELECT alloydb_ai_nl.add_fragment(
  nl_config_id => 'my_app_config',
  table_aliases => ARRAY['account AS T'],
  intent => 'Accounts with issuance after transaction',
  fragment => 'T.frequency = ''POPLATEK PO OBRATU''',
  check_intent => True);

-- A fragment that can be parameterized.
SELECT alloydb_ai_nl.add_fragment(
  nl_config_id => 'my_app_config',
  table_aliases => ARRAY['district AS T'],
  intent => 'Average salary between 6000 and 10000',
  fragment => 'T."A11" BETWEEN 6000 AND 10000',
  check_intent => True);

Wenn alloydb_ai_nl.add_fragment ausgeführt wird, extrahiert die alloydb_ai_nl-Erweiterung ein Manifest aus dem bereitgestellten Intent und parametrisiert den Intent und die Bedingung für das Fragment, sofern möglich. Verfügbare Fragmente werden durch Ansichten wie alloydb_ai_nl.fragment_store_view verfügbar gemacht, wie im folgenden Beispiel gezeigt:

SELECT manifest, scope, fragment, intent, pfragment, pintent
FROM alloydb_ai_nl.fragment_store_view
WHERE intent = 'Average salary between 6000 and 10000';

Die Abfrage gibt ein Ergebnisset ähnlich dem folgenden zurück:

manifest  | Average salary between a given number and a given number
scope     | district AS T
fragment  | T."A11" BETWEEN 6000 AND 10000
intent    | Average salary between 6000 and 10000
pfragment | T."A11" BETWEEN $2 AND $1
pintent   | Average salary between $2 and $1

Ein Manifest in einem Fragment wird automatisch aus der Intention generiert und stellt eine verallgemeinerte Version der Intention dar. Beispiel: Die Zahlen 6000 und 10000 im Intent werden jeweils durch a given number im Manifest ersetzt. Die Zahlen werden in den Spalten pfragment und pintent durch $2 bzw. $1 ersetzt. Die Spalten pfragment und pintent in alloydb_ai_nl.fragment_store_view sind die parametrisierte Darstellung für fragment bzw. intent.

Wenn Sie ein Fragment mit benutzerdefinierten Parametern versehen möchten, verwenden Sie die manuelle Version von alloydb_ai_nl.add_fragment, wie im folgenden Beispiel gezeigt:

SELECT alloydb_ai_nl.add_fragment(
  nl_config_id => 'my_app_config',
  table_aliases => ARRAY['bird_dev_financial.district AS T'],
  intent => $$districts in 'Prague'$$,
  parameterized_intent => $$districts in $1$$,
  fragment => $$T."A3" = 'Prague'$$,
  parameterized_fragment => $$T."A3" = $1$$,
  manifest => $$districts in a given city$$,
  check_intent => TRUE);

Fragmente verwalten

Verwenden Sie die folgenden APIs, um Fragmente zu verwalten:

-- To disable a fragment:
SELECT alloydb_ai_nl.disable_fragment(INPUT fragment_id);

-- To enable a fragment which has been disabled:
SELECT alloydb_ai_nl.enable_fragment(INPUT fragment_id);

-- To permanently remove a fragment:
SELECT alloydb_ai_nl.drop_fragment(INPUT fragment_id);

Mit der Ansicht alloydb_ai_nl.fragment_store_view können Sie die fragment_id eines Fragments anhand seines Inhalts extrahieren. Wenn Sie beispielsweise die Kennung eines Fragments mit dem Intent Average salary between 6000 and 10000 suchen möchten, führen Sie die folgende Beispielabfrage aus:

SELECT id
FROM alloydb_ai_nl.fragment_store_view
WHERE intent = "Average salary between 6000 and 10000";

Fragment aktualisieren

Wenn Sie ein Fragment aktualisieren, muss der Intent des Fragments mit Folgendem übereinstimmen:

  • Das Manifest und die SQL-Anweisung des Fragments
  • Die parametrisierte SQL-Anweisung
  • Die parametrisierte Intention

So sorgen Sie für Konsistenz, wenn Sie ein Fragment aktualisieren:

  1. Entfernen Sie das Fragment, das Sie ändern möchten, mit der Funktion alloydb_ai_nl.drop_fragment.
  2. Fügen Sie das aktualisierte Fragment mit der Funktion alloydb_ai_nl.add_fragment ein.

Vorlagen automatisch generieren

Sobald Sie einen repräsentativen Datensatz in Ihren Tabellen haben, empfehlen wir, SQL-Abfragen auszuführen, die den häufigen Fragen entsprechen, die Ihre Endnutzer wahrscheinlich stellen werden. Prüfen Sie, ob die Abfragen vollständige Abfragepläne haben und eine gute Leistung erzielen.

Nachdem Sie die Abfragen ausgeführt haben, kann AlloyDB AI Natural Language automatisch Vorlagen basierend auf dem Abfrageverlauf generieren. Sie können die folgenden APIs aufrufen, um Vorlagen zu generieren. Sie müssen die generierten Vorlagen prüfen und anwenden, bevor sie wirksam werden.

Die automatische Generierung von Vorlagen basiert auf den am häufigsten verwendeten Abfragen im Abfragelog google_db_advisor_workload_statements. Die Anfragen werden anhand der folgenden Kriterien gefiltert:

  • SELECT-Anweisungen
  • Ausführbare Dateien: Die Anfrage kann mit dem Befehl EXPLAIN erfolgreich verarbeitet werden.
  • Keine Duplikate: Die Abfrage wurde noch nicht zum Generieren von Vorlagen verwendet.
  • Alle referenzierten Tabellen und Ansichten fallen in den Bereich von nl_config.

So lassen Sie Vorlagen automatisch generieren, überprüfen und anwenden:

  1. Fordern Sie AlloyDB auf, Vorlagen basierend auf Ihrem Abfrageverlauf zu generieren:

    SELECT
  alloydb_ai_nl.generate_templates(
    'my_app_config',
);

    Verwenden Sie die bereitgestellte Ansicht alloydb_ai_nl.generated_templates_view, um die generated_templates zu überprüfen.

    Die folgende Ausgabe zeigt die Anzahl der generierten Vorlagen:

    -[ RECORD 1 ]------+--
generate_templates | 1

  2. Sehen Sie sich die generierten Vorlagen in der generated_templates_view-Ansicht an.

    SELECT *
FROM alloydb_ai_nl.generated_templates_view;

    Im Folgenden finden Sie ein Beispiel für die zurückgegebene Ausgabe:

    -[ RECORD 1 ]----------------------------------------------------------------
id          | 1
config      | my_app_config
type        | Template
manifest    | How many clients have a birth year of a given number?
nl          | How many clients have a birth year of 1997?
sql         | select count(*) from public.client as T where
             to_char(T.birth_date::timestamp, 'YYYY') = '1997';
intent      | How many clients have a birth year of 1997?
psql        | select count(*) from public.client as T where
             to_char(T.birth_date::timestamp, 'YYYY') = $1;
pintent     | How many clients have a birth year of $1?
comment     |
explanation |
weight      | 1

    Die manifest in der zurückgegebenen Ausgabe ist eine allgemeine Vorlage oder eine allgemeine Beschreibung des Fragetyp oder des Vorgangs, der ausgeführt werden kann. pintent ist eine parametrisierte Version von intent. Dabei wird intent verallgemeinert, indem der spezifische Wert (1997) durch einen Platzhalter ($1) ersetzt wird.

  3. Führen Sie die folgende Beispielanweisung aus, um eine generierte Vorlage zu aktualisieren:

    SELECT alloydb_ai_nl.update_generated_template(
  id => 1,
  manifest => 'How many clients are born in a given year?',
  nl => 'How many clients are born in 1997?',
  intent => 'How many clients are born in 1997?',
  pintent => 'How many clients are born in $1?'

);

  4. Wenden Sie die Vorlagen an. Die angewendeten Vorlagen werden sofort dem Vorlagenspeicher hinzugefügt und aus der Überprüfungsansicht gelöscht.

    -- For all templates generated under the nl config.
SELECT
  alloydb_ai_nl.apply_generated_templates('my_app_config');

Sicherheit für natürliche Sprache konfigurieren

Informationen zum Konfigurieren der Sicherheit für AlloyDB AI-Funktionen für natürliche Sprache finden Sie unter Sicherheit von Datenanwendungen mit parametrisierten sicheren Ansichten verwalten.

Konzepttypen und Wertindexe definieren

Sie definieren Konzepttypen und Wertindexe, um ein besseres Verständnis der gestellten Fragen zu ermöglichen. Ein Konzepttyp ist eine Kategorie oder Klasse von Entitäten, die die semantische Bedeutung von Wörtern und Wortgruppen und nicht nur ihre wörtliche Form identifiziert.

Beispiel: Zwei Ländernamen können identisch sein, auch wenn einer in Großbuchstaben (z. B. USA) und der andere in Kleinbuchstaben (z. B. usa) geschrieben ist. In diesem Fall ist der Ländername der Konzepttyp. Weitere Beispiele für Konzepttypen sind Personenname, Ortsname und Datum.

Ein Wertindex ist ein Index für die Werte in den Spalten, die Teil der Konfiguration für natürliche Sprache nl_config sind. Er basiert auf den Konzepttypen, die jeder Spalte zugeordnet sind. Ein Werteindex ermöglicht den effizienten Abgleich von Wertausdrücken für die gestellte Frage und Werten in der Datenbank.

So definieren Sie Konzepttypen und einen Wertindex: In den Beispielen wird eine Spalte einem Konzepttyp zugeordnet, ein Werteindex erstellt und aktualisiert und ein Synonymset verwendet, um eine Wertesuche durchzuführen.

  1. Führen Sie die folgende Abfrage aus, um eine Spalte einem Konzepttyp zuzuordnen:

    SELECT
  alloydb_ai_nl.associate_concept_type(
    column_names_in => 'my_schema.country.country_name',
    concept_type_in => 'country_name',
    nl_config_id_in => 'my_app_config'
  );

  2. So erstellen Sie einen Wertindex basierend auf allen Spalten, die Teil einer Konfiguration in natürlicher Sprache sind und einem Konzepttyp zugeordnet sind:

    SELECT
  alloydb_ai_nl.create_value_index(
    nl_config_id_in => 'my_app_config'
  );

  3. Wenn Sie Konzepttypen neuen Spalten zuordnen, aktualisieren Sie den Wertindex, damit die Änderungen berücksichtigt werden.

    SELECT
  alloydb_ai_nl.refresh_value_index(
    nl_config_id_in => 'my_app_config'
  );

  4. Führen Sie die folgende Beispielanweisung aus, um AlloyDB AI-Funktionen für natürliche Sprache zu aktivieren, damit Synonyme eines Werts berücksichtigt werden:

    SELECT
  alloydb_ai_nl.insert_synonym_set(
    ARRAY [
      'USA',
      'US',
      'United States',
      'United States of America'
    ]
  );

    Auch wenn in den Daten in Ihren Tabellen ein bestimmter Wert verwendet wird, z. B. United States zur Identifizierung eines Landes, können Sie eine Synonymgruppe definieren, die alle Synonyme für United States enthält. Wenn eines der Synonyme in der Frage in natürlicher Sprache vorkommt, gleicht AlloyDB AI die Synonyme mit den Werten in Ihren Tabellen ab.

  5. Führen Sie eine Wertsuche durch, um die richtigen Datenbankwerte für ein Array von Wertformulierungen zu finden.

    SELECT
  alloydb_ai_nl.get_concept_and_value(
    value_phrases_in => ARRAY['United States'],
    nl_config_id_in  => 'my_app_config'
  );

    Wenn ein Nutzer beispielsweise eine Frage wie „Wie viele Einwohner hat die USA?“ stellt, die die folgende get_sql-Abfrage verwendet, verwendet AlloyDB AI Natural Language die get_concept_and_value-Funktion mit dem Wertausdruck United States, um eine unscharfe Suche in den Wertindexen durchzuführen. Bei der Fuzzy-Suche werden Übereinstimmungen gefunden, auch wenn die Suchanfrage nicht genau mit den entsprechenden Daten übereinstimmt.

    Mit natürlicher Sprache wird ein Ergebnis – der Wert USA – gefunden, das der Suchanfrage nahekommt. Dieses Ergebnis wird dann verwendet, um die SQL-Abfrage zu generieren.

    SELECT
  alloydb_ai_nl.get_sql(
    nl_config_id    => 'my_app_config',
    nl_question     => 'What is the population of the United States?',
    additional_info => json_build_object('enrich_nl_question', TRUE)
  ) ->> 'sql';

    In der folgenden Tabelle sind die integrierten Konzepttypen aufgeführt, die von AlloyDB AI Natural Language definiert werden.

    Konzeptname Beschreibung
    generic_entity_name Für einen generischen Entitätsnamen kann eine einzelne Spalte vom Typ „String“ verwendet werden. Beispiel:
      SELECT alloydb_ai_nl.associate_concept_type('public.item.item_name', 'generic_entity_name')
    country_name, city_name, region_name Namen von Ländern, Städten und Regionen. Die Verwendung ist genau dieselbe wie beim Konzepttyp generic_entity_name.
    full_person_name Name der Person, bestehend aus Vor-, Nach- und zweitem Vornamen. Für den vollständigen Namen einer Person können bis zu drei Spalten vom Typ „String“ verwendet werden. Beim Zuordnen von Namensspalten zu full_person_name können beliebige Spalten übersprungen werden. Beispiel: 
      SELECT alloydb_ai_nl.associate_concept_type('public.person.last_name,public.person.first_name,public.person.middle_name','full_person_name')
    ssn Eine einzelne Stringspalte mit einer Sozialversicherungsnummer. Beispiel:
      SELECT alloydb_ai_nl.associate_concept_type('public.person.ssn','ssn')
    date Ein Datum oder ein Zeitstempel. Beispiel:
     SELECT alloydb_ai_nl.associate_concept_type('public.person.date_col','date')

Konzepttypzuordnungen automatisch generieren

Wenn Sie Spalten automatisch mit Konzepttypen verknüpfen möchten, verwenden Sie die Funktion für die automatische Zuordnung von Konzepttypen der AlloyDB AI Natural Language API. Eine Konzepttypzuordnung definiert die Beziehung zwischen einem Konzepttyp und einer oder mehreren Datenbankspalten. Sie ist eine Voraussetzung für das Erstellen von Wertindexen.

So lassen Sie automatisch Zuordnungen von Konzepttypen generieren:

  1. Rufen Sie die folgenden APIs auf, um Zuordnungen zu generieren.

    -- To cover all relations within the scope of a provided nl_config.
SELECT alloydb_ai_nl.generate_concept_type_associations(
  nl_config => 'my_app_config'
);

-- To cover a specific relation.
SELECT alloydb_ai_nl.generate_concept_type_associations(
  nl_config => 'my_app_config',
  relation_name => 'my_app_table'
);

  2. Sehen Sie sich die generierten Zuordnungen an, indem Sie die folgende Abfrage ausführen.

    SELECT * FROM alloydb_ai_nl.generated_value_index_columns_view;

  3. Optional: Aktualisieren Sie die generierten Assoziationen.

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

  4. Optional: Entfernen Sie eine automatisch generierte Verknüpfung.

    SELECT alloydb_ai_nl.drop_generated_concept_type_association(id => 1);

  5. Wenden Sie die generierten Zuordnungen an.

    -- To apply all associations under a nl config.
SELECT alloydb_ai_nl.apply_generated_concept_type_associations(
  nl_config => 'my_app_config'
);

-- To apply a specific association by id.
SELECT alloydb_ai_nl.apply_generated_concept_type_association(
  id => 1
);

  6. Aktualisieren Sie den Wertindex, damit die Änderungen berücksichtigt werden.

    SELECT alloydb_ai_nl.refresh_value_index(
  nl_config_id_in => 'my_app_config'
);

SQL-Anweisungen aus Eingaben in natürlicher Sprache generieren

Mit AlloyDB AI können Sie SQL-Anweisungen aus Eingaben in natürlicher Sprache generieren. Wenn Sie die generierte SQL-Anweisung ausführen, werden die Daten aus der Datenbank bereitgestellt, die Sie zum Beantworten der Frage in natürlicher Sprache benötigen.

  1. Wenn Sie natürliche Sprache verwenden möchten, um mit der Funktion alloydb_ai_nl.get_sql Ergebnisse aus Ihrer Datenbank abzurufen, können Sie das folgende Beispiel verwenden:

    SELECT
  alloydb_ai_nl.get_sql(
    'my_app_config', -- nl_config
    'What is the sum that client number 4''s account has following transaction 851?' -- nl question
  );

    Die folgende JSON-Ausgabe wird zurückgegeben:

    {
  "sql": "SELECT T3.balance FROM public.client AS T1 INNER JOIN public.account AS T2 ON T1.district_id = T2.district_id INNER JOIN public.trans AS T3 ON T2.account_id = T3.account_id WHERE T1.client_id = 4 AND T3.trans_id = 851",
  "prompt": "",
  "retries": 0,
  "error_msg": "",
  "nl_question": "What is the sum that client number 4's account has following transaction 851?"
}

  2. Optional: Wenn Sie die generierte SQL-Abfrage als Textstring extrahieren möchten, fügen Sie ->>'sql' hinzu:

    SELECT
  alloydb_ai_nl.get_sql(
    'my_app_config', -- nl_config
    'What is the sum that client number 4''s account has following transaction 851?' -- nl question
  ) ->> 'sql';

    Mit dem Operator ->> wird ein JSON-Wert als Text extrahiert. Die Funktion alloydb_ai_nl.get_sql gibt ein JSON-Objekt zurück. Das ist der Teil der Anweisung, mit dem der Wert abgerufen wird, der dem Schlüssel sql zugeordnet ist. Dieser Wert ist die generierte SQL-Abfrage.

Zusammenfassungen von Ergebnissen aus Eingaben in natürlicher Sprache generieren

Mit AlloyDB AI können Sie Zusammenfassungen von Ergebnissen aus Eingaben in natürlicher Sprache generieren. Mit der Funktion alloydb_ai_nl.get_sql_summary wird die Frage in natürlicher Sprache sicher für die zugrunde liegende Tabelle ausgeführt, eine Zusammenfassung einer Stichprobe des Ergebnissatzes erstellt und die Zusammenfassung in natürlicher Sprache zurückgegeben.

Wenn Sie eine Zusammenfassung der Ergebnisse für eine Frage in natürlicher Sprache in Ihrer Datenbank erstellen möchten, verwenden Sie die Funktion alloydb_ai_nl.get_sql_summary, wie im folgenden Beispiel gezeigt:

SELECT
  alloydb_ai_nl.get_sql_summary(
    nl_config_id => 'my_app_config',
    nl_question => 'Give me the total number of accounts and the earliest opening date and other information for accounts who choose issuance after transaction are staying in east Bohemia region?');

Durch Aufrufen der vorherigen Anweisung wird das folgende JSON-Objekt generiert:

{
  "answer": "The result set indicates that there are 13 accounts that chose issuance after a transaction and are located in the East Bohemia region. The earliest opening date among these accounts is August 21, 1993. Other information about these accounts is not provided in the result set."
}

Sie können die Tabellen und Ansichten, auf die in einer Abfrage in alloydb_ai_nl.get_sql_summary zugegriffen wird, mit einer oder mehreren parametrisierten sicheren Ansichten schützen. Die Parameternamen und ihre Werte sind für eine Anwendung verfügbar und werden von alloydb_ai_nl.get_sql_summary benötigt.

Die Anwendung möchte beispielsweise den Parameter user_id für einen authentifizierten Nutzer mit der User-ID 123 bereitstellen. Dazu müssen Sie die Eingaben param_names und param_values angeben, wie im folgenden Beispiel gezeigt:

SELECT
  alloydb_ai_nl.get_sql_summary(
    nl_config_id => 'my_app_config',
    nl_question => 'Give me the total number of accounts and the earliest opening date and other information for accounts who choose issuance after transaction are staying in east Bohemia region?',
    param_names => ARRAY ['user_id'],
    param_values => ARRAY ['123']
);

Durch die Angabe der Argumente param_names und param_values wird sichergestellt, dass die entsprechenden Sicherheitsfilter angewendet werden, wenn das Ergebnisset erstellt und die Zusammenfassung generiert wird, falls die Frage nl_question mit einer SQL-Anweisung beantwortet werden kann, die durch parametrisierte sichere Ansichten erzwungen wird.

Testen und optimieren

Um die automatisch generierten Abfragen zu verbessern, ändern Sie den Kontext oder fügen Sie besseren Kontext hinzu, verwenden Sie Abfragevorlagen und Wertindexe und wiederholen Sie den Vorgang, bis Sie die gewünschten Ergebnisse erhalten.

Nächste Schritte