Activation des extensions Aurora PostgreSQL dans votre cluster de base de données Babelfish Utilisation de Babelfish avec Amazon S3 Utiliser Babelfish avec AWS Lambda Utilisation de pg_stat_statements dans Babelfish Utiliser pgvector dans Babelfish Utilisation de l'apprentissage automatique d'Amazon Aurora avec Babelfish

Utilisation des extensions Aurora PostgreSQL avec Babelfish

Aurora PostgreSQL fournit des extensions permettant de travailler avec d'autres services. AWS Il s'agit d'extensions facultatives qui prennent en charge divers cas d'utilisation, tels que l'utilisation d'Amazon S3 avec votre cluster de base de données pour importer ou exporter des données.

Pour importer des données d'un compartiment Amazon S3 vers votre cluster de base de données Babelfish, vous devez configurer l'extension aws_s3 Aurora PostgreSQL. Cette extension vous permet également d'exporter des données de votre cluster de base de données Aurora PostgreSQL vers un compartiment Amazon S3.
AWS Lambda est un service de calcul qui vous permet d'exécuter du code sans provisionner ni gérer de serveurs. Vous pouvez par exemple utiliser des fonctions Lambda pour traiter les notifications d'événements à partir de votre instance de base de données. Pour en savoir plus sur Lambda, veuillez consulter Qu'est-ce qu' AWS Lambda ? dans le Guide du développeur AWS Lambda . Pour appeler des fonctions Lambda à partir de votre cluster de base de données Babelfish, vous devez configurer l'extension aws_lambda Aurora PostgreSQL.

Pour configurer ces extensions pour votre cluster Babelfish, vous devez d'abord accorder à l'utilisateur Babelfish interne l'autorisation de charger les extensions. Après avoir accordé l'autorisation, vous pouvez charger les extensions Aurora PostgreSQL.

Activation des extensions Aurora PostgreSQL dans votre cluster de base de données Babelfish

Avant de pouvoir charger les extensions aws_s3 ou aws_lambda, vous accordez les privilèges nécessaires à votre cluster de base de données Babelfish.

La procédure suivante utilise l'outil de ligne de commande psql PostgreSQL pour se connecter au cluster de base de données. Pour plus d’informations, consultez Utilisation de psql pour se connecter au cluster de bases de données. Vous pouvez également utiliser pgAdmin. Pour plus de détails, consultez Utilisation de pgAdmin pour se connecter au cluster de bases de données.

Cette procédure charge les extensions aws_s3 et aws_lambda l'une après l'autre. Si vous ne comptez utiliser que l'une de ces extensions, vous n'avez pas besoin de les charger toutes les deux. L'extension aws_commons est requise par chacune, et elle est chargée par défaut, comme indiqué dans la sortie.

Pour configurer votre cluster de base de données Babelfish avec des privilèges pour les extensions Aurora PostgreSQL

Connectez-vous à votre cluster de base de données Babelfish. Utilisez le nom de l'utilisateur « principal » (-U) que vous avez spécifié lors de la création du cluster de base de données Babelfish. La valeur par défaut (postgres) est illustrée dans les exemples.

Pour LinuxmacOS, ou Unix :
```
psql -h your-Babelfish.cluster.444455556666-us-east-1.rds.amazonaws.com \
-U postgres \
-d babelfish_db \
-p 5432
```
Dans Windows :
```
psql -h your-Babelfish.cluster.444455556666-us-east-1.rds.amazonaws.com ^
-U postgres ^
-d babelfish_db ^
-p 5432
```
La commande répond par une invite à saisir le mot de passe du nom d'utilisateur (-U).
```
Password:
```
Saisissez le mot de passe du nom d'utilisateur (-U) du cluster de base de données. Lorsque vous serez connecté, vous obtiendrez une sortie similaire à ce qui suit.
```
psql (13.4)
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, compression: off)
Type "help" for help.

postgres=>
```
Accordez des privilèges à l'utilisateur Babelfish interne pour créer et charger des extensions.
```
babelfish_db=> GRANT rds_superuser TO master_dbo;
GRANT ROLE
```
Créez et chargez l'extension aws_s3. L'extension aws_commons est nécessaire et elle est installée automatiquement lorsque l'extension aws_s3 est installée.
```
babelfish_db=> create extension aws_s3 cascade;
NOTICE:  installing required extension "aws_commons"
CREATE EXTENSION
```

