diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala index ec19606411a5..99155624dcd9 100644 --- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala +++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala @@ -730,6 +730,11 @@ class Analyzer( case class ResolveNamespace(catalogManager: CatalogManager) extends Rule[LogicalPlan] with LookupCatalog { def apply(plan: LogicalPlan): LogicalPlan = plan resolveOperators { + case s @ ShowTablesStatement(UnresolvedNamespace(Seq()), _) => + s.copy(namespace = + ResolvedNamespace(currentCatalog.asNamespaceCatalog, catalogManager.currentNamespace)) + case UnresolvedNamespace(Seq()) => + ResolvedNamespace(currentCatalog.asNamespaceCatalog, Seq.empty[String]) case UnresolvedNamespace(CatalogAndNamespace(catalog, ns)) => ResolvedNamespace(catalog.asNamespaceCatalog, ns) } diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/ResolveCatalogs.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/ResolveCatalogs.scala index 4487a9f1b6b8..0a8b085e7505 100644 --- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/ResolveCatalogs.scala +++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/ResolveCatalogs.scala @@ -108,11 +108,11 @@ class ResolveCatalogs(val catalogManager: CatalogManager) case AlterNamespaceSetPropertiesStatement( NonSessionCatalogAndNamespace(catalog, ns), properties) => - AlterNamespaceSetProperties(catalog.asNamespaceCatalog, ns, properties) + AlterNamespaceSetProperties(catalog, ns, properties) case AlterNamespaceSetLocationStatement( NonSessionCatalogAndNamespace(catalog, ns), location) => - AlterNamespaceSetProperties(catalog.asNamespaceCatalog, ns, + AlterNamespaceSetProperties(catalog, ns, Map(SupportsNamespaces.PROP_LOCATION -> location)) case RenameTableStatement(NonSessionCatalogAndTable(catalog, oldName), newNameParts, isView) => @@ -190,28 +190,22 @@ class ResolveCatalogs(val catalogManager: CatalogManager) s"Can not specify catalog `${catalog.name}` for view ${viewName.quoted} " + s"because view support in catalog has not been implemented yet") - case c @ CreateNamespaceStatement(NonSessionCatalogAndNamespace(catalog, ns), _, _) => + case c @ CreateNamespaceStatement(CatalogAndNamespace(catalog, ns), _, _) + if !isSessionCatalog(catalog) => CreateNamespace(catalog.asNamespaceCatalog, ns, c.ifNotExists, c.properties) case DropNamespaceStatement(NonSessionCatalogAndNamespace(catalog, ns), ifExists, cascade) => DropNamespace(catalog, ns, ifExists, cascade) case DescribeNamespaceStatement(NonSessionCatalogAndNamespace(catalog, ns), extended) => - DescribeNamespace(catalog.asNamespaceCatalog, ns, extended) + DescribeNamespace(catalog, ns, extended) - case ShowNamespacesStatement(Some(CatalogAndNamespace(catalog, ns)), pattern) => - val namespace = if (ns.nonEmpty) Some(ns) else None - ShowNamespaces(catalog.asNamespaceCatalog, namespace, pattern) + case ShowNamespacesStatement(NonSessionCatalogAndNamespace(catalog, ns), pattern) => + ShowNamespaces(catalog, ns, pattern) - case ShowNamespacesStatement(None, pattern) => - ShowNamespaces(currentCatalog.asNamespaceCatalog, None, pattern) - - case ShowTablesStatement(Some(NonSessionCatalogAndNamespace(catalog, ns)), pattern) => + case ShowTablesStatement(NonSessionCatalogAndNamespace(catalog, ns), pattern) => ShowTables(catalog.asTableCatalog, ns, pattern) - case ShowTablesStatement(None, pattern) if !isSessionCatalog(currentCatalog) => - ShowTables(currentCatalog.asTableCatalog, catalogManager.currentNamespace, pattern) - case UseStatement(isNamespaceSet, nameParts) => if (isNamespaceSet) { SetCatalogAndNamespace(catalogManager, None, Some(nameParts)) @@ -239,10 +233,11 @@ class ResolveCatalogs(val catalogManager: CatalogManager) } object NonSessionCatalogAndNamespace { - def unapply(nameParts: Seq[String]): Option[(CatalogPlugin, Seq[String])] = nameParts match { - case CatalogAndNamespace(catalog, ns) if !isSessionCatalog(catalog) => - Some(catalog -> ns) - case _ => None - } + def unapply(resolved: ResolvedNamespace): Option[(SupportsNamespaces, Seq[String])] = + if (!isSessionCatalog(resolved.catalog)) { + Some(resolved.catalog -> resolved.namespace) + } else { + None + } } } diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala index a6a041d0ebc6..5ea98e02346b 100644 --- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala +++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala @@ -2548,7 +2548,7 @@ class AstBuilder(conf: SQLConf) extends SqlBaseBaseVisitor[AnyRef] with Logging */ override def visitDropNamespace(ctx: DropNamespaceContext): LogicalPlan = withOrigin(ctx) { DropNamespaceStatement( - visitMultipartIdentifier(ctx.multipartIdentifier), + UnresolvedNamespace(visitMultipartIdentifier(ctx.multipartIdentifier)), ctx.EXISTS != null, ctx.CASCADE != null) } @@ -2565,7 +2565,7 @@ class AstBuilder(conf: SQLConf) extends SqlBaseBaseVisitor[AnyRef] with Logging override def visitSetNamespaceProperties(ctx: SetNamespacePropertiesContext): LogicalPlan = { withOrigin(ctx) { AlterNamespaceSetPropertiesStatement( - visitMultipartIdentifier(ctx.multipartIdentifier), + UnresolvedNamespace(visitMultipartIdentifier(ctx.multipartIdentifier)), visitPropertyKeyValues(ctx.tablePropertyList)) } } @@ -2581,7 +2581,7 @@ class AstBuilder(conf: SQLConf) extends SqlBaseBaseVisitor[AnyRef] with Logging override def visitSetNamespaceLocation(ctx: SetNamespaceLocationContext): LogicalPlan = { withOrigin(ctx) { AlterNamespaceSetLocationStatement( - visitMultipartIdentifier(ctx.multipartIdentifier), + UnresolvedNamespace(visitMultipartIdentifier(ctx.multipartIdentifier)), visitLocationSpec(ctx.locationSpec)) } } @@ -2594,8 +2594,9 @@ class AstBuilder(conf: SQLConf) extends SqlBaseBaseVisitor[AnyRef] with Logging throw new ParseException(s"FROM/IN operator is not allowed in SHOW DATABASES", ctx) } + val multiPart = Option(ctx.multipartIdentifier).map(visitMultipartIdentifier) ShowNamespacesStatement( - Option(ctx.multipartIdentifier).map(visitMultipartIdentifier), + UnresolvedNamespace(multiPart.getOrElse(Seq.empty[String])), Option(ctx.pattern).map(string)) } @@ -2610,7 +2611,7 @@ class AstBuilder(conf: SQLConf) extends SqlBaseBaseVisitor[AnyRef] with Logging override def visitDescribeNamespace(ctx: DescribeNamespaceContext): LogicalPlan = withOrigin(ctx) { DescribeNamespaceStatement( - visitMultipartIdentifier(ctx.multipartIdentifier()), + UnresolvedNamespace(visitMultipartIdentifier(ctx.multipartIdentifier())), ctx.EXTENDED != null) } @@ -2780,8 +2781,9 @@ class AstBuilder(conf: SQLConf) extends SqlBaseBaseVisitor[AnyRef] with Logging * Create a [[ShowTablesStatement]] command. */ override def visitShowTables(ctx: ShowTablesContext): LogicalPlan = withOrigin(ctx) { + val multiPart = Option(ctx.multipartIdentifier).map(visitMultipartIdentifier) ShowTablesStatement( - Option(ctx.multipartIdentifier).map(visitMultipartIdentifier), + UnresolvedNamespace(multiPart.getOrElse(Seq.empty[String])), Option(ctx.pattern).map(string)) } diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/plans/logical/statements.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/plans/logical/statements.scala index e205dd4e2899..6103b05f1d13 100644 --- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/plans/logical/statements.scala +++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/plans/logical/statements.scala @@ -302,8 +302,10 @@ case class DescribeTableStatement( * A DESCRIBE NAMESPACE statement, as parsed from SQL. */ case class DescribeNamespaceStatement( - namespace: Seq[String], - extended: Boolean) extends ParsedStatement + namespace: LogicalPlan, + extended: Boolean) extends ParsedStatement { + override def children: Seq[LogicalPlan] = Seq(namespace) +} /** * A DESCRIBE TABLE tbl_name col_name statement, as parsed from SQL. @@ -346,8 +348,11 @@ case class InsertIntoStatement( /** * A SHOW TABLES statement, as parsed from SQL. */ -case class ShowTablesStatement(namespace: Option[Seq[String]], pattern: Option[String]) - extends ParsedStatement +case class ShowTablesStatement( + namespace: LogicalPlan, + pattern: Option[String]) extends ParsedStatement { + override def children: Seq[LogicalPlan] = Seq(namespace) +} /** * A SHOW TABLE EXTENDED statement, as parsed from SQL. @@ -370,29 +375,38 @@ case class CreateNamespaceStatement( * A DROP NAMESPACE statement, as parsed from SQL. */ case class DropNamespaceStatement( - namespace: Seq[String], + namespace: LogicalPlan, ifExists: Boolean, - cascade: Boolean) extends ParsedStatement + cascade: Boolean) extends ParsedStatement { + override def children: Seq[LogicalPlan] = Seq(namespace) +} /** * ALTER (DATABASE|SCHEMA|NAMESPACE) ... SET (DBPROPERTIES|PROPERTIES) command, as parsed from SQL. */ case class AlterNamespaceSetPropertiesStatement( - namespace: Seq[String], - properties: Map[String, String]) extends ParsedStatement + namespace: LogicalPlan, + properties: Map[String, String]) extends ParsedStatement { + override def children: Seq[LogicalPlan] = Seq(namespace) +} /** * ALTER (DATABASE|SCHEMA|NAMESPACE) ... SET LOCATION command, as parsed from SQL. */ case class AlterNamespaceSetLocationStatement( - namespace: Seq[String], - location: String) extends ParsedStatement + namespace: LogicalPlan, + location: String) extends ParsedStatement { + override def children: Seq[LogicalPlan] = Seq(namespace) +} /** * A SHOW NAMESPACES statement, as parsed from SQL. */ -case class ShowNamespacesStatement(namespace: Option[Seq[String]], pattern: Option[String]) - extends ParsedStatement +case class ShowNamespacesStatement( + namespace: LogicalPlan, + pattern: Option[String]) extends ParsedStatement { + override def children: Seq[LogicalPlan] = Seq(namespace) +} /** * A USE statement, as parsed from SQL. diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/plans/logical/v2Commands.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/plans/logical/v2Commands.scala index 10e9dc85a051..f1f98c244370 100644 --- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/plans/logical/v2Commands.scala +++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/plans/logical/v2Commands.scala @@ -284,7 +284,7 @@ case class AlterNamespaceSetProperties( */ case class ShowNamespaces( catalog: SupportsNamespaces, - namespace: Option[Seq[String]], + namespace: Seq[String], pattern: Option[String]) extends Command { override val output: Seq[Attribute] = Seq( AttributeReference("namespace", StringType, nullable = false)()) diff --git a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/DDLParserSuite.scala b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/DDLParserSuite.scala index e6b2c6440147..d35c22aa81e6 100644 --- a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/DDLParserSuite.scala +++ b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/DDLParserSuite.scala @@ -745,8 +745,10 @@ class DDLParserSuite extends AnalysisTest { test("describe database") { val sql1 = "DESCRIBE DATABASE EXTENDED a.b" val sql2 = "DESCRIBE DATABASE a.b" - comparePlans(parsePlan(sql1), DescribeNamespaceStatement(Seq("a", "b"), extended = true)) - comparePlans(parsePlan(sql2), DescribeNamespaceStatement(Seq("a", "b"), extended = false)) + comparePlans(parsePlan(sql1), + DescribeNamespaceStatement(UnresolvedNamespace(Seq("a", "b")), extended = true)) + comparePlans(parsePlan(sql2), + DescribeNamespaceStatement(UnresolvedNamespace(Seq("a", "b")), extended = false)) } test("SPARK-17328 Fix NPE with EXPLAIN DESCRIBE TABLE") { @@ -1106,16 +1108,16 @@ class DDLParserSuite extends AnalysisTest { test("show tables") { comparePlans( parsePlan("SHOW TABLES"), - ShowTablesStatement(None, None)) + ShowTablesStatement(UnresolvedNamespace(Seq.empty[String]), None)) comparePlans( parsePlan("SHOW TABLES FROM testcat.ns1.ns2.tbl"), - ShowTablesStatement(Some(Seq("testcat", "ns1", "ns2", "tbl")), None)) + ShowTablesStatement(UnresolvedNamespace(Seq("testcat", "ns1", "ns2", "tbl")), None)) comparePlans( parsePlan("SHOW TABLES IN testcat.ns1.ns2.tbl"), - ShowTablesStatement(Some(Seq("testcat", "ns1", "ns2", "tbl")), None)) + ShowTablesStatement(UnresolvedNamespace(Seq("testcat", "ns1", "ns2", "tbl")), None)) comparePlans( parsePlan("SHOW TABLES IN tbl LIKE '*dog*'"), - ShowTablesStatement(Some(Seq("tbl")), Some("*dog*"))) + ShowTablesStatement(UnresolvedNamespace(Seq("tbl")), Some("*dog*"))) } test("show table extended") { @@ -1230,78 +1232,86 @@ class DDLParserSuite extends AnalysisTest { test("drop namespace") { comparePlans( parsePlan("DROP NAMESPACE a.b.c"), - DropNamespaceStatement(Seq("a", "b", "c"), ifExists = false, cascade = false)) + DropNamespaceStatement( + UnresolvedNamespace(Seq("a", "b", "c")), ifExists = false, cascade = false)) comparePlans( parsePlan("DROP NAMESPACE IF EXISTS a.b.c"), - DropNamespaceStatement(Seq("a", "b", "c"), ifExists = true, cascade = false)) + DropNamespaceStatement( + UnresolvedNamespace(Seq("a", "b", "c")), ifExists = true, cascade = false)) comparePlans( parsePlan("DROP NAMESPACE IF EXISTS a.b.c RESTRICT"), - DropNamespaceStatement(Seq("a", "b", "c"), ifExists = true, cascade = false)) + DropNamespaceStatement( + UnresolvedNamespace(Seq("a", "b", "c")), ifExists = true, cascade = false)) comparePlans( parsePlan("DROP NAMESPACE IF EXISTS a.b.c CASCADE"), - DropNamespaceStatement(Seq("a", "b", "c"), ifExists = true, cascade = true)) + DropNamespaceStatement( + UnresolvedNamespace(Seq("a", "b", "c")), ifExists = true, cascade = true)) comparePlans( parsePlan("DROP NAMESPACE a.b.c CASCADE"), - DropNamespaceStatement(Seq("a", "b", "c"), ifExists = false, cascade = true)) + DropNamespaceStatement( + UnresolvedNamespace(Seq("a", "b", "c")), ifExists = false, cascade = true)) } test("set namespace properties") { comparePlans( parsePlan("ALTER DATABASE a.b.c SET PROPERTIES ('a'='a', 'b'='b', 'c'='c')"), AlterNamespaceSetPropertiesStatement( - Seq("a", "b", "c"), Map("a" -> "a", "b" -> "b", "c" -> "c"))) + UnresolvedNamespace(Seq("a", "b", "c")), Map("a" -> "a", "b" -> "b", "c" -> "c"))) comparePlans( parsePlan("ALTER SCHEMA a.b.c SET PROPERTIES ('a'='a')"), AlterNamespaceSetPropertiesStatement( - Seq("a", "b", "c"), Map("a" -> "a"))) + UnresolvedNamespace(Seq("a", "b", "c")), Map("a" -> "a"))) comparePlans( parsePlan("ALTER NAMESPACE a.b.c SET PROPERTIES ('b'='b')"), AlterNamespaceSetPropertiesStatement( - Seq("a", "b", "c"), Map("b" -> "b"))) + UnresolvedNamespace(Seq("a", "b", "c")), Map("b" -> "b"))) comparePlans( parsePlan("ALTER DATABASE a.b.c SET DBPROPERTIES ('a'='a', 'b'='b', 'c'='c')"), AlterNamespaceSetPropertiesStatement( - Seq("a", "b", "c"), Map("a" -> "a", "b" -> "b", "c" -> "c"))) + UnresolvedNamespace(Seq("a", "b", "c")), Map("a" -> "a", "b" -> "b", "c" -> "c"))) comparePlans( parsePlan("ALTER SCHEMA a.b.c SET DBPROPERTIES ('a'='a')"), AlterNamespaceSetPropertiesStatement( - Seq("a", "b", "c"), Map("a" -> "a"))) + UnresolvedNamespace(Seq("a", "b", "c")), Map("a" -> "a"))) comparePlans( parsePlan("ALTER NAMESPACE a.b.c SET DBPROPERTIES ('b'='b')"), AlterNamespaceSetPropertiesStatement( - Seq("a", "b", "c"), Map("b" -> "b"))) + UnresolvedNamespace(Seq("a", "b", "c")), Map("b" -> "b"))) } test("set namespace location") { comparePlans( parsePlan("ALTER DATABASE a.b.c SET LOCATION '/home/user/db'"), - AlterNamespaceSetLocationStatement(Seq("a", "b", "c"), "/home/user/db")) + AlterNamespaceSetLocationStatement( + UnresolvedNamespace(Seq("a", "b", "c")), "/home/user/db")) comparePlans( parsePlan("ALTER SCHEMA a.b.c SET LOCATION '/home/user/db'"), - AlterNamespaceSetLocationStatement(Seq("a", "b", "c"), "/home/user/db")) + AlterNamespaceSetLocationStatement( + UnresolvedNamespace(Seq("a", "b", "c")), "/home/user/db")) comparePlans( parsePlan("ALTER NAMESPACE a.b.c SET LOCATION '/home/user/db'"), - AlterNamespaceSetLocationStatement(Seq("a", "b", "c"), "/home/user/db")) + AlterNamespaceSetLocationStatement( + UnresolvedNamespace(Seq("a", "b", "c")), "/home/user/db")) } test("show databases: basic") { comparePlans( parsePlan("SHOW DATABASES"), - ShowNamespacesStatement(None, None)) + ShowNamespacesStatement(UnresolvedNamespace(Seq.empty[String]), None)) comparePlans( parsePlan("SHOW DATABASES LIKE 'defau*'"), - ShowNamespacesStatement(None, Some("defau*"))) + ShowNamespacesStatement(UnresolvedNamespace(Seq.empty[String]), Some("defau*"))) } test("show databases: FROM/IN operator is not allowed") { @@ -1317,16 +1327,16 @@ class DDLParserSuite extends AnalysisTest { test("show namespaces") { comparePlans( parsePlan("SHOW NAMESPACES"), - ShowNamespacesStatement(None, None)) + ShowNamespacesStatement(UnresolvedNamespace(Seq.empty[String]), None)) comparePlans( parsePlan("SHOW NAMESPACES FROM testcat.ns1.ns2"), - ShowNamespacesStatement(Some(Seq("testcat", "ns1", "ns2")), None)) + ShowNamespacesStatement(UnresolvedNamespace(Seq("testcat", "ns1", "ns2")), None)) comparePlans( parsePlan("SHOW NAMESPACES IN testcat.ns1.ns2"), - ShowNamespacesStatement(Some(Seq("testcat", "ns1", "ns2")), None)) + ShowNamespacesStatement(UnresolvedNamespace(Seq("testcat", "ns1", "ns2")), None)) comparePlans( parsePlan("SHOW NAMESPACES IN testcat.ns1 LIKE '*pattern*'"), - ShowNamespacesStatement(Some(Seq("testcat", "ns1")), Some("*pattern*"))) + ShowNamespacesStatement(UnresolvedNamespace(Seq("testcat", "ns1")), Some("*pattern*"))) } test("analyze table statistics") { diff --git a/sql/core/src/main/scala/org/apache/spark/sql/catalyst/analysis/ResolveSessionCatalog.scala b/sql/core/src/main/scala/org/apache/spark/sql/catalyst/analysis/ResolveSessionCatalog.scala index 5abde31466d0..682f810fc539 100644 --- a/sql/core/src/main/scala/org/apache/spark/sql/catalyst/analysis/ResolveSessionCatalog.scala +++ b/sql/core/src/main/scala/org/apache/spark/sql/catalyst/analysis/ResolveSessionCatalog.scala @@ -184,8 +184,7 @@ class ResolveSessionCatalog( } DescribeDatabaseCommand(ns.head, d.extended) - case AlterNamespaceSetPropertiesStatement( - SessionCatalogAndNamespace(_, ns), properties) => + case AlterNamespaceSetPropertiesStatement(SessionCatalogAndNamespace(_, ns), properties) => if (ns.length != 1) { throw new AnalysisException( s"The database name is not valid: ${ns.quoted}") @@ -316,7 +315,8 @@ class ResolveSessionCatalog( case DropViewStatement(SessionCatalogAndTable(catalog, viewName), ifExists) => DropTableCommand(viewName.asTableIdentifier, ifExists, isView = true, purge = false) - case c @ CreateNamespaceStatement(SessionCatalogAndNamespace(_, ns), _, _) => + case c @ CreateNamespaceStatement(CatalogAndNamespace(catalog, ns), _, _) + if isSessionCatalog(catalog) => if (ns.length != 1) { throw new AnalysisException( s"The database name is not valid: ${ns.quoted}") @@ -334,17 +334,17 @@ class ResolveSessionCatalog( } DropDatabaseCommand(ns.head, d.ifExists, d.cascade) - case ShowTablesStatement(Some(CatalogAndNamespace(catalog, ns)), pattern) - if isSessionCatalog(catalog) => + case ShowNamespacesStatement(SessionCatalogAndNamespace(catalog, ns), pattern) => + ShowNamespaces(catalog, ns, pattern) + + case ShowTablesStatement(SessionCatalogAndNamespace(_, ns), pattern) => + assert(ns.nonEmpty) if (ns.length != 1) { throw new AnalysisException( s"The database name is not valid: ${ns.quoted}") } ShowTablesCommand(Some(ns.head), pattern) - case ShowTablesStatement(None, pattern) if isSessionCatalog(currentCatalog) => - ShowTablesCommand(None, pattern) - case ShowTableStatement(ns, pattern, partitionsSpec) => val db = ns match { case Some(ns) if ns.length != 1 => @@ -590,11 +590,12 @@ class ResolveSessionCatalog( } object SessionCatalogAndNamespace { - def unapply(nameParts: Seq[String]): Option[(CatalogPlugin, Seq[String])] = nameParts match { - case CatalogAndNamespace(catalog, ns) if isSessionCatalog(catalog) => - Some(catalog -> ns) - case _ => None - } + def unapply(resolved: ResolvedNamespace): Option[(SupportsNamespaces, Seq[String])] = + if (isSessionCatalog(resolved.catalog)) { + Some(resolved.catalog -> resolved.namespace) + } else { + None + } } private def assertTopLevelColumn(colName: Seq[String], command: String): Unit = { diff --git a/sql/core/src/main/scala/org/apache/spark/sql/execution/datasources/v2/ShowNamespacesExec.scala b/sql/core/src/main/scala/org/apache/spark/sql/execution/datasources/v2/ShowNamespacesExec.scala index 15402cc0074c..fe3ab8023db6 100644 --- a/sql/core/src/main/scala/org/apache/spark/sql/execution/datasources/v2/ShowNamespacesExec.scala +++ b/sql/core/src/main/scala/org/apache/spark/sql/execution/datasources/v2/ShowNamespacesExec.scala @@ -32,19 +32,16 @@ import org.apache.spark.sql.connector.catalog.SupportsNamespaces case class ShowNamespacesExec( output: Seq[Attribute], catalog: SupportsNamespaces, - namespace: Option[Seq[String]], + namespace: Seq[String], pattern: Option[String]) extends V2CommandExec { override protected def run(): Seq[InternalRow] = { - val namespaces = namespace.map { ns => - if (ns.nonEmpty) { - catalog.listNamespaces(ns.toArray) - } else { - catalog.listNamespaces() - } - } - .getOrElse(catalog.listNamespaces()) + val namespaces = if (namespace.nonEmpty) { + catalog.listNamespaces(namespace.toArray) + } else { + catalog.listNamespaces() + } val rows = new ArrayBuffer[InternalRow]() val encoder = RowEncoder(schema).resolveAndBind()