Aktivieren von Aurora-PostgreSQL-Erweiterungen in Ihrem Babelfish-DB-Cluster Verwenden von Babelfish mit Amazon S3 Verwenden Sie Babelfish mit AWS Lambda Verwenden von pg_stat_statements in Babelfish Verwendung von pgvector in Babelfish Verwenden von Amazon Aurora Machine Learning mit Babelfish

Verwenden von Aurora PostgreSQL-Erweiterungen mit Babelfish

Aurora PostgreSQL bietet Erweiterungen für die Arbeit mit anderen AWS Diensten. Dies sind optionale Erweiterungen, die verschiedene Anwendungsfälle unterstützen, z. B. die Verwendung von Amazon S3 mit Ihrem DB-Cluster zum Importieren oder Exportieren von Daten.

Wenn Sie Daten aus einem Amazon S3 Bucket in Ihren Babelfish-DB-Cluster importieren möchten, richten Sie die Aurora-PostgreSQL-Erweiterung aws_s3 ein. Mit dieser Erweiterung können Sie auch Daten aus Ihrem Aurora-PostgreSQL-DB-Cluster in einen Amazon S3 Bucket exportieren.
AWS Lambda ist ein Rechendienst, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Sie können Lambda-Funktionen verwenden, um zum Beispiel Ereignisbenachrichtigungen von Ihrer DB-Instance zu verarbeiten. Weitere Informationen zu Lambda finden Sie unter Was ist AWS Lambda? im AWS Lambda -Entwicklerhandbuch. Zum Aufrufen von Lambda-Funktionen aus Ihrem Babelfish-DB-Cluster richten Sie die Aurora-PostgreSQL-Erweiterung aws_lambda ein.

Um diese Erweiterungen für Ihren Babelfish-Cluster einzurichten, müssen Sie zuerst dem internen Babelfish-Benutzer die Erlaubnis erteilen, die Erweiterungen zu laden. Nachdem Sie die Berechtigung erteilt haben, können Sie dann Aurora-PostgreSQL-Erweiterungen laden.

Aktivieren von Aurora-PostgreSQL-Erweiterungen in Ihrem Babelfish-DB-Cluster

Bevor Sie die aws_s3- oder aws_lambda-Erweiterungen laden können, müssen Sie Ihrem Babelfish-DB-Cluster die erforderlichen Berechtigungen gewähren.

In der folgenden Vorgehensweise wird das psql-PostgreSQL-Befehlszeilen-Tool für die Verbindung mit dem DB-Cluster verwendet. Weitere Informationen finden Sie unter Herstellen einer Verbindung mit Ihrem psql. Sie können auch pgAdmin verwenden. Details hierzu finden Sie unter Herstellen einer Verbindung mit dem DB-Cluster mit pgAdmin.

Dieses Verfahren lädt sowohl aws_s3 als auch aws_lambda nacheinander. Sie müssen nicht beides laden, wenn Sie nur eine dieser Erweiterungen verwenden möchten. Die aws_commons-Erweiterung wird von beiden Optionen benötigt und wird standardmäßig geladen, wie in der Ausgabe gezeigt.

Richten Sie Babelfish-DB-Cluster mit Berechtigungen für die Aurora-PostgreSQL-Erweiterungen ein

Stellen Sie eine Verbindung mit Ihrem Babelfish-DB-Cluster her. Verwenden Sie den Namen für den „Hauptbenutzer“ (-U), den Sie beim Erstellen des Babelfish-DB-Clusters angegeben haben. In den Beispielen wird der Standard (postgres) dargestellt.