Créez et chargez l'extension aws_lambda.


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

Utilisation de Babelfish avec Amazon S3

Si vous ne disposez pas d'un compartiment Amazon S3 à utiliser avec votre cluster de base de données Babelfish, vous pouvez en créer un. Vous devez accorder l'accès pour tout compartiment Amazon S3 que vous souhaitez utiliser.

Avant d'essayer d'importer ou d'exporter des données à l'aide d'un compartiment Amazon S3, suivez les étapes uniques suivantes.

Pour configurer l'accès de votre instance de base de données Babelfish à votre compartiment Amazon S3

Créez un compartiment Amazon S3 pour votre instance Babelfish, si nécessaire. Pour ce faire, suivez les instructions de la section Create a Bucket (Créer un compartiment) dans le Guide de l'utilisateur Amazon Simple Storage Service.
Chargez les fichiers dans votre compartiment Amazon S3. Pour ce faire, suivez les étapes de la section Add an object to a bucket (Ajouter un objet à un compartiment) dans le Guide de l'utilisateur Amazon Simple Storage Service.
Configurez les autorisations nécessaires :
- Pour importer des données à partir d'Amazon S3, le cluster de base de données Babelfish doit être autorisé à accéder au compartiment. Nous vous recommandons d'utiliser un rôle AWS Identity and Access Management (IAM) et d'associer une politique IAM à ce rôle pour votre cluster. Pour ce faire, suivez les étapes de Utilisation d'un rôle IAM pour accéder à un compartiment Amazon S3.
- Pour exporter des données à partir de votre cluster de base de données Babelfish, votre cluster doit avoir accès au compartiment Amazon S3. Comme pour l'importation, nous recommandons d'utiliser une politique et un rôle IAM. Pour ce faire, suivez les étapes de Configuration de l'accès à un compartiment Amazon S3.

Vous pouvez désormais utiliser Amazon S3 avec l'extension aws_s3 et votre cluster de base de données Babelfish.

Pour importer des données à partir d'Amazon S3 vers Babelfish et pour exporter des données Babelfish vers Amazon S3

Utilisez l'extension aws_s3 avec votre cluster de base de données Babelfish.

Dans ce cas, veillez à référencer les tables telles qu'elles existent dans le cadre de PostgreSQL. En d'autres termes, si vous souhaitez importer vers une table Babelfish nommée [database].[schema].[tableA], référez-vous à cette table en tant que database_schema_tableA dans la fonctionaws_s3 :
- Pour obtenir un exemple d'utilisation de fonction aws_s3 pour importer des données, veuillez consulter Importation de données d'Amazon S3 vers votre cluster de base de données Aurora PostgreSQL.
- Pour obtenir des exemples d'utilisation de fonctions aws_s3 pour exporter des données, veuillez consulter Exportation de données de requête à l'aide de la fonction aws_s3.query_export_to_s3.
Veillez à référencer les tables Babelfish à l'aide de la dénomination PostgreSQL lorsque vous utilisez l'extension aws_s3 et Amazon S3, comme indiqué dans la table suivante.

Table Babelfish	Table Aurora PostgreSQL
`database.schema.table`	`database_schema_table`

Pour en savoir plus sur l'utilisation d'Amazon S3 avec Aurora PostgreSQL, veuillez consulter les sections Importation de données Amazon S3 dans une d'un cluster de base de données Aurora PostgreSQL et Exportation de données à partir d'un cluster de base de données Aurora PostgreSQL vers Amazon S3.

Utiliser Babelfish avec AWS Lambda

