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

Diese Seite wurde von der Cloud Translation API übersetzt.

SQL-Abfragen mit Fragen in natürlicher Sprache generieren

Wählen Sie eine Dokumentationsversion aus:

Sie können SQL-Anweisungen mit AlloyDB AI Natural Language einrichten, konfigurieren und generieren. So lassen sich generative KI-Anwendungen für Nutzer erstellen, die Datenbanken mit natürlicher Sprache abfragen.

Um die alloydb_ai_nl-Erweiterung zu aktivieren, die die API für die Unterstützung natürlicher Sprache für AlloyDB for PostgreSQL ist, führen Sie die folgenden allgemeinen Schritte aus:

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

Hinweise

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

Erforderliche Erweiterung aktivieren

Bevor Sie AlloyDB AI Natural Language installieren und verwenden, müssen Sie die Erweiterung aktivieren. Führen Sie dazu den folgenden PostgreSQL-Befehl in der Datei postgresql.conf aus:

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

AlloyDB Omni und AlloyDB AI installieren

AlloyDB Omni installieren Sie verwenden die AlloyDB for PostgreSQL-Instanz, um die Anwendungsdatenbank und das Schema zu erstellen.
AlloyDB AI in AlloyDB Omni installieren

Erforderliche Rollen

Sie benötigen eine Superuser-Rolle, um die alloydb_ai_nl-Erweiterung zu installieren und anderen Nutzern Zugriff zu gewähren. Der postgres-Standardnutzer hat eine Superuser-Rolle. Weitere Informationen finden Sie unter Übersicht über AlloyDB Omni-Nutzerrollen.

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

So installieren Sie die alloydb_ai_nl-Erweiterung:

AlloyDB AI in AlloyDB Omni aktivieren
Stellen Sie eine Verbindung zur Datenbank her und führen Sie den folgenden Befehl aus: AlloyDB Omni for Containers

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 aktuelle Version verwenden. Weitere Informationen zur Erweiterung alloydb_ai_nl finden Sie in der Übersicht über AlloyDB AI Natural Language.

Prüfen Sie, ob Sie die Erweiterung aktualisieren müssen. Wenn die default_version später als die installed_version ist, aktualisieren Sie die Erweiterung.
```
SELECT * FROM pg_available_extensions where name = 'alloydb_ai_nl';
```
Führen Sie ein Upgrade der Erweiterung durch.
```
ALTER EXTENSION alloydb_ai_nl UPDATE;
```

Konfiguration für natürliche Sprache erstellen und Schema registrieren

In AlloyDB AI Natural Language wird nl_config verwendet, 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.

Erstellen Sie eine Konfiguration in natürlicher Sprache anhand des folgenden Beispiels:
```
SELECT
  alloydb_ai_nl.g_create_configuration(
    'my_app_config'        -- configuration_id
  );
```
gemini-2.0-flash:generateContent ist der Modellendpunkt.

Registrieren Sie ein Schema für eine bestimmte Konfiguration anhand des folgenden Beispiels.

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:

Fügen Sie mit der folgenden Beispielabfrage ein allgemeines Kontextelement für die angegebene Konfiguration hinzu:
```
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 obige Anweisung hilft AlloyDB AI Natural Language, Nutzern qualitativ hochwertigere Antworten auf Fragen in natürlicher Sprache zu geben.
Hier können Sie die allgemeinen Kontexte für die angegebene Konfiguration aufrufen.
```
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.

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

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

Sehen Sie sich die generierten Schemakontexte an.
```
SELECT schema_object, object_context
FROM alloydb_ai_nl.generated_schema_context_view;
```
Die generierten Schemakontexte werden in der vorherigen Ansicht gespeichert.

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

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

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

Wenden Sie den generierten Schemakontext an.
```
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 für „nla_demo_cfg“ registriert sind.

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äufig verwendeter 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 mit einem nl_config verknüpft sein.

Die alloydb_ai_nl-Erweiterung verwendet eine template_store, um dynamisch relevante SQL-Vorlagen 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
  ```

### Provide a customized parameterization {:#custom-parameterization}

To provide a customized parameterization for a SQL statement using the manual
interface of the `add_template` function, run the statement in the following
example:

