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 preparedstatement() support (#1887)

Anders Wasen19a32ab51d97
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 98878187d4..3b6995872d 100644
--- a/compatibility-tests/sdk-test-go/tests/rds_data_test.go
+++ b/compatibility-tests/sdk-test-go/tests/rds_data_test.go
@@ -355,13 +355,30 @@ func TestRdsDataApiGoSdkV1(t *testing.T) {
ResourceArn: awsV1.String(resourceArn),
SecretArn: awsV1.String(secretArn),
Database: awsV1.String(database),
- Sql: awsV1.String("select :id"),
- Parameters: []*rdsdataservice.SqlParameter{{
- Name: awsV1.String("id"),
- Value: &rdsdataservice.Field{LongValue: awsV1.Int64(1)},
- }},
+ Sql: awsV1.String("insert into data_api_items (id, title, score) values (:id, :title, :score)"),
+ Parameters: []*rdsdataservice.SqlParameter{
+ {Name: awsV1.String("id"), Value: &rdsdataservice.Field{StringValue: awsV1.String("param-1")}},
+ {Name: awsV1.String("title"), Value: &rdsdataservice.Field{StringValue: awsV1.String("parameterized")}},
+ {Name: awsV1.String("score"), Value: &rdsdataservice.Field{LongValue: awsV1.Int64(42)}},
+ },
})
- assertAwsErrorCode(t, err, "BadRequestException")
+ require.NoError(t, err)
+
+ paramOut, err := dataSvc.ExecuteStatement(&rdsdataservice.ExecuteStatementInput{
+ ResourceArn: awsV1.String(resourceArn),
+ SecretArn: awsV1.String(secretArn),
+ Database: awsV1.String(database),
+ Sql: awsV1.String("select title, score from data_api_items where id = :id and score = :score"),
+ IncludeResultMetadata: awsV1.Bool(true),
+ Parameters: []*rdsdataservice.SqlParameter{
+ {Name: awsV1.String("id"), Value: &rdsdataservice.Field{StringValue: awsV1.String("param-1")}},
+ {Name: awsV1.String("score"), Value: &rdsdataservice.Field{LongValue: awsV1.Int64(42)}},
+ },
+ })
+ require.NoError(t, err)
+ require.Len(t, paramOut.Records, 1)
+ assert.Equal(t, "parameterized", awsV1.StringValue(paramOut.Records[0][0].StringValue))
+ assert.Equal(t, int64(42), awsV1.Int64Value(paramOut.Records[0][1].LongValue))
_, err = dataSvc.ExecuteStatement(&rdsdataservice.ExecuteStatementInput{
ResourceArn: awsV1.String(resourceArn),
@@ -713,13 +730,30 @@ func TestRdsDataApiGoSdkPostgresV1(t *testing.T) {
ResourceArn: awsV1.String(resourceArn),
SecretArn: awsV1.String(secretArn),
Database: awsV1.String(database),
- Sql: awsV1.String("select :id"),
- Parameters: []*rdsdataservice.SqlParameter{{
- Name: awsV1.String("id"),
- Value: &rdsdataservice.Field{LongValue: awsV1.Int64(1)},
- }},
+ Sql: awsV1.String("insert into data_api_items (id, title, score) values (:id, :title, :score)"),
+ Parameters: []*rdsdataservice.SqlParameter{
+ {Name: awsV1.String("id"), Value: &rdsdataservice.Field{StringValue: awsV1.String("param-1")}},
+ {Name: awsV1.String("title"), Value: &rdsdataservice.Field{StringValue: awsV1.String("parameterized")}},
+ {Name: awsV1.String("score"), Value: &rdsdataservice.Field{LongValue: awsV1.Int64(42)}},
+ },
})
- assertAwsErrorCode(t, err, "BadRequestException")
+ require.NoError(t, err)
+
+ paramOut, err := dataSvc.ExecuteStatement(&rdsdataservice.ExecuteStatementInput{
+ ResourceArn: awsV1.String(resourceArn),
+ SecretArn: awsV1.String(secretArn),
+ Database: awsV1.String(database),
+ Sql: awsV1.String("select title, score from data_api_items where id = :id and score = :score"),
+ IncludeResultMetadata: awsV1.Bool(true),
+ Parameters: []*rdsdataservice.SqlParameter{
+ {Name: awsV1.String("id"), Value: &rdsdataservice.Field{StringValue: awsV1.String("param-1")}},
+ {Name: awsV1.String("score"), Value: &rdsdataservice.Field{LongValue: awsV1.Int64(42)}},
+ },
+ })
+ require.NoError(t, err)
+ require.Len(t, paramOut.Records, 1)
+ assert.Equal(t, "parameterized", awsV1.StringValue(paramOut.Records[0][0].StringValue))
+ assert.Equal(t, int64(42), awsV1.Int64Value(paramOut.Records[0][1].LongValue))
_, err = dataSvc.ExecuteStatement(&rdsdataservice.ExecuteStatementInput{
ResourceArn: awsV1.String(resourceArn),
@@ -895,13 +929,30 @@ func TestRdsDataApiGoSdkV2(t *testing.T) {
ResourceArn: awsV2.String(resourceArn),
SecretArn: awsV2.String(secretArn),
Database: awsV2.String(database),
- Sql: awsV2.String("select :id"),
- Parameters: []rdsdatatypes.SqlParameter{{
- Name: awsV2.String("id"),
- Value: &rdsdatatypes.FieldMemberLongValue{Value: 1},
- }},
+ Sql: awsV2.String("insert into data_api_v2_items (id, name, qty) values (:id, :name, :qty)"),
+ Parameters: []rdsdatatypes.SqlParameter{
+ {Name: awsV2.String("id"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "v2-param"}},
+ {Name: awsV2.String("name"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "parameterized"}},
+ {Name: awsV2.String("qty"), Value: &rdsdatatypes.FieldMemberLongValue{Value: 42}},
+ },
})
- assertSmithyErrorCode(t, err, "BadRequestException")
+ require.NoError(t, err)
+
+ paramOut, err := dataSvc.ExecuteStatement(ctx, &rdsdata.ExecuteStatementInput{
+ ResourceArn: awsV2.String(resourceArn),
+ SecretArn: awsV2.String(secretArn),
+ Database: awsV2.String(database),
+ Sql: awsV2.String("select name, qty from data_api_v2_items where id = :id and qty = :qty"),
+ IncludeResultMetadata: true,
+ Parameters: []rdsdatatypes.SqlParameter{
+ {Name: awsV2.String("id"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "v2-param"}},
+ {Name: awsV2.String("qty"), Value: &rdsdatatypes.FieldMemberLongValue{Value: 42}},
+ },
+ })
+ require.NoError(t, err)
+ require.Len(t, paramOut.Records, 1)
+ assert.Equal(t, "parameterized", fieldStringValue(t, paramOut.Records[0][0]))
+ assert.Equal(t, int64(42), fieldLongValue(t, paramOut.Records[0][1]))
_, err = dataSvc.ExecuteSql(ctx, &rdsdata.ExecuteSqlInput{
DbClusterOrInstanceArn: awsV2.String(resourceArn),
@@ -1068,13 +1119,30 @@ func TestRdsDataApiGoSdkPostgresV2(t *testing.T) {
ResourceArn: awsV2.String(resourceArn),
SecretArn: awsV2.String(secretArn),
Database: awsV2.String(database),
- Sql: awsV2.String("select :id"),
- Parameters: []rdsdatatypes.SqlParameter{{
- Name: awsV2.String("id"),
- Value: &rdsdatatypes.FieldMemberLongValue{Value: 1},
- }},
+ Sql: awsV2.String("insert into data_api_v2_items (id, name, qty) values (:id, :name, :qty)"),
+ Parameters: []rdsdatatypes.SqlParameter{
+ {Name: awsV2.String("id"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "v2-param"}},
+ {Name: awsV2.String("name"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "parameterized"}},
+ {Name: awsV2.String("qty"), Value: &rdsdatatypes.FieldMemberLongValue{Value: 42}},
+ },
})
- assertSmithyErrorCode(t, err, "BadRequestException")
+ require.NoError(t, err)
+
+ paramOut, err := dataSvc.ExecuteStatement(ctx, &rdsdata.ExecuteStatementInput{
+ ResourceArn: awsV2.String(resourceArn),
+ SecretArn: awsV2.String(secretArn),
+ Database: awsV2.String(database),
+ Sql: awsV2.String("select name, qty from data_api_v2_items where id = :id and qty = :qty"),
+ IncludeResultMetadata: true,
+ Parameters: []rdsdatatypes.SqlParameter{
+ {Name: awsV2.String("id"), Value: &rdsdatatypes.FieldMemberStringValue{Value: "v2-param"}},
+ {Name: awsV2.String("qty"), Value: &rdsdatatypes.FieldMemberLongValue{Value: 42}},
+ },
+ })
+ require.NoError(t, err)
+ require.Len(t, paramOut.Records, 1)
+ assert.Equal(t, "parameterized", fieldStringValue(t, paramOut.Records[0][0]))
+ assert.Equal(t, int64(42), fieldLongValue(t, paramOut.Records[0][1]))
_, err = dataSvc.ExecuteSql(ctx, &rdsdata.ExecuteSqlInput{
DbClusterOrInstanceArn: awsV2.String(resourceArn),
diff --git a/docs/services/rds-data.md b/docs/services/rds-data.md
index 92b9a88969..cd8bda9874 100644
--- a/docs/services/rds-data.md
+++ b/docs/services/rds-data.md
@@ -33,7 +33,7 @@ For the upstream API shape, see the AWS RDS Data API documentation:
- `database` is optional when the resolved RDS resource has a database name; otherwise it must be provided. Transactional `ExecuteStatement` requests must use the same database as the active transaction when `database` is present.
- Transaction requests validate `resourceArn` against the active transaction resource. Floci resolves accepted ARN aliases to the local resource before comparing transaction identity.
- 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 not implemented yet; send raw SQL strings. Non-empty or malformed `parameters` requests return `BadRequestException`.
+- 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`.
- 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.
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 24f015b67b..1e8bd3344e 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
@@ -6,6 +6,7 @@ import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import io.github.hectorvent.floci.config.EmulatorConfig;
import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.services.rds.model.DatabaseEngine;
import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;
import io.github.hectorvent.floci.services.secretsmanager.model.SecretVersion;
import io.github.hectorvent.floci.core.common.Resettable;
@@ -16,12 +17,15 @@ import jakarta.inject.Inject;
import org.jboss.logging.Logger;
import java.sql.Connection;
+import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.time.Duration;
import java.time.Instant;
+import java.util.LinkedHashMap;
+import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
@@ -107,6 +111,7 @@ public class RdsDataService implements Resettable {
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);
@@ -117,7 +122,7 @@ public class RdsDataService implements Resettable {
requireActiveTransaction(transactionId, tx);
validateTransactionIdentity(tx, request);
tx.refresh(transactionTtl);
- return executeOnConnection(tx.connection, sql, includeMetadata);
+ return executeOnConnection(tx.connection, tx.engine, sql, parameters, includeMetadata);
}
}
@@ -125,7 +130,7 @@ public class RdsDataService implements Resettable {
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, sql, includeMetadata);
+ return executeOnConnection(connection, target.engine(), sql, parameters, includeMetadata);
}
} catch (SQLException e) {
throw databaseError(e);
@@ -145,7 +150,7 @@ public class RdsDataService implements Resettable {
connection = connectionFactory.open(target, credentials.username(), credentials.password(), database);
connection.setAutoCommit(false);
String transactionId = UUID.randomUUID().toString();
- transactions.put(transactionId, new TransactionContext(transactionId, connection, target.arn(), database, transactionTtl));
+ transactions.put(transactionId, new TransactionContext(transactionId, connection, target.engine(), target.arn(), database, transactionTtl));
ObjectNode response = objectMapper.createObjectNode();
response.put("transactionId", transactionId);
@@ -206,26 +211,46 @@ public class RdsDataService implements Resettable {
return response;
}
- private ObjectNode executeOnConnection(Connection connection, String sql, boolean includeMetadata) throws SQLException {
- try (Statement statement = connection.createStatement()) {
- boolean hasResultSet = statement.execute(sql);
- ObjectNode response = objectMapper.createObjectNode();
- if (hasResultSet) {
- try (ResultSet rs = statement.getResultSet()) {
- ResultSetMetaData meta = rs.getMetaData();
- if (includeMetadata) {
- response.set("columnMetadata", columnMetadata(meta));
- }
- response.set("records", records(rs, meta));
+ 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())) {
+ RdsDataSqlParameters.bind(statement, parsed.parameterOrder(), parameters);
+ return buildResponse(statement, statement.execute(), includeMetadata);
+ }
+ }
+
+ /**
+ * Whether a backslash escapes quotes inside string literals for {@code engine}.
+ * MySQL and MariaDB honor {@code \'} by default (NO_BACKSLASH_ESCAPES disabled);
+ * PostgreSQL treats backslash literally with {@code standard_conforming_strings} on.
+ */
+ private static boolean usesBackslashEscapes(DatabaseEngine engine) {
+ return switch (engine) {
+ case MYSQL, MARIADB -> true;
+ case POSTGRES -> false;
+ };
+ }
+
+ private ObjectNode buildResponse(Statement statement, boolean hasResultSet, boolean includeMetadata)
+ 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.put("numberOfRecordsUpdated", 0L);
- } else {
- int updateCount = statement.getUpdateCount();
- response.set("records", objectMapper.createArrayNode());
- response.put("numberOfRecordsUpdated", Math.max(updateCount, 0));
+ response.set("records", records(rs, meta));
}
- return response;
+ response.put("numberOfRecordsUpdated", 0L);
+ } else {
+ int updateCount = statement.getUpdateCount();
+ response.set("records", objectMapper.createArrayNode());
+ response.put("numberOfRecordsUpdated", Math.max(updateCount, 0));
}
+ return response;
}
private ArrayNode columnMetadata(ResultSetMetaData meta) throws SQLException {
@@ -384,17 +409,36 @@ public class RdsDataService implements Resettable {
}
private static void rejectUnsupportedOptions(JsonNode request) {
- rejectSqlParameters(request);
rejectFormattedRecords(request);
rejectResultSetOptions(request);
}
- private static void rejectSqlParameters(JsonNode request) {
+ private static Map<String, JsonNode> parseParameters(JsonNode request) {
JsonNode parameters = request.get("parameters");
- if (parameters != null && (!parameters.isArray() || !parameters.isEmpty())) {
+ if (parameters == null || parameters.isNull()) {
+ return Map.of();
+ }
+ if (!parameters.isArray()) {
throw new AwsException("BadRequestException",
- "SqlParameter binding is not supported by this local RDS Data API implementation.", 400);
+ "parameters must be an array of SqlParameter values.", 400);
+ }
+ Map<String, JsonNode> byName = new LinkedHashMap<>();
+ for (JsonNode parameter : parameters) {
+ if (parameter == null || !parameter.isObject()) {
+ throw new AwsException("BadRequestException",
+ "Each parameter must be a SqlParameter object.", 400);
+ }
+ String name = textOrNull(parameter, "name");
+ if (name == null || name.isBlank()) {
+ throw new AwsException("BadRequestException",
+ "Each SqlParameter requires a name.", 400);
+ }
+ if (byName.putIfAbsent(name, parameter) != null) {
+ throw new AwsException("BadRequestException",
+ "Duplicate parameter name :" + name + " in the parameter set.", 400);
+ }
}
+ return byName;
}
private static void rejectFormattedRecords(JsonNode request) {
@@ -438,13 +482,15 @@ public class RdsDataService implements Resettable {
private static final class TransactionContext {
private final String id;
private final Connection connection;
+ private final DatabaseEngine engine;
private final String resourceArn;
private final String database;
private volatile Instant expiresAt;
- private TransactionContext(String id, Connection connection, String resourceArn, String database, Duration ttl) {
+ private TransactionContext(String id, Connection connection, DatabaseEngine engine, String resourceArn, String database, Duration ttl) {
this.id = id;
this.connection = connection;
+ this.engine = engine;
this.resourceArn = resourceArn;
this.database = database;
refresh(ttl);
diff --git a/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataSqlParameters.java b/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataSqlParameters.java
new file mode 100644
index 0000000000..5b54714d20
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/rdsdata/RdsDataSqlParameters.java
@@ -0,0 +1,273 @@
+package io.github.hectorvent.floci.services.rdsdata;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.github.hectorvent.floci.core.common.AwsException;
+
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.sql.Date;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Translates AWS RDS Data API {@code SqlParameter} bindings into JDBC
+ * {@link PreparedStatement} bindings.
+ *
+ * <p>The Data API uses named placeholders ({@code :name}); JDBC uses positional
+ * {@code ?}. {@link #parse(String)} rewrites the SQL to positional form while
+ * recording the placeholder order, and {@link #bind} binds each value variant.
+ * The rewrite is shared across MySQL, MariaDB, and PostgreSQL; the only
+ * dialect difference is whether a backslash escapes quotes inside string
+ * literals (see {@link #parse(String, boolean)}).
+ */
+final class RdsDataSqlParameters {
+
+ private RdsDataSqlParameters() {
+ }
+
+ /**
+ * SQL rewritten with positional {@code ?} placeholders, plus the ordered
+ * list of the Data API parameter names each placeholder was derived from.
+ * A name repeats once per occurrence in the original SQL.
+ */
+ record ParsedSql(String sql, List<String> parameterOrder) {
+ }
+
+ /**
+ * Rewrites {@code :name} placeholders to positional {@code ?} without
+ * treating backslash as a string-literal escape (the PostgreSQL default
+ * with {@code standard_conforming_strings} on).
+ */
+ static ParsedSql parse(String sql) {
+ return parse(sql, false);
+ }
+
+ /**
+ * Rewrites {@code :name} placeholders to positional {@code ?}, skipping over
+ * string literals, quoted/backtick identifiers, line and block comments,
+ * PostgreSQL {@code ::} casts, and PostgreSQL dollar-quoted strings so a
+ * colon inside any of those is left untouched.
+ *
+ * @param backslashEscapes when {@code true}, a backslash inside a single- or
+ * double-quoted string escapes the next character (MySQL/MariaDB
+ * default, i.e. {@code NO_BACKSLASH_ESCAPES} disabled). Backtick
+ * identifiers never honor backslash escaping.
+ */
+ static ParsedSql parse(String sql, boolean backslashEscapes) {
+ StringBuilder out = new StringBuilder(sql.length());
+ List<String> order = new ArrayList<>();
+ int len = sql.length();
+ int i = 0;
+ while (i < len) {
+ char c = sql.charAt(i);
+
+ if (c == '-' && i + 1 < len && sql.charAt(i + 1) == '-') {
+ int end = sql.indexOf('\n', i);
+ if (end < 0) {
+ end = len;
+ }
+ out.append(sql, i, end);
+ i = end;
+ continue;
+ }
+
+ if (c == '/' && i + 1 < len && sql.charAt(i + 1) == '*') {
+ int end = sql.indexOf("*/", i + 2);
+ end = end < 0 ? len : end + 2;
+ out.append(sql, i, end);
+ i = end;
+ continue;
+ }
+
+ if (c == '\'' || c == '"' || c == '`') {
+ i = copyQuoted(sql, i, c, out, backslashEscapes);
+ continue;
+ }
+
+ if (c == '$') {
+ int consumed = copyDollarQuoted(sql, i, out);
+ if (consumed > i) {
+ i = consumed;
+ continue;
+ }
+ out.append(c);
+ i++;
+ continue;
+ }
+
+ if (c == ':') {
+ if (i + 1 < len && sql.charAt(i + 1) == ':') {
+ out.append("::");
+ i += 2;
+ continue;
+ }
+ if (i + 1 < len && isNameStart(sql.charAt(i + 1))) {
+ int j = i + 1;
+ while (j < len && isNamePart(sql.charAt(j))) {
+ j++;
+ }
+ order.add(sql.substring(i + 1, j));
+ out.append('?');
+ i = j;
+ continue;
+ }
+ }
+
+ out.append(c);
+ i++;
+ }
+ return new ParsedSql(out.toString(), order);
+ }
+
+ /**
+ * Binds each positional placeholder from {@code order} using the matching
+ * {@code SqlParameter} node in {@code parametersByName}.
+ *
+ * @throws AwsException if a placeholder has no matching parameter value
+ */
+ static void bind(PreparedStatement statement, List<String> order, Map<String, JsonNode> parametersByName)
+ throws SQLException {
+ for (int position = 0; position < order.size(); position++) {
+ String name = order.get(position);
+ JsonNode parameter = parametersByName.get(name);
+ if (parameter == null) {
+ throw new AwsException("BadRequestException",
+ "SQL statement references parameter :" + name
+ + " but no matching value was supplied.", 400);
+ }
+ bindValue(statement, position + 1, name, parameter);
+ }
+ }
+
+ private static void bindValue(PreparedStatement statement, int index, String name, JsonNode parameter)
+ throws SQLException {
+ JsonNode value = parameter.get("value");
+ if (value == null || value.isNull() || value.path("isNull").asBoolean(false)) {
+ statement.setNull(index, Types.NULL);
+ return;
+ }
+ String typeHint = text(parameter, "typeHint");
+
+ if (value.has("booleanValue")) {
+ statement.setBoolean(index, value.get("booleanValue").asBoolean());
+ } else if (value.has("longValue")) {
+ statement.setLong(index, value.get("longValue").asLong());
+ } else if (value.has("doubleValue")) {
+ statement.setDouble(index, value.get("doubleValue").asDouble());
+ } else if (value.has("blobValue")) {
+ statement.setBytes(index, blobBytes(name, value.get("blobValue")));
+ } else if (value.has("arrayValue")) {
+ throw new AwsException("BadRequestException",
+ "arrayValue is not supported for parameter :" + name
+ + " by this local RDS Data API implementation.", 400);
+ } else if (value.has("stringValue")) {
+ bindString(statement, index, name, value.get("stringValue").asText(), typeHint);
+ } else {
+ throw new AwsException("BadRequestException",
+ "Parameter :" + name + " has no supported value field.", 400);
+ }
+ }
+
+ private static void bindString(PreparedStatement statement, int index, String name, String value, String typeHint)
+ throws SQLException {
+ String hint = typeHint == null ? "" : typeHint.toUpperCase(Locale.ROOT);
+ try {
+ switch (hint) {
+ case "DECIMAL" -> statement.setBigDecimal(index, new BigDecimal(value));
+ case "TIMESTAMP" -> statement.setTimestamp(index, Timestamp.valueOf(value));
+ case "DATE" -> statement.setDate(index, Date.valueOf(value));
+ case "TIME" -> statement.setTime(index, Time.valueOf(withoutFractionalSeconds(value)));
+ case "UUID" -> statement.setObject(index, UUID.fromString(value));
+ case "JSON" -> statement.setObject(index, value, Types.OTHER);
+ default -> statement.setString(index, value);
+ }
+ } catch (IllegalArgumentException e) {
+ throw new AwsException("BadRequestException",
+ "Parameter :" + name + " value \"" + value + "\" is not a valid "
+ + hint + " for the supplied typeHint.", 400);
+ }
+ }
+
+ /**
+ * The AWS RDS Data API documents {@code TIME} as {@code HH:MM:SS[.FFF]} with
+ * optional fractional seconds, but {@link Time#valueOf(String)} only accepts
+ * {@code HH:mm:ss} and throws on a fractional part. Drop any fractional
+ * seconds so a documented-valid value is not falsely rejected.
+ */
+ private static String withoutFractionalSeconds(String value) {
+ int dot = value.indexOf('.');
+ return dot < 0 ? value : value.substring(0, dot);
+ }
+
+ private static byte[] blobBytes(String name, JsonNode blob) {
+ try {
+ return blob.binaryValue();
+ } catch (IOException e) {
+ throw new AwsException("BadRequestException",
+ "Parameter :" + name + " blobValue is not valid base64: " + e.getMessage(), 400);
+ }
+ }
+
+ private static int copyQuoted(String sql, int start, char quote, StringBuilder out, boolean backslashEscapes) {
+ int len = sql.length();
+ boolean escapable = backslashEscapes && quote != '`';
+ out.append(quote);
+ int i = start + 1;
+ while (i < len) {
+ char c = sql.charAt(i);
+ out.append(c);
+ if (escapable && c == '\\' && i + 1 < len) {
+ out.append(sql.charAt(i + 1));
+ i += 2;
+ continue;
+ }
+ if (c == quote) {
+ if (i + 1 < len && sql.charAt(i + 1) == quote) {
+ out.append(quote);
+ i += 2;
+ continue;
+ }
+ return i + 1;
+ }
+ i++;
+ }
+ return i;
+ }
+
+ private static int copyDollarQuoted(String sql, int start, StringBuilder out) {
+ int len = sql.length();
+ int tagEnd = start + 1;
+ while (tagEnd < len && isNamePart(sql.charAt(tagEnd))) {
+ tagEnd++;
+ }
+ if (tagEnd >= len || sql.charAt(tagEnd) != '$') {
+ return start;
+ }
+ String tag = sql.substring(start, tagEnd + 1);
+ int close = sql.indexOf(tag, tagEnd + 1);
+ int end = close < 0 ? len : close + tag.length();
+ out.append(sql, start, end);
+ return end;
+ }
+
+ private static boolean isNameStart(char c) {
+ return Character.isLetter(c) || c == '_';
+ }
+
+ private static boolean isNamePart(char c) {
+ return Character.isLetterOrDigit(c) || c == '_';
+ }
+
+ private static String text(JsonNode node, String field) {
+ JsonNode value = node.get(field);
+ return value == null || value.isNull() ? null : value.asText();
+ }
+}
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 a3e44deb54..d9e35110df 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
@@ -10,7 +10,7 @@ import static org.hamcrest.Matchers.equalTo;
class RdsDataControllerIntegrationTest {
@Test
- void executeRejectsSqlParametersWithJsonDataApiError() {
+ void executeRejectsMalformedSqlParametersWithJsonDataApiError() {
given()
.contentType("application/json")
.body("""
@@ -19,7 +19,7 @@ class RdsDataControllerIntegrationTest {
"secretArn": "arn:aws:secretsmanager:us-east-1:000000000000:secret:missing",
"database": "app",
"sql": "select 1",
- "parameters": [{"name": "id", "value": {"longValue": 1}}]
+ "parameters": {"name": "id", "value": {"longValue": 1}}
}
""")
.when()
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 7f7a94daea..ff5cfb30a3 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
@@ -72,6 +72,143 @@ class RdsDataServiceTest {
assertEquals(0L, selectResponse.get("numberOfRecordsUpdated").asLong());
}
+ @Test
+ void bindsSqlParametersThroughPreparedStatements() throws Exception {
+ TestHarness harness = new TestHarness();
+ harness.createTables();
+
+ ObjectNode insert = harness.request("""
+ insert into data_api_items(id, title, score, payload, active, created_at)
+ values (:id, :title, :score, :payload, :active, :created_at)
+ """);
+ ArrayNode insertParams = objectMapper.createArrayNode();
+ insertParams.add(stringParam("id", "p1"));
+ insertParams.add(stringParam("title", "Param"));
+ insertParams.add(longParam("score", 7));
+ insertParams.add(blobParam("payload", new byte[] {9, 8, 7}));
+ insertParams.add(booleanParam("active", true));
+ insertParams.add(hintedStringParam("created_at", "2026-06-09 12:34:56", "TIMESTAMP"));
+ insert.set("parameters", insertParams);
+ ObjectNode insertResponse = harness.service.executeStatement(insert, REGION);
+ assertEquals(1L, insertResponse.get("numberOfRecordsUpdated").asLong());
+
+ ObjectNode select = harness.request(
+ "select title, score, payload, active from data_api_items where id = :id");
+ ArrayNode selectParams = objectMapper.createArrayNode();
+ selectParams.add(stringParam("id", "p1"));
+ select.set("parameters", selectParams);
+ ObjectNode selectResponse = harness.service.executeStatement(select, REGION);
+
+ ArrayNode row = (ArrayNode) selectResponse.get("records").get(0);
+ assertEquals("Param", row.get(0).get("stringValue").asText());
+ assertEquals(7L, row.get(1).get("longValue").asLong());
+ assertArrayEquals(new byte[] {9, 8, 7}, row.get(2).get("blobValue").binaryValue());
+ assertTrue(row.get(3).get("booleanValue").asBoolean());
+ }
+
+ @Test
+ void rejectsSqlParameterWithoutMatchingValue() throws Exception {
+ TestHarness harness = new TestHarness();
+ harness.createTables();
+
+ ObjectNode select = harness.request("select 1 from data_api_items where id = :id");
+ ArrayNode params = objectMapper.createArrayNode();
+ params.add(stringParam("other", "value"));
+ select.set("parameters", params);
+
+ AwsException error = assertThrows(AwsException.class,
+ () -> harness.service.executeStatement(select, REGION));
+ assertEquals("BadRequestException", error.getErrorCode());
+ }
+
+ @Test
+ void rejectsMissingParameterEvenWhenParametersOmitted() throws Exception {
+ TestHarness harness = new TestHarness();
+ harness.createTables();
+
+ ObjectNode select = harness.request("select 1 from data_api_items where id = :id");
+
+ AwsException error = assertThrows(AwsException.class,
+ () -> harness.service.executeStatement(select, REGION));
+ assertEquals("BadRequestException", error.getErrorCode());
+ assertEquals(400, error.getHttpStatus());
+ assertTrue(error.getMessage().contains(":id"));
+ }
+
+ @Test
+ void bindsTimeTypeHintWithOptionalFractionalSeconds() throws Exception {
+ TestHarness harness = new TestHarness();
+ harness.createTables();
+
+ ObjectNode withFraction = harness.request("select cast(:t as time) as t");
+ ArrayNode fractionParams = objectMapper.createArrayNode();
+ fractionParams.add(hintedStringParam("t", "14:30:15.123", "TIME"));
+ withFraction.set("parameters", fractionParams);
+ ObjectNode fractionResponse = harness.service.executeStatement(withFraction, REGION);
+ assertEquals("14:30:15",
+ ((ArrayNode) fractionResponse.get("records").get(0)).get(0).get("stringValue").asText());
+
+ ObjectNode withoutFraction = harness.request("select cast(:t as time) as t");
+ ArrayNode plainParams = objectMapper.createArrayNode();
+ plainParams.add(hintedStringParam("t", "09:05:07", "TIME"));
+ withoutFraction.set("parameters", plainParams);
+ ObjectNode plainResponse = harness.service.executeStatement(withoutFraction, REGION);
+ assertEquals("09:05:07",
+ ((ArrayNode) plainResponse.get("records").get(0)).get(0).get("stringValue").asText());
+ }
+
+ @Test
+ void rejectsMalformedTypeHintValueWithBadRequest() throws Exception {
+ TestHarness harness = new TestHarness();
+ harness.createTables();
+
+ ObjectNode select = harness.request(
+ "select id from data_api_items where created_at = :ts");
+ ArrayNode params = objectMapper.createArrayNode();
+ params.add(hintedStringParam("ts", "not-a-timestamp", "TIMESTAMP"));
+ select.set("parameters", params);
+
+ AwsException error = assertThrows(AwsException.class,
+ () -> harness.service.executeStatement(select, REGION));
+ assertEquals("BadRequestException", error.getErrorCode());
+ assertEquals(400, error.getHttpStatus());
+ assertTrue(error.getMessage().contains(":ts"));
+ }
+
+ @Test
+ void rejectsMalformedUuidTypeHintValueWithBadRequest() throws Exception {
+ TestHarness harness = new TestHarness();
+ harness.createTables();
+
+ ObjectNode select = harness.request("select id from data_api_items where id = :id");
+ ArrayNode params = objectMapper.createArrayNode();
+ params.add(hintedStringParam("id", "not-a-uuid", "UUID"));
+ select.set("parameters", params);
+
+ AwsException error = assertThrows(AwsException.class,
+ () -> harness.service.executeStatement(select, REGION));
+ assertEquals("BadRequestException", error.getErrorCode());
+ assertEquals(400, error.getHttpStatus());
+ }
+
+ @Test
+ void rejectsDuplicateParameterNames() throws Exception {
+ TestHarness harness = new TestHarness();
+ harness.createTables();
+
+ ObjectNode select = harness.request("select 1 from data_api_items where id = :id");
+ ArrayNode params = objectMapper.createArrayNode();
+ params.add(stringParam("id", "first"));
+ params.add(stringParam("id", "second"));
+ select.set("parameters", params);
+
+ AwsException error = assertThrows(AwsException.class,
+ () -> harness.service.executeStatement(select, REGION));
+ assertEquals("BadRequestException", error.getErrorCode());
+ assertEquals(400, error.getHttpStatus());
+ assertTrue(error.getMessage().contains(":id"));
+ }
+
@Test
void commitsRollsBackAndRejectsInvalidTransactionRequests() throws Exception {
TestHarness harness = new TestHarness();
@@ -293,6 +430,40 @@ class RdsDataServiceTest {
return request;
}
+ private ObjectNode stringParam(String name, String value) {
+ ObjectNode param = objectMapper.createObjectNode();
+ param.put("name", name);
+ param.set("value", objectMapper.createObjectNode().put("stringValue", value));
+ return param;
+ }
+
+ private ObjectNode hintedStringParam(String name, String value, String typeHint) {
+ ObjectNode param = stringParam(name, value);
+ param.put("typeHint", typeHint);
+ return param;
+ }
+
+ private ObjectNode longParam(String name, long value) {
+ ObjectNode param = objectMapper.createObjectNode();
+ param.put("name", name);
+ param.set("value", objectMapper.createObjectNode().put("longValue", value));
+ return param;
+ }
+
+ private ObjectNode booleanParam(String name, boolean value) {
+ ObjectNode param = objectMapper.createObjectNode();
+ param.put("name", name);
+ param.set("value", objectMapper.createObjectNode().put("booleanValue", value));
+ return param;
+ }
+
+ private ObjectNode blobParam(String name, byte[] value) {
+ ObjectNode param = objectMapper.createObjectNode();
+ param.put("name", name);
+ param.set("value", objectMapper.createObjectNode().put("blobValue", value));
+ return param;
+ }
+
private static SecretsManagerService fallbackSecrets() {
SecretsManagerService secrets = mock(SecretsManagerService.class);
when(secrets.getSecretValue(any(), any(), any(), any()))
diff --git a/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataSqlParametersTest.java b/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataSqlParametersTest.java
new file mode 100644
index 0000000000..bc9cf0037a
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/rdsdata/RdsDataSqlParametersTest.java
@@ -0,0 +1,93 @@
+package io.github.hectorvent.floci.services.rdsdata;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class RdsDataSqlParametersTest {
+
+ @Test
+ void rewritesNamedPlaceholdersToPositional() {
+ RdsDataSqlParameters.ParsedSql parsed = RdsDataSqlParameters.parse(
+ "select * from t where id = :id and name = :name");
+
+ assertEquals("select * from t where id = ? and name = ?", parsed.sql());
+ assertEquals(List.of("id", "name"), parsed.parameterOrder());
+ }
+
+ @Test
+ void repeatsPlaceholderOncePerOccurrence() {
+ RdsDataSqlParameters.ParsedSql parsed = RdsDataSqlParameters.parse(
+ "select * from t where a = :id or b = :id");
+
+ assertEquals("select * from t where a = ? or b = ?", parsed.sql());
+ assertEquals(List.of("id", "id"), parsed.parameterOrder());
+ }
+
+ @Test
+ void ignoresColonsInsideStringLiteralsAndIdentifiers() {
+ RdsDataSqlParameters.ParsedSql parsed = RdsDataSqlParameters.parse(
+ "select ':notparam', \":col:\", `x:y` from t where id = :id");
+
+ assertEquals("select ':notparam', \":col:\", `x:y` from t where id = ?", parsed.sql());
+ assertEquals(List.of("id"), parsed.parameterOrder());
+ }
+
+ @Test
+ void preservesPostgresCastOperatorAndCastsParameters() {
+ RdsDataSqlParameters.ParsedSql parsed = RdsDataSqlParameters.parse(
+ "select id::text from t where created = :ts::timestamp");
+
+ assertEquals("select id::text from t where created = ?::timestamp", parsed.sql());
+ assertEquals(List.of("ts"), parsed.parameterOrder());
+ }
+
+ @Test
+ void ignoresColonsInsideComments() {
+ RdsDataSqlParameters.ParsedSql parsed = RdsDataSqlParameters.parse(
+ "select 1 -- :nope\n/* :also */ where id = :id");
+
+ assertEquals("select 1 -- :nope\n/* :also */ where id = ?", parsed.sql());
+ assertEquals(List.of("id"), parsed.parameterOrder());
+ }
+
+ @Test
+ void ignoresColonsInsideDollarQuotedStrings() {
+ RdsDataSqlParameters.ParsedSql parsed = RdsDataSqlParameters.parse(
+ "select $tag$ :nope $tag$ where id = :id");
+
+ assertEquals("select $tag$ :nope $tag$ where id = ?", parsed.sql());
+ assertEquals(List.of("id"), parsed.parameterOrder());
+ }
+
+ @Test
+ void treatsBackslashAsEscapeInStringLiteralWhenEnabled() {
+ RdsDataSqlParameters.ParsedSql parsed = RdsDataSqlParameters.parse(
+ "select * from t where note = 'it\\'s a :id' and id = :id", true);
+
+ assertEquals("select * from t where note = 'it\\'s a :id' and id = ?", parsed.sql());
+ assertEquals(List.of("id"), parsed.parameterOrder());
+ }
+
+ @Test
+ void treatsBackslashQuoteAsClosingQuoteWhenEscapesDisabled() {
+ // PostgreSQL default (standard_conforming_strings on): backslash is literal,
+ // so the first unescaped quote closes the literal.
+ RdsDataSqlParameters.ParsedSql parsed = RdsDataSqlParameters.parse(
+ "select 'a\\' as c, :id", false);
+
+ assertEquals("select 'a\\' as c, ?", parsed.sql());
+ assertEquals(List.of("id"), parsed.parameterOrder());
+ }
+
+ @Test
+ void ignoresBackslashInsideBacktickIdentifierEvenWhenEscapesEnabled() {
+ RdsDataSqlParameters.ParsedSql parsed = RdsDataSqlParameters.parse(
+ "select `a\\` , id from t where id = :id", true);
+
+ assertEquals("select `a\\` , id from t where id = ?", parsed.sql());
+ assertEquals(List.of("id"), parsed.parameterOrder());
+ }
+}