Für LinuxmacOS, oderUnix:
```
psql -h your-Babelfish.cluster.444455556666-us-east-1.rds.amazonaws.com \
-U postgres \
-d babelfish_db \
-p 5432
```
Windows:
```
psql -h your-Babelfish.cluster.444455556666-us-east-1.rds.amazonaws.com ^
-U postgres ^
-d babelfish_db ^
-p 5432
```
Der Befehl antwortet mit einer Aufforderung zur Eingabe des Passworts für den Benutzernamen (-U).
```
Password:
```
Geben Sie das Passwort für den Benutzernamen (-U) für den DB-Cluster ein. Wenn die Verbindung erfolgreich ist, wird eine Ausgabe ähnlich der Folgenden angezeigt.
```
psql (13.4)
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, compression: off)
Type "help" for help.

postgres=>
```
Erteilen Sie dem internen Babelfish-Benutzer Berechtigungen zum Erstellen und Laden von Erweiterungen.
```
babelfish_db=> GRANT rds_superuser TO master_dbo;
GRANT ROLE
```
Erstellen und laden Sie die aws_s3-Erweiterung. Die aws_commons-Erweiterung ist erforderlich und wird automatisch mit aws_s3 installiert.
```
babelfish_db=> create extension aws_s3 cascade;
NOTICE:  installing required extension "aws_commons"
CREATE EXTENSION
```

Erstellen und laden Sie die aws_lambda-Erweiterung.


babelfish_db=> create extension aws_lambda cascade;
CREATE EXTENSION
babelfish_db=>

Verwenden von Babelfish mit Amazon S3

Wenn Sie noch keinen Amazon-S3-Bucket für Ihren Babelfish-DB-Cluster haben, können Sie einen erstellen. Gewähren Sie Zugriff für jeden Amazon-S3-Bucket, den Sie verwenden möchten.

Bevor Sie versuchen, Daten mit einem Amazon-S3-Bucket zu importieren oder zu exportieren, führen Sie die folgenden einmaligen Schritte aus.

Gewähren Sie Ihrer Babelfish-DB-Instance Zugriff auf Ihren Amazon-S3-Bucket

Erstellen Sie bei Bedarf einen Amazon-S3-Bucket für Ihre Babelfish-Instance. Befolgen Sie dazu die Anweisungen unter Erstellen eines Buckets im Benutzerhandbuch zum Amazon Simple Storage Service.
Laden Sie Dateien in Ihren Amazon-S3-Bucket hoch. Befolgen Sie dazu die Schritte unter Hinzufügen eines Objekts zu einem Bucket im Benutzerhandbuch zum Amazon Simple Storage Service.
Richten Sie Berechtigungen nach Bedarf ein:
- Zum Importieren von Daten aus Amazon S3 benötigt der Babelfish-DB-Cluster die Berechtigung für den Zugriff auf den Bucket. Wir empfehlen, eine AWS Identity and Access Management (IAM-) Rolle zu verwenden und dieser Rolle für Ihren Cluster eine IAM-Richtlinie zuzuordnen. Eine Schritt-für-Schritt-Anleitung hierzu finden Sie unter Verwenden einer IAM-Rolle für den Zugriff auf einen Amazon S3-Bucket.
- Wenn Sie Daten aus Ihrem Babelfish-DB-Cluster exportieren möchten, muss Ihrem Cluster Zugriff auf den Amazon S3 Bucket gewährt werden. Wie beim Importieren empfehlen wir die Verwendung einer IAM-Rolle und -Richtlinie. Eine Schritt-für-Schritt-Anleitung hierzu finden Sie unter Einrichten des Zugriffs auf einen Amazon S3-Bucket.

Sie können Amazon S3 jetzt mit der aws_s3-Erweiterung mit Ihrem Babelfish-DB-Cluster verwenden.

Importieren von Daten aus Amazon S3 nach Babelfish und exportieren von Babelfish-Daten nach Amazon S3

Verwenden Sie die aws_s3-Erweiterung mit Ihrem Babellfish-DB-Cluster.

Verweisen Sie in diesem Fall auf die Tabellen, wie sie in PostgreSQL existieren. Das heißt, beim Import in eine Babelfish-Tabelle namens [database].[schema].[tableA] bezeichnen Sie diese Tabelle in der aws_s3-Funktion als database_schema_tableA:
- Ein Beispiel für die Verwendung einer aws_s3-Funktion zum Importieren von Daten finden Sie unter Importieren von Daten aus Amazon S3 in Ihren Aurora PostgreSQL DB-Cluster.
- Beispiele für die Verwendung von aws_s3-Funktionen zum Exportieren von Daten finden Sie unter Exportieren von Abfragedaten mithilfe der Funktion aws_s3.query_export_to_s3.
Verweisen Sie mit der PostgreSQL-Benennung auf Babelfish-Tabellen, wenn Sie die aws_s3-Erweiterung und Amazon S3 wie in folgender Tabelle verwenden.

