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

Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

SQL-Abfragen aus 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 können Sie für Nutzer sichtbare generative KI-Anwendungen erstellen, die Datenbanken mit natürlicher Sprache abfragen.

So aktivieren Sie die Erweiterung alloydb_ai_nl, die die API für die Unterstützung natürlicher Sprache in AlloyDB Omni ist:

Installieren Sie die Erweiterung alloydb_ai_nl.
Definieren Sie eine Konfiguration in natürlicher Sprache für Ihre Anwendung.
Schema registrieren
Kontext hinzufügen
Fügen Sie Abfragevorlagen hinzu.
Konzepttypen definieren und einen Werteindex erstellen
SQL-Anweisungen über eine Schnittstelle für natürliche Sprache generieren

Hinweis

Hier erfahren Sie, wie Sie die AlloyDB Omni-Datenbank installieren und eine Verbindung dazu 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 natürliche Sprache 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

Zur Vorbereitung auf das Generieren von Abfragen in natürlicher Sprache müssen Sie die erforderliche Erweiterung installieren, eine Konfiguration erstellen und ein Schema registrieren.

Erweiterung „alloydb_ai_nl“ installieren

Die Erweiterung alloydb_ai_nl verwendet die Erweiterung google_ml_integration, 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 AlloyDB Omni-Datenbank her und führen Sie den folgenden Befehl aus:

CREATE EXTENSION alloydb_ai_nl cascade;

Erweiterung „alloydb_ai_nl“ aktualisieren

Prüfen Sie, ob Sie die aktuelle Version der alloydb_ai_nl-Erweiterung haben. Wenn Sie die Erweiterung bereits installiert haben, prüfen Sie, ob eine neue Version verfügbar ist, und aktualisieren Sie die Erweiterung, wenn Sie nicht die aktuelle Version verwenden.

Prüfen Sie, ob Sie die Erweiterung aktualisieren müssen. Wenn die default_version-Version aktueller ist als die installed_version-Version, 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 in natürlicher 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 einem Schema, 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

Zu den allgemeinen Kontextelementen gehören anwendungsspezifische Regeln, Geschäftslogikanweisungen 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 domainspezifische 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 vorherige Anweisung hilft AlloyDB AI Natural Language, qualitativ hochwertigere Antworten auf Fragen von Nutzern in natürlicher Sprache zu liefern.

Allgemeine Kontexte für die angegebene Konfiguration ansehen.

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

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

Sie können Vorlagen hinzufügen, um die Qualität von generativen KI-Anwendungen zu verbessern, die mit LLMs erstellt wurden. Eine Abfragevorlage ist eine 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 SQL-Abfragen aus natürlicher Sprache (NL2SQL) liefern.

Vorlagen sind in erster Linie für die Angabe durch die Anwendung vorgesehen, können aber auch automatisch von der alloydb_ai_nl-Erweiterung basierend auf häufig verwendeten SQL-Abfragen generiert werden. Jede Vorlage muss mit einem nl_config verknüpft sein.

Die alloydb_ai_nl-Erweiterung verwendet einen template_store, um relevante SQL-Vorlagen dynamisch in den Prozess der Generierung einer SQL-Anweisung einzubinden, mit der die Frage des Endnutzers beantwortet wird. Der template_store führt Folgendes 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 Kontexte, um eine SQL-Anweisung zu erstellen.

Vorlage zum Vorlagenspeicher hinzufügen

Sie fügen Vorlagen hinzu, indem Sie die Frage mit dem Parameter 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 den Wert TRUE hat, führt alloydb_ai_nl eine semantische Prüfung durch, um zu bestätigen, dass die angegebene Absicht mit der übergebenen SQL-Anweisung übereinstimmt. Wenn die Absicht nicht mit der SQL-Anweisung übereinstimmt, wird die Vorlage nicht hinzugefügt.

SQL und Intention werden durch alloydb_ai_nl parametrisiert. In der Ansicht alloydb_ai_nl.template_store_view werden die parametrisierten SQL-Anweisungen und ihre Absichten 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 des Intents 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 und der Wert von Slokolov im Manifest durch a given city ersetzt. Wenn für das optionale Argument check_intent der Wert TRUE angegeben wird, wird während add_template eine LLM-basierte Intent-Überprüfung durchgeführt. Wenn die bereitgestellte SQL-Anweisung während dieser Prüfung nicht dem Zweck und Ziel der bereitgestellten 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 bereitgestellte 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 gesetzt ist, können Sie die vorherige Vorlage nicht dem Vorlagenspeicher hinzufügen. Wenn Sie die vorherige Anweisung ausführen, wird ein Fehler wie der folgende 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 bleibt im Vorlagenspeicher, wird aber von alloydb_ai_nl nicht 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 den template_id einer Vorlage anhand ihres Inhalts extrahieren. Wenn Sie beispielsweise die ID von Vorlagen mit der Intention accounts that associated with loans suchen 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
Der parametrisierte Intent
Das Manifest der Vorlage

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

So aktualisieren Sie eine Vorlage:

