feat(exasol): transpile USE/OPEN SCHEMA and SHOW TABLES to system-table query (#7538)

* feat(exasol): transpile USE/OPEN SCHEMA and SHOW TABLES to system-table query

Exasol uses `OPEN SCHEMA <name>` where other dialects use `USE <name>`, and
has no native `SHOW TABLES` statement — the equivalent is a SELECT on
`SYS.EXA_ALL_TABLES`. Previously both statements produced invalid Exasol
output (parse error or empty string).

Changes:

* Add `use_sql` in ExasolGenerator that emits `OPEN SCHEMA <this>` for the
  default `USE schema` form. For other kinds (e.g. `USE ROLE admin`,
  `USE WAREHOUSE wh`), emit an unsupported warning and fall back to the
  base `USE` generator rather than silently rewriting them as schema
  switches.
* Add parser support in ExasolParser for `OPEN SCHEMA <id>` so it round-
  trips as an `exp.Use` node.
* Add `show_sql` in ExasolGenerator that rewrites `SHOW TABLES [FROM db]`
  to `SELECT TABLE_NAME FROM SYS.EXA_ALL_TABLES WHERE TABLE_SCHEMA = ...`,
  using the provided schema (uppercased to match Exasol metadata) or
  `CURRENT_SCHEMA` when absent. Other SHOW kinds fall through to the base
  generator (which marks them unsupported).

* Update sqlglot/parsers/exasol.py

* Update sqlglot/parsers/exasol.py

---------

Co-authored-by: Jo <46752250+georgesittas@users.noreply.github.com>

Author: mkcorneli

sqlglot/generators/exasol.py

@@ -890,6 +890,31 @@ def if_sql(self, expression: exp.If) -> str:
         false = self.sql(expression, "false")
         return f"IF {this} THEN {true} ELSE {false} ENDIF"
 
+    # https://docs.exasol.com/db/latest/sql/open_schema.htm
+    def use_sql(self, expression: exp.Use) -> str:
+        kind = expression.args.get("kind")
+        if kind and self.sql(kind).upper() != "SCHEMA":
+            self.unsupported(f"'USE {self.sql(kind)}' is not supported in Exasol")
+            return super().use_sql(expression)
+        this = self.sql(expression, "this")
+        return f"OPEN SCHEMA {this}"
+
+    # https://docs.exasol.com/db/latest/sql_references/metadata/metadata_system_tables.htm
+    def show_sql(self, expression: exp.Show) -> str:
+        if expression.name == "TABLES":
+            db_name = expression.text("db")
+            schema_filter: exp.Expression = (
+                exp.Literal.string(db_name.upper()) if db_name else exp.CurrentSchema()
+            )
+            select = (
+                exp.select(exp.column("TABLE_NAME"))
+                .from_(exp.table_("EXA_ALL_TABLES", db="SYS"))
+                .where(exp.column("TABLE_SCHEMA").eq(schema_filter))
+            )
+            return self.sql(select)
+
+        return super().show_sql(expression)
+
     def collate_sql(self, expression: exp.Collate) -> str:
         return self.sql(expression.this)
 

sqlglot/parsers/exasol.py

@@ -127,6 +127,12 @@ class ExasolParser(parser.Parser):
         "JSON_EXTRACT": lambda self: self._parse_json_extract(),
     }
 
+    def _parse_statement(self) -> exp.Expr | None:
+        # https://docs.exasol.com/db/latest/sql/open_schema.htm
+        if self._match_text_seq("OPEN", "SCHEMA"):
+            return self.expression(exp.Use(this=self._parse_table(schema=False)))
+        return super()._parse_statement()
+
     def _parse_column(self) -> exp.Expr | None:
         column = super()._parse_column()
         if not isinstance(column, exp.Column):

tests/dialects/test_exasol.py

@@ -954,3 +954,40 @@ def test_group_by_all(self):
                 write="exasol",
                 unsupported_level=ErrorLevel.RAISE,
             )
+
+    def test_use_to_open_schema(self):
+        self.validate_all(
+            "OPEN SCHEMA test",
+            read={"mysql": "USE test"},
+            write={"exasol": "OPEN SCHEMA test"},
+        )
+        self.validate_identity("OPEN SCHEMA test")
+        self.validate_all(
+            'OPEN SCHEMA "my_database"',
+            read={"mysql": "USE `my_database`"},
+            write={"exasol": 'OPEN SCHEMA "my_database"'},
+        )
+        # USE ROLE / USE WAREHOUSE have no Exasol equivalent — emit unsupported
+        with self.assertRaises(UnsupportedError):
+            transpile(
+                "USE ROLE admin",
+                read="snowflake",
+                write="exasol",
+                unsupported_level=ErrorLevel.RAISE,
+            )
+
+    def test_show_tables(self):
+        self.validate_all(
+            "SELECT TABLE_NAME FROM SYS.EXA_ALL_TABLES WHERE TABLE_SCHEMA = 'TEST'",
+            read={"mysql": "SHOW TABLES FROM test"},
+            write={
+                "exasol": "SELECT TABLE_NAME FROM SYS.EXA_ALL_TABLES WHERE TABLE_SCHEMA = 'TEST'"
+            },
+        )
+        self.validate_all(
+            "SELECT TABLE_NAME FROM SYS.EXA_ALL_TABLES WHERE TABLE_SCHEMA = CURRENT_SCHEMA",
+            read={"mysql": "SHOW TABLES"},
+            write={
+                "exasol": "SELECT TABLE_NAME FROM SYS.EXA_ALL_TABLES WHERE TABLE_SCHEMA = CURRENT_SCHEMA"
+            },
+        )