Babelfish-Tabelle	Aurora PostgreSQL-Tabelle
`database.schema.table`	`database_schema_table`

Weitere Informationen zur Verwendung von Amazon S3 mit Aurora PostgreSQL finden Sie unter Importieren von Amazon S3 in einen Aurora-PostgreSQL-DB-Cluster und Exportieren von Daten aus einem/einer Aurora PostgreSQL-DB-Cluster zu Amazon S3.

Verwenden Sie Babelfish mit AWS Lambda

Nach dem die aws_lambda-Erweiterung in Ihrem Babelfish-DB-Cluster geladen ist und bevor Sie Lambda-Funktionen aufrufen, gewähren Sie Lambda wie folgt Zugriff auf Ihren DB-Cluster.

Richten Sie den Zugriff für Ihren Babelfish-DB-Cluster zur Funktion mit Lambda ein

Dieses Verfahren verwendet die AWS CLI , um die IAM-Richtlinie und -Rolle zu erstellen und diese dem Babelfish-DB-Cluster zuzuordnen.

Erstellen Sie eine IAM-Richtlinie, die den Zugriff auf Lambda von Ihrem Babelfish-DB-Cluster aus erlaubt.


aws iam create-policy  --policy-name rds-lambda-policy --policy-document '{
    "Version": "2012-10-17",
    "Statement": [
        {
        "Sid": "AllowAccessToExampleFunction",
        "Effect": "Allow",
        "Action": "lambda:InvokeFunction",
        "Resource": "arn:aws:lambda:aws-region:444455556666:function:my-function"
        }
    ]
}'

Erstellen Sie eine IAM-Rolle, die die Richtlinie zur Laufzeit annehmen kann.


aws iam create-role  --role-name rds-lambda-role --assume-role-policy-document '{
    "Version": "2012-10-17",
    "Statement": [
        {
        "Effect": "Allow",
        "Principal": {
            "Service": "rds.amazonaws.com"
        },
        "Action": "sts:AssumeRole"
        }
    ]
}'

Fügen Sie der Rolle die -Richtlinie an.


aws iam attach-role-policy \
    --policy-arn arn:aws:iam::444455556666:policy/rds-lambda-policy \
    --role-name rds-lambda-role --region aws-region

Hängen Sie die Rolle an Ihren Babelfish-DB-Cluster an.


aws rds add-role-to-db-cluster \
       --db-cluster-identifier my-cluster-name \
       --feature-name Lambda \
       --role-arn  arn:aws:iam::444455556666:role/rds-lambda-role   \
       --region aws-region

Nachdem Sie diese Aufgaben durchgeführt haben, können Sie Ihre Lambda-Funktionen aufrufen. Weitere Informationen und Beispiele für die Einrichtung AWS Lambda des Aurora PostgreSQL-DB-Clusters mit AWS Lambda finden Sie unter. Schritt 2: Konfigurieren Sie IAM für Ihren Aurora PostgreSQL-DB-Cluster, und AWS Lambda

Aufrufen einer Lambda-Funktion aus Ihrem Babelfish-DB-Cluster

AWS Lambda unterstützt Funktionen, die in Java, Node.js, Python, Ruby und anderen Sprachen geschrieben wurden. Wenn die Funktion beim Aufruf Text zurückgibt, können Sie sie von Ihrem Babelfish-DB-Cluster aus aufrufen. Das folgende Beispiel ist eine Platzhalter-Python-Funktion, die eine Begrüßung zurückgibt.


