This is an automated email from the ASF dual-hosted git repository. yuqi4733 pushed a commit to branch branch-lance-namespace-dev in repository https://gitbox.apache.org/repos/asf/gravitino.git
commit 7a239445fd73a5ddc581e5e552b44c184e6803cd Author: Jerry Shao <[email protected]> AuthorDate: Fri Nov 7 09:58:33 2025 +0800 [#9028] improve(core): Refactor the table and table entity to avoid introducing unnecessary interfaces (#9029) ### What changes were proposed in this pull request? Refactor the table and table entity to avoid introducing unnecessary interfaces ### Why are the changes needed? To make the generic lakehouse catalog more stable Fix: #9028 ### Does this PR introduce _any_ user-facing change? No. ### How was this patch tested? Exisiting UT and IT. --- .../main/java/org/apache/gravitino/rel/Table.java | 71 +++++++------ .../GenericLakehouseCatalogOperations.java | 22 ++-- .../lakehouse/lance/LanceCatalogOperations.java | 35 +++---- .../test/CatalogGenericLakehouseLanceIT.java | 2 - .../gravitino/catalog/EntityCombinedTable.java | 10 -- .../gravitino/connector/GenericLakehouseTable.java | 26 ++--- .../org/apache/gravitino/meta/TableEntity.java | 113 +++++++++++++-------- .../storage/relational/utils/POConverters.java | 53 +++++----- .../java/org/apache/gravitino/meta/TestEntity.java | 4 +- .../gravitino/storage/TestEntityStorage.java | 17 ++-- .../storage/relational/TestJDBCBackend.java | 2 +- .../storage/relational/utils/TestPOConverters.java | 6 +- .../gravitino/lance/common/config/LanceConfig.java | 6 +- mcp-server/tests/unit/tools/__init__.py | 3 + 14 files changed, 188 insertions(+), 182 deletions(-) diff --git a/api/src/main/java/org/apache/gravitino/rel/Table.java b/api/src/main/java/org/apache/gravitino/rel/Table.java index 316ba18839..d9b95c5210 100644 --- a/api/src/main/java/org/apache/gravitino/rel/Table.java +++ b/api/src/main/java/org/apache/gravitino/rel/Table.java @@ -44,6 +44,46 @@ import org.apache.gravitino.tag.SupportsTags; @Evolving public interface Table extends Auditable { + /** + * The property name for the table format. This property indicates the format of the table, such + * as "iceberg", "hudi", "lance", etc. generic lakehouse catalog will use this property to + * determine the table format and perform specific operations based on the format. For other + * relational catalogs, this property can be ignored. + * + * <p>This property is a must-have property for generic lakehouse catalog to create tables, and + * cannot be modified after table creation. + * + * <p>Current supported formats include: + * + * <ul> + * <li>lance + * </ul> + */ + String PROPERTY_TABLE_FORMAT = "format"; + + /** + * The property name to indicate whether the table is external. This property is a boolean value + * represented as a string ("true" or "false"). if true (the table is external), the drop + * operation will not delete the underlying data. + * + * <p>This property is optional and defaults to "false" if not specified. Also, it depends on the + * catalog implementation to decide whether to leverage and allow to alter this property. + */ + String PROPERTY_EXTERNAL = "external"; + + /** + * The property name for the table location. This property indicates the physical location of the + * table's data, such as a file path or a URI. + * + * <p>The location property is optional, it can be specified when creating the table. If not, the + * catalog implementation may use a location based on the catalog and schema location properties. + * + * <p>It depends on the catalog implementation to decide whether to leverage and allow to alter + * this property after table creation. And the behavior of altering this property (moving the + * table data) is also catalog specific. + */ + String PROPERTY_LOCATION = "location"; + /** * @return Name of the table. */ @@ -99,37 +139,6 @@ public interface Table extends Auditable { return Collections.emptyMap(); } - /** - * Table format of the table. For example, in a file-based table, it could be "parquet", "Lance", - * "Iceberg", etc. - * - * @return the table format name, for more information: LakehouseTableFormat - */ - default String format() { - throw new UnsupportedOperationException("Table format is not supported."); - } - - /** - * Gets the location of the table if the table has a location. For example, in a file-based table, - * it could be the root path where the table data is stored. - * - * @return the location of the table as a string. - */ - default String location() { - throw new UnsupportedOperationException("Table location is not supported."); - } - - /** - * Indicates whether the table is external. An external table is a table that is not managed by - * the catalog and the drop operation will not delete the underlying data. If it's a managed - * table, dropping the table will delete the underlying data. - * - * @return true if the table is external, false otherwise - */ - default boolean external() { - return false; - } - /** * Table method for working with partitions. If the table does not support partition operations, * an {@link UnsupportedOperationException} is thrown. diff --git a/catalogs/catalog-generic-lakehouse/src/main/java/org/apache/gravitino/catalog/lakehouse/GenericLakehouseCatalogOperations.java b/catalogs/catalog-generic-lakehouse/src/main/java/org/apache/gravitino/catalog/lakehouse/GenericLakehouseCatalogOperations.java index 3860b52d57..5603ab1f22 100644 --- a/catalogs/catalog-generic-lakehouse/src/main/java/org/apache/gravitino/catalog/lakehouse/GenericLakehouseCatalogOperations.java +++ b/catalogs/catalog-generic-lakehouse/src/main/java/org/apache/gravitino/catalog/lakehouse/GenericLakehouseCatalogOperations.java @@ -200,16 +200,16 @@ public class GenericLakehouseCatalogOperations try { TableEntity tableEntity = store.get(ident, Entity.EntityType.TABLE, TableEntity.class); return GenericLakehouseTable.builder() - .withFormat(tableEntity.getFormat()) - .withProperties(tableEntity.getProperties()) + .withFormat(tableEntity.format()) + .withProperties(tableEntity.properties()) .withAuditInfo(tableEntity.auditInfo()) - .withSortOrders(tableEntity.getSortOrder()) - .withPartitioning(tableEntity.getPartitions()) - .withDistribution(tableEntity.getDistribution()) + .withSortOrders(tableEntity.sortOrders()) + .withPartitioning(tableEntity.partitioning()) + .withDistribution(tableEntity.distribution()) .withColumns(EntityConverter.toColumns(tableEntity.columns())) - .withIndexes(tableEntity.getIndexes()) + .withIndexes(tableEntity.indexes()) .withName(tableEntity.name()) - .withComment(tableEntity.getComment()) + .withComment(tableEntity.comment()) .build(); } catch (NoSuchEntityException e) { throw new NoSuchTableException(e, "Table %s does not exist", ident); @@ -265,8 +265,8 @@ public class GenericLakehouseCatalogOperations .withFormat(format.lowerName()) .withProperties(newProperties) .withComment(comment) - .withPartitions(partitions) - .withSortOrder(sortOrders) + .withPartitioning(partitions) + .withSortOrders(sortOrders) .withDistribution(distribution) .withIndexes(indexes) .withId(idGenerator.nextId()) @@ -359,7 +359,7 @@ public class GenericLakehouseCatalogOperations throws NoSuchTableException, IllegalArgumentException { try { TableEntity tableEntity = store.get(ident, Entity.EntityType.TABLE, TableEntity.class); - Map<String, String> tableProperties = tableEntity.getProperties(); + Map<String, String> tableProperties = tableEntity.properties(); LakehouseCatalogOperations lakehouseCatalogOperations = getLakehouseCatalogOperations(tableProperties); return lakehouseCatalogOperations.alterTable(ident, changes); @@ -373,7 +373,7 @@ public class GenericLakehouseCatalogOperations try { TableEntity tableEntity = store.get(ident, Entity.EntityType.TABLE, TableEntity.class); LakehouseCatalogOperations lakehouseCatalogOperations = - getLakehouseCatalogOperations(tableEntity.getProperties()); + getLakehouseCatalogOperations(tableEntity.properties()); return lakehouseCatalogOperations.purgeTable(ident); } catch (NoSuchTableException e) { LOG.warn("Table {} does not exist, skip purging it.", ident); diff --git a/catalogs/catalog-generic-lakehouse/src/main/java/org/apache/gravitino/catalog/lakehouse/lance/LanceCatalogOperations.java b/catalogs/catalog-generic-lakehouse/src/main/java/org/apache/gravitino/catalog/lakehouse/lance/LanceCatalogOperations.java index 16bef5565f..8ec7909b2b 100644 --- a/catalogs/catalog-generic-lakehouse/src/main/java/org/apache/gravitino/catalog/lakehouse/lance/LanceCatalogOperations.java +++ b/catalogs/catalog-generic-lakehouse/src/main/java/org/apache/gravitino/catalog/lakehouse/lance/LanceCatalogOperations.java @@ -190,7 +190,7 @@ public class LanceCatalogOperations implements LakehouseCatalogOperations { .withId(tableEntity.id()) .withName(tableEntity.name()) .withNamespace(tableEntity.namespace()) - .withFormat(entity.getFormat()) + .withFormat(entity.format()) .withAuditInfo( AuditInfo.builder() .withCreator(tableEntity.auditInfo().creator()) @@ -200,13 +200,12 @@ public class LanceCatalogOperations implements LakehouseCatalogOperations { .build()) .withColumns(tableEntity.columns()) .withIndexes( - ArrayUtils.addAll( - entity.getIndexes(), addedIndexes.toArray(new Index[0]))) - .withDistribution(tableEntity.getDistribution()) - .withPartitions(tableEntity.getPartitions()) - .withSortOrder(tableEntity.getSortOrder()) - .withProperties(tableEntity.getProperties()) - .withComment(tableEntity.getComment()) + ArrayUtils.addAll(entity.indexes(), addedIndexes.toArray(new Index[0]))) + .withDistribution(tableEntity.distribution()) + .withPartitioning(tableEntity.partitioning()) + .withSortOrders(tableEntity.sortOrders()) + .withProperties(tableEntity.properties()) + .withComment(tableEntity.comment()) .build()); // Add indexes to Lance dataset @@ -214,16 +213,16 @@ public class LanceCatalogOperations implements LakehouseCatalogOperations { // return the updated table return GenericLakehouseTable.builder() - .withFormat(updatedEntity.getFormat()) - .withProperties(updatedEntity.getProperties()) + .withFormat(updatedEntity.format()) + .withProperties(updatedEntity.properties()) .withAuditInfo(updatedEntity.auditInfo()) - .withSortOrders(updatedEntity.getSortOrder()) - .withPartitioning(updatedEntity.getPartitions()) - .withDistribution(updatedEntity.getDistribution()) + .withSortOrders(updatedEntity.sortOrders()) + .withPartitioning(updatedEntity.partitioning()) + .withDistribution(updatedEntity.distribution()) .withColumns(EntityConverter.toColumns(updatedEntity.columns())) - .withIndexes(updatedEntity.getIndexes()) + .withIndexes(updatedEntity.indexes()) .withName(updatedEntity.name()) - .withComment(updatedEntity.getComment()) + .withComment(updatedEntity.comment()) .build(); } catch (NoSuchEntityException e) { throw new NoSuchTableException("No such table: %s", ident); @@ -234,9 +233,7 @@ public class LanceCatalogOperations implements LakehouseCatalogOperations { private void addLanceIndex(TableEntity updatedEntity, List<Index> addedIndexes) { String location = - updatedEntity - .getProperties() - .get(GenericLakehouseTablePropertiesMetadata.LAKEHOUSE_LOCATION); + updatedEntity.properties().get(GenericLakehouseTablePropertiesMetadata.LAKEHOUSE_LOCATION); try (Dataset dataset = Dataset.open(location, new RootAllocator())) { // For Lance, we only support adding indexes, so in fact, we can't handle drop index here. for (Index index : addedIndexes) { @@ -276,7 +273,7 @@ public class LanceCatalogOperations implements LakehouseCatalogOperations { public boolean purgeTable(NameIdentifier ident) { try { TableEntity tableEntity = store.get(ident, Entity.EntityType.TABLE, TableEntity.class); - Map<String, String> lancePropertiesMap = tableEntity.getProperties(); + Map<String, String> lancePropertiesMap = tableEntity.properties(); String location = lancePropertiesMap.get(GenericLakehouseTablePropertiesMetadata.LAKEHOUSE_LOCATION); diff --git a/catalogs/catalog-generic-lakehouse/src/test/java/org/apache/gravitino/catalog/lakehouse/integration/test/CatalogGenericLakehouseLanceIT.java b/catalogs/catalog-generic-lakehouse/src/test/java/org/apache/gravitino/catalog/lakehouse/integration/test/CatalogGenericLakehouseLanceIT.java index 1b4fd8b172..ca1e8ca003 100644 --- a/catalogs/catalog-generic-lakehouse/src/test/java/org/apache/gravitino/catalog/lakehouse/integration/test/CatalogGenericLakehouseLanceIT.java +++ b/catalogs/catalog-generic-lakehouse/src/test/java/org/apache/gravitino/catalog/lakehouse/integration/test/CatalogGenericLakehouseLanceIT.java @@ -53,7 +53,6 @@ import org.apache.gravitino.Catalog; import org.apache.gravitino.NameIdentifier; import org.apache.gravitino.Schema; import org.apache.gravitino.client.GravitinoMetalake; -import org.apache.gravitino.integration.test.container.ContainerSuite; import org.apache.gravitino.integration.test.util.BaseIT; import org.apache.gravitino.integration.test.util.GravitinoITUtils; import org.apache.gravitino.rel.Column; @@ -97,7 +96,6 @@ public class CatalogGenericLakehouseLanceIT extends BaseIT { public static final String LANCE_COL_NAME2 = "lance_col_name2"; public static final String LANCE_COL_NAME3 = "lance_col_name3"; protected final String provider = "generic-lakehouse"; - protected final ContainerSuite containerSuite = ContainerSuite.getInstance(); protected GravitinoMetalake metalake; protected Catalog catalog; protected String tempDirectory; diff --git a/core/src/main/java/org/apache/gravitino/catalog/EntityCombinedTable.java b/core/src/main/java/org/apache/gravitino/catalog/EntityCombinedTable.java index 7a0d90ead7..921b14dcdf 100644 --- a/core/src/main/java/org/apache/gravitino/catalog/EntityCombinedTable.java +++ b/core/src/main/java/org/apache/gravitino/catalog/EntityCombinedTable.java @@ -129,16 +129,6 @@ public final class EntityCombinedTable implements Table { return table.index(); } - @Override - public String format() { - return table.format(); - } - - @Override - public String location() { - return table.location(); - } - public boolean imported() { return imported; } diff --git a/core/src/main/java/org/apache/gravitino/connector/GenericLakehouseTable.java b/core/src/main/java/org/apache/gravitino/connector/GenericLakehouseTable.java index 7206125386..c408c49cc0 100644 --- a/core/src/main/java/org/apache/gravitino/connector/GenericLakehouseTable.java +++ b/core/src/main/java/org/apache/gravitino/connector/GenericLakehouseTable.java @@ -19,28 +19,15 @@ package org.apache.gravitino.connector; +import com.google.common.collect.ImmutableMap; +import org.apache.gravitino.rel.Table; + public class GenericLakehouseTable extends BaseTable { - private String format; public static Builder builder() { return new Builder(); } - @Override - public String format() { - return format; - } - - @Override - public String location() { - return properties.get("location"); - } - - @Override - public boolean external() { - return properties.get("external") != null && Boolean.parseBoolean(properties.get("external")); - } - @Override protected TableOperations newOps() throws UnsupportedOperationException { throw new UnsupportedOperationException("Not implemented yet"); @@ -58,10 +45,13 @@ public class GenericLakehouseTable extends BaseTable { @Override protected GenericLakehouseTable internalBuild() { GenericLakehouseTable genericLakehouseTable = new GenericLakehouseTable(); - genericLakehouseTable.format = this.format; genericLakehouseTable.columns = this.columns; genericLakehouseTable.comment = this.comment; - genericLakehouseTable.properties = this.properties; + genericLakehouseTable.properties = + ImmutableMap.<String, String>builder() + .putAll(this.properties) + .put(Table.PROPERTY_TABLE_FORMAT, this.format) + .buildKeepingLast(); genericLakehouseTable.auditInfo = this.auditInfo; genericLakehouseTable.distribution = this.distribution; genericLakehouseTable.indexes = this.indexes; diff --git a/core/src/main/java/org/apache/gravitino/meta/TableEntity.java b/core/src/main/java/org/apache/gravitino/meta/TableEntity.java index 795db870d9..638a1ab346 100644 --- a/core/src/main/java/org/apache/gravitino/meta/TableEntity.java +++ b/core/src/main/java/org/apache/gravitino/meta/TableEntity.java @@ -26,15 +26,19 @@ import java.util.List; import java.util.Map; import lombok.Getter; import lombok.ToString; +import lombok.experimental.Accessors; import org.apache.gravitino.Auditable; import org.apache.gravitino.Entity; import org.apache.gravitino.Field; import org.apache.gravitino.HasIdentifier; import org.apache.gravitino.Namespace; import org.apache.gravitino.rel.expressions.distributions.Distribution; +import org.apache.gravitino.rel.expressions.distributions.Distributions; import org.apache.gravitino.rel.expressions.sorts.SortOrder; import org.apache.gravitino.rel.expressions.transforms.Transform; +import org.apache.gravitino.rel.expressions.transforms.Transforms; import org.apache.gravitino.rel.indexes.Index; +import org.apache.gravitino.rel.indexes.Indexes; import org.apache.gravitino.utils.CollectionUtils; /** A class representing a table entity in Apache Gravitino. */ @@ -47,23 +51,17 @@ public class TableEntity implements Entity, Auditable, HasIdentifier { Field.required("audit_info", AuditInfo.class, "The audit details of the table"); public static final Field COLUMNS = Field.optional("columns", List.class, "The columns of the table"); - public static final Field FORMAT = Field.optional("format", String.class, "The table's format"); public static final Field PROPERTIES = Field.optional("properties", Map.class, "The table's properties"); - - public static final Field PARTITIONS = - Field.optional("partitions", Transform[].class, "The table's partition"); - - public static final Field SORT_ORDER = + public static final Field PARTITIONING = + Field.optional("partitioning", Transform[].class, "The table's partitioning"); + public static final Field SORT_ORDERS = Field.optional("sortOrders", SortOrder[].class, "The table's sort order"); - public static final Field DISTRIBUTION = Field.optional("distribution", Distribution.class, "The table's distribution"); - public static final Field INDEXES = Field.optional("indexes", Index[].class, "The table's indexes"); - public static final Field COMMENT = Field.optional("comment", String.class, "The table's comment"); @@ -77,13 +75,33 @@ public class TableEntity implements Entity, Auditable, HasIdentifier { private List<ColumnEntity> columns; - @Getter private String format; - @Getter private Map<String, String> properties; - @Getter private Transform[] partitions; - @Getter private SortOrder[] sortOrder; - @Getter private Distribution distribution; - @Getter private Index[] indexes; - @Getter private String comment; + @Getter + @Accessors(fluent = true) + private String format; + + @Getter + @Accessors(fluent = true) + private Map<String, String> properties; + + @Getter + @Accessors(fluent = true) + private Transform[] partitioning; + + @Getter + @Accessors(fluent = true) + private SortOrder[] sortOrders; + + @Getter + @Accessors(fluent = true) + private Distribution distribution; + + @Getter + @Accessors(fluent = true) + private Index[] indexes; + + @Getter + @Accessors(fluent = true) + private String comment; /** * Returns a map of the fields and their corresponding values for this table. @@ -97,11 +115,10 @@ public class TableEntity implements Entity, Auditable, HasIdentifier { fields.put(NAME, name); fields.put(AUDIT_INFO, auditInfo); fields.put(COLUMNS, columns); - fields.put(FORMAT, format); fields.put(PROPERTIES, properties); - fields.put(PARTITIONS, partitions); - fields.put(SORT_ORDER, sortOrder); + fields.put(PARTITIONING, partitioning); + fields.put(SORT_ORDERS, sortOrders); fields.put(DISTRIBUTION, distribution); fields.put(INDEXES, indexes); fields.put(COMMENT, comment); @@ -181,8 +198,8 @@ public class TableEntity implements Entity, Auditable, HasIdentifier { && Objects.equal(format, baseTable.format) // Please check the correctness of this comparison. && Objects.equal(properties, baseTable.properties) - && Arrays.equals(partitions, baseTable.partitions) - && Arrays.equals(sortOrder, baseTable.sortOrder) + && Arrays.equals(partitioning, baseTable.partitioning) + && Arrays.equals(sortOrders, baseTable.sortOrders) && Objects.equal(distribution, baseTable.distribution) && Arrays.equals(indexes, baseTable.indexes) && Objects.equal(comment, baseTable.comment); @@ -190,7 +207,20 @@ public class TableEntity implements Entity, Auditable, HasIdentifier { @Override public int hashCode() { - return Objects.hashCode(id, name, auditInfo, columns, namespace); + return Objects.hashCode( + id, + name, + auditInfo, + columns, + namespace, + format, + properties, + Arrays.hashCode(partitioning), + Arrays.hashCode(sortOrders), + distribution, + distribution, + Arrays.hashCode(indexes), + comment); } public static class Builder { @@ -236,13 +266,13 @@ public class TableEntity implements Entity, Auditable, HasIdentifier { return this; } - public Builder withPartitions(Transform[] partitions) { - tableEntity.partitions = partitions; + public Builder withPartitioning(Transform[] partitioning) { + tableEntity.partitioning = partitioning; return this; } - public Builder withSortOrder(SortOrder[] sortOrder) { - tableEntity.sortOrder = sortOrder; + public Builder withSortOrders(SortOrder[] sortOrders) { + tableEntity.sortOrders = sortOrders; return this; } @@ -264,25 +294,18 @@ public class TableEntity implements Entity, Auditable, HasIdentifier { public TableEntity build() { tableEntity.validate(); - if (tableEntity.columns == null) { - tableEntity.columns = Collections.emptyList(); - } - - if (tableEntity.properties == null) { - tableEntity.properties = Collections.emptyMap(); - } - - if (tableEntity.indexes == null) { - tableEntity.indexes = new Index[0]; - } - - if (tableEntity.partitions == null) { - tableEntity.partitions = new Transform[0]; - } - - if (tableEntity.sortOrder == null) { - tableEntity.sortOrder = new SortOrder[0]; - } + tableEntity.columns = + tableEntity.columns == null ? Collections.emptyList() : tableEntity.columns; + tableEntity.properties = + tableEntity.properties == null ? Collections.emptyMap() : tableEntity.properties; + tableEntity.indexes = + tableEntity.indexes == null ? Indexes.EMPTY_INDEXES : tableEntity.indexes; + tableEntity.partitioning = + tableEntity.partitioning == null ? Transforms.EMPTY_TRANSFORM : tableEntity.partitioning; + tableEntity.sortOrders = + tableEntity.sortOrders == null ? new SortOrder[0] : tableEntity.sortOrders; + tableEntity.distribution = + tableEntity.distribution == null ? Distributions.NONE : tableEntity.distribution; return tableEntity; } diff --git a/core/src/main/java/org/apache/gravitino/storage/relational/utils/POConverters.java b/core/src/main/java/org/apache/gravitino/storage/relational/utils/POConverters.java index 63f46f4e11..802ce6f810 100644 --- a/core/src/main/java/org/apache/gravitino/storage/relational/utils/POConverters.java +++ b/core/src/main/java/org/apache/gravitino/storage/relational/utils/POConverters.java @@ -401,33 +401,32 @@ public class POConverters { .withCurrentVersion(INIT_VERSION) .withLastVersion(INIT_VERSION) .withDeletedAt(DEFAULT_DELETED_AT) - .withFormat(tableEntity.getFormat()) - .withComment(tableEntity.getComment()) + .withFormat(tableEntity.format()) + .withComment(tableEntity.comment()) .withProperties( - tableEntity.getProperties() == null + tableEntity.properties() == null ? null - : JsonUtils.anyFieldMapper().writeValueAsString(tableEntity.getProperties())) + : JsonUtils.anyFieldMapper().writeValueAsString(tableEntity.properties())) .withIndexes( - tableEntity.getIndexes() == null + tableEntity.indexes() == null ? null : JsonUtils.anyFieldMapper() - .writeValueAsString(DTOConverters.toDTOs(tableEntity.getIndexes()))) + .writeValueAsString(DTOConverters.toDTOs(tableEntity.indexes()))) .withDistribution( - tableEntity.getDistribution() == null + tableEntity.distribution() == null ? null : JsonUtils.anyFieldMapper() - .writeValueAsString(DTOConverters.toDTO(tableEntity.getDistribution()))) + .writeValueAsString(DTOConverters.toDTO(tableEntity.distribution()))) .withSortOrders( - tableEntity.getSortOrder() == null + tableEntity.sortOrders() == null ? null : JsonUtils.anyFieldMapper() - .writeValueAsString(DTOConverters.toDTOs(tableEntity.getSortOrder()))) + .writeValueAsString(DTOConverters.toDTOs(tableEntity.sortOrders()))) .withPartitions( - tableEntity.getPartitions() == null + tableEntity.partitioning() == null ? null : JsonUtils.anyFieldMapper() - .writeValueAsString(DTOConverters.toDTOs(tableEntity.getPartitions()))); - // TODO support partitions later + .writeValueAsString(DTOConverters.toDTOs(tableEntity.partitioning()))); return builder.build(); } catch (JsonProcessingException e) { throw new RuntimeException("Failed to serialize json object:", e); @@ -461,33 +460,33 @@ public class POConverters { .withCurrentVersion(currentVersion) .withLastVersion(lastVersion) .withDeletedAt(DEFAULT_DELETED_AT) - .withComment(newTable.getComment()) + .withComment(newTable.comment()) .withProperties( - newTable.getProperties() == null + newTable.properties() == null ? null - : JsonUtils.anyFieldMapper().writeValueAsString(newTable.getProperties())) + : JsonUtils.anyFieldMapper().writeValueAsString(newTable.properties())) .withIndexes( - newTable.getIndexes() == null + newTable.indexes() == null ? null : JsonUtils.anyFieldMapper() - .writeValueAsString(DTOConverters.toDTOs(newTable.getIndexes()))) + .writeValueAsString(DTOConverters.toDTOs(newTable.indexes()))) .withDistribution( - newTable.getDistribution() == null + newTable.distribution() == null ? null : JsonUtils.anyFieldMapper() - .writeValueAsString(DTOConverters.toDTO(newTable.getDistribution()))) + .writeValueAsString(DTOConverters.toDTO(newTable.distribution()))) .withSortOrders( - newTable.getSortOrder() == null + newTable.sortOrders() == null ? null : JsonUtils.anyFieldMapper() - .writeValueAsString(DTOConverters.toDTOs(newTable.getSortOrder()))) + .writeValueAsString(DTOConverters.toDTOs(newTable.sortOrders()))) .withPartitions( - newTable.getPartitions() == null + newTable.partitioning() == null ? null : JsonUtils.anyFieldMapper() - .writeValueAsString(DTOConverters.toDTOs(newTable.getPartitions()))) + .writeValueAsString(DTOConverters.toDTOs(newTable.partitioning()))) // TODO support partitions later - .withFormat(newTable.getFormat()); + .withFormat(newTable.format()); return builder.build(); } catch (JsonProcessingException e) { @@ -522,7 +521,7 @@ public class POConverters { : DTOConverters.fromDTO( JsonUtils.anyFieldMapper() .readValue(tablePO.getDistribution(), DistributionDTO.class))) - .withSortOrder( + .withSortOrders( StringUtils.isBlank(tablePO.getSortOrders()) ? null : DTOConverters.fromDTOs( @@ -534,7 +533,7 @@ public class POConverters { : DTOConverters.fromDTOs( JsonUtils.anyFieldMapper().readValue(tablePO.getIndexes(), IndexDTO[].class))) // TODO add field partition, distribution and sort order; - .withPartitions( + .withPartitioning( StringUtils.isBlank(tablePO.getPartitions()) ? null : JsonUtils.anyFieldMapper() diff --git a/core/src/test/java/org/apache/gravitino/meta/TestEntity.java b/core/src/test/java/org/apache/gravitino/meta/TestEntity.java index 9ac22212be..b6653d11ab 100644 --- a/core/src/test/java/org/apache/gravitino/meta/TestEntity.java +++ b/core/src/test/java/org/apache/gravitino/meta/TestEntity.java @@ -175,7 +175,7 @@ public class TestEntity { .withName(tableName) .withAuditInfo(auditInfo) .withFormat(format) - .withSortOrder(sortOrders) + .withSortOrders(sortOrders) .withProperties(tableProperties) .withComment(comment) .withIndexes(indexes) @@ -189,7 +189,7 @@ public class TestEntity { Assertions.assertEquals(format, fields.get(TableEntity.FORMAT)); Assertions.assertEquals(tableProperties, fields.get(TableEntity.PROPERTIES)); Assertions.assertEquals(comment, fields.get(TableEntity.COMMENT)); - Assertions.assertEquals(sortOrders, fields.get(TableEntity.SORT_ORDER)); + Assertions.assertEquals(sortOrders, fields.get(TableEntity.SORT_ORDERS)); Assertions.assertEquals(indexes, fields.get(TableEntity.INDEXES)); Assertions.assertEquals(distribution, fields.get(TableEntity.DISTRIBUTION)); } diff --git a/core/src/test/java/org/apache/gravitino/storage/TestEntityStorage.java b/core/src/test/java/org/apache/gravitino/storage/TestEntityStorage.java index ad9cd173bc..89f276724c 100644 --- a/core/src/test/java/org/apache/gravitino/storage/TestEntityStorage.java +++ b/core/src/test/java/org/apache/gravitino/storage/TestEntityStorage.java @@ -2710,9 +2710,9 @@ public class TestEntityStorage { store.get(table.nameIdentifier(), Entity.EntityType.TABLE, TableEntity.class); // check table properties - Assertions.assertEquals("/tmp/test", fetchedTable.getProperties().get("location")); - Assertions.assertEquals("lance", fetchedTable.getProperties().get("format")); - Assertions.assertEquals("This is a lance table", fetchedTable.getComment()); + Assertions.assertEquals("/tmp/test", fetchedTable.properties().get("location")); + Assertions.assertEquals("lance", fetchedTable.properties().get("format")); + Assertions.assertEquals("This is a lance table", fetchedTable.comment()); Assertions.assertEquals(1, fetchedTable.columns().size()); Assertions.assertEquals("column1", fetchedTable.columns().get(0).name()); @@ -2753,9 +2753,9 @@ public class TestEntityStorage { // check updated table properties Assertions.assertEquals( - "/tmp/updated_test", fetchedUpdatedTable.getProperties().get("location")); - Assertions.assertEquals("lance", fetchedUpdatedTable.getProperties().get("format")); - Assertions.assertEquals("This is an updated lance table", fetchedUpdatedTable.getComment()); + "/tmp/updated_test", fetchedUpdatedTable.properties().get("location")); + Assertions.assertEquals("lance", fetchedUpdatedTable.properties().get("format")); + Assertions.assertEquals("This is an updated lance table", fetchedUpdatedTable.comment()); Assertions.assertEquals(2, fetchedUpdatedTable.columns().size()); for (ColumnEntity column : fetchedUpdatedTable.columns()) { if (column.name().equals("column1")) { @@ -2764,10 +2764,7 @@ public class TestEntityStorage { } Assertions.assertTrue( - fetchedUpdatedTable.columns().stream() - .filter(c -> c.name().equals("column2")) - .findFirst() - .isPresent()); + fetchedUpdatedTable.columns().stream().anyMatch(c -> c.name().equals("column2"))); // Test drop the table Assertions.assertTrue(store.delete(table.nameIdentifier(), Entity.EntityType.TABLE)); diff --git a/core/src/test/java/org/apache/gravitino/storage/relational/TestJDBCBackend.java b/core/src/test/java/org/apache/gravitino/storage/relational/TestJDBCBackend.java index b2916cfcaf..5cd67cc798 100644 --- a/core/src/test/java/org/apache/gravitino/storage/relational/TestJDBCBackend.java +++ b/core/src/test/java/org/apache/gravitino/storage/relational/TestJDBCBackend.java @@ -1253,7 +1253,7 @@ public class TestJDBCBackend { backend.insert(table, false); TableEntity fetchedTable = backend.get(table.nameIdentifier(), Entity.EntityType.TABLE); - Assertions.assertEquals("LANCE", fetchedTable.getProperties().get("format")); + Assertions.assertEquals("LANCE", fetchedTable.properties().get("format")); TableEntity updatedTable = TableEntity.builder() diff --git a/core/src/test/java/org/apache/gravitino/storage/relational/utils/TestPOConverters.java b/core/src/test/java/org/apache/gravitino/storage/relational/utils/TestPOConverters.java index eea8837baf..2582b459c6 100644 --- a/core/src/test/java/org/apache/gravitino/storage/relational/utils/TestPOConverters.java +++ b/core/src/test/java/org/apache/gravitino/storage/relational/utils/TestPOConverters.java @@ -629,8 +629,8 @@ public class TestPOConverters { Lists.newArrayList(), NamespaceUtil.ofTable("test_metalake", "test_catalog", "test_schema")); - Assertions.assertEquals(tableEntity.getDistribution(), entity.getDistribution()); - Assertions.assertArrayEquals(tableEntity.getPartitions(), entity.getPartitions()); + Assertions.assertEquals(tableEntity.distribution(), entity.distribution()); + Assertions.assertArrayEquals(tableEntity.partitioning(), entity.partitioning()); } @Test @@ -1398,7 +1398,7 @@ public class TestPOConverters { .withNamespace(namespace) .withColumns(columns) .withDistribution(Distributions.of(Strategy.EVEN, 10, NamedReference.field("key"))) - .withSortOrder( + .withSortOrders( new SortOrder[] {SortOrders.of(NamedReference.field("col1"), SortDirection.ASCENDING)}) .withAuditInfo(auditInfo) .build(); diff --git a/lance/lance-common/src/main/java/org/apache/gravitino/lance/common/config/LanceConfig.java b/lance/lance-common/src/main/java/org/apache/gravitino/lance/common/config/LanceConfig.java index f4556e43e4..28fb09fb1f 100644 --- a/lance/lance-common/src/main/java/org/apache/gravitino/lance/common/config/LanceConfig.java +++ b/lance/lance-common/src/main/java/org/apache/gravitino/lance/common/config/LanceConfig.java @@ -42,21 +42,21 @@ public class LanceConfig extends Config implements OverwriteDefaultConfig { public static final ConfigEntry<String> NAMESPACE_BACKEND = new ConfigBuilder(CONFIG_NAMESPACE_BACKEND) .doc("The backend implementation for namespace operations") - .version(ConfigConstants.VERSION_0_1_0) + .version(ConfigConstants.VERSION_1_1_0) .stringConf() .createWithDefault(GRAVITINO_NAMESPACE_BACKEND); public static final ConfigEntry<String> METALAKE_NAME = new ConfigBuilder(GRAVITINO_NAMESPACE_BACKEND + "." + CONFIG_METALAKE) .doc("The Metalake name for Lance Gravitino namespace backend") - .version(ConfigConstants.VERSION_0_1_0) + .version(ConfigConstants.VERSION_1_1_0) .stringConf() .create(); public static final ConfigEntry<String> NAMESPACE_BACKEND_URI = new ConfigBuilder(GRAVITINO_NAMESPACE_BACKEND + "." + CONFIG_URI) .doc("The URI of the namespace backend, e.g., Gravitino server URI") - .version(ConfigConstants.VERSION_0_1_0) + .version(ConfigConstants.VERSION_1_1_0) .stringConf() .createWithDefault(GRAVITINO_URI); diff --git a/mcp-server/tests/unit/tools/__init__.py b/mcp-server/tests/unit/tools/__init__.py index 50752ad81a..4456ffb949 100644 --- a/mcp-server/tests/unit/tools/__init__.py +++ b/mcp-server/tests/unit/tools/__init__.py @@ -14,6 +14,7 @@ # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. +import logging from tests.unit.tools.mock_operation import ( MockCatalogOperation, @@ -21,3 +22,5 @@ from tests.unit.tools.mock_operation import ( MockSchemaOperation, MockTableOperation, ) + +logging.disable(logging.INFO)
