clickzetta-semantic-model-generator 1.0.2__tar.gz → 1.0.4__tar.gz

{clickzetta_semantic_model_generator-1.0.2 → clickzetta_semantic_model_generator-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: clickzetta-semantic-model-generator
-Version: 1.0.2
+Version: 1.0.4
 Summary: Curate a Semantic Model for ClickZetta Lakehouse
 License: Apache Software License; BSD License
 Author: qililiang
@@ -13,12 +13,12 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Provides-Extra: looker
 Requires-Dist: PyYAML (>=6.0.1,<7.0.0)
-Requires-Dist: clickzetta-connector-python (==0.8.92)
-Requires-Dist: clickzetta-zettapark-python (==0.1.3)
+Requires-Dist: clickzetta-connector-python (>=0.8.92)
+Requires-Dist: clickzetta-zettapark-python (>=0.1.3)
 Requires-Dist: dashscope (>=1.22.2,<2.0.0)
 Requires-Dist: loguru (>=0.7.2,<0.8.0)
 Requires-Dist: looker-sdk (>=24.14.0,<25.0.0) ; extra == "looker"
-Requires-Dist: numpy (>=1.26.4,<2.0.0)
+Requires-Dist: numpy (>=1.26.4,<3.0.0)
 Requires-Dist: pandas (>=2.0.1,<3.0.0)
 Requires-Dist: protobuf (==5.26.1)
 Requires-Dist: pyarrow (==14.0.2)
@@ -31,7 +31,7 @@ Requires-Dist: streamlit (==1.36.0)
 Requires-Dist: streamlit-extras (==0.4.0)
 Requires-Dist: strictyaml (>=1.7.3,<2.0.0)
 Requires-Dist: tqdm (>=4.66.5,<5.0.0)
-Requires-Dist: urllib3 (>=1.26.19,<2.0.0)
+Requires-Dist: urllib3 (>=1.26.19,<3.0.0)
 Description-Content-Type: text/markdown
 
 # semantic-model-generator

{clickzetta_semantic_model_generator-1.0.2 → clickzetta_semantic_model_generator-1.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "clickzetta-semantic-model-generator"
-version = "1.0.2"
+version = "1.0.4"
 description = "Curate a Semantic Model for ClickZetta Lakehouse"
 authors = ["qililiang <qililiang@clickzetta.com>"]
 license = "Apache Software License; BSD License"
@@ -11,7 +11,7 @@ packages = [{include = "semantic_model_generator"}]
 python = ">=3.9,<3.9.7 || >3.9.7,<3.12"
 pandas = "^2.0.1"
 loguru = "^0.7.2"
-clickzetta-connector-python = "0.8.92"
+clickzetta-connector-python = ">=0.8.92"
 protobuf = "5.26.1"
 pydantic = ">=2.8.2,<3.0.0"
 PyYAML = "^6.0.1"
@@ -22,11 +22,11 @@ sqlglot = "25.10.0"
 strictyaml = "^1.7.3"
 streamlit = "1.36.0"
 streamlit-extras = "0.4.0"
-numpy = "^1.26.4"
+numpy = ">=1.26.4,<3.0.0"
 python-dotenv = "^1.0.1"
-urllib3 = "^1.26.19"
+urllib3 = ">=1.26.19,<3.0.0"
 requests = "^2.32.3"
-clickzetta-zettapark-python = "0.1.3"
+clickzetta-zettapark-python = ">=0.1.3"
 dashscope = "^1.22.2"
 
 # Optional dependencies for functionality such as partner semantic model support.

{clickzetta_semantic_model_generator-1.0.2 → clickzetta_semantic_model_generator-1.0.4}/semantic_model_generator/clickzetta_utils/clickzetta_connector.py

@@ -4,7 +4,6 @@ import concurrent.futures
 import re
 from collections import defaultdict
 from contextlib import contextmanager
-from types import SimpleNamespace
 from typing import Any, Dict, Generator, List, Optional, TypeVar, Union
 
 import pandas as pd
@@ -13,8 +12,10 @@ from loguru import logger
 
 from semantic_model_generator.clickzetta_utils import env_vars
 from semantic_model_generator.clickzetta_utils.utils import (
-    clickzetta_connection,
     create_session,
+    join_quoted_identifiers,
+    normalize_identifier,
+    quote_identifier,
 )
 from semantic_model_generator.data_processing.data_types import Column, Table
 
@@ -115,7 +116,9 @@ class ClickzettaCursor:
     def execute(self, query: str) -> "ClickzettaCursor":
         self._df = _execute_query_to_pandas(self._session, query)
         columns = [] if self._df is None else list(self._df.columns)
-        self.description = [(col, None, None, None, None, None, None) for col in columns]
+        self.description = [
+            (col, None, None, None, None, None, None) for col in columns
+        ]
         return self
 
     def fetchone(self) -> Optional[tuple[Any, ...]]:
@@ -153,14 +156,8 @@ class ClickzettaConnectionProxy:
         self.session.close()
 
 
-def _quote_identifier(name: str) -> str:
-    return f'"{name}"'
-
-
 def _qualify_table(workspace: str, schema_name: str, table_name: str) -> str:
-    return ".".join(
-        [_quote_identifier(workspace), _quote_identifier(schema_name), _quote_identifier(table_name)]
-    )
+    return join_quoted_identifiers(workspace, schema_name, table_name)
 
 
 def _value_is_true(value: Any) -> bool:
@@ -173,11 +170,9 @@ def _value_is_true(value: Any) -> bool:
 
 
 def _sanitize_identifier(value: Any, fallback: str = "") -> str:
-    if value is None or value == "":
+    normalized = normalize_identifier(value)
+    if not normalized:
         return fallback
-    normalized = str(value).strip()
-    if normalized.startswith('"') and normalized.endswith('"') and len(normalized) >= 2:
-        normalized = normalized[1:-1]
     return normalized
 
 
@@ -214,15 +209,19 @@ def _fetch_distinct_values(
     column_name: str,
     ndv: int,
 ) -> Optional[List[str]]:
-    workspace_part = _sanitize_identifier(workspace, workspace).upper() if workspace else ""
-    schema_part = _sanitize_identifier(schema_name, schema_name).upper() if schema_name else ""
-    table_part = _sanitize_identifier(table_name, table_name).upper()
-    column_part = _sanitize_identifier(column_name, column_name).upper()
+    workspace_part = _sanitize_identifier(workspace, workspace) if workspace else ""
+    schema_part = (
+        _sanitize_identifier(schema_name, schema_name) if schema_name else ""
+    )
+    table_part = _sanitize_identifier(table_name, table_name)
+    column_part = _sanitize_identifier(column_name, column_name)
 
-    qualified_parts = [part for part in (workspace_part, schema_part, table_part) if part]
-    qualified_table = ".".join(qualified_parts)
+    qualified_table = join_quoted_identifiers(
+        workspace_part, schema_part, table_part
+    )
+    column_expr = quote_identifier(column_part)
 
-    query = f"SELECT DISTINCT {column_part} FROM {qualified_table} LIMIT {ndv}"
+    query = f"SELECT DISTINCT {column_expr} FROM {qualified_table} LIMIT {ndv}"
     try:
         df = session.sql(query).to_pandas()
         if df.empty:
@@ -257,7 +256,6 @@ def _get_column_representation(
     else:
         column_datatype = str(column_datatype_raw)
     column_datatype = _normalize_column_type(column_datatype)
-    normalized_type = column_datatype.split("(")[0].strip()
     column_values = (
         _fetch_distinct_values(
             session=session,
@@ -351,7 +349,14 @@ def _catalog_category(session: Session, workspace: str) -> str:
         return "UNKNOWN"
 
     df.columns = [str(col).upper() for col in df.columns]
-    name_col = next((col for col in ("WORKSPACE_NAME", "NAME", "CATALOG_NAME") if col in df.columns), None)
+    name_col = next(
+        (
+            col
+            for col in ("WORKSPACE_NAME", "NAME", "CATALOG_NAME")
+            if col in df.columns
+        ),
+        None,
+    )
     category_col = next((col for col in ("CATEGORY",) if col in df.columns), None)
     if not name_col or not category_col:
         _CATALOG_CATEGORY_CACHE[workspace_upper] = "UNKNOWN"
@@ -408,7 +413,9 @@ ORDER BY kc.ordinal_position
         if result is not None:
             return result
     except Exception:
-        logger.debug("Primary key lookup via sys.information_schema failed; falling back.")
+        logger.debug(
+            "Primary key lookup via sys.information_schema failed; falling back."
+        )
 
     fallback_query = f"""
 SELECT kc.column_name
@@ -423,7 +430,13 @@ ORDER BY kc.ordinal_position
         if result is not None:
             return result
     except Exception as exc:
-        logger.warning("Primary key lookup failed for {}.{}.{}: {}", workspace, schema_name, table_name, exc)
+        logger.warning(
+            "Primary key lookup failed for {}.{}.{}: {}",
+            workspace,
+            schema_name,
+            table_name,
+            exc,
+        )
     return None
 
 
@@ -432,9 +445,7 @@ def _build_information_schema_query(
     table_schema: Optional[str],
     table_names: Optional[List[str]],
 ) -> str:
-    where_conditions: List[str] = [
-        "1=1"
-    ]
+    where_conditions: List[str] = ["1=1"]
     if table_schema:
         where_conditions.append(f"upper(t.table_schema) = '{table_schema.upper()}'")
     if table_names:
@@ -442,7 +453,6 @@ def _build_information_schema_query(
         where_conditions.append(f"upper(t.table_name) IN ({formatted_names})")
 
     where_clause = " AND ".join(where_conditions)
-    base = "information_schema"
     return f"""
 SELECT
     t.table_schema AS {_TABLE_SCHEMA_COL},
@@ -474,27 +484,48 @@ def _fetch_columns_via_show(
     schema = table_schema.upper() if table_schema else ""
 
     for table_name in table_names:
-        qualified_parts = [part for part in (catalog, schema, table_name.upper()) if part]
+        qualified_parts = [
+            part for part in (catalog, schema, table_name.upper()) if part
+        ]
         qualified_table = ".".join(qualified_parts)
         query = f"SHOW COLUMNS IN {qualified_table}"
         try:
             df = session.sql(query).to_pandas()
         except Exception as exc:
-            logger.debug("SHOW COLUMNS fallback failed for {}: {}", qualified_table, exc)
+            logger.debug(
+                "SHOW COLUMNS fallback failed for {}: {}", qualified_table, exc
+            )
             continue
         if df.empty:
             continue
         df.columns = [str(col).upper() for col in df.columns]
-        schema_col = next((col for col in ("TABLE_SCHEMA", "SCHEMA_NAME") if col in df.columns), None)
-        table_col = next((col for col in ("TABLE_NAME", "NAME") if col in df.columns), None)
-        column_col = next((col for col in ("COLUMN_NAME", "NAME") if col in df.columns and col != table_col), None)
-        datatype_col = next((col for col in ("DATA_TYPE", "TYPE") if col in df.columns), None)
-        comment_col = next((col for col in ("COMMENT", "COLUMN_COMMENT") if col in df.columns), None)
+        schema_col = next(
+            (col for col in ("TABLE_SCHEMA", "SCHEMA_NAME") if col in df.columns), None
+        )
+        table_col = next(
+            (col for col in ("TABLE_NAME", "NAME") if col in df.columns), None
+        )
+        column_col = next(
+            (
+                col
+                for col in ("COLUMN_NAME", "NAME")
+                if col in df.columns and col != table_col
+            ),
+            None,
+        )
+        datatype_col = next(
+            (col for col in ("DATA_TYPE", "TYPE") if col in df.columns), None
+        )
+        comment_col = next(
+            (col for col in ("COMMENT", "COLUMN_COMMENT") if col in df.columns), None
+        )
 
         normalized = pd.DataFrame()
         normalized[_TABLE_SCHEMA_COL] = df[schema_col] if schema_col else table_schema
         normalized[_TABLE_NAME_COL] = df[table_col] if table_col else table_name
-        normalized[_COLUMN_NAME_COL] = df[column_col] if column_col else df.index.astype(str)
+        normalized[_COLUMN_NAME_COL] = (
+            df[column_col] if column_col else df.index.astype(str)
+        )
         normalized[_DATATYPE_COL] = df[datatype_col] if datatype_col else ""
         normalized[_COLUMN_COMMENT_ALIAS] = df[comment_col] if comment_col else ""
         normalized[_TABLE_COMMENT_COL] = ""
@@ -552,6 +583,7 @@ def get_valid_schemas_tables_columns_df(
     if _TABLE_SCHEMA_COL in result.columns:
         result[_TABLE_SCHEMA_COL] = result[_TABLE_SCHEMA_COL].astype(str).str.upper()
     if _IS_PRIMARY_KEY_COL in result.columns:
+
         def _normalize_pk(value: Any) -> bool:
             if isinstance(value, bool):
                 return value
@@ -617,10 +649,10 @@ def fetch_tables_views_in_schema(
     workspace_upper = workspace.upper()
     schema_upper = schema.upper()
 
-    target = ""
     try:
         if workspace_upper and schema_upper:
-            df = session.sql(f"SHOW TABLES IN {workspace_upper}.{schema_upper}").to_pandas()
+            scope = join_quoted_identifiers(workspace_upper, schema_upper)
+            df = session.sql(f"SHOW TABLES IN {scope}").to_pandas()
         else:
             df = session.sql("SHOW TABLES").to_pandas()
     except Exception as exc:  # pragma: no cover
@@ -634,17 +666,27 @@ def fetch_tables_views_in_schema(
     df.columns = [str(col).upper() for col in df.columns]
     name_column = "TABLE_NAME" if "TABLE_NAME" in df.columns else df.columns[0]
     schema_column = next(
-        (col for col in ("SCHEMA_NAME", "TABLE_SCHEMA", "NAMESPACE") if col in df.columns),
+        (
+            col
+            for col in ("SCHEMA_NAME", "TABLE_SCHEMA", "NAMESPACE")
+            if col in df.columns
+        ),
         None,
     )
     catalog_column = next(
-        (col for col in ("CATALOG_NAME", "WORKSPACE_NAME", "TABLE_CATALOG") if col in df.columns),
+        (
+            col
+            for col in ("CATALOG_NAME", "WORKSPACE_NAME", "TABLE_CATALOG")
+            if col in df.columns
+        ),
         None,
     )
 
     results: List[str] = []
     for _, row in df.iterrows():
-        if _value_is_true(row.get("IS_VIEW")) and not _value_is_true(row.get("IS_MATERIALIZED_VIEW")):
+        if _value_is_true(row.get("IS_VIEW")) and not _value_is_true(
+            row.get("IS_MATERIALIZED_VIEW")
+        ):
             continue
         if _value_is_true(row.get("IS_EXTERNAL")):
             continue
@@ -686,11 +728,15 @@ def fetch_stages_in_schema(connection: Any, schema_name: str) -> List[str]:
 
     queries: List[str] = []
     if schema:
-        queries.append(f"SHOW VOLUMES IN {workspace}.{schema}")
-        queries.append(f"SHOW STAGES IN SCHEMA {workspace}.{schema}")
+        scope = join_quoted_identifiers(workspace, schema)
+        if scope:
+            queries.append(f"SHOW VOLUMES IN {scope}")
+            queries.append(f"SHOW STAGES IN SCHEMA {scope}")
     else:
-        queries.append(f"SHOW VOLUMES IN {workspace}")
-        queries.append(f"SHOW STAGES IN DATABASE {workspace}")
+        workspace_identifier = quote_identifier(workspace)
+        if workspace_identifier:
+            queries.append(f"SHOW VOLUMES IN {workspace_identifier}")
+            queries.append(f"SHOW STAGES IN DATABASE {workspace_identifier}")
 
     stage_names: List[str] = ["volume:user://~/semantic_models/"]
     seen: set[str] = set(stage_names)
@@ -756,7 +802,11 @@ def fetch_yaml_names_in_stage(
     if stage.lower().startswith("volume:user://"):
         volume_body = stage[len("volume:") :]
         # Normalize relative directory
-        relative = volume_body[len("user://") :] if volume_body.startswith("user://") else volume_body
+        relative = (
+            volume_body[len("user://") :]
+            if volume_body.startswith("user://")
+            else volume_body
+        )
         relative = relative.lstrip("~/")
         relative = relative.strip("/")
 
@@ -842,7 +892,9 @@ def create_table_in_schema(
     table_fqn: str,
     columns_schema: Dict[str, str],
 ) -> bool:
-    fields = ", ".join(f"{_quote_identifier(name)} {dtype}" for name, dtype in columns_schema.items())
+    fields = ", ".join(
+        f"{quote_identifier(name)} {dtype}" for name, dtype in columns_schema.items()
+    )
     query = f"CREATE TABLE IF NOT EXISTS {table_fqn} ({fields})"
     try:
         session.sql(query).collect()

{clickzetta_semantic_model_generator-1.0.2 → clickzetta_semantic_model_generator-1.0.4}/semantic_model_generator/clickzetta_utils/env_vars.py

@@ -20,7 +20,9 @@ _CONFIG_PATHS = [
 _ACTIVE_CONFIG_PATH: Optional[str] = None
 
 
-def _load_config_from_file() -> Tuple[Optional[Dict[str, str]], Dict[str, Dict[str, str]]]:
+def _load_config_from_file() -> (
+    Tuple[Optional[Dict[str, str]], Dict[str, Dict[str, str]]]
+):
     global _ACTIVE_CONFIG_PATH
     _ACTIVE_CONFIG_PATH = None
     for path in _CONFIG_PATHS:
@@ -91,7 +93,10 @@ def _deep_lookup(mapping: Any, key: str) -> Optional[Any]:
         if isinstance(current, dict):
             for candidate_key, candidate_value in current.items():
                 candidate_key_str = str(candidate_key).lower()
-                if candidate_key_str == normalized_key and candidate_value not in (None, ""):
+                if candidate_key_str == normalized_key and candidate_value not in (
+                    None,
+                    "",
+                ):
                     return candidate_value
                 if isinstance(candidate_value, (dict, list)):
                     queue.append(candidate_value)

{clickzetta_semantic_model_generator-1.0.2 → clickzetta_semantic_model_generator-1.0.4}/semantic_model_generator/clickzetta_utils/utils.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from contextlib import contextmanager
-from typing import Dict, Iterable
+from typing import Any, Dict, Iterable
 
 from clickzetta.zettapark.session import Session
 
@@ -21,6 +21,47 @@ DEFAULT_HINTS: Dict[str, str] = {
 }
 
 
+def normalize_identifier(value: Any) -> str:
+    """
+    Strips outer quotes/backticks and surrounding whitespace from an identifier.
+    Returns an empty string when the identifier is missing.
+    """
+
+    if value is None:
+        return ""
+    text = str(value).strip()
+    if len(text) >= 2 and text[0] == text[-1] and text[0] in {'"', '`'}:
+        return text[1:-1]
+    return text
+
+
+def quote_identifier(value: Any) -> str:
+    """
+    Wraps an identifier in backticks, escaping embedded backticks as needed.
+    Returns an empty string if the identifier is missing.
+    """
+
+    normalized = normalize_identifier(value)
+    if not normalized:
+        return ""
+    escaped = normalized.replace("`", "``")
+    return f"`{escaped}`"
+
+
+def join_quoted_identifiers(*parts: Any) -> str:
+    """
+    Joins identifier parts with '.' and ensures each segment is backtick-quoted.
+    Empty segments are skipped.
+    """
+
+    quoted_parts = [
+        quote_identifier(part)
+        for part in parts
+        if normalize_identifier(part)
+    ]
+    return ".".join(part for part in quoted_parts if part)
+
+
 def create_fqn_table(fqn_str: str) -> FQNParts:
     """
     Splits a fully qualified table name into its ClickZetta components.
@@ -72,7 +113,8 @@ def _apply_session_context(session: Session, *, schema: str, vcluster: str) -> N
         ("schema", schema),
         ("vcluster", vcluster),
     ):
-        session.sql(f"USE {component.upper()} {value.upper()}")
+        identifier = quote_identifier(value)
+        session.sql(f"USE {component.upper()} {identifier}")
 
 
 def _iter_non_empty(*pairs: tuple[str, str]) -> Iterable[tuple[str, str]]:

{clickzetta_semantic_model_generator-1.0.2 → clickzetta_semantic_model_generator-1.0.4}/semantic_model_generator/data_processing/cte_utils.py

@@ -8,15 +8,37 @@ import sqlglot.expressions
 from loguru import logger
 from sqlglot import Dialect
 
-from semantic_model_generator.protos import semantic_model_pb2
 from semantic_model_generator.clickzetta_utils.clickzetta_connector import (
     OBJECT_DATATYPES,
 )
+from semantic_model_generator.clickzetta_utils.utils import (
+    join_quoted_identifiers,
+    normalize_identifier,
+)
+from semantic_model_generator.protos import semantic_model_pb2
 
 _SQLGLOT_CLICKZETTA_KEY = "".join(["snow", "flake"])
 ClickzettaDialect = Dialect.get_or_raise(_SQLGLOT_CLICKZETTA_KEY)
 
 _LOGICAL_TABLE_PREFIX = "__"
+_SQLGLOT_QUOTE_CHAR = '"'
+
+
+def _prepare_sql_for_parsing(sql: str) -> str:
+    """
+    Converts backtick-quoted identifiers to double quotes for SQLGlot parsing.
+    """
+
+    return sql.replace("`", _SQLGLOT_QUOTE_CHAR)
+
+
+def _render_clickzetta_sql(expression: sqlglot.Expression, *, pretty: bool = False) -> str:
+    """
+    Renders a SQLGlot expression using ClickZetta dialect and rewrites identifiers with backticks.
+    """
+
+    rendered = expression.sql(dialect=ClickzettaDialect, pretty=pretty)
+    return rendered.replace(_SQLGLOT_QUOTE_CHAR, "`")
 
 
 def is_logical_table(table_name: str) -> bool:
@@ -33,12 +55,12 @@ def logical_table_name(table: semantic_model_pb2.Table) -> str:
 
 def fully_qualified_table_name(table: semantic_model_pb2.FullyQualifiedTable) -> str:
     """Returns fully qualified table name such as my_db.my_schema.my_table"""
-    fqn = table.table
-    if len(table.schema) > 0:
-        fqn = f"{table.schema}.{fqn}"
-    if len(table.database) > 0:
-        fqn = f"{table.database}.{fqn}"
-    return fqn  # type: ignore[no-any-return]
+    parts = [
+        normalize_identifier(component)
+        for component in (table.database, table.schema, table.table)
+        if component
+    ]
+    return join_quoted_identifiers(*parts)  # type: ignore[no-any-return]
 
 
 def is_aggregation_expr(col: semantic_model_pb2.Column) -> bool:
@@ -156,8 +178,8 @@ def _generate_cte_for(
         cte = f"WITH {logical_table_name(table)} AS (\n"
         cte += "SELECT \n"
         cte += ",\n".join(expr_columns) + "\n"
-        cte += f"FROM {fully_qualified_table_name(table.base_table)}"
-        cte += ")"
+        cte += f"FROM {fully_qualified_table_name(table.base_table)}\n"
+        cte += ")\n"
         return cte
 
 
@@ -261,13 +283,15 @@ def _convert_to_clickzetta_sql(sql: str) -> str:
     str: The SQL statement in ClickZetta syntax.
     """
     try:
-        expression = sqlglot.parse_one(sql, dialect=ClickzettaDialect)
+        expression = sqlglot.parse_one(
+            _prepare_sql_for_parsing(sql), dialect=ClickzettaDialect
+        )
     except Exception as e:
         raise ValueError(
             f"Unable to parse sql statement.\n Provided sql: {sql}\n. Error: {e}"
         )
 
-    return expression.sql(dialect=ClickzettaDialect)
+    return _render_clickzetta_sql(expression)
 
 
 def generate_select(
@@ -332,12 +356,16 @@ def expand_all_logical_tables_as_ctes(
     for cte in ctes:
         new_withs.append(
             sqlglot.parse_one(
-                cte, read=ClickzettaDialect, into=sqlglot.expressions.With
+                _prepare_sql_for_parsing(cte),
+                read=ClickzettaDialect,
+                into=sqlglot.expressions.With,
             )
         )
 
     # Step 3: Prefix the CTEs to the original query.
-    ast = sqlglot.parse_one(sql_query, read=ClickzettaDialect)
+    ast = sqlglot.parse_one(
+        _prepare_sql_for_parsing(sql_query), read=ClickzettaDialect
+    )
     with_ = ast.args.get("with")
     # If the query doesn't have a WITH clause, then generate one.
     if with_ is None:
@@ -349,7 +377,9 @@ def expand_all_logical_tables_as_ctes(
     else:
         new_ctes = [w.expressions[0] for w in new_withs]
         with_.set("expressions", new_ctes + with_.expressions)
-    return ast.sql(dialect=ClickzettaDialect, pretty=True)  # type: ignore [no-any-return]
+    return _render_clickzetta_sql(
+        ast, pretty=True
+    )  # type: ignore [no-any-return]
 
 
 def context_to_column_format(