lambda_function.py
import json
def lambda_handler(event, context):
    #TODO implement
    return {
        'statusCode': 200,
        'body': json.dumps('Hello from Lambda!')

Derzeit wird JSON von Babelfish nicht unterstützt. Wenn Ihre Funktion JSON zurückgibt, verwenden Sie einen Wrapper, um den JSON-Code zu behandeln. Angenommen, die vorher gezeigte lambda_function.py ist in Lambda als my-function gespeichert.

Stellen Sie mit Hilfe des psql-Clients (oder des pgAdmin-Clients) eine Verbindung zu Ihrem Babelfish-DB-Cluster her. Weitere Informationen finden Sie unter Herstellen einer Verbindung mit Ihrem psql.

Erstellen Sie den Wrapper. In diesem Beispiel wird die prozedurale Sprache von PostgreSQL für SQL verwendet, PL/pgSQL. Weitere Informationen hierzu finden Sie unter PL/pgSQL-SQL Procedural Language.


create or replace function master_dbo.lambda_wrapper()
returns text
language plpgsql
as
$$
declare
   r_status_code integer;
   r_payload text;
begin
   SELECT payload INTO r_payload
     FROM aws_lambda.invoke(  aws_commons.create_lambda_function_arn('my-function', 'us-east-1')
                            ,'{"body": "Hello from Postgres!"}'::json );
   return r_payload ;
end;
$$;

Die Funktion kann jetzt vom Babelfish-TDS-Port (1433) oder vom PostgreSQL-Port (5433) aus ausgeführt werden.

So rufen Sie diese Funktion von Ihrem PostgreSQL-Port aus auf:


SELECT * from aws_lambda.invoke(aws_commons.create_lambda_function_arn('my-function', 'us-east-1'), '{"body": "Hello from Postgres!"}'::json );

Die Ausgabe sieht folgendermaßen oder ähnlich aus:


status_code |                        payload                        | executed_version | log_result
-------------+-------------------------------------------------------+------------------+------------
         200 | {"statusCode": 200, "body": "\"Hello from Lambda!\""} | $LATEST          |
(1 row)

Um diese Funktion vom TDS-Port aus aufzurufen, stellen Sie eine Verbindung mit dem Port über den sqlcmd-Befehlszeilen-Client von SQL Server her. Details hierzu finden Sie unter Verbinden mit Ihrem DB-Cluster mithilfe eines SQL Server-Clients. Wenn eine Verbindung hergestellt ist, führen Sie Folgendes aus:
```
1> select lambda_wrapper();
2> go
```
Daraufhin erhalten Sie ein Ergebnis, das dem hier dargestellten entspricht:
```
{"statusCode": 200, "body": "\"Hello from Lambda!\""}
```

Weitere Informationen zur Verwendung von Lambda mit Aurora PostgreSQL finden Sie unter Aufrufen einer AWS Lambda Funktion aus einem Aurora PostgreSQL-DB-Cluster ( PostgreSQL-DB-Instance). Weitere Informationen über die Nutzung von Lambda-Funktionen finden Sie unter Erste Schritte mit Lambda im AWS Lambda -Entwicklerhandbuch.

Verwenden von pg_stat_statements in Babelfish

Babelfish für Aurora PostgreSQL unterstützt die pg_stat_statements-Erweiterung ab 3.3.0. Weitere Informationen finden Sie unter pg_stat_statements.

Einzelheiten zur von Aurora PostgreSQL unterstützten Version dieser Erweiterung finden Sie unter Erweiterungsversionen.

Erstellen der pg_stat_statements-Erweiterung

Zum Aktivieren von pg_stat_statements müssen Sie die Berechnung der Abfrage-ID aktivieren. Dies erfolgt automatisch, wenn compute_query_id auf on oder auto in der Parametergruppe gesetzt ist. Der Standardwert für den compute_query_id-Parameter ist auto. Sie müssen auch diese Erweiterung erstellen, um diese Funktion zu aktivieren. Verwenden Sie den folgenden Befehl, um die Erweiterung vom T-SQL-Endpunkt aus zu installieren:


				
1>EXEC sp_execute_postgresql 'CREATE EXTENSION pg_stat_statements WITH SCHEMA sys';

Sie können mit der folgenden Abfrage auf die Abfragestatistiken zugreifen:



postgres=>select * from pg_stat_statements;

Anmerkung

Wenn Sie während der Installation den Schemanamen für die Erweiterung nicht angeben, wird dieser standardmäßig im öffentlichen Schema erstellt. Um darauf zuzugreifen, müssen Sie eckige Klammern mit Schemaqualifizierer verwenden, wie unten gezeigt:


postgres=>select * from [public].pg_stat_statements;

Sie können die Erweiterung auch vom PSQL-Endpunkt aus erstellen.

Autorisieren der Erweiterung

Standardmäßig können Sie die Statistiken für Abfragen sehen, die in Ihrer T-SQL-Datenbank ausgeführt wurden, ohne dass eine Autorisierung erforderlich ist.

Um auf Abfragestatistiken zugreifen zu können, die von anderen erstellt wurden, benötigen Sie eine pg_read_all_stats-PostgreSQL-Rolle. Folgen Sie den unten genannten Schritten, um den Befehl GRANT pg_read_all_stats zu erstellen.

Verwenden Sie in T-SQL die folgende Abfrage, die den internen PG-Rollennamen zurückgibt.
```
SELECT rolname FROM pg_roles WHERE oid = USER_ID();
```
Stellen Sie mit der Berechtigung rds_superuser eine Verbindung mit der Babelfish-für-Aurora-PostgreSQL-Datenbank her und verwenden Sie den folgenden Befehl:
```
GRANT pg_read_all_stats TO <rolname_from_above_query>
```

Beispiel

Vom T-SQL-Endpunkt aus:


1>SELECT rolname FROM pg_roles WHERE oid = USER_ID();
2>go



rolname
-------
master_dbo
(1 rows affected)

Vom PSQL-Endpunkt aus:


babelfish_db=# grant pg_read_all_stats to master_dbo;


GRANT ROLE

Sie können mit der Ansicht pg_stat_statements auf die Abfragestatistiken zugreifen:


1>create table t1(cola int);
2>go
1>insert into t1 values (1),(2),(3);
2>go


(3 rows affected)


1>select userid, dbid, queryid, query from pg_stat_statements;
2>go



userid dbid queryid             query
------ ---- -------             -----
37503 34582 6487973085327558478 select * from t1
37503 34582 6284378402749466286 SET QUOTED_IDENTIFIER OFF
37503 34582 2864302298511657420 insert into t1 values ($1),($2),($3)
10    34582 NULL                <insufficient privilege>
37503 34582 5615368793313871642 SET TEXTSIZE 4096
37503 34582 639400815330803392  create table t1(cola int)
(6 rows affected)

Zurücksetzen der Abfragestatistiken

Sie können pg_stat_statements_reset() verwenden, um die bisher von pg_stat_statements erfassten Statistiken zurückzusetzen. Weitere Informationen finden Sie unter pg_stat_statements. Dies wird derzeit nur über den PSQL-Endpunkt unterstützt. Stellen Sie mit der rds_superuser-Berechtigung eine Verbindung zu Babelfish für Aurora PostgreSQL her und verwenden Sie den folgenden Befehl:



SELECT pg_stat_statements_reset();

Einschränkungen

Derzeit wird pg_stat_statements() nicht über den T-SQL-Endpunkt unterstützt. pg_stat_statements-View ist die empfohlene Methode zum Erfassen von Statistiken.
Einige der Abfragen werden möglicherweise vom T-SQL-Parser neu geschrieben, der von der Aurora PostgreSQL-Engine implementiert wurde. In der pg_stat_statements-Ansicht wird die neu geschriebene Abfrage und nicht die ursprüngliche Abfrage angezeigt.

Beispiel
```
select next value for [dbo].[newCounter];
```
Die obige Abfrage wird in der Ansicht pg_stat_statements wie folgt umgeschrieben.
```
select nextval($1);
```
Aufgrund des Ausführungsablaufs der Anweisungen werden einige Abfragen möglicherweise nicht von pg_stat_statements verfolgt und sind daher in der Ansicht nicht sichtbar. Dazu gehören die folgenden Anweisungen: use dbname, goto, print, raise error, set, throw, declare cursor.
Bei den Anweisungen CREATE LOGIN und ALTER LOGIN werden Abfrage und Abfrage-ID nicht angezeigt. Es werden unzureichende Berechtigungen angezeigt.
Die pg_stat_statements-Ansicht enthält immer die folgenden zwei Einträge, da diese intern vom sqlcmd-Client ausgeführt werden.
- SET QUOTED_IDENTIFIER OFF
- SET TEXTSIZE 4096

Verwendung von pgvector in Babelfish

Mit pgvector, einer Open-Source-Erweiterung, können Sie direkt in Ihrer Postgres-Datenbank nach ähnlichen Daten suchen. Babelfish unterstützt diese Erweiterung jetzt ab den Versionen 15.6 und 16.2. Weitere Informationen finden Sie in der Open-Source-Dokumentation von pgvector.

Voraussetzungen

Um die PGVector-Funktionalität zu aktivieren, installieren Sie die Erweiterung im sys-Schema mit einer der folgenden Methoden:

Führen Sie den folgenden Befehl im sqlcmd-Client aus:


exec sys.sp_execute_postgresql 'CREATE EXTENSION vector WITH SCHEMA sys';

Connect zum PSQL-Client her babelfish_db und führen Sie den folgenden Befehl aus:
```
CREATE EXTENSION vector WITH SCHEMA sys;
```

Anmerkung

Nach der Installation der Erweiterung pgvector ist der Vektor-Datentyp nur in neuen Datenbankverbindungen verfügbar, die Sie einrichten. Bestehende Verbindungen erkennen den neuen Datentyp nicht.

Unterstützte Funktionalität

Babelfish erweitert die T-SQL-Funktionalität um die folgenden Funktionen:

Speichern

Babelfish unterstützt jetzt eine mit Vektor-Datentypen kompatible Syntax und verbessert so die T-SQL-Kompatibilität. Weitere Informationen zum Speichern von Daten mit pgvector finden Sie unter Speichern.
Abfragen

Babelfish erweitert die Unterstützung von T-SQL-Ausdrücken um Vektor-Ähnlichkeitsoperatoren. Für alle anderen Abfragen ist jedoch weiterhin die standardmäßige T-SQL-Syntax erforderlich.

Anmerkung
T-SQL unterstützt den Array-Typ nicht, und die Datenbanktreiber haben keine Schnittstelle, um sie zu handhaben. Um dieses Problem zu umgehen, verwendet Babelfish Textzeichenfolgen (varchar/nvarchar) zum Speichern von Vektordaten. Wenn Sie beispielsweise einen Vektorwert [1,2,3] anfordern, gibt Babelfish als Antwort die Zeichenfolge '[1,2,3]' zurück. Sie können diese Zeichenfolge auf Anwendungsebene nach Ihren Bedürfnissen analysieren und aufteilen.

Weitere Informationen zum Abfragen von Daten mit pgvector finden Sie unter Abfragen.
Indizierung

T-SQL unterstützt Create Index USING INDEX_METHOD jetzt Syntax. Sie können jetzt einen Ähnlichkeitssuchoperator definieren, der bei der Erstellung eines Indexes für eine bestimmte Spalte verwendet wird.

Die Grammatik wurde auch erweitert, um Operationen zur Vektorähnlichkeit für die benötigte Spalte zu unterstützen (überprüfen Sie die column_name_list_with_order_for_vector-Grammatik).
```
CREATE [UNIQUE] [clustered] [COLUMNSTORE] INDEX <index_name> ON <table_name> [USING vector_index_method] (<column_name_list_with_order_for_vector>)
Where column_name_list_with_order_for_vector is:
    <column_name> [ASC | DESC] [VECTOR_COSINE_OPS | VECTOR_IP_OPS | VECTOR_L2_OPS] (COMMA simple_column_name [ASC | DESC] [VECTOR_COSINE_OPS | VECTOR_IP_OPS | VECTOR_L2_OPS])
```
Weitere Informationen zur Indizierung von Daten mit pgvector finden Sie unter Indizierung.
Leistung
- Wird SET BABELFISH_STATISTICS PROFILE ON zum Debuggen von Abfrageplänen vom T-SQL-Endpunkt aus verwendet.
- Erhöhen max_parallel_workers_get_gather Sie die Anzahl mithilfe der in set_config T-SQL unterstützten Funktion.
- Wird IVFFlat für ungefähre Suchanfragen verwendet. Weitere Informationen finden Sie unter IVFFlat.
Informationen zur Verbesserung der Leistung mit pgvector finden Sie unter Leistung.

Einschränkungen

Babelfish unterstützt keine Volltextsuche für die Hybridsuche. Weitere Informationen finden Sie unter Hybridsuche.
Babelfish unterstützt derzeit keine Neuindizierungsfunktionen. Sie können den PostgreSQL-Endpunkt jedoch weiterhin für die Neuindizierung verwenden. Weitere Informationen finden Sie unter Staubsaugen.

Verwenden von Amazon Aurora Machine Learning mit Babelfish

Sie können die Funktionen Ihres Babelfish for Aurora PostgreSQL-DB-Clusters erweitern, indem Sie ihn in Amazon Aurora Machine Learning integrieren. Diese nahtlose Integration gewährt Ihnen Zugriff auf eine Reihe leistungsstarker Dienste wie Amazon Comprehend oder Amazon SageMaker oder Amazon Bedrock, die jeweils auf unterschiedliche Anforderungen im Bereich maschinelles Lernen zugeschnitten sind.

Als Babelfish-Benutzer können Sie bei der Arbeit mit Aurora Machine Learning vorhandenes Wissen über T-SQL-Syntax und -Semantik nutzen. Folgen Sie den Anweisungen in der AWS Dokumentation für Aurora PostgreSQL. Weitere Informationen finden Sie unter Verwendung von Amazon Aurora Machine Learning mit Aurora PostgreSQL.

Voraussetzungen

Bevor Sie versuchen, Ihren Babelfish for Aurora PostgreSQL-DB-Cluster für die Nutzung von Aurora Machine Learning einzurichten, müssen Sie die entsprechenden Anforderungen und Voraussetzungen verstehen. Weitere Informationen finden Sie unter Voraussetzungen für die Verwendung von Aurora Machine Learning mit Aurora PostgreSQL.
Stellen Sie sicher, dass Sie die aws_ml Erweiterung entweder mithilfe des Postgres-Endpunkts oder der Store-Prozedur installieren. sp_execute_postgresql
```
exec sys.sp_execute_postgresql 'Create Extension aws_ml'
```
Anmerkung
Derzeit unterstützt Babelfish keine Kaskadenoperationen in Babelfish. sp_execute_postgresql Da es aws_ml darauf angewiesen istaws_commons, müssen Sie es separat mithilfe des Postgres-Endpunkts installieren.
```
create extension aws_common;
```

Umgang mit T-SQL-Syntax und -Semantik mit Funktionen `aws_ml`

In den folgenden Beispielen wird erklärt, wie T-SQL-Syntax und -Semantik auf die Amazon ML-Services angewendet werden:

Beispiel : aws_bedrock.invoke_model — Eine einfache Abfrage mit Amazon Bedrock-Funktionen


aws_bedrock.invoke_model(
   model_id      varchar,
   content_type  text,
   accept_type   text,
   model_input   text)
Returns Varchar(MAX)

Das folgende Beispiel zeigt, wie Sie mithilfe von invoke_model ein Anthropic Claude 2-Modell für Bedrock aufrufen.



SELECT aws_bedrock.invoke_model (
    'anthropic.claude-v2', -- model_id
    'application/json', -- content_type
    'application/json', -- accept_type
    '{"prompt": "\n\nHuman:
    You are a helpful assistant that answers questions directly
    and only using the information provided in the context below.
    \nDescribe the answerin detail.\n\nContext: %s \n\nQuestion:
    %s \n\nAssistant:","max_tokens_to_sample":4096,"temperature"
    :0.5,"top_k":250,"top_p":0.5,"stop_sequences":[]}' -- model_input
);

