# Usar extensões do Aurora PostgreSQL com o Babelfish O Aurora PostgreSQL fornece extensões para trabalhar com outros serviços da AWS. Essas são extensões opcionais que oferecem suporte a vários casos de uso, como usar o Simple Storage Service (Amazon S3) com seu cluster de banco de dados para importar ou exportar dados. + Para importar dados de um bucket do Amazon S3 para seu cluster de banco de dados do Babelfish, configure a extensão `aws_s3` do Aurora PostgreSQL. Essa extensão também permite exportar dados do seu cluster de bancos de dados Aurora PostgreSQL para um bucket do Simple Storage Service (Amazon S3). + O AWS Lambda é um serviço de computação que permite executar código sem o provisionamento ou gerenciamento de servidores. Por exemplo, você pode usar funções Lambda para realizar certas ações, como processar notificações de eventos de uma instância de banco de dados. Para saber mais sobre o Lambda, consulte [O que é o AWS Lambda?](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) no * Guia do desenvolvedor do AWS Lambda.* Para invocar funções do Lambda a partir do cluster de banco de dados do Babelfish, configure a extensão `aws_lambda` do Aurora PostgreSQL. Para configurar essas extensões para o cluster do Babelfish, primeiro você precisa conceder permissão ao usuário interno do Babelfish para carregar as extensões. Depois de conceder permissão, você pode carregar extensões do Aurora PostgreSQL. ## Habilitar extensões do Aurora PostgreSQL em seu cluster de banco de dados do Babelfish Antes que você possa carregar o `aws_s3` ou as extensões do `aws_lambda`, você concede os privilégios necessários ao cluster de banco de dados do Babelfish. O procedimento a seguir usa a ferramenta da linha de comando `psql` do PostgreSQL para se conectar ao cluster de banco de dados. Para obter mais informações, consulte [Utilizar o psql para se conectar ao cluster de banco de dados](babelfish-connect-PostgreSQL.md#babelfish-connect-psql). Você também pode usar o pgAdmin. Para obter detalhes, consulte [Utilizar o pgAdmin para se conectar ao cluster de banco de dados](babelfish-connect-PostgreSQL.md#babelfish-connect-pgadmin). Este procedimento carrega ambos `aws_s3` e `aws_lambda`, um após o outro. Você não precisa carregar os dois se quiser usar apenas uma dessas extensões. A extensão `aws_commons` é necessária para cada um, e é carregada por padrão, conforme mostrado na saída. **Para configurar seu cluster de banco de dados do Babelfish com privilégios para as extensões do Aurora PostgreSQL** 1. Conecte-se ao seu cluster de banco de dados do Babelfish. Use o nome para o usuário “primário” (-U) que você especificou quando criou o cluster de banco de dados do Babelfish. O padrão (`postgres`) é mostrado nos exemplos. Para Linux, macOS ou Unix: ``` psql -h your-Babelfish.cluster.444455556666-us-east-1.rds.amazonaws.com \ -U postgres \ -d babelfish_db \ -p 5432 ``` Para Windows: ``` psql -h your-Babelfish.cluster.444455556666-us-east-1.rds.amazonaws.com ^ -U postgres ^ -d babelfish_db ^ -p 5432 ``` O comando responde com um prompt para inserir a senha para o nome de usuário (-U). ``` Password: ``` Insira a senha do nome de usuário (-U) para o cluster de banco de dados. Quando a conexão é bem-sucedida, a saída é semelhante à seguinte: ``` psql (13.4) SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, compression: off) Type "help" for help. postgres=> ``` 1. Conceda privilégios ao usuário interno do Babelfish para criar e carregar extensões. ``` babelfish_db=> GRANT rds_superuser TO master_dbo; GRANT ROLE ``` 1. Crie e carregue a extensão `aws_s3`. A extensão `aws_commons` é necessária e é instalada automaticamente quando o `aws_s3`está instalado. ``` babelfish_db=> create extension aws_s3 cascade; NOTICE: installing required extension "aws_commons" CREATE EXTENSION ``` 1. Crie e carregue a extensão `aws_lambda`. ``` babelfish_db=> create extension aws_lambda cascade; CREATE EXTENSION babelfish_db=> ``` ## Usar o Babelfish com o Simple Storage Service (Amazon S3) Se ainda não tiver um bucket do Simple Storage Service (Amazon S3) para usar com o cluster de banco de dados do Babelfish, crie um. Para qualquer bucket do Simple Storage Service (Amazon S3) que você deseja usar, você fornece acesso. Antes de tentar importar ou exportar dados usando um bucket do Simple Storage Service (Amazon S3), conclua as etapas únicas a seguir. **Para configurar o acesso da instância de banco de dados do Babelfish ao bucket do Simple Storage Service (Amazon S3)** 1. Crie um bucket do Simple Storage Service (Amazon S3) para a instância do Babelfish, se necessário. Para isso, siga as instruções em [Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.htmlurl-s3-user;GetStartedWithS3.html#creating-bucket) no *Guia do usuário do Amazon Simple Storage Service*. 1. Carregue arquivos no seu bucket do Amazon S3. Para isso, siga as etapas em [Adicionar um objeto a um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PuttingAnObjectInABucket.htmlurl-s3-user;GetStartedWithS3.html#uploading-an-object-bucket) no *Guia do usuário do Amazon Simple Storage Service*. 1. Configure permissões conforme necessário: + Para importar dados do Amazon S3, o cluster de banco de dados do Babelfish precisa de permissão para acessar o bucket. Recomendamos usar uma função AWS Identity and Access Management (IAM) e anexar uma política do IAM a essa função para o cluster. Para isso, siga as etapas em [Usar uma função do IAM para acessar um bucket do Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md#USER_PostgreSQL.S3Import.ARNRole). + Para exportar dados de seu cluster de banco de dados do Babelfish, seu cluster deve ter acesso ao bucket do Amazon S3. Assim como na importação, recomendamos o uso de uma função e uma política do IAM. Para isso, siga as etapas em [Configurar o acesso a um bucket do Amazon S3](postgresql-s3-export-access-bucket.md). Agora você pode usar o Amazon S3 com a extensão `aws_s3` com seu cluster de banco de dados do Babelfish. **Para importar dados do Simple Storage Service (Amazon S3) para o Babelfish e exportar dados do Babelfish para o Simple Storage Service (Amazon S3)** 1. Use a extensão `aws_s3` com seu cluster de banco de dados do Babelfish. Ao fazer isso, certifique-se de fazer referência às tabelas conforme elas existem no contexto do PostgreSQL. Ou seja, se você quiser importar para uma tabela Babelfish chamada `[database].[schema].[tableA]`, consulte essa tabela como `database_schema_tableA` na função `aws_s3`: + Para um exemplo de uso de uma função `aws_s3` para importar dados, consulte [Importar dados do Amazon S3 para um cluster de banco de dados do Aurora PostgreSQL](USER_PostgreSQL.S3Import.FileFormats.md). + Para exemplos de uso de funções `aws_s3` para exportar dados, consulte [Exportar dados de consulta usando a função aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md). 1. Certifique-se de fazer referência a tabelas do Babelfish usando a nomeação do PostgreSQL ao usar a extensão `aws_s3` e o Simple Storage Service (Amazon S3), conforme mostrado na tabela a seguir. | Mesa Babelfish | Mesa Aurora PostgreSQL | | --- | --- | | `database.schema.table` | `database_schema_table` | Para saber mais sobre como usar o Simple Storage Service (Amazon S3) com o Aurora PostgreSQL, consulte [Importar dados do Amazon S3 para um cluster de banco de dados do Aurora PostgreSQL](USER_PostgreSQL.S3Import.md) e [Exportar dados de um cluster de banco de dados do Aurora PostgreSQL para o Amazon S3](postgresql-s3-export.md). ## Usar o Babelfish com o AWS Lambda Depois que a extensão `aws_lambda` é carregada em seu cluster de banco de dados do Babelfish, mas antes que você possa chamar funções Lambda, você dá acesso ao Lambda ao cluster de banco de dados seguindo este procedimento. **Para configurar o acesso para o cluster de banco de dados do Babelfish para trabalhar com o Lambda** Este procedimento usa a AWS CLI para criar a política e o perfil do IAM e associá-los ao cluster de banco de dados do Babelfish. 1. Crie uma política do IAM que permita acesso ao Lambda a partir do seu cluster de banco de dados do 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. Crie uma função do IAM que a política possa assumir em tempo de execução. ``` 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. Anexe a política ao perfil. ``` aws iam attach-role-policy \ --policy-arn arn:aws:iam::444455556666:policy/rds-lambda-policy \ --role-name rds-lambda-role --region aws-region ``` 1. Anexar o perfil ao seu cluster de banco de dados do 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 ``` Depois de concluir essas tarefas, você pode invocar suas funções Lambda. Para obter mais informações e exemplos de configuração do AWS Lambda para o cluster de bancos de dados Aurora PostgreSQL com o AWS Lambda, consulte [Etapa 2: configurar o IAM para o cluster de bancos de dados do Aurora PostgreSQL e o AWS Lambda](PostgreSQL-Lambda.md#PostgreSQL-Lambda-access). **Para invocar uma função Lambda a partir do seu cluster de banco de dados do Babelfish** AWS LambdaO suporta funções escritas em Java, Node.js, Python, Ruby e outras linguagens. Se a função retornar texto quando invocada, você poderá chamá-la do cluster de banco de dados do Babelfish. O exemplo a seguir é uma função placeholder do python que retorna uma saudação. ``` lambda_function.py import json def lambda_handler(event, context): #TODO implement return { 'statusCode': 200, 'body': json.dumps('Hello from Lambda!') ``` Atualmente, o Babelfish não é compatível com o JSON. Se sua função retornar JSON, você usa um wrapper para lidar com o JSON. Por exemplo, digamos que a `lambda_function.py` mostrada antes é armazenada no Lambda como `my-function`. 1. Conecte-se ao seu cluster de banco de dados do Babelfish usando o cliente `psql` (ou o cliente pgAdmin). Para obter mais informações, consulte [Utilizar o psql para se conectar ao cluster de banco de dados](babelfish-connect-PostgreSQL.md#babelfish-connect-psql). 1. Crie o wrapper. Este exemplo usa a linguagem processual do PostgreSQL para SQL , `PL/pgSQL`. Para saber mais, consulte [Linguagem processual PL/pgSQL–SQL](https://www.postgresql.org/docs/13/plpgsql.html). ``` 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; $$; ``` A função agora pode ser executada a partir da porta Babelfish TDS (1433) ou da porta PostgreSQL (5433). 1. Para invocar (chamar) essa função a partir da sua porta PostgreSQL: ``` SELECT * from aws_lambda.invoke(aws_commons.create_lambda_function_arn('my-function', 'us-east-1'), '{"body": "Hello from Postgres!"}'::json ); ``` A saída é semelhante à seguinte: ``` status_code | payload | executed_version | log_result -------------+-------------------------------------------------------+------------------+------------ 200 | {"statusCode": 200, "body": "\"Hello from Lambda!\""} | $LATEST | (1 row) ``` 1. Para invocar (chamar) essa função a partir da porta TDS, conecte-se à porta usando o cliente da linha de comando `sqlcmd` do SQL Server. Para obter detalhes, consulte [Utilizar um cliente SQL Server para se conectar ao seu cluster de banco de dados](babelfish-connect-sqlserver.md). Quando conectado, execute o seguinte: ``` 1> select lambda_wrapper(); 2> go ``` Esse comando retorna uma saída semelhante à seguinte: ``` {"statusCode": 200, "body": "\"Hello from Lambda!\""} ``` Para saber mais sobre como usar o Lambda com o Aurora PostgreSQL, consulte [Invocar uma função do AWS Lambda de um cluster de banco de dados do Aurora PostgreSQL](PostgreSQL-Lambda.md). Para obter mais informações sobre como usar funções Lambda, consulte [Conceitos básicos do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) no *Guia do desenvolvedor do AWS Lambda*. ## Usando pg\$1stat\$1statements no Babelfish O Babelfish para Aurora PostgreSQL é compatível com a extensão `pg_stat_statements` a partir da versão 3.3.0. Para saber mais, consulte [pg\$1stat\$1statements](https://www.postgresql.org/docs/current/pgstatstatements.html). Para obter detalhes sobre a versão dessa extensão compatível com o Aurora PostgreSQL, consulte [Versões de extensão](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html). ### Criar a extensão pg\$1stat\$1statements Para ativar `pg_stat_statements`, você deve ativar o cálculo do identificador de consulta. Isso será feito automaticamente se `compute_query_id` estiver definido como `on` ou `auto` no grupo de parâmetros. O valor padrão do parâmetro `compute_query_id` é `auto`. Também é necessário criar essa extensão para ativar esse atributo. Use o comando a seguir para instalar a extensão do endpoint T-SQL: ``` 1>EXEC sp_execute_postgresql 'CREATE EXTENSION pg_stat_statements WITH SCHEMA sys'; ``` Você pode acessar as estatísticas da consulta usando a seguinte consulta: ``` postgres=>select * from pg_stat_statements; ``` **nota** Durante a instalação, se você não fornecer o nome do esquema para a extensão, por padrão, ela o criará no esquema público. Para acessá-lo, você deve usar colchetes com o qualificador de esquema, conforme mostrado abaixo: ``` postgres=>select * from [public].pg_stat_statements; ``` Você também pode criar a extensão a partir do endpoint PSQL. ### Autorizar a extensão Por padrão, você pode ver as estatísticas das consultas realizadas em seu banco de dados T-SQL sem a necessidade de qualquer autorização. Para acessar as estatísticas de consultas criadas por outras pessoas, você precisa ter a função `pg_read_all_stats` PostgreSQL. Siga as etapas mencionadas abaixo para construir o comando GRANT pg\$1read\$1all\$1stats. 1. No T-SQL, use a consulta a seguir que retorna o nome da função interna do PG. ``` SELECT rolname FROM pg_roles WHERE oid = USER_ID(); ``` 1. Conecte-se ao banco de dados do Babelfish para Aurora PostgreSQL com o privilégio rds\$1superuser e use o seguinte comando: ``` GRANT pg_read_all_stats TO ``` **Exemplo** No endpoint do T-SQL: ``` 1>SELECT rolname FROM pg_roles WHERE oid = USER_ID(); 2>go ``` ``` rolname ------- master_dbo (1 rows affected) ``` No endpoint do PSQL: ``` babelfish_db=# grant pg_read_all_stats to master_dbo; ``` ``` GRANT ROLE ``` Você pode acessar as estatísticas da consulta usando a exibição 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) ``` ### Redefinir as estatísticas de consulta Você pode usar `pg_stat_statements_reset()` para redefinir as estatísticas coletadas até agora por pg\$1stat\$1statements. Para saber mais, consulte [pg\$1stat\$1statements]( https://www.postgresql.org/docs/current/pgstatstatements.html). Atualmente, isso é compatível somente por meio do endpoint PSQL. Conecte-se ao Babelfish para Aurora PostgreSQL com o privilégio `rds_superuser` e use o seguinte comando: ``` SELECT pg_stat_statements_reset(); ``` ### Limitações + Atualmente, `pg_stat_statements()` não é compatível com o endpoint T-SQL. A exibição `pg_stat_statements` é a forma recomendada de coletar as estatísticas. + Algumas das consultas podem ser reescritas pelo analisador T-SQL implementado pelo mecanismo Aurora PostgreSQL. A exibição `pg_stat_statements` mostrará a consulta reescrita e não a consulta original. Exemplo ``` select next value for [dbo].[newCounter]; ``` A consulta acima foi reescrita da seguinte forma na exibição pg\$1stat\$1statements. ``` select nextval($1); ``` + Com base no fluxo de execução das instruções, algumas das consultas podem não ser rastreadas por pg\$1stat\$1statements e não estarão visíveis na exibição. Isso inclui as seguintes declarações: `use dbname`, `goto`, `print`, `raise error`, `set`, `throw`, `declare cursor`. + Para as instruções CREATE LOGIN e ALTER LOGIN, query e queryid não serão mostrados. Isso mostrará privilégios insuficientes. + A exibição `pg_stat_statements` sempre contém as duas entradas abaixo, pois elas são executadas internamente pelo cliente `sqlcmd`. + SET QUOTED\$1IDENTIFIER OFF + DEFINIR TAMANHO DO TEXTO 4096 ## Usar o pgvector no Babelfish O pgvector, uma extensão de código aberto, permite pesquisar dados semelhantes diretamente no banco de dados Postgres. O Babelfish comporta essa extensão a partir das versões 15.6 e 16.2. Para ter mais informações, consulte a [documentação de código aberto do pgvector](https://github.com/pgvector/pgvector). ### Pré-requisitos Para habilitar a funcionalidade pgvector, instale a extensão no esquema sys usando um dos seguintes métodos: + Execute o seguinte comando no cliente sqlcmd: ``` exec sys.sp_execute_postgresql 'CREATE EXTENSION vector WITH SCHEMA sys'; ``` + Conecte-se ao `babelfish_db` e execute o seguinte comando no cliente psql: ``` CREATE EXTENSION vector WITH SCHEMA sys; ``` **nota** Depois de instalar a extensão pgvector, os dados do tipo vetorial só estarão disponíveis nas novas conexões de banco de dados que você estabelecer. As conexões existentes não reconhecerão o novo tipo de dados. ### Funções compatíveis O Babelfish estende a funcionalidade T-SQL para comportar o seguinte: + **Armazenamento** O Babelfish agora aceita sintaxe compatível com dados do tipo vetorial, aprimorando a compatibilidade com T-SQL. Para saber mais sobre como armazenar dados com o pgvector, consulte [Storing](https://github.com/pgvector/pgvector?tab=readme-ov-file#storing). + **Consultas** O Babelfish expande o suporte à expressão T-SQL para incluir operadores de similaridade vetorial. No entanto, para todas as outras consultas, a sintaxe T-SQL padrão ainda é necessária. **nota** O T-SQL não comporta o tipo Array e os drivers do banco de dados não têm nenhuma interface para lidar com eles. Como solução alternativa, o Babelfish usa strings de texto (varchar/nvarchar) para armazenar dados vetoriais. Por exemplo, quando você solicita um valor vetorial [1,2,3], o Babelfish exibe uma string “[1,2,3]” como resposta. É possível analisar e dividir essa string em nível de aplicação de acordo com suas necessidades. Para saber mais sobre como consultar dados com o pgvector, consulte [Querying](https://github.com/pgvector/pgvector?tab=readme-ov-file#querying). + **Indexação** O T-SQL `Create Index` agora aceita a sintaxe `USING INDEX_METHOD`. Agora você pode definir o operador de pesquisa por similaridade a ser usado em uma coluna específica ao criar um índice. A gramática também é estendida para comportar operações de similaridade vetorial na coluna necessária (confira a gramática column\$1name\$1list\$1with\$1order\$1for\$1vector). ``` 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]) ``` Para saber mais sobre a indexação de dados com pgvector, consulte [Indexing](https://github.com/pgvector/pgvector?tab=readme-ov-file#indexing). + **desempenho** + Use `SET BABELFISH_STATISTICS PROFILE ON` para depurar os planos de consulta do endpoint T-SQL. + Aumente `max_parallel_workers_get_gather` usando a função `set_config` aceita no T-SQL. + Use `IVFFlat` para pesquisas aproximadas. Para ter mais informações, consulte [IVFFlat](https://github.com/pgvector/pgvector?tab=readme-ov-file#ivfflat). Para melhorar a performance com o pgvector, consulte [Performance](https://github.com/pgvector/pgvector?tab=readme-ov-file#performance). ### Limitações + O Babelfish não aceita pesquisa de texto completo para pesquisa híbrida. Para ter mais informações, consulte [Hybrid Search](https://github.com/pgvector/pgvector?tab=readme-ov-file#hybrid-search). + No momento, o Babelfish não comporta a funcionalidade de reindexação. No entanto, ainda é possível usar o endpoint PostgreSQL para reindexar. Para ter mais informações, consulte [Vacuuming](https://github.com/pgvector/pgvector?tab=readme-ov-file#vacuuming). ## Usar o machine learning do Amazon Aurora com Babelfish É possível ampliar os recursos do cluster de banco de dados do Babelfish para Aurora PostgreSQL integrando-o ao machine learning do Amazon Aurora. Essa integração perfeita concede acesso a uma série de serviços avançados, como o Amazon Comprehend, o Amazon SageMaker AI ou o Amazon Bedrock, cada um adaptado para atender às necessidades distintas de machine learning. Como usuário do Babelfish, é possível usar o conhecimento existente da sintaxe e da semântica do T-SQL ao trabalhar com o machine learning do Aurora. Siga as instruções fornecidas na documentação da AWS do Aurora PostgreSQL. Para obter mais informações, consulte [Usar machine learning do Amazon Aurora com o Aurora PostgreSQL](postgresql-ml.md). ### Pré-requisitos + Antes de tentar configurar o cluster de banco de dados do Babelfish para Aurora PostgreSQL para usar o machine learning do Aurora, é necessário entender os requisitos e os pré-requisitos relacionados. Para obter mais informações, consulte [Requisitos para usar o machine learning do Aurora com o Aurora PostgreSQL](postgresql-ml.md#postgresql-ml-prereqs). + Não se esqueça de instalar a extensão `aws_ml` usando o endpoint Postgres ou o procedimento de armazenamento `sp_execute_postgresql`. ``` exec sys.sp_execute_postgresql 'Create Extension aws_ml' ``` **nota** No momento, o Babelfish não aceita operações em cascata com `sp_execute_postgresql` no Babelfish. Como `aws_ml` depende de `aws_commons`, você precisará instalá-lo separadamente usando o endpoint Postgres. ``` create extension aws_common; ``` ### Tratar a sintaxe e a semântica do T-SQL com funções `aws_ml` Os exemplos a seguir explicam como a sintaxe e a semântica do T-SQL são aplicadas aos serviços de ML da Amazon: **Example : aws\$1bedrock.invoke\$1model: uma consulta simples utilizando as funções do Amazon Bedrock.** ``` aws_bedrock.invoke_model( model_id varchar, content_type text, accept_type text, model_input text) Returns Varchar(MAX) ``` O exemplo a seguir mostra como invocar um modelo do Anthropic Claude 2 para o Bedrock usando 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: uma consulta simples utilizando as funções do Amazon Comprehend.** ``` aws_comprehend.detect_sentiment( input_text varchar, language_code varchar, max_rows_per_batch int) Returns table (sentiment varchar, confidence real) ``` O código de exemplo a seguir mostra como invocar o serviço do Amazon Comprehend. ``` select sentiment from aws_comprehend.detect_sentiment('This is great', 'en'); ``` **Example : aws\$1sagemaker.invoke\$1endpoint: uma consulta simples usando as funções do 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) ``` Como model\$1input está marcado como VARIADIC e com o tipo “any”, os usuários podem transmitir uma lista de qualquer tamanho e de qualquer tipo de dados para a função, que atuará como entrada para o modelo. O código de exemplo a seguir mostra como invocar o serviço do Amazon SageMaker. ``` 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 ``` Para ter mais informações detalhadas sobre como usar o machine learning do Aurora com o Aurora PostgreSQL, consulte [Usar machine learning do Amazon Aurora com o Aurora PostgreSQL](postgresql-ml.md). ### Limitações + Embora o Babelfish não permita a criação de matrizes, ele ainda pode tratar dados que representam matrizes. Quando você usa funções como `aws_bedrock.invoke_model_get_embeddings` que exibem matrizes, os resultados são entregues como uma string com os elementos da matriz.