This is an automated email from the ASF dual-hosted git repository. dimas pushed a commit to branch dmitri-tmp1 in repository https://gitbox.apache.org/repos/asf/polaris.git
commit 18fd74edb3569f07d336f699ca0d8bdcde360151 Author: Michael Collado <[email protected]> AuthorDate: Tue Sep 23 15:27:11 2025 -0700 Add additional test for loadResolvedEntities by id --- .../polaris/core/entity/PolarisBaseEntity.java | 6 + .../AtomicOperationMetaStoreManager.java | 55 ++++++---- .../BasePolarisMetaStoreManagerTest.java | 10 +- .../persistence/PolarisTestMetaStoreManager.java | 122 ++++++++++++++++++++- 4 files changed, 162 insertions(+), 31 deletions(-) diff --git a/polaris-core/src/main/java/org/apache/polaris/core/entity/PolarisBaseEntity.java b/polaris-core/src/main/java/org/apache/polaris/core/entity/PolarisBaseEntity.java index 6c91517a1..80b0a9640 100644 --- a/polaris-core/src/main/java/org/apache/polaris/core/entity/PolarisBaseEntity.java +++ b/polaris-core/src/main/java/org/apache/polaris/core/entity/PolarisBaseEntity.java @@ -339,7 +339,10 @@ public class PolarisBaseEntity extends PolarisEntityCore { PolarisBaseEntity that = (PolarisBaseEntity) o; return subTypeCode == that.subTypeCode && createTimestamp == that.createTimestamp + && dropTimestamp == that.dropTimestamp + && purgeTimestamp == that.purgeTimestamp && toPurgeTimestamp == that.toPurgeTimestamp + && lastUpdateTimestamp == that.lastUpdateTimestamp && grantRecordsVersion == that.grantRecordsVersion && Objects.equals(properties, that.properties) && Objects.equals(internalProperties, that.internalProperties); @@ -356,7 +359,10 @@ public class PolarisBaseEntity extends PolarisEntityCore { entityVersion, subTypeCode, createTimestamp, + dropTimestamp, + purgeTimestamp, toPurgeTimestamp, + lastUpdateTimestamp, properties, internalProperties, grantRecordsVersion); diff --git a/polaris-core/src/main/java/org/apache/polaris/core/persistence/AtomicOperationMetaStoreManager.java b/polaris-core/src/main/java/org/apache/polaris/core/persistence/AtomicOperationMetaStoreManager.java index 7b156dad6..4f07a1358 100644 --- a/polaris-core/src/main/java/org/apache/polaris/core/persistence/AtomicOperationMetaStoreManager.java +++ b/polaris-core/src/main/java/org/apache/polaris/core/persistence/AtomicOperationMetaStoreManager.java @@ -1771,27 +1771,13 @@ public class AtomicOperationMetaStoreManager extends BaseMetaStoreManager { @Nonnull PolarisCallContext callCtx, @Nonnull List<EntityNameLookupRecord> entityLookupRecords) { BasePersistence ms = callCtx.getMetaStore(); - List<PolarisBaseEntity> entities = - ms.lookupEntities( - callCtx, - entityLookupRecords.stream() - .map(r -> new PolarisEntityId(r.getCatalogId(), r.getId())) - .collect(Collectors.toList())); - // mimic the behavior of loadEntity above, return null if not found or type mismatch - List<ResolvedPolarisEntity> ret = - IntStream.range(0, entityLookupRecords.size()) - .mapToObj( - i -> { - if (entities.get(i) != null - && !entities.get(i).getType().equals(entityLookupRecords.get(i).getType())) { - return null; - } else { - return entities.get(i); - } - }) - .map(e -> toResolvedPolarisEntity(callCtx, e, ms)) + List<PolarisEntityId> entityIds = + entityLookupRecords.stream() + .map(r -> new PolarisEntityId(r.getCatalogId(), r.getId())) .collect(Collectors.toList()); - return new ResolvedEntitiesResult(ret); + Function<Integer, PolarisEntityType> entityTypeForIndex = + i -> entityLookupRecords.get(i).getType(); + return getResolvedEntitiesResult(callCtx, ms, entityIds, entityTypeForIndex); } @Nonnull @@ -1801,20 +1787,43 @@ public class AtomicOperationMetaStoreManager extends BaseMetaStoreManager { @Nonnull PolarisEntityType entityType, @Nonnull List<PolarisEntityId> entityIds) { BasePersistence ms = callCtx.getMetaStore(); - List<PolarisBaseEntity> entities = ms.lookupEntities(callCtx, entityIds); + return getResolvedEntitiesResult(callCtx, ms, entityIds, i -> entityType); + } + private static ResolvedEntitiesResult getResolvedEntitiesResult( + PolarisCallContext callCtx, + BasePersistence ms, + List<PolarisEntityId> entityIds, + Function<Integer, PolarisEntityType> entityTypeForIndex) { + List<PolarisBaseEntity> entities = ms.lookupEntities(callCtx, entityIds); // mimic the behavior of loadEntity above, return null if not found or type mismatch List<ResolvedPolarisEntity> ret = IntStream.range(0, entityIds.size()) .mapToObj( i -> { - if (entities.get(i) != null && !entities.get(i).getType().equals(entityType)) { + if (entities.get(i) != null + && !entities.get(i).getType().equals(entityTypeForIndex.apply(i))) { return null; } else { return entities.get(i); } }) - .map(e -> toResolvedPolarisEntity(callCtx, e, ms)) + .map( + e -> { + if (e == null) { + return null; + } else { + // load the grant records + final List<PolarisGrantRecord> grantRecordsAsSecurable = + ms.loadAllGrantRecordsOnSecurable(callCtx, e.getCatalogId(), e.getId()); + final List<PolarisGrantRecord> grantRecordsAsGrantee = + e.getType().isGrantee() + ? ms.loadAllGrantRecordsOnGrantee(callCtx, e.getCatalogId(), e.getId()) + : List.of(); + return new ResolvedPolarisEntity( + PolarisEntity.of(e), grantRecordsAsGrantee, grantRecordsAsSecurable); + } + }) .collect(Collectors.toList()); return new ResolvedEntitiesResult(ret); } diff --git a/polaris-core/src/testFixtures/java/org/apache/polaris/core/persistence/BasePolarisMetaStoreManagerTest.java b/polaris-core/src/testFixtures/java/org/apache/polaris/core/persistence/BasePolarisMetaStoreManagerTest.java index c65f81a6e..0675e7bf1 100644 --- a/polaris-core/src/testFixtures/java/org/apache/polaris/core/persistence/BasePolarisMetaStoreManagerTest.java +++ b/polaris-core/src/testFixtures/java/org/apache/polaris/core/persistence/BasePolarisMetaStoreManagerTest.java @@ -240,8 +240,14 @@ public abstract class BasePolarisMetaStoreManagerTest { /** test batch entity load */ @Test - protected void testBatchLoad() { - polarisTestMetaStoreManager.testBatchLoad(); + protected void testLoadResolvedEntities() { + polarisTestMetaStoreManager.testLoadResolvedEntities(); + } + + /** test batch entity load */ + @Test + protected void testLoadResolvedEntitiesById() { + polarisTestMetaStoreManager.testLoadResolvedEntitiesById(); } /** Test the set of functions for the entity cache */ diff --git a/polaris-core/src/testFixtures/java/org/apache/polaris/core/persistence/PolarisTestMetaStoreManager.java b/polaris-core/src/testFixtures/java/org/apache/polaris/core/persistence/PolarisTestMetaStoreManager.java index ca6b4248c..6a073c136 100644 --- a/polaris-core/src/testFixtures/java/org/apache/polaris/core/persistence/PolarisTestMetaStoreManager.java +++ b/polaris-core/src/testFixtures/java/org/apache/polaris/core/persistence/PolarisTestMetaStoreManager.java @@ -23,6 +23,7 @@ import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Objects; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.commons.lang3.tuple.Pair; import org.apache.polaris.core.PolarisCallContext; @@ -2693,7 +2694,7 @@ public class PolarisTestMetaStoreManager { this.ensureNotExistsById(catalog.getId(), T1.getId(), PolarisEntityType.NAMESPACE); } - public void testBatchLoad() { + public void testLoadResolvedEntities() { // load all principals List<EntityNameLookupRecord> principals = polarisMetaStoreManager @@ -2756,8 +2757,9 @@ public class PolarisTestMetaStoreManager { InstanceOfAssertFactories.list(ResolvedPolarisEntity.class)) .hasSize(4) .allSatisfy(entity -> Assertions.assertThat(entity).isNotNull()) - .extracting(r -> (PolarisBaseEntity) r.getEntity()) - .containsExactly(catalog, N1, N1_N2, T1); + .extracting(r -> getEntityCore(r.getEntity())) + .containsExactly( + getEntityCore(catalog), getEntityCore(N1), getEntityCore(N1_N2), getEntityCore(T1)); ResolvedPolarisEntity catalogEntity = entitiesResult.getResolvedEntities().get(0); Assertions.assertThat(catalogEntity) @@ -2849,10 +2851,118 @@ public class PolarisTestMetaStoreManager { ResolvedEntitiesResult::getResolvedEntities, InstanceOfAssertFactories.list(ResolvedPolarisEntity.class)) .hasSize(6) - .filteredOn(e -> e != null) + .filteredOn(Objects::nonNull) .hasSize(2) - .extracting(r -> (PolarisBaseEntity) r.getEntity()) - .containsExactly(catalog, T1); + .extracting(r -> getEntityCore(r.getEntity())) + .containsExactly(getEntityCore(catalog), getEntityCore(T1)); + } + + public void testLoadResolvedEntitiesById() { + // load all principals + List<EntityNameLookupRecord> principals = + polarisMetaStoreManager + .listEntities( + this.polarisCallContext, + null, + PolarisEntityType.PRINCIPAL, + PolarisEntitySubType.NULL_SUBTYPE, + PageToken.readEverything()) + .getEntities(); + + // create new catalog + PolarisBaseEntity catalog = + new PolarisBaseEntity( + PolarisEntityConstants.getNullId(), + polarisMetaStoreManager.generateNewEntityId(this.polarisCallContext).getId(), + PolarisEntityType.CATALOG, + PolarisEntitySubType.NULL_SUBTYPE, + PolarisEntityConstants.getRootEntityId(), + "test"); + CreateCatalogResult catalogCreated = + polarisMetaStoreManager.createCatalog(this.polarisCallContext, catalog, List.of()); + Assertions.assertThat(catalogCreated).isNotNull(); + + // load the catalog again, since the grant versions are different + catalog = + polarisMetaStoreManager + .loadEntity( + polarisCallContext, + 0L, + catalogCreated.getCatalog().getId(), + PolarisEntityType.CATALOG) + .getEntity(); + + // now create all objects + PolarisBaseEntity N1 = this.createEntity(List.of(catalog), PolarisEntityType.NAMESPACE, "N1"); + PolarisBaseEntity N1_N2 = + this.createEntity(List.of(catalog, N1), PolarisEntityType.NAMESPACE, "N2"); + PolarisBaseEntity T1 = + this.createEntity( + List.of(catalog, N1, N1_N2), + PolarisEntityType.TABLE_LIKE, + PolarisEntitySubType.ICEBERG_TABLE, + "T1"); + + // batch load all entities. They should all be present and non-null + ResolvedEntitiesResult entitiesResult = + polarisMetaStoreManager.loadResolvedEntities( + polarisCallContext, + PolarisEntityType.NAMESPACE, + List.of( + new PolarisEntityId(N1.getCatalogId(), N1.getId()), + new PolarisEntityId(N1_N2.getCatalogId(), N1_N2.getId()))); + Assertions.assertThat(entitiesResult) + .isNotNull() + .returns(BaseResult.ReturnStatus.SUCCESS, ResolvedEntitiesResult::getReturnStatus) + .extracting( + ResolvedEntitiesResult::getResolvedEntities, + InstanceOfAssertFactories.list(ResolvedPolarisEntity.class)) + .hasSize(2) + .allSatisfy(entity -> Assertions.assertThat(entity).isNotNull()) + .extracting(r -> getEntityCore(r.getEntity())) + .containsExactly(getEntityCore(N1), getEntityCore(N1_N2)); + + // try entities which do not exist + entitiesResult = + polarisMetaStoreManager.loadResolvedEntities( + polarisCallContext, + PolarisEntityType.CATALOG, + List.of( + new PolarisEntityId(catalog.getId(), 27), + new PolarisEntityId(catalog.getId(), 35))); + Assertions.assertThat(entitiesResult) + .isNotNull() + .returns(BaseResult.ReturnStatus.SUCCESS, ResolvedEntitiesResult::getReturnStatus) + .extracting( + ResolvedEntitiesResult::getResolvedEntities, + InstanceOfAssertFactories.list(ResolvedPolarisEntity.class)) + .hasSize(2) + .allSatisfy(entity -> Assertions.assertThat(entity).isNull()); + + // existing entities, some with wrong type + entitiesResult = + polarisMetaStoreManager.loadResolvedEntities( + polarisCallContext, + PolarisEntityType.NAMESPACE, + List.of( + new PolarisEntityId(catalog.getCatalogId(), catalog.getId()), + new PolarisEntityId(catalog.getId(), N1_N2.getId()), + new PolarisEntityId(catalog.getId(), T1.getId()))); + Assertions.assertThat(entitiesResult) + .isNotNull() + .returns(BaseResult.ReturnStatus.SUCCESS, ResolvedEntitiesResult::getReturnStatus) + .extracting( + ResolvedEntitiesResult::getResolvedEntities, + InstanceOfAssertFactories.list(ResolvedPolarisEntity.class)) + .hasSize(3) + .filteredOn(Objects::nonNull) + .hasSize(1) + .extracting(r -> getEntityCore(r.getEntity())) + .containsExactly(getEntityCore(N1_N2)); + } + + private static PolarisEntityCore getEntityCore(PolarisBaseEntity entity) { + return new PolarisEntityCore.Builder<>(entity).build(); } /** Test the set of functions for the entity cache */