Beispiel : aws_comprehend.detect_sentiment — Eine einfache Abfrage mit Amazon Comprehend Comprehend-Funktionen



aws_comprehend.detect_sentiment(
   input_text varchar,
   language_code varchar,
   max_rows_per_batch int)
Returns table (sentiment varchar, confidence real)

Das folgende Beispiel zeigt, wie der Amazon Comprehend Service aufgerufen wird.



select sentiment from aws_comprehend.detect_sentiment('This is great', 'en');

Beispiel : aws_sagemaker.invoke_endpoint — Eine einfache Abfrage mit Amazon-Funktionen SageMaker


aws_sagemaker.invoke_endpoint(
  endpoint_name varchar,   
  max_rows_per_batch int,
  VARIADIC model_input "any") -- Babelfish inherits PG's variadic parameter type
Rerurns Varchar(MAX)

Da model_input als VARIADIC markiert ist und den Typ „any“ hat, können Benutzer eine Liste mit beliebiger Länge und beliebigem Datentyp an die Funktion übergeben, die als Eingabe für das Modell dient. Das folgende Beispiel zeigt, wie der SageMaker Amazon-Service aufgerufen wird.



SELECT CAST (aws_sagemaker.invoke_endpoint(
    'sagemaker_model_endpoint_name',
    NULL,
    arg1, arg2 -- model inputs are separate arguments )
AS INT) -- cast the output to INT

