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();
+  }
+}

Reply via email to