Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Utilizzo delle estensioni Aurora PostgreSQL con Babelfish Aurora PostgreSQL fornisce estensioni per lavorare con altri servizi. AWS Si tratta di estensioni opzionali che supportano diversi casi d'uso, ad esempio l'utilizzo di Amazon S3 con il cluster database per l'importazione o l'esportazione di dati. + Per importare i dati da un bucket Amazon S3 nel cluster database Babelfish, è necessario configurare l'estensione Aurora PostgreSQL `aws_s3`. Questa estensione consente anche di esportare i dati dal cluster database di Aurora PostgreSQL in un bucket Simple Storage Service (Amazon S3). + AWS Lambda è un servizio di elaborazione che consente di eseguire codice senza fornire o gestire server. È possibile utilizzare le funzioni Lambda per elaborare le notifiche di eventi da un'istanza database. Per ulteriori informazioni su Lambda, consulta [Che cos'è AWS Lambda?](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) nella *Guida per gli sviluppatori di AWS Lambda .* Per richiamare le funzioni Lambda dal cluster database Babelfish, è necessario configurare l'estensione Aurora PostgreSQL `aws_lambda`. Per configurare queste estensioni per il cluster Babelfish, devi prima concedere l'autorizzazione all'utente Babelfish interno per caricare le estensioni. Dopo aver concesso l'autorizzazione, è possibile caricare le estensioni Aurora PostgreSQL. ## Abilitazione delle estensioni Aurora PostgreSQL nel cluster database Babelfish Per poter caricare le estensioni `aws_s3` o `aws_lambda`, concedere i privilegi necessari al cluster database Babelfish. Nella procedura che segue viene utilizzato lo strumento a riga di comando `psql` di PostgreSQL per connettersi al cluster database. Per ulteriori informazioni, consulta [Usare psql per connettersi al cluster di database](babelfish-connect-PostgreSQL.md#babelfish-connect-psql). È possibile utilizzare anche pgAdmin. Per informazioni dettagliate, vedi [Uso di pgAdmin per connettersi al cluster di database](babelfish-connect-PostgreSQL.md#babelfish-connect-pgadmin). Questa procedura carica `aws_s3` e `aws_lambda`, uno dopo l'altro. Se si desidera utilizzare solo una di queste estensioni, non è necessario caricarle entrambe. L'estensione `aws_commons` è richiesta da ciascuno e viene caricata per impostazione predefinita come mostrato nell'output. **Per configurare il cluster database Babelfish con privilegi per le estensioni Aurora PostgreSQL** 1. Connettiti al cluster database Babelfish. Utilizza il nome per l'utente "master" (-U) specificato al momento della creazione del cluster database Babelfish. Il valore predefinito (`postgres`) viene visualizzato negli esempi. Per Linux, macOS o Unix: ``` psql -h your-Babelfish.cluster.444455556666-us-east-1.rds.amazonaws.com \ -U postgres \ -d babelfish_db \ -p 5432 ``` Per Windows: ``` psql -h your-Babelfish.cluster.444455556666-us-east-1.rds.amazonaws.com ^ -U postgres ^ -d babelfish_db ^ -p 5432 ``` Il comando risponde con un prompt per inserire la password per il nome utente (-U). ``` Password: ``` Inserisci la password del nome utente (-U) per il cluster database. Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente. ``` psql (13.4) SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, compression: off) Type "help" for help. postgres=> ``` 1. Concedi i privilegi all'utente Babelfish interno per creare e caricare le estensioni. ``` babelfish_db=> GRANT rds_superuser TO master_dbo; GRANT ROLE ``` 1. Crea e carica l'estensione `aws_s3`. L'estensione `aws_commons` è obbligatoria e viene installata automaticamente quando viene installato `aws_s3`. ``` babelfish_db=> create extension aws_s3 cascade; NOTICE: installing required extension "aws_commons" CREATE EXTENSION ``` 1. Crea e carica l'estensione `aws_lambda`. ``` babelfish_db=> create extension aws_lambda cascade; CREATE EXTENSION babelfish_db=> ``` ## Utilizzo di Babelfish con Simple Storage Service (Amazon S3) Se non hai già un bucket Simple Storage Service (Amazon S3) da utilizzare con il cluster database Babelfish, puoi creane uno. Fornisci l'accesso per qualsiasi bucket Simple Storage Service (Amazon S3) che desideri utilizzare. Prima di provare a importare o esportare dati utilizzando un bucket Simple Storage Service (Amazon S3), completa i seguenti passaggi una tantum. **Per configurare l'accesso per la tua istanza database Babelfish al bucket Simple Storage Service (Amazon S3)** 1. Se necessario, crea un bucket Simple Storage Service (Amazon S3) per la tua istanza Babelfish. Per farlo, segui le istruzioni riportate in [Create a bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.htmlurl-s3-user;GetStartedWithS3.html#creating-bucket) nella *Guida per l’utente di Amazon Simple Storage Service*. 1. Carica i file nel tuo bucket Simple Storage Service (Amazon S3). A tale scopo, attieniti alla procedura descritta in [Add an object to a bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PuttingAnObjectInABucket.htmlurl-s3-user;GetStartedWithS3.html#uploading-an-object-bucket) nella *Guida per l’utente di Amazon Simple Storage Service.* 1. Imposta le autorizzazioni come necessario: + Per importare dati da Amazon S3, il cluster database Babelfish richiede l'autorizzazione per accedere al bucket. Ti consigliamo di utilizzare un ruolo AWS Identity and Access Management (IAM) e di associare una policy IAM a quel ruolo per il tuo cluster. A tale scopo, segui la procedura in [Utilizzo di un ruolo IAM per accedere a un bucket Amazon S3.](USER_PostgreSQL.S3Import.AccessPermission.md#USER_PostgreSQL.S3Import.ARNRole). + Per esportare i dati dal cluster database Babelfish, è necessario concedere al cluster l'accesso al bucket Amazon S3. Come per l'importazione, si consiglia di utilizzare un ruolo e una policy IAM. A tale scopo, segui la procedura in [Configurazione dell'accesso a un bucket Amazon S3](postgresql-s3-export-access-bucket.md). Ora puoi utilizzare Amazon S3 con l'estensione `aws_s3` con il cluster database Babelfish. **Per importare dati da Simple Storage Service (Amazon S3) in Babelfish ed esportare dati Babelfish in Simple Storage Service (Amazon S3)** 1. Utilizzo dell'estensione `aws_s3` con il cluster database Babelfish. In questa situazione, assicurati di fare riferimento alle tabelle così come sono presenti nel contesto di PostgreSQL. Vale a dire, se vuoi importare in una tabella Babelfish denominata `[database].[schema].[tableA]`, fai riferimento a quella tabella come `database_schema_tableA` nella funzione `aws_s3`: + Per un esempio di utilizzo di una funzione `aws_s3` per importare dati, vedi [](USER_PostgreSQL.S3Import.FileFormats.md). + Per esempi di utilizzo di funzioni `aws_s3` per esportare dati, vedi [Esportazione dei dati della query utilizzando la funzione aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md). 1. Assicurati di fare riferimento alle tabelle Babelfish usando la denominazione PostgreSQL quando utilizzi l'estensione `aws_s3` e Simple Storage Service (Amazon S3), come illustrato nella tabella seguente. | Tabella Babelfish | Tabella Aurora PostgreSQL | | --- | --- | | `database.schema.table` | `database_schema_table` | Per ulteriori informazioni sull'uso di Amazon S3 con Aurora PostgreSQL, vedi [Importazione di dati da Amazon S3 in un cluster database Aurora PostgreSQL](USER_PostgreSQL.S3Import.md) e [Esportazione di dati da del cluster di database Aurora PostgreSQLRDS per PostgreSQL a Amazon S3](postgresql-s3-export.md). ## Usare Babelfish con AWS Lambda Dopo aver caricato l'estensione `aws_lambda` nel cluster database Babelfish ma prima di richiamare le funzioni Lambda, puoi fornire l'accesso a Lambda al cluster database seguendo questa procedura. **Per configurare l'accesso per il cluster database Babelfish per il funzionamento con Lambda** Questa procedura utilizza AWS CLI per creare la politica e il ruolo IAM e associarli al cluster Babelfish DB. 1. Crea una policy IAM che consente l'accesso a Lambda dal cluster database 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" } ] }' ``` 1. Crea un ruolo IAM che la policy può assumere in fase di esecuzione. ``` 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" } ] }' ``` 1. Collegare la policy al ruolo. ``` aws iam attach-role-policy \ --policy-arn arn:aws:iam::444455556666:policy/rds-lambda-policy \ --role-name rds-lambda-role --region aws-region ``` 1. Associa il ruolo al tuo cluster database 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 ``` Dopo aver completato queste attività, è possibile richiamare le funzioni Lambda. Per ulteriori informazioni ed esempi di configurazione AWS Lambda per il cluster Aurora PostgreSQL DB con, consulta. AWS Lambda[ AWS Lambda](PostgreSQL-Lambda.md#PostgreSQL-Lambda-access) **Per richiamare una funzione Lambda dal cluster database Babelfish** AWS Lambda supporta funzioni scritte in Java, Node.js, Python, Ruby e altri linguaggi. Se la funzione restituisce un testo quando viene richiamata, è possibile richiamarla dal cluster database Babelfish. L'esempio seguente è una funzione python segnaposto che restituisce un saluto. ``` lambda_function.py import json def lambda_handler(event, context): #TODO implement return { 'statusCode': 200, 'body': json.dumps('Hello from Lambda!') ``` Attualmente, Babelfish non supporta JSON. Se la funzione restituisce JSON, si utilizza un wrapper per gestire il JSON. Ad esempio, diciamo che la funzione `lambda_function.py` mostrata in precedenza è memorizzata in Lambda come `my-function`. 1. Collegati al cluster database Babelfish utilizzando il client `psql` (o il client pgAdmin). Per ulteriori informazioni, consulta [Usare psql per connettersi al cluster di database](babelfish-connect-PostgreSQL.md#babelfish-connect-psql). 1. Crea il wrapper. Questo esempio utilizza il linguaggio procedurale di PostgreSQL per SQL, `PL/pgSQL`. Per ulteriori informazioni, consulta [PL/pgSQL–SQL Procedural Language](https://www.postgresql.org/docs/13/plpgsql.html) (PL/pgSQL - Linguaggio procedurale SQL). ``` 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 funzione ora può essere eseguita dalla porta TDS Babelfish (1433) o dalla porta PostgreSQL (5433). 1. Per richiamare (chiamare) questa funzione dalla porta PostgreSQL: ``` SELECT * from aws_lambda.invoke(aws_commons.create_lambda_function_arn('my-function', 'us-east-1'), '{"body": "Hello from Postgres!"}'::json ); ``` L'output è simile a quello riportato di seguito: ``` status_code | payload | executed_version | log_result -------------+-------------------------------------------------------+------------------+------------ 200 | {"statusCode": 200, "body": "\"Hello from Lambda!\""} | $LATEST | (1 row) ``` 1. Per richiamare (chiamare) questa funzione dalla porta TDS, connettiti alla porta utilizzando il client della riga di comando `sqlcmd` di SQL Server. Per informazioni dettagliate, vedi [Utilizzo di un client SQL Server per la connessione al cluster database](babelfish-connect-sqlserver.md). Una volta connesso, esegui quanto segue: ``` 1> select lambda_wrapper(); 2> go ``` Il comando restituisce un output simile al seguente: ``` {"statusCode": 200, "body": "\"Hello from Lambda!\""} ``` Per ulteriori informazioni sull'uso di Lambda con Aurora PostgreSQL, consulta [](PostgreSQL-Lambda.md). Per ulteriori informazioni sull'utilizzo delle funzioni Lambda, consulta [Nozioni di base su Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) nella *Guida per gli sviluppatori di AWS Lambda *. ## Utilizzo di pg\$1stat\$1statements in Babelfish Babelfish per Aurora PostgreSQL supporta l'estensione `pg_stat_statements` dalla versione 3.3.0. Per maggiori informazioni, consulta [pg\$1stat\$1statements](https://www.postgresql.org/docs/current/pgstatstatements.html). Per informazioni sulla versione di questa estensione supportata da Aurora PostgreSQL, consulta [Extension versions](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html). ### Creazione dell'estensione pg\$1stat\$1statements Per attivare `pg_stat_statements`, è necessario attivare il calcolo dell'identificatore di query. Questa operazione viene eseguita automaticamente se `compute_query_id` è impostato su `on` o `auto` nel gruppo di parametri. Il valore predefinito del parametro `compute_query_id` è `auto`. È inoltre necessario creare questa estensione per attivare questa funzionalità. Utilizza il comando seguente per installare l'estensione dall'endpoint T-SQL: ``` 1>EXEC sp_execute_postgresql 'CREATE EXTENSION pg_stat_statements WITH SCHEMA sys'; ``` È possibile accedere alle statistiche delle query utilizzando la seguente query: ``` postgres=>select * from pg_stat_statements; ``` **Nota** Se durante l'installazione non fornisci il nome dello schema per l'estensione, per impostazione predefinita l'estensione verrà creata in uno schema pubblico. Per accedervi, è necessario scrivere il qualificatore dello schema tra parentesi quadre, come mostrato di seguito: ``` postgres=>select * from [public].pg_stat_statements; ``` Puoi anche creare l'estensione dall'endpoint PSQL. ### Autorizzazione dell'estensione Per impostazione predefinita, è possibile visualizzare le statistiche per le query eseguite all'interno del database T-SQL senza bisogno di autorizzazioni. Per accedere alle statistiche delle query create da altri, è necessario disporre del ruolo PostgreSQL `pg_read_all_stats`. Segui i passaggi indicati di seguito per costruire il comando GRANT pg\$1read\$1all\$1stats. 1. In T-SQL, usa la seguente query che restituisce il nome del ruolo PG interno. ``` SELECT rolname FROM pg_roles WHERE oid = USER_ID(); ``` 1. Connettiti al database PostgreSQL di Babelfish per Aurora con il privilegio rds\$1superuser e usa il seguente comando: ``` GRANT pg_read_all_stats TO ``` **Esempio** Dall'endpoint T-SQL: ``` 1>SELECT rolname FROM pg_roles WHERE oid = USER_ID(); 2>go ``` ``` rolname ------- master_dbo (1 rows affected) ``` Dall'endpoint PSQL: ``` babelfish_db=# grant pg_read_all_stats to master_dbo; ``` ``` GRANT ROLE ``` Puoi accedere alle statistiche delle query utilizzando la vista pg\$1stat\$1statements: ``` 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 37503 34582 5615368793313871642 SET TEXTSIZE 4096 37503 34582 639400815330803392 create table t1(cola int) (6 rows affected) ``` ### Reimpostazione delle statistiche delle query Puoi usare `pg_stat_statements_reset()` per eseguire il ripristino delle statistiche raccolte finora da pg\$1stat\$1statements. Per maggiori informazioni, consulta [pg\$1stat\$1statements]( https://www.postgresql.org/docs/current/pgstatstatements.html). Attualmente è supportato solo tramite endpoint PSQL. Per connetterti a Babelfish per Aurora PostgreSQL con il privilegio `rds_superuser`, usa il comando seguente: ``` SELECT pg_stat_statements_reset(); ``` ### Limitazioni + Attualmente, `pg_stat_statements()` non è supportato tramite l'endpoint T-SQL. La vista `pg_stat_statements` è il metodo consigliato per raccogliere le statistiche. + Alcune query potrebbero essere riscritte dal parser T-SQL implementato dal motore di Aurora PostgreSQL, in tal caso la vista `pg_stat_statements` mostrerà la query riscritta e non la query originale. Esempio ``` select next value for [dbo].[newCounter]; ``` La query precedente viene riscritta come segue nella vista pg\$1stat\$1statements. ``` select nextval($1); ``` + In base al flusso di esecuzione delle istruzioni, alcune query potrebbero non essere tracciate da pg\$1stat\$1statements e non essere visibili nella vista. Ciò include le seguenti istruzioni: `use dbname`, `goto`, `print`, `raise error`, `set`, `throw`, `declare cursor`. + Per le istruzioni CREATE LOGIN e ALTER LOGIN, query e queryid non verranno visualizzate. Verrà visualizzato un avviso di privilegi insufficienti. + La vista `pg_stat_statements` contiene sempre le due voci seguenti, poiché vengono eseguite internamente dal client `sqlcmd`. + SET QUOTED\$1IDENTIFIER OFF + SET TEXTSIZE 4096 ## Utilizzo di pgvector in Babelfish L’estensione open source pgvector consente di cercare dati simili direttamente all’interno del database Postgres. Babelfish ora supporta questa estensione a partire dalle versioni 15.6 e 16.2. Per ulteriori informazioni, consultare la [documentazione open source per pgvector](https://github.com/pgvector/pgvector). ### Prerequisiti Per abilitare la funzionalità pgvector, installare l’estensione nello schema sys utilizzando uno dei seguenti metodi: + Eseguire il comando seguente nel client sqlcmd: ``` exec sys.sp_execute_postgresql 'CREATE EXTENSION vector WITH SCHEMA sys'; ``` + Connettersi a `babelfish_db` ed eseguire il comando seguente nel client psql: ``` CREATE EXTENSION vector WITH SCHEMA sys; ``` **Nota** Dopo aver installato l’estensione pgvector, il tipo di dati vettoriali sarà disponibile solo nelle nuove connessioni al database. Le connessioni esistenti non riconoscono il nuovo tipo di dati. ### Funzionalità supportata Babelfish estende la funzionalità T-SQL per supportare: + **Archiviazione** Babelfish ora supporta la sintassi compatibile con i tipi di dati vettoriali, migliorando la compatibilità T-SQL. Per saperne di più sull’archiviazione dei dati con pgvector, consulta [Storing](https://github.com/pgvector/pgvector?tab=readme-ov-file#storing). + **Esecuzione di query** Babelfish espande il supporto delle espressioni T-SQL per includere operatori di somiglianza vettoriale. Tuttavia, per tutte le altre query, è ancora richiesta la sintassi T-SQL standard. **Nota** T-SQL non supporta il tipo Matrice e i driver del database non dispongono di un’interfaccia per gestirlo. Come soluzione alternativa, Babelfish utilizza stringhe di testo (varchar/nvarchar) per archiviare i dati vettoriali. Ad esempio, quando si richiede un valore vettoriale [1,2,3], Babelfish restituisce una stringa '[1,2,3]' come risposta. È possibile analizzare e dividere questa stringa a livello di applicazione in base alle esigenze. Per ulteriori informazioni sull’esecuzione di query sui dati con pgvector, consulta [Esecuzione di query](https://github.com/pgvector/pgvector?tab=readme-ov-file#querying). + **Indicizzazione** T-SQL `Create Index` ora supporta la sintassi `USING INDEX_METHOD`. È ora possibile definire l’operatore di ricerca per similarità da utilizzare su una colonna specifica durante la creazione di un indice. La grammatica viene inoltre estesa per supportare le operazioni di similarità vettoriale sulla colonna richiesta (controlla column\$1name\$1list\$1with\$1order\$1for\$1vector grammar). ``` CREATE [UNIQUE] [clustered] [COLUMNSTORE] INDEX ON [USING vector_index_method] () Where column_name_list_with_order_for_vector is: [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]) ``` Per ulteriori informazioni sull’indicizzazione dei dati con pgvector, consulta [Indicizzazione](https://github.com/pgvector/pgvector?tab=readme-ov-file#indexing). + **Prestazioni** + Utilizzare `SET BABELFISH_STATISTICS PROFILE ON` per eseguire il debug dei piani di query dall’endpoint T-SQL. + Aumentare `max_parallel_workers_get_gather` utilizzando la funzione `set_config` supportata in T-SQL. + Utilizzare `IVFFlat` per ricerche approssimative. Per ulteriori informazioni, consulta [IVFFlat](https://github.com/pgvector/pgvector?tab=readme-ov-file#ivfflat). Per migliorare le prestazioni con pgvector, consulta [Prestazioni](https://github.com/pgvector/pgvector?tab=readme-ov-file#performance). ### Limitazioni + Babelfish non supporta la ricerca full-text per la ricerca ibrida. Per ulteriori informazioni, consulta [Hybrid Search](https://github.com/pgvector/pgvector?tab=readme-ov-file#hybrid-search). + Babelfish attualmente non supporta la funzionalità di reindicizzazione. Tuttavia, è possibile utilizzare l’endpoint PostgreSQL per reindicizzare. Per ulteriori informazioni, consulta [Vacuuming](https://github.com/pgvector/pgvector?tab=readme-ov-file#vacuuming). ## Utilizzo del machine learning Amazon Aurora con Babelfish È possibile estendere le funzionalità del cluster di database Babelfish per Aurora PostgreSQL integrandolo con il machine learning Amazon Aurora. Questa perfetta integrazione ti consente di accedere a una gamma di potenti servizi come Amazon Comprehend o Amazon AI o SageMaker Amazon Bedrock, ciascuno personalizzato per soddisfare esigenze di machine learning distinte. Come utente Babelfish, è possibile utilizzare le conoscenze esistenti della sintassi e della semantica T-SQL quando si lavora con il machine learning Aurora. Segui le istruzioni fornite nella AWS documentazione di Aurora PostgreSQL. Per ulteriori informazioni, consulta [Utilizzo del machine learning di Amazon Aurora con Aurora PostgreSQL](postgresql-ml.md). ### Prerequisiti + Prima di provare a configurare il cluster di database Babelfish per Aurora PostgreSQL per utilizzare il machine learning Aurora, è necessario comprendere i requisiti e i prerequisiti correlati. Per ulteriori informazioni, consulta [Requisiti per l'utilizzo del machine learning di Aurora con Aurora PostgreSQL](postgresql-ml.md#postgresql-ml-prereqs). + Assicurarsi di installare l’estensione `aws_ml` utilizzando l’endpoint Postgres o la stored procedure `sp_execute_postgresql`. ``` exec sys.sp_execute_postgresql 'Create Extension aws_ml' ``` **Nota** Attualmente Babelfish non supporta le operazioni a cascata con `sp_execute_postgresql`. Poiché `aws_ml` si basa su `aws_commons`, è necessario installarlo separatamente utilizzando l’endpoint Postgres. ``` create extension aws_common; ``` ### Gestione della sintassi e della semantica T-SQL con le funzioni `aws_ml` Gli esempi seguenti spiegano come la sintassi e la semantica T-SQL vengono applicate ai servizi Amazon ML: **Example : aws\$1bedrock.invoke\$1model: una query semplice che utilizza le funzioni di Amazon Bedrock** ``` aws_bedrock.invoke_model( model_id varchar, content_type text, accept_type text, model_input text) Returns Varchar(MAX) ``` L’esempio seguente mostra come invocare un modello Anthropic Claude 2 per Bedrock utilizzando invoke\$1model. ``` 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 ); ``` **Example : aws\$1comprehend.detect\$1sentiment: una query semplice che utilizza le funzioni di Amazon Comprehend** ``` aws_comprehend.detect_sentiment( input_text varchar, language_code varchar, max_rows_per_batch int) Returns table (sentiment varchar, confidence real) ``` L’esempio seguente mostra come invocare il servizio Amazon Comprehend. ``` select sentiment from aws_comprehend.detect_sentiment('This is great', 'en'); ``` **Example : aws\$1sagemaker.invoke\$1endpoint — Una semplice query che utilizza le funzioni di 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) ``` Poiché model\$1input è contrassegnato come VARIADIC e ha il tipo “any”, gli utenti possono passare un elenco di qualsiasi lunghezza e qualsiasi tipo di dati alla funzione che fungerà da input per il modello. L'esempio seguente mostra come richiamare il SageMaker servizio 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 ``` Per ulteriori informazioni sull’utilizzo del machine learning Aurora con Aurora PostgreSQL, consulta [Utilizzo del machine learning di Amazon Aurora con Aurora PostgreSQL](postgresql-ml.md). ### Limitazioni + Sebbene Babelfish non consenta la creazione di matrici, può comunque gestire i dati che rappresentano matrici. Quando si utilizzano funzioni come `aws_bedrock.invoke_model_get_embeddings` che restituiscono matrici, i risultati vengono forniti come una stringa contenente gli elementi della matrice.