Light, fluffy, and always free - The AWS Local Emulator alternative
feat(rds-data): adding data-api support for lable/name and batch (#2518)
Anders Wasena3044e065e26
diff --git a/compatibility-tests/sdk-test-go/tests/rds_data_test.go b/compatibility-tests/sdk-test-go/tests/rds_data_test.goindex 3b6995872d..435502bdd1 100644--- a/compatibility-tests/sdk-test-go/tests/rds_data_test.go+++ b/compatibility-tests/sdk-test-go/tests/rds_data_test.go@@ -168,6 +168,10 @@ func TestRdsDataApiGoSdkV1(t *testing.T) {require.NoError(t, err)require.Len(t, selectOut.ColumnMetadata, 12)assert.Equal(t, "title", awsV1.StringValue(selectOut.ColumnMetadata[0].Name))+ assert.Equal(t, "title", awsV1.StringValue(selectOut.ColumnMetadata[0].Label))+ assert.NotEmpty(t, awsV1.StringValue(selectOut.ColumnMetadata[0].TypeName))+ assert.Equal(t, "nothing", awsV1.StringValue(selectOut.ColumnMetadata[3].Label))+ assert.Equal(t, "data_api_items", awsV1.StringValue(selectOut.ColumnMetadata[1].TableName))require.Len(t, selectOut.Records, 1)require.Len(t, selectOut.Records[0], 12)assert.Equal(t, "first item", awsV1.StringValue(selectOut.Records[0][0].StringValue))@@ -334,13 +338,74 @@ func TestRdsDataApiGoSdkV1(t *testing.T) {assert.Equal(t, "count", awsV1.StringValue(countOut.ColumnMetadata[0].Name))assert.Equal(t, int64(1), awsV1.Int64Value(countOut.Records[0][0].LongValue))+ batchOut, err := dataSvc.BatchExecuteStatement(&rdsdataservice.BatchExecuteStatementInput{+ ResourceArn: awsV1.String(resourceArn),+ SecretArn: awsV1.String(secretArn),+ Database: awsV1.String(database),+ Sql: awsV1.String("insert into data_api_items (id, title, score) values (:id, :title, :score)"),+ ParameterSets: [][]*rdsdataservice.SqlParameter{+ {+ {Name: awsV1.String("id"), Value: &rdsdataservice.Field{StringValue: awsV1.String("batch-1")}},+ {Name: awsV1.String("title"), Value: &rdsdataservice.Field{StringValue: awsV1.String("batch one")}},+ {Name: awsV1.String("score"), Value: &rdsdataservice.Field{LongValue: awsV1.Int64(1)}},+ },+ {+ {Name: awsV1.String("id"), Value: &rdsdataservice.Field{StringValue: awsV1.String("batch-2")}},+ {Name: awsV1.String("title"), Value: &rdsdataservice.Field{StringValue: awsV1.String("batch two")}},+ {Name: awsV1.String("score"), Value: &rdsdataservice.Field{LongValue: awsV1.Int64(2)}},+ },+ },+ })+ require.NoError(t, err)+ require.Len(t, batchOut.UpdateResults, 2)+ assert.Empty(t, batchOut.UpdateResults[0].GeneratedFields)++ batchCountOut, err := dataSvc.ExecuteStatement(&rdsdataservice.ExecuteStatementInput{+ ResourceArn: awsV1.String(resourceArn),+ SecretArn: awsV1.String(secretArn),+ Database: awsV1.String(database),+ Sql: awsV1.String("select count(*) as count from data_api_items where id in ('batch-1', 'batch-2')"),+ })+ require.NoError(t, err)+ assert.Equal(t, int64(2), awsV1.Int64Value(batchCountOut.Records[0][0].LongValue))+_, err = dataSvc.BatchExecuteStatement(&rdsdataservice.BatchExecuteStatementInput{ResourceArn: awsV1.String(resourceArn),SecretArn: awsV1.String(secretArn),Database: awsV1.String(database),- Sql: awsV1.String("insert into data_api_items (id, title, score) values ('batch-1', 'batch', 1)"),+ Sql: awsV1.String("select id from data_api_items where score = :score"),+ ParameterSets: [][]*rdsdataservice.SqlParameter{+ {{Name: awsV1.String("score"), Value: &rdsdataservice.Field{LongValue: awsV1.Int64(1)}}},+ {{Name: awsV1.String("score"), Value: &rdsdataservice.Field{LongValue: awsV1.Int64(2)}}},+ },+ })+ assertAwsErrorCode(t, err, "BadRequestException")++ noSetsOut, err := dataSvc.BatchExecuteStatement(&rdsdataservice.BatchExecuteStatementInput{+ ResourceArn: awsV1.String(resourceArn),+ SecretArn: awsV1.String(secretArn),+ Database: awsV1.String(database),+ Sql: awsV1.String("insert into data_api_items (id, title, score) values ('batch-no-sets', 'no sets', 99)"),+ })+ require.NoError(t, err)+ assert.Empty(t, noSetsOut.UpdateResults)++ noSetsCountOut, err := dataSvc.ExecuteStatement(&rdsdataservice.ExecuteStatementInput{+ ResourceArn: awsV1.String(resourceArn),+ SecretArn: awsV1.String(secretArn),+ Database: awsV1.String(database),+ Sql: awsV1.String("select count(*) as count from data_api_items where id = 'batch-no-sets'"),+ })+ require.NoError(t, err)+ assert.Equal(t, int64(0), awsV1.Int64Value(noSetsCountOut.Records[0][0].LongValue))++ _, err = dataSvc.BatchExecuteStatement(&rdsdataservice.BatchExecuteStatementInput{+ ResourceArn: awsV1.String(resourceArn),+ SecretArn: awsV1.String(secretArn),+ Database: awsV1.String(database),+ Sql: awsV1.String("insert into data_api_items (id, title, score) values (:id, :title, :score)"),+ ParameterSets: [][]*rdsdataservice.SqlParameter{{{Name: awsV1.String("id")}}},})- require.Error(t, err)assertAwsErrorCode(t, err, "BadRequestException")_, err = dataSvc.ExecuteSql(&rdsdataservice.ExecuteSqlInput{@@ -542,6 +607,10 @@ func TestRdsDataApiGoSdkPostgresV1(t *testing.T) {require.NoError(t, err)require.Len(t, selectOut.ColumnMetadata, 12)assert.Equal(t, "title", awsV1.StringValue(selectOut.ColumnMetadata[0].Name))+ assert.Equal(t, "title", awsV1.StringValue(selectOut.ColumnMetadata[0].Label))+ assert.NotEmpty(t, awsV1.StringValue(selectOut.ColumnMetadata[0].TypeName))+ assert.Equal(t, "nothing", awsV1.StringValue(selectOut.ColumnMetadata[3].Label))+ assert.Equal(t, "data_api_items", awsV1.StringValue(selectOut.ColumnMetadata[1].TableName))require.Len(t, selectOut.Records, 1)require.Len(t, selectOut.Records[0], 12)assert.Equal(t, "first item", awsV1.StringValue(selectOut.Records[0][0].StringValue))@@ -709,13 +778,74 @@ func TestRdsDataApiGoSdkPostgresV1(t *testing.T) {assert.Equal(t, "count", awsV1.StringValue(countOut.ColumnMetadata[0].Name))assert.Equal(t, int64(1), awsV1.Int64Value(countOut.Records[0][0].LongValue))+ batchOut, err := dataSvc.BatchExecuteStatement(&rdsdataservice.BatchExecuteStatementInput{+ ResourceArn: awsV1.String(resourceArn),+ SecretArn: awsV1.String(secretArn),+ Database: awsV1.String(database),+ Sql: awsV1.String("insert into data_api_items (id, title, score) values (:id, :title, :score)"),+ ParameterSets: [][]*rdsdataservice.SqlParameter{+ {+ {Name: awsV1.String("id"), Value: &rdsdataservice.Field{StringValue: awsV1.String("batch-1")}},+ {Name: awsV1.String("title"), Value: &rdsdataservice.Field{StringValue: awsV1.String("batch one")}},+ {Name: awsV1.String("score"), Value: &rdsdataservice.Field{LongValue: awsV1.Int64(1)}},+ },+ {+ {Name: awsV1.String("id"), Value: &rdsdataservice.Field{StringValue: awsV1.String("batch-2")}},+ {Name: awsV1.String("title"), Value: &rdsdataservice.Field{StringValue: awsV1.String("batch two")}},+ {Name: awsV1.String("score"), Value: &rdsdataservice.Field{LongValue: awsV1.Int64(2)}},+ },+ },+ })+ require.NoError(t, err)+ require.Len(t, batchOut.UpdateResults, 2)+ assert.Empty(t, batchOut.UpdateResults[0].GeneratedFields)++ batchCountOut, err := dataSvc.ExecuteStatement(&rdsdataservice.ExecuteStatementInput{+ ResourceArn: awsV1.String(resourceArn),+ SecretArn: awsV1.String(secretArn),+ Database: awsV1.String(database),+ Sql: awsV1.String("select count(*) as count from data_api_items where id in ('batch-1', 'batch-2')"),+ })+ require.NoError(t, err)+ assert.Equal(t, int64(2), awsV1.Int64Value(batchCountOut.Records[0][0].LongValue))+_, err = dataSvc.BatchExecuteStatement(&rdsdataservice.BatchExecuteStatementInput{ResourceArn: awsV1.String(resourceArn),SecretArn: awsV1.String(secretArn),Database: awsV1.String(database),- Sql: awsV1.String("insert into data_api_items (id, title, score) values ('batch-1', 'batch', 1)"),+ Sql: awsV1.String("select id from data_api_items where score = :score"),+ ParameterSets: [][]*rdsdataservice.SqlParameter{+ {{Name: awsV1.String("score"), Value: &rdsdataservice.Field{LongValue: awsV1.Int64(1)}}},+ {{Name: awsV1.String("score"), Value: &rdsdataservice.Field{LongValue: awsV1.Int64(2)}}},+ },+ })+ assertAwsErrorCode(t, err, "BadRequestException")++ noSetsOut, err := dataSvc.BatchExecuteStatement(&rdsdataservice.BatchExecuteStatementInput{+ ResourceArn: awsV1.String(resourceArn),+ SecretArn: awsV1.String(secretArn),+ Database: awsV1.String(database),+ Sql: awsV1.String("insert into data_api_items (id, title, score) values ('batch-no-sets', 'no sets', 99)"),+ })+ require.NoError(t, err)+ assert.Empty(t, noSetsOut.UpdateResults)++ noSetsCountOut, err := dataSvc.ExecuteStatement(&rdsdataservice.ExecuteStatementInput{+ ResourceArn: awsV1.String(resourceArn),+ SecretArn: awsV1.String(secretArn),+ Database: awsV1.String(database),+ Sql: awsV1.String("select count(*) as count from data_api_items where id = 'batch-no-sets'"),+ })+ require.NoError(t, err)+ assert.Equal(t, int64(0), awsV1.Int64Value(noSetsCountOut.Records[0][0].LongValue))++ _, err = dataSvc.BatchExecuteStatement(&rdsdataservice.BatchExecuteStatementInput{+ ResourceArn: awsV1.String(resourceArn),+ SecretArn: awsV1.String(secretArn),+ Database: awsV1.String(database),+ Sql: awsV1.String("insert into data_api_items (id, title, score) values (:id, :title, :score)"),+ ParameterSets: [][]*rdsdataservice.SqlParameter{{{Name: awsV1.String("id")}}},})- require.Error(t, err)assertAwsErrorCode(t, err, "BadRequestException")_, err = dataSvc.ExecuteSql(&rdsdataservice.ExecuteSqlInput{@@ -888,6 +1018,9 @@ func TestRdsDataApiGoSdkV2(t *testing.T) {require.NoError(t, err)require.Len(t, selectOut.ColumnMetadata, 5)assert.Equal(t, "name", awsV2.ToString(selectOut.ColumnMetadata[0].Name))+ assert.Equal(t, "name", awsV2.ToString(selectOut.ColumnMetadata[0].Label))+ assert.NotEmpty(t, awsV2.ToString(selectOut.ColumnMetadata[0].TypeName))+ assert.Equal(t, "data_api_v2_items", awsV2.ToString(selectOut.ColumnMetadata[0].TableName))require.Len(t, selectOut.Records, 1)assert.Equal(t, "second client", fieldStringValue(t, selectOut.Records[0][0]))assert.Equal(t, int64(12), fieldLongValue(t, selectOut.Records[0][1]))@@ -954,6 +1087,66 @@ func TestRdsDataApiGoSdkV2(t *testing.T) {assert.Equal(t, "parameterized", fieldStringValue(t, paramOut.Records[0][0]))assert.Equal(t, int64(42), fieldLongValue(t, paramOut.Records[0][1]))+ batchOut, err := dataSvc.BatchExecuteStatement(ctx, &rdsdata.BatchExecuteStatementInput{+ ResourceArn: awsV2.String(resourceArn),+ SecretArn: awsV2.String(secretArn),+ Database: awsV2.String(database),+ Sql: awsV2.String("insert into data_api_v2_items (id, name, qty) values (:id, :name, :qty)"),+ ParameterSets: [][]rdsdatatypes.SqlParameter{+ {+ {Name: awsV2.String("id"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "v2-batch-1"}},+ {Name: awsV2.String("name"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "batch one"}},+ {Name: awsV2.String("qty"), Value: &rdsdatatypes.FieldMemberLongValue{Value: 1}},+ },+ {+ {Name: awsV2.String("id"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "v2-batch-2"}},+ {Name: awsV2.String("name"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "batch two"}},+ {Name: awsV2.String("qty"), Value: &rdsdatatypes.FieldMemberLongValue{Value: 2}},+ },+ },+ })+ require.NoError(t, err)+ require.Len(t, batchOut.UpdateResults, 2)++ batchCountOut, err := dataSvc.ExecuteStatement(ctx, &rdsdata.ExecuteStatementInput{+ ResourceArn: awsV2.String(resourceArn),+ SecretArn: awsV2.String(secretArn),+ Database: awsV2.String(database),+ Sql: awsV2.String("select count(*) as count from data_api_v2_items where id in ('v2-batch-1', 'v2-batch-2')"),+ })+ require.NoError(t, err)+ assert.Equal(t, int64(2), fieldLongValue(t, batchCountOut.Records[0][0]))++ _, err = dataSvc.BatchExecuteStatement(ctx, &rdsdata.BatchExecuteStatementInput{+ ResourceArn: awsV2.String(resourceArn),+ SecretArn: awsV2.String(secretArn),+ Database: awsV2.String(database),+ Sql: awsV2.String("select id from data_api_v2_items where qty = :qty"),+ ParameterSets: [][]rdsdatatypes.SqlParameter{+ {{Name: awsV2.String("qty"), Value: &rdsdatatypes.FieldMemberLongValue{Value: 1}}},+ {{Name: awsV2.String("qty"), Value: &rdsdatatypes.FieldMemberLongValue{Value: 2}}},+ },+ })+ assertSmithyErrorCode(t, err, "BadRequestException")++ noSetsOut, err := dataSvc.BatchExecuteStatement(ctx, &rdsdata.BatchExecuteStatementInput{+ ResourceArn: awsV2.String(resourceArn),+ SecretArn: awsV2.String(secretArn),+ Database: awsV2.String(database),+ Sql: awsV2.String("insert into data_api_v2_items (id, name, qty) values ('v2-batch-no-sets', 'no sets', 99)"),+ })+ require.NoError(t, err)+ assert.Empty(t, noSetsOut.UpdateResults)++ noSetsCountOut, err := dataSvc.ExecuteStatement(ctx, &rdsdata.ExecuteStatementInput{+ ResourceArn: awsV2.String(resourceArn),+ SecretArn: awsV2.String(secretArn),+ Database: awsV2.String(database),+ Sql: awsV2.String("select count(*) as count from data_api_v2_items where id = 'v2-batch-no-sets'"),+ })+ require.NoError(t, err)+ assert.Equal(t, int64(0), fieldLongValue(t, noSetsCountOut.Records[0][0]))+_, err = dataSvc.ExecuteSql(ctx, &rdsdata.ExecuteSqlInput{DbClusterOrInstanceArn: awsV2.String(resourceArn),AwsSecretStoreArn: awsV2.String(secretArn),@@ -1078,6 +1271,9 @@ func TestRdsDataApiGoSdkPostgresV2(t *testing.T) {require.NoError(t, err)require.Len(t, selectOut.ColumnMetadata, 5)assert.Equal(t, "name", awsV2.ToString(selectOut.ColumnMetadata[0].Name))+ assert.Equal(t, "name", awsV2.ToString(selectOut.ColumnMetadata[0].Label))+ assert.NotEmpty(t, awsV2.ToString(selectOut.ColumnMetadata[0].TypeName))+ assert.Equal(t, "data_api_v2_items", awsV2.ToString(selectOut.ColumnMetadata[0].TableName))require.Len(t, selectOut.Records, 1)assert.Equal(t, "second client", fieldStringValue(t, selectOut.Records[0][0]))assert.Equal(t, int64(12), fieldLongValue(t, selectOut.Records[0][1]))@@ -1144,6 +1340,66 @@ func TestRdsDataApiGoSdkPostgresV2(t *testing.T) {assert.Equal(t, "parameterized", fieldStringValue(t, paramOut.Records[0][0]))assert.Equal(t, int64(42), fieldLongValue(t, paramOut.Records[0][1]))+ batchOut, err := dataSvc.BatchExecuteStatement(ctx, &rdsdata.BatchExecuteStatementInput{+ ResourceArn: awsV2.String(resourceArn),+ SecretArn: awsV2.String(secretArn),+ Database: awsV2.String(database),+ Sql: awsV2.String("insert into data_api_v2_items (id, name, qty) values (:id, :name, :qty)"),+ ParameterSets: [][]rdsdatatypes.SqlParameter{+ {+ {Name: awsV2.String("id"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "v2-batch-1"}},+ {Name: awsV2.String("name"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "batch one"}},+ {Name: awsV2.String("qty"), Value: &rdsdatatypes.FieldMemberLongValue{Value: 1}},+ },+ {+ {Name: awsV2.String("id"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "v2-batch-2"}},+ {Name: awsV2.String("name"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "batch two"}},+ {Name: awsV2.String("qty"), Value: &rdsdatatypes.FieldMemberLongValue{Value: 2}},+ },+ },+ })+ require.NoError(t, err)+ require.Len(t, batchOut.UpdateResults, 2)++ batchCountOut, err := dataSvc.ExecuteStatement(ctx, &rdsdata.ExecuteStatementInput{+ ResourceArn: awsV2.String(resourceArn),+ SecretArn: awsV2.String(secretArn),+ Database: awsV2.String(database),+ Sql: awsV2.String("select count(*) as count from data_api_v2_items where id in ('v2-batch-1', 'v2-batch-2')"),+ })+ require.NoError(t, err)+ assert.Equal(t, int64(2), fieldLongValue(t, batchCountOut.Records[0][0]))++ _, err = dataSvc.BatchExecuteStatement(ctx, &rdsdata.BatchExecuteStatementInput{+ ResourceArn: awsV2.String(resourceArn),+ SecretArn: awsV2.String(secretArn),+ Database: awsV2.String(database),+ Sql: awsV2.String("select id from data_api_v2_items where qty = :qty"),+ ParameterSets: [][]rdsdatatypes.SqlParameter{+ {{Name: awsV2.String("qty"), Value: &rdsdatatypes.FieldMemberLongValue{Value: 1}}},+ {{Name: awsV2.String("qty"), Value: &rdsdatatypes.FieldMemberLongValue{Value: 2}}},+ },+ })+ assertSmithyErrorCode(t, err, "BadRequestException")++ noSetsOut, err := dataSvc.BatchExecuteStatement(ctx, &rdsdata.BatchExecuteStatementInput{+ ResourceArn: awsV2.String(resourceArn),+ SecretArn: awsV2.String(secretArn),+ Database: awsV2.String(database),+ Sql: awsV2.String("insert into data_api_v2_items (id, name, qty) values ('v2-batch-no-sets', 'no sets', 99)"),+ })+ require.NoError(t, err)+ assert.Empty(t, noSetsOut.UpdateResults)++ noSetsCountOut, err := dataSvc.ExecuteStatement(ctx, &rdsdata.ExecuteStatementInput{+ ResourceArn: awsV2.String(resourceArn),+ SecretArn: awsV2.String(secretArn),+ Database: awsV2.String(database),+ Sql: awsV2.String("select count(*) as count from data_api_v2_items where id = 'v2-batch-no-sets'"),+ })+ require.NoError(t, err)+ assert.Equal(t, int64(0), fieldLongValue(t, noSetsCountOut.Records[0][0]))+_, err = dataSvc.ExecuteSql(ctx, &rdsdata.ExecuteSqlInput{DbClusterOrInstanceArn: awsV2.String(resourceArn),AwsSecretStoreArn: awsV2.String(secretArn),diff --git a/docs/services/rds-data.md b/docs/services/rds-data.mdindex cd8bda9874..32ca91a6cf 100644--- a/docs/services/rds-data.md+++ b/docs/services/rds-data.md@@ -24,8 +24,9 @@ For the upstream API shape, see the AWS RDS Data API documentation:| `BeginTransaction` | `POST /BeginTransaction` | `resourceArn`, `secretArn` | Open a JDBC transaction and return a transaction ID || `CommitTransaction` | `POST /CommitTransaction` | `resourceArn`, `secretArn`, `transactionId` | Commit an open transaction || `RollbackTransaction` | `POST /RollbackTransaction` | `resourceArn`, `secretArn`, `transactionId` | Roll back an open transaction |+| `BatchExecuteStatement` | `POST /BatchExecute` | `resourceArn`, `secretArn`, `sql` | Run one SQL statement once per entry in `parameterSets` |-`BatchExecuteStatement` is recognized at `POST /BatchExecute` and returns an AWS-style `BadRequestException` because batch execution is not implemented yet. The deprecated `ExecuteSql` operation is also recognized at `POST /ExecuteSql` and returns an AWS-style `BadRequestException`.+The deprecated `ExecuteSql` operation is recognized at `POST /ExecuteSql` and returns an AWS-style `BadRequestException`.## Compatibility Notes@@ -35,9 +36,12 @@ For the upstream API shape, see the AWS RDS Data API documentation:- MySQL, MariaDB, and PostgreSQL resources are supported. Aurora PostgreSQL resources resolve to the same PostgreSQL execution path.- SQL is sent directly to the local database engine through JDBC. `SqlParameter` binding is supported for all engines: named `:placeholder` markers are rewritten to positional JDBC bind parameters and executed through a `PreparedStatement`. Colons inside string literals, quoted/backtick identifiers, comments, PostgreSQL `::` casts, and PostgreSQL dollar-quoted strings are left untouched. A placeholder used more than once binds its value at each position. Supported value variants are `stringValue`, `booleanValue`, `longValue`, `doubleValue`, `blobValue`, and `isNull`; `typeHint` values `DECIMAL`, `TIMESTAMP`, `DATE`, `TIME`, `UUID`, and `JSON` are honored. `arrayValue` parameters are not supported yet and return `BadRequestException`, as do malformed `parameters` payloads (not a JSON array, or an entry missing `name`).- Result records include Data API field variants such as `stringValue`, `longValue`, `blobValue`, `booleanValue`, `doubleValue`, and `isNull`.+- `includeResultMetadata` returns the full AWS `ColumnMetadata` shape per column: `label`, `name`, `type`, `typeName`, `tableName`, `schemaName`, `nullable`, `precision`, `scale`, `isSigned`, `isCaseSensitive`, `isCurrency`, `isAutoIncrement`, and `arrayBaseColumnType`. `label` is the result-set label (the alias when the query aliases a column) and `name` is the underlying column name, falling back to the label for computed columns — clients that hydrate rows by `label` need it present. `type` is a JDBC type code and `typeName` is the engine's own type name (for example `4` and `int4` for a PostgreSQL integer), both taken from the driver so they match the engine actually serving the query. `arrayBaseColumnType` is always `0` because array columns are not mapped to `arrayValue` fields yet.+- `ExecuteStatement` returns `generatedFields` for statements that report an update count on MySQL and MariaDB, carrying the auto-increment keys the engine generated. As on Aurora PostgreSQL, PostgreSQL resources always return an empty list — use a `RETURNING` clause to read generated values. `generatedFields` is omitted for statements that return a result set.+- `BatchExecuteStatement` runs the statement once per entry in `parameterSets` through a JDBC batch and returns one `updateResults` entry per set, each carrying the `generatedFields` that set produced under the same engine rules as `ExecuteStatement` — a set inserting several rows reports one field per generated key. On MySQL and MariaDB the sets are executed one at a time so each entry owns its own keys, because `getGeneratedKeys()` after a JDBC batch reports every key the batch generated with nothing tying a key back to the set that produced it. It accepts `transactionId`, so a batch can take part in a Data API transaction; without one the batch commits automatically. An absent or empty `parameterSets` runs nothing and returns an empty `updateResults`: AWS runs the statement once per parameter set provided and points a caller who wants a single parameterless execution at one empty set (`[[]]`, which runs once here) or at `ExecuteStatement`. A statement that returns rows rather than an update count — a `SELECT`, or a CTE ending in one — is rejected with `BadRequestException` before any set runs, because a batch reports one `UpdateResult` per set and has nowhere to carry a result set, and AWS documents the operation as taking a DML statement. The check reads the driver's description of the prepared statement, so nothing executes first, and a DML statement that also reports rows through a PostgreSQL `RETURNING` clause is left alone: the batch still performs its writes, and `generatedFields` is empty on PostgreSQL anyway.- SQL errors are returned as `DatabaseErrorException` so AWS SDK callers can handle database failures with normal AWS error decoding.- If `secretArn` points to a local Secrets Manager secret with JSON credentials (`username` or `user`, plus `password`), those credentials are used. If the secret is missing or cannot be parsed, Floci falls back to the resolved RDS resource's master credentials for local development convenience.-- `formatRecordsAs=JSON`, `formattedRecords`, `generatedFields`, and `resultSetOptions` are not implemented yet. Requests that require those unsupported result modes return `BadRequestException`.+- `formatRecordsAs=JSON`, `formattedRecords`, and `resultSetOptions` are not implemented yet, and `ExecuteStatement` requests asking for those result modes return `BadRequestException`. They are `ExecuteStatement`-only fields in the AWS API, so `BatchExecuteStatement` — whose input is limited to `resourceArn`, `secretArn`, `sql`, `database`, `schema`, `parameterSets`, and `transactionId` — ignores them as AWS does rather than rejecting them.- RDS `HttpEndpointEnabled` control-plane gating is not modeled locally; availability is controlled by `FLOCI_SERVICES_RDS_DATA_ENABLED` and whether the target local RDS resource is running.## Configuration@@ -82,4 +86,15 @@ aws rds-data execute-statement \--sql "select 1 as count" \--include-result-metadata \--endpoint-url "$AWS_ENDPOINT_URL"++aws rds-data batch-execute-statement \+ --resource-arn "$RESOURCE_ARN" \+ --secret-arn "$SECRET_ARN" \+ --database app \+ --sql "insert into items (id, title) values (:id, :title)" \+ --parameter-sets '[+ [{"name":"id","value":{"longValue":1}},{"name":"title","value":{"stringValue":"first"}}],+ [{"name":"id","value":{"longValue":2}},{"name":"title","value":{"stringValue":"second"}}]+ ]' \+ --endpoint-url "$AWS_ENDPOINT_URL"```diff --git a/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataColumnMetadata.java b/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataColumnMetadata.javanew file mode 100644index 0000000000..58d28826c1--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataColumnMetadata.java@@ -0,0 +1,71 @@+package io.github.hectorvent.floci.services.rdsdata;++import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;++import java.sql.ResultSetMetaData;+import java.sql.SQLException;++/**+ * Maps JDBC {@link ResultSetMetaData} onto the AWS RDS Data API+ * {@code ColumnMetadata} shape.+ *+ * <p>Every documented field is emitted for each column. {@code label} matters+ * as much as {@code name}: AWS clients commonly hydrate rows by the result-set+ * label, so a response carrying only {@code name} collapses every row to a+ * single key.+ *+ * <p>{@code type} is a {@link java.sql.Types} code and {@code typeName} is the+ * engine's own type name, exactly as AWS reports them (for example {@code 4}+ * and {@code int4} for a PostgreSQL integer). {@code arrayBaseColumnType} is+ * always {@code 0} because array columns are not mapped to {@code arrayValue}+ * fields yet.+ */+final class RdsDataColumnMetadata {++ private RdsDataColumnMetadata() {+ }++ static ArrayNode toColumnMetadata(ObjectMapper objectMapper, ResultSetMetaData meta) throws SQLException {+ ArrayNode columns = objectMapper.createArrayNode();+ for (int index = 1; index <= meta.getColumnCount(); index++) {+ columns.add(toColumn(objectMapper, meta, index));+ }+ return columns;+ }++ private static ObjectNode toColumn(ObjectMapper objectMapper, ResultSetMetaData meta, int index)+ throws SQLException {+ String name = meta.getColumnName(index);+ String label = meta.getColumnLabel(index);++ ObjectNode column = objectMapper.createObjectNode();+ column.put("arrayBaseColumnType", 0);+ column.put("isAutoIncrement", meta.isAutoIncrement(index));+ column.put("isCaseSensitive", meta.isCaseSensitive(index));+ column.put("isCurrency", meta.isCurrency(index));+ column.put("isSigned", meta.isSigned(index));+ column.put("label", firstNonBlank(label, name));+ column.put("name", firstNonBlank(name, label));+ column.put("nullable", meta.isNullable(index));+ column.put("precision", meta.getPrecision(index));+ column.put("scale", meta.getScale(index));+ column.put("schemaName", orEmpty(meta.getSchemaName(index)));+ column.put("tableName", orEmpty(meta.getTableName(index)));+ column.put("type", meta.getColumnType(index));+ column.put("typeName", orEmpty(meta.getColumnTypeName(index)));+ return column;+ }++ private static String firstNonBlank(String preferred, String fallback) {+ if (preferred != null && !preferred.isBlank()) {+ return preferred;+ }+ return orEmpty(fallback);+ }++ private static String orEmpty(String value) {+ return value == null ? "" : value;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataController.java b/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataController.javaindex e064c0b1fb..b2a8cf5620 100644--- a/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataController.java+++ b/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataController.java@@ -56,9 +56,9 @@ public class RdsDataController {@POST@Path("/BatchExecute")- public Response batchExecuteStatement() {- return error(400, "BadRequestException",- "BatchExecuteStatement is not supported by this local RDS Data API implementation.");+ public Response batchExecuteStatement(@Context HttpHeaders headers, String body) {+ return handle(headers, body, (request, region) ->+ Response.ok(service.batchExecuteStatement(request, region)).build());}@POSTdiff --git a/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataService.java b/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataService.javaindex c0a4dd39a1..55c6e648b6 100644--- a/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataService.java+++ b/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataService.java@@ -24,8 +24,12 @@ import java.sql.SQLException;import java.sql.Statement;import java.time.Duration;import java.time.Instant;+import java.util.ArrayList;import java.util.LinkedHashMap;+import java.util.List;+import java.util.Locale;import java.util.Map;+import java.util.Set;import java.util.UUID;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ConcurrentMap;@@ -38,6 +42,9 @@ public class RdsDataService implements Resettable {private static final Logger LOG = Logger.getLogger(RdsDataService.class);+ /** Statement keywords whose result is a write, even when a {@code RETURNING} clause also reports rows. */+ private static final Set<String> DML_KEYWORDS = Set.of("insert", "update", "delete", "merge", "replace");+private final RdsDataResourceResolver resourceResolver;private final SecretsManagerService secretsManagerService;private final ObjectMapper objectMapper;@@ -109,30 +116,24 @@ public class RdsDataService implements Resettable {rejectUnsupportedOptions(request);String sql = requiredText(request, "sql");- String resourceArn = requiredText(request, "resourceArn");- requiredText(request, "secretArn");Map<String, JsonNode> parameters = parseParameters(request);- String transactionId = textOrNull(request, "transactionId");boolean includeMetadata = request.path("includeResultMetadata").asBoolean(false);try {- if (transactionId != null && !transactionId.isBlank()) {- TransactionContext tx = transaction(transactionId);- synchronized (tx) {- requireActiveTransaction(transactionId, tx);- validateTransactionIdentity(tx, request, region);- tx.refresh(transactionTtl);- return executeOnConnection(tx.connection, tx.engine, sql, parameters, includeMetadata);- }- }+ return onTargetConnection(request, region, (connection, engine) ->+ executeOnConnection(connection, engine, sql, parameters, includeMetadata));+ } catch (SQLException e) {+ throw databaseError(e);+ }+ }- RdsDataResourceResolver.DatabaseTarget target =- resourceResolver.resolve(resourceArn, region);- Credentials credentials = credentials(request, target, region);- String database = databaseName(request, target);- try (Connection connection = connectionFactory.open(target, credentials.username(), credentials.password(), database)) {- return executeOnConnection(connection, target.engine(), sql, parameters, includeMetadata);- }+ public ObjectNode batchExecuteStatement(JsonNode request, String region) {+ String sql = requiredText(request, "sql");+ List<Map<String, JsonNode>> parameterSets = parseParameterSets(request);++ try {+ return onTargetConnection(request, region, (connection, engine) ->+ batchOnConnection(connection, engine, sql, parameterSets));} catch (SQLException e) {throw databaseError(e);}@@ -214,14 +215,187 @@ public class RdsDataService implements Resettable {return response;}+ private ObjectNode onTargetConnection(JsonNode request, String region, ConnectionWork work)+ throws SQLException {+ String resourceArn = requiredText(request, "resourceArn");+ requiredText(request, "secretArn");+ String transactionId = textOrNull(request, "transactionId");++ if (transactionId != null && !transactionId.isBlank()) {+ TransactionContext tx = transaction(transactionId);+ synchronized (tx) {+ requireActiveTransaction(transactionId, tx);+ validateTransactionIdentity(tx, request, region);+ tx.refresh(transactionTtl);+ return work.execute(tx.connection, tx.engine);+ }+ }++ RdsDataResourceResolver.DatabaseTarget target =+ resourceResolver.resolve(resourceArn, region);+ Credentials credentials = credentials(request, target, region);+ String database = databaseName(request, target);+ try (Connection connection = connectionFactory.open(target, credentials.username(), credentials.password(), database)) {+ return work.execute(connection, target.engine());+ }+ }+private ObjectNode executeOnConnection(Connection connection, DatabaseEngine engine, String sql,Map<String, JsonNode> parameters, boolean includeMetadata)throws SQLException {RdsDataSqlParameters.ParsedSql parsed = RdsDataSqlParameters.parse(sql, usesBackslashEscapes(engine));- try (PreparedStatement statement = connection.prepareStatement(parsed.sql())) {+ try (PreparedStatement statement = prepare(connection, engine, parsed.sql())) {RdsDataSqlParameters.bind(statement, parsed.parameterOrder(), parameters);- return buildResponse(statement, statement.execute(), includeMetadata);+ return buildResponse(statement, statement.execute(), includeMetadata, engine);+ }+ }++ /**+ * Runs {@code sql} once per parameter set and reports one+ * {@code updateResults} entry per set.+ *+ * <p>No parameter sets runs nothing. AWS executes the statement "as many+ * times as the number of parameter sets provided" and points a caller who+ * wants a single parameterless execution at one empty set ({@code [[]]}) or+ * at {@code ExecuteStatement}, so an absent or empty {@code parameterSets}+ * must not reach the database.+ *+ * <p>Engines that report generated keys execute a set at a time so each+ * entry carries the keys that set produced: {@code getGeneratedKeys()}+ * after {@code executeBatch()} flattens every row the whole batch generated+ * with nothing tying a row back to the set that made it, so a set inserting+ * more or fewer than one row would shift the keys onto the wrong entries.+ * PostgreSQL reports no generated keys, so it keeps the batched round trip.+ */+ private ObjectNode batchOnConnection(Connection connection, DatabaseEngine engine, String sql,+ List<Map<String, JsonNode>> parameterSets)+ throws SQLException {+ ArrayNode updateResults = objectMapper.createArrayNode();+ if (parameterSets.isEmpty()) {+ return batchResponse(updateResults);+ }+ RdsDataSqlParameters.ParsedSql parsed = RdsDataSqlParameters.parse(sql, usesBackslashEscapes(engine));+ try (PreparedStatement statement = prepare(connection, engine, parsed.sql())) {+ rejectStatementReturningRows(statement, parsed.sql());+ if (returnsGeneratedKeys(engine)) {+ for (Map<String, JsonNode> parameters : parameterSets) {+ RdsDataSqlParameters.bind(statement, parsed.parameterOrder(), parameters);+ statement.execute();+ updateResults.add(updateResult(generatedFields(statement, engine)));+ }+ } else {+ for (Map<String, JsonNode> parameters : parameterSets) {+ RdsDataSqlParameters.bind(statement, parsed.parameterOrder(), parameters);+ statement.addBatch();+ }+ statement.executeBatch();+ for (int set = 0; set < parameterSets.size(); set++) {+ updateResults.add(updateResult(objectMapper.createArrayNode()));+ }+ }}+ return batchResponse(updateResults);+ }++ private ObjectNode batchResponse(ArrayNode updateResults) {+ ObjectNode response = objectMapper.createObjectNode();+ response.set("updateResults", updateResults);+ return response;+ }++ /**+ * Rejects a batched statement whose result is rows rather than an update+ * count. AWS takes "a DML statement" here and answers with one+ * {@code UpdateResult} per set, which has nowhere to carry a result set.+ * Neither engine refuses one on its own: the MySQL branch of+ * {@link #batchOnConnection} executes each set through {@code execute()} to+ * keep generated keys with their set, which bypasses the+ * {@code executeBatch()} that Connector/J would have refused, and the+ * PostgreSQL driver batches a {@code SELECT} happily.+ *+ * <p>The check reads the driver's description of the prepared statement,+ * which both drivers answer without running it. A DML statement that also+ * reports rows through a {@code RETURNING} clause is left alone — AWS points+ * Aurora PostgreSQL callers at {@code RETURNING} because+ * {@code generatedFields} is always empty there — so the leading keyword+ * decides that before the description is asked for.+ */+ private static void rejectStatementReturningRows(PreparedStatement statement, String sql) {+ if (isDataModifying(sql) || !returnsRows(statement)) {+ return;+ }+ throw new AwsException("BadRequestException",+ "BatchExecuteStatement does not support a SQL statement that returns a result set. "+ + "Use ExecuteStatement instead.", 400);+ }++ private static boolean returnsRows(PreparedStatement statement) {+ try {+ return statement.getMetaData() != null;+ } catch (SQLException e) {+ // A driver that cannot describe the statement leaves the verdict to the execution itself.+ LOG.debugv("Could not describe RDS Data API batch statement: {0}", e.getMessage());+ return false;+ }+ }++ /**+ * Whether {@code sql} opens a data-modifying statement, ignoring leading+ * whitespace and comments. Only used to exempt DML from+ * {@link #rejectStatementReturningRows}, so an unrecognized leading keyword+ * counts as not modifying and the driver's description decides.+ */+ private static boolean isDataModifying(String sql) {+ int len = sql.length();+ int i = 0;+ while (i < len) {+ char c = sql.charAt(i);+ if (Character.isWhitespace(c)) {+ i++;+ } else if (c == '-' && i + 1 < len && sql.charAt(i + 1) == '-') {+ int end = sql.indexOf('\n', i);+ i = end < 0 ? len : end + 1;+ } else if (c == '/' && i + 1 < len && sql.charAt(i + 1) == '*') {+ int end = sql.indexOf("*/", i + 2);+ i = end < 0 ? len : end + 2;+ } else {+ break;+ }+ }+ int start = i;+ while (i < len && Character.isLetter(sql.charAt(i))) {+ i++;+ }+ return DML_KEYWORDS.contains(sql.substring(start, i).toLowerCase(Locale.ROOT));+ }++ private ObjectNode updateResult(ArrayNode generatedFields) {+ ObjectNode updateResult = objectMapper.createObjectNode();+ updateResult.set("generatedFields", generatedFields);+ return updateResult;+ }++ private static PreparedStatement prepare(Connection connection, DatabaseEngine engine, String sql)+ throws SQLException {+ if (returnsGeneratedKeys(engine)) {+ return connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);+ }+ return connection.prepareStatement(sql);+ }++ /**+ * Whether generated keys are requested from {@code engine}. AWS reports no+ * {@code generatedFields} for Aurora PostgreSQL — callers read generated+ * values with a {@code RETURNING} clause instead — so they are only asked+ * for on the engines AWS answers them for. That also avoids the PostgreSQL+ * driver rewriting the statement with {@code RETURNING *} to satisfy+ * {@code RETURN_GENERATED_KEYS}.+ */+ private static boolean returnsGeneratedKeys(DatabaseEngine engine) {+ return switch (engine) {+ case MYSQL, MARIADB -> true;+ case POSTGRES -> false;+ };}/**@@ -236,14 +410,14 @@ public class RdsDataService implements Resettable {};}- private ObjectNode buildResponse(Statement statement, boolean hasResultSet, boolean includeMetadata)- throws SQLException {+ private ObjectNode buildResponse(Statement statement, boolean hasResultSet, boolean includeMetadata,+ DatabaseEngine engine) throws SQLException {ObjectNode response = objectMapper.createObjectNode();if (hasResultSet) {try (ResultSet rs = statement.getResultSet()) {ResultSetMetaData meta = rs.getMetaData();if (includeMetadata) {- response.set("columnMetadata", columnMetadata(meta));+ response.set("columnMetadata", RdsDataColumnMetadata.toColumnMetadata(objectMapper, meta));}response.set("records", records(rs, meta));}@@ -252,22 +426,32 @@ public class RdsDataService implements Resettable {int updateCount = statement.getUpdateCount();response.set("records", objectMapper.createArrayNode());response.put("numberOfRecordsUpdated", Math.max(updateCount, 0));+ response.set("generatedFields", generatedFields(statement, engine));}return response;}- private ArrayNode columnMetadata(ResultSetMetaData meta) throws SQLException {- ArrayNode columns = objectMapper.createArrayNode();- for (int i = 1; i <= meta.getColumnCount(); i++) {- ObjectNode column = objectMapper.createObjectNode();- String name = meta.getColumnLabel(i);- if (name == null || name.isBlank()) {- name = meta.getColumnName(i);+ /**+ * The keys generated by the last execution of {@code statement}, one+ * {@code Field} per generated column of every row the driver reported.+ */+ private ArrayNode generatedFields(Statement statement, DatabaseEngine engine) {+ if (!returnsGeneratedKeys(engine)) {+ return objectMapper.createArrayNode();+ }+ try (ResultSet keys = statement.getGeneratedKeys()) {+ ResultSetMetaData meta = keys.getMetaData();+ ArrayNode fields = objectMapper.createArrayNode();+ while (keys.next()) {+ for (int i = 1; i <= meta.getColumnCount(); i++) {+ fields.add(RdsDataFieldMapper.toField(objectMapper, keys.getObject(i), meta.getColumnType(i)));+ }}- column.put("name", name);- columns.add(column);+ return fields;+ } catch (SQLException e) {+ LOG.debugv("Could not read generated keys for RDS Data API statement: {0}", e.getMessage());+ return objectMapper.createArrayNode();}- return columns;}private ArrayNode records(ResultSet rs, ResultSetMetaData meta) throws SQLException {@@ -422,13 +606,32 @@ public class RdsDataService implements Resettable {}private static Map<String, JsonNode> parseParameters(JsonNode request) {- JsonNode parameters = request.get("parameters");+ return parseParameterList(request.get("parameters"), "parameters");+ }++ private static List<Map<String, JsonNode>> parseParameterSets(JsonNode request) {+ JsonNode parameterSets = request.get("parameterSets");+ if (parameterSets == null || parameterSets.isNull()) {+ return List.of();+ }+ if (!parameterSets.isArray()) {+ throw new AwsException("BadRequestException",+ "parameterSets must be an array of SqlParameter arrays.", 400);+ }+ List<Map<String, JsonNode>> sets = new ArrayList<>();+ for (JsonNode parameters : parameterSets) {+ sets.add(parseParameterList(parameters, "each entry in parameterSets"));+ }+ return sets;+ }++ private static Map<String, JsonNode> parseParameterList(JsonNode parameters, String field) {if (parameters == null || parameters.isNull()) {return Map.of();}if (!parameters.isArray()) {throw new AwsException("BadRequestException",- "parameters must be an array of SqlParameter values.", 400);+ field + " must be an array of SqlParameter values.", 400);}Map<String, JsonNode> byName = new LinkedHashMap<>();for (JsonNode parameter : parameters) {@@ -515,4 +718,9 @@ public class RdsDataService implements Resettable {private record Credentials(String username, String password) {}++ @FunctionalInterface+ private interface ConnectionWork {+ ObjectNode execute(Connection connection, DatabaseEngine engine) throws SQLException;+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataControllerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataControllerIntegrationTest.javaindex d9e35110df..2afd3291d1 100644--- a/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataControllerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataControllerIntegrationTest.java@@ -114,7 +114,7 @@ class RdsDataControllerIntegrationTest {}@Test- void batchExecuteReturnsJsonUnsupportedError() {+ void batchExecuteRejectsMissingSqlWithJsonDataApiError() {given().contentType("application/json").body("{}")@@ -128,6 +128,52 @@ class RdsDataControllerIntegrationTest {.body("__type", equalTo("BadRequestException"));}+ @Test+ void batchExecuteRejectsMalformedParameterSetsWithJsonDataApiError() {+ given()+ .contentType("application/json")+ .body("""+ {+ "resourceArn": "arn:aws:rds:us-east-1:000000000000:cluster:missing",+ "secretArn": "arn:aws:secretsmanager:us-east-1:000000000000:secret:missing",+ "database": "app",+ "sql": "insert into items(id) values (:id)",+ "parameterSets": {"name": "id"}+ }+ """)+ .when()+ .post("/BatchExecute")+ .then()+ .statusCode(400)+ .contentType("application/json")+ .header("X-Amzn-Errortype", "BadRequestException")+ .header("x-amzn-query-error", "BadRequestException;Sender")+ .body("__type", equalTo("BadRequestException"));+ }++ @Test+ void batchExecuteUnknownResourceReturnsJsonDataApiError() {+ given()+ .contentType("application/json")+ .body("""+ {+ "resourceArn": "arn:aws:rds:us-east-1:000000000000:cluster:missing",+ "secretArn": "arn:aws:secretsmanager:us-east-1:000000000000:secret:missing",+ "database": "app",+ "sql": "insert into items(id) values (:id)",+ "parameterSets": [[{"name": "id", "value": {"longValue": 1}}]]+ }+ """)+ .when()+ .post("/BatchExecute")+ .then()+ .statusCode(400)+ .contentType("application/json")+ .header("X-Amzn-Errortype", "BadRequestException")+ .header("x-amzn-query-error", "BadRequestException;Sender")+ .body("__type", equalTo("BadRequestException"));+ }+@Testvoid executeSqlReturnsJsonUnsupportedError() {given()diff --git a/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataServiceTest.javaindex e41ab3ae73..93581594d8 100644--- a/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataServiceTest.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.services.rdsdata;+import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.node.ArrayNode;import com.fasterxml.jackson.databind.node.ObjectNode;@@ -11,14 +12,17 @@ import org.junit.jupiter.api.Test;import java.lang.reflect.Proxy;import java.sql.Connection;import java.sql.DriverManager;+import java.sql.ResultSetMetaData;import java.sql.SQLException;import java.sql.Statement;+import java.sql.Types;import java.time.Duration;import java.util.UUID;import java.util.concurrent.atomic.AtomicBoolean;import static org.junit.jupiter.api.Assertions.assertArrayEquals;import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.mockito.ArgumentMatchers.any;@@ -72,6 +76,259 @@ class RdsDataServiceTest {assertEquals(0L, selectResponse.get("numberOfRecordsUpdated").asLong());}+ @Test+ void emitsEveryColumnMetadataFieldAwsClientsRead() throws Exception {+ TestHarness harness = new TestHarness();+ harness.createTables();+ harness.service.executeStatement(harness.request(+ "insert into data_api_items(id, title, score) values ('meta', 'Meta', 3)"), REGION);++ ObjectNode select = harness.request(+ "select title as aliased_title, score from data_api_items where id = 'meta'");+ select.put("includeResultMetadata", true);+ ObjectNode response = harness.service.executeStatement(select, REGION);++ ArrayNode metadata = (ArrayNode) response.get("columnMetadata");+ JsonNode aliased = metadata.get(0);+ assertEquals("aliased_title", aliased.get("label").asText().toLowerCase());+ assertEquals("title", aliased.get("name").asText().toLowerCase());+ assertEquals(Types.VARCHAR, aliased.get("type").asInt());+ assertFalse(aliased.get("typeName").asText().isBlank());+ assertEquals("data_api_items", aliased.get("tableName").asText().toLowerCase());+ assertEquals(ResultSetMetaData.columnNullable, aliased.get("nullable").asInt());+ assertEquals(255, aliased.get("precision").asInt());+ assertEquals(0, aliased.get("scale").asInt());+ assertEquals(0, aliased.get("arrayBaseColumnType").asInt());+ assertFalse(aliased.get("isAutoIncrement").asBoolean());+ assertFalse(aliased.get("isCurrency").asBoolean());+ assertTrue(aliased.has("isCaseSensitive"));+ assertTrue(aliased.has("schemaName"));++ JsonNode score = metadata.get(1);+ assertEquals("score", score.get("label").asText().toLowerCase());+ assertEquals("score", score.get("name").asText().toLowerCase());+ assertEquals(Types.BIGINT, score.get("type").asInt());+ assertTrue(score.get("isSigned").asBoolean());++ assertFalse(response.has("generatedFields"));+ }++ @Test+ void returnsGeneratedFieldsForAutoIncrementInserts() throws Exception {+ TestHarness harness = new TestHarness();+ harness.createTables();++ ObjectNode response = harness.service.executeStatement(+ harness.request("insert into data_api_events(name) values ('created')"), REGION);++ assertEquals(1L, response.get("numberOfRecordsUpdated").asLong());+ ArrayNode generatedFields = (ArrayNode) response.get("generatedFields");+ assertEquals(1, generatedFields.size());+ assertTrue(generatedFields.get(0).get("longValue").asLong() > 0);+ }++ @Test+ void batchExecuteStatementRunsEveryParameterSet() throws Exception {+ TestHarness harness = new TestHarness();+ harness.createTables();++ ObjectNode batch = harness.request("insert into data_api_events(name) values (:name)");+ batch.set("parameterSets", parameterSets("first", "second"));++ ObjectNode response = harness.service.batchExecuteStatement(batch, REGION);++ ArrayNode updateResults = (ArrayNode) response.get("updateResults");+ assertEquals(2, updateResults.size());+ long firstId = updateResults.get(0).get("generatedFields").get(0).get("longValue").asLong();+ long secondId = updateResults.get(1).get("generatedFields").get(0).get("longValue").asLong();+ assertTrue(secondId > firstId);+ assertFalse(response.has("records"));+ assertEquals(2L, harness.countEvents());+ }++ @Test+ void batchExecuteStatementKeepsGeneratedKeysWithTheirParameterSet() throws Exception {+ TestHarness harness = new TestHarness();+ harness.createTables();++ ObjectNode batch = harness.request(+ "insert into data_api_events(name) values (:first), (:second)");+ ArrayNode sets = objectMapper.createArrayNode();+ sets.add(objectMapper.createArrayNode()+ .add(stringParam("first", "one-a"))+ .add(stringParam("second", "one-b")));+ sets.add(objectMapper.createArrayNode()+ .add(stringParam("first", "two-a"))+ .add(stringParam("second", "two-b")));+ batch.set("parameterSets", sets);++ ObjectNode response = harness.service.batchExecuteStatement(batch, REGION);++ ArrayNode updateResults = (ArrayNode) response.get("updateResults");+ assertEquals(2, updateResults.size());+ ArrayNode firstKeys = (ArrayNode) updateResults.get(0).get("generatedFields");+ ArrayNode secondKeys = (ArrayNode) updateResults.get(1).get("generatedFields");+ assertEquals(2, firstKeys.size());+ assertEquals(2, secondKeys.size());+ assertTrue(secondKeys.get(0).get("longValue").asLong()+ > firstKeys.get(1).get("longValue").asLong());+ assertEquals(4L, harness.countEvents());+ }++ @Test+ void batchExecuteStatementHonorsAnOpenTransaction() throws Exception {+ TestHarness harness = new TestHarness();+ harness.createTables();++ String transactionId = harness.service.beginTransaction(harness.beginRequest(), REGION)+ .get("transactionId").asText();+ ObjectNode batch = harness.request("insert into data_api_events(name) values (:name)");+ batch.set("parameterSets", parameterSets("rolled", "back"));+ batch.put("transactionId", transactionId);+ harness.service.batchExecuteStatement(batch, REGION);++ harness.service.rollbackTransaction(harness.transactionRequest(transactionId), REGION);++ assertEquals(0L, harness.countEvents());+ }++ @Test+ void batchExecuteStatementIgnoresExecuteStatementOnlyResultOptions() throws Exception {+ TestHarness harness = new TestHarness();+ harness.createTables();++ ObjectNode batch = harness.request("insert into data_api_events(name) values (:name)");+ batch.set("parameterSets", parameterSets("ignored-options"));+ batch.put("formatRecordsAs", "JSON");+ batch.set("resultSetOptions", objectMapper.createObjectNode().put("decimalReturnType", "STRING"));++ ObjectNode response = harness.service.batchExecuteStatement(batch, REGION);++ assertEquals(1, response.get("updateResults").size());+ assertEquals(1L, harness.countEvents());+ }++ @Test+ void batchExecuteStatementRunsNothingWithoutParameterSets() throws Exception {+ TestHarness harness = new TestHarness();+ harness.createTables();++ ObjectNode absent = harness.request("insert into data_api_events(name) values ('no-sets')");+ ObjectNode absentResponse = harness.service.batchExecuteStatement(absent, REGION);++ ObjectNode empty = harness.request("insert into data_api_events(name) values ('no-sets')");+ empty.set("parameterSets", objectMapper.createArrayNode());+ ObjectNode emptyResponse = harness.service.batchExecuteStatement(empty, REGION);++ assertEquals(0, absentResponse.get("updateResults").size());+ assertEquals(0, emptyResponse.get("updateResults").size());+ assertEquals(0L, harness.countEvents());+ }++ @Test+ void batchExecuteStatementRunsOnceForOneEmptyParameterSet() throws Exception {+ TestHarness harness = new TestHarness();+ harness.createTables();++ ObjectNode batch = harness.request("insert into data_api_events(name) values ('empty-set')");+ batch.set("parameterSets", objectMapper.createArrayNode().add(objectMapper.createArrayNode()));++ ObjectNode response = harness.service.batchExecuteStatement(batch, REGION);++ assertEquals(1, response.get("updateResults").size());+ assertEquals(1L, harness.countEvents());+ }++ @Test+ void batchExecuteStatementRejectsAStatementThatReturnsRows() throws Exception {+ TestHarness harness = new TestHarness();+ harness.createTables();+ harness.service.executeStatement(+ harness.request("insert into data_api_events(name) values ('kept')"), REGION);++ ObjectNode select = harness.request("select id from data_api_events where name = :name");+ select.set("parameterSets", parameterSets("kept", "kept"));+ AwsException error = assertThrows(AwsException.class,+ () -> harness.service.batchExecuteStatement(select, REGION));++ assertEquals("BadRequestException", error.getErrorCode());+ assertTrue(error.getMessage().contains("returns a result set"));+ assertEquals(1L, harness.countEvents());+ }++ @Test+ void batchExecuteStatementRunsDmlHiddenBehindALeadingComment() throws Exception {+ TestHarness harness = new TestHarness();+ harness.createTables();++ ObjectNode batch = harness.request("""+ -- seeds the events table+ /* two sets */ insert into data_api_events(name) values (:name)+ """);+ batch.set("parameterSets", parameterSets("commented-one", "commented-two"));++ ObjectNode response = harness.service.batchExecuteStatement(batch, REGION);++ assertEquals(2, response.get("updateResults").size());+ assertEquals(2L, harness.countEvents());+ }++ @Test+ void batchExecuteStatementReportsOneResultPerSetOnPostgres() throws Exception {+ TestHarness harness = new TestHarness(DatabaseEngine.POSTGRES);+ harness.createEventsTable();++ ObjectNode batch = harness.request("insert into data_api_events(name) values (:name)");+ batch.set("parameterSets", parameterSets("first", "second"));++ ObjectNode response = harness.service.batchExecuteStatement(batch, REGION);++ ArrayNode updateResults = (ArrayNode) response.get("updateResults");+ assertEquals(2, updateResults.size());+ assertEquals(0, updateResults.get(0).get("generatedFields").size());+ assertEquals(0, updateResults.get(1).get("generatedFields").size());+ assertEquals(2L, harness.countEvents());+ }++ @Test+ void batchExecuteStatementRejectsAStatementThatReturnsRowsOnPostgres() throws Exception {+ TestHarness harness = new TestHarness(DatabaseEngine.POSTGRES);+ harness.createEventsTable();++ ObjectNode select = harness.request("select id from data_api_events where name = :name");+ select.set("parameterSets", parameterSets("first", "second"));+ AwsException error = assertThrows(AwsException.class,+ () -> harness.service.batchExecuteStatement(select, REGION));++ assertEquals("BadRequestException", error.getErrorCode());+ assertTrue(error.getMessage().contains("returns a result set"));+ }++ @Test+ void batchExecuteStatementValidatesRequestShape() throws Exception {+ TestHarness harness = new TestHarness();+ harness.createTables();++ ObjectNode missingSql = harness.beginRequest();+ AwsException missingSqlError = assertThrows(AwsException.class,+ () -> harness.service.batchExecuteStatement(missingSql, REGION));+ assertEquals("BadRequestException", missingSqlError.getErrorCode());+ assertEquals("sql is required.", missingSqlError.getMessage());++ ObjectNode notAnArray = harness.request("insert into data_api_events(name) values (:name)");+ notAnArray.set("parameterSets", objectMapper.createObjectNode());+ AwsException notAnArrayError = assertThrows(AwsException.class,+ () -> harness.service.batchExecuteStatement(notAnArray, REGION));+ assertEquals("BadRequestException", notAnArrayError.getErrorCode());++ ObjectNode setNotAnArray = harness.request("insert into data_api_events(name) values (:name)");+ setNotAnArray.set("parameterSets",+ objectMapper.createArrayNode().add(objectMapper.createObjectNode()));+ AwsException setNotAnArrayError = assertThrows(AwsException.class,+ () -> harness.service.batchExecuteStatement(setNotAnArray, REGION));+ assertEquals("BadRequestException", setNotAnArrayError.getErrorCode());+ }+@Testvoid bindsSqlParametersThroughPreparedStatements() throws Exception {TestHarness harness = new TestHarness();@@ -439,6 +696,14 @@ class RdsDataServiceTest {return request;}+ private ArrayNode parameterSets(String... names) {+ ArrayNode sets = objectMapper.createArrayNode();+ for (String name : names) {+ sets.add(objectMapper.createArrayNode().add(stringParam("name", name)));+ }+ return sets;+ }+private ObjectNode stringParam(String name, String value) {ObjectNode param = objectMapper.createObjectNode();param.put("name", name);@@ -486,10 +751,22 @@ class RdsDataServiceTest {}private static RdsDataResourceResolver.DatabaseTarget target(String resourceArn) {- return new RdsDataResourceResolver.DatabaseTarget(resourceArn, DatabaseEngine.MYSQL,+ return target(resourceArn, DatabaseEngine.MYSQL);+ }++ private static RdsDataResourceResolver.DatabaseTarget target(String resourceArn, DatabaseEngine engine) {+ return new RdsDataResourceResolver.DatabaseTarget(resourceArn, engine,"127.0.0.1", 3306, "sa", "", "app");}+ /** The H2 compatibility mode standing in for {@code engine}. */+ private static String h2Mode(DatabaseEngine engine) {+ return switch (engine) {+ case MYSQL, MARIADB -> "MySQL";+ case POSTGRES -> "PostgreSQL";+ };+ }+private static Connection throwingSetAutoCommitConnection(AtomicBoolean closed) {return (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(),new Class<?>[] {Connection.class},@@ -519,20 +796,29 @@ class RdsDataServiceTest {}private final class TestHarness {- private final String jdbcUrl = "jdbc:h2:mem:rdsdata_" + UUID.randomUUID()- + ";MODE=MySQL;DATABASE_TO_LOWER=TRUE;DB_CLOSE_DELAY=-1";+ private final String jdbcUrl;private final RdsDataResourceResolver resolver;private final RdsDataResourceResolver.DatabaseTarget target;private final RdsDataService service;private TestHarness() {- this(Duration.ofSeconds(60));+ this(DatabaseEngine.MYSQL, Duration.ofSeconds(60));+ }++ private TestHarness(DatabaseEngine engine) {+ this(engine, Duration.ofSeconds(60));}private TestHarness(Duration transactionTtl) {+ this(DatabaseEngine.MYSQL, transactionTtl);+ }++ private TestHarness(DatabaseEngine engine, Duration transactionTtl) {+ jdbcUrl = "jdbc:h2:mem:rdsdata_" + UUID.randomUUID() + ";MODE=" + h2Mode(engine)+ + ";DATABASE_TO_LOWER=TRUE;DB_CLOSE_DELAY=-1";resolver = mock(RdsDataResourceResolver.class);SecretsManagerService secrets = fallbackSecrets();- target = target();+ target = target(RESOURCE_ARN, engine);when(resolver.resolve(RESOURCE_ARN, REGION)).thenReturn(target);when(resolver.resolve(FALLBACK_RESOURCE_ARN, REGION)).thenReturn(target);when(resolver.resolve(OTHER_RESOURCE_ARN, REGION)).thenReturn(target(OTHER_RESOURCE_ARN));@@ -563,6 +849,28 @@ class RdsDataServiceTest {created_at timestamp(9))""");+ statement.execute("""+ create table data_api_events(+ id bigint auto_increment primary key,+ name varchar(64)+ )+ """);+ }+ }++ /**+ * The events table alone, in DDL both H2 compatibility modes accept, for+ * harnesses standing in for PostgreSQL.+ */+ private void createEventsTable() throws SQLException {+ try (Connection connection = DriverManager.getConnection(jdbcUrl, "sa", "");+ Statement statement = connection.createStatement()) {+ statement.execute("""+ create table data_api_events(+ id bigint generated by default as identity primary key,+ name varchar(64)+ )+ """);}}@@ -600,6 +908,12 @@ class RdsDataServiceTest {return request;}+ private long countEvents() {+ ObjectNode request = request("select count(*) as count from data_api_events");+ ObjectNode response = service.executeStatement(request, REGION);+ return response.get("records").get(0).get(0).get("longValue").asLong();+ }+private long countById(String id) {ObjectNode request = request("select count(*) as count from data_api_items where id = '" + id + "'");ObjectNode response = service.executeStatement(request, REGION);