Ausführlichere Informationen zur Verwendung von Aurora Machine Learning mit Aurora PostgreSQL finden Sie unter. Verwendung von Amazon Aurora Machine Learning mit Aurora PostgreSQL

Einschränkungen

Babelfish erlaubt zwar nicht die Erstellung von Arrays, kann aber dennoch Daten verarbeiten, die Arrays repräsentieren. Wenn du solche Funktionen verwendestaws_bedrock.invoke_model_get_embeddings, die Arrays zurückgeben, werden die Ergebnisse als Zeichenfolge geliefert, die die Array-Elemente enthält.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Verwenden von T-SQL-Abfragehinweise zur Verbesserung der Abfrageleistung von Babelfish

Babelfish unterstützt verknüpfte Server

Verwenden von Aurora PostgreSQL-Erweiterungen mit Babelfish

Aktivieren von Aurora-PostgreSQL-Erweiterungen in Ihrem Babelfish-DB-Cluster

Richten Sie Babelfish-DB-Cluster mit Berechtigungen für die Aurora-PostgreSQL-Erweiterungen ein

Verwenden von Babelfish mit Amazon S3

Gewähren Sie Ihrer Babelfish-DB-Instance Zugriff auf Ihren Amazon-S3-Bucket

Importieren von Daten aus Amazon S3 nach Babelfish und exportieren von Babelfish-Daten nach Amazon S3