Après le chargement de l'extension aws_lambda dans votre cluster de base de données Babelfish, mais avant l'appel des fonctions Lambda, accordez à Lambda l'accès à votre cluster de base de données en suivant cette procédure.

Pour configurer l'accès à votre cluster de base de données Babelfish afin qu'il fonctionne avec Lambda

Cette procédure utilise le AWS CLI pour créer la politique et le rôle IAM, et les associer au cluster de base de données Babelfish.

Créez une politique IAM qui autorise l'accès à Lambda à partir de votre cluster de base de données Babelfish.


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"
        }
    ]
}'

Créez un rôle IAM que la politique peut endosser lors de l'exécution.


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"
        }
    ]
}'

Attachez la stratégie au rôle.


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

Attacher le rôle à votre cluster de base de données Babelfish


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

Une fois ces tâches terminées, vous pouvez appeler vos fonctions Lambda. Pour plus d'informations et des exemples de configuration d'un cluster AWS Lambda AWS Lambda de base de données Aurora PostgreSQL avec, consultez. Étape 2 : configurer IAM pour votre instance de base de données Aurora PostgreSQL pour PostgreSQL et AWS Lambda

Pour appeler une fonction Lambda à partir de votre cluster de base de données Babelfish

AWS Lambda prend en charge les fonctions écrites en Java, Node.js, Python, Ruby et dans d'autres langages. Si la fonction renvoie du texte lorsqu'elle est appelée, vous pouvez l'appeler à partir de votre cluster de base de données Babelfish. L'exemple suivant est une fonction Python d'espace réservé qui renvoie un message de salutation.


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

Actuellement, Babelfish ne prend pas en charge JSON. Si votre fonction renvoie JSON, utilisez un encapsuleur pour gérer le JSON. Par exemple, disons que la fonction lambda_function.py illustrée ci-dessus est stockée dans Lambda en tant que my-function.

Connectez-vous à votre cluster de base de données Babelfish à l'aide du client psql (ou du client pgAdmin). Pour plus d’informations, consultez Utilisation de psql pour se connecter au cluster de bases de données.

Créez l'encapsuleur. Cet exemple utilise le langage procédural de PostgreSQL pour SQL, PL/pgSQL. Pour en savoir plus, consultez 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;
$$;

La fonction peut désormais être exécutée à partir du port TDS Babelfish (1433) ou du port PostgreSQL (5433).

Pour appeler cette fonction depuis votre port PostgreSQL :


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

La sortie est similaire à ce qui suit :


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

Pour appeler cette fonction à partir du port TDS, connectez-vous au port à l'aide du client de ligne de commande sqlcmd de SQL Server. Pour plus de détails, consultez Utilisation d'un client SQL Server pour se connecter au cluster de bases de données. Une fois connecté, exécutez les opérations suivantes :
```
1> select lambda_wrapper();
2> go
```
La commande renvoie un résultat semblable à ce qui suit :
```
{"statusCode": 200, "body": "\"Hello from Lambda!\""}
```

Pour en savoir plus sur l'utilisation de Lambda avec Aurora PostgreSQL, veuillez consulter Invocation d'une AWS Lambda fonction depuis une instance de base de données Aurora PostgreSQL pour PostgreSQL. Pour plus d'informations sur l'utilisation des fonctions Lambda, veuillez consulter Mise en route avec Lambda dans le Guide du développeur AWS Lambda .

Utilisation de pg_stat_statements dans Babelfish

Babelfish for Aurora PostgreSQL prend en charge l'extension pg_stat_statements à partir de la version 3.3.0. Pour plus d'informations, consultez pg_stat_statements.

Pour plus d'informations sur la version de cette extension prise en charge par Aurora PostgreSQL, consultez Extension versions.

Création de l'extension pg_stat_statements

Pour l'activer sur pg_stat_statements, vous devez activer le calcul de l'identifiant de la requête. Il s'active automatiquement si compute_query_id est défini sur on ou auto dans le groupe de paramètres. La valeur par défaut du paramètre compute_query_id est auto. Vous devez également créer cette extension pour activer cette fonctionnalité. Utilisez la commande suivante pour installer l'extension à partir du point de terminaison T-SQL :


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

