Diese Seite wurde von der Cloud Translation API übersetzt.

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:

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

Fordern Sie Zugriff auf die Verarbeitung natürlicher Sprache in AlloyDB AI an und warten Sie, bis Sie die Bestätigung der Aktivierung erhalten, bevor Sie der Anleitung auf dieser Seite folgen.
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.

Cluster erstellen und Vertex AI-Integration aktivieren

AlloyDB-Cluster und ‑Instanz erstellen Sie verwenden die AlloyDB-Instanz, um die Anwendungsdatenbank und das Schema zu erstellen.
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:

roles/alloydb.admin: die vordefinierte IAM-Rolle „AlloyDB Admin“

Weitere Informationen finden Sie unter PostgreSQL-Nutzer mit integrierter Authentifizierung 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;

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.

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.

Verwenden Sie das folgende Beispiel, um ein Schema für eine bestimmte Konfiguration zu registrieren:

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 zum Beantworten einer Frage eines Endnutzers verwenden können. Der Kontext umfasst Schemastruktur und ‑beziehungen, Zusammenfassungen und Beschreibungen von Spalten, Spaltenwerten und ihrer Semantik sowie 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:

Verwenden Sie das folgende Beispiel, um ein allgemeines Kontext-Element 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.
Führen Sie die folgende Anweisung 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, darunter 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, indem Sie die folgende Anweisung ausführen:
```
SELECT schema_object, object_context
FROM alloydb_ai_nl.generated_schema_context_view;
```
Die generierten Schemakontexte werden in der vorherigen Ansicht gespeichert.

Optional: Führen Sie die folgende Anweisung aus, um die generierten Schemakontexte zu aktualisieren:

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 generated_schema_context_view gelöscht. Führen Sie den folgenden Befehl aus:

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

Optional: Führen Sie die folgende Anweisung aus, um den Schemakontext manuell festzulegen:

-- 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 ein template_store, um relevante SQL-Vorlagen dynamisch in den Prozess der Generierung einer SQL-Anweisung zur Beantwortung der Nutzerfrage einzubinden. Das template_store identifiziert Vorlagen mit ähnlichen Intentionen wie die Frage in natürlicher Sprache, die gestellt wurde, identifiziert die entsprechende parametrisierte SQL-Anweisung und erstellt eine SQL-Anweisung, indem Parameter mit Werten aus der Frage in natürlicher Sprache instanziiert werden. Wenn es jedoch keine Vorlage mit derselben Intention wie die Frage des Nutzers gibt, verwendet alloydb_ai_nl alle relevanten Vorlagen und den Kontext, um eine SQL-Anweisung zu erstellen.

Wenn Sie Vorlagen hinzufügen möchten, geben Sie die Frage mit einem Parameter namens intent und die SQL-Abfrage an.

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

SELECT
  alloydb_ai_nl.add_template(
    nl_config => '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.

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. Es ist wichtig, dass Sie dafür sorgen, dass die Abfragen gute Abfragepläne haben und leistungsstark sind.

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: Der Befehl EXPLAIN verarbeitet die Anfrage erfolgreich.
Keine Duplikate: Die Abfrage wurde nicht zuvor 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 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 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-Funktionen für natürliche Sprache finden Sie unter Sicherheit von Datenanwendungen mit parametrisierten sicheren Ansichten verwalten.

Konzepttypen und Wertindex 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.

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

Wenn Sie einen Wertindex auf Grundlage aller Spalten erstellen möchten, die Teil einer Konfiguration in natürlicher Sprache sind und einem Konzepttyp zugeordnet sind, führen Sie die folgende Anweisung aus:
```
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. Verwenden Sie die folgende Anweisung:
```
SELECT
  alloydb_ai_nl.refresh_value_index(
    nl_config_id_in => 'my_app_config'
  );
```
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.

Führen Sie mit der folgenden Anweisung 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, verwendet AlloyDB AI Natural Language die Funktion get_concept_and_value 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 ähnelt. 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')

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.

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?"
}

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.

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.