Light, fluffy, and always free - The AWS Local Emulator alternative
feat(glue): table version reads and deletes, batch partition delete, SearchTables (#3828)
David30b491a54670
diff --git a/docs/services/glue.md b/docs/services/glue.mdindex 064068751f..12618b6929 100644--- a/docs/services/glue.md+++ b/docs/services/glue.md@@ -25,7 +25,14 @@ Floci emulates the AWS Glue Data Catalog and Glue Schema Registry, allowing you| CreateTable | Creates a table definition in the local Glue Data Catalog. || GetTable | Returns a stored table definition and resolves schema references when possible. || GetTables | Lists table definitions for a database. |+| UpdateTable | Replaces a table definition; the previous version is archived unless `SkipArchive` is set. || DeleteTable | Deletes a table definition from a database. |+| BatchDeleteTable | Deletes several tables of a database, reporting the missing ones in `Errors`. |+| GetTableVersions | Lists the current and archived versions of a table, newest first. |+| GetTableVersion | Returns one version by `VersionId`, or the current version when none is given. |+| DeleteTableVersion | Deletes an archived version; the current version cannot be deleted, as on AWS. |+| BatchDeleteTableVersion | Deletes several archived versions, reporting the ones not deleted in `Errors`. |+| SearchTables | Searches every table of the catalog by `SearchText` (substring, or exact when quoted), property `Filters` (string keys use the tokenised match of the API reference, time keys honour `Comparator`, other keys read table parameters) and `SortCriteria`, paged by `MaxResults` and `NextToken`. |#### Partitions@@ -33,6 +40,7 @@ Floci emulates the AWS Glue Data Catalog and Glue Schema Registry, allowing you|--------|-------------|| CreatePartition | Creates a partition for a Data Catalog table. || GetPartitions | Lists partitions stored for a Data Catalog table. |+| BatchDeletePartition | Deletes up to 25 partitions, reporting the ones not found in `Errors`. || CreatePartitionIndex | Registers a partition index on a table. Keys must name partition columns, and a table holds at most 3 indexes. The index reports `CREATING` before `ACTIVE`. || GetPartitionIndexes | Lists a table's partition indexes, each with its keys resolved to name and type. || DeletePartitionIndex | Removes a partition index from a table. The index reports `DELETING` before it disappears. |diff --git a/src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.javaindex 273c97ddb8..4694a53a49 100644--- a/src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.java@@ -124,6 +124,26 @@ public class GlueJsonHandler {String tableName = request.get("TableName").asText();yield Response.ok(Map.of("TableVersions", glueService.getTableVersions(dbName, tableName))).build();}+ case "GetTableVersion" -> {+ String dbName = request.get("DatabaseName").asText();+ String tableName = request.get("TableName").asText();+ yield Response.ok(Map.of("TableVersion", glueService.getTableVersion(+ dbName, tableName, request.path("VersionId").asText(null)))).build();+ }+ case "DeleteTableVersion" -> {+ String dbName = request.get("DatabaseName").asText();+ String tableName = request.get("TableName").asText();+ glueService.deleteTableVersion(dbName, tableName, request.path("VersionId").asText(null));+ yield Response.ok().build();+ }+ case "BatchDeleteTableVersion" -> {+ String dbName = request.get("DatabaseName").asText();+ String tableName = request.get("TableName").asText();+ List<String> versionIds = mapper.convertValue(request.get("VersionIds"), STRING_LIST);+ yield Response.ok(Map.of("Errors", glueService.batchDeleteTableVersions(+ dbName, tableName, versionIds == null ? List.of() : versionIds))).build();+ }+ case "SearchTables" -> handleSearchTables(request);case "DeleteTable" -> {String dbName = request.get("DatabaseName").asText();String tableName = request.get("Name").asText();@@ -156,6 +176,7 @@ public class GlueJsonHandler {yield Response.ok(Map.of("Partitions", glueService.getPartitions(dbName, tableName, expression))).build();}case "DeletePartition" -> handleDeletePartition(request);+ case "BatchDeletePartition" -> handleBatchDeletePartition(request);case "UpdatePartition" -> handleUpdatePartition(request);case "UpdateColumnStatisticsForPartition" -> handleUpdateColumnStatisticsForPartition(request);case "GetColumnStatisticsForPartition" -> handleGetColumnStatisticsForPartition(request);@@ -319,6 +340,31 @@ public class GlueJsonHandler {.build();}+ private Response handleBatchDeletePartition(JsonNode request) {+ String dbName = request.get("DatabaseName").asText();+ String tableName = request.get("TableName").asText();+ List<Map<String, Object>> partitionsToDelete = mapper.convertValue(request.get("PartitionsToDelete"), MAP_LIST);+ List<List<String>> partitionValues = (partitionsToDelete == null ? List.<Map<String, Object>>of() : partitionsToDelete)+ .stream()+ .map(partition -> mapper.convertValue(partition.get("Values"), STRING_LIST))+ .toList();+ return Response.ok(Map.of(+ "Errors", glueService.batchDeletePartitions(dbName, tableName, partitionValues))).build();+ }++ private Response handleSearchTables(JsonNode request) {+ List<GlueService.SearchFilter> filters = request.hasNonNull("Filters")+ ? mapper.convertValue(request.get("Filters"), new TypeReference<List<GlueService.SearchFilter>>() {})+ : null;+ List<GlueService.SearchSort> sortCriteria = request.hasNonNull("SortCriteria")+ ? mapper.convertValue(request.get("SortCriteria"), new TypeReference<List<GlueService.SearchSort>>() {})+ : null;+ GlueService.Page<Table> page = glueService.searchTables(+ request.path("SearchText").asText(null), filters, sortCriteria,+ readMaxResults(request), readNextToken(request));+ return Response.ok(pageResponse("TableList", page.items(), page.nextToken())).build();+ }+private Response handleDeletePartition(JsonNode request) {String dbName = request.get("DatabaseName").asText();String tableName = request.get("TableName").asText();diff --git a/src/main/java/io/github/hectorvent/floci/services/glue/GlueService.java b/src/main/java/io/github/hectorvent/floci/services/glue/GlueService.javaindex 45d706e334..36c2781a8f 100644--- a/src/main/java/io/github/hectorvent/floci/services/glue/GlueService.java+++ b/src/main/java/io/github/hectorvent/floci/services/glue/GlueService.java@@ -243,6 +243,198 @@ public class GlueService {return resolved;}+ /**+ * SearchTables over every table of the catalog. SearchText matches a substring of the name,+ * database, description, owner, column names and comments and parameter values, or the whole+ * name when quoted, as the reference describes. String filters use the reference's tokenised+ * match (the field split on punctuation, each token compared whole), time filters honour the+ * Comparator, and any other key is looked up in the table's parameters.+ */+ public Page<Table> searchTables(String searchText, List<SearchFilter> filters,+ List<SearchSort> sortCriteria, Integer maxResults, String nextToken) {+ List<Table> matches = new ArrayList<>();+ for (Table stored : tableStore.scan(k -> true)) {+ Table table = withResolvedSchemaReference(stored);+ if (matchesSearchText(table, searchText) && matchesFilters(table, filters)) {+ matches.add(table);+ }+ }+ matches.sort(searchComparator(sortCriteria));+ return paginate(matches, maxResults, nextToken);+ }++ @RegisterForReflection+ public record SearchFilter(+ @JsonProperty("Key") String key,+ @JsonProperty("Value") String value,+ @JsonProperty("Comparator") String comparator) {}++ @RegisterForReflection+ public record SearchSort(+ @JsonProperty("FieldName") String fieldName,+ @JsonProperty("Sort") String sort) {}++ private static boolean matchesSearchText(Table table, String searchText) {+ if (searchText == null || searchText.isBlank()) {+ return true;+ }+ String text = searchText.trim();+ boolean exact = text.length() >= 2 && text.startsWith("\"") && text.endsWith("\"");+ if (exact) {+ text = text.substring(1, text.length() - 1);+ }+ String needle = text.toLowerCase(Locale.ROOT);+ if (exact) {+ return searchableValues(table).stream().anyMatch(value -> value.equalsIgnoreCase(needle));+ }+ return searchableValues(table).stream()+ .anyMatch(value -> value.toLowerCase(Locale.ROOT).contains(needle));+ }++ private static List<String> searchableValues(Table table) {+ List<String> values = new ArrayList<>();+ addIfPresent(values, table.getName());+ addIfPresent(values, table.getDatabaseName());+ addIfPresent(values, table.getDescription());+ addIfPresent(values, table.getOwner());+ if (table.getStorageDescriptor() != null && table.getStorageDescriptor().getColumns() != null) {+ for (Column column : table.getStorageDescriptor().getColumns()) {+ addIfPresent(values, column.getName());+ addIfPresent(values, column.getComment());+ }+ }+ if (table.getPartitionKeys() != null) {+ for (Column column : table.getPartitionKeys()) {+ addIfPresent(values, column.getName());+ addIfPresent(values, column.getComment());+ }+ }+ if (table.getParameters() != null) {+ table.getParameters().values().forEach(value -> addIfPresent(values, value));+ }+ return values;+ }++ private static void addIfPresent(List<String> values, String value) {+ if (value != null && !value.isBlank()) {+ values.add(value);+ }+ }++ private static boolean matchesFilters(Table table, List<SearchFilter> filters) {+ if (filters == null) {+ return true;+ }+ for (SearchFilter filter : filters) {+ if (filter == null || filter.key() == null || filter.key().isBlank()) {+ throw new AwsException("InvalidInputException", "Filter Key is required.", 400);+ }+ if (!matchesFilter(table, filter)) {+ return false;+ }+ }+ return true;+ }++ private static boolean matchesFilter(Table table, SearchFilter filter) {+ String key = filter.key();+ String value = filter.value() == null ? "" : filter.value();+ switch (key) {+ case "Name": return tokenMatch(table.getName(), value);+ case "DatabaseName": return tokenMatch(table.getDatabaseName(), value);+ case "Owner": return tokenMatch(table.getOwner(), value);+ case "TableType": return tokenMatch(table.getTableType(), value);+ case "Description": return tokenMatch(table.getDescription(), value);+ case "CreateTime": return timeMatch(table.getCreateTime(), value, filter.comparator());+ case "UpdateTime": return timeMatch(table.getUpdateTime(), value, filter.comparator());+ case "LastAccessTime": return timeMatch(table.getLastAccessTime(), value, filter.comparator());+ default:+ return table.getParameters() != null && tokenMatch(table.getParameters().get(key), value);+ }+ }++ /** The reference's fuzzy match: the field split on punctuation, each token compared whole. */+ private static boolean tokenMatch(String field, String value) {+ if (field == null) {+ return false;+ }+ if (field.equalsIgnoreCase(value)) {+ return true;+ }+ for (String token : field.split("[\\p{Punct}\\s]+")) {+ if (!token.isEmpty() && token.equalsIgnoreCase(value)) {+ return true;+ }+ }+ return false;+ }++ private static boolean timeMatch(Instant field, String value, String comparator) {+ if (field == null) {+ return false;+ }+ Instant bound = parseSearchTime(value);+ int cmp = field.compareTo(bound);+ String op = comparator == null || comparator.isBlank() ? "EQUALS" : comparator;+ return switch (op) {+ case "EQUALS" -> cmp == 0;+ case "GREATER_THAN" -> cmp > 0;+ case "LESS_THAN" -> cmp < 0;+ case "GREATER_THAN_EQUALS" -> cmp >= 0;+ case "LESS_THAN_EQUALS" -> cmp <= 0;+ default -> throw new AwsException("InvalidInputException",+ "Invalid Comparator: " + comparator, 400);+ };+ }++ /** A time filter value: epoch seconds as AWS timestamps travel, or an ISO-8601 instant. */+ private static Instant parseSearchTime(String value) {+ try {+ return Instant.ofEpochSecond(Long.parseLong(value.trim()));+ } catch (NumberFormatException ignored) {+ // not epoch seconds+ }+ try {+ return Instant.parse(value.trim());+ } catch (java.time.format.DateTimeParseException e) {+ throw new AwsException("InvalidInputException", "Invalid time value: " + value, 400);+ }+ }++ private static Comparator<Table> searchComparator(List<SearchSort> sortCriteria) {+ Comparator<Table> byName = Comparator.comparing(Table::getDatabaseName, Comparator.nullsLast(String::compareTo))+ .thenComparing(Table::getName, Comparator.nullsLast(String::compareTo));+ if (sortCriteria == null || sortCriteria.isEmpty()) {+ return byName;+ }+ Comparator<Table> result = null;+ for (SearchSort criterion : sortCriteria) {+ Comparator<Table> next = sortField(criterion.fieldName());+ if ("DESC".equalsIgnoreCase(criterion.sort())) {+ next = next.reversed();+ } else if (criterion.sort() != null && !"ASC".equalsIgnoreCase(criterion.sort())) {+ throw new AwsException("InvalidInputException", "Invalid Sort: " + criterion.sort(), 400);+ }+ result = result == null ? next : result.thenComparing(next);+ }+ return result.thenComparing(byName);+ }++ private static Comparator<Table> sortField(String fieldName) {+ String field = fieldName == null ? "" : fieldName;+ return switch (field) {+ case "Name" -> Comparator.comparing(Table::getName, Comparator.nullsLast(String::compareTo));+ case "DatabaseName" -> Comparator.comparing(Table::getDatabaseName, Comparator.nullsLast(String::compareTo));+ case "Owner" -> Comparator.comparing(Table::getOwner, Comparator.nullsLast(String::compareTo));+ case "TableType" -> Comparator.comparing(Table::getTableType, Comparator.nullsLast(String::compareTo));+ case "CreateTime" -> Comparator.comparing(Table::getCreateTime, Comparator.nullsLast(Instant::compareTo));+ case "UpdateTime" -> Comparator.comparing(Table::getUpdateTime, Comparator.nullsLast(Instant::compareTo));+ case "LastAccessTime" -> Comparator.comparing(Table::getLastAccessTime, Comparator.nullsLast(Instant::compareTo));+ default -> throw new AwsException("InvalidInputException",+ "Invalid sort FieldName: " + fieldName, 400);+ };+ }+public synchronized void updateTable(String databaseName, Table table, String versionId, boolean skipArchive) {Database database = getDatabase(databaseName);String key = tableKey(databaseName, table.getName());@@ -282,6 +474,71 @@ public class GlueService {.toList();}+ /** One archived version, or the current table when no VersionId is given, as AWS answers. */+ public Map<String, Object> getTableVersion(String databaseName, String tableName, String versionId) {+ Table current = getTable(databaseName, tableName);+ Table version;+ if (versionId == null || versionId.isBlank() || versionId.equals(current.getVersionId())) {+ version = current;+ } else {+ requireIntegerVersionId(versionId);+ version = tableVersionStore.get(tableVersionKey(databaseName, tableName, versionId))+ .map(this::withResolvedSchemaReference)+ .orElseThrow(() -> new AwsException("EntityNotFoundException", "Version not found.", 400));+ }+ return Map.of("Table", version, "VersionId", version.getVersionId());+ }++ /**+ * Drops an archived version. The current version is never deletable on AWS (DeleteTable is+ * the way to drop it), so it is refused rather than silently kept.+ */+ public synchronized void deleteTableVersion(String databaseName, String tableName, String versionId) {+ Table current = getTable(databaseName, tableName);+ requireIntegerVersionId(versionId);+ if (versionId.equals(current.getVersionId())) {+ throw new AwsException("InvalidInputException",+ "Cannot delete the latest version " + versionId + " of table " + tableName+ + "; delete the table instead.", 400);+ }+ String key = tableVersionKey(databaseName, tableName, versionId);+ if (tableVersionStore.get(key).isEmpty()) {+ throw new AwsException("EntityNotFoundException", "Version not found.", 400);+ }+ tableVersionStore.delete(key);+ LOG.infov("Deleted Glue Table version: {0}.{1} v{2}", databaseName, tableName, versionId);+ }++ public synchronized List<TableVersionError> batchDeleteTableVersions(+ String databaseName, String tableName, List<String> versionIds) {+ Table current = getTable(databaseName, tableName);+ if (versionIds.size() > 100) {+ throw new AwsException("InvalidInputException",+ "VersionIds must contain at most 100 versions.", 400);+ }+ List<TableVersionError> errors = new ArrayList<>();+ for (String versionId : versionIds) {+ try {+ deleteTableVersion(databaseName, current.getName(), versionId);+ } catch (AwsException e) {+ errors.add(new TableVersionError(current.getName(), versionId,+ new ErrorDetail(e.getErrorCode(), e.getMessage())));+ }+ }+ return errors;+ }++ private static void requireIntegerVersionId(String versionId) {+ if (versionId == null || versionId.isBlank()) {+ throw new AwsException("InvalidInputException", "VersionId is required.", 400);+ }+ try {+ Long.parseLong(versionId);+ } catch (NumberFormatException e) {+ throw new AwsException("InvalidInputException", "Invalid table VersionId: " + versionId, 400);+ }+ }+public void deleteTable(String databaseName, String tableName) {getTable(databaseName, tableName);String key = tableKey(databaseName, tableName);@@ -621,6 +878,26 @@ public class GlueService {.forEach(partitionColumnStatisticsStore::delete);}+ /** Deletes what exists and reports the rest, the batch shape BatchCreatePartition uses. */+ public List<BatchCreatePartitionError> batchDeletePartitions(+ String databaseName, String tableName, List<List<String>> partitionsToDelete) {+ getTable(databaseName, tableName);+ if (partitionsToDelete.size() > 25) {+ throw new AwsException("InvalidInputException",+ "PartitionsToDelete must contain at most 25 partitions.", 400);+ }+ List<BatchCreatePartitionError> errors = new ArrayList<>();+ for (List<String> values : partitionsToDelete) {+ if (partitionStore.get(partitionKey(databaseName, tableName, values)).isEmpty()) {+ errors.add(new BatchCreatePartitionError(values,+ new ErrorDetail("EntityNotFoundException", "Cannot find partition.")));+ continue;+ }+ deletePartition(databaseName, tableName, values);+ }+ return errors;+ }+public void updatePartition(String databaseName, String tableName, List<String> partitionValues, Partition partition) {Table table = getTable(databaseName, tableName);String key = partitionKey(databaseName, tableName, partitionValues);@@ -1090,6 +1367,12 @@ public class GlueService {@JsonProperty("TableName") String tableName,@JsonProperty("ErrorDetail") ErrorDetail errorDetail) {}+ @RegisterForReflection+ public record TableVersionError(+ @JsonProperty("TableName") String tableName,+ @JsonProperty("VersionId") String versionId,+ @JsonProperty("ErrorDetail") ErrorDetail errorDetail) {}+@RegisterForReflectionpublic record BatchCreatePartitionError(@JsonProperty("PartitionValues") List<String> partitionValues,diff --git a/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerTest.javaindex 8e33bd28cc..b7f23ddc12 100644--- a/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerTest.java@@ -402,6 +402,89 @@ class GlueJsonHandlerTest {assertEquals("glueetl", job.get("Command").get("Name").asText());}+ @SuppressWarnings("unchecked")+ private static Map<String, Object> body(Response response) {+ assertEquals(200, response.getStatus());+ return (Map<String, Object>) response.getEntity();+ }++ /** The version calls answer with the reference's shapes: a TableVersion wrapper, per-version Errors. */+ @Test+ void tableVersionCallsUseTheReferenceShapes() throws Exception {+ createDatabaseAndTable("versions_db", "plain");+ ObjectNode update = mapper.createObjectNode();+ update.put("DatabaseName", "versions_db");+ update.putObject("TableInput").put("Name", "plain").put("Description", "second");+ assertEquals(200, handler.handle("UpdateTable", update, REGION).getStatus());++ ObjectNode get = mapper.createObjectNode();+ get.put("DatabaseName", "versions_db").put("TableName", "plain").put("VersionId", "0");+ Map<String, Object> version = (Map<String, Object>) body(handler.handle("GetTableVersion", get, REGION))+ .get("TableVersion");+ assertEquals("0", version.get("VersionId"));+ assertNotNull(version.get("Table"));++ ObjectNode batch = mapper.createObjectNode();+ batch.put("DatabaseName", "versions_db").put("TableName", "plain");+ batch.putArray("VersionIds").add("0").add("5");+ List<GlueService.TableVersionError> errors = (List<GlueService.TableVersionError>) body(+ handler.handle("BatchDeleteTableVersion", batch, REGION)).get("Errors");+ assertEquals(1, errors.size());+ assertEquals("5", errors.get(0).versionId());+ assertEquals("plain", errors.get(0).tableName());+ assertEquals("{\"TableName\":\"plain\",\"VersionId\":\"5\",\"ErrorDetail\":{\"ErrorCode\":\"EntityNotFoundException\",\"ErrorMessage\":\"Version not found.\"}}",+ mapper.writeValueAsString(errors.get(0)));++ ObjectNode delete = mapper.createObjectNode();+ delete.put("DatabaseName", "versions_db").put("TableName", "plain").put("VersionId", "0");+ AwsException gone = assertThrows(AwsException.class, () -> handler.handle("DeleteTableVersion", delete, REGION));+ assertEquals("EntityNotFoundException", gone.getErrorCode());+ }++ @Test+ void batchDeletePartitionReportsMissingPartitionsInErrors() throws Exception {+ createPartitionedTable("bdp_db", "events", "dt");+ ObjectNode create = mapper.createObjectNode();+ create.put("DatabaseName", "bdp_db").put("TableName", "events");+ create.putObject("PartitionInput").putArray("Values").add("2026-01-01");+ assertEquals(200, handler.handle("CreatePartition", create, REGION).getStatus());++ ObjectNode batch = mapper.createObjectNode();+ batch.put("DatabaseName", "bdp_db").put("TableName", "events");+ ArrayNode toDelete = batch.putArray("PartitionsToDelete");+ toDelete.addObject().putArray("Values").add("2026-01-01");+ toDelete.addObject().putArray("Values").add("2026-01-02");+ List<GlueService.BatchCreatePartitionError> errors = (List<GlueService.BatchCreatePartitionError>) body(+ handler.handle("BatchDeletePartition", batch, REGION)).get("Errors");+ assertEquals(1, errors.size());+ assertEquals(List.of("2026-01-02"), errors.get(0).partitionValues());+ assertTrue(mapper.writeValueAsString(errors.get(0)).startsWith("{\"PartitionValues\":[\"2026-01-02\"],\"ErrorDetail\":"));++ ObjectNode list = mapper.createObjectNode();+ list.put("DatabaseName", "bdp_db").put("TableName", "events");+ assertTrue(((List<?>) body(handler.handle("GetPartitions", list, REGION)).get("Partitions")).isEmpty());+ }++ @Test+ void searchTablesReturnsTableListWithPaging() throws Exception {+ createDatabaseAndTable("search_db", "alpha");+ createDatabaseAndTable("search_db2", "beta");++ ObjectNode search = mapper.createObjectNode();+ search.put("MaxResults", 1);+ Map<String, Object> first = body(handler.handle("SearchTables", search, REGION));+ assertEquals(1, ((List<?>) first.get("TableList")).size());+ assertNotNull(first.get("NextToken"));++ ObjectNode filtered = mapper.createObjectNode();+ filtered.putArray("Filters").addObject().put("Key", "DatabaseName").put("Value", "search_db2");+ filtered.putArray("SortCriteria").addObject().put("FieldName", "Name").put("Sort", "ASC");+ Map<String, Object> page = body(handler.handle("SearchTables", filtered, REGION));+ List<?> tables = (List<?>) page.get("TableList");+ assertEquals(1, tables.size());+ assertEquals("beta", ((io.github.hectorvent.floci.services.glue.model.Table) tables.get(0)).getName());+ }+private static final class InMemoryStorageFactory extends StorageFactory {private InMemoryStorageFactory() {super(null, null);diff --git a/src/test/java/io/github/hectorvent/floci/services/glue/GlueServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/glue/GlueServiceTest.javaindex 9bf4a9722e..80bda3da9f 100644--- a/src/test/java/io/github/hectorvent/floci/services/glue/GlueServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/glue/GlueServiceTest.java@@ -37,6 +37,7 @@ import java.util.concurrent.TimeUnit;import java.util.concurrent.CountDownLatch;import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNotNull;import static org.junit.jupiter.api.Assertions.assertNull;import static org.junit.jupiter.api.Assertions.assertThrows;@@ -1311,4 +1312,173 @@ class GlueServiceTest {glueService.getPartitionIndexes("db1", "indexed");}+ // ── Table versions, batch partition delete and SearchTables ──────────────++ private Table namedTable(String name) {+ Table table = new Table();+ table.setName(name);+ return table;+ }++ private void createVersions(String name, int updates) {+ Table table = namedTable(name);+ table.setDescription("v0");+ glueService.createTable("db1", table);+ for (int i = 1; i <= updates; i++) {+ Table replacement = namedTable(name);+ replacement.setDescription("v" + i);+ glueService.updateTable("db1", replacement, String.valueOf(i - 1), false);+ }+ }++ @Test+ void getTableVersionReturnsTheRequestedOrTheCurrentVersion() {+ createVersions("plain", 2);++ Map<String, Object> archived = glueService.getTableVersion("db1", "plain", "0");+ assertEquals("0", archived.get("VersionId"));+ assertEquals("v0", ((Table) archived.get("Table")).getDescription());++ Map<String, Object> current = glueService.getTableVersion("db1", "plain", null);+ assertEquals("2", current.get("VersionId"));+ assertEquals("v2", ((Table) current.get("Table")).getDescription());+ assertEquals("2", glueService.getTableVersion("db1", "plain", "2").get("VersionId"));++ AwsException missing = assertThrows(AwsException.class,+ () -> glueService.getTableVersion("db1", "plain", "7"));+ assertEquals("EntityNotFoundException", missing.getErrorCode());+ assertEquals("Version not found.", missing.getMessage());+ AwsException notAnInteger = assertThrows(AwsException.class,+ () -> glueService.getTableVersion("db1", "plain", "latest"));+ assertEquals("InvalidInputException", notAnInteger.getErrorCode());+ AwsException noTable = assertThrows(AwsException.class,+ () -> glueService.getTableVersion("db1", "nope", "0"));+ assertEquals("EntityNotFoundException", noTable.getErrorCode());+ }++ @Test+ void deleteTableVersionDropsArchivedVersionsButNeverTheCurrentOne() {+ createVersions("plain", 3);++ glueService.deleteTableVersion("db1", "plain", "1");+ List<String> remaining = glueService.getTableVersions("db1", "plain").stream()+ .map(version -> (String) version.get("VersionId")).toList();+ assertEquals(List.of("3", "2", "0"), remaining);++ AwsException current = assertThrows(AwsException.class,+ () -> glueService.deleteTableVersion("db1", "plain", "3"));+ assertEquals("InvalidInputException", current.getErrorCode());+ AwsException gone = assertThrows(AwsException.class,+ () -> glueService.deleteTableVersion("db1", "plain", "1"));+ assertEquals("EntityNotFoundException", gone.getErrorCode());+ AwsException blank = assertThrows(AwsException.class,+ () -> glueService.deleteTableVersion("db1", "plain", null));+ assertEquals("InvalidInputException", blank.getErrorCode());++ List<GlueService.TableVersionError> errors =+ glueService.batchDeleteTableVersions("db1", "plain", List.of("0", "9", "3", "2"));+ assertEquals(List.of("9", "3"), errors.stream().map(GlueService.TableVersionError::versionId).toList());+ assertEquals("EntityNotFoundException", errors.get(0).errorDetail().errorCode());+ assertEquals("InvalidInputException", errors.get(1).errorDetail().errorCode());+ assertEquals("plain", errors.get(0).tableName());+ assertEquals(1, glueService.getTableVersions("db1", "plain").size(), "only the current version is left");++ List<String> tooMany = java.util.stream.IntStream.rangeClosed(1, 101)+ .mapToObj(String::valueOf).toList();+ AwsException overCap = assertThrows(AwsException.class,+ () -> glueService.batchDeleteTableVersions("db1", "plain", tooMany));+ assertEquals("InvalidInputException", overCap.getErrorCode());+ }++ @Test+ void batchDeletePartitionDeletesWhatExistsAndReportsTheRest() {+ Table table = namedTable("events");+ table.setPartitionKeys(List.of(new Column("dt", "string")));+ glueService.createTable("db1", table);+ for (String dt : List.of("2026-01-01", "2026-01-02", "2026-01-03")) {+ Partition partition = new Partition();+ partition.setValues(List.of(dt));+ glueService.createPartition("db1", "events", partition);+ }++ List<GlueService.BatchCreatePartitionError> errors = glueService.batchDeletePartitions(+ "db1", "events", List.of(List.of("2026-01-01"), List.of("2026-01-09"), List.of("2026-01-03")));++ assertEquals(1, errors.size());+ assertEquals(List.of("2026-01-09"), errors.get(0).partitionValues());+ assertEquals("EntityNotFoundException", errors.get(0).errorDetail().errorCode());+ assertEquals(List.of(List.of("2026-01-02")),+ glueService.getPartitions("db1", "events").stream().map(Partition::getValues).toList());+ AwsException noTable = assertThrows(AwsException.class,+ () -> glueService.batchDeletePartitions("db1", "nope", List.of(List.of("x"))));+ assertEquals("EntityNotFoundException", noTable.getErrorCode());+ }++ @Test+ void searchTablesMatchesTextTokensAndTimesAcrossDatabases() {+ glueService.createDatabase(new Database("db2"));+ Table orders = namedTable("customer-orders");+ orders.setDescription("Orders placed by customers");+ orders.setOwner("sales");+ orders.setTableType("EXTERNAL_TABLE");+ StorageDescriptor sd = new StorageDescriptor();+ sd.setColumns(List.of(new Column("order_id", "string"), new Column("total", "double")));+ orders.setStorageDescriptor(sd);+ orders.setParameters(Map.of("classification", "parquet"));+ glueService.createTable("db1", orders);+ Table link = namedTable("xx-link-yy");+ link.setOwner("data");+ glueService.createTable("db2", link);+ Table nolink = namedTable("xxlinkyy");+ nolink.setOwner("data");+ glueService.createTable("db2", nolink);++ List<String> all = names(glueService.searchTables(null, null, null, null, null));+ assertEquals(List.of("customer-orders", "xx-link-yy", "xxlinkyy"), all, "database then name");++ assertEquals(List.of("customer-orders"), names(glueService.searchTables("ORDER_ID", null, null, null, null)),+ "column names take part in the text search");+ assertEquals(List.of("xx-link-yy", "xxlinkyy"), names(glueService.searchTables("link", null, null, null, null)));+ assertEquals(List.of("xx-link-yy"),+ names(glueService.searchTables("\"xx-link-yy\"", null, null, null, null)), "quotes mean exact");+ assertEquals(List.of(), names(glueService.searchTables("\"link\"", null, null, null, null)));++ // The reference's example: Key=Name, Value=link finds xx-link-yy but not xxlinkyy.+ assertEquals(List.of("xx-link-yy"), names(glueService.searchTables(null,+ List.of(new GlueService.SearchFilter("Name", "link", null)), null, null, null)));+ assertEquals(List.of("customer-orders"), names(glueService.searchTables(null,+ List.of(new GlueService.SearchFilter("DatabaseName", "db1", null),+ new GlueService.SearchFilter("classification", "parquet", null)), null, null, null)));+ assertEquals(List.of(), names(glueService.searchTables(null,+ List.of(new GlueService.SearchFilter("Owner", "sales", null),+ new GlueService.SearchFilter("TableType", "VIRTUAL_VIEW", null)), null, null, null)));++ long future = Instant.now().getEpochSecond() + 3600;+ assertEquals(3, glueService.searchTables(null,+ List.of(new GlueService.SearchFilter("CreateTime", String.valueOf(future), "LESS_THAN")),+ null, null, null).items().size());+ assertEquals(List.of(), names(glueService.searchTables(null,+ List.of(new GlueService.SearchFilter("CreateTime", String.valueOf(future), "GREATER_THAN")),+ null, null, null)));+ AwsException badComparator = assertThrows(AwsException.class, () -> glueService.searchTables(null,+ List.of(new GlueService.SearchFilter("CreateTime", "0", "BETWEEN")), null, null, null));+ assertEquals("InvalidInputException", badComparator.getErrorCode());++ assertEquals(List.of("xxlinkyy", "xx-link-yy", "customer-orders"), names(glueService.searchTables(null, null,+ List.of(new GlueService.SearchSort("Name", "DESC")), null, null)));+ AwsException badField = assertThrows(AwsException.class, () -> glueService.searchTables(null, null,+ List.of(new GlueService.SearchSort("Columns", "ASC")), null, null));+ assertEquals("InvalidInputException", badField.getErrorCode());++ GlueService.Page<Table> first = glueService.searchTables(null, null, null, 2, null);+ assertEquals(2, first.items().size());+ assertNotNull(first.nextToken());+ GlueService.Page<Table> second = glueService.searchTables(null, null, null, 2, first.nextToken());+ assertEquals(List.of("xxlinkyy"), names(second));+ assertNull(second.nextToken());+ }++ private static List<String> names(GlueService.Page<Table> page) {+ return page.items().stream().map(Table::getName).toList();+ }}