Vous pouvez accéder aux statistiques des requêtes à l'aide de la requête suivante :



postgres=>select * from pg_stat_statements;

Note

Pendant l'installation, si vous ne fournissez pas le nom du schéma de l'extension, celle-ci sera créée par défaut dans le schéma public. Pour y accéder, vous devez utiliser des crochets avec un qualificateur de schéma, comme indiqué ci-dessous :


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

Vous pouvez également créer l'extension à partir du point de terminaison PSQL.

Autorisation de l'extension

Par défaut, vous pouvez consulter les statistiques des requêtes effectuées dans votre base de données T-SQL sans avoir besoin d'autorisation.

Pour accéder aux statistiques des requêtes créées par d'autres utilisateurs, vous devez disposer du rôle pg_read_all_stats PostgreSQL. Suivez les étapes mentionnées ci-dessous pour créer la commande GRANT pg_read_all_stats.

Dans T-SQL, utilisez la requête suivante qui renvoie le nom du rôle PG interne.
```
SELECT rolname FROM pg_roles WHERE oid = USER_ID();
```
Connectez-vous à la base de données Babelfish for Aurora PostgreSQL avec le privilège rds_superuser et utilisez la commande suivante :
```
GRANT pg_read_all_stats TO <rolname_from_above_query>
```

Exemple

À partir du point de terminaison T-SQL :


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



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

À partir du point de terminaison PSQL :


babelfish_db=# grant pg_read_all_stats to master_dbo;


GRANT ROLE

Vous pouvez accéder aux statistiques des requêtes à l'aide de la vue pg_stat_statements :


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)

Réinitialisation des statistiques des requêtes

Vous pouvez utiliser pg_stat_statements_reset() pour réinitialiser les statistiques recueillies jusqu'à présent par pg_stat_statements. Pour plus d'informations, consultez pg_stat_statements. Elle est actuellement prise en charge uniquement via le point de terminaison PSQL. Connectez-vous à Babelfish for Aurora PostgreSQL avec le privilège rds_superuser et utilisez la commande suivante :



SELECT pg_stat_statements_reset();

Limites

Actuellement, pg_stat_statements() n'est pas pris en charge via le point de terminaison T-SQL. La vue pg_stat_statements est la méthode recommandée pour recueillir les statistiques.
Certaines requêtes peuvent être réécrites par l'analyseur T-SQL implémenté par le moteur Aurora PostgreSQL. La vue pg_stat_statements affichera la requête réécrite, et non la requête d'origine.

Exemple
```
select next value for [dbo].[newCounter];
```
La requête ci-dessus est réécrite comme suit dans la vue pg_stat_statements.
```
select nextval($1);
```
Selon le flux d'exécution des instructions, certaines requêtes peuvent ne pas être suivies par pg_stat_statements et ne seront pas visibles dans la vue. Elle comprend les instructions suivantes : use dbname, goto, print, raise error, set, throw, declare cursor.
Pour les instructions CREATE LOGIN et ALTER LOGIN, query et queryid ne s'afficheront pas. Elle indiquera que les privilèges sont insuffisants.
La vue pg_stat_statements contient toujours les deux entrées ci-dessous, car elles sont exécutées en interne par le client sqlcmd.
- SET QUOTED_IDENTIFIER OFF
- SET TEXTSIZE 4096

Utiliser pgvector dans Babelfish

pgvector, une extension open source, vous permet de rechercher des données similaires directement dans votre base de données Postgres. Babelfish supporte désormais cette extension à partir des versions 15.6 et 16.2. Pour plus d'informations, consultez la documentation open source de pgvector.

Prérequis

Pour activer la fonctionnalité pgvector, installez l'extension dans le schéma sys en utilisant l'une des méthodes suivantes :

Exécutez la commande suivante dans le client sqlcmd :


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

Connectez-vous babelfish_db et exécutez la commande suivante dans le client psql :
```
CREATE EXTENSION vector WITH SCHEMA sys;
```

