[SPARK-56678][SQL] Use structured Catalog/Namespace/Table rows in DESCRIBE TABLE EXTENDED for v2 tables and views

cloud-fan · cloud-fan · commit 3a685b1a16e1 · 2026-05-02T01:31:43.000+08:00
### What changes were proposed in this pull request? Standardize the `# Detailed Table Information` / `# Detailed View Information` block in `DESCRIBE TABLE EXTENDED` output for v2 tables and views to emit structured rows derived from the resolved identifier: - For tables (`DescribeTableExec`): the single `Name` row that came from `Table.name()` is replaced by `Catalog`, `Namespace`, `Database`, and `Table`. - For views (`DescribeV2ViewExec`): the `Catalog` + `Identifier` pair (where `Identifier` was a single string concatenating namespace and name with `.`) is replaced by `Catalog`, `Namespace`, `Database`, and `View`. The catalog name and resolved `Identifier` are threaded from `ResolvedTable` / `ResolvedPersistentView` through the v2 execs. `DescribeTablePartitionExec` is updated to pass the catalog name to the inner `DescribeTableExec` it constructs for the schema/partition header. The `Namespace` row uses `Identifier.namespace().quoted` — dot-separated, with back-tick quoting only on segments that need it — matching the existing Spark convention for multi-segment namespaces. This keeps the row round-trip-safe for namespaces with dots in segments while staying readable for the common single-level case. #### `Database` row for v1 compatibility v1 `DescribeTableCommand` (via `CatalogTable.toJsonLinkedHashMap`) emits `Catalog` / `Database` / `Table` rows, where `Database` is the single-string `database` field of `TableIdentifier`. To keep DESCRIBE consumers that read the `Database` row working uniformly across v1 (HMS) and v2, this PR also emits a `Database` row in the v2 output. The row is **always present**: - For a single-segment namespace, `Database` is that single segment (matches v1 exactly). - For a multi-segment namespace, `Database` is the trailing segment — multi-segment namespaces still surface their leaf segment under the v1-compat row, while consumers that need the full namespace read `Namespace`. - For a root-level entity (empty namespace), `Database` is the empty string. The row is still emitted so the layout is uniform across all v2 namespaces. `Database` alone is not round-trip-safe for multi-segment cases; `Namespace` is the canonical v2 representation. ### Why are the changes needed? In a multi-catalog deployment, the catalog name is a first-class part of a v2 table or view identifier. The previous output buried it inside connector-controlled strings: - `Table.name()` for tables is connector-defined; some connectors return `catalog.namespace.name`, others just `namespace.name`, others use a custom format. The result is that `DESCRIBE TABLE` output looks different across catalogs even for the same logical table shape. - `Identifier` for v2 views collapsed namespace and name into a single dotted string, so consumers had to parse the dot back out and could not unambiguously round-trip multi-level namespaces with dots in segments. Splitting the components into `Catalog`, `Namespace`, `Database`, and `Table` / `View` rows: - gives `DESCRIBE TABLE EXTENDED` a uniform shape across v2 connectors, - makes the catalog name explicit and surfaceable when multiple v2 catalogs are configured, - handles multi-level namespaces naturally via `Identifier.namespace().quoted`, - aligns the table and view sections so consumers can read the same rows from either, switching only on the section header (`# Detailed Table Information` vs `# Detailed View Information`), - with the always-emitted `Database` compatibility row, lets consumers built for v1 (HMS) keep working without changes, - is parseable programmatically without splitting strings. ### Does this PR introduce any user-facing change? Yes, slight output change in `DESCRIBE TABLE EXTENDED` for v2 tables and v2 views. For v2 tables, single-segment namespace (most common): - Before: `Name | testcat.ns.t | ` - After: `Catalog | testcat | `, `Namespace | ns | `, `Database | ns | `, `Table | t | `. For v2 tables, multi-segment namespace: - Before: `Name | testcat.ns1.ns2.t | ` - After: `Catalog | testcat | `, `Namespace | ns1.ns2 | `, `Database | ns2 | `, `Table | t | `. For v2 views, single-segment namespace: - Before: `Catalog | testcat | `, `Identifier | ns.v | ` - After: `Catalog | testcat | `, `Namespace | ns | `, `Database | ns | `, `View | v | `. For v2 views, multi-segment namespace: - Before: `Catalog | testcat | `, `Identifier | ns1.ns2.v | ` - After: `Catalog | testcat | `, `Namespace | ns1.ns2 | `, `Database | ns2 | `, `View | v | `. v1 paths (session-catalog tables and views via HMS) are unchanged. Tools that read DESCRIBE output should switch from concatenating `Name` / `Identifier` to reading the structured rows. ### How was this patch tested? - Updated the affected golden assertion in `DescribeTableSuite` (`DESCRIBE TABLE EXTENDED of a partitioned table`) to match the new row layout including the `Database` compatibility row. - Added focused tests in v2 `DescribeTableSuite` pinning the structured rows on a freshly created v2 table for both single-segment (`ns`) and multi-segment (`ns1.ns2`) namespaces — the multi-segment test pins that `Database` carries the trailing segment while `Namespace` carries the full dot-joined form. - Added parallel tests in v2 `DescribeViewSuite` pinning the same layout for v2 views (single-segment and multi-segment). - Removed the now-redundant `DESCRIBE TABLE EXTENDED on a non-view MetadataTable shows the real identifier` test in `DataSourceV2MetadataTableSuite` (the structured-row layout is what's pinned by the new tests in `v2.DescribeTableSuite`; the identifier-passthrough behavior is no longer tied to `MetadataTable.name()`). Ran: build/sbt 'sql/testOnly \ org.apache.spark.sql.execution.command.v2.DescribeTableSuite \ org.apache.spark.sql.execution.command.v2.DescribeViewSuite \ org.apache.spark.sql.connector.DataSourceV2MetadataTableSuite \ org.apache.spark.sql.connector.DataSourceV2MetadataViewSuite' ### Was this patch authored or co-authored using generative AI tooling? Generated-by: Claude Opus 4.7 Closes #55625 from cloud-fan/describe-table-view-structured-rows. Authored-by: Wenchen Fan <wenchen@databricks.com> Signed-off-by: Wenchen Fan <wenchen@databricks.com>
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/catalog/MetadataTable.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/catalog/MetadataTable.java
@@ -50,9 +50,12 @@ public class MetadataTable implements Table {
 
   /**
    * @param info metadata for the table or view. Pass a {@link ViewInfo} for a view.
-   * @param name human-readable name for this table, used by places that read {@link #name()}
-   *             (e.g. the {@code Name} row of {@code DESCRIBE TABLE EXTENDED}). Catalogs
-   *             returning a {@code MetadataTable} from {@link TableCatalog#loadTable} or
+   * @param name human-readable name for this table, returned by {@link #name()} and surfaced
+   *             in places that read it (e.g. {@code BatchScan} plan-tree labels and
+   *             partition-management error messages). {@code DESCRIBE TABLE EXTENDED} does
+   *             not read this field; it emits the resolved identifier as structured
+   *             {@code Catalog} / {@code Namespace} / {@code Table} rows. Catalogs returning
+   *             a {@code MetadataTable} from {@link TableCatalog#loadTable} or
    *             {@link TableViewCatalog#loadTableOrView} should typically pass
    *             {@code ident.toString()}, matching the quoted multi-part form used elsewhere
    *             for v2 identifiers.
diff --git a/sql/core/src/main/scala/org/apache/spark/sql/execution/datasources/v2/DataSourceV2Strategy.scala b/sql/core/src/main/scala/org/apache/spark/sql/execution/datasources/v2/DataSourceV2Strategy.scala
@@ -547,7 +547,7 @@ class DataSourceV2Strategy(session: SparkSession) extends Strategy with Predicat
       DescribeNamespaceExec(output, catalog.asNamespaceCatalog, ns, extended) :: Nil
 
     case DescribeRelation(r: ResolvedTable, isExtended, output) =>
-      DescribeTableExec(output, r.table, isExtended) :: Nil
+      DescribeTableExec(output, r.catalog.name(), r.identifier, r.table, isExtended) :: Nil
 
     case DescribeTablePartition(r: ResolvedTable, part, isExtended, output) =>
       DescribeTablePartitionExec(output, r.table.asPartitionable, r.identifier,
diff --git a/sql/core/src/main/scala/org/apache/spark/sql/execution/datasources/v2/DescribeTableExec.scala b/sql/core/src/main/scala/org/apache/spark/sql/execution/datasources/v2/DescribeTableExec.scala
@@ -24,17 +24,153 @@ import org.apache.spark.sql.catalyst.InternalRow
 import org.apache.spark.sql.catalyst.catalog.{CatalogTableType, ClusterBySpec}
 import org.apache.spark.sql.catalyst.expressions.Attribute
 import org.apache.spark.sql.catalyst.util.{quoteIfNeeded, ResolveDefaultColumns}
-import org.apache.spark.sql.connector.catalog.{CatalogV2Util, SupportsMetadataColumns, SupportsRead, Table, TableCatalog}
+import org.apache.spark.sql.connector.catalog.{CatalogV2Util, Identifier, SupportsMetadataColumns, SupportsRead, Table, TableCatalog}
+import org.apache.spark.sql.connector.catalog.CatalogV2Implicits.NamespaceHelper
 import org.apache.spark.sql.connector.expressions.{ClusterByTransform, IdentityTransform}
 import org.apache.spark.sql.connector.read.SupportsReportStatistics
 import org.apache.spark.sql.errors.QueryExecutionErrors
 import org.apache.spark.sql.util.CaseInsensitiveStringMap
 import org.apache.spark.util.ArrayImplicits._
 
+/**
+ * Catalog / Namespace / Database / <entity> row formatting shared by
+ * `DescribeTableExec.addTableDetails` and `DescribeV2ViewExec.run`. Hosting it in one place
+ * keeps the row layout (including the v1-compat `Database` row) as a single source of truth
+ * so the table and view paths can't drift.
+ */
+private[v2] trait DescribeIdentifierRows extends LeafV2CommandExec {
+  /**
+   * Append the structured identifier rows (`Catalog`, `Namespace`, `Database`,
+   * `<entityLabel>`) to `rows`. `entityLabel` is `"Table"` for a v2 table and `"View"` for a
+   * v2 view -- the only divergence between the two paths.
+   *
+   * Row shapes:
+   *  - `Catalog` carries the catalog plugin name (always present for v2).
+   *  - `Namespace` is the canonical multi-segment representation, joined with `.` and with
+   *    `quoteIfNeeded` applied per segment (so segments containing dots round-trip). Always
+   *    emitted; for an empty namespace (root-level entity) the value is the empty string,
+   *    so the row's presence stays uniform across v2 outputs.
+   *  - `Database` is always emitted for v1 compatibility. Its value is the trailing
+   *    namespace segment (so multi-segment namespaces still surface their leaf segment),
+   *    or the empty string when the namespace is the catalog root. Consumers that need
+   *    the full namespace should read `Namespace`; `Database` alone is not round-trip-safe
+   *    for multi-segment cases.
+   *  - `<entityLabel>` is the unqualified entity name from `Identifier.name()`.
+   */
+  protected def addIdentifierRows(
+      rows: ArrayBuffer[InternalRow],
+      catalogName: String,
+      identifier: Identifier,
+      entityLabel: String): Unit = {
+    rows += toCatalystRow("Catalog", catalogName, "")
+    rows += toCatalystRow("Namespace", identifier.namespace().quoted, "")
+    rows += toCatalystRow("Database", identifier.namespace().lastOption.getOrElse(""), "")
+    rows += toCatalystRow(entityLabel, identifier.name(), "")
+  }
+}
+
+/**
+ * Schema + partitioning + clustering row formatting shared by `DescribeTableExec.run()` (which
+ * uses it for the schema-row prefix) and `DescribeTablePartitionExec.run()` (which uses it as
+ * the entire pre-partition section). Mixing the helpers into a trait lets each exec invoke
+ * them directly off `this`, so the partition exec doesn't need to thread the table-only
+ * `catalogName` / `identifier` arguments that `DescribeTableExec` consumes for the EXTENDED
+ * `# Detailed Table Information` block.
+ *
+ * Kept orthogonal to [[DescribeIdentifierRows]] so `DescribeTablePartitionExec` (which only
+ * needs the schema/partitioning rows) doesn't inherit identifier-row helpers it never calls.
+ * `DescribeTableExec` mixes both traits in.
+ */
+private[v2] trait DescribeTableBaseRows extends LeafV2CommandExec {
+  def table: Table
+
+  /** A blank `("", "", "")` row used as a section separator in DESCRIBE output. */
+  protected def emptyRow(): InternalRow = toCatalystRow("", "", "")
+
+  /** Schema + partitioning + clustering rows, shared with DescribeTablePartitionExec. */
+  protected def addBaseDescription(rows: ArrayBuffer[InternalRow]): Unit = {
+    addSchema(rows)
+    addPartitioning(rows)
+    addClustering(rows)
+  }
+
+  private def addSchema(rows: ArrayBuffer[InternalRow]): Unit = {
+    rows ++= table.columns().map{ column =>
+      toCatalystRow(
+        column.name, column.dataType.simpleString, column.comment)
+    }
+  }
+
+  private def addClusteringToRows(
+      clusterBySpec: ClusterBySpec,
+      rows: ArrayBuffer[InternalRow]): Unit = {
+    rows += toCatalystRow("# Clustering Information", "", "")
+    rows += toCatalystRow(s"# ${output.head.name}", output(1).name, output(2).name)
+    rows ++= clusterBySpec.columnNames.map { fieldNames =>
+      val schema = CatalogV2Util.v2ColumnsToStructType(table.columns())
+      val nestedField = schema.findNestedField(fieldNames.fieldNames.toIndexedSeq)
+      assert(nestedField.isDefined,
+        "The clustering column " +
+          s"${fieldNames.fieldNames.map(quoteIfNeeded).mkString(".")} " +
+          s"was not found in the table schema ${schema.catalogString}.")
+      nestedField.get
+    }.map { case (path, field) =>
+      toCatalystRow(
+        (path :+ field.name).map(quoteIfNeeded).mkString("."),
+        field.dataType.simpleString,
+        field.getComment().orNull)
+    }
+  }
+
+  private def addClustering(rows: ArrayBuffer[InternalRow]): Unit = {
+    ClusterBySpec.extractClusterBySpec(table.partitioning.toIndexedSeq).foreach { clusterBySpec =>
+      addClusteringToRows(clusterBySpec, rows)
+    }
+  }
+
+  private def addPartitioning(rows: ArrayBuffer[InternalRow]): Unit = {
+    // Clustering columns are handled in addClustering().
+    val partitioning = table.partitioning
+      .filter(t => !t.isInstanceOf[ClusterByTransform])
+    if (partitioning.nonEmpty) {
+      val partitionColumnsOnly = table.partitioning.forall(t => t.isInstanceOf[IdentityTransform])
+      if (partitionColumnsOnly) {
+        rows += toCatalystRow("# Partition Information", "", "")
+        rows += toCatalystRow(s"# ${output(0).name}", output(1).name, output(2).name)
+        val schema = CatalogV2Util.v2ColumnsToStructType(table.columns())
+        rows ++= table.partitioning
+          .map(_.asInstanceOf[IdentityTransform].ref.fieldNames())
+          .map { fieldNames =>
+            val nestedField = schema.findNestedField(fieldNames.toImmutableArraySeq)
+            if (nestedField.isEmpty) {
+              throw QueryExecutionErrors.partitionColumnNotFoundInTheTableSchemaError(
+                fieldNames.toSeq,
+                schema)
+            }
+            nestedField.get
+          }.map { case (path, field) =>
+            toCatalystRow(
+              (path :+ field.name).map(quoteIfNeeded(_)).mkString("."),
+              field.dataType.simpleString,
+              field.getComment().orNull)
+          }
+      } else {
+        rows += emptyRow()
+        rows += toCatalystRow("# Partitioning", "", "")
+        rows ++= table.partitioning.zipWithIndex.map {
+          case (transform, index) => toCatalystRow(s"Part $index", transform.describe(), "")
+        }
+      }
+    }
+  }
+}
+
 case class DescribeTableExec(
     output: Seq[Attribute],
+    catalogName: String,
+    identifier: Identifier,
     table: Table,
-    isExtended: Boolean) extends LeafV2CommandExec {
+    isExtended: Boolean) extends DescribeTableBaseRows with DescribeIdentifierRows {
   override protected def run(): Seq[InternalRow] = {
     val rows = new ArrayBuffer[InternalRow]()
     addBaseDescription(rows)
@@ -48,17 +184,10 @@ case class DescribeTableExec(
     rows.toSeq
   }
 
-  /** Schema + partitioning + clustering rows, shared with DescribeTablePartitionExec. */
-  private[v2] def addBaseDescription(rows: ArrayBuffer[InternalRow]): Unit = {
-    addSchema(rows)
-    addPartitioning(rows)
-    addClustering(rows)
-  }
-
   private def addTableDetails(rows: ArrayBuffer[InternalRow]): Unit = {
     rows += emptyRow()
     rows += toCatalystRow("# Detailed Table Information", "", "")
-    rows += toCatalystRow("Name", table.name(), "")
+    addIdentifierRows(rows, catalogName, identifier, entityLabel = "Table")
 
     val tableType = if (table.properties().containsKey(TableCatalog.PROP_EXTERNAL)) {
       CatalogTableType.EXTERNAL.name
@@ -87,13 +216,6 @@ case class DescribeTableExec(
     }
   }
 
-  private def addSchema(rows: ArrayBuffer[InternalRow]): Unit = {
-    rows ++= table.columns().map{ column =>
-      toCatalystRow(
-        column.name, column.dataType.simpleString, column.comment)
-    }
-  }
-
   private def addTableConstraints(rows: ArrayBuffer[InternalRow]): Unit = {
     if (table.constraints.nonEmpty) {
       rows += emptyRow()
@@ -117,33 +239,6 @@ case class DescribeTableExec(
     case _ =>
   }
 
-  private def addClusteringToRows(
-      clusterBySpec: ClusterBySpec,
-      rows: ArrayBuffer[InternalRow]): Unit = {
-    rows += toCatalystRow("# Clustering Information", "", "")
-    rows += toCatalystRow(s"# ${output.head.name}", output(1).name, output(2).name)
-    rows ++= clusterBySpec.columnNames.map { fieldNames =>
-      val schema = CatalogV2Util.v2ColumnsToStructType(table.columns())
-      val nestedField = schema.findNestedField(fieldNames.fieldNames.toIndexedSeq)
-      assert(nestedField.isDefined,
-        "The clustering column " +
-          s"${fieldNames.fieldNames.map(quoteIfNeeded).mkString(".")} " +
-          s"was not found in the table schema ${schema.catalogString}.")
-      nestedField.get
-    }.map { case (path, field) =>
-      toCatalystRow(
-        (path :+ field.name).map(quoteIfNeeded).mkString("."),
-        field.dataType.simpleString,
-        field.getComment().orNull)
-    }
-  }
-
-  private def addClustering(rows: ArrayBuffer[InternalRow]): Unit = {
-    ClusterBySpec.extractClusterBySpec(table.partitioning.toIndexedSeq).foreach { clusterBySpec =>
-      addClusteringToRows(clusterBySpec, rows)
-    }
-  }
-
   private def addTableStats(rows: ArrayBuffer[InternalRow]): Unit = table match {
     case read: SupportsRead =>
       read.newScanBuilder(CaseInsensitiveStringMap.empty()).build() match {
@@ -160,42 +255,4 @@ case class DescribeTableExec(
       }
     case _ =>
   }
-
-  private def addPartitioning(rows: ArrayBuffer[InternalRow]): Unit = {
-    // Clustering columns are handled in addClustering().
-    val partitioning = table.partitioning
-      .filter(t => !t.isInstanceOf[ClusterByTransform])
-    if (partitioning.nonEmpty) {
-      val partitionColumnsOnly = table.partitioning.forall(t => t.isInstanceOf[IdentityTransform])
-      if (partitionColumnsOnly) {
-        rows += toCatalystRow("# Partition Information", "", "")
-        rows += toCatalystRow(s"# ${output(0).name}", output(1).name, output(2).name)
-        val schema = CatalogV2Util.v2ColumnsToStructType(table.columns())
-        rows ++= table.partitioning
-          .map(_.asInstanceOf[IdentityTransform].ref.fieldNames())
-          .map { fieldNames =>
-            val nestedField = schema.findNestedField(fieldNames.toImmutableArraySeq)
-            if (nestedField.isEmpty) {
-              throw QueryExecutionErrors.partitionColumnNotFoundInTheTableSchemaError(
-                fieldNames.toSeq,
-                schema)
-            }
-            nestedField.get
-          }.map { case (path, field) =>
-            toCatalystRow(
-              (path :+ field.name).map(quoteIfNeeded(_)).mkString("."),
-              field.dataType.simpleString,
-              field.getComment().orNull)
-          }
-      } else {
-        rows += emptyRow()
-        rows += toCatalystRow("# Partitioning", "", "")
-        rows ++= table.partitioning.zipWithIndex.map {
-          case (transform, index) => toCatalystRow(s"Part $index", transform.describe(), "")
-        }
-      }
-    }
-  }
-
-  private def emptyRow(): InternalRow = toCatalystRow("", "", "")
 }
diff --git a/sql/core/src/main/scala/org/apache/spark/sql/execution/datasources/v2/DescribeTablePartitionExec.scala b/sql/core/src/main/scala/org/apache/spark/sql/execution/datasources/v2/DescribeTablePartitionExec.scala
@@ -32,14 +32,16 @@ case class DescribeTablePartitionExec(
     table: SupportsPartitionManagement,
     tableIdent: Identifier,
     partSpec: ResolvedPartitionSpec,
-    isExtended: Boolean) extends LeafV2CommandExec {
+    isExtended: Boolean) extends DescribeTableBaseRows {
 
   override protected def run(): Seq[InternalRow] = {
     val partitionRow = validateAndGetPartition()
 
-    // Delegate schema + partitioning + clustering to DescribeTableExec.
+    // Schema + partitioning + clustering rows come from the shared `DescribeTableBaseRows`
+    // trait, which is mixed in by both this exec and `DescribeTableExec` so each can call
+    // the helper directly off `this`.
     val rows = new ArrayBuffer[InternalRow]()
-    DescribeTableExec(output, table, isExtended = false).addBaseDescription(rows)
+    addBaseDescription(rows)
 
     if (isExtended) {
       addPartitionDetails(rows, partitionRow)
diff --git a/sql/core/src/main/scala/org/apache/spark/sql/execution/datasources/v2/V2ViewInspectionExecs.scala b/sql/core/src/main/scala/org/apache/spark/sql/execution/datasources/v2/V2ViewInspectionExecs.scala
@@ -146,17 +146,19 @@ case class ShowV2ViewColumnsExec(
 
 /**
  * Physical plan node for DESCRIBE TABLE on a v2 view. Schema rows first; when EXTENDED is
- * specified, an additional `# Detailed View Information` block emits the v2-native fields
- * (catalog, identifier, view text, captured creation context, schema-binding mode, query
- * column names, user TBLPROPERTIES). v2 views are unpartitioned by definition, so the
- * partition-spec branch from v1 `DescribeTableCommand` is unreachable here.
+ * specified, an additional `# Detailed View Information` block emits the v2-native fields:
+ * the resolved-identifier components via [[DescribeIdentifierRows#addIdentifierRows]] (which
+ * also surfaces a v1-compat `Database` row for single-segment namespaces), followed by view
+ * text, captured creation context, schema-binding mode, query column names, and user
+ * TBLPROPERTIES. v2 views are unpartitioned by definition, so the partition-spec branch from
+ * v1 `DescribeTableCommand` is unreachable here.
  */
 case class DescribeV2ViewExec(
     output: Seq[Attribute],
     catalogName: String,
     identifier: Identifier,
     viewInfo: ViewInfo,
-    isExtended: Boolean) extends LeafV2CommandExec with SQLConfHelper {
+    isExtended: Boolean) extends DescribeIdentifierRows with SQLConfHelper {
 
   override protected def run(): Seq[InternalRow] = {
     val result = new ArrayBuffer[InternalRow]
@@ -166,10 +168,7 @@ case class DescribeV2ViewExec(
     if (isExtended) {
       result += toCatalystRow("", "", "")
       result += toCatalystRow("# Detailed View Information", "", "")
-      result += toCatalystRow("Catalog", catalogName, "")
-      val qualified = (identifier.namespace() :+ identifier.name())
-        .map(quoteIfNeeded).mkString(".")
-      result += toCatalystRow("Identifier", qualified, "")
+      addIdentifierRows(result, catalogName, identifier, entityLabel = "View")
       // Promote first-class reserved fields (Owner / Comment / Collation) to top-level rows
       // before the EXTENDED Properties block, mirroring v1 `CatalogTable.toJsonLinkedHashMap`
       // which renders these as their own rows rather than burying them in `Table Properties`.
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/connector/DataSourceV2MetadataTableSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/connector/DataSourceV2MetadataTableSuite.scala
@@ -83,24 +83,6 @@ class DataSourceV2MetadataTableSuite extends QueryTest with SharedSparkSession {
     checkAnswer(spark.table(tableName), 0.until(10).map(i => Row(i, -i)))
   }
 
-  test("DESCRIBE TABLE EXTENDED on a non-view MetadataTable shows the real identifier") {
-    // MetadataTable.name() is read by DescribeTableExec's "Name" row. Pin that it
-    // reflects the catalog-supplied identifier (here TestingDataSourceTableCatalog passes
-    // `ident.toString`) rather than a generic placeholder, so the DESCRIBE output is
-    // meaningful for users.
-    withTempPath { path =>
-      val loc = path.getCanonicalPath
-      val tableName = s"table_catalog.`$loc`.test_json"
-      spark.range(1).select($"id".cast("string").as("col")).write.json(loc)
-      val nameRow = sql(s"DESCRIBE TABLE EXTENDED $tableName")
-        .collect()
-        .find(_.getString(0) == "Name")
-        .getOrElse(fail("DESCRIBE output missing the `Name` row"))
-      val rendered = nameRow.getString(1)
-      assert(rendered.contains("test_json"), s"expected the real identifier, got: $rendered")
-    }
-  }
-
   test("fully-qualified column reference uses the real catalog name") {
     withTempPath { path =>
       val loc = path.getCanonicalPath
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/connector/DataSourceV2SQLSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/connector/DataSourceV2SQLSuite.scala
@@ -3912,8 +3912,8 @@ class DataSourceV2SQLSuiteV1Filter
         QueryTest.checkAnswer(
           descriptionDf.filter(
             "!(col_name in ('Catalog', 'Created Time', 'Created By', 'Database', " +
-              "'index', 'Location', 'Name', 'Owner', 'Provider', 'Table', 'Table Properties', " +
-              "'Type', '_partition', ''))"),
+              "'index', 'Location', 'Name', 'Namespace', 'Owner', 'Provider', 'Table', " +
+              "'Table Properties', 'Type', '_partition', ''))"),
           Seq(
             Row("# Detailed Table Information", "", ""),
             Row("# Column Default Values", "", ""),
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/command/v2/DescribeTableSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/command/v2/DescribeTableSuite.scala
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/command/v2/DescribeViewSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/command/v2/DescribeViewSuite.scala
