jerryshao commented on code in PR #10874:
URL: https://github.com/apache/gravitino/pull/10874#discussion_r3166982315
##########
core/src/main/java/org/apache/gravitino/storage/relational/service/SchemaMetaService.java:
##########
@@ -495,16 +515,98 @@ public List<SchemaEntity>
batchGetSchemaByIdentifier(List<NameIdentifier> identi
NameIdentifier firstIdent = identifiers.get(0);
NameIdentifier catalogIdent =
NameIdentifierUtil.getCatalogIdentifier(firstIdent);
- List<String> schemaNames =
-
identifiers.stream().map(NameIdentifier::name).collect(Collectors.toList());
+ // Convert logical schema names to physical for DB batch query.
+ List<String> physicalSchemaNames =
+ identifiers.stream()
+ .map(id -> toPhysicalSchemaName(id.name()))
+ .collect(Collectors.toList());
return SessionUtils.doWithCommitAndFetchResult(
SchemaMetaMapper.class,
mapper -> {
List<SchemaPO> schemaPOs =
mapper.batchSelectSchemaByIdentifier(
- catalogIdent.namespace().level(0), catalogIdent.name(),
schemaNames);
- return POConverters.fromSchemaPOs(schemaPOs, firstIdent.namespace());
+ catalogIdent.namespace().level(0), catalogIdent.name(),
physicalSchemaNames);
+ // Convert physical PO names back to logical for callers.
+ return POConverters.fromSchemaPOs(schemaPOs,
firstIdent.namespace()).stream()
+ .map(this::toLogicalEntity)
+ .collect(Collectors.toList());
});
}
+
+ //
---------------------------------------------------------------------------
+ // Helpers: logical ↔ physical schema name conversion at the PO boundary
+ //
---------------------------------------------------------------------------
+
+ /**
+ * Converts a logical schema name (e.g. {@code "A:B:C"}) to the physical
internal form (e.g.
+ * {@code "A\u0001B\u0001C"}) used in the database. Non-HierarchicalSchema
names are returned
+ * unchanged.
+ */
+ private String toPhysicalSchemaName(String logicalName) {
+ return HierarchicalSchemaUtil.logicalToPhysical(
+ logicalName, HierarchicalSchemaUtil.schemaSeparator());
+ }
+
+ /**
+ * Converts a physical schema name (e.g. {@code "A\u0001B\u0001C"}) back to
the logical separator
+ * form (e.g. {@code "A:B:C"}). Non-HierarchicalSchema names are returned
unchanged.
+ */
+ private String toLogicalSchemaName(String physicalName) {
+ return HierarchicalSchemaUtil.physicalToLogical(
+ physicalName, HierarchicalSchemaUtil.schemaSeparator());
+ }
+
+ /**
+ * Builds a new {@link NameIdentifier} with the physical schema name while
keeping the original
+ * namespace unchanged.
+ */
+ private NameIdentifier toPhysicalIdentifier(NameIdentifier identifier) {
+ String physicalName = toPhysicalSchemaName(identifier.name());
+ if (physicalName.equals(identifier.name())) {
+ return identifier;
+ }
+ return NameIdentifier.of(identifier.namespace(), physicalName);
+ }
+
+ /**
+ * Returns a {@link SchemaEntity} whose {@code name()} is the logical
representation. If the PO
+ * stored a physical name (contains the internal physical separator), it is
converted back to the
+ * logical separator form. Otherwise the original entity is returned
unchanged.
+ */
+ private SchemaEntity toLogicalEntity(SchemaEntity entity) {
+ String logicalName = toLogicalSchemaName(entity.name());
+ if (logicalName.equals(entity.name())) {
+ return entity;
+ }
+ return SchemaEntity.builder()
+ .withId(entity.id())
+ .withName(logicalName)
+ .withNamespace(entity.namespace())
+ .withComment(entity.comment())
+ .withProperties(entity.properties())
+ .withAuditInfo(entity.auditInfo())
+ .build();
+ }
+
+ /**
+ * Returns a {@link SchemaEntity} whose {@code name()} is the physical
representation suitable for
+ * storage. If the entity carries a logical name (contains the separator),
it is converted to the
+ * physical internal form. Otherwise the original entity is returned
unchanged.
+ */
+ private SchemaEntity toPhysicalEntity(SchemaEntity entity) {
+ String separator = HierarchicalSchemaUtil.schemaSeparator();
+ if (!HierarchicalSchemaUtil.isHierarchical(entity.name(), separator)) {
+ return entity;
+ }
+ String physicalName = toPhysicalSchemaName(entity.name());
+ return SchemaEntity.builder()
+ .withId(entity.id())
+ .withName(physicalName)
+ .withNamespace(entity.namespace())
+ .withComment(entity.comment())
+ .withProperties(entity.properties())
+ .withAuditInfo(entity.auditInfo())
+ .build();
+ }
}
Review Comment:
I think it is better to do the conversion in the interface level, like
entity store to make here transparent.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