Note

Après avoir installé l'extension pgvector, le type de données vectorielles ne sera disponible que dans les nouvelles connexions à la base de données que vous établirez. Les connexions existantes ne reconnaîtront pas le nouveau type de données.

Fonctionnalité prise en charge

Babelfish étend les fonctionnalités T-SQL pour prendre en charge les éléments suivants :

Stockage

Babelfish prend désormais en charge la syntaxe compatible avec les types de données vectoriels, améliorant ainsi sa compatibilité T-SQL. Pour en savoir plus sur le stockage de données avec pgvector, consultez Stockage.
Interrogation

Babelfish étend la prise en charge des expressions T-SQL pour inclure les opérateurs de similarité vectorielle. Cependant, pour toutes les autres requêtes, la syntaxe T-SQL standard est toujours requise.

Note
T-SQL ne prend pas en charge le type Array et les pilotes de base de données ne disposent d'aucune interface pour les gérer. Pour contourner le problème, Babelfish utilise des chaînes de texte (varchar/nvarchar) pour stocker des données vectorielles. Par exemple, lorsque vous demandez une valeur vectorielle [1,2,3], Babelfish renvoie une chaîne « [1,2,3] » comme réponse. Vous pouvez analyser et diviser cette chaîne au niveau de l'application selon vos besoins.

Pour en savoir plus sur l'interrogation de données avec pgvector, consultez la section Interrogation.
Indexation

T-SQL prend Create Index désormais en charge USING INDEX_METHOD la syntaxe. Vous pouvez désormais définir l'opérateur de recherche de similarité à utiliser sur une colonne spécifique lors de la création d'un index.

La grammaire est également étendue pour prendre en charge les opérations de similarité vectorielle sur la colonne requise (vérifiez la grammaire column_name_list_with_order_for_vector).
```
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])
```
Pour en savoir plus sur l'indexation des données avec pgvector, consultez Indexation.
Performances
- SET BABELFISH_STATISTICS PROFILE ONÀ utiliser pour déboguer les plans de requête à partir du point de terminaison T-SQL.
- Augmentez max_parallel_workers_get_gather à l'aide de la set_config fonction prise en charge dans T-SQL.
- À utiliser IVFFlat pour des recherches approximatives. Pour plus d'informations, consultez IVFFlat.
Pour améliorer les performances avec pgvector, consultez Performance.

Limites

Babelfish ne prend pas en charge la recherche en texte intégral pour la recherche hybride. Pour plus d'informations, consultez la section Recherche hybride.
Babelfish ne prend actuellement pas en charge la fonctionnalité de réindexation. Cependant, vous pouvez toujours utiliser le point de terminaison PostgreSQL pour réindexer. Pour plus d'informations, consultez la section Passer l'aspirateur.

Utilisation de l'apprentissage automatique d'Amazon Aurora avec Babelfish

Vous pouvez étendre les fonctionnalités de votre cluster de base de données Babelfish for Aurora PostgreSQL en l'intégrant à l'apprentissage automatique Amazon Aurora. Cette intégration fluide vous donne accès à une gamme de services puissants tels qu'Amazon Comprehend, Amazon ou SageMaker Amazon Bedrock, chacun étant conçu pour répondre à des besoins d'apprentissage automatique distincts.

En tant qu'utilisateur de Babelfish, vous pouvez utiliser les connaissances existantes en matière de syntaxe et de sémantique T-SQL lorsque vous travaillez avec le machine learning Aurora. Suivez les instructions fournies dans la AWS documentation d'Aurora PostgreSQL. Pour plus d’informations, consultez Utilisation du machine learning Amazon Aurora avec Aurora PostgreSQL.

Prérequis

