Skip to content

armgit / floci

Public Imported from GitHub
0

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.go
index 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.md
index 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.java
new file mode 100644
index 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.java
index 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());
}
@POST
diff --git a/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataService.java b/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataService.java
index 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.java
index 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"));
+ }
+
@Test
void 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.java
index 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());
+ }
+
@Test
void 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);