Verwenden Sie Babelfish mit AWS Lambda

Richten Sie den Zugriff für Ihren Babelfish-DB-Cluster zur Funktion mit Lambda ein

Aufrufen einer Lambda-Funktion aus Ihrem Babelfish-DB-Cluster

Verwenden von pg_stat_statements in Babelfish

Erstellen der pg_stat_statements-Erweiterung

Anmerkung

Autorisieren der Erweiterung

Beispiel

Zurücksetzen der Abfragestatistiken

Einschränkungen

Verwendung von pgvector in Babelfish

Voraussetzungen

Anmerkung

Unterstützte Funktionalität

Anmerkung

Einschränkungen

Verwenden von Amazon Aurora Machine Learning mit Babelfish

Voraussetzungen

Anmerkung

Umgang mit T-SQL-Syntax und -Semantik mit Funktionen aws_ml

Beispiel : aws_bedrock.invoke_model — Eine einfache Abfrage mit Amazon Bedrock-Funktionen

Beispiel : aws_comprehend.detect_sentiment — Eine einfache Abfrage mit Amazon Comprehend Comprehend-Funktionen

Beispiel : aws_sagemaker.invoke_endpoint — Eine einfache Abfrage mit Amazon-Funktionen SageMaker

Einschränkungen

Umgang mit T-SQL-Syntax und -Semantik mit Funktionen `aws_ml`