Avant d'essayer de configurer votre cluster de base de données Babelfish for Aurora PostgreSQL pour utiliser l'apprentissage automatique Aurora, vous devez connaître les exigences et les prérequis associés. Pour plus d’informations, consultez Exigences pour l'utilisation du machine learning Aurora avec Aurora PostgreSQL.
Assurez-vous d'installer l'aws_mlextension à l'aide du point de terminaison Postgres ou de la procédure du sp_execute_postgresql magasin.
```
exec sys.sp_execute_postgresql 'Create Extension aws_ml'
```
Note
Actuellement, Babelfish ne prend pas en charge les opérations en cascade sp_execute_postgresql dans Babelfish. Comme il aws_ml repose suraws_commons, vous devrez l'installer séparément à l'aide du point de terminaison Postgres.
```
create extension aws_common;
```

Gestion de la syntaxe et de la sémantique T-SQL avec des fonctions `aws_ml`

Les exemples suivants expliquent comment la syntaxe et la sémantique T-SQL sont appliquées aux services Amazon ML :

Exemple : aws_bedrock.invoke_model — Une requête simple utilisant les fonctions Amazon Bedrock


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

L'exemple suivant montre comment invoquer un modèle Anthropic Claude 2 pour Bedrock à l'aide de invoke_model.



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

Exemple : aws_comprehend.detect_sentiment — Une requête simple utilisant les fonctions Amazon Comprehend



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

L'exemple suivant montre comment appeler le service Amazon Comprehend.



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

Exemple : aws_sagemaker.invoke_endpoint — Une requête simple utilisant les fonctions Amazon 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)

Puisque model_input est marqué comme VARIADIC et de type « any », les utilisateurs peuvent transmettre une liste de n'importe quelle longueur et de n'importe quel type de données à la fonction qui servira d'entrée au modèle. L'exemple suivant montre comment appeler le SageMaker service Amazon.



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

Pour des informations plus détaillées sur l'utilisation de l'apprentissage automatique Aurora avec Aurora PostgreSQL, consultez. Utilisation du machine learning Amazon Aurora avec Aurora PostgreSQL

Limites

Bien que Babelfish n'autorise pas la création de tableaux, il peut toujours gérer des données représentant des tableaux. Lorsque vous utilisez des fonctions telles aws_bedrock.invoke_model_get_embeddings que celles qui renvoient des tableaux, les résultats sont fournis sous forme de chaîne contenant les éléments du tableau.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Utilisation des indicateurs de requête T-SQL pour améliorer les performances des requêtes Babelfish

Babelfish prend en charge les serveurs liés

Utilisation des extensions Aurora PostgreSQL avec Babelfish

Activation des extensions Aurora PostgreSQL dans votre cluster de base de données Babelfish

Pour configurer votre cluster de base de données Babelfish avec des privilèges pour les extensions Aurora PostgreSQL

Utilisation de Babelfish avec Amazon S3

Pour configurer l'accès de votre instance de base de données Babelfish à votre compartiment Amazon S3

Pour importer des données à partir d'Amazon S3 vers Babelfish et pour exporter des données Babelfish vers Amazon S3

Utiliser Babelfish avec AWS Lambda

Pour configurer l'accès à votre cluster de base de données Babelfish afin qu'il fonctionne avec Lambda

Pour appeler une fonction Lambda à partir de votre cluster de base de données Babelfish

Utilisation de pg_stat_statements dans Babelfish

Création de l'extension pg_stat_statements

Note

Autorisation de l'extension

Exemple

Réinitialisation des statistiques des requêtes

Limites

Utiliser pgvector dans Babelfish

Prérequis

Note

Fonctionnalité prise en charge

Note

Limites

Utilisation de l'apprentissage automatique d'Amazon Aurora avec Babelfish

Prérequis

Note

Gestion de la syntaxe et de la sémantique T-SQL avec des fonctions aws_ml

Exemple : aws_bedrock.invoke_model — Une requête simple utilisant les fonctions Amazon Bedrock

Exemple : aws_comprehend.detect_sentiment — Une requête simple utilisant les fonctions Amazon Comprehend

Exemple : aws_sagemaker.invoke_endpoint — Une requête simple utilisant les fonctions Amazon SageMaker

Limites

Gestion de la syntaxe et de la sémantique T-SQL avec des fonctions `aws_ml`