Light, fluffy, and always free - The AWS Local Emulator alternative
feat(dynamodb): improve PartiQL grammar coverage (#3798)
TATSUNO “Taz” Yasuhiro82a3c1dbacd8
diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAccessPathValidator.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAccessPathValidator.javaindex 45a5d77d75..e512097e8c 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAccessPathValidator.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAccessPathValidator.java@@ -306,7 +306,7 @@ final class DynamoDbAccessPathValidator {validateCompositeSortKeyConditions(sortKeys, sortKeyEqualities);}- private static String attributeType(TableDefinition table, String attribute) {+ static String attributeType(TableDefinition table, String attribute) {List<AttributeDefinition> definitions = table.getAttributeDefinitions();if (definitions == null) {throw validationException(KEY_TYPE_MISMATCH);diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAttributeValueValidator.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAttributeValueValidator.javaindex b2cb835ed0..81dfce134b 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAttributeValueValidator.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAttributeValueValidator.java@@ -53,13 +53,11 @@ final class DynamoDbAttributeValueValidator {}}- // PartiQL reports the limit with this short wording, and a transaction turns it into a- // cancellation reason.static final String NESTING_EXCEEDED = "Nesting Levels have exceeded supported limits";static void requireParameterNestingWithinLimit(JsonNode value) {- if (!valueNestingWithinLimit(value)) {- throw validationEx(NESTING_EXCEEDED);+ if (depthOf(value) > MAX_NESTING_LEVELS + 1) {+ throw validationEx(NESTING_EXCEEDED + ": Attributes in the item have nested levels beyond supported limit");}}diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandler.javaindex b8995fbb33..03ae79aa88 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandler.java@@ -15,6 +15,7 @@ import jakarta.inject.Inject;import jakarta.ws.rs.core.Response;import java.util.*;+import java.util.function.Supplier;/*** DynamoDB JSON protocol handler.@@ -676,6 +677,7 @@ public class DynamoDbJsonHandler {checkUnusedEan(exprAttrNames, hashTokens);Set<String> colonTokensAll = extractColonTokens(updateExpression, conditionExpression);checkUnusedEav(exprAttrValues, colonTokensAll);+ dynamoDbService.requireAddOrDeleteOperandTypes(updateExpression, exprAttrValues, true);}if (expectedUpd != null) {@@ -1696,6 +1698,8 @@ public class DynamoDbJsonHandler {op.get("ExpressionAttributeNames"),op.get("ExpressionAttributeValues"));DynamoDbAttributeValueValidator.requireNestingWithinLimit(op.get("Item"), false);+ dynamoDbService.requireAddOrDeleteOperandTypes(op.path("UpdateExpression").textValue(),+ op.get("ExpressionAttributeValues"), false);}}@@ -2674,15 +2678,32 @@ public class DynamoDbJsonHandler {if (stmts.isMissingNode() || !stmts.isArray() || stmts.isEmpty()) {throw new AwsException("ValidationException", "TransactStatements must not be empty", 400);}- List<JsonNode> transactItems = new ArrayList<>();try {- cancelOnTooDeepParameters(stmts);- for (JsonNode s : stmts) {- DynamoDbPartiQLParser.Stmt stmt = DynamoDbPartiQLParser.parse(- s.path("Statement").asText(), toPartiQLParams(s.path("Parameters")));- transactItems.add(partiQLHandler.toTransactItem(stmt, region));+ List<DynamoDbPartiQLParser.Stmt> statements = new ArrayList<>();+ for (int i = 0; i < stmts.size(); i++) {+ JsonNode s = stmts.get(i);+ List<JsonNode> parameters = toPartiQLParams(s.path("Parameters"));+ statements.add(inTransactStatement(i,+ () -> DynamoDbPartiQLParser.parse(s.path("Statement").asText(), parameters)));+ }+ long reads = statements.stream().filter(DynamoDbPartiQLParser.Stmt.Select.class::isInstance).count();+ if (reads > 0 && reads < statements.size()) {+ throw new AwsException("ValidationException",+ "ExecuteTransaction API does not support both read and write operations in the same request.", 400);+ }+ if (reads == statements.size()) {+ return executeTransactionReads(statements.stream()+ .map(DynamoDbPartiQLParser.Stmt.Select.class::cast)+ .toList(), region);+ }+ List<DynamoDbPartiQLHandler.TransactMember> members = new ArrayList<>();+ for (int i = 0; i < statements.size(); i++) {+ DynamoDbPartiQLParser.Stmt stmt = statements.get(i);+ members.add(inTransactStatement(i, () -> partiQLHandler.toTransactItem(stmt, region)));}- dynamoDbService.transactWriteItems(transactItems, region);+ List<JsonNode> transactItems = cancelOnMemberReasons(members);+ dynamoDbService.transactWriteItems(transactItems, region,+ request.path("ClientRequestToken").asText(null), request);ObjectNode resp = objectMapper.createObjectNode();resp.set("Responses", objectMapper.createArrayNode());return Response.ok(resp).build();@@ -2694,8 +2715,9 @@ public class DynamoDbJsonHandler {for (TransactionCanceledException.CancellationReason reason : e.getCancellationReasons()) {ObjectNode r = objectMapper.createObjectNode();r.put("Code", reason.code().isEmpty() ? "None" : reason.code());- r.put("Message", reason.code().isEmpty() ? ""- : reason.message() != null ? reason.message() : "The conditional request failed");+ if (!reason.code().isEmpty()) {+ r.put("Message", reason.message() != null ? reason.message() : "The conditional request failed");+ }if (reason.item() != null) {r.set("Item", reason.item());}@@ -2705,24 +2727,69 @@ public class DynamoDbJsonHandler {}}- // AWS cancels the transaction, with that statement's reason, when a parameter is too deep.- private void cancelOnTooDeepParameters(JsonNode stmts) {- var reasons = new ArrayList<TransactionCanceledException.CancellationReason>();- var cancelled = false;- for (JsonNode s : stmts) {- var tooDeep = false;- for (var parameter : s.path("Parameters")) {- tooDeep |= !DynamoDbAttributeValueValidator.valueNestingWithinLimit(parameter);+ private Response executeTransactionReads(List<DynamoDbPartiQLParser.Stmt.Select> selects, String region) {+ List<DynamoDbPartiQLHandler.TransactMember> members = new ArrayList<>();+ for (int i = 0; i < selects.size(); i++) {+ DynamoDbPartiQLParser.Stmt.Select select = selects.get(i);+ members.add(inTransactStatement(i, () -> partiQLHandler.toTransactGetItem(select, region)));+ }+ List<JsonNode> getItems = cancelOnMemberReasons(members);++ List<JsonNode> results = dynamoDbService.transactGetItems(getItems, region);+ requireOneReadPerItem(getItems, region);+ ArrayNode responses = objectMapper.createArrayNode();+ for (int i = 0; i < results.size(); i++) {+ JsonNode item = partiQLHandler.projectSelected(selects.get(i), results.get(i));+ ObjectNode entry = objectMapper.createObjectNode();+ if (item != null) {+ entry.set("Item", item);}- cancelled |= tooDeep;- reasons.add(tooDeep- ? new TransactionCanceledException.CancellationReason("ValidationError", null,- DynamoDbAttributeValueValidator.NESTING_EXCEEDED)- : new TransactionCanceledException.CancellationReason("", null));+ responses.add(entry);+ }+ ObjectNode resp = objectMapper.createObjectNode();+ resp.set("Responses", responses);+ return Response.ok(resp).build();+ }++ private static List<JsonNode> cancelOnMemberReasons(List<DynamoDbPartiQLHandler.TransactMember> members) {+ List<JsonNode> items = new ArrayList<>();+ List<TransactionCanceledException.CancellationReason> reasons = new ArrayList<>();+ boolean cancelled = false;+ for (DynamoDbPartiQLHandler.TransactMember member : members) {+ cancelled |= member.reason() != null;+ items.add(member.item());+ reasons.add(member.reason() != null ? member.reason() : new TransactionCanceledException.CancellationReason("", null));}if (cancelled) {throw new TransactionCanceledException(reasons);}+ return items;+ }++ private void requireOneReadPerItem(List<JsonNode> getItems, String region) {+ Set<List<String>> items = new HashSet<>();+ for (JsonNode getItem : getItems) {+ JsonNode get = getItem.path("Get");+ String tableName = get.path("TableName").asText();+ TableDefinition table = dynamoDbService.findTable(tableName, region).orElseThrow();+ String itemKey = dynamoDbService.buildItemKey(table, get.path("Key"), true);+ if (!items.add(List.of(tableName, itemKey))) {+ throw new AwsException("ValidationException",+ "Transaction request cannot include multiple operations on one item", 400);+ }+ }+ }++ private <T> T inTransactStatement(int index, Supplier<T> member) {+ try {+ return member.get();+ } catch (AwsException e) {+ if (!"ValidationException".equals(e.getErrorCode())) {+ throw e;+ }+ throw new AwsException("ValidationException",+ "Validation failed in TransactStatements[" + index + "]: " + e.getMessage(), 400);+ }}private Response handleBatchExecuteStatement(JsonNode request, String region) {@@ -2732,60 +2799,79 @@ public class DynamoDbJsonHandler {}ArrayNode responses = objectMapper.createArrayNode();for (JsonNode s : stmts) {- try {- DynamoDbPartiQLParser.Stmt stmt = DynamoDbPartiQLParser.parse(- s.path("Statement").asText(), toPartiQLParams(s.path("Parameters")));- if (stmt instanceof DynamoDbPartiQLParser.Stmt.Select select- && !batchSelectResolvesThroughPrimaryKey(select, region)) {- throw new AwsException("ValidationError",- "Select statements within BatchExecuteStatement must specify the primary key "- + "in the where clause.", 400);- }- JsonNode result = partiQLHandler.execute(stmt, PartiQLExecuteContext.builder()- .consistentRead(s.path("ConsistentRead").asBoolean(false)), region);- ObjectNode slot = objectMapper.createObjectNode();- JsonNode firstItem = result.path("Items").path(0);- if (!firstItem.isMissingNode()) {- slot.set("Item", firstItem);- }- responses.add(slot);- } catch (AwsException e) {- ObjectNode slot = objectMapper.createObjectNode();- ObjectNode err = objectMapper.createObjectNode();- err.put("Code", e.getErrorCode());- err.put("Message", e.getMessage());- slot.set("Error", err);- responses.add(slot);- }+ responses.add(batchMemberResponse(s, region));}ObjectNode resp = objectMapper.createObjectNode();resp.set("Responses", responses);return Response.ok(resp).build();}+ private ObjectNode batchMemberResponse(JsonNode statement, String region) {+ ObjectNode slot = objectMapper.createObjectNode();+ String tableName = null;+ try {+ DynamoDbPartiQLParser.Stmt stmt = parsePartiQLStatement(statement);+ tableName = stmt.table();+ if (stmt instanceof DynamoDbPartiQLParser.Stmt.Select select) {+ requireBatchSelectReadsByKey(select, region);+ }+ JsonNode result = partiQLHandler.execute(stmt, PartiQLExecuteContext.builder()+ .consistentRead(statement.path("ConsistentRead").asBoolean(false)), region);+ JsonNode firstItem = result.path("Items").path(0);+ if (!firstItem.isMissingNode()) {+ slot.set("Item", firstItem);+ }+ slot.put("TableName", tableName);+ } catch (AwsException e) {+ ObjectNode err = objectMapper.createObjectNode();+ err.put("Code", batchMemberErrorCode(e.getErrorCode()));+ err.put("Message", e.getMessage());+ slot.set("Error", err);+ if (tableName != null && batchMemberReachedItsTable(e)) {+ slot.put("TableName", tableName);+ }+ }+ return slot;+ }++ private static String batchMemberErrorCode(String errorCode) {+ if ("ValidationException".equals(errorCode)) {+ return "ValidationError";+ }+ return errorCode.endsWith("Exception")+ ? errorCode.substring(0, errorCode.length() - "Exception".length())+ : errorCode;+ }++ private static boolean batchMemberReachedItsTable(AwsException e) {+ return e instanceof ItemNestingExceededException+ || "ConditionalCheckFailedException".equals(e.getErrorCode())+ || "DuplicateItemException".equals(e.getErrorCode());+ }+// BatchExecuteStatement only runs SELECT statements that resolve through// the table's primary key: index-qualified statements and partial-key// WHERE clauses are rejected per statement (characterised on real AWS,// eu-west-1, 2026-09-02).- private boolean batchSelectResolvesThroughPrimaryKey(DynamoDbPartiQLParser.Stmt.Select select, String region) {+ private void requireBatchSelectReadsByKey(DynamoDbPartiQLParser.Stmt.Select select, String region) {if (select.index() != null) {- return false;+ throw batchSelectNeedsKey();}TableDefinition table = dynamoDbService.describeTable(select.table(), region);- String pkName = table.getPartitionKeyName();- String skName = table.getSortKeyName();- boolean pkEq = false;- boolean skEq = skName == null;- for (DynamoDbPartiQLParser.Cond c : select.where()) {- if (c instanceof DynamoDbPartiQLParser.Cond.Eq eq) {- if (eq.attr().equals(pkName)) {- pkEq = true;- } else if (skName != null && eq.attr().equals(skName)) {- skEq = true;- }- }+ DynamoDbPartiQLHandler.requireReadsWithinLimit(table, select.where());+ if (!DynamoDbPartiQLHandler.namesOnlyTheKey(table, select.where())) {+ throw batchSelectNeedsKey();}- return pkEq && skEq;+ }++ private static AwsException batchSelectNeedsKey() {+ return new AwsException("ValidationException",+ "Select statements within BatchExecuteStatement must specify the primary key in the where clause.", 400);+ }++ private DynamoDbPartiQLParser.Stmt parsePartiQLStatement(JsonNode statement) {+ return DynamoDbPartiQLParser.parse(statement.path("Statement").asText(),+ toPartiQLParams(statement.path("Parameters")));}private List<JsonNode> toPartiQLParams(JsonNode node) {@@ -2793,7 +2879,11 @@ public class DynamoDbJsonHandler {return Collections.emptyList();}List<JsonNode> params = new ArrayList<>();- node.forEach(params::add);+ for (JsonNode parameter : node) {+ DynamoDbAttributeValueValidator.requireParameterNestingWithinLimit(parameter);+ checkAttrSets(parameter);+ params.add(parameter);+ }return params;}}diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLHandler.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLHandler.javaindex 7f0b73fb89..84f03fb608 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLHandler.java@@ -8,6 +8,7 @@ import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.dynamodb.DynamoDbPartiQLParser.*;import io.github.hectorvent.floci.services.dynamodb.model.ConditionalCheckFailedException;+import io.github.hectorvent.floci.services.dynamodb.model.KeySchemaElement;import io.github.hectorvent.floci.services.dynamodb.model.TableDefinition;import java.nio.charset.StandardCharsets;@@ -15,6 +16,8 @@ import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;import java.util.*;import java.util.Base64;+import java.util.function.Supplier;+import java.util.stream.Collectors;class DynamoDbPartiQLHandler {@@ -32,6 +35,8 @@ class DynamoDbPartiQLHandler {case Stmt.Insert s -> executeInsert(s, region);case Stmt.Update s -> executeUpdate(s, region);case Stmt.Delete s -> executeDelete(s, region);+ case Stmt.Exists ignored -> throw new AwsException("ValidationException",+ "EXISTS can only be used in ExecuteTransaction write requests.", 400);};}@@ -56,9 +61,11 @@ class DynamoDbPartiQLHandler {// projects; the message preserves statement order (characterised on// real AWS, eu-west-1, 2026-09-02). An LSI read reaches the co-located// base item, so non-projected columns stay legal there.- if (accessPath.isGlobalSecondaryIndex() && !"ALL".equals(accessPath.projectionType())) {+ if (accessPath.isGlobalSecondaryIndex() && !"ALL".equals(accessPath.projectionType())+ && !stmt.columns().isEmpty()) {Set<String> projected = accessPath.projectedAttributeNames(table);List<String> unprojected = stmt.columns().stream()+ .map(Path::root).filter(c -> !"*".equals(c)).filter(c -> !projected.contains(c)).toList();@@ -70,30 +77,87 @@ class DynamoDbPartiQLHandler {}}- String pkName = accessPath.partitionKeyName();- String skName = accessPath.sortKeyName();+ DynamoDbPartiQLKeyPlan keys = new DynamoDbPartiQLKeyPlan(stmt.where(), accessPath, table);+ keys.requireKeyTypesMatchSchema();+ keys.requireNoOverlap();+ keys.requireReadsWithinLimit();+ requireFilterAttributesProjected(keys, accessPath, table);++ Routing routing = routingOf(stmt.where(), keys, accessPath.partitionKeyName(), accessPath.sortKeyName());+ Supplier<JsonNode> startKey = () -> decodeNextToken(ctx.nextToken(), ctx.tokenBinding());+ Page page = stmt.orderBy().isEmpty()+ ? readPage(stmt, table, accessPath, routing, startKey, ctx.limit(), region)+ : readOrdered(stmt, table, accessPath, routing, startKey.get(), ctx.limit(), region);+ List<JsonNode> items = page.items();+ JsonNode lastEvaluatedKey = page.lastEvaluatedKey();++ // Apply column projection for non-* SELECT. Projects against the full+ // item: an LSI read can reach attributes outside the index projection+ // (characterised on real AWS, eu-west-1, 2026-09-02).+ if (!stmt.columns().isEmpty()) {+ List<SelectedColumn> columns = selectedColumns(stmt);+ items = items.stream()+ .map(item -> (JsonNode) selectColumns(item, columns))+ .toList();+ }++ // SELECT * over an index reads the projection, not the whole item. An+ // ALL projection stores every base attribute, so nothing is trimmed.+ if (stmt.columns().isEmpty() && accessPath.isIndex()+ && !"ALL".equals(accessPath.projectionType())) {+ Set<String> projected = accessPath.projectedAttributeNames(table);+ items = items.stream()+ .map(item -> (JsonNode) ProjectionEvaluator.trimToAttributes((ObjectNode) item, projected))+ .toList();+ }++ ArrayNode arr = mapper.createArrayNode();+ items.forEach(arr::add);+ ObjectNode resp = mapper.createObjectNode();+ resp.set("Items", arr);+ if (lastEvaluatedKey != null) {+ resp.put("NextToken", encodeNextToken(lastEvaluatedKey, ctx.tokenBinding()));+ }+ return resp;+ }++ private record Routing(Cond.Eq pkEq, Cond skCond, List<Cond> filterConds, PVal partition) {}+ private static Routing routingOf(List<Cond> where, DynamoDbPartiQLKeyPlan keys, String pkName, String skName) {+ Optional<PVal> partition = keys.singlePartition();+ if (partition.isEmpty()) {+ return new Routing(null, null, where, null);+ }Cond.Eq pkEq = null;Cond skCond = null;List<Cond> filterConds = new ArrayList<>();-- for (Cond c : stmt.where()) {- String attr = condAttr(c);- if (pkName.equals(attr)) {- if (c instanceof Cond.Eq eq) {- pkEq = eq;- } else {- filterConds.add(c);- }- } else if (skName != null && skName.equals(attr)) {+ for (Cond c : where) {+ if (c instanceof Cond.Eq eq && isKeyCondition(eq, pkName)) {+ pkEq = eq;+ } else if (skCond == null && DynamoDbPartiQLKeyPlan.isSortKeyRange(c, skName)) {skCond = c;+ } else if (DynamoDbPartiQLKeyPlan.attributePaths(c).map(Path::root)+ .anyMatch(root -> root.equals(pkName) || root.equals(skName))) {+ return new Routing(null, null, where, partition.get());} else {filterConds.add(c);}}+ return new Routing(pkEq, skCond, filterConds, null);+ }- List<JsonNode> items;- JsonNode lastEvaluatedKey = null;+ private record Page(List<JsonNode> items, JsonNode lastEvaluatedKey) {}++ private Page readPage(Stmt.Select stmt, TableDefinition table, DynamoDbAccessPath accessPath,+ Routing routing, Supplier<JsonNode> startKey, Integer limit, String region) {+ if (routing.partition() != null) {+ return readPartition(stmt, table, accessPath, routing, startKey, limit, region);+ }+ String pkName = accessPath.partitionKeyName();+ String skName = accessPath.sortKeyName();+ Cond.Eq pkEq = routing.pkEq();+ Cond skCond = routing.skCond();+ List<Cond> filterConds = routing.filterConds();if (pkEq == null) {// No equality on the selected source's partition key: AWS performs@@ -107,68 +171,151 @@ class DynamoDbPartiQLHandler {scanFilters.add(skCond);}String fe = buildFe(scanFilters, eav, ean);- JsonNode exclusiveStartKey = decodeNextToken(ctx.nextToken(), ctx.tokenBinding());+ JsonNode exclusiveStartKey = startKey.get();DynamoDbAccessPathValidator.validateExclusiveStartKey(exclusiveStartKey, table, accessPath, true);DynamoDbService.ScanResult result = service.scan(stmt.table(), fe,ean.isEmpty() ? null : ean.toNode(mapper),eav.isEmpty() ? null : eav.toNode(mapper),- null, ctx.limit(), exclusiveStartKey, accessPath.indexName(), region);- items = result.items();- lastEvaluatedKey = result.lastEvaluatedKey();- } else if (accessPath.kind() == DynamoDbAccessPath.Kind.TABLE && skName == null+ null, limit, exclusiveStartKey, accessPath.indexName(), region);+ return new Page(result.items(), result.lastEvaluatedKey());+ }+ if (accessPath.kind() == DynamoDbAccessPath.Kind.TABLE && skName == null&& skCond == null && filterConds.isEmpty()) {ObjectNode key = mapper.createObjectNode();key.set(pkName, toTypedNode(pkEq.val()));JsonNode item = service.getItem(stmt.table(), key, region);- items = item != null ? List.of(item) : Collections.emptyList();- } else {- ExprAttrBuilder eav = new ExprAttrBuilder();- ExprAttrNameBuilder ean = new ExprAttrNameBuilder();- String kce = buildKce(pkEq, skCond, pkName, skName, eav, ean);- String fe = buildFe(filterConds, eav, ean);- JsonNode exclusiveStartKey = decodeNextToken(ctx.nextToken(), ctx.tokenBinding());- DynamoDbAccessPathValidator.validateExclusiveStartKey(exclusiveStartKey, table, accessPath, false);- DynamoDbService.QueryResult result = service.query(- stmt.table(), null, eav.toNode(mapper), kce, fe,- ctx.limit(), null, accessPath.indexName(), exclusiveStartKey,- ean.isEmpty() ? null : ean.toNode(mapper), region);- items = result.items();- lastEvaluatedKey = result.lastEvaluatedKey();+ return new Page(item != null ? List.of(item) : Collections.emptyList(), null);}+ ExprAttrBuilder eav = new ExprAttrBuilder();+ ExprAttrNameBuilder ean = new ExprAttrNameBuilder();+ String kce = buildKce(pkEq, skCond, pkName, skName, eav, ean);+ String fe = buildFe(filterConds, eav, ean);+ JsonNode exclusiveStartKey = startKey.get();+ DynamoDbAccessPathValidator.validateExclusiveStartKey(exclusiveStartKey, table, accessPath, false);+ DynamoDbService.QueryResult result = service.query(+ stmt.table(), null, eav.toNode(mapper), kce, fe,+ limit, null, accessPath.indexName(), exclusiveStartKey,+ ean.isEmpty() ? null : ean.toNode(mapper), region);+ return new Page(result.items(), result.lastEvaluatedKey());+ }- // Apply column projection for non-* SELECT. Projects against the full- // item: an LSI read can reach attributes outside the index projection- // (characterised on real AWS, eu-west-1, 2026-09-02).- if (!stmt.columns().isEmpty()) {- ExprAttrNameBuilder projEan = new ExprAttrNameBuilder();- String proj = stmt.columns().stream()- .map(projEan::alias)- .reduce((a, b) -> a + "," + b)- .orElse("");- ObjectNode eanNode = projEan.isEmpty() ? null : projEan.toNode(mapper);- items = items.stream()- .map(item -> (JsonNode) ProjectionEvaluator.project(item, proj, eanNode))- .toList();+ private Page readPartition(Stmt.Select stmt, TableDefinition table, DynamoDbAccessPath accessPath,+ Routing routing, Supplier<JsonNode> startKey, Integer limit, String region) {+ ExprAttrBuilder eav = new ExprAttrBuilder();+ ExprAttrNameBuilder ean = new ExprAttrNameBuilder();+ String kce = ean.alias(accessPath.partitionKeyName()) + " = " + eav.add(toTypedNode(routing.partition()));+ JsonNode exclusiveStartKey = startKey.get();+ DynamoDbAccessPathValidator.validateExclusiveStartKey(exclusiveStartKey, table, accessPath, false);+ DynamoDbService.QueryResult result = service.query(stmt.table(), null, eav.toNode(mapper), kce, null,+ limit, null, accessPath.indexName(), exclusiveStartKey, ean.toNode(mapper), region);+ ExprAttrBuilder filterValues = new ExprAttrBuilder();+ ExprAttrNameBuilder filterNames = new ExprAttrNameBuilder();+ ExpressionEvaluator.Expr filter = ExpressionEvaluator.parse(buildFe(routing.filterConds(), filterValues, filterNames));+ JsonNode names = filterNames.isEmpty() ? null : filterNames.toNode(mapper);+ JsonNode values = filterValues.isEmpty() ? null : filterValues.toNode(mapper);+ List<JsonNode> matching = result.items().stream()+ .filter(item -> ExpressionEvaluator.evaluate(filter, item, names, values))+ .toList();+ return new Page(matching, result.lastEvaluatedKey());+ }++ private Page readOrdered(Stmt.Select stmt, TableDefinition table, DynamoDbAccessPath accessPath,+ Routing routing, JsonNode after, Integer limit, String region) {+ requireOrderByShape(stmt, accessPath);+ List<JsonNode> rows = new ArrayList<>();+ JsonNode lastKey = null;+ do {+ JsonNode from = lastKey;+ Page page = readPage(stmt, table, accessPath, routing, () -> from, null, region);+ rows.addAll(page.items());+ lastKey = page.lastEvaluatedKey();+ } while (lastKey != null);++ Comparator<JsonNode> order = orderByComparator(stmt.orderBy(), accessPath, table);+ rows.sort(order);+ int start = 0;+ if (after != null) {+ while (start < rows.size() && order.compare(rows.get(start), after) <= 0) {+ start++;+ }}+ int end = limit == null ? rows.size() : Math.min(rows.size(), start + limit);+ JsonNode resumeAfter = start < end && end < rows.size() ? orderingKey(rows.get(end - 1), accessPath, table) : null;+ return new Page(new ArrayList<>(rows.subList(start, end)), resumeAfter);+ }- // SELECT * over an index reads the projection, not the whole item. An- // ALL projection stores every base attribute, so nothing is trimmed.- if (stmt.columns().isEmpty() && accessPath.isIndex()- && !"ALL".equals(accessPath.projectionType())) {- Set<String> projected = accessPath.projectedAttributeNames(table);- items = items.stream()- .map(item -> (JsonNode) ProjectionEvaluator.trimToAttributes((ObjectNode) item, projected))- .toList();+ private static void requireOrderByShape(Stmt.Select stmt, DynamoDbAccessPath accessPath) {+ if (stmt.where().isEmpty()) {+ throw new AwsException("ValidationException",+ "Must have WHERE clause in the statement when using ORDER BY clause.", 400);+ }+ Set<String> keys = accessPath.keyAttributeNames();+ for (OrderTerm term : stmt.orderBy()) {+ if (!keys.contains(term.attribute())) {+ throw new AwsException("ValidationException",+ "Attribute " + term.attribute() + " in ORDER BY clause must be part of the primary key", 400);+ }+ }+ String pkName = accessPath.partitionKeyName();+ int hashKeyConditions = stmt.where().stream().mapToInt(c -> hashKeyConditionCount(c, pkName)).sum();+ if (hashKeyConditions == 0) {+ throw new AwsException("ValidationException",+ "Must have at least one non-optional hash key condition in WHERE clause when using ORDER BY clause.",+ 400);+ }+ boolean ordersByHashKey = stmt.orderBy().stream().anyMatch(term -> term.attribute().equals(pkName));+ if (hashKeyConditions > 1 && !ordersByHashKey) {+ throw new AwsException("ValidationException",+ "Must have hash key in ORDER BY clause when more than one hash key condition specified in WHERE clause.",+ 400);}+ }- ArrayNode arr = mapper.createArrayNode();- items.forEach(arr::add);- ObjectNode resp = mapper.createObjectNode();- resp.set("Items", arr);- if (lastEvaluatedKey != null) {- resp.put("NextToken", encodeNextToken(lastEvaluatedKey, ctx.tokenBinding()));+ private static int hashKeyConditionCount(Cond cond, String pkName) {+ return switch (cond) {+ case Cond.Eq eq when isKeyCondition(eq, pkName) -> 1;+ case Cond.In in when isKeyCondition(in, pkName) -> in.values().size();+ case Cond.Or or when or.operands().stream()+ .allMatch(o -> o instanceof Cond.Eq && isKeyCondition(o, pkName)) -> or.operands().size();+ default -> 0;+ };+ }++ private static Comparator<JsonNode> orderByComparator(List<OrderTerm> terms, DynamoDbAccessPath accessPath,+ TableDefinition table) {+ String pkName = accessPath.partitionKeyName();+ String skName = accessPath.sortKeyName();+ boolean pkDescending = directionOf(terms, pkName).orElse(false);+ Comparator<JsonNode> order = byAttribute(pkName, pkDescending);+ if (skName != null) {+ order = order.thenComparing(byAttribute(skName, directionOf(terms, skName).orElse(true)));}- return resp;+ for (String tableKey : List.of(table.getPartitionKeyName(), Objects.toString(table.getSortKeyName(), ""))) {+ if (!tableKey.isEmpty() && !tableKey.equals(pkName) && !tableKey.equals(skName)) {+ order = order.thenComparing(byAttribute(tableKey, false));+ }+ }+ return order;+ }++ private static Optional<Boolean> directionOf(List<OrderTerm> terms, String attribute) {+ return terms.stream().filter(term -> term.attribute().equals(attribute)).findFirst().map(OrderTerm::descending);+ }++ private static Comparator<JsonNode> byAttribute(String attribute, boolean descending) {+ Comparator<JsonNode> ascending = (a, b) -> ExpressionEvaluator.compareAttributeValues(a.path(attribute), b.path(attribute));+ return descending ? ascending.reversed() : ascending;+ }++ private JsonNode orderingKey(JsonNode row, DynamoDbAccessPath accessPath, TableDefinition table) {+ ObjectNode key = mapper.createObjectNode();+ Set<String> names = new LinkedHashSet<>(accessPath.keyAttributeNames());+ names.add(table.getPartitionKeyName());+ if (table.getSortKeyName() != null) {+ names.add(table.getSortKeyName());+ }+ names.forEach(name -> key.set(name, row.get(name)));+ return key;}// NextToken is opaque to the client, so it carries a digest binding it to@@ -239,22 +386,89 @@ class DynamoDbPartiQLHandler {private String buildCondExpr(Cond c, ExprAttrBuilder eav, ExprAttrNameBuilder ean) {return switch (c) {- case Cond.Eq eq -> ean.alias(eq.attr()) + " = " + eav.add(toTypedNode(eq.val()));- case Cond.Cmp cmp -> ean.alias(cmp.attr()) + " " + cmp.op() + " " + eav.add(toTypedNode(cmp.val()));+ case Cond.Eq eq -> ean.alias(eq.path()) + " = " + eav.add(toTypedNode(eq.val()));+ case Cond.Cmp cmp -> ean.alias(cmp.path()) + " " + cmp.op() + " " + eav.add(toTypedNode(cmp.val()));case Cond.Between b ->- ean.alias(b.attr()) + " BETWEEN " + eav.add(toTypedNode(b.lo())) + " AND " + eav.add(toTypedNode(b.hi()));+ ean.alias(b.path()) + " BETWEEN " + eav.add(toTypedNode(b.lo())) + " AND " + eav.add(toTypedNode(b.hi()));case Cond.BeginsWith bw ->- "begins_with(" + ean.alias(bw.attr()) + ", " + eav.add(toTypedNode(bw.prefix())) + ")";+ "begins_with(" + ean.alias(bw.path()) + ", " + eav.add(toTypedNode(bw.prefix())) + ")";+ case Cond.In in -> ean.alias(in.path()) + " IN (" + in.values().stream()+ .map(v -> eav.add(toTypedNode(v)))+ .collect(Collectors.joining(", ")) + ")";+ case Cond.Missing m ->+ (m.negated() ? "attribute_exists(" : "attribute_not_exists(") + ean.alias(m.path()) + ")";+ case Cond.Contains ct ->+ "contains(" + ean.alias(ct.path()) + ", " + eav.add(toTypedNode(ct.operand())) + ")";+ case Cond.AttributeType at ->+ "attribute_type(" + ean.alias(at.path()) + ", " + eav.add(toTypedNode(at.type())) + ")";+ case Cond.SizeCmp sc ->+ "size(" + ean.alias(sc.path()) + ") " + sc.op() + " " + eav.add(toTypedNode(sc.val()));+ case Cond.IsNull isNull -> (isNull.negated() ? "NOT " : "") + "attribute_type(" + ean.alias(isNull.path())+ + ", " + eav.add(mapper.createObjectNode().put("S", "NULL")) + ")";+ case Cond.And and -> joinOperands(and.operands(), " AND ", eav, ean);+ case Cond.Or or -> joinOperands(or.operands(), " OR ", eav, ean);+ case Cond.Not not -> "NOT (" + buildCondExpr(not.operand(), eav, ean) + ")";};}- private static String condAttr(Cond c) {- return switch (c) {- case Cond.Eq eq -> eq.attr();- case Cond.Cmp cmp -> cmp.attr();- case Cond.Between b -> b.attr();- case Cond.BeginsWith bw -> bw.attr();- };+ private String joinOperands(List<Cond> operands, String separator,+ ExprAttrBuilder eav, ExprAttrNameBuilder ean) {+ return "(" + operands.stream()+ .map(operand -> buildCondExpr(operand, eav, ean))+ .collect(Collectors.joining(separator)) + ")";+ }++ private static void requireFilterAttributesProjected(DynamoDbPartiQLKeyPlan keys, DynamoDbAccessPath accessPath,+ TableDefinition table) {+ if (!accessPath.isIndex() || "ALL".equals(accessPath.projectionType())) {+ return;+ }+ List<String> unprojected = keys.unprojectedFilterAttributes(accessPath.projectedAttributeNames(table));+ if (!unprojected.isEmpty()) {+ throw new AwsException("ValidationException",+ "One or more parameter values were invalid: Secondary index "+ + accessPath.indexName()+ + " does not project one or more filter attributes: ["+ + String.join(", ", unprojected) + "]", 400);+ }+ }++ private static boolean isKeyCondition(Cond cond, String keyName) {+ return cond.bareAttribute().filter(keyName::equals).isPresent();+ }++ private record SelectedColumn(Path path, String reportedName) {}++ private static List<SelectedColumn> selectedColumns(Stmt.Select stmt) {+ return stmt.columns().stream()+ .map(column -> new SelectedColumn(column, column.leafName()))+ .toList();+ }++ private ObjectNode selectColumns(JsonNode item, List<SelectedColumn> columns) {+ ObjectNode projected = mapper.createObjectNode();+ for (SelectedColumn column : columns) {+ JsonNode value = resolvePath(item, column.path());+ if (value != null && !value.isMissingNode()) {+ projected.set(column.reportedName(), value);+ }+ }+ return projected;+ }++ private JsonNode resolvePath(JsonNode item, Path path) {+ List<Seg> segments = path.segments();+ JsonNode current = item.get(((Seg.Name) segments.getFirst()).value());+ for (int i = 1; i < segments.size() && current != null; i++) {+ current = switch (segments.get(i)) {+ case Seg.Name name -> current.path("M").get(name.value());+ case Seg.Index index -> {+ JsonNode list = current.path("L");+ yield index.value() < list.size() ? list.get((int) index.value()) : null;+ }+ };+ }+ return current;}// --- INSERT ---@@ -271,54 +485,108 @@ class DynamoDbPartiQLHandler {} catch (ConditionalCheckFailedException e) {throw new AwsException("DuplicateItemException", "Duplicate primary key exists in table", 400);}- return emptyItemsResponse();+ return itemsResponse(null);}// --- UPDATE ---private JsonNode executeUpdate(Stmt.Update stmt, String region) {+ requireNoIndexQualifier(stmt.index());TableDefinition table = service.describeTable(stmt.table(), region);+ requireOneValuePerKey(table, stmt.where());ObjectNode key = buildKey(table, stmt.where());ExprAttrBuilder eav = new ExprAttrBuilder();ExprAttrNameBuilder ean = new ExprAttrNameBuilder();- StringBuilder ue = new StringBuilder();- if (!stmt.sets().isEmpty()) {- ue.append("SET ");- List<String> parts = new ArrayList<>();- for (Assign a : stmt.sets()) {- parts.add(ean.alias(a.attr()) + " = " + eav.add(toTypedNode(a.val())));- }- ue.append(String.join(", ", parts));- }- if (!stmt.removes().isEmpty()) {- if (!ue.isEmpty()) ue.append(" ");- ue.append("REMOVE ");- ue.append(stmt.removes().stream().map(ean::alias).reduce((a, b) -> a + ", " + b).orElse(""));- }+ String ue = buildUpdateExpression(stmt.sets(), stmt.removes(), eav, ean);+ String ce = updateCondition(table, stmt.where(), eav, ean);+ String returnValues = stmt.returning().returnValues();- service.updateItem(stmt.table(), key, null, ue.toString(),+ DynamoDbService.UpdateResult result = service.updateItem(stmt.table(), key, null, ue,ean.isEmpty() ? null : ean.toNode(mapper),- eav.isEmpty() ? null : eav.toNode(mapper), "NONE", region);- return emptyItemsResponse();+ eav.isEmpty() ? null : eav.toNode(mapper), returnValues, ce, region, "NONE");+ return itemsResponse(returnedAttributes(stmt.returning(), result));+ }++ private static void requireNoIndexQualifier(String index) {+ if (index != null) {+ throw new AwsException("ValidationException",+ "This operation is not supported on an index", 400);+ }+ }++ private static Returning returningOf(Stmt stmt) {+ return switch (stmt) {+ case Stmt.Update upd -> upd.returning();+ case Stmt.Delete del -> del.returning();+ case Stmt.Select ignored -> Returning.NONE;+ case Stmt.Insert ignored -> Returning.NONE;+ case Stmt.Exists ignored -> Returning.NONE;+ };+ }++ private JsonNode returnedAttributes(Returning returning, DynamoDbService.UpdateResult result) {+ return switch (returning) {+ case NONE -> null;+ case ALL_OLD -> result.oldItem();+ case ALL_NEW -> result.newItem();+ case MODIFIED_OLD -> DynamoDbUpdatedAttributes.collect(result.touched(), false);+ case MODIFIED_NEW -> DynamoDbUpdatedAttributes.collect(result.touched(), true);+ };}// --- DELETE ---private JsonNode executeDelete(Stmt.Delete stmt, String region) {+ requireNoIndexQualifier(stmt.index());TableDefinition table = service.describeTable(stmt.table(), region);+ requireOneValuePerKey(table, stmt.where());ObjectNode key = buildKey(table, stmt.where());- service.deleteItem(stmt.table(), key, null, null, null, region, "NONE");- return emptyItemsResponse();++ ExprAttrBuilder eav = new ExprAttrBuilder();+ ExprAttrNameBuilder ean = new ExprAttrNameBuilder();+ String ce = deleteCondition(table, stmt.where(), eav, ean);++ JsonNode oldItem = service.deleteItem(stmt.table(), key, ce,+ ean.isEmpty() ? null : ean.toNode(mapper),+ eav.isEmpty() ? null : eav.toNode(mapper), region, "NONE");+ return itemsResponse(stmt.returning() == Returning.ALL_OLD ? oldItem : null);}// --- Transaction item builder ---- JsonNode toTransactItem(Stmt stmt, String region) {+ record TransactMember(JsonNode item, TransactionCanceledException.CancellationReason reason) {++ static final TransactMember TABLE_NOT_FOUND = cancels("ResourceNotFound", "Requested resource not found");+ static final TransactMember KEY_MISMATCH = cancels("ValidationError", "The provided key element does not match the schema");++ static TransactMember cancels(String code, String message) {+ return new TransactMember(null, new TransactionCanceledException.CancellationReason(code, null, message));+ }+ }++ TransactMember toTransactItem(Stmt stmt, String region) {+ requireNoIndexQualifier(switch (stmt) {+ case Stmt.Update upd -> upd.index();+ case Stmt.Delete del -> del.index();+ default -> null;+ });+ Optional<TableDefinition> found = service.findTable(stmt.table(), region);+ if (found.isEmpty()) {+ return TransactMember.TABLE_NOT_FOUND;+ }+ TableDefinition table = found.get();+ if (returningOf(stmt) != Returning.NONE) {+ throw new AwsException("ValidationException",+ "RETURNING clause is not supported in ExecuteTransaction.", 400);+ }+ Optional<TransactMember> keyProblem = keyProblemOf(stmt, table);+ if (keyProblem.isPresent()) {+ return keyProblem.get();+ }ObjectNode txItem = mapper.createObjectNode();switch (stmt) {case Stmt.Insert ins -> {- TableDefinition table = service.describeTable(ins.table(), region);String pkName = table.getPartitionKeyName();ObjectNode item = mapper.createObjectNode();ins.item().forEach((k, v) -> item.set(k, toTypedNode(v)));@@ -329,65 +597,263 @@ class DynamoDbPartiQLHandler {txItem.set("Put", put);}case Stmt.Update upd -> {- TableDefinition table = service.describeTable(upd.table(), region);ObjectNode key = buildKey(table, upd.where());ExprAttrBuilder eav = new ExprAttrBuilder();ExprAttrNameBuilder ean = new ExprAttrNameBuilder();- StringBuilder ue = new StringBuilder();- if (!upd.sets().isEmpty()) {- ue.append("SET ");- List<String> parts = new ArrayList<>();- for (Assign a : upd.sets()) {- parts.add(ean.alias(a.attr()) + " = " + eav.add(toTypedNode(a.val())));- }- ue.append(String.join(", ", parts));- }- if (!upd.removes().isEmpty()) {- if (!ue.isEmpty()) ue.append(" ");- ue.append("REMOVE ");- ue.append(upd.removes().stream().map(ean::alias).reduce((a, b) -> a + ", " + b).orElse(""));- }+ String ue = buildUpdateExpression(upd.sets(), upd.removes(), eav, ean);ObjectNode update = mapper.createObjectNode();update.put("TableName", upd.table());update.set("Key", key);- update.put("UpdateExpression", ue.toString());+ update.put("UpdateExpression", ue);+ update.put("ConditionExpression", updateCondition(table, upd.where(), eav, ean));if (!eav.isEmpty()) update.set("ExpressionAttributeValues", eav.toNode(mapper));if (!ean.isEmpty()) update.set("ExpressionAttributeNames", ean.toNode(mapper));txItem.set("Update", update);}case Stmt.Delete del -> {- TableDefinition table = service.describeTable(del.table(), region);ObjectNode key = buildKey(table, del.where());+ ExprAttrBuilder eav = new ExprAttrBuilder();+ ExprAttrNameBuilder ean = new ExprAttrNameBuilder();+ String ce = deleteCondition(table, del.where(), eav, ean);ObjectNode delete = mapper.createObjectNode();delete.put("TableName", del.table());delete.set("Key", key);+ if (ce != null) {+ delete.put("ConditionExpression", ce);+ }+ if (!eav.isEmpty()) {+ delete.set("ExpressionAttributeValues", eav.toNode(mapper));+ }+ if (!ean.isEmpty()) {+ delete.set("ExpressionAttributeNames", ean.toNode(mapper));+ }txItem.set("Delete", delete);}case Stmt.Select ignored ->throw new AwsException("ValidationException","SELECT is not supported inside ExecuteTransaction", 400);+ case Stmt.Exists exists -> txItem.set("ConditionCheck", conditionCheck(exists.select(), table));+ }+ return new TransactMember(txItem, null);+ }++ private ObjectNode conditionCheck(Stmt.Select select, TableDefinition table) {+ List<Cond> conditions = nonKeyConditions(table, select.where());+ if (!pinsFullKey(table, select.where()) || conditions.isEmpty()) {+ throw new AwsException("ValidationException",+ "EXISTS() must contain a single item read with additional condition", 400);+ }+ ExprAttrBuilder eav = new ExprAttrBuilder();+ ExprAttrNameBuilder ean = new ExprAttrNameBuilder();+ ObjectNode check = mapper.createObjectNode();+ check.put("TableName", select.table());+ check.set("Key", buildKey(table, select.where()));+ check.put("ConditionExpression", joinOperands(conditions, " AND ", eav, ean));+ if (!eav.isEmpty()) {+ check.set("ExpressionAttributeValues", eav.toNode(mapper));+ }+ if (!ean.isEmpty()) {+ check.set("ExpressionAttributeNames", ean.toNode(mapper));}- return txItem;+ return check;+ }++ private static Optional<TransactMember> keyProblemOf(Stmt stmt, TableDefinition table) {+ return switch (stmt) {+ case Stmt.Insert ins -> table.getKeySchema().stream()+ .map(KeySchemaElement::getAttributeName)+ .filter(name -> !ins.item().containsKey(name))+ .findFirst()+ .map(name -> TransactMember.cancels("ValidationError",+ "One or more parameter values were invalid: Missing the key " + name + " in the item"));+ case Stmt.Update upd -> wrongKey(table, upd.where());+ case Stmt.Delete del -> wrongKey(table, del.where());+ default -> Optional.empty();+ };+ }++ private static Optional<TransactMember> wrongKey(TableDefinition table, List<Cond> where) {+ boolean namesOneItem = secondKeyValue(table, where).isEmpty() && pinsFullKey(table, where)+ && keyTypesMatch(table, where);+ return namesOneItem ? Optional.empty() : Optional.of(TransactMember.KEY_MISMATCH);+ }++ private static boolean keyTypesMatch(TableDefinition table, List<Cond> where) {+ return firstKeyValues(table, where).entrySet().stream()+ .allMatch(key -> DynamoDbPartiQLKeyPlan.matchesKeyType(table, key.getKey(), key.getValue()));+ }++ TransactMember toTransactGetItem(Stmt.Select stmt, String region) {+ Optional<TableDefinition> found = service.findTable(stmt.table(), region);+ if (found.isEmpty()) {+ return TransactMember.TABLE_NOT_FOUND;+ }+ TableDefinition table = found.get();+ if (stmt.index() != null) {+ throw new AwsException("ValidationException",+ "Reads on indices are not supported within transactions.", 400);+ }+ new DynamoDbPartiQLKeyPlan(stmt.where(), DynamoDbAccessPath.resolve(table, null), table).requireNoOverlap();+ if (!namesOnlyTheKey(table, stmt.where())) {+ throw new AwsException("ValidationException",+ "Select statements within ExecuteTransaction must specify the primary key in the where clause.", 400);+ }+ List<Cond> equalities = asEqualities(stmt.where());+ if (!keyTypesMatch(table, equalities)) {+ return TransactMember.KEY_MISMATCH;+ }+ ObjectNode get = mapper.createObjectNode();+ get.put("TableName", stmt.table());+ get.set("Key", buildKey(table, equalities));+ ObjectNode txItem = mapper.createObjectNode();+ txItem.set("Get", get);+ return new TransactMember(txItem, null);+ }++ JsonNode projectSelected(Stmt.Select stmt, JsonNode item) {+ if (item == null || stmt.columns().isEmpty()) {+ return item;+ }+ return selectColumns(item, selectedColumns(stmt));}// --- Shared helpers ---+ private String buildUpdateExpression(List<SetClause> sets, List<Path> removes,+ ExprAttrBuilder eav, ExprAttrNameBuilder ean) {+ List<String> assignments = new ArrayList<>();+ List<String> adds = new ArrayList<>();+ List<String> deletes = new ArrayList<>();+ for (SetClause clause : sets) {+ switch (clause) {+ case Assign assign -> assignments.add(assignExpr(assign, eav, ean));+ case SetAdd add -> adds.add(ean.alias(add.path()) + " " + eav.add(toTypedNode(add.bag())));+ case SetDelete delete -> deletes.add(ean.alias(delete.path()) + " " + eav.add(toTypedNode(delete.bag())));+ }+ }+ List<String> clauses = new ArrayList<>();+ if (!assignments.isEmpty()) {+ clauses.add("SET " + String.join(", ", assignments));+ }+ if (!removes.isEmpty()) {+ clauses.add("REMOVE " + removes.stream()+ .map(ean::alias)+ .collect(Collectors.joining(", ")));+ }+ if (!adds.isEmpty()) {+ clauses.add("ADD " + String.join(", ", adds));+ }+ if (!deletes.isEmpty()) {+ clauses.add("DELETE " + String.join(", ", deletes));+ }+ return String.join(" ", clauses);+ }++ private String assignExpr(Assign assign, ExprAttrBuilder eav, ExprAttrNameBuilder ean) {+ String assignment = ean.alias(assign.path()) + " = " + operandExpr(assign.left(), eav, ean);+ if (assign.op() == null) {+ return assignment;+ }+ return assignment + " " + assign.op() + " " + operandExpr(assign.right(), eav, ean);+ }++ private String operandExpr(Operand operand, ExprAttrBuilder eav, ExprAttrNameBuilder ean) {+ return switch (operand) {+ case Operand.Value value -> eav.add(toTypedNode(value.val()));+ case Operand.Attribute attribute -> ean.alias(attribute.path());+ case Operand.ListAppend append -> "list_append(" + operandExpr(append.first(), eav, ean)+ + ", " + operandExpr(append.second(), eav, ean) + ")";+ };+ }+private ObjectNode buildKey(TableDefinition table, List<Cond> where) {- String pkName = table.getPartitionKeyName();- String skName = table.getSortKeyName();+ if (!pinsFullKey(table, where)) {+ throw new AwsException("ValidationException",+ "Where clause does not contain a mandatory equality on all key attributes", 400);+ }ObjectNode key = mapper.createObjectNode();+ firstKeyValues(table, where).forEach((name, value) -> key.set(name, toTypedNode(value)));+ return key;+ }++ private static boolean pinsFullKey(TableDefinition table, List<Cond> where) {+ return firstKeyValues(table, where).size() == keyAttributeNames(table).size();+ }++ static void requireReadsWithinLimit(TableDefinition table, List<Cond> where) {+ new DynamoDbPartiQLKeyPlan(where, DynamoDbAccessPath.resolve(table, null), table).requireReadsWithinLimit();+ }++ static boolean namesOnlyTheKey(TableDefinition table, List<Cond> where) {+ List<Cond> equalities = asEqualities(where);+ return nonKeyConditions(table, equalities).isEmpty() && pinsFullKey(table, equalities);+ }++ private static List<Cond> asEqualities(List<Cond> where) {+ return where.stream()+ .map(c -> c instanceof Cond.In in && in.values().size() == 1 ? new Cond.Eq(in.path(), in.values().getFirst()) : c)+ .toList();+ }++ private static Set<String> keyAttributeNames(TableDefinition table) {+ return DynamoDbAccessPath.resolve(table, null).keyAttributeNames();+ }++ private static boolean isKeyEquality(Cond cond, Set<String> keyNames) {+ return cond instanceof Cond.Eq eq && eq.bareAttribute().filter(keyNames::contains).isPresent();+ }++ private static Map<String, PVal> firstKeyValues(TableDefinition table, List<Cond> where) {+ Set<String> keyNames = keyAttributeNames(table);+ Map<String, PVal> firstValues = new LinkedHashMap<>();for (Cond c : where) {- if (c instanceof Cond.Eq eq) {- if (pkName.equals(eq.attr()) || (skName != null && skName.equals(eq.attr()))) {- key.set(eq.attr(), toTypedNode(eq.val()));- }+ if (c instanceof Cond.Eq eq && isKeyEquality(eq, keyNames)) {+ firstValues.putIfAbsent(eq.path().root(), eq.val());}}- if (!key.has(pkName)) {- throw new AwsException("ValidationException",- "WHERE clause must include an equality condition on the partition key", 400);+ return firstValues;+ }++ private static Optional<Cond.Eq> secondKeyValue(TableDefinition table, List<Cond> where) {+ Map<String, PVal> firstValues = firstKeyValues(table, where);+ return where.stream()+ .filter(c -> c instanceof Cond.Eq eq+ && eq.bareAttribute().map(firstValues::get).filter(first -> !first.equals(eq.val())).isPresent())+ .map(Cond.Eq.class::cast)+ .findFirst();+ }++ private static List<Cond> nonKeyConditions(TableDefinition table, List<Cond> where) {+ Set<String> keyNames = keyAttributeNames(table);+ Map<String, PVal> firstValues = firstKeyValues(table, where);+ return where.stream()+ .filter(c -> !(c instanceof Cond.Eq eq && isKeyEquality(eq, keyNames)+ && firstValues.get(eq.path().root()).equals(eq.val())))+ .toList();+ }++ private static void requireOneValuePerKey(TableDefinition table, List<Cond> where) {+ secondKeyValue(table, where).ifPresent(eq -> {+ throw new AwsException("ValidationException", "Multiple conditions on same key " + eq.path().root()+ + ". Only single item Update/Insert/Delete are supported", 400);+ });+ }++ private String updateCondition(TableDefinition table, List<Cond> where,+ ExprAttrBuilder eav, ExprAttrNameBuilder ean) {+ String exists = "attribute_exists(" + ean.alias(table.getPartitionKeyName()) + ")";+ List<Cond> filters = nonKeyConditions(table, where);+ return filters.isEmpty() ? exists : exists + " AND " + joinOperands(filters, " AND ", eav, ean);+ }++ private String deleteCondition(TableDefinition table, List<Cond> where,+ ExprAttrBuilder eav, ExprAttrNameBuilder ean) {+ List<Cond> filters = nonKeyConditions(table, where);+ if (filters.isEmpty()) {+ return null;}- return key;+ return "attribute_not_exists(" + ean.alias(table.getPartitionKeyName()) + ") OR "+ + joinOperands(filters, " AND ", eav, ean);}JsonNode toTypedNode(PVal val) {@@ -397,12 +863,34 @@ class DynamoDbPartiQLHandler {case PVal.Bool b -> mapper.createObjectNode().put("BOOL", b.v());case PVal.Null ignored -> mapper.createObjectNode().put("NULL", true);case PVal.Av av -> av.node();+ case PVal.ListOf list -> {+ ObjectNode node = mapper.createObjectNode();+ ArrayNode items = node.putArray("L");+ list.items().forEach(item -> items.add(toTypedNode(item)));+ yield node;+ }+ case PVal.Tuple tuple -> {+ ObjectNode node = mapper.createObjectNode();+ ObjectNode fields = node.putObject("M");+ tuple.fields().forEach((name, value) -> fields.set(name, toTypedNode(value)));+ yield node;+ }+ case PVal.Bag bag -> {+ ObjectNode node = mapper.createObjectNode();+ ArrayNode members = node.putArray(bag.type());+ bag.members().forEach(member -> members.add(toTypedNode(member).path(bag.type().substring(0, 1))));+ yield node;+ }};}- private ObjectNode emptyItemsResponse() {+ private ObjectNode itemsResponse(JsonNode returned) {ObjectNode resp = mapper.createObjectNode();- resp.set("Items", mapper.createArrayNode());+ ArrayNode items = mapper.createArrayNode();+ if (returned != null && !returned.isEmpty()) {+ items.add(returned);+ }+ resp.set("Items", items);return resp;}@@ -440,6 +928,22 @@ class DynamoDbPartiQLHandler {});}+ String alias(Path path) {+ StringBuilder expression = new StringBuilder();+ for (Seg segment : path.segments()) {+ switch (segment) {+ case Seg.Name name -> {+ if (!expression.isEmpty()) {+ expression.append('.');+ }+ expression.append(alias(name.value()));+ }+ case Seg.Index index -> expression.append('[').append(index.value()).append(']');+ }+ }+ return expression.toString();+ }+boolean isEmpty() { return aliasToName.isEmpty(); }ObjectNode toNode(ObjectMapper mapper) {diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLKeyPlan.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLKeyPlan.javanew file mode 100644index 0000000000..3bddca8e33--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLKeyPlan.java@@ -0,0 +1,342 @@+package io.github.hectorvent.floci.services.dynamodb;++import io.github.hectorvent.floci.services.dynamodb.DynamoDbPartiQLParser.Cond;+import io.github.hectorvent.floci.services.dynamodb.DynamoDbPartiQLParser.PVal;+import io.github.hectorvent.floci.services.dynamodb.DynamoDbPartiQLParser.Path;+import io.github.hectorvent.floci.services.dynamodb.model.TableDefinition;++import java.math.BigDecimal;+import java.nio.charset.StandardCharsets;+import java.util.ArrayList;+import java.util.Arrays;+import java.util.Base64;+import java.util.Comparator;+import java.util.HashSet;+import java.util.List;+import java.util.Map;+import java.util.Optional;+import java.util.Set;+import java.util.TreeMap;+import java.util.stream.Collectors;+import java.util.stream.Stream;++final class DynamoDbPartiQLKeyPlan {++ private static final int MAX_BRANCHES = 1000;+ private static final int MAX_DECOMPOSED_READS = 50;++ private final String partitionKey;+ private final String sortKey;+ private final TableDefinition table;+ private final boolean everyBranchPinsPartition;+ private final List<Cond.Leaf> keyConditions = new ArrayList<>();+ private final List<Branch> branches;+ private boolean tooManyBranches;++ private record Spread(List<Cond.Leaf> keyConditions, List<Cond> filters) {++ static final Spread EMPTY = new Spread(List.of(), List.of());++ Spread and(Spread other) {+ return new Spread(Stream.concat(keyConditions.stream(), other.keyConditions.stream()).toList(),+ Stream.concat(filters.stream(), other.filters.stream()).toList());+ }+ }++ private record Branch(Key partition, PVal partitionValue, Range sortRange, List<Cond> filters) {}++ DynamoDbPartiQLKeyPlan(List<Cond> where, DynamoDbAccessPath accessPath, TableDefinition table) {+ this.partitionKey = accessPath.partitionKeyName();+ this.sortKey = accessPath.sortKeyName();+ this.table = table;+ Cond conditions = new Cond.And(where);+ this.everyBranchPinsPartition = everyBranchPinsPartition(conditions);+ List<Spread> spread = spread(conditions);+ this.branches = tooManyBranches+ ? List.of(new Branch(null, null, Range.ALL, where))+ : spread.stream().map(this::branchOf).toList();+ }++ void requireKeyTypesMatchSchema() {+ for (Cond.Leaf condition : keyConditions) {+ String name = condition.path().root();+ for (PVal value : values(condition)) {+ String type = DynamoDbPartiQLParser.typeCode(value);+ if (!DynamoDbPartiQLParser.ORDERED_TYPES.contains(type)) {+ throw DynamoDbPartiQLParser.validationEx(+ "Key value must be of type S, N, or B. Key name: " + name + ", Key type: " + type);+ }+ if (!matchesKeyType(table, name, value)) {+ throw DynamoDbPartiQLParser.validationEx(+ "Key attribute's data type should match its data type in table's schema: Key " + name);+ }+ }+ }+ }++ static boolean matchesKeyType(TableDefinition table, String keyName, PVal value) {+ return DynamoDbAccessPathValidator.attributeType(table, keyName).equals(DynamoDbPartiQLParser.typeCode(value));+ }++ void requireReadsWithinLimit() {+ if (everyBranchPinsPartition && (tooManyBranches || branches.size() > MAX_DECOMPOSED_READS)) {+ throw DynamoDbPartiQLParser.validationEx("Too many decomposed read operations for a given query.");+ }+ }++ private boolean everyBranchPinsPartition(Cond cond) {+ return switch (cond) {+ case Cond.Leaf leaf -> pinsPartition(leaf);+ case Cond.And and -> and.operands().stream().anyMatch(this::everyBranchPinsPartition);+ case Cond.Or or -> or.operands().stream().allMatch(this::everyBranchPinsPartition);+ case Cond.Not ignored -> false;+ };+ }++ void requireNoOverlap() {+ if (!keyed()) {+ return;+ }+ Map<Key, List<Range>> rangesByPartition = new TreeMap<>();+ for (Branch branch : branches) {+ rangesByPartition.computeIfAbsent(branch.partition(), ignored -> new ArrayList<>()).add(branch.sortRange());+ }+ for (List<Range> ranges : rangesByPartition.values()) {+ Range reach = null;+ for (Range range : ranges.stream().filter(range -> !range.isEmpty()).sorted(Range.BY_LOWER).toList()) {+ if (reach != null && range.startsBefore(reach)) {+ throw DynamoDbPartiQLParser.validationEx(+ "Overlapping conditions with range keys are not supported in where clause");+ }+ if (reach == null || range.endsAfter(reach)) {+ reach = range;+ }+ }+ }+ }++ List<String> unprojectedFilterAttributes(Set<String> projected) {+ if (!keyed()) {+ return List.of();+ }+ Set<String> last = Set.of();+ for (Branch branch : branches.stream().sorted(Comparator.comparing(Branch::partition)).toList()) {+ Set<String> names = branch.filters().stream()+ .flatMap(DynamoDbPartiQLKeyPlan::attributePaths)+ .map(Path::root)+ .filter(root -> !projected.contains(root))+ .collect(Collectors.toCollection(HashSet::new));+ if (names.isEmpty()) {+ return List.of();+ }+ last = names;+ }+ return List.copyOf(last);+ }++ Optional<PVal> singlePartition() {+ Key first = branches.getFirst().partition();+ if (!keyed() || branches.stream().anyMatch(branch -> branch.partition().compareTo(first) != 0)) {+ return Optional.empty();+ }+ return Optional.of(branches.getFirst().partitionValue());+ }++ static Stream<Path> attributePaths(Cond cond) {+ return DynamoDbPartiQLParser.leaves(cond).map(Cond.Leaf::path);+ }++ static boolean isSortKeyRange(Cond cond, String sortKey) {+ if (sortKey == null || cond.bareAttribute().filter(sortKey::equals).isEmpty()) {+ return false;+ }+ return cond instanceof Cond.Cmp cmp ? !"<>".equals(cmp.op())+ : cond instanceof Cond.Eq || cond instanceof Cond.Between || cond instanceof Cond.BeginsWith;+ }++ private boolean keyed() {+ return branches.stream().allMatch(branch -> branch.partition() != null);+ }++ private Branch branchOf(Spread spread) {+ Key partition = null;+ PVal partitionValue = null;+ boolean conflicting = false;+ Range sortRange = Range.ALL;+ for (Cond.Leaf condition : spread.keyConditions()) {+ if (condition.path().root().equals(partitionKey)) {+ PVal value = ((Cond.Eq) condition).val();+ Key key = Key.of(value);+ conflicting |= partition != null && partition.compareTo(key) != 0;+ if (partition == null) {+ partition = key;+ partitionValue = value;+ }+ } else {+ sortRange = sortRange.intersect(rangeOf(condition));+ }+ }+ return new Branch(conflicting ? null : partition, partitionValue, sortRange, spread.filters());+ }++ private List<Spread> spread(Cond cond) {+ return switch (cond) {+ case Cond.In in when isKeyCondition(in) -> {+ keyConditions.add(in);+ yield in.values().stream()+ .map(value -> new Spread(List.of(new Cond.Eq(in.path(), value)), List.of()))+ .toList();+ }+ case Cond.Leaf leaf when isKeyCondition(leaf) -> {+ keyConditions.add(leaf);+ yield List.of(new Spread(List.of(leaf), List.of()));+ }+ case Cond.And and -> {+ List<Spread> spread = List.of(Spread.EMPTY);+ for (Cond operand : and.operands()) {+ spread = and(spread, spread(operand));+ }+ yield spread;+ }+ case Cond.Or or when namesKey(or) -> {+ List<Spread> spread = or.operands().stream().flatMap(operand -> spread(operand).stream()).toList();+ tooManyBranches |= spread.size() > MAX_BRANCHES;+ yield spread;+ }+ default -> List.of(new Spread(List.of(), List.of(cond)));+ };+ }++ private List<Spread> and(List<Spread> left, List<Spread> right) {+ if ((long) left.size() * right.size() > MAX_BRANCHES) {+ tooManyBranches = true;+ return left;+ }+ return left.stream().flatMap(l -> right.stream().map(l::and)).toList();+ }++ private boolean namesKey(Cond cond) {+ return switch (cond) {+ case Cond.Leaf leaf -> isKeyCondition(leaf);+ case Cond.And and -> and.operands().stream().anyMatch(this::namesKey);+ case Cond.Or or -> or.operands().stream().anyMatch(this::namesKey);+ case Cond.Not ignored -> false;+ };+ }++ private boolean pinsPartition(Cond.Leaf leaf) {+ return leaf.bareAttribute().filter(partitionKey::equals).isPresent()+ && (leaf instanceof Cond.Eq || leaf instanceof Cond.In);+ }++ private boolean isKeyCondition(Cond.Leaf leaf) {+ if (leaf.bareAttribute().filter(partitionKey::equals).isPresent()) {+ return pinsPartition(leaf);+ }+ return isSortKeyRange(leaf, sortKey)+ || (leaf instanceof Cond.In && leaf.bareAttribute().filter(name -> name.equals(sortKey)).isPresent());+ }++ private static List<PVal> values(Cond.Leaf condition) {+ return switch (condition) {+ case Cond.Eq eq -> List.of(eq.val());+ case Cond.Cmp cmp -> List.of(cmp.val());+ case Cond.Between between -> List.of(between.lo(), between.hi());+ case Cond.BeginsWith beginsWith -> List.of(beginsWith.prefix());+ case Cond.In in -> in.values();+ default -> List.of();+ };+ }++ private static Range rangeOf(Cond.Leaf condition) {+ return switch (condition) {+ case Cond.Eq eq -> new Range(Key.of(eq.val()), true, Key.of(eq.val()), true);+ case Cond.Between between -> new Range(Key.of(between.lo()), true, Key.of(between.hi()), true);+ case Cond.BeginsWith beginsWith -> new Range(Key.of(beginsWith.prefix()), true, prefixEnd(beginsWith.prefix()), false);+ case Cond.Cmp cmp -> switch (cmp.op()) {+ case "<" -> new Range(null, false, Key.of(cmp.val()), false);+ case "<=" -> new Range(null, false, Key.of(cmp.val()), true);+ case ">" -> new Range(Key.of(cmp.val()), false, null, false);+ default -> new Range(Key.of(cmp.val()), true, null, false);+ };+ default -> Range.ALL;+ };+ }++ private static Key prefixEnd(PVal prefix) {+ byte[] bytes = Key.of(prefix).bytes();+ for (int i = bytes.length - 1; i >= 0; i--) {+ if (bytes[i] != (byte) 0xFF) {+ byte[] end = Arrays.copyOf(bytes, i + 1);+ end[i]++;+ return new Key(null, end);+ }+ }+ return null;+ }++ private record Key(BigDecimal number, byte[] bytes) implements Comparable<Key> {++ static Key of(PVal value) {+ return switch (value) {+ case PVal.Num number -> new Key(new BigDecimal(number.v()), "N".getBytes(StandardCharsets.UTF_8));+ case PVal.Str text -> new Key(null, text.v().getBytes(StandardCharsets.UTF_8));+ case PVal.Av av when av.node().has("B") -> new Key(null, Base64.getDecoder().decode(av.node().get("B").asText()));+ default -> new Key(null, DynamoDbPartiQLParser.typeCode(value).getBytes(StandardCharsets.UTF_8));+ };+ }++ @Override+ public int compareTo(Key other) {+ if (number != null && other.number != null) {+ return number.compareTo(other.number);+ }+ return Arrays.compareUnsigned(bytes, other.bytes);+ }+ }++ private record Range(Key lower, boolean lowerInclusive, Key upper, boolean upperInclusive) {++ static final Range ALL = new Range(null, false, null, false);++ static final Comparator<Range> BY_LOWER = Comparator+ .comparing(Range::lower, Comparator.nullsFirst(Comparator.<Key>naturalOrder()))+ .thenComparing(range -> !range.lowerInclusive());++ Range intersect(Range other) {+ boolean raisesLower = other.lower != null && (lower == null || other.lower.compareTo(lower) > 0+ || (other.lower.compareTo(lower) == 0 && !other.lowerInclusive));+ boolean dropsUpper = other.upper != null && (upper == null || other.upper.compareTo(upper) < 0+ || (other.upper.compareTo(upper) == 0 && !other.upperInclusive));+ return new Range(raisesLower ? other.lower : lower, raisesLower ? other.lowerInclusive : lowerInclusive,+ dropsUpper ? other.upper : upper, dropsUpper ? other.upperInclusive : upperInclusive);+ }++ boolean isEmpty() {+ if (lower == null || upper == null) {+ return false;+ }+ int order = lower.compareTo(upper);+ return order > 0 || (order == 0 && !(lowerInclusive && upperInclusive));+ }++ boolean startsBefore(Range reach) {+ if (reach.upper == null || lower == null) {+ return true;+ }+ int order = lower.compareTo(reach.upper);+ return order < 0 || (order == 0 && lowerInclusive && reach.upperInclusive);+ }++ boolean endsAfter(Range reach) {+ if (reach.upper == null) {+ return false;+ }+ if (upper == null) {+ return true;+ }+ int order = upper.compareTo(reach.upper);+ return order > 0 || (order == 0 && upperInclusive && !reach.upperInclusive);+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLParser.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLParser.javaindex a8aa444e06..6c8feeff5b 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLParser.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLParser.java@@ -4,6 +4,7 @@ import com.fasterxml.jackson.databind.JsonNode;import io.github.hectorvent.floci.core.common.AwsException;import java.util.*;+import java.util.stream.Stream;public class DynamoDbPartiQLParser {@@ -13,19 +14,98 @@ public class DynamoDbPartiQLParser {IDENT, STRING, NUMBER, BOOL, NULL, QUESTION,EQ, NE, LT, LE, GT, GE,LPAREN, RPAREN, LBRACE, RBRACE, COMMA, COLON, DOT,+ OR, NOT, IN, IS, MISSING, RETURNING, ALL, MODIFIED, OLD, NEW,+ PLUS, MINUS, LBRACKET, RBRACKET,+ LBAG, RBAG, SEMICOLON,+ ORDER, BY, ASC, DESC,EOF}- record Token(TType type, String value) {}+ record Token(TType type, String value, int start) {+ Token(TType type, String value) {+ this(type, value, -1);+ }+ }// --- AST node types ---- public sealed interface Stmt permits Stmt.Select, Stmt.Insert, Stmt.Update, Stmt.Delete {+ public sealed interface Seg permits Seg.Name, Seg.Index {+ record Name(String value) implements Seg {}+ record Index(long value) implements Seg {}+ }++ public record Path(List<Seg> segments) {++ public String root() {+ return ((Seg.Name) segments.getFirst()).value();+ }++ public boolean isRootOnly() {+ return segments.size() == 1;+ }++ String leafName() {+ int last = segments.size() - 1;+ while (segments.get(last) instanceof Seg.Index) {+ last--;+ }+ StringBuilder name = new StringBuilder(((Seg.Name) segments.get(last)).value());+ for (Seg trailing : segments.subList(last + 1, segments.size())) {+ name.append('[').append(((Seg.Index) trailing).value()).append(']');+ }+ return name.toString();+ }+ }++ public enum Returning {+ NONE("NONE"),+ ALL_OLD("ALL_OLD"),+ ALL_NEW("ALL_NEW"),+ MODIFIED_OLD("UPDATED_OLD"),+ MODIFIED_NEW("UPDATED_NEW");++ private final String returnValues;++ Returning(String returnValues) {+ this.returnValues = returnValues;+ }++ String returnValues() {+ return returnValues;+ }++ String clause() {+ return "RETURNING " + name().replace('_', ' ') + " *";+ }+ }++ record OrderTerm(String attribute, boolean descending) {}++ public sealed interface Stmt permits Stmt.Select, Stmt.Insert, Stmt.Update, Stmt.Delete, Stmt.Exists {String table();- record Select(String table, String index, List<String> columns, List<Cond> where) implements Stmt {}- record Insert(String table, Map<String, PVal> item) implements Stmt {}- record Update(String table, List<Assign> sets, List<String> removes, List<Cond> where) implements Stmt {}- record Delete(String table, List<Cond> where) implements Stmt {}+ List<Cond> where();+ record Select(String table, String index, List<Path> columns, List<Cond> where,+ List<OrderTerm> orderBy) implements Stmt {}+ record Insert(String table, Map<String, PVal> item) implements Stmt {+ @Override+ public List<Cond> where() {+ return List.of();+ }+ }+ record Update(String table, String index, List<SetClause> sets, List<Path> removes,+ List<Cond> where, Returning returning) implements Stmt {}+ record Delete(String table, String index, List<Cond> where, Returning returning) implements Stmt {}+ record Exists(Select select) implements Stmt {+ @Override+ public String table() {+ return select.table();+ }++ @Override+ public List<Cond> where() {+ return select.where();+ }+ }}/**@@ -58,23 +138,63 @@ public class DynamoDbPartiQLParser {}}- sealed interface PVal permits PVal.Str, PVal.Num, PVal.Bool, PVal.Null, PVal.Av {+ sealed interface PVal permits PVal.Str, PVal.Num, PVal.Bool, PVal.Null, PVal.Av,+ PVal.ListOf, PVal.Tuple, PVal.Bag {record Str(String v) implements PVal {}record Num(String v) implements PVal {}record Bool(boolean v) implements PVal {}record Null() implements PVal {}// A parameter of a type with no literal syntax, kept as its wire node.record Av(String type, JsonNode node) implements PVal {}+ record ListOf(List<PVal> items) implements PVal {}+ record Tuple(Map<String, PVal> fields) implements PVal {}+ record Bag(String type, List<PVal> members) implements PVal {}+ }++ sealed interface Cond permits Cond.Leaf, Cond.And, Cond.Or, Cond.Not {++ default Optional<String> bareAttribute() {+ return Optional.empty();+ }++ sealed interface Leaf extends Cond permits Eq, Cmp, Between, BeginsWith, In, Missing,+ Contains, AttributeType, SizeCmp, IsNull {+ Path path();++ @Override+ default Optional<String> bareAttribute() {+ return path().isRootOnly() ? Optional.of(path().root()) : Optional.empty();+ }+ }++ record Eq(Path path, PVal val) implements Leaf {}+ record Cmp(Path path, String op, PVal val) implements Leaf {}+ record Between(Path path, PVal lo, PVal hi) implements Leaf {}+ record BeginsWith(Path path, PVal prefix) implements Leaf {}+ record In(Path path, List<PVal> values) implements Leaf {}+ record Missing(Path path, boolean negated) implements Leaf {}+ record Contains(Path path, PVal operand) implements Leaf {}+ record AttributeType(Path path, PVal type) implements Leaf {}+ record SizeCmp(Path path, String op, PVal val) implements Leaf {}+ record IsNull(Path path, boolean negated) implements Leaf {}+ record And(List<Cond> operands) implements Cond {}+ record Or(List<Cond> operands) implements Cond {}+ record Not(Cond operand) implements Cond {}+ }++ sealed interface Operand permits Operand.Value, Operand.Attribute, Operand.ListAppend {+ record Value(PVal val) implements Operand {}+ record Attribute(Path path) implements Operand {}+ record ListAppend(Operand first, Operand second) implements Operand {}}- sealed interface Cond permits Cond.Eq, Cond.Cmp, Cond.Between, Cond.BeginsWith {- record Eq(String attr, PVal val) implements Cond {}- record Cmp(String attr, String op, PVal val) implements Cond {}- record Between(String attr, PVal lo, PVal hi) implements Cond {}- record BeginsWith(String attr, PVal prefix) implements Cond {}+ sealed interface SetClause permits Assign, SetAdd, SetDelete {+ Path path();}- record Assign(String attr, PVal val) {}+ record Assign(Path path, Operand left, String op, Operand right) implements SetClause {}+ record SetAdd(Path path, PVal bag) implements SetClause {}+ record SetDelete(Path path, PVal bag) implements SetClause {}// --- Tokenizer ---@@ -84,23 +204,42 @@ public class DynamoDbPartiQLParser {while (i < n) {char c = input.charAt(i);if (Character.isWhitespace(c)) { i++; continue; }+ if (input.startsWith("--", i)) {+ while (i < n && input.charAt(i) != '\n' && input.charAt(i) != '\r') i++;+ continue;+ }+ if (input.startsWith("/*", i)) {+ int end = input.indexOf("*/", i + 2);+ if (end < 0) {+ throw validationEx("Statement wasn't well formed, can't be processed: ");+ }+ i = end + 2;+ continue;+ }if (c == '\'') {- int start = ++i;- while (i < n && input.charAt(i) != '\'') i++;- tokens.add(new Token(TType.STRING, input.substring(start, i)));+ StringBuilder text = new StringBuilder();+ i++;+ while (i < n && (input.charAt(i) != '\'' || (i + 1 < n && input.charAt(i + 1) == '\''))) {+ text.append(input.charAt(i));+ i += input.charAt(i) == '\'' ? 2 : 1;+ }+ tokens.add(new Token(TType.STRING, text.toString()));i++;continue;}if (c == '"') {int start = ++i;while (i < n && input.charAt(i) != '"') i++;- tokens.add(new Token(TType.IDENT, input.substring(start, i)));+ tokens.add(new Token(TType.IDENT, input.substring(start, i), start - 1));i++;continue;}- if (c == '?') { tokens.add(new Token(TType.QUESTION, "?")); i++; continue; }+ if (c == '?') { tokens.add(new Token(TType.QUESTION, "?", i)); i++; continue; }if (c == '*') { tokens.add(new Token(TType.IDENT, "*")); i++; continue; }if (c == '=') { tokens.add(new Token(TType.EQ, "=")); i++; continue; }+ if (c == '!' && i + 1 < n && input.charAt(i + 1) == '=') { tokens.add(new Token(TType.NE, "!=")); i += 2; continue; }+ if (c == '<' && i + 1 < n && input.charAt(i + 1) == '<') { tokens.add(new Token(TType.LBAG, "<<")); i += 2; continue; }+ if (c == '>' && i + 1 < n && input.charAt(i + 1) == '>') { tokens.add(new Token(TType.RBAG, ">>")); i += 2; continue; }if (c == '<') {if (i + 1 < n && input.charAt(i + 1) == '>') { tokens.add(new Token(TType.NE, "<>")); i += 2; }else if (i + 1 < n && input.charAt(i + 1) == '=') { tokens.add(new Token(TType.LE, "<=")); i += 2; }@@ -116,16 +255,23 @@ public class DynamoDbPartiQLParser {if (c == ')') { tokens.add(new Token(TType.RPAREN, ")")); i++; continue; }if (c == '{') { tokens.add(new Token(TType.LBRACE, "{")); i++; continue; }if (c == '}') { tokens.add(new Token(TType.RBRACE, "}")); i++; continue; }+ if (c == '[') { tokens.add(new Token(TType.LBRACKET, "[")); i++; continue; }+ if (c == ']') { tokens.add(new Token(TType.RBRACKET, "]")); i++; continue; }if (c == ',') { tokens.add(new Token(TType.COMMA, ",")); i++; continue; }if (c == ':') { tokens.add(new Token(TType.COLON, ":")); i++; continue; }+ if (c == ';') { tokens.add(new Token(TType.SEMICOLON, ";")); i++; continue; }if (c == '.') { tokens.add(new Token(TType.DOT, ".")); i++; continue; }- if (Character.isDigit(c) || (c == '-' && i + 1 < n && Character.isDigit(input.charAt(i + 1)))) {+ if (Character.isDigit(c)+ || (c == '-' && i + 1 < n && Character.isDigit(input.charAt(i + 1)) && !endsOperand(tokens))) {int start = i;if (c == '-') i++;while (i < n && (Character.isDigit(input.charAt(i)) || input.charAt(i) == '.')) i++;- tokens.add(new Token(TType.NUMBER, input.substring(start, i)));+ i = skipExponent(input, i);+ tokens.add(new Token(TType.NUMBER, input.substring(start, i), start));continue;}+ if (c == '+') { tokens.add(new Token(TType.PLUS, "+")); i++; continue; }+ if (c == '-') { tokens.add(new Token(TType.MINUS, "-")); i++; continue; }if (Character.isLetter(c) || c == '_') {int start = i;while (i < n && (Character.isLetterOrDigit(input.charAt(i)) || input.charAt(i) == '_')) i++;@@ -142,12 +288,26 @@ public class DynamoDbPartiQLParser {case "REMOVE" -> TType.REMOVE;case "DELETE" -> TType.DELETE;case "AND" -> TType.AND;+ case "OR" -> TType.OR;+ case "NOT" -> TType.NOT;+ case "IN" -> TType.IN;+ case "IS" -> TType.IS;+ case "MISSING" -> TType.MISSING;case "BETWEEN" -> TType.BETWEEN;+ case "RETURNING" -> TType.RETURNING;+ case "ALL" -> TType.ALL;+ case "MODIFIED" -> TType.MODIFIED;+ case "OLD" -> TType.OLD;+ case "NEW" -> TType.NEW;+ case "ORDER" -> TType.ORDER;+ case "BY" -> TType.BY;+ case "ASC" -> TType.ASC;+ case "DESC" -> TType.DESC;case "TRUE", "FALSE" -> TType.BOOL;case "NULL" -> TType.NULL;default -> TType.IDENT;};- tokens.add(new Token(type, word));+ tokens.add(new Token(type, word, start));continue;}throw validationEx("Unexpected character '" + c + "' in PartiQL statement");@@ -156,80 +316,171 @@ public class DynamoDbPartiQLParser {return tokens;}+ private static int skipExponent(String input, int i) {+ int n = input.length();+ if (i >= n || (input.charAt(i) != 'e' && input.charAt(i) != 'E')) {+ return i;+ }+ int digits = i + 1;+ if (digits < n && (input.charAt(digits) == '+' || input.charAt(digits) == '-')) {+ digits++;+ }+ if (digits >= n || !Character.isDigit(input.charAt(digits))) {+ return i;+ }+ while (digits < n && Character.isDigit(input.charAt(digits))) {+ digits++;+ }+ return digits;+ }+// --- Recursive-descent parser ---+ private final String statement;private final List<Token> tokens;private final List<JsonNode> parameters;private int pos = 0;private int paramIdx = 0;+ private int literalDepth = 0;- private DynamoDbPartiQLParser(List<Token> tokens, List<JsonNode> parameters) {- this.tokens = tokens;+ private DynamoDbPartiQLParser(String statement, List<JsonNode> parameters) {+ this.statement = statement;+ this.tokens = tokenize(statement);this.parameters = parameters;}static Stmt parse(String statement, List<JsonNode> parameters) {parameters.forEach(DynamoDbAttributeValueValidator::validate);- parameters.forEach(DynamoDbAttributeValueValidator::requireParameterNestingWithinLimit);- return new DynamoDbPartiQLParser(tokenize(statement.trim()), parameters).parseStmt();+ DynamoDbPartiQLParser parser = new DynamoDbPartiQLParser(statement, parameters);+ Stmt stmt = parser.parseStmt();+ if (parser.peek().type() == TType.SEMICOLON) {+ parser.advance();+ }+ if (parser.peek().type() != TType.EOF) {+ throw validationEx("Statement wasn't well formed, can't be processed: Unexpected token after expression");+ }+ stmt.where().stream()+ .flatMap(DynamoDbPartiQLParser::leaves)+ .filter(Cond.In.class::isInstance)+ .map(Cond.In.class::cast)+ .filter(in -> in.values().size() > MAX_IN_OPERANDS)+ .findFirst()+ .ifPresent(in -> {+ throw validationEx("The IN operator is provided with too many operands; number of operands: "+ + in.values().size());+ });+ return stmt;+ }++ private static final int MAX_IN_OPERANDS = 100;++ static Stream<Cond.Leaf> leaves(Cond cond) {+ return switch (cond) {+ case Cond.Leaf leaf -> Stream.of(leaf);+ case Cond.Not not -> leaves(not.operand());+ case Cond.And and -> and.operands().stream().flatMap(DynamoDbPartiQLParser::leaves);+ case Cond.Or or -> or.operands().stream().flatMap(DynamoDbPartiQLParser::leaves);+ };+ }++ private static final Set<TType> OPERAND_ENDS = EnumSet.of(TType.IDENT, TType.NUMBER, TType.STRING,+ TType.BOOL, TType.NULL, TType.QUESTION, TType.RPAREN, TType.RBRACKET, TType.RBRACE, TType.RBAG);++ private static boolean endsOperand(List<Token> tokens) {+ return !tokens.isEmpty() && OPERAND_ENDS.contains(tokens.getLast().type());}private Stmt parseStmt() {+ if (peekFunction("exists")) {+ advance();+ consume(TType.LPAREN);+ Stmt.Select select = parseSelect();+ consume(TType.RPAREN);+ return new Stmt.Exists(select);+ }return switch (peek().type()) {case SELECT -> parseSelect();case INSERT -> parseInsert();case UPDATE -> parseUpdate();case DELETE -> parseDelete();- default -> throw validationEx("Unsupported PartiQL statement: " + peek().value());+ default -> throw validationEx(+ "Statement wasn't well formed, can't be processed: Expected data manipulation");};}// SELECT col [, col …] | * FROM "Table"["." "Index"] [WHERE cond [AND cond …]]private Stmt.Select parseSelect() {consume(TType.SELECT);- List<String> cols = new ArrayList<>();+ List<Path> cols = new ArrayList<>();if (peek().type() == TType.IDENT && "*".equals(peek().value())) {advance();} else {- cols.add(expectIdent());- while (peek().type() == TType.COMMA) { advance(); cols.add(expectIdent()); }+ cols.add(parsePath());+ while (peek().type() == TType.COMMA) { advance(); cols.add(parsePath()); }}consume(TType.FROM);- String table = expectIdent();- String index = null;- if (peek().type() == TType.DOT) {- advance();- index = expectIdent();- }+ String table = expectTableName();+ String index = parseIndexQualifier();List<Cond> where = new ArrayList<>();if (peek().type() == TType.WHERE) { advance(); where = parseConditions(); }- return new Stmt.Select(table, index, cols, where);+ return new Stmt.Select(table, index, cols, where, parseOrderBy());+ }++ private List<OrderTerm> parseOrderBy() {+ if (peek().type() != TType.ORDER) {+ return List.of();+ }+ advance();+ consume(TType.BY);+ List<OrderTerm> terms = new ArrayList<>();+ do {+ if (!terms.isEmpty()) {+ advance();+ }+ String attribute = expectIdent();+ boolean descending = peek().type() == TType.DESC;+ if (descending || peek().type() == TType.ASC) {+ advance();+ }+ terms.add(new OrderTerm(attribute, descending));+ } while (peek().type() == TType.COMMA);+ return List.copyOf(terms);}// INSERT INTO "Table" VALUE {'key': val, …}private Stmt.Insert parseInsert() {consume(TType.INSERT);consume(TType.INTO);- String table = expectIdent();+ String table = expectTableName();+ if (peek().type() == TType.DOT) {+ throw validationEx("FROM clause may only contain a single table name");+ }consume(TType.VALUE);consume(TType.LBRACE);- Map<String, PVal> item = new LinkedHashMap<>();+ return new Stmt.Insert(table, parseTupleFields(null));+ }++ private Map<String, PVal> parseTupleFields(String literalPath) {+ Map<String, PVal> fields = new LinkedHashMap<>();while (peek().type() != TType.RBRACE && peek().type() != TType.EOF) {String key = expectStringOrIdent();consume(TType.COLON);- item.put(key, parseValue());- if (peek().type() == TType.COMMA) advance();+ fields.put(key, parseValue(literalPath == null ? null : literalPath + "." + key));+ if (peek().type() == TType.COMMA) {+ advance();+ }}consume(TType.RBRACE);- return new Stmt.Insert(table, item);+ return fields;}// UPDATE "Table" SET attr=val [, …] [REMOVE attr [, …]] WHERE …private Stmt.Update parseUpdate() {consume(TType.UPDATE);- String table = expectIdent();- List<Assign> sets = new ArrayList<>();- List<String> removes = new ArrayList<>();+ String table = expectTableName();+ String index = parseIndexQualifier();+ List<SetClause> sets = new ArrayList<>();+ List<Path> removes = new ArrayList<>();while (peek().type() == TType.SET || peek().type() == TType.REMOVE) {if (peek().type() == TType.SET) {advance();@@ -237,62 +488,275 @@ public class DynamoDbPartiQLParser {while (peek().type() == TType.COMMA) { advance(); sets.add(parseAssign()); }} else {advance();- removes.add(expectIdent());- while (peek().type() == TType.COMMA) { advance(); removes.add(expectIdent()); }+ removes.add(parsePath());+ while (peek().type() == TType.COMMA) { advance(); removes.add(parsePath()); }}}consume(TType.WHERE);- return new Stmt.Update(table, sets, removes, parseConditions());+ List<Cond> where = parseConditions();+ return new Stmt.Update(table, index, sets, removes, where, parseReturning());}- // DELETE FROM "Table" WHERE …private Stmt.Delete parseDelete() {consume(TType.DELETE);consume(TType.FROM);- String table = expectIdent();+ String table = expectTableName();+ String index = parseIndexQualifier();consume(TType.WHERE);- return new Stmt.Delete(table, parseConditions());+ List<Cond> where = parseConditions();+ Returning returning = parseReturning();+ if (returning != Returning.NONE && returning != Returning.ALL_OLD) {+ throw validationEx("Invalid returning clause: " + returning.clause()+ + ". Only RETURNING ALL OLD * is allowed in DELETE statements.");+ }+ return new Stmt.Delete(table, index, where, returning);+ }++ private String expectTableName() {+ String table = expectIdent();+ requireNonEmptyPathComponent(table);+ return table;+ }++ private String parseIndexQualifier() {+ if (peek().type() != TType.DOT) {+ return null;+ }+ advance();+ String index = expectIdent();+ requireNonEmptyPathComponent(index);+ if (peek().type() == TType.DOT) {+ throw validationEx("A path may contain at most 2 components in the FROM clause");+ }+ return index;+ }++ private static void requireNonEmptyPathComponent(String component) {+ if (component.isEmpty()) {+ throw validationEx("Path component cannot be an empty string");+ }+ }++ private Returning parseReturning() {+ if (peek().type() != TType.RETURNING) {+ return Returning.NONE;+ }+ advance();+ TType scope = advance().type();+ TType age = advance().type();+ Returning returning = returningOf(scope, age);+ Token star = advance();+ if (!"*".equals(star.value())) {+ throw validationEx("Expected * in the RETURNING clause, got: '" + star.value() + "'");+ }+ return returning;+ }++ private static Returning returningOf(TType scope, TType age) {+ if (scope == TType.ALL && age == TType.OLD) {+ return Returning.ALL_OLD;+ }+ if (scope == TType.ALL && age == TType.NEW) {+ return Returning.ALL_NEW;+ }+ if (scope == TType.MODIFIED && age == TType.OLD) {+ return Returning.MODIFIED_OLD;+ }+ if (scope == TType.MODIFIED && age == TType.NEW) {+ return Returning.MODIFIED_NEW;+ }+ throw validationEx("Expected ALL or MODIFIED and OLD or NEW in the RETURNING clause");}private List<Cond> parseConditions() {- List<Cond> conds = new ArrayList<>();- conds.add(parseCond());- while (peek().type() == TType.AND) { advance(); conds.add(parseCond()); }- return conds;+ Cond cond = parseOr();+ return cond instanceof Cond.And and ? and.operands() : List.of(cond);+ }++ private Cond parseOr() {+ List<Cond> operands = new ArrayList<>();+ operands.add(parseAnd());+ while (peek().type() == TType.OR) {+ advance();+ operands.add(parseAnd());+ }+ return operands.size() == 1 ? operands.getFirst() : new Cond.Or(List.copyOf(operands));+ }++ private Cond parseAnd() {+ List<Cond> operands = new ArrayList<>();+ addAndOperand(operands, parseNot());+ while (peek().type() == TType.AND) {+ advance();+ addAndOperand(operands, parseNot());+ }+ return operands.size() == 1 ? operands.getFirst() : new Cond.And(List.copyOf(operands));+ }++ private static void addAndOperand(List<Cond> operands, Cond operand) {+ if (operand instanceof Cond.And and) {+ operands.addAll(and.operands());+ } else {+ operands.add(operand);+ }+ }++ private Cond parseNot() {+ if (peek().type() == TType.NOT) {+ advance();+ return new Cond.Not(parseNot());+ }+ return parseComparison();+ }++ private static final Set<TType> COMPARISONS = EnumSet.of(TType.EQ, TType.NE, TType.LT, TType.LE, TType.GT, TType.GE);++ private static final List<String> PREDICATE_FUNCTIONS =+ List.of("begins_with", "contains", "attribute_type", "attribute_exists", "attribute_not_exists");++ private Cond parseComparison() {+ if (peek().type() == TType.BOOL+ && (tokens.get(pos + 1).type() == TType.EQ || tokens.get(pos + 1).type() == TType.NE)) {+ boolean flag = Boolean.parseBoolean(advance().value());+ boolean equal = advance().type() == TType.EQ;+ Cond predicate = parseCond();+ return flag == equal ? predicate : new Cond.Not(predicate);+ }+ Cond cond = parseCond();+ if (peek().type() == TType.BETWEEN) {+ throw incorrectOperandType("BETWEEN", "BOOL");+ }+ if (peek().type() == TType.IN) {+ advance();+ consume(TType.LBRACKET);+ List<Cond> matches = new ArrayList<>();+ matches.add(conditionEquals(cond));+ while (peek().type() == TType.COMMA) {+ advance();+ matches.add(conditionEquals(cond));+ }+ consume(TType.RBRACKET);+ return matches.size() == 1 ? matches.getFirst() : new Cond.Or(List.copyOf(matches));+ }+ if (!COMPARISONS.contains(peek().type())) {+ return cond;+ }+ String op = parseOp();+ if (!"=".equals(op) && !"<>".equals(op)) {+ throw incorrectOperandType(op, "BOOL");+ }+ Cond equal = conditionEquals(cond);+ return "=".equals(op) ? equal : new Cond.Not(equal);+ }++ private Cond conditionEquals(Cond cond) {+ boolean predicateNext = peek().type() == TType.LPAREN+ || PREDICATE_FUNCTIONS.stream().anyMatch(this::peekFunction);+ if (predicateNext) {+ Cond other = parseCond();+ return sameTruth(cond, other, new Cond.Not(other));+ }+ if (peek().type() == TType.IDENT) {+ Path path = parsePath();+ return sameTruth(cond, new Cond.Eq(path, new PVal.Bool(true)), new Cond.Eq(path, new PVal.Bool(false)));+ }+ if (parseValue() instanceof PVal.Bool flag) {+ return flag.v() ? cond : new Cond.Not(cond);+ }+ return new Cond.And(List.of(cond, new Cond.Not(cond)));+ }++ private static Cond sameTruth(Cond cond, Cond whenTrue, Cond whenFalse) {+ return new Cond.Or(List.of(new Cond.And(List.of(cond, whenTrue)),+ new Cond.And(List.of(new Cond.Not(cond), whenFalse))));}// S, N and B are the only types DynamoDB gives an ordering.- private static final Set<String> ORDERED_TYPES = Set.of("S", "N", "B");+ static final Set<String> ORDERED_TYPES = Set.of("S", "N", "B");- private static String typeCode(PVal val) {+ static String typeCode(PVal val) {return switch (val) {case PVal.Str ignored -> "S";case PVal.Num ignored -> "N";case PVal.Bool ignored -> "BOOL";case PVal.Null ignored -> "NULL";case PVal.Av av -> av.type();+ case PVal.ListOf ignored -> "L";+ case PVal.Tuple ignored -> "M";+ case PVal.Bag bag -> bag.type();};}private static void requireOrdered(String op, PVal val) {- String type = typeCode(val);- if (!ORDERED_TYPES.contains(type)) {- throw validationEx("Incorrect operand type for operator or function; "- + "operator or function: " + op + ", operand type: " + type);+ if (!ORDERED_TYPES.contains(typeCode(val))) {+ throw incorrectOperandType(op, val);}}+ private static AwsException incorrectOperandType(String op, PVal val) {+ return incorrectOperandType(op, typeCode(val));+ }++ private static AwsException incorrectOperandType(String op, String type) {+ return validationEx("Incorrect operand type for operator or function; "+ + "operator or function: " + op + ", operand type: " + type);+ }+private Cond parseCond() {+ if (peek().type() == TType.LPAREN) {+ advance();+ Cond grouped = parseOr();+ consume(TType.RPAREN);+ return grouped;+ }if (peek().type() == TType.IDENT && "begins_with".equalsIgnoreCase(peek().value())) {advance();consume(TType.LPAREN);- String attr = expectIdent();+ Path path = parsePath();consume(TType.COMMA);PVal prefix = parseValue();consume(TType.RPAREN);- return new Cond.BeginsWith(attr, prefix);+ return new Cond.BeginsWith(path, prefix);}- String attr = expectIdent();+ if (peekFunction("contains")) {+ advance();+ consume(TType.LPAREN);+ Path path = parsePath();+ consume(TType.COMMA);+ PVal operand = parseValue();+ consume(TType.RPAREN);+ return new Cond.Contains(path, operand);+ }+ if (peekFunction("attribute_type")) {+ advance();+ consume(TType.LPAREN);+ Path path = parsePath();+ consume(TType.COMMA);+ PVal type = parseValue();+ consume(TType.RPAREN);+ requireAttributeTypeName(type);+ return new Cond.AttributeType(path, type);+ }+ if (peekFunction("attribute_exists") || peekFunction("attribute_not_exists")) {+ boolean exists = "attribute_exists".equalsIgnoreCase(advance().value());+ consume(TType.LPAREN);+ Path path = parsePath();+ consume(TType.RPAREN);+ return new Cond.Missing(path, exists);+ }+ if (peekFunction("size")) {+ advance();+ consume(TType.LPAREN);+ Path path = parsePath();+ consume(TType.RPAREN);+ String op = parseOp();+ PVal val = parseValue();+ if (!"=".equals(op) && !"<>".equals(op)) {+ requireOrdered(op, val);+ }+ return new Cond.SizeCmp(path, op, val);+ }+ Path path = parsePath();if (peek().type() == TType.BETWEEN) {advance();PVal lo = parseValue();@@ -300,17 +764,62 @@ public class DynamoDbPartiQLParser {PVal hi = parseValue();requireOrdered("BETWEEN", lo);requireOrdered("BETWEEN", hi);- return new Cond.Between(attr, lo, hi);+ return new Cond.Between(path, lo, hi);+ }+ if (peek().type() == TType.IN) {+ advance();+ consume(TType.LBRACKET);+ List<PVal> values = new ArrayList<>();+ values.add(parseValue());+ while (peek().type() == TType.COMMA) {+ advance();+ values.add(parseValue());+ }+ consume(TType.RBRACKET);+ return new Cond.In(path, List.copyOf(values));+ }+ if (peek().type() == TType.IS) {+ advance();+ boolean negated = peek().type() == TType.NOT;+ if (negated) {+ advance();+ }+ if (peek().type() == TType.NULL) {+ advance();+ return new Cond.IsNull(path, negated);+ }+ consume(TType.MISSING);+ return new Cond.Missing(path, negated);}String op = parseOp();PVal val = parseValue();if ("=".equals(op)) {- return new Cond.Eq(attr, val);+ return new Cond.Eq(path, val);}if (!"<>".equals(op)) {requireOrdered(op, val);}- return new Cond.Cmp(attr, op, val);+ return new Cond.Cmp(path, op, val);+ }++ private boolean peekFunction(String name) {+ return peek().type() == TType.IDENT && name.equalsIgnoreCase(peek().value())+ && tokens.get(pos + 1).type() == TType.LPAREN;+ }++ private static final Set<String> SET_TYPES = Set.of("SS", "NS", "BS");++ private static final List<String> ATTRIBUTE_TYPE_NAMES =+ List.of("N", "BS", "L", "B", "NULL", "M", "S", "SS", "NS", "BOOL");++ private static void requireAttributeTypeName(PVal type) {+ if (!(type instanceof PVal.Str name)) {+ throw incorrectOperandType("attribute_type", type);+ }+ if (!ATTRIBUTE_TYPE_NAMES.contains(name.v())) {+ throw validationEx("Invalid attribute type name found; type: " + name.v()+ + ", valid types: {" + String.join(",", ATTRIBUTE_TYPE_NAMES) + "}");+ }}private String parseOp() {@@ -323,24 +832,215 @@ public class DynamoDbPartiQLParser {};}- private Assign parseAssign() {- String attr = expectIdent();+ private SetClause parseAssign() {+ Path path = parsePath();consume(TType.EQ);- return new Assign(attr, parseValue());+ if (peekFunction("set_add") || peekFunction("set_delete")) {+ return parseSetMutation(path);+ }+ Operand left = parseOperand();+ if (peek().type() == TType.PLUS || peek().type() == TType.MINUS) {+ String op = advance().value();+ Operand right = parseOperand();+ requireNumberLiteral(op, left);+ requireNumberLiteral(op, right);+ return new Assign(path, left, op, right);+ }+ return new Assign(path, left, null, null);+ }++ private static void requireNumberLiteral(String op, Operand operand) {+ if (operand instanceof Operand.Value value && !(value.val() instanceof PVal.Num)) {+ throw incorrectOperandType(op, value.val());+ }+ }++ private SetClause parseSetMutation(Path target) {+ Token function = advance();+ String name = function.value().toUpperCase(Locale.ROOT);+ consume(TType.LPAREN);+ Token firstArgument = peek();+ if (!parsePath().equals(target)) {+ throw validationEx("The first argument to " + name + " must equal the assignment value at "+ + position(function));+ }+ consume(TType.COMMA);+ PVal bag = parseValue();+ consume(TType.RPAREN);+ if (!SET_TYPES.contains(typeCode(bag))) {+ throw validationEx("The second argument to " + name + " must be a value with type SET at "+ + position(firstArgument));+ }+ return "set_add".equalsIgnoreCase(function.value()) ? new SetAdd(target, bag) : new SetDelete(target, bag);+ }++ private String position(Token token) {+ boolean quoted = statement.charAt(token.start()) == '"';+ return position(token.start(), token.value().length() + (quoted ? 2 : 0));+ }++ private String position(int start, int length) {+ int lineStart = statement.lastIndexOf('\n', start - 1) + 1;+ long line = statement.substring(0, start).chars().filter(c -> c == '\n').count() + 1;+ return line + ":" + (start - lineStart + 1) + ":" + length;+ }++ private Operand parseOperand() {+ if (peekFunction("list_append")) {+ advance();+ consume(TType.LPAREN);+ Operand first = parseOperand();+ consume(TType.COMMA);+ Operand second = parseOperand();+ consume(TType.RPAREN);+ return new Operand.ListAppend(first, second);+ }+ if (peek().type() == TType.IDENT) {+ return new Operand.Attribute(parsePath());+ }+ return new Operand.Value(parseValue());+ }++ private Path parsePath() {+ List<Seg> segments = new ArrayList<>();+ segments.add(new Seg.Name(expectIdent()));+ while (true) {+ switch (peek().type()) {+ case DOT -> {+ advance();+ segments.add(new Seg.Name(expectIdent()));+ }+ case LBRACKET -> {+ advance();+ segments.add(new Seg.Index(expectListIndex()));+ consume(TType.RBRACKET);+ }+ default -> {+ return new Path(List.copyOf(segments));+ }+ }+ }+ }++ private long expectListIndex() {+ Token t = advance();+ if (t.type() == TType.NUMBER) {+ try {+ long index = Long.parseLong(t.value());+ if (index < 0 || index > Integer.MAX_VALUE) {+ int sign = index < 0 ? 1 : 0;+ throw validationEx("List index is not within the allowable range; index: [" + t.value() + "] at "+ + position(t.start() + sign, t.value().length() - sign));+ }+ return index;+ } catch (NumberFormatException expected) {+ // Falls through to the shared rejection below.+ }+ }+ throw validationEx("Expected a list index, got: '" + t.value() + "'");}private PVal parseValue() {+ return parseValue(null);+ }++ private PVal parseValue(String literalPath) {+ if (literalDepth == DynamoDbAttributeValueValidator.MAX_NESTING_LEVELS) {+ throw validationEx(DynamoDbAttributeValueValidator.NESTING_EXCEEDED + " under " + literalPath);+ }Token t = advance();+ String nested = literalPath == null ? "root" : literalPath;return switch (t.type()) {case STRING -> new PVal.Str(t.value());case NUMBER -> new PVal.Num(t.value());case BOOL -> new PVal.Bool(Boolean.parseBoolean(t.value()));case NULL -> new PVal.Null();- case QUESTION -> resolveParam();+ case QUESTION -> {+ if (literalPath != null) {+ throw validationEx("Unsupported data type: Parameter under key " + literalPath + " at "+ + position(t.start(), 1));+ }+ yield resolveParam();+ }+ case LBRACKET, LBRACE, LBAG -> parseCollection(t, nested);+ case PLUS, MINUS -> parseSignedNumber(t);default -> throw validationEx("Expected value literal or ?, got: " + t.value());};}+ private PVal parseCollection(Token open, String literalPath) {+ literalDepth++;+ PVal collection = switch (open.type()) {+ case LBRACKET -> new PVal.ListOf(parseListItems(literalPath));+ case LBRACE -> new PVal.Tuple(parseTupleFields(literalPath));+ default -> parseBag(literalPath);+ };+ literalDepth--;+ return collection;+ }++ private PVal.Num parseSignedNumber(Token sign) {+ Token operand = advance();+ PVal.Num number = switch (operand.type()) {+ case NUMBER -> new PVal.Num(operand.value());+ case PLUS, MINUS -> parseSignedNumber(operand);+ default -> throw validationEx("Unsupported operator in Condition Expression. Operator: " + sign.value());+ };+ if (sign.type() == TType.PLUS) {+ return number;+ }+ return new PVal.Num(number.v().startsWith("-") ? number.v().substring(1) : "-" + number.v());+ }++ private List<PVal> parseListItems(String literalPath) {+ List<PVal> items = new ArrayList<>();+ while (peek().type() != TType.RBRACKET && peek().type() != TType.EOF) {+ items.add(parseValue(literalPath + "[" + items.size() + "]"));+ if (peek().type() == TType.COMMA) {+ advance();+ }+ }+ consume(TType.RBRACKET);+ return List.copyOf(items);+ }++ private PVal.Bag parseBag(String literalPath) {+ List<PVal> members = new ArrayList<>();+ while (peek().type() != TType.RBAG && peek().type() != TType.EOF) {+ members.add(parseValue(literalPath));+ if (peek().type() == TType.COMMA) {+ advance();+ }+ }+ consume(TType.RBAG);+ if (members.isEmpty()) {+ throw validationEx("Empty bags are not supported");+ }+ String memberType = typeCode(members.getFirst());+ boolean uniform = members.stream().allMatch(m -> typeCode(m).equals(memberType));+ if (!uniform || !(memberType.equals("S") || memberType.equals("N"))) {+ throw validationEx(+ "Unsupported data type in Bag. DynamoDB only supports either numbers or strings in bags");+ }+ requireDistinctMembers(memberType, members);+ return new PVal.Bag(memberType + "S", List.copyOf(members));+ }++ private static void requireDistinctMembers(String memberType, List<PVal> members) {+ boolean numbers = memberType.equals("N");+ List<String> texts = members.stream()+ .map(member -> member instanceof PVal.Num n ? n.v() : ((PVal.Str) member).v())+ .toList();+ long distinct = texts.stream()+ .map(text -> numbers ? DynamoDbNumberUtils.validateAndNormalize(text) : text)+ .distinct()+ .count();+ if (distinct < texts.size()) {+ throw validationEx("One or more parameter values were invalid: Input collection ["+ + String.join(", ", texts) + "] contains duplicates" + (numbers ? "! under root" : "."));+ }+ }+private PVal resolveParam() {if (paramIdx >= parameters.size()) {throw validationEx("Not enough parameters supplied for ? placeholders");diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.javaindex 539a017f15..566aa28625 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.java@@ -633,6 +633,7 @@ public class DynamoDbService implements ResourceProvider {if (conditionExpression != null) {evaluateCondition(existing, conditionExpression, exprAttrNames, exprAttrValues, returnValuesOnConditionCheckFailure);}+ requireItemNestingWithinLimit(normalizedItem);tableItems.put(itemKey, normalizedItem);if (shouldPersist) {@@ -922,6 +923,7 @@ public class DynamoDbService implements ResourceProvider {// Reject any attempt to modify a key attributevalidateKeyNotModified(table, key, item);+ requireItemNestingWithinLimit(item);// AWS validates index key values against the item the update produces.validateIndexKeyTypes(table, item, true);@@ -1466,7 +1468,7 @@ public class DynamoDbService implements ResourceProvider {for (int i = 0; i < transactItems.size(); i++) {try {validateTransactItem(transactItems.get(i), region, staged);- } catch (KeySchemaMismatchException e) {+ } catch (KeySchemaMismatchException | ItemNestingExceededException e) {throw cancelledByMember(transactItems.size(), i, e.getMessage());}}@@ -1610,6 +1612,12 @@ public class DynamoDbService implements ResourceProvider {}}+ private static void requireItemNestingWithinLimit(JsonNode item) {+ if (!DynamoDbAttributeValueValidator.nestingWithinLimit(item)) {+ throw new ItemNestingExceededException();+ }+ }+private static TransactionCanceledException cancelledByMember(int memberCount, int failedMember,String message) {List<TransactionCanceledException.CancellationReason> reasons = new ArrayList<>();@@ -1712,6 +1720,7 @@ public class DynamoDbService implements ResourceProvider {DynamoDbItemSize.validateSize(normalizedItem);buildItemKey(table, normalizedItem);validateIndexKeyTypes(table, normalizedItem, false);+ requireItemNestingWithinLimit(normalizedItem);} else if (transactItem.has("Delete")) {JsonNode del = transactItem.get("Delete");String tableName = canonicalTableName(region, del.path("TableName").asText());@@ -1743,6 +1752,7 @@ public class DynamoDbService implements ResourceProvider {applyUpdateExpression(item, updateExpression, exprAttrNames, exprAttrValues);}validateKeyNotModified(table, key, item);+ requireItemNestingWithinLimit(item);validateIndexKeyTypes(table, item, true);}}@@ -2271,7 +2281,6 @@ public class DynamoDbService implements ResourceProvider {String attrPath = clause.substring(0, eqIdx).trim();touched.add(attrPath);- String attrName = resolveAttributeName(attrPath, exprAttrNames);String rest = clause.substring(eqIdx + 1).trim();@@ -2335,7 +2344,7 @@ public class DynamoDbService implements ResourceProvider {// if_not_exists(attrRef, fallbackExpr) evaluates to:// attrRef's current value — when attrRef exists in the item// fallbackExpr — otherwise- // The result is always assigned to attrName.+ // The result is always assigned to attrPath.String[] args = extractFunctionArgs(valuePart);if (args.length == 2) {String checkAttr = resolveAttributeName(args[0].trim(), exprAttrNames);@@ -2380,7 +2389,7 @@ public class DynamoDbService implements ResourceProvider {ObjectNode result =JsonNodeFactory.instance.objectNode();result.set("L", merged);- item.set(attrName, result);+ setValueAtPath(item, attrPath, result, exprAttrNames);}}} else if (valuePart.startsWith(":") && exprAttrValues != null) {@@ -2532,6 +2541,7 @@ public class DynamoDbService implements ResourceProvider {* - For sets (SS, NS, BS): adds elements to the existing set, or creates the set if it doesn't exist*/private JsonNode applyAddOperation(JsonNode existingValue, JsonNode addValue) {+ requireSameTypeAsOperand(existingValue, addValue, List.of("N", "SS", "NS", "BS"));ObjectNode result = JsonNodeFactory.instance.objectNode();// Handle number addition@@ -2646,13 +2656,61 @@ public class DynamoDbService implements ResourceProvider {return clause;}+ private static final Map<String, String> OPERAND_TYPE_NAMES = Map.of(+ "S", "STRING", "N", "NUMBER", "B", "Binary", "BOOL", "BOOL", "NULL", "NULL", "L", "LIST", "M", "MAP");++ void requireAddOrDeleteOperandTypes(String updateExpression, JsonNode exprAttrValues, boolean inValidationEnvelope) {+ if (updateExpression == null || exprAttrValues == null) {+ return;+ }+ String remaining = updateExpression.trim().replaceAll("\\s+", " ");+ while (!remaining.isEmpty()) {+ String keyword = remaining.substring(0, Math.max(remaining.indexOf(' '), 0)).toUpperCase();+ String body = remaining.substring(keyword.length()).trim();+ int nextClause = findNextClauseKeyword(body);+ String actions = nextClause < 0 ? body : body.substring(0, nextClause);+ remaining = nextClause < 0 ? "" : body.substring(nextClause);+ Set<String> allowed = switch (keyword) {+ case "ADD" -> Set.of("N", "SS", "NS", "BS");+ case "DELETE" -> Set.of("SS", "NS", "BS");+ default -> null;+ };+ while (allowed != null && !actions.isBlank()) {+ int comma = findNextComma(actions);+ String[] words = (comma < 0 ? actions : actions.substring(0, comma)).trim().split(" ");+ actions = comma < 0 ? "" : actions.substring(comma + 1);+ JsonNode operand = exprAttrValues.get(words[words.length - 1]);+ if (operand == null) {+ continue;+ }+ String type = DynamoDbAttributeValueValidator.typeOf(operand);+ if (!allowed.contains(type)) {+ throw new AwsException("ValidationException", (inValidationEnvelope ? "1 validation error detected: " : "")+ + "Invalid UpdateExpression: Incorrect operand type for operator or function;"+ + " operator: " + keyword + ", operand type: " + OPERAND_TYPE_NAMES.get(type)+ + ", typeSet: ALLOWED_FOR_ADD_OPERAND", 400);+ }+ }+ }+ }++ private static void requireSameTypeAsOperand(JsonNode existingValue, JsonNode operand, List<String> types) {+ for (String type : types) {+ if (operand.has(type) && existingValue != null && !existingValue.has(type)) {+ throw new AwsException("ValidationException",+ "An operand in the update expression has an incorrect data type", 400);+ }+ }+ }+/*** Implements DynamoDB DELETE operation semantics:* removes the specified elements from a set attribute (SS, NS, BS).* Returns null if the resulting set is empty (caller should remove the attribute).- * Returns the existing value unchanged if types don't match or the value isn't a set.+ * Returns the existing value unchanged if the value to delete isn't a set.*/private JsonNode applyDeleteOperation(JsonNode existingValue, JsonNode deleteValue) {+ requireSameTypeAsOperand(existingValue, deleteValue, List.of("SS", "NS", "BS"));ObjectNode result = JsonNodeFactory.instance.objectNode();if (deleteValue.has("SS") && existingValue.has("SS")) {diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/ExpressionEvaluator.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/ExpressionEvaluator.javaindex 762cc00919..61e9fa2234 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/ExpressionEvaluator.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/ExpressionEvaluator.java@@ -711,7 +711,7 @@ final class ExpressionEvaluator {JsonNode leftNode = resolveAttributeValue(cmp.left(), item, exprAttrNames, exprAttrValues);JsonNode rightNode = resolveAttributeValue(cmp.right(), item, exprAttrNames, exprAttrValues);- if (leftNode == null || rightNode == null) return false;+ if (leftNode == null || rightNode == null || !sameType(leftNode, rightNode)) return false;int cmpResult = compareAttributeValues(leftNode, rightNode);return switch (cmp.op()) {case LT -> cmpResult < 0;@@ -727,10 +727,14 @@ final class ExpressionEvaluator {JsonNode val = resolveAttributeValue(bet.value(), item, exprAttrNames, exprAttrValues);JsonNode low = resolveAttributeValue(bet.low(), item, exprAttrNames, exprAttrValues);JsonNode high = resolveAttributeValue(bet.high(), item, exprAttrNames, exprAttrValues);- if (val == null || low == null || high == null) return false;+ if (val == null || low == null || high == null || !sameType(val, low) || !sameType(val, high)) return false;return compareAttributeValues(val, low) >= 0 && compareAttributeValues(val, high) <= 0;}+ private static boolean sameType(JsonNode left, JsonNode right) {+ return left.fieldNames().next().equals(right.fieldNames().next());+ }+private static boolean evaluateIn(InExpr in, JsonNode item,JsonNode exprAttrNames, JsonNode exprAttrValues) {// For IN, we use type-aware equality via the raw attribute value nodesdiff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/ItemNestingExceededException.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/ItemNestingExceededException.javanew file mode 100644index 0000000000..f2415cd79c--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/ItemNestingExceededException.java@@ -0,0 +1,10 @@+package io.github.hectorvent.floci.services.dynamodb;++import io.github.hectorvent.floci.core.common.AwsException;++public class ItemNestingExceededException extends AwsException {++ public ItemNestingExceededException() {+ super("ValidationException", DynamoDbAttributeValueValidator.NESTING_EXCEEDED, 400);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAddDeleteOperandIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAddDeleteOperandIntegrationTest.javanew file mode 100644index 0000000000..02a05d789e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAddDeleteOperandIntegrationTest.java@@ -0,0 +1,115 @@+package io.github.hectorvent.floci.services.dynamodb;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.contains;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.nullValue;++/**+ * ADD and DELETE operand types, with every expectation captured from real DynamoDB (eu-west-2, 2026-09-17).+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class DynamoDbAddDeleteOperandIntegrationTest {++ private static final String CONTENT_TYPE = "application/x-amz-json-1.0";+ private static final String TABLE = "add-delete-operands";+ private static final String KEY = "{\"pk\":{\"S\":\"a\"}}";+ private static final String REFUSED = "Invalid UpdateExpression: Incorrect operand type for operator or function;"+ + " operator: %s, operand type: %s, typeSet: ALLOWED_FOR_ADD_OPERAND";++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ @Order(1)+ void createTable() {+ request("DynamoDB_20120810.CreateTable", """+ {+ "TableName": "%s",+ "AttributeDefinitions": [{"AttributeName":"pk","AttributeType":"S"}],+ "KeySchema": [{"AttributeName":"pk","KeyType":"HASH"}],+ "BillingMode": "PAY_PER_REQUEST"+ }+ """.formatted(TABLE))+ .statusCode(200);+ request("DynamoDB_20120810.PutItem", """+ {"TableName":"%s","Item":{"pk":{"S":"a"},"n":{"N":"5"},"s":{"SS":["m"]}}}+ """.formatted(TABLE))+ .statusCode(200);+ }++ @Test+ @Order(2)+ void updateItemRefusesAnOperandBeforeReadingTheItem() {+ updateItem("\"UpdateExpression\":\"ADD n :v\",\"ExpressionAttributeValues\":{\":v\":{\"S\":\"x\"}}")+ .statusCode(400)+ .body("message", equalTo("1 validation error detected: " + REFUSED.formatted("ADD", "STRING")));+ updateItem("\"UpdateExpression\":\"SET t = :t ADD n :v\","+ + "\"ExpressionAttributeValues\":{\":t\":{\"S\":\"t\"},\":v\":{\"BOOL\":true}}")+ .statusCode(400)+ .body("message", equalTo("1 validation error detected: " + REFUSED.formatted("ADD", "BOOL")));+ updateItem("\"UpdateExpression\":\"DELETE nope :v\",\"ConditionExpression\":\"attribute_exists(nope)\","+ + "\"ExpressionAttributeValues\":{\":v\":{\"L\":[{\"S\":\"m\"}]}}")+ .statusCode(400)+ .body("message", equalTo("1 validation error detected: " + REFUSED.formatted("DELETE", "LIST")));+ updateItem("\"UpdateExpression\":\"DELETE s :v\",\"ExpressionAttributeValues\":{\":v\":{\"N\":\"1\"}}")+ .statusCode(400)+ .body("message", equalTo("1 validation error detected: " + REFUSED.formatted("DELETE", "NUMBER")));+ request("DynamoDB_20120810.UpdateItem", """+ {"TableName":"add-delete-operands-missing","Key":%s,"UpdateExpression":"ADD n :v",+ "ExpressionAttributeValues":{":v":{"S":"x"}}}+ """.formatted(KEY))+ .statusCode(400)+ .body("message", equalTo("1 validation error detected: " + REFUSED.formatted("ADD", "STRING")));+ assertItemUnchanged();+ }++ @Test+ @Order(3)+ void transactWriteItemsRefusesAnOperandWithoutTheErrorCount() {+ request("DynamoDB_20120810.TransactWriteItems", """+ {"TransactItems":[{"Update":{"TableName":"%s","Key":%s,"UpdateExpression":"ADD n :v",+ "ExpressionAttributeValues":{":v":{"S":"x"}}}}]}+ """.formatted(TABLE, KEY))+ .statusCode(400)+ .body("message", equalTo(REFUSED.formatted("ADD", "STRING")));+ assertItemUnchanged();+ }++ private static void assertItemUnchanged() {+ request("DynamoDB_20120810.GetItem", """+ {"TableName":"%s","Key":%s,"ConsistentRead":true}+ """.formatted(TABLE, KEY))+ .statusCode(200)+ .body("Item.n.N", equalTo("5"))+ .body("Item.s.SS", contains("m"))+ .body("Item.t", nullValue());+ }++ private static ValidatableResponse updateItem(String expression) {+ return request("DynamoDB_20120810.UpdateItem",+ "{\"TableName\":\"" + TABLE + "\",\"Key\":" + KEY + "," + expression + "}");+ }++ private static ValidatableResponse request(String target, String body) {+ return given()+ .header("X-Amz-Target", target)+ .contentType(CONTENT_TYPE)+ .body(body)+ .when()+ .post("/")+ .then();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandlerTest.javaindex 631c18fa6e..4c35d41f0b 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandlerTest.java@@ -1322,6 +1322,24 @@ class DynamoDbJsonHandlerTest {assertEquals(NESTING_MESSAGE, ex.getMessage());}+ @Test+ void updateItemRejectsAValueThatLeavesALeafAtLevel33UnderANestedPath() throws Exception {+ createUsersTable("eu-west-1");+ ObjectNode create = updateUserRequest();+ create.put("UpdateExpression", "SET parent = :empty");+ ObjectNode emptyMap = mapper.createObjectNode();+ emptyMap.putObject("M");+ create.set("ExpressionAttributeValues", mapper.createObjectNode().set(":empty", emptyMap));+ handler.handle("UpdateItem", create, "eu-west-1");++ ObjectNode request = updateUserRequest();+ request.put("UpdateExpression", "SET parent.deep = :deep");+ request.set("ExpressionAttributeValues", mapper.createObjectNode().set(":deep", nestedMaps(31)));+ AwsException ex = assertThrows(AwsException.class,+ () -> handler.handle("UpdateItem", request, "eu-west-1"));+ assertEquals("Nesting Levels have exceeded supported limits", ex.getMessage());+ }+private ObjectNode transactWrite(String action, ObjectNode op) {op.put("TableName", "Users");var member = mapper.createObjectNode();@@ -1662,17 +1680,30 @@ class DynamoDbJsonHandlerTest {createUsersTable("eu-west-1");var request = mapper.createObjectNode();request.put("Statement", "UPDATE \"Users\" SET deep=? WHERE userId=?");- request.set("Parameters", mapper.createArrayNode().add(nestedMaps(32)).add(attributeValue("S", "u1")));+ request.set("Parameters", mapper.createArrayNode().add(nestedMaps(33)).add(attributeValue("S", "u1")));var ex = assertThrows(AwsException.class,() -> handler.handle("ExecuteStatement", request, "eu-west-1"));assertEquals("ValidationException", ex.getErrorCode());- assertEquals("Nesting Levels have exceeded supported limits", ex.getMessage());+ assertEquals("Nesting Levels have exceeded supported limits: "+ + "Attributes in the item have nested levels beyond supported limit", ex.getMessage());+ }++ @Test+ void executeStatementReadsAParameterWithALeafAtLevel33() throws Exception {+ createUsersTable("eu-west-1");+ ObjectNode request = mapper.createObjectNode();+ request.put("Statement", "SELECT * FROM \"Users\" WHERE userId=? AND deep=?");+ request.set("Parameters", mapper.createArrayNode().add(attributeValue("S", "u1")).add(nestedMaps(32)));++ Response response = handler.handle("ExecuteStatement", request, "eu-west-1");+ assertEquals(200, response.getStatus());}@Test- void executeTransactionCancelsOnATooDeepParameterWithThatStatementsReason() throws Exception {+ void executeTransactionCancelsOnAnItemLeftTooDeepWithThatStatementsReason() throws Exception {createUsersTable("eu-west-1");+ service.putItem("Users", item("userId", "u1"), "eu-west-1");var fine = mapper.createObjectNode();fine.put("Statement", "UPDATE \"Users\" SET x=? WHERE userId=?");fine.set("Parameters", mapper.createArrayNode().add(attributeValue("S", "x")).add(attributeValue("S", "u1")));diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLDocumentedSyntaxIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLDocumentedSyntaxIntegrationTest.javanew file mode 100644index 0000000000..e55cb7ce4d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLDocumentedSyntaxIntegrationTest.java@@ -0,0 +1,372 @@+package io.github.hectorvent.floci.services.dynamodb;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import java.util.Arrays;+import java.util.Base64;+import java.util.List;+import java.util.stream.Collectors;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsInAnyOrder;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasKey;+import static org.hamcrest.Matchers.not;+import static org.hamcrest.Matchers.notNullValue;+import static org.hamcrest.Matchers.nullValue;++/**+ * The PartiQL forms the AWS developer guide shows, with every expectation captured from real+ * DynamoDB (eu-west-2, 2026-09-17).+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class DynamoDbPartiQLDocumentedSyntaxIntegrationTest {++ private static final String CONTENT_TYPE = "application/x-amz-json-1.0";+ private static final String TABLE = "partiql-documented-syntax";++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ @Order(1)+ void createTable() {+ request("DynamoDB_20120810.CreateTable", """+ {+ "TableName": "%s",+ "AttributeDefinitions": [+ {"AttributeName":"pk","AttributeType":"S"},+ {"AttributeName":"sk","AttributeType":"S"}+ ],+ "KeySchema": [+ {"AttributeName":"pk","KeyType":"HASH"},+ {"AttributeName":"sk","KeyType":"RANGE"}+ ],+ "BillingMode": "PAY_PER_REQUEST"+ }+ """.formatted(TABLE))+ .statusCode(200);+ }++ @Test+ @Order(2)+ void insertsMapsListsAndSets() {+ statement("INSERT INTO \"" + TABLE + "\" value {'pk':'dt', 'sk':'1', 'NumberType':1,"+ + " 'MapType' : {'entryname1': 'value', 'entryname2': 4},"+ + " 'ListType': [1,'stringval'],"+ + " 'NumberSetType':<<1,34,32,4.5>>,"+ + " 'StringSetType':<<'stringval','stringval2'>>}")+ .statusCode(200);++ getItem("dt")+ .body("Item.NumberType.N", equalTo("1"))+ .body("Item.MapType.M.entryname1.S", equalTo("value"))+ .body("Item.MapType.M.entryname2.N", equalTo("4"))+ .body("Item.ListType.L[0].N", equalTo("1"))+ .body("Item.ListType.L[1].S", equalTo("stringval"))+ .body("Item.NumberSetType.NS", containsInAnyOrder("1", "34", "32", "4.5"))+ .body("Item.StringSetType.SS", containsInAnyOrder("stringval", "stringval2"));+ }++ @Test+ @Order(3)+ void updatesWithListAppendAndSetAdd() {+ statement("UPDATE \"" + TABLE + "\""+ + " SET NumberType=NumberType + 100"+ + " SET MapType.NewMapEntry=[2020, 'stringvalue', 2.4]"+ + " SET ListType = LIST_APPEND(ListType, [4, <<'string1', 'string2'>>])"+ + " SET NumberSetType= SET_ADD(NumberSetType, <<345, 48.4>>)"+ + " SET StringSetType = SET_ADD(StringSetType, <<'stringsetvalue1', 'stringsetvalue2'>>)"+ + " WHERE pk='dt' AND sk='1'")+ .statusCode(200);++ getItem("dt")+ .body("Item.NumberType.N", equalTo("101"))+ .body("Item.MapType.M.NewMapEntry.L[0].N", equalTo("2020"))+ .body("Item.MapType.M.NewMapEntry.L[1].S", equalTo("stringvalue"))+ .body("Item.MapType.M.NewMapEntry.L[2].N", equalTo("2.4"))+ .body("Item.ListType.L.size()", equalTo(4))+ .body("Item.ListType.L[3].SS", containsInAnyOrder("string1", "string2"))+ .body("Item.NumberSetType.NS", containsInAnyOrder("1", "4.5", "32", "34", "48.4", "345"))+ .body("Item.StringSetType.SS",+ containsInAnyOrder("stringsetvalue1", "stringsetvalue2", "stringval", "stringval2"));+ }++ @Test+ @Order(4)+ void updatesWithRemoveAndSetDelete() {+ statement("UPDATE \"" + TABLE + "\""+ + " SET NumberType=NumberType - 1"+ + " REMOVE ListType[1]"+ + " REMOVE MapType.NewMapEntry"+ + " SET NumberSetType = SET_DELETE( NumberSetType, <<345>>)"+ + " SET StringSetType = SET_DELETE( StringSetType, <<'stringsetvalue1'>>)"+ + " WHERE pk='dt' AND sk='1'")+ .statusCode(200);++ getItem("dt")+ .body("Item.NumberType.N", equalTo("100"))+ .body("Item.ListType.L.size()", equalTo(3))+ .body("Item.ListType.L[1].N", equalTo("4"))+ .body("Item.MapType.M.NewMapEntry", nullValue())+ .body("Item.NumberSetType.NS", containsInAnyOrder("1", "4.5", "32", "34", "48.4"))+ .body("Item.StringSetType.SS", containsInAnyOrder("stringsetvalue2", "stringval", "stringval2"));+ }++ @Test+ @Order(5)+ void readsExponentsAndDoubledQuotes() {+ statement("INSERT INTO \"" + TABLE + "\" VALUE {'pk':'num', 'sk':'1',"+ + " 'a':1E3, 'b':-1.5e-3, 'c':2.50, 'd':-0, 'q':'it''s here'}")+ .statusCode(200);++ getItem("num")+ .body("Item.a.N", equalTo("1000"))+ .body("Item.b.N", equalTo("-0.0015"))+ .body("Item.c.N", equalTo("2.5"))+ .body("Item.d.N", equalTo("0"))+ .body("Item.q.S", equalTo("it's here"));+ statement("SELECT sk FROM \"" + TABLE + "\" WHERE pk = 'num' AND q = 'it''s here' AND a = 1e3")+ .statusCode(200)+ .body("Items.size()", equalTo(1));+ }++ @Test+ @Order(6)+ void refusesABagDynamoDbCannotStore() {+ statement("INSERT INTO \"" + TABLE + "\" VALUE {'pk':'bag', 'sk':'1', 's':<<>>}")+ .statusCode(400)+ .body("message", equalTo("Empty bags are not supported"));+ statement("INSERT INTO \"" + TABLE + "\" VALUE {'pk':'bag', 'sk':'1', 's':<<1, 'a'>>}")+ .statusCode(400)+ .body("message", equalTo(+ "Unsupported data type in Bag. DynamoDB only supports either numbers or strings in bags"));+ statement("INSERT INTO \"" + TABLE + "\" VALUE {'pk':'bag', 'sk':'1', 's':<<'a', 'a'>>}")+ .statusCode(400)+ .body("message", equalTo(+ "One or more parameter values were invalid: Input collection [a, a] contains duplicates."));+ }++ @Test+ @Order(7)+ void appendsToListsAndChangesSetMembers() {+ putItem("sets", "\"AwardDetail\":{\"M\":{\"Grammys\":{\"L\":[{\"N\":\"2020\"},{\"N\":\"2018\"}]}}},"+ + "\"BandMembers\":{\"SS\":[\"member1\",\"member2\"]},\"Only\":{\"SS\":[\"only\"]}");++ update("sets", "SET AwardDetail.Grammys = list_append(AwardDetail.Grammys, [2016])");+ update("sets", "SET AwardDetail.Grammys = list_append([2010], AwardDetail.Grammys)");+ update("sets", "SET BandMembers = set_add(BandMembers, <<'newbandmember'>>)");+ update("sets", "SET BandMembers = set_delete(BandMembers, <<'member1'>>)");+ update("sets", "SET Fresh = set_add(Fresh, <<'m'>>)");+ update("sets", "SET Only = set_delete(Only, <<'only'>>)");++ getItem("sets")+ .body("Item.AwardDetail.M.Grammys.L.N", equalTo(List.of("2010", "2020", "2018", "2016")))+ .body("Item.'#n0.#n1'", nullValue())+ .body("Item.BandMembers.SS", containsInAnyOrder("member2", "newbandmember"))+ .body("Item.Fresh.SS", containsInAnyOrder("m"))+ .body("Item.Only", nullValue());+ }++ @Test+ @Order(8)+ void refusesMisusedUpdateFunctions() {+ String prefix = "UPDATE \"" + TABLE + "\" SET Other = ";+ statement(prefix + "set_add(BandMembers, <<'x'>>) WHERE pk='sets' AND sk='1'")+ .statusCode(400)+ .body("message", equalTo("The first argument to SET_ADD must equal the assignment value at 1:"+ + (prefix.length() + 1) + ":7"));+ statement("UPDATE \"" + TABLE + "\" SET BandMembers = set_add(BandMembers, <<1>>) WHERE pk='sets' AND sk='1'")+ .statusCode(400)+ .body("message", equalTo("An operand in the update expression has an incorrect data type"));+ statement("UPDATE \"" + TABLE + "\" SET NoList = list_append(NoList, [1]) WHERE pk='sets' AND sk='1'")+ .statusCode(400)+ .body("message", equalTo("The provided expression refers to an attribute that does not exist in the item"));+ }++ @Test+ @Order(9)+ void filtersWithFunctionsAndNullChecks() {+ putItem("fn-1", "\"Address\":{\"S\":\"7834 24th Kirkland\"},\"tags\":{\"SS\":[\"a\",\"b\"]},"+ + "\"Total\":{\"N\":\"400\"},\"nul\":{\"NULL\":true},"+ + "\"Image\":{\"B\":\"" + Base64.getEncoder().encodeToString(new byte[400]) + "\"}");+ putItem("fn-2", "\"Total\":{\"N\":\"550\"}");++ assertKeys("pk IN ['fn-1', 'fn-2'] AND contains(\"Address\", 'Kirkland')", "fn-1");+ assertKeys("pk IN ['fn-1', 'fn-2'] AND contains(tags, 'a')", "fn-1");+ assertKeys("pk IN ['fn-1', 'fn-2'] AND attribute_type(\"Total\", 'N')", "fn-1", "fn-2");+ assertKeys("pk IN ['fn-1', 'fn-2'] AND size(\"Image\") > 300", "fn-1");+ assertKeys("pk IN ['fn-1', 'fn-2'] AND Total != 400", "fn-2");+ assertKeys("pk IN ['fn-1', 'fn-2'] AND nul IS NULL", "fn-1");+ assertKeys("pk IN ['fn-1', 'fn-2'] AND nul IS NOT NULL", "fn-2");+ assertKeys("pk IN ['fn-1', 'fn-2'] AND absent IS NULL");++ statement("SELECT pk FROM \"" + TABLE + "\" WHERE pk = 'fn-1' AND attribute_type(Total, 'X')")+ .statusCode(400)+ .body("message", equalTo(+ "Invalid attribute type name found; type: X, valid types: {N,BS,L,B,NULL,M,S,SS,NS,BOOL}"));+ }++ @Test+ @Order(10)+ void ordersByTheKey() {+ for (String pk : List.of("o", "p")) {+ for (String sk : List.of("1", "2", "3")) {+ request("DynamoDB_20120810.PutItem", """+ {"TableName":"%s","Item":{"pk":{"S":"%s"},"sk":{"S":"%s"}}}+ """.formatted(TABLE, pk, sk))+ .statusCode(200);+ }+ }++ assertOrder("pk = 'o' ORDER BY sk DESC", "o/3", "o/2", "o/1");+ assertOrder("pk = 'o' ORDER BY sk", "o/1", "o/2", "o/3");+ assertOrder("pk = 'o' ORDER BY pk ASC", "o/3", "o/2", "o/1");+ assertOrder("pk IN ['o', 'p'] ORDER BY pk DESC, sk ASC", "p/1", "p/2", "p/3", "o/1", "o/2", "o/3");++ String firstToken = request("DynamoDB_20120810.ExecuteStatement",+ orderedBody("pk IN ['o', 'p'] ORDER BY pk DESC", 2, null))+ .statusCode(200)+ .body("Items.sk.S", equalTo(List.of("3", "2")))+ .body("NextToken", notNullValue())+ .extract().path("NextToken");+ request("DynamoDB_20120810.ExecuteStatement", orderedBody("pk IN ['o', 'p'] ORDER BY pk DESC", 2, firstToken))+ .statusCode(200)+ .body("Items.pk.S", equalTo(List.of("p", "o")))+ .body("Items.sk.S", equalTo(List.of("1", "3")));+ }++ @Test+ @Order(11)+ void refusesAnOrderByItCannotServe() {+ String select = "SELECT sk FROM \"" + TABLE + "\" ";+ statement(select + "ORDER BY sk")+ .statusCode(400)+ .body("message", equalTo("Must have WHERE clause in the statement when using ORDER BY clause."));+ statement(select + "WHERE pk = 'o' ORDER BY Total DESC")+ .statusCode(400)+ .body("message", equalTo("Attribute Total in ORDER BY clause must be part of the primary key"));+ statement(select + "WHERE pk > 'a' ORDER BY sk")+ .statusCode(400)+ .body("message", equalTo("Must have at least one non-optional hash key condition in WHERE clause"+ + " when using ORDER BY clause."));+ statement(select + "WHERE pk IN ['o', 'p'] ORDER BY sk DESC")+ .statusCode(400)+ .body("message", equalTo("Must have hash key in ORDER BY clause when more than one hash key condition"+ + " specified in WHERE clause."));+ }++ @Test+ @Order(12)+ void checksAConditionWithExists() {+ putItem("x1", "\"free\":{\"S\":\"x\"}");+ putItem("x2", "\"free\":{\"S\":\"x\"}");+ putItem("x3", "\"Awards\":{\"N\":\"1\"}");++ transaction("EXISTS(SELECT * FROM \"" + TABLE + "\" WHERE pk = 'x1' AND sk = '1' AND Awards IS MISSING)",+ "UPDATE \"" + TABLE + "\" SET AwardsWon=1 WHERE pk = 'x2' AND sk = '1'")+ .statusCode(200);+ getItem("x2").body("Item.AwardsWon.N", equalTo("1"));++ transaction("EXISTS(SELECT * FROM \"" + TABLE + "\" WHERE pk = 'x3' AND sk = '1' AND Awards IS MISSING)",+ "UPDATE \"" + TABLE + "\" SET Touched=1 WHERE pk = 'x1' AND sk = '1'")+ .statusCode(400)+ .body("__type", equalTo("TransactionCanceledException"))+ .body("message", equalTo("Transaction cancelled, please refer cancellation reasons for specific reasons"+ + " [ConditionalCheckFailed, None]"))+ .body("CancellationReasons[0].Code", equalTo("ConditionalCheckFailed"))+ .body("CancellationReasons[0].Message", equalTo("The conditional request failed"))+ .body("CancellationReasons[1].Code", equalTo("None"))+ .body("CancellationReasons[1]", not(hasKey("Message")));++ transaction("EXISTS(SELECT * FROM \"" + TABLE + "\" WHERE pk = 'x1' AND sk = '1')",+ "UPDATE \"" + TABLE + "\" SET Touched=1 WHERE pk = 'x2' AND sk = '1'")+ .statusCode(400)+ .body("message", equalTo("Validation failed in TransactStatements[0]:"+ + " EXISTS() must contain a single item read with additional condition"));++ statement("EXISTS(SELECT * FROM \"" + TABLE + "\" WHERE pk = 'x1' AND sk = '1' AND Awards IS MISSING)")+ .statusCode(400)+ .body("message", equalTo("EXISTS can only be used in ExecuteTransaction write requests."));++ transaction("SELECT * FROM \"" + TABLE + "\" WHERE pk = 'x3' AND sk = '1'",+ "UPDATE \"" + TABLE + "\" SET Touched=1 WHERE pk = 'x3' AND sk = '1'")+ .statusCode(400)+ .body("message", equalTo(+ "ExecuteTransaction API does not support both read and write operations in the same request."));+ }++ private void assertKeys(String where, String... pks) {+ statement("SELECT pk FROM \"" + TABLE + "\" WHERE " + where)+ .statusCode(200)+ .body("Items.pk.S", containsInAnyOrder((Object[]) pks));+ }++ private void assertOrder(String whereAndOrder, String... rows) {+ List<String> expected = List.of(rows);+ request("DynamoDB_20120810.ExecuteStatement", orderedBody(whereAndOrder, null, null))+ .statusCode(200)+ .body("Items.pk.S", equalTo(expected.stream().map(r -> r.split("/")[0]).toList()))+ .body("Items.sk.S", equalTo(expected.stream().map(r -> r.split("/")[1]).toList()));+ }++ private static String orderedBody(String whereAndOrder, Integer limit, String nextToken) {+ String statement = "SELECT pk, sk FROM \"" + TABLE + "\" WHERE " + whereAndOrder;+ return "{\"Statement\":" + json(statement)+ + (limit == null ? "" : ",\"Limit\":" + limit)+ + (nextToken == null ? "" : ",\"NextToken\":" + json(nextToken)) + "}";+ }++ private static void update(String pk, String action) {+ statement("UPDATE \"" + TABLE + "\" " + action + " WHERE pk='" + pk + "' AND sk='1'").statusCode(200);+ }++ private static ValidatableResponse getItem(String pk) {+ return request("DynamoDB_20120810.GetItem", """+ {"TableName":"%s","Key":{"pk":{"S":"%s"},"sk":{"S":"1"}},"ConsistentRead":true}+ """.formatted(TABLE, pk))+ .statusCode(200);+ }++ private static void putItem(String pk, String attributes) {+ request("DynamoDB_20120810.PutItem", """+ {"TableName":"%s","Item":{"pk":{"S":"%s"},"sk":{"S":"1"},%s}}+ """.formatted(TABLE, pk, attributes))+ .statusCode(200);+ }++ private static ValidatableResponse statement(String partiql) {+ return request("DynamoDB_20120810.ExecuteStatement", "{\"Statement\":" + json(partiql) + "}");+ }++ private static ValidatableResponse transaction(String... statements) {+ String members = Arrays.stream(statements)+ .map(s -> "{\"Statement\":" + json(s) + "}")+ .collect(Collectors.joining(","));+ return request("DynamoDB_20120810.ExecuteTransaction", "{\"TransactStatements\":[" + members + "]}");+ }++ private static String json(String text) {+ return "\"" + text.replace("\\", "\\\\").replace("\"", "\\\"") + "\"";+ }++ private static ValidatableResponse request(String target, String body) {+ return given()+ .header("X-Amz-Target", target)+ .contentType(CONTENT_TYPE)+ .body(body)+ .when()+ .post("/")+ .then();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLEdgeCaseIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLEdgeCaseIntegrationTest.javanew file mode 100644index 0000000000..08907415d7--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLEdgeCaseIntegrationTest.java@@ -0,0 +1,732 @@+package io.github.hectorvent.floci.services.dynamodb;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import java.util.Arrays;+import java.util.List;+import java.util.stream.Collectors;+import java.util.stream.IntStream;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.contains;+import static org.hamcrest.Matchers.containsInAnyOrder;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.notNullValue;+import static org.hamcrest.Matchers.nullValue;++/**+ * PartiQL edge cases, with every expectation captured from real DynamoDB (eu-west-2, 2026-09-17).+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class DynamoDbPartiQLEdgeCaseIntegrationTest {++ private static final String CONTENT_TYPE = "application/x-amz-json-1.0";+ private static final String TABLE = "partiql-edge-cases";+ private static final String QUOTED_TABLE = "\"" + TABLE + "\"";++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ @Order(1)+ void createTable() {+ request("DynamoDB_20120810.CreateTable", """+ {+ "TableName": "%s",+ "AttributeDefinitions": [+ {"AttributeName":"pk","AttributeType":"S"},+ {"AttributeName":"sk","AttributeType":"S"}+ ],+ "KeySchema": [+ {"AttributeName":"pk","KeyType":"HASH"},+ {"AttributeName":"sk","KeyType":"RANGE"}+ ],+ "BillingMode": "PAY_PER_REQUEST"+ }+ """.formatted(TABLE))+ .statusCode(200);+ }++ @Test+ @Order(2)+ void readsKeyEqualitiesInsideAGroupedAnd() {+ putItem("grouped", "\"flag\":{\"S\":\"x\"}");+ putItem("grouped-other", "\"flag\":{\"S\":\"x\"}");++ statement("UPDATE " + QUOTED_TABLE + " SET a=2 WHERE (pk='grouped' AND sk='1') AND flag='x'")+ .statusCode(200);+ getItem("grouped").body("Item.a.N", equalTo("2"));++ transaction("EXISTS(SELECT * FROM " + QUOTED_TABLE + " WHERE (pk='grouped' AND sk='1') AND nope IS MISSING)",+ "UPDATE " + QUOTED_TABLE + " SET b=1 WHERE pk='grouped-other' AND sk='1'")+ .statusCode(200);+ getItem("grouped-other").body("Item.b.N", equalTo("1"));++ statement("DELETE FROM " + QUOTED_TABLE + " WHERE (pk='grouped' AND sk='1') AND flag='x'")+ .statusCode(200);+ getItem("grouped").body("Item", nullValue());+ }++ @Test+ @Order(3)+ void subtractsWithoutSpacesAndRefusesTrailingTokens() {+ putItem("minus", "\"n\":{\"N\":\"5\"}");++ statement("UPDATE " + QUOTED_TABLE + " SET n=n-1 WHERE pk='minus' AND sk='1'").statusCode(200);+ getItem("minus").body("Item.n.N", equalTo("4"));++ statement("SELECT sk FROM " + QUOTED_TABLE + " WHERE pk='minus' AND n>-5;")+ .statusCode(200)+ .body("Items.size()", equalTo(1));+ statement("UPDATE " + QUOTED_TABLE + " SET t=1 WHERE pk='minus' AND sk='1' garbage")+ .statusCode(400)+ .body("message", equalTo(+ "Statement wasn't well formed, can't be processed: Unexpected token after expression"));+ getItem("minus").body("Item.t", nullValue());+ }++ @Test+ @Order(4)+ void refusesANegativeListIndex() {+ putItem("index", "\"l\":{\"L\":[{\"S\":\"a\"},{\"S\":\"b\"}]}");+ String select = "SELECT l[-1] FROM " + QUOTED_TABLE + " WHERE pk='index' AND sk='1'";++ statement(select)+ .statusCode(400)+ .body("message", equalTo("List index is not within the allowable range; index: [-1] at 1:11:1"));+ statement("SELECT l[-0] FROM " + QUOTED_TABLE + " WHERE pk='index' AND sk='1'")+ .statusCode(200)+ .body("Items[0].'l[0]'.S", equalTo("a"));+ }++ @Test+ @Order(15)+ void refusesAListIndexAboveTheIntegerRange() {+ statement("SELECT l[2147483648] FROM " + QUOTED_TABLE + " WHERE pk='index' AND sk='1'")+ .statusCode(400)+ .body("message", equalTo("List index is not within the allowable range; index: [2147483648] at 1:10:10"));+ statement("UPDATE " + QUOTED_TABLE + " REMOVE l[2147483648] WHERE pk='index' AND sk='1'")+ .statusCode(400);+ statement("SELECT l[2147483647] FROM " + QUOTED_TABLE + " WHERE pk='index' AND sk='1'")+ .statusCode(200);+ getItem("index").body("Item.l.L.size()", equalTo(2));+ }++ @Test+ @Order(5)+ void refusesANonStringTypeInAttributeType() {+ statement("SELECT sk FROM " + QUOTED_TABLE + " WHERE pk='index' AND attribute_type(l, 1)")+ .statusCode(400)+ .body("message", equalTo("Incorrect operand type for operator or function;"+ + " operator or function: attribute_type, operand type: N"));+ statement("SELECT sk FROM " + QUOTED_TABLE + " WHERE pk='index' AND attribute_type(l, true)")+ .statusCode(400)+ .body("message", equalTo("Incorrect operand type for operator or function;"+ + " operator or function: attribute_type, operand type: BOOL"));+ }++ @Test+ @Order(6)+ void refusesAValueThatIsNotASetInSetAdd() {+ putItem("sets", "\"BandMembers\":{\"SS\":[\"member1\",\"member2\"]}");+ String prefix = "UPDATE " + QUOTED_TABLE + "\nSET BandMembers = set_add(";++ statement(prefix + "BandMembers, 'x')\nWHERE pk='sets' AND sk='1'")+ .statusCode(400)+ .body("message", equalTo("The second argument to SET_ADD must be a value with type SET at 2:27:11"));+ String quotedPrefix = "UPDATE " + QUOTED_TABLE + " SET \"BandMembers\" = set_delete(";+ statement(quotedPrefix + "\"BandMembers\", ['x']) WHERE pk='sets' AND sk='1'")+ .statusCode(400)+ .body("message", equalTo("The second argument to SET_DELETE must be a value with type SET at 1:"+ + (quotedPrefix.length() + 1) + ":13"));+ getItem("sets").body("Item.BandMembers.SS", containsInAnyOrder("member1", "member2"));+ }++ @Test+ @Order(7)+ void refusesDuplicateMembersInABag() {+ putItem("bags", "\"s\":{\"SS\":[\"a\"]},\"n\":{\"NS\":[\"1\"]}");+ String update = "UPDATE " + QUOTED_TABLE + " SET ";+ String where = " WHERE pk='bags' AND sk='1'";++ statement(update + "s = set_add(s, <<'b','b'>>)" + where)+ .statusCode(400)+ .body("message", equalTo(+ "One or more parameter values were invalid: Input collection [b, b] contains duplicates."));+ statement(update + "n = set_add(n, <<2, 2.0>>)" + where)+ .statusCode(400)+ .body("message", equalTo(+ "One or more parameter values were invalid: Input collection [2, 2.0] contains duplicates! under root"));+ statement("SELECT sk FROM " + QUOTED_TABLE + where + " AND s = <<'a','a'>>")+ .statusCode(400)+ .body("message", equalTo(+ "One or more parameter values were invalid: Input collection [a, a] contains duplicates."));+ transaction("INSERT INTO " + QUOTED_TABLE + " VALUE {'pk':'bags-tx','sk':'1','x':[<<'a','a'>>]}")+ .statusCode(400)+ .body("message", equalTo("Validation failed in TransactStatements[0]:"+ + " One or more parameter values were invalid: Input collection [a, a] contains duplicates."));+ getItem("bags-tx").body("Item", nullValue());++ statement(update + "n = <<1, 10>>" + where).statusCode(200);+ getItem("bags")+ .body("Item.s.SS", containsInAnyOrder("a"))+ .body("Item.n.NS", containsInAnyOrder("1", "10"));+ }++ @Test+ @Order(8)+ void refusesAnInvalidParameterBeforeReadingTheStatement() {+ String duplicates = "One or more parameter values were invalid: Input collection [a, a] contains duplicates.";+ String insert = "INSERT INTO " + QUOTED_TABLE + " VALUE {'pk':'params','sk':'1','x':?}";+ String update = "UPDATE " + QUOTED_TABLE + " SET y = ? WHERE pk='params' AND sk='1'";++ statement("UPDATE " + QUOTED_TABLE + " SET WHERE", "[{\"SS\":[\"a\",\"a\"]}]")+ .statusCode(400)+ .body("message", equalTo(duplicates));+ statement(insert, "[{\"NULL\":false}]")+ .statusCode(400)+ .body("message", equalTo(+ "One or more parameter values were invalid: Null attribute value types must have the value of true"));+ request("DynamoDB_20120810.ExecuteTransaction", "{\"TransactStatements\":["+ + member(update, "[{\"N\":\"1\"}]") + "," + member(insert, "[{\"SS\":[\"a\",\"a\"]}]") + "]}")+ .statusCode(400)+ .body("message", equalTo(duplicates));+ request("DynamoDB_20120810.BatchExecuteStatement",+ "{\"Statements\":[" + member(update, "[{\"SS\":[]}]") + "]}")+ .statusCode(200)+ .body("Responses[0].Error.Code", equalTo("ValidationError"))+ .body("Responses[0].Error.Message", equalTo(+ "One or more parameter values were invalid: An string set may not be empty"));+ getItem("params").body("Item", nullValue());+ }++ @Test+ @Order(9)+ void refusesTwoReadsOfOneItemInATransaction() {+ putItem("reads", "\"a\":{\"S\":\"x\"}");+ String select = "SELECT * FROM " + QUOTED_TABLE + " WHERE pk='reads' AND sk='1'";++ transaction(select, "SELECT a FROM " + QUOTED_TABLE + " WHERE sk='1' AND pk='reads'")+ .statusCode(400)+ .body("message", equalTo("Transaction request cannot include multiple operations on one item"));+ transaction(select, select, "SELECT * FROM " + QUOTED_TABLE + " WHERE pk=1 AND sk='1'")+ .statusCode(400)+ .body("message", equalTo("Transaction cancelled, please refer cancellation reasons for specific reasons"+ + " [None, None, ValidationError]"));+ transaction(select, "SELECT * FROM " + QUOTED_TABLE + " WHERE pk='reads' AND sk='2'")+ .statusCode(200)+ .body("Responses[0].Item.a.S", equalTo("x"));+ }++ @Test+ @Order(10)+ void readsOnlyByTheKeyInATransaction() {+ putItem("keyed", "\"flag\":{\"S\":\"right\"}");+ String select = "SELECT * FROM " + QUOTED_TABLE + " WHERE ";+ String refused = "Validation failed in TransactStatements[0]:"+ + " Select statements within ExecuteTransaction must specify the primary key in the where clause.";++ transaction(select + "pk='keyed' AND sk='1' AND flag='right'")+ .statusCode(400)+ .body("message", equalTo(refused));+ transaction(select + "pk='keyed' AND sk='1' AND pk='reads'")+ .statusCode(400)+ .body("message", equalTo(refused));+ transaction(select + "pk='keyed'")+ .statusCode(400)+ .body("message", equalTo(refused));+ transaction(select + "(sk='1') AND pk='keyed' AND pk='keyed'")+ .statusCode(200)+ .body("Responses[0].Item.flag.S", equalTo("right"));+ }++ @Test+ @Order(11)+ void refusesUnprojectedAttributesInsideGroupedConditionsOnAKeyedIndexRead() {+ request("DynamoDB_20120810.CreateTable", """+ {+ "TableName": "partiql-edge-cases-index",+ "AttributeDefinitions": [+ {"AttributeName":"pk","AttributeType":"S"},+ {"AttributeName":"gsiPk","AttributeType":"S"}+ ],+ "KeySchema": [{"AttributeName":"pk","KeyType":"HASH"}],+ "GlobalSecondaryIndexes": [{+ "IndexName": "gsi-inc",+ "KeySchema": [{"AttributeName":"gsiPk","KeyType":"HASH"}],+ "Projection": {"ProjectionType":"INCLUDE","NonKeyAttributes":["projattr"]}+ }],+ "BillingMode": "PAY_PER_REQUEST"+ }+ """)+ .statusCode(200);+ request("DynamoDB_20120810.PutItem", """+ {"TableName":"partiql-edge-cases-index",+ "Item":{"pk":{"S":"p"},"gsiPk":{"S":"y"},"projattr":{"S":"proj1"},"nonproj":{"S":"np1"}}}+ """)+ .statusCode(200);+ String select = "SELECT pk FROM \"partiql-edge-cases-index\".\"gsi-inc\" WHERE gsiPk='y' AND ";+ String refused = "One or more parameter values were invalid: Secondary index gsi-inc"+ + " does not project one or more filter attributes: ";++ statement(select + "NOT (nonproj='np1' OR projattr='x')")+ .statusCode(400)+ .body("message", equalTo(refused + "[nonproj]"));+ statement(select + "b='1' AND (a='2' OR projattr='3')")+ .statusCode(400)+ .body("message", equalTo(refused + "[a, b]"));+ statement(select + "(zz='1' OR aa='2' OR mm='3')")+ .statusCode(400)+ .body("message", equalTo(refused + "[zz, aa, mm]"));+ statement(select + "(projattr='proj1' OR projattr='proj2')")+ .statusCode(200)+ .body("Items[0].pk.S", equalTo("p"));+ }++ @Test+ @Order(12)+ void skipsLineAndBlockComments() {+ putItem("comments", "\"n\":{\"N\":\"1\"},\"note\":{\"S\":\"a--b /*c*/\"}");+ String key = "pk='comments' AND sk='1'";++ statement("SELECT/**/* FROM " + QUOTED_TABLE + " -- the table\nWHERE pk/* key */='comments' AND sk='1' --")+ .statusCode(200)+ .body("Items[0].note.S", equalTo("a--b /*c*/"));+ statement("SELECT note FROM " + QUOTED_TABLE + " WHERE " + key + " AND note = 'a--b /*c*/'; -- done")+ .statusCode(200)+ .body("Items.size()", equalTo(1));+ statement("UPDATE " + QUOTED_TABLE + " SET n=n--1 WHERE " + key)+ .statusCode(400);+ statement("SELECT * FROM " + QUOTED_TABLE + " WHERE " + key + " /* open")+ .statusCode(400);+ getItem("comments").body("Item.n.N", equalTo("1"));+ }++ @Test+ @Order(13)+ void appliesASignToANumberLiteral() {+ putItem("signs", "\"n\":{\"N\":\"1\"}");+ String select = "SELECT sk FROM " + QUOTED_TABLE + " WHERE pk='signs' AND sk='1' AND ";++ statement(select + "n = - - 1").statusCode(200).body("Items.size()", equalTo(1));+ statement(select + "n > -/* c */-1").statusCode(200).body("Items.size()", equalTo(0));+ statement(select + "n BETWEEN - 2 AND +5 AND n IN [- 1, 1]").statusCode(200).body("Items.size()", equalTo(1));+ statement(select + "n > -?").statusCode(400);+ statement(select + "n > -n").statusCode(400);++ statement("UPDATE " + QUOTED_TABLE + " SET n = n - - 2, l = [- 1] WHERE pk='signs' AND sk='1'").statusCode(200);+ getItem("signs")+ .body("Item.n.N", equalTo("3"))+ .body("Item.l.L[0].N", equalTo("-1"));+ }++ @Test+ @Order(14)+ void refusesAParameterInsideACollectionLiteral() {+ String prefix = "UPDATE " + QUOTED_TABLE + " SET x = ";++ statement(prefix + "[?] WHERE pk='literals' AND sk='1'", "[{\"S\":\"v\"}]")+ .statusCode(400)+ .body("message", equalTo("Unsupported data type: Parameter under key root[0] at 1:"+ + (prefix.length() + 2) + ":1"));+ String insert = "INSERT INTO " + QUOTED_TABLE + " VALUE {'pk':'literals','sk':'1','m':{'k':?}}";+ statement(insert, "[{\"S\":\"v\"}]")+ .statusCode(400)+ .body("message", equalTo("Unsupported data type: Parameter under key root.k at 1:"+ + (insert.indexOf('?') + 1) + ":1"));+ getItem("literals").body("Item", nullValue());++ statement("INSERT INTO " + QUOTED_TABLE + " VALUE {'pk':?,'sk':'1','n':1}", "[{\"S\":\"literals\"}]")+ .statusCode(200);+ statement("SELECT sk FROM " + QUOTED_TABLE + " WHERE pk='literals' AND n IN [?, 2]", "[{\"N\":\"1\"}]")+ .statusCode(200)+ .body("Items.size()", equalTo(1));+ }++ @Test+ @Order(16)+ void refusesALiteralNested32LevelsDeep() {+ String update = "UPDATE " + QUOTED_TABLE + " SET d = ";+ String where = " WHERE pk='nested' AND sk='1'";++ statement(update + "{'a':".repeat(32) + "1" + "}".repeat(32) + where)+ .statusCode(400)+ .body("message", equalTo("Nesting Levels have exceeded supported limits under root" + ".a".repeat(32)));+ statement(update + "{'a':" + "[".repeat(31) + "1" + "]".repeat(31) + "}" + where)+ .statusCode(400)+ .body("message", equalTo("Nesting Levels have exceeded supported limits under root.a" + "[0]".repeat(31)));+ transaction(update + "[".repeat(32) + "1" + "]".repeat(32) + where)+ .statusCode(400)+ .body("message", equalTo("Validation failed in TransactStatements[0]:"+ + " Nesting Levels have exceeded supported limits under root" + "[0]".repeat(32)));++ statement("INSERT INTO " + QUOTED_TABLE + " VALUE {'pk':'nested','sk':'1','d':"+ + "{'a':".repeat(31) + "1" + "}".repeat(31) + "}")+ .statusCode(200);+ getItem("nested").body("Item.d.M.a.M.a.M", notNullValue());+ }++ @Test+ @Order(17)+ void refusesANonNumberLiteralInArithmeticBeforeTheCondition() {+ putItem("arithmetic", "\"n\":{\"N\":\"1\"}");+ String update = "UPDATE " + QUOTED_TABLE + " SET n = ";+ String failingCondition = " WHERE pk='arithmetic' AND sk='1' AND nope='x'";++ statement(update + "'a' + 1" + failingCondition)+ .statusCode(400)+ .body("message", equalTo("Incorrect operand type for operator or function; operator or function: +, operand type: S"));+ statement(update + "n - null" + failingCondition)+ .statusCode(400)+ .body("message", equalTo("Incorrect operand type for operator or function; operator or function: -, operand type: NULL"));+ transaction(update + "n + [1] WHERE pk='arithmetic' AND sk='1'")+ .statusCode(400)+ .body("message", equalTo("Validation failed in TransactStatements[0]:"+ + " Incorrect operand type for operator or function; operator or function: +, operand type: L"));+ getItem("arithmetic").body("Item.n.N", equalTo("1"));+ }++ @Test+ @Order(18)+ void readsAttributeExistsAndAttributeNotExists() {+ putItem("exists", "\"m\":{\"M\":{\"x\":{\"S\":\"y\"}}},\"l\":{\"L\":[{\"S\":\"a\"}]}");+ String select = "SELECT sk FROM " + QUOTED_TABLE + " WHERE pk='exists' AND sk='1' AND ";++ statement(select + "attribute_exists(m.x) AND ATTRIBUTE_NOT_EXISTS (nope) AND attribute_exists(l[0])")+ .statusCode(200)+ .body("Items.size()", equalTo(1));+ statement(select + "(attribute_exists(nope) OR NOT attribute_exists(\"m\"))")+ .statusCode(200)+ .body("Items.size()", equalTo(0));+ statement(select + "attribute_exists('m')").statusCode(400);++ statement("UPDATE " + QUOTED_TABLE + " SET t=1 WHERE pk='exists' AND sk='1' AND attribute_exists(nope)")+ .statusCode(400)+ .body("__type", equalTo("ConditionalCheckFailedException"));+ getItem("exists").body("Item.t", nullValue());+ }++ @Test+ @Order(19)+ void comparesAConditionWithABoolean() {+ putItem("booleans", "\"n\":{\"N\":\"1\"},\"flag\":{\"S\":\"right\"},\"yes\":{\"BOOL\":true}");+ String select = "SELECT sk FROM " + QUOTED_TABLE + " WHERE pk='booleans' AND sk='1' AND ";++ for (String holds : List.of("attribute_exists(nope) = false", "true = attribute_exists(n)",+ "attribute_exists(n) <> 1", "contains(nope, 'z') = false", "(n BETWEEN 0 AND 5) = true",+ "(n = 5 OR flag = 'x') = false", "attribute_exists(nope) IN [true, false]",+ "attribute_exists(n) = attribute_exists(flag)", "attribute_exists(n) = yes")) {+ statement(select + holds).statusCode(200).body("Items.size()", equalTo(1));+ }+ for (String fails : List.of("attribute_exists(n) = 1", "NOT attribute_exists(n) = true",+ "(attribute_exists(n) = true) = false", "attribute_exists(n) = flag")) {+ statement(select + fails).statusCode(200).body("Items.size()", equalTo(0));+ }+ statement(select + "attribute_exists(n) > false")+ .statusCode(400)+ .body("message", equalTo("Incorrect operand type for operator or function; operator or function: >, operand type: BOOL"));+ }++ @Test+ @Order(20)+ void readsSortKeyConditionsThatAQueryKeyCannotHold() {+ putItem("ranges", "\"flag\":{\"S\":\"one\"}");+ putItem("ranges", "2", "\"flag\":{\"S\":\"two\"}");+ String select = "SELECT sk FROM " + QUOTED_TABLE + " WHERE pk='ranges' AND ";++ for (String both : List.of("(sk='1' OR sk='2')", "sk IN ['1','2']", "(sk < '1' OR sk > '1' OR sk='1')",+ "attribute_exists(pk)")) {+ statement(select + both).statusCode(200).body("Items.sk.S", containsInAnyOrder("1", "2"));+ }+ for (String second : List.of("NOT sk='1'", "sk <> '1'", "sk > '0' AND sk <> '1'")) {+ statement(select + second).statusCode(200).body("Items.sk.S", containsInAnyOrder("2"));+ }+ statement(select + "sk='1' AND sk > '0'").statusCode(200).body("Items.sk.S", containsInAnyOrder("1"));+ }++ @Test+ @Order(21)+ void refusesOverlappingKeyConditionsAndMismatchedKeyTypes() {+ String select = "SELECT sk FROM " + QUOTED_TABLE + " WHERE ";+ String overlapping = "Overlapping conditions with range keys are not supported in where clause";++ for (String where : List.of("pk IN ['ranges','ranges']", "pk='ranges' OR pk='ranges'",+ "pk='ranges' AND (sk > '0' OR sk < '5')", "pk='ranges' AND (sk='1' OR flag='two')",+ "(pk='ranges' AND flag='one') OR (pk='ranges' AND flag='two')")) {+ statement(select + where).statusCode(400).body("message", equalTo(overlapping));+ }+ transaction(select + "pk IN ['ranges','ranges'] AND sk='1'")+ .statusCode(400)+ .body("message", equalTo("Validation failed in TransactStatements[0]: " + overlapping));+ statement(select + "pk='ranges' OR sk='1'").statusCode(200);++ statement(select + "pk = 1 OR pk = 'ranges'")+ .statusCode(400)+ .body("message", equalTo("Key attribute's data type should match its data type in table's schema: Key pk"));+ statement(select + "pk = 'ranges' AND sk IN ['1', 2]")+ .statusCode(400)+ .body("message", equalTo("Key attribute's data type should match its data type in table's schema: Key sk"));+ statement(select + "pk > 1").statusCode(200).body("Items.size()", equalTo(0));+ }++ @Test+ @Order(22)+ void checksProjectionOnEachKeyedBranchOfAnIndexRead() {+ String select = "SELECT pk FROM \"partiql-edge-cases-index\".\"gsi-inc\" WHERE ";+ String refused = "One or more parameter values were invalid: Secondary index gsi-inc"+ + " does not project one or more filter attributes: ";++ statement(select + "(gsiPk='y' OR gsiPk='z') AND zz='1'")+ .statusCode(400)+ .body("message", equalTo(refused + "[zz]"));+ statement(select + "(gsiPk='b' AND u1='1') OR (gsiPk='q' AND u2='1')")+ .statusCode(400)+ .body("message", equalTo(refused + "[u2]"));+ statement(select + "(gsiPk='q' AND u1='1') OR (gsiPk='b' AND u2='1')")+ .statusCode(400)+ .body("message", equalTo(refused + "[u1]"));+ for (String accepted : List.of("(gsiPk='y' AND projattr='1') OR (gsiPk='z' AND aa='1')",+ "gsiPk > 'a' AND zz='1'", "gsiPk='y' AND (gsiPk='z' OR zz='1')", "(gsiPk='y' AND zz='1') OR aa='1'")) {+ statement(select + accepted).statusCode(200);+ }+ statement(select + "(gsiPk='y' AND zz='1') OR (gsiPk='y' AND aa='1')")+ .statusCode(400)+ .body("message", equalTo("Overlapping conditions with range keys are not supported in where clause"));+ }++ @Test+ @Order(23)+ void readsByAOneValueInAndRefusesAnythingBesideTheKeyInTransactionAndBatchReads() {+ String select = "SELECT sk FROM " + QUOTED_TABLE + " WHERE ";+ String batchRefused = "Select statements within BatchExecuteStatement must specify the primary key in the where clause.";++ transaction(select + "pk IN ['ranges'] AND sk IN ['1']")+ .statusCode(200)+ .body("Responses[0].Item.sk.S", equalTo("1"));+ transaction(select + "(pk IN ['ranges']) AND pk='ranges' AND sk='2'")+ .statusCode(200)+ .body("Responses[0].Item.sk.S", equalTo("2"));+ transaction(select + "pk IN ['other'] AND pk='ranges' AND sk='1'")+ .statusCode(400)+ .body("message", equalTo("Validation failed in TransactStatements[0]:"+ + " Select statements within ExecuteTransaction must specify the primary key in the where clause."));+ transaction("EXISTS(" + select + "pk IN ['ranges'] AND sk='1' AND flag='one')",+ "UPDATE " + QUOTED_TABLE + " SET b=1 WHERE pk='ranges' AND sk='2'")+ .statusCode(400)+ .body("message", equalTo("Validation failed in TransactStatements[0]:"+ + " EXISTS() must contain a single item read with additional condition"));++ request("DynamoDB_20120810.BatchExecuteStatement", "{\"Statements\":["+ + "{\"Statement\":" + json(select + "pk IN ['ranges'] AND sk='1'") + "},"+ + "{\"Statement\":" + json(select + "pk='ranges' AND sk='1' AND flag='one'") + "},"+ + "{\"Statement\":" + json(select + "pk='ranges' AND sk='1' AND pk='other'") + "}]}")+ .statusCode(200)+ .body("Responses[0].Item.sk.S", equalTo("1"))+ .body("Responses[1].Error.Message", equalTo(batchRefused))+ .body("Responses[2].Error.Message", equalTo(batchRefused));+ }++ @Test+ @Order(24)+ void refusesTwoValuesForOneKeyOnAWriteAndReadsTheFirstInExists() {+ putItem("conflict", "\"flag\":{\"S\":\"right\"}");+ putItem("other", "\"flag\":{\"S\":\"right\"}");+ String multiple = "Multiple conditions on same key pk. Only single item Update/Insert/Delete are supported";++ statement("UPDATE " + QUOTED_TABLE + " SET a=1 WHERE pk='conflict' AND sk='1' AND pk='other'")+ .statusCode(400)+ .body("message", equalTo(multiple));+ statement("DELETE FROM " + QUOTED_TABLE + " WHERE pk='conflict' AND sk='1' AND pk='other'")+ .statusCode(400)+ .body("message", equalTo(multiple));+ statement("UPDATE " + QUOTED_TABLE + " SET a=2 WHERE pk='conflict' AND sk='1' AND pk='conflict'")+ .statusCode(200);+ getItem("conflict").body("Item.a.N", equalTo("2"));++ transaction("EXISTS(SELECT * FROM " + QUOTED_TABLE + " WHERE pk='conflict' AND sk='1' AND pk='other' AND flag='right')",+ "UPDATE " + QUOTED_TABLE + " SET b=1 WHERE pk='other' AND sk='1'")+ .statusCode(400)+ .body("CancellationReasons[0].Code", equalTo("ConditionalCheckFailed"))+ .body("CancellationReasons[1].Code", equalTo("None"));+ }++ @Test+ @Order(25)+ void cancelsATransactionThatNamesAMissingTable() {+ putItem("missing", "\"flag\":{\"S\":\"right\"}");+ String missingUpdate = "UPDATE \"partiql-edge-cases-missing\" SET a=1 WHERE pk='x' AND sk='1'";+ String select = "SELECT * FROM " + QUOTED_TABLE + " WHERE pk='missing' AND sk='1'";++ transaction(missingUpdate + " RETURNING ALL NEW *", "DELETE FROM \"partiql-edge-cases-missing\" WHERE pk='x' AND sk='1'")+ .statusCode(400)+ .body("__type", equalTo("TransactionCanceledException"))+ .body("CancellationReasons.Code", contains("ResourceNotFound", "ResourceNotFound"))+ .body("CancellationReasons[0].Message", equalTo("Requested resource not found"));+ transaction(select, "SELECT * FROM \"partiql-edge-cases-missing\".\"idx\" WHERE pk='x' AND sk='1'")+ .statusCode(400)+ .body("CancellationReasons.Code", contains("None", "ResourceNotFound"))+ .body("CancellationReasons[0].Message", nullValue());++ transaction(missingUpdate, "UPDATE " + QUOTED_TABLE + " SET a=1 WHERE pk='missing' AND sk='1' RETURNING ALL NEW *")+ .statusCode(400)+ .body("message", equalTo("Validation failed in TransactStatements[1]: RETURNING clause is not supported in ExecuteTransaction."));+ transaction("SELECT * FROM \"partiql-edge-cases-missing\" WHERE pk='x' AND sk='1'", "SELECT * FROM " + QUOTED_TABLE + ".\"idx\" WHERE pk='x' AND sk='1'")+ .statusCode(400)+ .body("message", equalTo("Validation failed in TransactStatements[1]: Reads on indices are not supported within transactions."));+ getItem("missing").body("Item.a", nullValue());+ }++ @Test+ @Order(26)+ void cancelsATransactionWhoseWriteDoesNotNameOneItem() {+ putItem("keys", "\"flag\":{\"S\":\"right\"}");+ String update = "UPDATE " + QUOTED_TABLE + " SET a=1 WHERE ";+ String mismatch = "The provided key element does not match the schema";++ transaction(update + "pk='keys'", update + "pk IN ['keys'] AND sk='1'", update + "pk='keys' AND sk='1' AND pk='other'",+ update + "pk='keys' AND sk=1", update + "pk='keys' AND sk='1'")+ .statusCode(400)+ .body("CancellationReasons.Code", contains("ValidationError", "ValidationError", "ValidationError",+ "ValidationError", "None"))+ .body("CancellationReasons[0].Message", equalTo(mismatch))+ .body("CancellationReasons[3].Message", equalTo(mismatch));+ transaction("INSERT INTO " + QUOTED_TABLE + " VALUE {'pk':'keys-insert'}", "DELETE FROM " + QUOTED_TABLE + " WHERE sk='1'")+ .statusCode(400)+ .body("CancellationReasons[0].Message", equalTo("One or more parameter values were invalid: Missing the key sk in the item"))+ .body("CancellationReasons[1].Message", equalTo(mismatch));+ transaction("SELECT * FROM " + QUOTED_TABLE + " WHERE pk='keys' AND sk=1")+ .statusCode(400)+ .body("CancellationReasons[0].Message", equalTo(mismatch));+ getItem("keys").body("Item.a", nullValue());+ }++ @Test+ @Order(27)+ void refusesAWriteThatLeavesTheItemTooDeep() {+ putItem("deep-path", "\"m\":{\"M\":{}}");+ String update = "UPDATE " + QUOTED_TABLE + " SET m.deep = ? WHERE pk='deep-path' AND sk='1'";+ String parameters = "[" + "{\"M\":{\"a\":".repeat(31) + "{\"S\":\"x\"}" + "}}".repeat(31) + "]";+ String tooDeep = "Nesting Levels have exceeded supported limits";++ statement(update, parameters)+ .statusCode(400)+ .body("message", equalTo(tooDeep));+ request("DynamoDB_20120810.ExecuteTransaction", "{\"TransactStatements\":[" + member(update, parameters) + "]}")+ .statusCode(400)+ .body("CancellationReasons[0].Code", equalTo("ValidationError"))+ .body("CancellationReasons[0].Message", equalTo(tooDeep));+ request("DynamoDB_20120810.BatchExecuteStatement", "{\"Statements\":[" + member(update, parameters) + "]}")+ .statusCode(200)+ .body("Responses[0].Error.Message", equalTo(tooDeep))+ .body("Responses[0].TableName", equalTo(TABLE));+ getItem("deep-path").body("Item.m.M.deep", nullValue());+ }++ @Test+ @Order(28)+ void namesAPathColumnFromItsLastNamedComponent() {+ putItem("columns", "\"m\":{\"M\":{\"k\":{\"L\":[{\"S\":\"c\"}]}}}");++ statement("SELECT m.k[0] FROM " + QUOTED_TABLE + " WHERE pk='columns' AND sk='1'")+ .statusCode(200)+ .body("Items[0].'k[0]'.S", equalTo("c"));+ }++ @Test+ @Order(29)+ void refusesTooManyInOperandsAndTooManyDecomposedReads() {+ String select = "SELECT sk FROM " + QUOTED_TABLE + " WHERE ";+ String tooManyReads = "Too many decomposed read operations for a given query.";+ String tooManyOperands = "The IN operator is provided with too many operands; number of operands: 101";++ for (String where : List.of("pk IN [" + inValues(51) + "]",+ "pk='ranges' AND sk IN [" + inValues(51) + "]",+ "pk IN [" + inValues(26) + "] AND sk IN ['1','2']")) {+ statement(select + where).statusCode(400).body("message", equalTo(tooManyReads));+ }+ for (String where : List.of("pk IN [" + inValues(50) + "] AND flag IN [" + inValues(100) + "]",+ "pk IN [" + inValues(51) + "] OR flag='one'")) {+ statement(select + where).statusCode(200);+ }+ request("DynamoDB_20120810.BatchExecuteStatement",+ "{\"Statements\":[{\"Statement\":" + json(select + "pk IN [" + inValues(51) + "] AND sk='1'") + "}]}")+ .statusCode(200)+ .body("Responses[0].Error.Message", equalTo(tooManyReads));++ statement(select + "pk='ranges' AND flag IN [" + inValues(101) + "]")+ .statusCode(400)+ .body("message", equalTo(tooManyOperands));+ statement("UPDATE " + QUOTED_TABLE + " SET t=1 WHERE pk='ranges' AND sk='1' AND flag IN [" + inValues(101) + "]")+ .statusCode(400)+ .body("message", equalTo(tooManyOperands));+ transaction("SELECT * FROM " + QUOTED_TABLE + " WHERE pk IN [" + inValues(101) + "] AND sk='1'")+ .statusCode(400)+ .body("message", equalTo("Validation failed in TransactStatements[0]: " + tooManyOperands));+ getItem("ranges").body("Item.t", nullValue());+ }++ private static ValidatableResponse getItem(String pk) {+ return request("DynamoDB_20120810.GetItem", """+ {"TableName":"%s","Key":{"pk":{"S":"%s"},"sk":{"S":"1"}},"ConsistentRead":true}+ """.formatted(TABLE, pk))+ .statusCode(200);+ }++ private static void putItem(String pk, String attributes) {+ putItem(pk, "1", attributes);+ }++ private static void putItem(String pk, String sk, String attributes) {+ request("DynamoDB_20120810.PutItem", """+ {"TableName":"%s","Item":{"pk":{"S":"%s"},"sk":{"S":"%s"},%s}}+ """.formatted(TABLE, pk, sk, attributes))+ .statusCode(200);+ }++ private static ValidatableResponse statement(String partiql) {+ return request("DynamoDB_20120810.ExecuteStatement", "{\"Statement\":" + json(partiql) + "}");+ }++ private static ValidatableResponse statement(String partiql, String parameters) {+ return request("DynamoDB_20120810.ExecuteStatement", member(partiql, parameters));+ }++ private static ValidatableResponse transaction(String... statements) {+ String members = Arrays.stream(statements)+ .map(s -> "{\"Statement\":" + json(s) + "}")+ .collect(Collectors.joining(","));+ return request("DynamoDB_20120810.ExecuteTransaction", "{\"TransactStatements\":[" + members + "]}");+ }++ private static String member(String partiql, String parameters) {+ return "{\"Statement\":" + json(partiql) + ",\"Parameters\":" + parameters + "}";+ }++ private static String inValues(int count) {+ return IntStream.range(0, count).mapToObj(i -> "'v" + i + "'").collect(Collectors.joining(","));+ }++ private static String json(String text) {+ return "\"" + text.replace("\\", "\\\\").replace("\"", "\\\"").replace("\n", "\\n") + "\"";+ }++ private static ValidatableResponse request(String target, String body) {+ return given()+ .header("X-Amz-Target", target)+ .contentType(CONTENT_TYPE)+ .body(body)+ .when()+ .post("/")+ .then();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLIntegrationTest.javanew file mode 100644index 0000000000..a50ed67916--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLIntegrationTest.java@@ -0,0 +1,342 @@+package io.github.hectorvent.floci.services.dynamodb;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.nullValue;++@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class DynamoDbPartiQLIntegrationTest {++ private static final String CONTENT_TYPE = "application/x-amz-json-1.0";+ private static final String TABLE = "partiql-statements";++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ @Order(1)+ void createTable() {+ request("DynamoDB_20120810.CreateTable", """+ {+ "TableName": "%s",+ "AttributeDefinitions": [{"AttributeName":"pk","AttributeType":"S"}],+ "KeySchema": [{"AttributeName":"pk","KeyType":"HASH"}],+ "BillingMode": "PAY_PER_REQUEST"+ }+ """.formatted(TABLE))+ .statusCode(200);+ }++ @Test+ @Order(2)+ void selectReportsADocumentPathUnderItsLeafName() {+ putItem("path-select", """+ "profile":{"M":{"sub":{"S":"deep"},"sib":{"S":"keep"}}},+ "tags":{"L":[{"S":"a"},{"S":"b"}]}+ """);++ statement("SELECT profile.sub, tags[1] FROM \"" + TABLE + "\" WHERE pk = 'path-select'")+ .statusCode(200)+ .body("Items.size()", equalTo(1))+ .body("Items[0].sub.S", equalTo("deep"))+ .body("Items[0].'tags[1]'.S", equalTo("b"))+ .body("Items[0].profile", nullValue());+ }++ @Test+ @Order(3)+ void updateWritesThroughADocumentPath() {+ putItem("path-update", "\"profile\":{\"M\":{\"sub\":{\"S\":\"old\"}}}");++ statement("UPDATE \"" + TABLE + "\" SET profile.sub = 'new' WHERE pk = 'path-update'")+ .statusCode(200);++ statement("SELECT profile.sub FROM \"" + TABLE + "\" WHERE pk = 'path-update'")+ .statusCode(200)+ .body("Items[0].sub.S", equalTo("new"));+ }++ @Test+ @Order(4)+ void whereTakesInNotAndTheMissingPredicate() {+ putItem("grammar-a", "\"kind\":{\"S\":\"alpha\"}");+ putItem("grammar-b", "\"kind\":{\"S\":\"beta\"}");++ statement("SELECT pk FROM \"" + TABLE + "\" WHERE pk IN ['grammar-a','grammar-b']"+ + " AND NOT begins_with(\"kind\", 'al')")+ .statusCode(200)+ .body("Items.size()", equalTo(1))+ .body("Items[0].pk.S", equalTo("grammar-b"));++ statement("SELECT pk FROM \"" + TABLE + "\" WHERE pk = 'grammar-a' AND \"kind\" IS NOT MISSING")+ .statusCode(200)+ .body("Items.size()", equalTo(1));++ statement("SELECT pk FROM \"" + TABLE + "\" WHERE pk = 'grammar-a' AND \"kind\" IS MISSING")+ .statusCode(200)+ .body("Items.size()", equalTo(0));+ }++ @Test+ @Order(5)+ void updateOnAKeyHoldingNoItemFailsTheConditionalCheck() {+ statement("UPDATE \"" + TABLE + "\" SET data = 'new' WHERE pk = 'write-ghost'")+ .statusCode(400)+ .body("__type", equalTo("ConditionalCheckFailedException"));++ request("DynamoDB_20120810.GetItem", """+ {"TableName":"%s","Key":{"pk":{"S":"write-ghost"}}}+ """.formatted(TABLE))+ .statusCode(200)+ .body("Item", nullValue());+ }++ @Test+ @Order(6)+ void aFalsePredicateBesideTheKeyLeavesTheItem() {+ putItem("write-pred", "\"name\":{\"S\":\"alpha\"},\"n\":{\"N\":\"5\"}");++ statement("UPDATE \"" + TABLE + "\" SET n = 9 WHERE pk = 'write-pred' AND \"name\" = 'beta'")+ .statusCode(400)+ .body("__type", equalTo("ConditionalCheckFailedException"));++ statement("DELETE FROM \"" + TABLE + "\" WHERE pk = 'write-pred' AND \"name\" = 'beta'")+ .statusCode(400)+ .body("__type", equalTo("ConditionalCheckFailedException"));++ request("DynamoDB_20120810.GetItem", """+ {"TableName":"%s","Key":{"pk":{"S":"write-pred"}}}+ """.formatted(TABLE))+ .statusCode(200)+ .body("Item.n.N", equalTo("5"));+ }++ @Test+ @Order(7)+ void deleteOnAKeyHoldingNoItemIsANoOpEvenWithAPredicate() {+ statement("DELETE FROM \"" + TABLE + "\" WHERE pk = 'write-absent' AND \"name\" = 'x'")+ .statusCode(200);+ }++ @Test+ @Order(8)+ void aWriteWithoutTheKeyEqualityIsRejected() {+ statement("DELETE FROM \"" + TABLE + "\" WHERE \"name\" = 'alpha'")+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo(+ "Where clause does not contain a mandatory equality on all key attributes"));+ }++ @Test+ @Order(9)+ void updateReturningReportsTheRowOnTheRequestedSide() {+ putItem("ret-update", "\"data\":{\"S\":\"old\"},\"keep\":{\"S\":\"same\"}");++ statement("UPDATE \"" + TABLE + "\" SET data = 'new' WHERE pk = 'ret-update' RETURNING ALL OLD *")+ .statusCode(200)+ .body("Items.size()", equalTo(1))+ .body("Items[0].data.S", equalTo("old"))+ .body("Items[0].keep.S", equalTo("same"));++ statement("UPDATE \"" + TABLE + "\" SET data = 'newer' WHERE pk = 'ret-update'"+ + " RETURNING MODIFIED NEW *")+ .statusCode(200)+ .body("Items.size()", equalTo(1))+ .body("Items[0].data.S", equalTo("newer"))+ .body("Items[0].keep", nullValue())+ .body("Items[0].pk", nullValue());+ }++ @Test+ @Order(10)+ void anEmptyModifiedProjectionAnswersNoRow() {+ putItem("ret-removed", "\"data\":{\"S\":\"old\"}");++ statement("UPDATE \"" + TABLE + "\" REMOVE data WHERE pk = 'ret-removed'"+ + " RETURNING MODIFIED NEW *")+ .statusCode(200)+ .body("Items.size()", equalTo(0));+ }++ @Test+ @Order(11)+ void deleteTakesOnlyReturningAllOld() {+ putItem("ret-delete", "\"data\":{\"S\":\"gone\"}");++ statement("DELETE FROM \"" + TABLE + "\" WHERE pk = 'ret-delete' RETURNING MODIFIED OLD *")+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("Invalid returning clause: RETURNING MODIFIED OLD *."+ + " Only RETURNING ALL OLD * is allowed in DELETE statements."));++ statement("DELETE FROM \"" + TABLE + "\" WHERE pk = 'ret-delete' RETURNING ALL OLD *")+ .statusCode(200)+ .body("Items.size()", equalTo(1))+ .body("Items[0].data.S", equalTo("gone"));++ statement("DELETE FROM \"" + TABLE + "\" WHERE pk = 'ret-delete' RETURNING ALL OLD *")+ .statusCode(200)+ .body("Items.size()", equalTo(0));+ }++ @Test+ @Order(12)+ void aTransactionMemberTakesNoReturningClause() {+ request("DynamoDB_20120810.ExecuteTransaction", """+ {"TransactStatements":[{"Statement":"UPDATE \\"%s\\" SET data = 'v' WHERE pk = 'ret-txn' RETURNING ALL NEW *"}]}+ """.formatted(TABLE))+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("Validation failed in TransactStatements[0]:"+ + " RETURNING clause is not supported in ExecuteTransaction."));+ }++ @Test+ @Order(13)+ void updateSetsFromAnAttributeAndALiteral() {+ putItem("arith", "\"n\":{\"N\":\"5\"}");++ statement("UPDATE \"" + TABLE + "\" SET n = n + 1 WHERE pk = 'arith' RETURNING MODIFIED NEW *")+ .statusCode(200)+ .body("Items[0].n.N", equalTo("6"));++ statement("UPDATE \"" + TABLE + "\" SET n = n - 2 WHERE pk = 'arith' RETURNING MODIFIED NEW *")+ .statusCode(200)+ .body("Items[0].n.N", equalTo("4"));+ }++ @Test+ @Order(14)+ void aReplayedTransactionTokenDoesNotApplyTwice() {+ putItem("txn-idem", "\"n\":{\"N\":\"0\"}");+ String body = """+ {"ClientRequestToken":"partiql-idem-token","TransactStatements":[+ {"Statement":"UPDATE \\"%s\\" SET n = n + 1 WHERE pk = 'txn-idem'"}]}+ """.formatted(TABLE);++ request("DynamoDB_20120810.ExecuteTransaction", body).statusCode(200);+ request("DynamoDB_20120810.ExecuteTransaction", body).statusCode(200);++ request("DynamoDB_20120810.GetItem", """+ {"TableName":"%s","Key":{"pk":{"S":"txn-idem"}}}+ """.formatted(TABLE))+ .statusCode(200)+ .body("Item.n.N", equalTo("1"));+ }++ @Test+ @Order(15)+ void aWriteStatementRejectsAnIndexQualifier() {+ statement("INSERT INTO \"" + TABLE + "\".\"an-index\" VALUE {'pk': 'qualified'}")+ .statusCode(400)+ .body("message", equalTo("FROM clause may only contain a single table name"));++ statement("UPDATE \"" + TABLE + "\".\"an-index\" SET data = 'x' WHERE pk = 'qualified'")+ .statusCode(400)+ .body("message", equalTo("This operation is not supported on an index"));++ statement("DELETE FROM \"" + TABLE + "\".\"an-index\" WHERE pk = 'qualified'")+ .statusCode(400)+ .body("message", equalTo("This operation is not supported on an index"));++ request("DynamoDB_20120810.ExecuteTransaction", """+ {"TransactStatements":[{"Statement":"UPDATE \\"%s\\".\\"an-index\\" SET data = 'x' WHERE pk = 'qualified'"}]}+ """.formatted(TABLE))+ .statusCode(400)+ .body("message", equalTo("Validation failed in TransactStatements[0]:"+ + " This operation is not supported on an index"));+ }++ @Test+ @Order(16)+ void theFromClauseTakesAtMostTwoNonEmptyComponents() {+ statement("SELECT * FROM \"\" WHERE pk = 'x'")+ .statusCode(400)+ .body("message", equalTo("Path component cannot be an empty string"));++ statement("SELECT * FROM \"" + TABLE + "\".\"\" WHERE pk = 'x'")+ .statusCode(400)+ .body("message", equalTo("Path component cannot be an empty string"));++ statement("SELECT * FROM \"" + TABLE + "\".\"an-index\".\"extra\" WHERE pk = 'x'")+ .statusCode(400)+ .body("message", equalTo("A path may contain at most 2 components in the FROM clause"));+ }++ @Test+ @Order(17)+ void aTransactionOfSelectsReadsTheItems() {+ putItem("txn-read", "\"data\":{\"S\":\"here\"}");++ request("DynamoDB_20120810.ExecuteTransaction", """+ {"TransactStatements":[{"Statement":"SELECT * FROM \\"%s\\" WHERE pk = 'txn-read'"}]}+ """.formatted(TABLE))+ .statusCode(200)+ .body("Responses.size()", equalTo(1))+ .body("Responses[0].Item.data.S", equalTo("here"));++ request("DynamoDB_20120810.ExecuteTransaction", """+ {"TransactStatements":[{"Statement":"SELECT * FROM \\"%s\\".\\"an-index\\" WHERE pk = 'txn-read'"}]}+ """.formatted(TABLE))+ .statusCode(400)+ .body("message", equalTo("Validation failed in TransactStatements[0]:"+ + " Reads on indices are not supported within transactions."));+ }++ @Test+ @Order(18)+ void aBatchMemberCarriesTheShortErrorCode() {+ putItem("batch-dup", "\"val\":{\"S\":\"here\"}");++ request("DynamoDB_20120810.BatchExecuteStatement", """+ {"Statements":[+ {"Statement":"SLECT * FROM \\"%1$s\\" WHERE pk = 'batch-dup'"},+ {"Statement":"INSERT INTO \\"%1$s\\" VALUE {'pk': 'batch-dup'}"},+ {"Statement":"UPDATE \\"%1$s\\" SET touched = 'yes' WHERE pk = 'batch-dup' AND val = 'wrong'"}]}+ """.formatted(TABLE))+ .statusCode(200)+ .body("Responses[0].Error.Code", equalTo("ValidationError"))+ .body("Responses[0].Error.Message", equalTo(+ "Statement wasn't well formed, can't be processed: Expected data manipulation"))+ .body("Responses[0].TableName", nullValue())+ .body("Responses[1].Error.Code", equalTo("DuplicateItem"))+ .body("Responses[1].TableName", equalTo(TABLE))+ .body("Responses[2].Error.Code", equalTo("ConditionalCheckFailed"))+ .body("Responses[2].TableName", equalTo(TABLE));+ }++ private static void putItem(String pk, String attributes) {+ request("DynamoDB_20120810.PutItem", """+ {"TableName":"%s","Item":{"pk":{"S":"%s"},%s}}+ """.formatted(TABLE, pk, attributes))+ .statusCode(200);+ }++ private static ValidatableResponse statement(String partiql) {+ return request("DynamoDB_20120810.ExecuteStatement",+ "{\"Statement\":\"" + partiql.replace("\"", "\\\"") + "\"}");+ }++ private static ValidatableResponse request(String target, String body) {+ return given()+ .header("X-Amz-Target", target)+ .contentType(CONTENT_TYPE)+ .body(body)+ .when()+ .post("/")+ .then();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLParserTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLParserTest.javaindex 9aa3f32faa..b37f980df1 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLParserTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbPartiQLParserTest.java@@ -5,18 +5,26 @@ import com.fasterxml.jackson.databind.ObjectMapper;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.dynamodb.DynamoDbPartiQLParser.Cond;import io.github.hectorvent.floci.services.dynamodb.DynamoDbPartiQLParser.PVal;+import io.github.hectorvent.floci.services.dynamodb.DynamoDbPartiQLParser.Path;+import io.github.hectorvent.floci.services.dynamodb.DynamoDbPartiQLParser.Seg;import io.github.hectorvent.floci.services.dynamodb.DynamoDbPartiQLParser.Stmt;import org.junit.jupiter.api.Test;import org.junit.jupiter.params.ParameterizedTest;import org.junit.jupiter.params.provider.CsvSource;import org.junit.jupiter.params.provider.ValueSource;+import java.util.stream.Collectors;+import java.util.stream.IntStream;+import java.util.Arrays;+import java.util.List;import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertInstanceOf;+import static org.junit.jupiter.api.Assertions.assertNotEquals;import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;class DynamoDbPartiQLParserTest {@@ -160,4 +168,105 @@ class DynamoDbPartiQLParserTest {assertEquals("<", assertInstanceOf(Cond.Cmp.class, cond).op());}++ @Test+ void parsesADocumentPathInASelectColumn() {+ Stmt stmt = DynamoDbPartiQLParser.parse("SELECT a.b[2].c FROM \"t\" WHERE pk = 'p'", List.of());++ Path column = assertInstanceOf(Stmt.Select.class, stmt).columns().getFirst();+ assertEquals(List.of(new Seg.Name("a"), new Seg.Name("b"), new Seg.Index(2), new Seg.Name("c")),+ column.segments());+ assertEquals("a", column.root());+ assertEquals("c", column.leafName());+ }++ @Test+ void parsesADocumentPathInAnUpdateTarget() {+ Stmt stmt = DynamoDbPartiQLParser.parse(+ "UPDATE \"t\" SET profile.sub = 'x' REMOVE tags[0] WHERE pk = 'p'", List.of());++ Stmt.Update update = assertInstanceOf(Stmt.Update.class, stmt);+ assertEquals(List.of(new Seg.Name("profile"), new Seg.Name("sub")),+ update.sets().getFirst().path().segments());+ assertEquals(List.of(new Seg.Name("tags"), new Seg.Index(0)),+ update.removes().getFirst().segments());+ }++ @Test+ void keepsABareAttributeNameAsARootOnlyPath() {+ Path path = assertInstanceOf(Cond.Eq.class, firstCond(SELECT + "= 'x'")).path();++ assertTrue(path.isRootOnly());+ assertEquals("val", path.root());+ }++ @Test+ void parsesAnInListAsOneCondition() {+ Cond.In in = assertInstanceOf(Cond.In.class, firstCond(SELECT + "IN ['a', 'b']"));++ assertEquals(2, in.values().size());+ assertEquals("val", in.path().root());+ }++ @ParameterizedTest+ @CsvSource({"IS MISSING, false", "IS NOT MISSING, true"})+ void parsesTheMissingPredicateWithItsNegation(String predicate, boolean negated) {+ Cond.Missing missing = assertInstanceOf(Cond.Missing.class, firstCond(SELECT + predicate));++ assertEquals(negated, missing.negated());+ }++ @Test+ void parsesNotAheadOfThePredicateItNegates() {+ Stmt stmt = DynamoDbPartiQLParser.parse(+ "SELECT pk FROM \"t\" WHERE NOT begins_with(val, 'a')", List.of());++ Cond.Not not = assertInstanceOf(Cond.Not.class,+ assertInstanceOf(Stmt.Select.class, stmt).where().getFirst());+ assertInstanceOf(Cond.BeginsWith.class, not.operand());+ }++ @Test+ void parsesAGroupedOrAsASingleTopLevelCondition() {+ Stmt stmt = DynamoDbPartiQLParser.parse(+ "SELECT pk FROM \"t\" WHERE (pk = 'a' AND v = 1) OR (pk = 'b')", List.of());++ List<Cond> where = assertInstanceOf(Stmt.Select.class, stmt).where();+ assertEquals(1, where.size());+ Cond.Or or = assertInstanceOf(Cond.Or.class, where.getFirst());+ assertEquals(2, or.operands().size());+ assertInstanceOf(Cond.And.class, or.operands().getFirst());+ }++ @Test+ void rejectsAListIndexThatIsNotAWholeNumber() {+ AwsException e = assertThrows(AwsException.class,+ () -> DynamoDbPartiQLParser.parse("SELECT a[1.5] FROM \"t\" WHERE pk = 'p'", List.of()));++ assertEquals("ValidationException", e.getErrorCode());+ }++ @Test+ void rejectsAnInOperatorWithMoreThan100Operands() {+ AwsException e = assertThrows(AwsException.class,+ () -> DynamoDbPartiQLParser.parse("SELECT a FROM \"t\" WHERE pk IN [" + inValues(101) + "]", List.of()));++ assertEquals("ValidationException", e.getErrorCode());+ assertEquals("The IN operator is provided with too many operands; number of operands: 101", e.getMessage());+ assertDoesNotThrow(() -> DynamoDbPartiQLParser.parse(+ "SELECT a FROM \"t\" WHERE pk IN [" + inValues(100) + "]", List.of()));+ }++ @Test+ void readsTheWholeStatementBeforeItCountsInOperands() {+ AwsException e = assertThrows(AwsException.class,+ () -> DynamoDbPartiQLParser.parse("SELECT a FROM \"t\" WHERE pk IN [" + inValues(101) + "] AND", List.of()));++ assertEquals("ValidationException", e.getErrorCode());+ assertNotEquals("The IN operator is provided with too many operands; number of operands: 101", e.getMessage());+ }++ private static String inValues(int count) {+ return IntStream.range(0, count).mapToObj(i -> "'v" + i + "'").collect(Collectors.joining(","));+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/ExpressionEvaluatorTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/ExpressionEvaluatorTest.javaindex e2c83b63a4..aed6eae6ee 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/ExpressionEvaluatorTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/ExpressionEvaluatorTest.java@@ -267,6 +267,14 @@ class ExpressionEvaluatorTest {return mapper.readTree(json);}+ @Test+ void orderingAgainstAnotherTypeMatchesNothing() throws Exception {+ JsonNode i = item("{\"a\": {\"S\": \"5\"}}");+ JsonNode v = values("{\":low\": {\"N\": \"1\"}, \":high\": {\"N\": \"9\"}}");+ assertFalse(ExpressionEvaluator.matches("a > :low", i, null, v));+ assertFalse(ExpressionEvaluator.matches("a BETWEEN :low AND :high", i, null, v));+ }+// AND, OR, NOT logic@Test