template_id mit alloydb_ai_nl.template_store_view identifizieren.
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, damit Abfragevorlagen eine Attributsuche wie Fragen in natürlicher Sprache durchführen können. 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 Erweiterung alloydb_ai_nl kann eine Vorlage mit einer Kombination aus Fragmenten verwenden, um die Antwort auf eine Anfrage in natürlicher Sprache zu synthetisieren.

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 identifiziert der template_store Vorlagen mit ähnlichen Absichten wie die Frage in natürlicher Sprache, die der Endnutzer gestellt hat. 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 durch die Muster ersetzt, die sich aus relevanten Vorlagen und Fragmenten ergeben. Wenn die Kombination aus Vorlagen und Fragmenten jedoch nicht den Zweck der Frage des Endnutzers erfüllt, 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-ID 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 Erweiterung alloydb_ai_nl 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 im Manifest jeweils durch a given number 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 eine benutzerdefinierte Parametrisierung eines Fragments bereitstellen 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 die Intent des Fragments mit Folgendem übereinstimmen:

Das Manifest und die SQL-Anweisung des Fragments
Die parametrisierte SQL-Anweisung
Der parametrisierte Intent

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 ein repräsentatives Dataset in Ihren Tabellen haben, empfehlen wir, SQL-Abfragen auszuführen, die den häufigen Fragen entsprechen, die Ihre Endnutzer wahrscheinlich stellen werden. Achten Sie darauf, dass die Abfragen vollständige Abfragepläne haben und eine gute Leistung erzielen.

Nachdem Sie die Abfragen ausgeführt haben, kann AlloyDB AI natürliche Sprache 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 Vorlagenerstellung basiert auf den am häufigsten verwendeten Abfragen im Abfrageprotokoll google_db_advisor_workload_statements. Die Abfragen werden anhand der folgenden Kriterien gefiltert:

SELECT-Anweisungen
Ausführbare Dateien: Die Abfrage kann mit dem Befehl EXPLAIN erfolgreich verarbeitet werden.
Keine Duplizierung: Die Abfrage wurde zuvor nicht zum Generieren von Vorlagen verwendet.
Alle referenzierten Tabellen und Ansichten befinden sich im Bereich von nl_config.

So können Sie Vorlagen automatisch generieren, prüfen und anwenden:

Fordern Sie AlloyDB for PostgreSQL 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
```

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

SELECT *
FROM alloydb_ai_nl.generated_templates_view;

Hier 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

Der manifest in der zurückgegebenen Ausgabe ist eine allgemeine Vorlage oder eine allgemeine Beschreibung des Fragetyps oder des Vorgangs, der ausgeführt werden kann. Der pintent ist eine parametrisierte Version des intent und verallgemeinert den intent, 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 von Ihnen 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 identifiziert, nicht nur ihre wörtliche Form.

Beispielsweise können zwei Ländernamen identisch sein, auch wenn ein Ländername 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, Stadtname und Datum.

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

So definieren Sie Konzepttypen und einen Wertindex: In den Beispielen wird eine Spalte mit einem Konzepttyp verknüpft, ein Wertindex erstellt und aktualisiert und ein Synonymsatz für eine Wertsuche verwendet.

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 mit neuen Spalten verknüpfen, aktualisieren Sie den Wertindex, um die Änderungen zu übernehmen.
```
SELECT
  alloydb_ai_nl.refresh_value_index(
    nl_config_id_in => 'my_app_config'
  );
  ```
```
Aktivieren Sie AlloyDB AI natürliche Sprache, 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 Wertphrasen 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, verwendet die AlloyDB AI-Funktion für natürliche Sprache die get_concept_and_value-Funktion mit der Wertphrase United States, um eine Fuzzy-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 nahe kommt, 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 natürliche Sprache definiert werden.

Konzeptname	Beschreibung
`generic_entity_name`	Eine einzelne Spalte vom Typ „String“ kann für einen generischen Entitätsnamen 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`	Der Name der Person, bestehend aus Vor-, Nach- und Mittelnamen. Für den vollständigen Namen einer Person können bis zu drei Spalten vom Typ „String“ verwendet werden. Alle Spalten können übersprungen werden, wenn Namensspalten mit dem `full_person_name` verknüpft 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')

Automatische Zuordnung von Konzepttypen

Wenn Sie Spalten automatisch mit Konzepttypen verknüpfen möchten, verwenden Sie die Funktion zur automatischen 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 lassen Sie automatisch Zuordnungen von Konzepttypen generieren:

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

Prüfen Sie die generierten Verknüpfungen.

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 Verknüpfungen 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, verwenden Sie das folgende Beispiel:

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, der den mit dem Schlüssel sql verknüpften Wert abruft. 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 Ergebniszusammenfassungen aus Eingaben in natürlicher Sprache generieren. Die Funktion alloydb_ai_nl.get_sql_summary führt die Frage in natürlicher Sprache sicher für die zugrunde liegende Tabelle aus, fasst eine Stichprobe der Ergebnismenge zusammen und gibt die Zusammenfassung in natürlicher Sprache zurück.

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 den Lesezugriff auf die Tabellen und Ansichten, auf die eine Abfrage in alloydb_ai_nl.get_sql_summary zugreift, mit einer oder mehreren parametrisierten sicheren Ansichten sichern. 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 Nutzer-ID 123 bereitstellen. Dazu geben Sie die Eingaben param_names und param_values an, 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 festgelegten Sicherheitsfilter angewendet werden, wenn die nl_question durch eine SQL-Anweisung beantwortet werden kann, die durch parametrisierte sichere Ansichten erzwungen wird, und die Ergebnismenge und die Zusammenfassung generiert werden.

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