```sql
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 dem Zweck und Ziel der angegebenen Intention entspricht, 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 der Last 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 Abfragegenerierung 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 endgültig 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 Kennung von Vorlagen mit der Intention accounts that associated with loans ermitteln möchten, führen Sie die folgende Abfrage aus. Sie gibt eine Vorlagenkennung zurück und gibt an, ob die Vorlage von alloydb_ai_nl.template_store_view aus 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

Mit alloydb_ai_nl können relevante Vorlagen abgerufen werden, wenn die für Vorlagen gespeicherten Einbettungen mit dem Inhalt der Vorlagen übereinstimmen.

So aktualisieren Sie eine Vorlage:

Ermitteln Sie die template_id mit alloydb_ai_nl.template_store_view.
Entfernen Sie die Vorlage.
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 gängiger 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 prü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 generieren.

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 von 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 von Ansichten wie alloydb_ai_nl.fragment_store_view bereitgestellt, 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 dem Intent generiert und stellt eine verallgemeinerte Version des Intents 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 benutzerdefiniert parametrisieren 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:

Entfernen Sie das Fragment, das Sie ändern möchten, mit der Funktion alloydb_ai_nl.drop_fragment.
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 nach den folgenden Kriterien gefiltert:

SELECT-Anweisungen
Ausführbare Dateien: Die Abfrage 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:

Fordern Sie AlloyDB for PostgreSQL auf, Vorlagen basierend auf Ihrem Anfrageverlauf 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
```

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.

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

);

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 Natural Language 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.

Beispielsweise können zwei Ländernamen gleich 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 Werte in den Spalten, die Teil der Konfiguration nl_config in natürlicher Sprache sind. Er basiert auf den Konzepttypen, die jeder Spalte zugeordnet sind. Ein Wertindex ermöglicht den effizienten Abgleich von Wertformulierungen für die gestellte Frage und Werten in der Datenbank.

Gehen Sie anhand der Beispiele so vor, um Konzepttypen und einen Wertindex zu definieren. In den Beispielen wird eine Spalte einem Konzepttyp zugeordnet, ein Werteindex erstellt und aktualisiert und ein Synonymsatz verwendet, um eine Wertesuche durchzuführen.

Spalte mit einem Konzepttyp verknüpfen

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

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'
  );
  ```
```
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'
  );
  ```
```
Aktivieren Sie AlloyDB AI Natural Language, um Synonyme eines Werts abzugleichen.
```
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 einer der Synonyme in der Frage in natürlicher Sprache vorkommt, gleicht AlloyDB AI Natural Language die Synonyme mit den Werten in Ihren Tabellen ab.
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 haben die USA?“ stellt, die die folgende get_sql-Abfrage verwendet, wird in AlloyDB AI Natural Language die get_concept_and_value-Funktion mit dem Wertausdruck United States verwendet, 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.

Die natürliche Sprache findet ein Ergebnis – den Wert USA –, das der Suchanfrage nahekommt, und verwendet dieses Ergebnis, 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';
```

Integrierte Konzepttypen, die von AlloyDB AI Natural Language definiert werden

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, die eine Sozialversicherungsnummer enthält. 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 Verknüpfung von Konzepttypen der AlloyDB AI Natural Language API. Eine Konzepttypzuordnung definiert die Beziehung zwischen einem Konzepttyp und einer oder mehreren Datenbankspalten. Das ist eine Voraussetzung für das Erstellen von Wertindexen.

So werden Konzepttypzuordnungen automatisch generiert:

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

Sehen Sie sich die generierten Assoziationen an.

SELECT * FROM alloydb_ai_nl.generated_value_index_columns_view;

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

Optional: Entfernen Sie eine generierte Verknüpfung.

SELECT alloydb_ai_nl.drop_generated_concept_type_association(id => 1);

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

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 Natural Language 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.

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

  The following JSON output is returned:

  ```Json
  {
  "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?"
  }
  ```

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 Natural Language 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 erstellt:

{
  "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 angegebenen Sicherheitsfilter angewendet werden, wenn die nl_question durch eine SQL-Anweisung beantwortet werden kann, die durch parametrisierte sichere Ansichten erzwungen wird, und das Ergebnisset erstellt und die Zusammenfassung generiert wird.

Testen und optimieren

Wenn Sie die automatisch generierten Abfragen verbessern möchten, ä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 erzielen.