This is an automated email from the ASF dual-hosted git repository.
mchades pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/gravitino.git
The following commit(s) were added to refs/heads/main by this push:
new 85d643cafa [#14144] feat(client-java): Support Semantic Model metric
discovery (#14145)
85d643cafa is described below
commit 85d643cafa0ba9b4c27db5516a0f6d49f5cc4f2c
Author: mchades <[email protected]>
AuthorDate: Thu Oct 29 14:44:05 2026 +0800
[#14144] feat(client-java): Support Semantic Model metric discovery (#14145)
### What changes were proposed in this pull request?
Implement listMetrics and listMetricInfos in the Java client through the
schema-level REST endpoint. Return catalog-relative [schema,
semanticModel] namespaces while preserving complete metric definitions
and server ordering.
Add unit tests and real-server integration tests for both modes,
lifecycle changes, and containing-model visibility.
### Why are the changes needed?
Expose the server-side discovery added in #14143 through the Java
client, following #14038 under #14036.
Server-side support in #14143 is now merged into `main`. This PR
contains only the Java client implementation and tests.
Fixes #14144.
### Does this PR introduce _any_ user-facing change?
Java callers can discover metric identifiers or complete definitions
across a schema through catalog.asSemanticModelCatalog().
### How was this patch tested?
80 tests passed on the rebased branch: 19 client unit tests and 61
embedded-server integration tests, using H2 and a JDBC Iceberg catalog.
Ran `TestSemanticModelCatalog`, `SemanticModelIT`, and
`SemanticModelMetricAuthorizationIT` with `-PtestMode=embedded
-PjdbcBackend=h2 -PskipDockerTests=true -PskipWeb=true`.
Javadoc, Spotless, and git diff --check passed.
---
.../client/GenericSemanticModelMetric.java | 71 ++++++++
.../apache/gravitino/client/RelationalCatalog.java | 13 ++
.../client/SemanticModelCatalogOperations.java | 51 ++++++
.../client/TestGenericSemanticModelMetric.java | 108 ++++++++++++
.../gravitino/client/TestSemanticModelCatalog.java | 153 +++++++++++++++++
.../client/integration/test/SemanticModelIT.java | 128 +++++++++++++++
.../SemanticModelMetricAuthorizationIT.java | 181 +++++++++++++++++++++
7 files changed, 705 insertions(+)
diff --git
a/clients/client-java/src/main/java/org/apache/gravitino/client/GenericSemanticModelMetric.java
b/clients/client-java/src/main/java/org/apache/gravitino/client/GenericSemanticModelMetric.java
new file mode 100644
index 0000000000..2e37830802
--- /dev/null
+++
b/clients/client-java/src/main/java/org/apache/gravitino/client/GenericSemanticModelMetric.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.gravitino.client;
+
+import java.util.Objects;
+import javax.annotation.Nullable;
+import org.apache.gravitino.Namespace;
+import org.apache.gravitino.semantic.Metric;
+import org.apache.gravitino.semantic.SemanticModelMetric;
+
+/** A decoded metric with a catalog-relative namespace. */
+final class GenericSemanticModelMetric implements SemanticModelMetric {
+ private final Namespace namespace;
+ private final Metric metric;
+
+ GenericSemanticModelMetric(Namespace namespace, Metric metric) {
+ this.namespace = namespace;
+ this.metric = metric;
+ }
+
+ @Override
+ public Namespace namespace() {
+ return namespace;
+ }
+
+ @Override
+ public Metric metric() {
+ return metric;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public boolean equals(@Nullable Object other) {
+ if (this == other) {
+ return true;
+ }
+ if (!(other instanceof GenericSemanticModelMetric)) {
+ return false;
+ }
+ GenericSemanticModelMetric that = (GenericSemanticModelMetric) other;
+ return namespace.equals(that.namespace) && metric.equals(that.metric);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public int hashCode() {
+ return Objects.hash(namespace, metric);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public String toString() {
+ return "GenericSemanticModelMetric{" + "namespace=" + namespace + ",
metric=" + metric + '}';
+ }
+}
diff --git
a/clients/client-java/src/main/java/org/apache/gravitino/client/RelationalCatalog.java
b/clients/client-java/src/main/java/org/apache/gravitino/client/RelationalCatalog.java
index 57b6205710..c822f38950 100644
---
a/clients/client-java/src/main/java/org/apache/gravitino/client/RelationalCatalog.java
+++
b/clients/client-java/src/main/java/org/apache/gravitino/client/RelationalCatalog.java
@@ -79,6 +79,7 @@ import org.apache.gravitino.semantic.SemanticModel;
import org.apache.gravitino.semantic.SemanticModelCatalog;
import org.apache.gravitino.semantic.SemanticModelChange;
import org.apache.gravitino.semantic.SemanticModelDefinition;
+import org.apache.gravitino.semantic.SemanticModelMetric;
/**
* Relational catalog is a catalog implementation that supports relational
database like metadata
@@ -131,6 +132,18 @@ class RelationalCatalog extends BaseSchemaCatalog
return semanticModelOperations.listSemanticModels(namespace);
}
+ /** {@inheritDoc} */
+ @Override
+ public NameIdentifier[] listMetrics(Namespace namespace) {
+ return semanticModelOperations.listMetrics(namespace);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public SemanticModelMetric[] listMetricInfos(Namespace namespace) {
+ return semanticModelOperations.listMetricInfos(namespace);
+ }
+
/** {@inheritDoc} */
@Override
public SemanticModel loadSemanticModel(NameIdentifier ident) {
diff --git
a/clients/client-java/src/main/java/org/apache/gravitino/client/SemanticModelCatalogOperations.java
b/clients/client-java/src/main/java/org/apache/gravitino/client/SemanticModelCatalogOperations.java
index 54b9c51689..cef17d9743 100644
---
a/clients/client-java/src/main/java/org/apache/gravitino/client/SemanticModelCatalogOperations.java
+++
b/clients/client-java/src/main/java/org/apache/gravitino/client/SemanticModelCatalogOperations.java
@@ -34,6 +34,7 @@ import
org.apache.gravitino.dto.requests.SemanticModelUpdateRequest;
import org.apache.gravitino.dto.requests.SemanticModelUpdatesRequest;
import org.apache.gravitino.dto.responses.DropResponse;
import org.apache.gravitino.dto.responses.EntityListResponse;
+import org.apache.gravitino.dto.responses.MetricInfoListResponse;
import org.apache.gravitino.dto.responses.SemanticModelResponse;
import org.apache.gravitino.dto.semantic.SemanticModelDefinitionDTO;
import org.apache.gravitino.exceptions.IllegalSemanticModelException;
@@ -47,6 +48,7 @@ import org.apache.gravitino.semantic.SemanticModel;
import org.apache.gravitino.semantic.SemanticModelCatalog;
import org.apache.gravitino.semantic.SemanticModelChange;
import org.apache.gravitino.semantic.SemanticModelDefinition;
+import org.apache.gravitino.semantic.SemanticModelMetric;
import org.apache.hc.core5.http.HttpHeaders;
/** Implements schema-scoped Semantic Model operations through the Gravitino
REST API. */
@@ -85,6 +87,43 @@ class SemanticModelCatalogOperations implements
SemanticModelCatalog {
.toArray(NameIdentifier[]::new);
}
+ /** {@inheritDoc} */
+ @Override
+ public NameIdentifier[] listMetrics(Namespace namespace) throws
NoSuchSchemaException {
+ checkSemanticModelNamespace(namespace);
+ EntityListResponse response =
+ restClient.get(
+ formatMetricRequestPath(getSemanticModelFullNamespace(namespace)),
+ Collections.singletonMap("details", "false"),
+ EntityListResponse.class,
+ Collections.emptyMap(),
+ ErrorHandlers.semanticModelErrorHandler());
+ response.validate();
+ return Arrays.stream(response.identifiers())
+ .map(ident ->
NameIdentifier.of(relativeMetricNamespace(ident.namespace()), ident.name()))
+ .toArray(NameIdentifier[]::new);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public SemanticModelMetric[] listMetricInfos(Namespace namespace) throws
NoSuchSchemaException {
+ checkSemanticModelNamespace(namespace);
+ MetricInfoListResponse response =
+ restClient.get(
+ formatMetricRequestPath(getSemanticModelFullNamespace(namespace)),
+ Collections.singletonMap("details", "true"),
+ MetricInfoListResponse.class,
+ Collections.emptyMap(),
+ ErrorHandlers.semanticModelErrorHandler());
+ response.validate();
+ return Arrays.stream(response.getMetrics())
+ .map(
+ info ->
+ new GenericSemanticModelMetric(
+ relativeMetricNamespace(info.namespace()), info.metric()))
+ .toArray(SemanticModelMetric[]::new);
+ }
+
/** {@inheritDoc} */
@Override
public SemanticModel loadSemanticModel(NameIdentifier ident) throws
NoSuchSemanticModelException {
@@ -260,6 +299,18 @@ class SemanticModelCatalogOperations implements
SemanticModelCatalog {
return Namespace.of(catalogNamespace.level(0), catalogName,
semanticModelNamespace.level(0));
}
+ private static String formatMetricRequestPath(Namespace namespace) {
+ return BaseSchemaCatalog.formatSchemaRequestPath(
+ Namespace.of(namespace.level(0), namespace.level(1)))
+ + "/"
+ + RESTUtils.encodeString(namespace.level(2))
+ + "/semantic-model-metrics";
+ }
+
+ private static Namespace relativeMetricNamespace(Namespace namespace) {
+ return Namespace.of(namespace.level(2), namespace.level(3));
+ }
+
private static String ossieMediaType(OssieFormat format) {
return format == OssieFormat.JSON ? OSSIE_JSON_MEDIA_TYPE :
OSSIE_YAML_MEDIA_TYPE;
}
diff --git
a/clients/client-java/src/test/java/org/apache/gravitino/client/TestGenericSemanticModelMetric.java
b/clients/client-java/src/test/java/org/apache/gravitino/client/TestGenericSemanticModelMetric.java
new file mode 100644
index 0000000000..79e9d8c8ec
--- /dev/null
+++
b/clients/client-java/src/test/java/org/apache/gravitino/client/TestGenericSemanticModelMetric.java
@@ -0,0 +1,108 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.gravitino.client;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import org.apache.gravitino.Namespace;
+import org.apache.gravitino.semantic.DialectExpression;
+import org.apache.gravitino.semantic.Expression;
+import org.apache.gravitino.semantic.Metric;
+import org.apache.gravitino.semantic.SemanticModelMetric;
+import org.junit.jupiter.api.Test;
+
+class TestGenericSemanticModelMetric {
+
+ @Test
+ void testValueEqualityAndCollections() {
+ SemanticModelMetric first =
+ new GenericSemanticModelMetric(
+ Namespace.of("schema", "sales_model"),
metric("SUM(orders.amount)", "Total revenue"));
+ SemanticModelMetric second =
+ new GenericSemanticModelMetric(
+ Namespace.of("schema", "sales_model"),
metric("SUM(orders.amount)", "Total revenue"));
+
+ assertEquals(first, first);
+ assertEquals(first, second);
+ assertEquals(second, first);
+ assertEquals(first.hashCode(), second.hashCode());
+ assertNotEquals(first, null);
+ assertNotEquals(first, new Object());
+ assertTrue(List.of(first).contains(second));
+
+ Set<SemanticModelMetric> metrics = new HashSet<>();
+ assertTrue(metrics.add(first));
+ assertFalse(metrics.add(second));
+ assertEquals(1, metrics.size());
+ assertTrue(metrics.contains(second));
+ }
+
+ @Test
+ void testEqualityIncludesNamespaceAndCompleteDefinition() {
+ Namespace namespace = Namespace.of("schema", "sales_model");
+ Metric metric = metric("SUM(orders.amount)", "Total revenue");
+ SemanticModelMetric original = new GenericSemanticModelMetric(namespace,
metric);
+
+ assertNotEquals(
+ original, new GenericSemanticModelMetric(Namespace.of("schema",
"other_model"), metric));
+ assertNotEquals(
+ original,
+ new GenericSemanticModelMetric(namespace,
metric("COUNT(orders.amount)", "Total revenue")));
+ assertNotEquals(
+ original,
+ new GenericSemanticModelMetric(
+ namespace, metric("SUM(orders.amount)", "Updated description")));
+ }
+
+ @Test
+ void testToStringIncludesNamespaceAndMetricDefinition() {
+ SemanticModelMetric info =
+ new GenericSemanticModelMetric(
+ Namespace.of("schema", "sales_model"),
metric("SUM(orders.amount)", "Total revenue"));
+
+ String description = info.toString();
+ assertTrue(description.contains("namespace=schema.sales_model"));
+ assertTrue(description.contains("name='revenue'"));
+ assertTrue(description.contains("SUM(orders.amount)"));
+ assertTrue(description.contains("Total revenue"));
+ }
+
+ private static Metric metric(String expression, String description) {
+ return Metric.builder()
+ .withName("revenue")
+ .withExpression(
+ Expression.builder()
+ .withDialects(
+ new DialectExpression[] {
+ DialectExpression.builder()
+ .withDialect("ANSI_SQL")
+ .withExpression(expression)
+ .build()
+ })
+ .build())
+ .withDescription(description)
+ .build();
+ }
+}
diff --git
a/clients/client-java/src/test/java/org/apache/gravitino/client/TestSemanticModelCatalog.java
b/clients/client-java/src/test/java/org/apache/gravitino/client/TestSemanticModelCatalog.java
index d656398b22..7388589260 100644
---
a/clients/client-java/src/test/java/org/apache/gravitino/client/TestSemanticModelCatalog.java
+++
b/clients/client-java/src/test/java/org/apache/gravitino/client/TestSemanticModelCatalog.java
@@ -55,9 +55,12 @@ import
org.apache.gravitino.dto.requests.SemanticModelUpdatesRequest;
import org.apache.gravitino.dto.responses.DropResponse;
import org.apache.gravitino.dto.responses.EntityListResponse;
import org.apache.gravitino.dto.responses.ErrorResponse;
+import org.apache.gravitino.dto.responses.MetricInfoListResponse;
import org.apache.gravitino.dto.responses.SemanticModelResponse;
+import org.apache.gravitino.dto.semantic.MetricDTO;
import org.apache.gravitino.dto.semantic.SemanticModelDTO;
import org.apache.gravitino.dto.semantic.SemanticModelDefinitionDTO;
+import org.apache.gravitino.dto.semantic.SemanticModelMetricDTO;
import org.apache.gravitino.exceptions.AlreadyExistsException;
import org.apache.gravitino.exceptions.CatalogNotInUseException;
import org.apache.gravitino.exceptions.ConnectionFailedException;
@@ -91,10 +94,13 @@ import org.apache.gravitino.semantic.SemanticModel;
import org.apache.gravitino.semantic.SemanticModelCatalog;
import org.apache.gravitino.semantic.SemanticModelChange;
import org.apache.gravitino.semantic.SemanticModelDefinition;
+import org.apache.gravitino.semantic.SemanticModelMetric;
import org.apache.hc.core5.http.HttpHeaders;
import org.apache.hc.core5.http.Method;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
import org.mockserver.matchers.Times;
import org.mockserver.model.HttpRequest;
@@ -148,6 +154,143 @@ public class TestSemanticModelCatalog extends TestBase {
actual);
}
+ @ParameterizedTest
+ @ValueSource(booleans = {false, true})
+ void testMetricDiscoveryPreservesNamespacesDefinitionsAndOrder(boolean
details)
+ throws JsonProcessingException {
+ String schema = "schema /%? 收入";
+ String path = metricPath(schema);
+ Metric metric = definition().metrics()[0];
+ NameIdentifier[] fullIdentifiers = {
+ NameIdentifier.of(Namespace.of(METALAKE_NAME, CATALOG_NAME, schema,
"a"), metric.name()),
+ NameIdentifier.of(Namespace.of(METALAKE_NAME, CATALOG_NAME, schema,
"a-b"), metric.name())
+ };
+ SemanticModelMetricDTO[] infos =
+ Arrays.stream(fullIdentifiers)
+ .map(
+ ident ->
+ new SemanticModelMetricDTO(ident.namespace(),
MetricDTO.fromMetric(metric)))
+ .toArray(SemanticModelMetricDTO[]::new);
+ buildMockResource(
+ Method.GET,
+ path,
+ Map.of("details", String.valueOf(details)),
+ null,
+ details ? new MetricInfoListResponse(infos) : new
EntityListResponse(fullIdentifiers),
+ SC_OK);
+ int requestsBefore = mockServer.retrieveRecordedRequests(request()).length;
+ NameIdentifier[] expected = {
+ NameIdentifier.of(Namespace.of(schema, "a"), metric.name()),
+ NameIdentifier.of(Namespace.of(schema, "a-b"), metric.name())
+ };
+ if (details) {
+ SemanticModelMetric[] actual =
+
catalog.asSemanticModelCatalog().listMetricInfos(Namespace.of(schema));
+ assertEquals(expected.length, actual.length);
+ for (int i = 0; i < actual.length; i++) {
+ assertEquals(expected[i].namespace(), actual[i].namespace());
+ assertEquals(metric, actual[i].metric());
+ }
+ } else {
+ assertArrayEquals(
+ expected,
catalog.asSemanticModelCatalog().listMetrics(Namespace.of(schema)));
+ }
+ assertEquals(requestsBefore + 1,
mockServer.retrieveRecordedRequests(request()).length);
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {false, true})
+ void testMetricDiscoveryEmptyResults(boolean details) throws
JsonProcessingException {
+ buildMockResource(
+ Method.GET,
+ metricPath(SCHEMA_NAME),
+ Map.of("details", String.valueOf(details)),
+ null,
+ details
+ ? new MetricInfoListResponse(new SemanticModelMetricDTO[0])
+ : new EntityListResponse(new NameIdentifier[0]),
+ SC_OK);
+ if (details) {
+ assertArrayEquals(
+ new SemanticModelMetric[0],
+
catalog.asSemanticModelCatalog().listMetricInfos(Namespace.of(SCHEMA_NAME)));
+ } else {
+ assertArrayEquals(
+ new NameIdentifier[0],
+
catalog.asSemanticModelCatalog().listMetrics(Namespace.of(SCHEMA_NAME)));
+ }
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {false, true})
+ void testMetricDiscoveryRejectsInvalidNamespacesAndResponses(boolean details)
+ throws JsonProcessingException {
+ int requestsBefore = mockServer.retrieveRecordedRequests(request()).length;
+ for (Namespace namespace :
+ new Namespace[] {null, Namespace.empty(), Namespace.of(CATALOG_NAME,
SCHEMA_NAME)}) {
+ assertThrows(
+ IllegalArgumentException.class,
+ () -> {
+ if (details)
catalog.asSemanticModelCatalog().listMetricInfos(namespace);
+ else catalog.asSemanticModelCatalog().listMetrics(namespace);
+ });
+ }
+ assertEquals(requestsBefore,
mockServer.retrieveRecordedRequests(request()).length);
+ buildMockResource(
+ Method.GET,
+ metricPath(SCHEMA_NAME),
+ Map.of("details", String.valueOf(details)),
+ null,
+ Map.of("code", 0),
+ SC_OK);
+ assertThrows(
+ IllegalArgumentException.class,
+ () -> {
+ if (details)
catalog.asSemanticModelCatalog().listMetricInfos(Namespace.of(SCHEMA_NAME));
+ else
catalog.asSemanticModelCatalog().listMetrics(Namespace.of(SCHEMA_NAME));
+ });
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {false, true})
+ void testMetricDiscoveryErrorMappings(boolean details) throws
JsonProcessingException {
+ List<ErrorResponse> errors =
+ List.of(
+
ErrorResponse.notFound(NoSuchMetalakeException.class.getSimpleName(), "missing
lake"),
+
ErrorResponse.notFound(NoSuchCatalogException.class.getSimpleName(), "missing
catalog"),
+
ErrorResponse.notFound(NoSuchSchemaException.class.getSimpleName(), "missing
schema"),
+ ErrorResponse.forbidden("schema denied", null),
+ ErrorResponse.unsupportedOperation("unsupported catalog", null),
+ ErrorResponse.internalError("metric discovery failed"));
+ List<Class<? extends RuntimeException>> exceptionTypes =
+ List.of(
+ NoSuchMetalakeException.class,
+ NoSuchCatalogException.class,
+ NoSuchSchemaException.class,
+ ForbiddenException.class,
+ UnsupportedOperationException.class,
+ RuntimeException.class);
+ int[] statuses = {404, 404, 404, 403, 501, 500};
+ for (int i = 0; i < errors.size(); i++) {
+ buildMockResource(
+ Method.GET,
+ metricPath(SCHEMA_NAME),
+ Map.of("details", String.valueOf(details)),
+ null,
+ errors.get(i),
+ statuses[i]);
+ RuntimeException failure =
+ assertThrows(
+ exceptionTypes.get(i),
+ () -> {
+ if (details)
+
catalog.asSemanticModelCatalog().listMetricInfos(Namespace.of(SCHEMA_NAME));
+ else
catalog.asSemanticModelCatalog().listMetrics(Namespace.of(SCHEMA_NAME));
+ });
+ assertTrue(failure.getMessage().contains(errors.get(i).getMessage()));
+ }
+ }
+
@Test
public void testLoadSemanticModelPreservesNestedDefinition() throws
JsonProcessingException {
SemanticModelDTO semanticModelDTO = semanticModelDTO(MODEL_NAME);
@@ -533,6 +676,16 @@ public class TestSemanticModelCatalog extends TestBase {
Namespace.of(METALAKE_NAME, CATALOG_NAME, SCHEMA_NAME));
}
+ private static String metricPath(String schema) {
+ return "/api/metalakes/"
+ + METALAKE_NAME
+ + "/catalogs/"
+ + CATALOG_NAME
+ + "/schemas/"
+ + RESTUtils.encodeString(schema)
+ + "/semantic-model-metrics";
+ }
+
private static void buildOssieImportResource(
OssieDocument document, Object responseBody, int statusCode) throws
JsonProcessingException {
String mediaType =
diff --git
a/clients/client-java/src/test/java/org/apache/gravitino/client/integration/test/SemanticModelIT.java
b/clients/client-java/src/test/java/org/apache/gravitino/client/integration/test/SemanticModelIT.java
index e39bb0c428..a57eb253b7 100644
---
a/clients/client-java/src/test/java/org/apache/gravitino/client/integration/test/SemanticModelIT.java
+++
b/clients/client-java/src/test/java/org/apache/gravitino/client/integration/test/SemanticModelIT.java
@@ -88,6 +88,7 @@ import org.apache.gravitino.semantic.SemanticModel;
import org.apache.gravitino.semantic.SemanticModelCatalog;
import org.apache.gravitino.semantic.SemanticModelChange;
import org.apache.gravitino.semantic.SemanticModelDefinition;
+import org.apache.gravitino.semantic.SemanticModelMetric;
import org.apache.gravitino.tag.SupportsTags;
import org.apache.gravitino.tag.Tag;
import org.apache.gravitino.tag.TagValue;
@@ -270,6 +271,110 @@ public class SemanticModelIT extends BaseIT {
() -> semanticModelCatalog.loadSemanticModel(renamedIdent));
}
+ @Test
+ void testMetricDiscoveryPreservesCompleteMetricsAndStructuredOrdering() {
+ assertMetricDiscovery(new NameIdentifier[0]);
+ Metric revenue = initialDefinition().metrics()[0];
+ Metric upperCase =
+ Metric.builder()
+ .withName("Revenue")
+ .withExpression(expression(Dialects.ANSI_SQL,
"COUNT(orders.order_id)"))
+ .build();
+ semanticModelCatalog.createSemanticModel(
+ NameIdentifier.of(SCHEMA_NAME, "a-b"), null,
metricDefinition(revenue), Map.of());
+ semanticModelCatalog.createSemanticModel(
+ NameIdentifier.of(SCHEMA_NAME, "a"), null, metricDefinition(revenue,
upperCase), Map.of());
+ semanticModelCatalog.createSemanticModel(
+ NameIdentifier.of(SCHEMA_NAME, "absent"),
+ null,
+ metricDefinition((Metric[]) null),
+ Map.of());
+ semanticModelCatalog.createSemanticModel(
+ NameIdentifier.of(SCHEMA_NAME, "empty"), null, metricDefinition(),
Map.of());
+ assertMetricDiscovery(
+ new NameIdentifier[] {
+ NameIdentifier.of(SCHEMA_NAME, "a", "Revenue"),
+ NameIdentifier.of(SCHEMA_NAME, "a", "revenue"),
+ NameIdentifier.of(SCHEMA_NAME, "a-b", "revenue")
+ },
+ upperCase,
+ revenue,
+ revenue);
+ }
+
+ @Test
+ void testMetricDiscoveryTracksReplacementRenameAndRecreation() {
+ NameIdentifier model = NameIdentifier.of(SCHEMA_NAME, MODEL_NAME);
+ Metric original = initialDefinition().metrics()[0];
+ semanticModelCatalog.createSemanticModel(model, null,
metricDefinition(original), Map.of());
+ assertMetricDiscovery(
+ new NameIdentifier[] {NameIdentifier.of(SCHEMA_NAME, MODEL_NAME,
original.name())},
+ original);
+ Metric replacement =
+ Metric.builder()
+ .withName(original.name())
+ .withExpression(expression(Dialects.ANSI_SQL,
"COUNT(orders.order_id)"))
+ .withDescription("Updated calculation")
+ .build();
+ Metric added =
+
Metric.builder().withName("收入.total").withExpression(original.expression()).build();
+ semanticModelCatalog.alterSemanticModel(
+ model,
SemanticModelChange.replaceDefinition(metricDefinition(replacement, added)));
+ assertMetricDiscovery(
+ new NameIdentifier[] {
+ NameIdentifier.of(SCHEMA_NAME, MODEL_NAME, replacement.name()),
+ NameIdentifier.of(SCHEMA_NAME, MODEL_NAME, added.name())
+ },
+ replacement,
+ added);
+ semanticModelCatalog.alterSemanticModel(model,
SemanticModelChange.rename(RENAMED_MODEL_NAME));
+ NameIdentifier renamed = NameIdentifier.of(SCHEMA_NAME,
RENAMED_MODEL_NAME);
+ assertMetricDiscovery(
+ new NameIdentifier[] {
+ NameIdentifier.of(SCHEMA_NAME, RENAMED_MODEL_NAME,
replacement.name()),
+ NameIdentifier.of(SCHEMA_NAME, RENAMED_MODEL_NAME, added.name())
+ },
+ replacement,
+ added);
+ semanticModelCatalog.alterSemanticModel(
+ renamed,
SemanticModelChange.replaceDefinition(metricDefinition(added)));
+ assertMetricDiscovery(
+ new NameIdentifier[] {NameIdentifier.of(SCHEMA_NAME,
RENAMED_MODEL_NAME, added.name())},
+ added);
+ assertTrue(semanticModelCatalog.dropSemanticModel(renamed));
+ assertMetricDiscovery(new NameIdentifier[0]);
+ semanticModelCatalog.createSemanticModel(renamed, null,
metricDefinition(original), Map.of());
+ assertMetricDiscovery(
+ new NameIdentifier[] {NameIdentifier.of(SCHEMA_NAME,
RENAMED_MODEL_NAME, original.name())},
+ original);
+ }
+
+ @Test
+ void testMetricDiscoverySchemaIsolationAndMissingSchema() {
+ String otherSchema = "metric_discovery_other";
+ Namespace namespace = Namespace.of(otherSchema);
+ catalog.asSchemas().createSchema(otherSchema, null, Map.of());
+ try {
+ Metric metric = initialDefinition().metrics()[0];
+ semanticModelCatalog.createSemanticModel(
+ NameIdentifier.of(otherSchema, MODEL_NAME), null,
metricDefinition(metric), Map.of());
+ assertMetricDiscovery(new NameIdentifier[0]);
+ assertArrayEquals(
+ new NameIdentifier[] {NameIdentifier.of(otherSchema, MODEL_NAME,
metric.name())},
+ semanticModelCatalog.listMetrics(namespace));
+ SemanticModelMetric[] infos =
semanticModelCatalog.listMetricInfos(namespace);
+ assertEquals(1, infos.length);
+ assertEquals(Namespace.of(otherSchema, MODEL_NAME),
infos[0].namespace());
+ assertEquals(metric, infos[0].metric());
+ } finally {
+ semanticModelCatalog.dropSemanticModel(NameIdentifier.of(otherSchema,
MODEL_NAME));
+ catalog.asSchemas().dropSchema(otherSchema, false);
+ }
+ assertThrows(NoSuchSchemaException.class, () ->
semanticModelCatalog.listMetrics(namespace));
+ assertThrows(
+ NoSuchSchemaException.class, () ->
semanticModelCatalog.listMetricInfos(namespace));
+ }
+
@Test
public void testCreateSemanticModelRejectsInvalidSourceIdentifier() {
NameIdentifier ident = NameIdentifier.of(SCHEMA_NAME, INVALID_MODEL_NAME);
@@ -1236,6 +1341,29 @@ public class SemanticModelIT extends BaseIT {
primaryKey == null ? "" : " primary_key: [" + primaryKey +
"]\n"));
}
+ private void assertMetricDiscovery(NameIdentifier[] identifiers, Metric...
metrics) {
+ assertEquals(
+ identifiers.length,
+ metrics.length,
+ "Expected identifiers and metric definitions must have the same
length");
+ Namespace namespace = Namespace.of(SCHEMA_NAME);
+ assertArrayEquals(identifiers,
semanticModelCatalog.listMetrics(namespace));
+ SemanticModelMetric[] infos =
semanticModelCatalog.listMetricInfos(namespace);
+ assertEquals(metrics.length, infos.length);
+ for (int i = 0; i < infos.length; i++) {
+ assertEquals(
+ identifiers[i], NameIdentifier.of(infos[i].namespace(),
infos[i].metric().name()));
+ assertEquals(metrics[i], infos[i].metric());
+ }
+ }
+
+ private static SemanticModelDefinition metricDefinition(@Nullable Metric...
metrics) {
+ return SemanticModelDefinition.builder()
+ .withDatasets(initialDefinition().datasets())
+ .withMetrics(metrics)
+ .build();
+ }
+
private static SemanticModelDefinition initialDefinition() {
Map<String, Object> additionalProperties = new LinkedHashMap<>();
additionalProperties.put("confidence", new BigDecimal("0.95"));
diff --git
a/clients/client-java/src/test/java/org/apache/gravitino/client/integration/test/authorization/SemanticModelMetricAuthorizationIT.java
b/clients/client-java/src/test/java/org/apache/gravitino/client/integration/test/authorization/SemanticModelMetricAuthorizationIT.java
new file mode 100644
index 0000000000..cdccd8ce7e
--- /dev/null
+++
b/clients/client-java/src/test/java/org/apache/gravitino/client/integration/test/authorization/SemanticModelMetricAuthorizationIT.java
@@ -0,0 +1,181 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.gravitino.client.integration.test.authorization;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.apache.gravitino.Catalog;
+import org.apache.gravitino.MetadataObject;
+import org.apache.gravitino.MetadataObjects;
+import org.apache.gravitino.NameIdentifier;
+import org.apache.gravitino.Namespace;
+import org.apache.gravitino.authorization.Owner;
+import org.apache.gravitino.authorization.Privileges;
+import org.apache.gravitino.authorization.SecurableObjects;
+import org.apache.gravitino.client.GravitinoMetalake;
+import org.apache.gravitino.exceptions.ForbiddenException;
+import org.apache.gravitino.integration.test.util.GravitinoITUtils;
+import org.apache.gravitino.rel.Column;
+import org.apache.gravitino.rel.types.Types;
+import org.apache.gravitino.semantic.Dataset;
+import org.apache.gravitino.semantic.DialectExpression;
+import org.apache.gravitino.semantic.Expression;
+import org.apache.gravitino.semantic.Metric;
+import org.apache.gravitino.semantic.SemanticModelCatalog;
+import org.apache.gravitino.semantic.SemanticModelDefinition;
+import org.apache.gravitino.semantic.SemanticModelMetric;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+/** Exercises metric discovery with real schema and containing-model
authorization. */
+public class SemanticModelMetricAuthorizationIT extends
BaseRestApiAuthorizationIT {
+ private static final String CATALOG = "metric_discovery_catalog";
+ private static final String SCHEMA = "metric_discovery_schema";
+ private static final String ROLE = "metric_reader";
+ private static final Namespace NAMESPACE = Namespace.of(SCHEMA);
+
+ private GravitinoMetalake metalake;
+ private SemanticModelCatalog adminModels;
+ private SemanticModelCatalog readerModels;
+
+ /** Creates models and a reader with catalog access but no schema or model
privileges. */
+ @BeforeAll
+ public void setUpMetricDiscovery() {
+ metalake = client.loadMetalake(METALAKE);
+ String database = GravitinoITUtils.genRandomName("metric_authorization");
+ Catalog catalog =
+ metalake.createCatalog(
+ CATALOG,
+ Catalog.Type.RELATIONAL,
+ "lakehouse-iceberg",
+ null,
+ Map.of(
+ "catalog-backend", "jdbc",
+ "warehouse", System.getProperty("java.io.tmpdir") + "/" +
database,
+ "uri", "jdbc:h2:mem:" + database +
";DB_CLOSE_DELAY=-1;MODE=MYSQL",
+ "jdbc-driver", "org.h2.Driver",
+ "jdbc-initialize", "true"));
+ catalog.asSchemas().createSchema(SCHEMA, null, Map.of());
+ catalog
+ .asTableCatalog()
+ .createTable(
+ NameIdentifier.of(SCHEMA, "orders"),
+ new Column[] {Column.of("amount", Types.LongType.get())},
+ null,
+ Map.of());
+ adminModels = catalog.asSemanticModelCatalog();
+ SemanticModelDefinition definition =
+ SemanticModelDefinition.builder()
+ .withDatasets(
+ new Dataset[] {
+ Dataset.builder()
+ .withName("orders")
+ .withSource(NameIdentifier.of(CATALOG, SCHEMA, "orders"))
+ .build()
+ })
+ .withMetrics(new Metric[] {metric("count"), metric("revenue")})
+ .build();
+ for (String model : List.of("hidden", "modify", "owned", "use")) {
+ adminModels.createSemanticModel(NameIdentifier.of(SCHEMA, model), null,
definition, Map.of());
+ }
+ metalake.createRole(
+ ROLE,
+ Map.of(),
+ List.of(SecurableObjects.ofCatalog(CATALOG,
List.of(Privileges.UseCatalog.allow()))));
+ metalake.grantRolesToUser(List.of(ROLE), NORMAL_USER);
+ readerModels =
+
normalUserClient.loadMetalake(METALAKE).loadCatalog(CATALOG).asSemanticModelCatalog();
+ }
+
+ @Test
+ void testDiscoveryUsesSchemaAccessAndWholeModelVisibility() {
+ assertVisibleModels(adminModels, "hidden", "modify", "owned", "use");
+ assertSchemaDenied();
+ MetadataObject schema = MetadataObjects.of(CATALOG, SCHEMA,
MetadataObject.Type.SCHEMA);
+ metalake.grantPrivilegesToRole(ROLE, schema,
List.of(Privileges.UseSchema.allow()));
+ assertVisibleModels(readerModels);
+
+ metalake.grantPrivilegesToRole(
+ ROLE, modelObject("use"),
List.of(Privileges.UseSemanticModel.allow()));
+ metalake.grantPrivilegesToRole(
+ ROLE, modelObject("modify"),
List.of(Privileges.ModifySemanticModel.allow()));
+ metalake.setOwner(modelObject("owned"), NORMAL_USER, Owner.Type.USER);
+ assertVisibleModels(readerModels, "modify", "owned", "use");
+
+ metalake.revokePrivilegesFromRole(
+ ROLE, modelObject("use"), Set.of(Privileges.UseSemanticModel.allow()));
+ assertVisibleModels(readerModels, "modify", "owned");
+ metalake.revokePrivilegesFromRole(
+ ROLE, modelObject("modify"),
Set.of(Privileges.ModifySemanticModel.allow()));
+ assertVisibleModels(readerModels, "owned");
+ metalake.setOwner(modelObject("owned"), USER, Owner.Type.USER);
+ assertVisibleModels(readerModels);
+ metalake.revokePrivilegesFromRole(ROLE, schema,
Set.of(Privileges.UseSchema.allow()));
+ assertSchemaDenied();
+ }
+
+ private void assertSchemaDenied() {
+ assertThrows(ForbiddenException.class, () ->
readerModels.listMetrics(NAMESPACE));
+ assertThrows(ForbiddenException.class, () ->
readerModels.listMetricInfos(NAMESPACE));
+ }
+
+ private static void assertVisibleModels(SemanticModelCatalog catalog,
String... models) {
+ NameIdentifier[] expected =
+ Arrays.stream(models)
+ .flatMap(
+ model ->
+ Arrays.stream(new String[] {"count", "revenue"})
+ .map(name -> NameIdentifier.of(SCHEMA, model, name)))
+ .toArray(NameIdentifier[]::new);
+ assertArrayEquals(expected, catalog.listMetrics(NAMESPACE));
+ SemanticModelMetric[] infos = catalog.listMetricInfos(NAMESPACE);
+ assertEquals(expected.length, infos.length);
+ for (int i = 0; i < infos.length; i++) {
+ assertEquals(expected[i], NameIdentifier.of(infos[i].namespace(),
infos[i].metric().name()));
+ assertEquals(metric(expected[i].name()), infos[i].metric());
+ }
+ }
+
+ private static MetadataObject modelObject(String model) {
+ return MetadataObjects.of(List.of(CATALOG, SCHEMA, model),
MetadataObject.Type.SEMANTIC_MODEL);
+ }
+
+ private static Metric metric(String name) {
+ return Metric.builder()
+ .withName(name)
+ .withExpression(
+ Expression.builder()
+ .withDialects(
+ new DialectExpression[] {
+ DialectExpression.builder()
+ .withDialect("ANSI_SQL")
+ .withExpression(
+ "count".equals(name) ? "COUNT(orders.amount)" :
"SUM(orders.amount)")
+ .build()
+ })
+ .build())
+ .build();
+ }
+}