Habilitar extensões do Aurora PostgreSQL em seu cluster de banco de dados do Babelfish Usar o Babelfish com o Simple Storage Service (Amazon S3)Usar o Babelfish com o AWS Lambda Usando pg_stat_statements no Babelfish Usar o pgvector no Babelfish Usar o machine learning do Amazon Aurora com Babelfish

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? 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. Você também pode usar o pgAdmin. Para obter detalhes, consulte Utilizar o pgAdmin para se conectar ao cluster de banco de dados.

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

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=>
```
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
```
Crie e carregue a extensão aws_s3. A extensão aws_commons é necessária e é instalada automaticamente quando o aws_s3está instalado.
```
babelfish_db=> create extension aws_s3 cascade;
NOTICE:  installing required extension "aws_commons"
CREATE EXTENSION
```

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)

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 no Guia do usuário do Amazon Simple Storage Service.
Carregue arquivos no seu bucket do Simple Storage Service (Amazon S3). Para isso, siga as etapas em Adicionar um objeto a um bucket no Guia do usuário do Amazon Simple Storage Service.
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.
- 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.

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)

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.
- Para exemplos de uso de funções aws_s3 para exportar dados, consulte Exportar dados de consulta usando a função aws_s3.query_export_to_s3.
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 e Exportar dados de um cluster de banco de dados do Aurora PostgreSQL para o Amazon S3.

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.

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

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

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

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 Aurora PostgreSQL e AWS Lambda.

Para invocar uma função Lambda a partir do seu cluster de banco de dados do Babelfish

O AWS Lambda 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.

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.

Crie o wrapper. Este exemplo usa a linguagem processual do PostgreSQL para SQL ,PL/pgSQL. Para saber mais, consulte Linguagem processual PL/pgSQL–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;
$$;

A função agora pode ser executada a partir da porta Babelfish TDS (1433) ou da porta PostgreSQL (5433).

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)

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. 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 bancos de dados Aurora PostgreSQL. Para obter mais informações sobre como usar funções Lambda, consulte Conceitos básicos do Lambda no Guia do desenvolvedor do AWS Lambda.

Usando pg_stat_statements 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_stat_statements.

Para obter detalhes sobre a versão dessa extensão compatível com o Aurora PostgreSQL, consulte Versões de extensão.

Criar a extensão pg_stat_statements

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_read_all_stats.

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();
```
Conecte-se ao banco de dados do Babelfish para Aurora PostgreSQL com o privilégio rds_superuser e use o seguinte comando:
```
GRANT pg_read_all_stats TO <rolname_from_above_query>
```

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

Redefinir as estatísticas de consulta

Você pode usar pg_stat_statements_reset() para redefinir as estatísticas coletadas até agora por pg_stat_statements. Para saber mais, consulte pg_stat_statements. 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_stat_statements.
```
select nextval($1);
```
Com base no fluxo de execução das instruções, algumas das consultas podem não ser rastreadas por pg_stat_statements 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_IDENTIFIER 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.

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.
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.
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_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])
```
Para saber mais sobre a indexação de dados com pgvector, consulte 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.
Para melhorar a performance com o pgvector, consulte Performance.

Limitações

O Babelfish não aceita pesquisa de texto completo para pesquisa híbrida. Para ter mais informações, consulte 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.

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 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.

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.
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:

exemplo : aws_bedrock.invoke_model: 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_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
);

exemplo : aws_comprehend.detect_sentiment: 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');

exemplo : aws_sagemaker.invoke_endpoint: 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_input 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.

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.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Usar dicas de consulta T-SQL para melhorar a performance de consultas do Babelfish

O Babelfish é compatível com servidores vinculados

Usar extensões do Aurora PostgreSQL com o Babelfish

Habilitar extensões do Aurora PostgreSQL em seu cluster de banco de dados do Babelfish

Para configurar seu cluster de banco de dados do Babelfish com privilégios para as extensões do Aurora PostgreSQL

Usar o Babelfish com o Simple Storage Service (Amazon S3)

Para configurar o acesso da instância de banco de dados do Babelfish ao bucket do Simple Storage Service (Amazon S3)

Para importar dados do Simple Storage Service (Amazon S3) para o Babelfish e exportar dados do Babelfish para o Simple Storage Service (Amazon S3)

Usar o Babelfish com o AWS Lambda

Para configurar o acesso para o cluster de banco de dados do Babelfish para trabalhar com o Lambda

Para invocar uma função Lambda a partir do seu cluster de banco de dados do Babelfish

Usando pg_stat_statements no Babelfish

Criar a extensão pg_stat_statements

nota

Autorizar a extensão

Exemplo

Redefinir as estatísticas de consulta

Limitações

Usar o pgvector no Babelfish

Pré-requisitos

nota

Funções compatíveis

nota

Limitações

Usar o machine learning do Amazon Aurora com Babelfish

Pré-requisitos

nota

Tratar a sintaxe e a semântica do T-SQL com funções aws_ml

exemplo : aws_bedrock.invoke_model: uma consulta simples utilizando as funções do Amazon Bedrock.

exemplo : aws_comprehend.detect_sentiment: uma consulta simples utilizando as funções do Amazon Comprehend.

exemplo : aws_sagemaker.invoke_endpoint: uma consulta simples usando as funções do Amazon SageMaker.

Limitações

Tratar a sintaxe e a semântica do T-SQL com funções `aws_ml`