# Uso de las extensiones Aurora PostgreSQL con Babelfish Aurora PostgreSQL proporciona extensiones para trabajar con otros servicios de AWS. Se trata de extensiones opcionales que admiten varios casos de uso, como el uso de Simple Storage Service (Amazon S3) con su clúster de bases de datos para importar o exportar datos. + Para importar datos desde un bucket de Amazon S3 al clúster de base de datos de Babelfish, debe configurar la extensión `aws_s3` Aurora PostgreSQL. Esta extensión también le permite exportar datos desde el clúster de la base de datos de Aurora PostgreSQL a un bucket de Simple Storage Service (Amazon S3). + AWS Lambda es un servicio automático que permite ejecutar código sin aprovisionar ni administrar servidores. Puede usar funciones de Lambda para hacer cosas como procesar notificaciones de eventos desde su instancia de base de datos. Para obtener más información sobre Lambda, consulte [¿Qué es AWS Lambda?](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) en la *Guía para desarrolladores de AWS Lambda.* Para invocar funciones de Lambda desde el clúster de Babelfish, debe configurar la extensión `aws_lambda` Aurora PostgreSQL. A fin de configurar estas extensiones para el clúster de Babelfish, primero debe conceder permiso al usuario interno de Babelfish para cargar las extensiones. Después de conceder el permiso, puede cargar las extensiones Aurora PostgreSQL. ## Habilitación de las extensiones Aurora PostgreSQL en el clúster de la base de datos de Babelfish Antes de poder cargar las extensiones `aws_s3` o `aws_lambda`, debe otorgar los privilegios necesarios al clúster de la base de datos de Babelfish. El siguiente procedimiento usa la herramienta de la línea de comandos `psql` PostgreSQL para conectarse al clúster de la base de datos. Para obtener más información, consulte [Conexión al clúster de bases de datos mediante psql](babelfish-connect-PostgreSQL.md#babelfish-connect-psql). También puede usar pgAdmin. Para obtener más información, consulte [Uso de pgAdmin para conectarse al clúster de bases de datos](babelfish-connect-PostgreSQL.md#babelfish-connect-pgadmin). Este procedimiento carga tanto `aws_s3` como `aws_lambda`, uno tras otro. No es necesario que cargue ambas si desea usar solo una de estas extensiones. La extensión `aws_commons` es requerida por cada una de ellas y se carga de forma predeterminada como se muestra en la salida. **Para configurar el clúster de la base de datos de Babelfish con privilegios para las extensiones de Aurora PostgreSQL** 1. Conéctese al clúster de base de datos de Babelfish. Use el nombre para el usuario “maestro” (-U) que especificó cuando creó el clúster de bases de datos de Babelfish. El valor predeterminado (`postgres`) se muestra en los ejemplos. Para Linux, macOS o 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 ``` El comando responde con una solicitud para ingresar la contraseña del nombre de usuario (-U). ``` Password: ``` Ingrese la contraseña del nombre de usuario (-U) para el clúster de bases de datos. Cuando se conecte correctamente, verá una respuesta similar a la siguiente. ``` 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 privilegios al usuario interno de Babelfish para crear y cargar extensiones. ``` babelfish_db=> GRANT rds_superuser TO master_dbo; GRANT ROLE ``` 1. Cree y cargue la extensión `aws_s3`. La extensión `aws_commons` es necesaria y se instala de forma automática cuando se instala el `aws_s3`. ``` babelfish_db=> create extension aws_s3 cascade; NOTICE: installing required extension "aws_commons" CREATE EXTENSION ``` 1. Cree y cargue la extensión `aws_lambda`. ``` babelfish_db=> create extension aws_lambda cascade; CREATE EXTENSION babelfish_db=> ``` ## Uso de Babelfish con Simple Storage Service (Amazon S3) Si aún no tiene un bucket de Simple Storage Service (Amazon S3) para usar con su clúster de bases de datos de Babelfish, puede crear uno. Debe proporcionar acceso a cualquier bucket de Simple Storage Service (Amazon S3) que desee usar. Antes de intentar importar o exportar datos con un bucket de Simple Storage Service (Amazon S3), complete los siguientes pasos de una sola vez. **Para configurar el acceso de la instancia de base de datos de Babelfish al bucket de Simple Storage Service (Amazon S3)** 1. Cree un bucket de Simple Storage Service (Amazon S3) para la instancia de Babelfish, si es necesario. Para ello, siga las instrucciones de [Crear un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.htmlurl-s3-user;GetStartedWithS3.html#creating-bucket) en la *Guía del usuario de Amazon Simple Storage Service*. 1. Cargue los archivos en el bucket de Simple Storage Service (Amazon S3). Para ello, siga los pasos de [Agregar un objeto a un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PuttingAnObjectInABucket.htmlurl-s3-user;GetStartedWithS3.html#uploading-an-object-bucket) en la *Guía del usuario de Amazon Simple Storage Service*. 1. Configure los permisos necesarios: + Para importar datos de Amazon S3, el clúster de base de datos de Babelfish necesita permiso para acceder al bucket. Se recomienda usar un rol de AWS Identity and Access Management (IAM) y adjuntar una política de IAM a ese rol para el clúster. Para ello, siga los pasos que se indican en [Uso de un rol de IAM para obtener acceso a un bucket de Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md#USER_PostgreSQL.S3Import.ARNRole). + Para exportar datos del clúster de base de datos de Babelfish, el clúster debe tener acceso al bucket de Amazon S3. Al igual que con la importación, se recomienda usar un rol y una política de IAM. Para ello, siga los pasos que se indican en [Configuración del acceso a un bucket de Amazon S3](postgresql-s3-export-access-bucket.md). Ahora puede usar Simple Storage Service (Amazon S3) con la extensión `aws_s3` con el clúster de base de datos de Babelfish. **Para importar datos de Simple Storage Service (Amazon S3) a Babelfish y para exportar datos de Babelfish a Amazon S3** 1. Use la extensión `aws_s3` con el clúster de bases de datos de Babelfish. Cuando lo haga, asegúrese de hacer referencia a las tablas, tal y como existen en el contexto de PostgreSQL. Es decir, si quiere importar a una tabla de Babelfish llamada `[database].[schema].[tableA]`, haga referencia a esa tabla como `database_schema_tableA` en la función `aws_s3`: + Para ver un ejemplo del uso de una función `aws_s3` para importar datos, consulte [Importación de datos de Amazon S3 a un clúster de base de datos de Aurora PostgreSQL ](USER_PostgreSQL.S3Import.FileFormats.md). + Para ver ejemplos del uso de las funciones de `aws_s3` para exportar datos, consulte [Exportación de datos de consulta mediante la función aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md). 1. Asegúrese de hacer referencia a las tablas de Babelfish mediante la nomenclatura de PostgreSQL cuando utilice la extensión `aws_s3` y Simple Storage Service (Amazon S3), como se muestra en la siguiente tabla. | Tabla de Babelfish | Tabla de Aurora PostgreSQL | | --- | --- | | `database.schema.table` | `database_schema_table` | Para obtener más información sobre el uso de Simple Storage Service (Amazon S3) con Aurora PostgreSQL, consulte [Importación de datos de Amazon S3 en un clúster de base de datos Aurora PostgreSQL](USER_PostgreSQL.S3Import.md) y [Exportación de datos de una Aurora PostgreSQL de base de datos de clústerde Amazon S3](postgresql-s3-export.md). ## Uso de Babelfish con AWS Lambda Después de cargar la extensión `aws_lambda` en el clúster de bases de datos de Babelfish, pero antes de poder invocar las funciones de Lambda, debe dar acceso a Lambda al clúster de bases de datos mediante este procedimiento. **Para configurar el acceso al clúster de la base de datos de Babelfish para trabajar con Lambda** Este procedimiento usa la AWS CLI para crear el rol y la política de IAM, así como para asociarlos al clúster de base de datos de Babelfish. 1. Cree una política de IAM que permita el acceso a Lambda desde el clúster de bases de datos de 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. Cree un rol de IAM que la política pueda asumir en tiempo de ejecución. ``` 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. Asocie la política de al rol. ``` aws iam attach-role-policy \ --policy-arn arn:aws:iam::444455556666:policy/rds-lambda-policy \ --role-name rds-lambda-role --region aws-region ``` 1. Adjunte el rol al clúster de base de datos de 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 ``` Después de completar estas tareas, puede invocar las funciones de Lambda. Para obtener más información y ejemplos de configuración de AWS Lambda para el clúster de bases de datos de Aurora PostgreSQL con AWS Lambda, consulte [Paso 2: configure IAM para su clúster de base de datos de Aurora PostgreSQL y AWS Lambda.](PostgreSQL-Lambda.md#PostgreSQL-Lambda-access). **Para invocar una función Lambda desde el clúster de bases de datos de Babelfish** AWS Lambda admite funciones escritas en Java, Node.js, Python, Ruby y otros lenguajes. Si la función devuelve texto cuando se invoca, puede invocarla desde el clúster de bases de datos de Babelfish. El siguiente ejemplo es una función Python de marcador de posición que muestra un saludo. ``` lambda_function.py import json def lambda_handler(event, context): #TODO implement return { 'statusCode': 200, 'body': json.dumps('Hello from Lambda!') ``` Actualmente, Babelfish no es compatible con JSON. Si la función devuelve JSON, debe usar una capa para gestionar el resultado JSON. Por ejemplo, digamos que `lambda_function.py`, como hemos mostrado anteriormente, se almacena en Lambda como `my-function`. 1. Conéctese al clúster de bases de datos de Babelfish con el cliente `psql` (o el cliente pgAdmin). Para obtener más información, consulte [Conexión al clúster de bases de datos mediante psql](babelfish-connect-PostgreSQL.md#babelfish-connect-psql). 1. Cree la capa. En este ejemplo se usa el lenguaje procedimental de PostgreSQL para SQL, `PL/pgSQL`. Para obtener más información, consulte [PL/pgSQL–SQL Procedural Language](https://www.postgresql.org/docs/13/plpgsql.html) (Lenguaje procedimental 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; $$; ``` La función ahora se puede ejecutar desde el puerto TDS de Babelfish (1433) o desde el puerto de PostgreSQL (5433). 1. Para invocar (llamar) esta función desde el puerto de PostgreSQL: ``` SELECT * from aws_lambda.invoke(aws_commons.create_lambda_function_arn('my-function', 'us-east-1'), '{"body": "Hello from Postgres!"}'::json ); ``` El resultado es similar al siguiente: ``` status_code | payload | executed_version | log_result -------------+-------------------------------------------------------+------------------+------------ 200 | {"statusCode": 200, "body": "\"Hello from Lambda!\""} | $LATEST | (1 row) ``` 1. Para invocar (llamar) esta función desde el puerto TDS, conéctese al puerto con el cliente de línea de comandos `sqlcmd` de SQL Server. Para obtener más información, consulte [Uso de un cliente de SQL Server para conectarse al clúster de su base de datos](babelfish-connect-sqlserver.md). Cuando se haya conectado, ejecute lo siguiente: ``` 1> select lambda_wrapper(); 2> go ``` El comando devuelve un resultado similar al siguiente: ``` {"statusCode": 200, "body": "\"Hello from Lambda!\""} ``` Para obtener más información sobre el uso de Lambda con Aurora PostgreSQL, consulte [Invocar una función de AWS Lambda desde un clúster de base de datos de Aurora PostgreSQL ](PostgreSQL-Lambda.md). Para obtener más información acerca de cómo trabajar con las funciones de Lambda, consulte [Introducción a Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) en la *Guía para desarrolladores de AWS Lambda*. ## Uso de pg\$1stat\$1statements en Babelfish Babelfish para Aurora PostgreSQL admite la extensión `pg_stat_statements` desde la versión 3.3.0 Para obtener más información, consulte [pg\$1stat\$1statements](https://www.postgresql.org/docs/current/pgstatstatements.html). Para obtener más información sobre la versión de esta extensión que admite Aurora PostgreSQL, consulte las [versiones de extensiones](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html). ### Creación de la extensión pg\$1stat\$1statements Para activar `pg_stat_statements`, debes activar el cálculo del identificador de consulta. Esto se hace automáticamente si `compute_query_id` está establecido en `on` o `auto` en el grupo de parámetros. El valor predeterminado del parámetro `compute_query_id` es `auto`. También debe crear esta extensión para activar esta función. Utilice el siguiente comando para instalar la extensión desde el punto de conexión de T-SQL: ``` 1>EXEC sp_execute_postgresql 'CREATE EXTENSION pg_stat_statements WITH SCHEMA sys'; ``` Puede acceder a las estadísticas de la consulta de la siguiente forma: ``` postgres=>select * from pg_stat_statements; ``` **nota** Durante la instalación, si no proporciona el nombre de esquema de la extensión, de forma predeterminada, la creará en un esquema público. Para acceder a él, debe usar corchetes con el calificador de esquema, como se muestra a continuación: ``` postgres=>select * from [public].pg_stat_statements; ``` También puede crear la extensión desde el punto de conexión de PSQL. ### Autorización de la extensión De forma predeterminada, puede ver las estadísticas de las consultas realizadas en su base de datos de T-SQL sin necesidad de autorización alguna. Para acceder a las estadísticas de consultas creadas por otros usuarios, debe tener el rol de `pg_read_all_stats` de PostgreSQL. Siga los pasos que se mencionan a continuación para crear el comando GRANT pg\$1read\$1all\$1stats. 1. En T-SQL, utilice la siguiente consulta que devuelve el nombre del rol de PG interno. ``` SELECT rolname FROM pg_roles WHERE oid = USER_ID(); ``` 1. Conéctese a la base de datos Babelfish para Aurora PostgreSQL con privilegios de rds\$1superuser y utilice el siguiente comando: ``` GRANT pg_read_all_stats TO ``` **Ejemplo** Desde el punto de conexión de T-SQL: ``` 1>SELECT rolname FROM pg_roles WHERE oid = USER_ID(); 2>go ``` ``` rolname ------- master_dbo (1 rows affected) ``` Desde el punto de conexión de PSQL: ``` babelfish_db=# grant pg_read_all_stats to master_dbo; ``` ``` GRANT ROLE ``` Puede acceder a las estadísticas de la consulta mediante 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) ``` ### Restablecer las estadísticas de las consultas Puede utilizar `pg_stat_statements_reset()` para restablecer las estadísticas recopiladas hasta ahora por pg\$1stat\$1statements. Para obtener más información, consulte [pg\$1stat\$1statements]( https://www.postgresql.org/docs/current/pgstatstatements.html). Actualmente, solo se admite a través del punto de conexión de PSQL. Conéctese a la base de datos Babelfish para Aurora PostgreSQL con privilegios de `rds_superuser` y utilice el siguiente comando: ``` SELECT pg_stat_statements_reset(); ``` ### Limitaciones + Actualmente, no se admite `pg_stat_statements()` a través del punto de conexión de T-SQL. Se recomienda usar la vista `pg_stat_statements` para recopilar las estadísticas. + Es posible que algunas de las consultas las reescriba el analizador de T-SQL implementado por el motor de Aurora PostgreSQL; la vista `pg_stat_statements` mostrará la consulta reescrita en lugar de la original. Ejemplo ``` select next value for [dbo].[newCounter]; ``` La consulta anterior se reescribe de la siguiente manera en la vista pg\$1stat\$1statements. ``` select nextval($1); ``` + Según el flujo de ejecución de las instrucciones, es posible que pg\$1stat\$1statements no realice el seguimiento de algunas consultas y que no se muestren en la vista. Esta política incluye las siguientes instrucciones: `use dbname`, `goto`, `print`, `raise error`, `set`, `throw`, `declare cursor`. + En las instrucciones CREATE LOGIN y ALTER LOGIN, no se mostrarán los parámetros query ni queryid. Mostrará privilegios insuficientes. + La vista `pg_stat_statements` siempre contiene las dos entradas siguientes, ya que el cliente `sqlcmd` las ejecuta internamente. + DESACTIVAR QUOTED\$1IDENTIFIER + ESTABLECER TEXTSIZE 4096 ## Uso de pgvector en Babelfish pgvector, una extensión de código abierto, le permite buscar datos similares directamente en la base de datos de Postgres. Babelfish ahora admite esta extensión a partir de las versiones 15.6 y 16.2. Para obtener más información, consulte [pgvector Open source Documentation](https://github.com/pgvector/pgvector). ### Requisitos previos Para habilitar la funcionalidad pgvector, instale la extensión en el esquema sys mediante uno de los siguientes métodos: + Ejecute el siguiente comando en el cliente sqlcmd: ``` exec sys.sp_execute_postgresql 'CREATE EXTENSION vector WITH SCHEMA sys'; ``` + Conéctese a `babelfish_db` y ejecute el siguiente comando en el cliente psql: ``` CREATE EXTENSION vector WITH SCHEMA sys; ``` **nota** Tras instalar la extensión pgvector, el tipo de datos vectoriales solo estará disponible en las nuevas conexiones de bases de datos que establezca. Las conexiones existentes no reconocerán el nuevo tipo de datos. ### Funcionalidad admitida Babelfish amplía la funcionalidad de T-SQL para admitir lo siguiente: + **Almacenamiento** Babelfish ahora admite una sintaxis compatible con tipos de datos vectoriales, lo que mejora su compatibilidad con T-SQL. Para obtener más información sobre el almacenamiento de datos con pgvector, consulte [Storing](https://github.com/pgvector/pgvector?tab=readme-ov-file#storing). + **Consultas** Babelfish amplía la compatibilidad de expresiones de T-SQL para incluir operadores de similitud vectorial. Sin embargo, para todas las demás consultas, sigue siendo necesaria la sintaxis T-SQL estándar. **nota** T-SQL no admite el tipo Array y los controladores de base de datos no tienen ninguna interfaz para gestionarlos. Como solución alternativa, Babelfish utiliza cadenas de texto (varchar/nvarchar) para almacenar datos vectoriales. Por ejemplo, cuando solicita un valor vectorial [1,2,3], Babelfish devolverá una cadena “[1,2,3]” como respuesta. Puede analizar y dividir esta cadena en la aplicación según sus necesidades. Para obtener más información sobre la consulta de datos con pgvector, consulte [Querying](https://github.com/pgvector/pgvector?tab=readme-ov-file#querying). + **Indexación** `Create Index` de T-SQL ahora admite la sintaxis `USING INDEX_METHOD`. Ahora puede definir un operador de búsqueda por similitud para usarlo en una columna específica al crear un índice. La gramática también se ha ampliado para admitir las operaciones de similitud vectorial en la columna requerida (consulte la 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 obtener más información sobre la indexación de datos con pgvector, consulte [Indexing](https://github.com/pgvector/pgvector?tab=readme-ov-file#indexing). + **Desempeño** + Utilice `SET BABELFISH_STATISTICS PROFILE ON` para depurar los planes de consultas desde el punto de conexión de T-SQL. + Aumente `max_parallel_workers_get_gather` con la función `set_config` admitida en T-SQL. + Utilice `IVFFlat` para búsquedas aproximadas. Para obtener más información, consulte [IVFFlat](https://github.com/pgvector/pgvector?tab=readme-ov-file#ivfflat). Para mejorar el rendimiento con pgvector, consulte [Performance](https://github.com/pgvector/pgvector?tab=readme-ov-file#performance). ### Limitaciones + Babelfish no admite la búsqueda de texto completo para la búsqueda híbrida. Para obtener más información, consulte [Hybrid Search](https://github.com/pgvector/pgvector?tab=readme-ov-file#hybrid-search). + Babelfish no admite actualmente la función de volver a indexar. Sin embargo, sigue teniendo la posibilidad de utilizar el punto de conexión de PostgreSQL para volver a indexar. Para obtener más información, consulte [Vacuuming](https://github.com/pgvector/pgvector?tab=readme-ov-file#vacuuming). ## Uso de machine learning de Amazon Aurora con Babelfish Puede ampliar las capacidades de su clúster de base de datos de Babelfish para Aurora PostgreSQL integrándolo con machine learning de Amazon Aurora. Esta integración perfecta le otorga acceso a una gama de servicios eficientes como Amazon Comprehend, IA de Amazon SageMaker o Amazon Bedrock, cada uno diseñado para abordar las distintas necesidades de machine learning. Como usuario de Babelfish, puede utilizar los conocimientos existentes sobre la sintaxis y la semántica de T-SQL cuando trabaje con machine learning de Aurora. Siga las instrucciones que se proporcionan en la documentación de AWS de Aurora PostgreSQL. Para obtener más información, consulte [Uso de machine learning de Amazon Aurora con Aurora PostgreSQL](postgresql-ml.md). ### Requisitos previos + Antes de intentar configurar el clúster de base de datos de Babelfish para Aurora PostgreSQL para usar machine learning de Aurora, asegúrese de comprender los siguientes requisitos y requisitos previos relacionados. Para obtener más información, consulte [Requisitos para usar machine learning de Aurora con Aurora PostgreSQL](postgresql-ml.md#postgresql-ml-prereqs). + Asegúrese de instalar la extensión `aws_ml` mediante el punto de conexión de Postgres o el procedimiento de almacenamiento `sp_execute_postgresql`. ``` exec sys.sp_execute_postgresql 'Create Extension aws_ml' ``` **nota** Actualmente, Babelfish no admite operaciones en cascada con `sp_execute_postgresql` en Babelfish. Como `aws_ml` se basa en `aws_commons`, deberá instalarlo por separado mediante el punto de conexión de Postgres. ``` create extension aws_common; ``` ### Tratamiento de la sintaxis y la semántica de T-SQL con funciones `aws_ml` En los siguientes ejemplos se explica cómo se aplican la sintaxis y la semántica de T-SQL a los servicios de Amazon ML: **Example : aws\$1bedrock.invoke\$1model: una consulta sencilla utilizando las funciones de Amazon Bedrock** ``` aws_bedrock.invoke_model( model_id varchar, content_type text, accept_type text, model_input text) Returns Varchar(MAX) ``` El siguiente ejemplo muestra cómo invocar un modelo de Anthropic Claude 2 para Bedrock mediante 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 consulta sencilla utilizando las funciones de Amazon Comprehend** ``` aws_comprehend.detect_sentiment( input_text varchar, language_code varchar, max_rows_per_batch int) Returns table (sentiment varchar, confidence real) ``` En el siguiente ejemplo se muestra cómo invocar el servicio de Amazon Comprehend. ``` select sentiment from aws_comprehend.detect_sentiment('This is great', 'en'); ``` **Example : aws\$1sagemaker.invoke\$1endpoint: una consulta sencilla utilizando las funciones de 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) ``` Puesto que model\$1input está marcado como VARIADIC y es del tipo “any”, los usuarios pueden pasar una lista de cualquier longitud y tipo de datos a la función, que actuará como entrada o entrada para el modelo. En el siguiente ejemplo se muestra cómo invocar el servicio de 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 obtener información detallada sobre el uso de machine learning de Aurora con Aurora PostgreSQL, consulte [Uso de machine learning de Amazon Aurora con Aurora PostgreSQL](postgresql-ml.md). ### Limitaciones + Aunque Babelfish no permite la creación de matrices, sí puede tratar datos que representen matrices. Cuando se utilizan funciones como `aws_bedrock.invoke_model_get_embeddings` que devuelven matrices, los resultados se entregan como una cadena que contiene los elementos de la matriz.