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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: clickzetta-semantic-model-generator
-Version: 1.0.4
+Version: 1.0.6
 Summary: Curate a Semantic Model for ClickZetta Lakehouse
 License: Apache Software License; BSD License
 Author: qililiang

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "clickzetta-semantic-model-generator"
-version = "1.0.4"
+version = "1.0.6"
 description = "Curate a Semantic Model for ClickZetta Lakehouse"
 authors = ["qililiang <qililiang@clickzetta.com>"]
 license = "Apache Software License; BSD License"

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

@@ -480,15 +480,30 @@ def _fetch_columns_via_show(
         return pd.DataFrame()
 
     rows: List[pd.DataFrame] = []
-    catalog = workspace.upper()
-    schema = table_schema.upper() if table_schema else ""
+    category = _catalog_category(session, workspace)
+    is_shared_catalog = category in {"SHARED", "EXTERNAL"}
+    catalog = workspace if is_shared_catalog else workspace.upper()
+    schema = (
+        table_schema or ""
+    )
+    if schema and not is_shared_catalog:
+        schema = schema.upper()
 
     for table_name in table_names:
         qualified_parts = [
-            part for part in (catalog, schema, table_name.upper()) if part
+            part
+            for part in (
+                catalog,
+                schema,
+                table_name.upper() if not is_shared_catalog else table_name,
+            )
+            if part
         ]
         qualified_table = ".".join(qualified_parts)
-        query = f"SHOW COLUMNS IN {qualified_table}"
+        if is_shared_catalog:
+            query = f"SHOW COLUMNS IN SHARE {qualified_table}"
+        else:
+            query = f"SHOW COLUMNS IN {qualified_table}"
         try:
             df = session.sql(query).to_pandas()
         except Exception as exc:
@@ -646,13 +661,25 @@ def fetch_tables_views_in_schema(
     parts = schema_name.split(".", maxsplit=1)
     workspace = parts[0]
     schema = parts[1] if len(parts) > 1 else ""
-    workspace_upper = workspace.upper()
-    schema_upper = schema.upper()
+    category = _catalog_category(session, workspace)
+    is_shared_catalog = category in {"SHARED", "EXTERNAL"}
+
+    workspace_token = workspace if is_shared_catalog else workspace.upper()
+    schema_token = schema if is_shared_catalog else schema.upper()
 
     try:
-        if workspace_upper and schema_upper:
-            scope = join_quoted_identifiers(workspace_upper, schema_upper)
-            df = session.sql(f"SHOW TABLES IN {scope}").to_pandas()
+        if workspace_token and schema_token:
+            if is_shared_catalog:
+                scope = ".".join(
+                    part for part in (workspace_token, schema_token) if part
+                )
+                df = session.sql(f"SHOW TABLES IN SHARE {scope}").to_pandas()
+            else:
+                scope = join_quoted_identifiers(
+                    workspace_token,
+                    schema_token,
+                )
+                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
@@ -688,8 +715,6 @@ def fetch_tables_views_in_schema(
             row.get("IS_MATERIALIZED_VIEW")
         ):
             continue
-        if _value_is_true(row.get("IS_EXTERNAL")):
-            continue
         # keep materialized views
         catalog_part = _sanitize_identifier(
             row[catalog_column] if catalog_column else workspace, workspace

{clickzetta_semantic_model_generator-1.0.4 → clickzetta_semantic_model_generator-1.0.6}/semantic_model_generator/relationships/discovery.py

@@ -112,22 +112,36 @@ def _tables_payload_to_raw_tables(
         if not isinstance(table_entry, Mapping):
             raise TypeError("Each table definition must be a mapping of table metadata")
 
-        table_name = str(
+        raw_table_identifier = str(
             table_entry.get("table_name")
             or table_entry.get("name")
             or table_entry.get("table")
             or ""
         ).strip()
-        if not table_name:
+        if not raw_table_identifier:
             raise ValueError("Table definition missing 'table_name'")
 
-        workspace = str(table_entry.get("workspace") or default_workspace).strip() or default_workspace
+        identifier_workspace, identifier_schema, identifier_table = _split_table_identifier(
+            raw_table_identifier
+        )
+
+        workspace = str(
+            table_entry.get("workspace")
+            or table_entry.get("database")
+            or identifier_workspace
+            or default_workspace
+        ).strip() or default_workspace
         schema = str(
             table_entry.get("schema")
             or table_entry.get("schema_name")
+            or identifier_schema
             or default_schema
         ).strip() or default_schema
 
+        table_name = identifier_table.strip()
+        if not table_name:
+            raise ValueError(f"Unable to parse table name from '{raw_table_identifier}'")
+
         columns_payload = table_entry.get("columns")
         if not isinstance(columns_payload, Sequence) or not columns_payload:
             raise ValueError(
@@ -370,3 +384,19 @@ def discover_relationships_from_schema(
         timeout_seconds=timeout_seconds,
         max_tables=max_tables,
     )
+def _split_table_identifier(identifier: str) -> Tuple[Optional[str], Optional[str], str]:
+    """
+    Split a table identifier that may include workspace/schema prefixes.
+
+    Supported formats:
+      - workspace.schema.table
+      - schema.table
+      - table
+    """
+
+    parts = [part.strip() for part in identifier.split(".") if part.strip()]
+    if len(parts) == 3:
+        return parts[0], parts[1], parts[2]
+    if len(parts) == 2:
+        return None, parts[0], parts[1]
+    return None, None, parts[0]

{clickzetta_semantic_model_generator-1.0.4 → clickzetta_semantic_model_generator-1.0.6}/semantic_model_generator/tests/relationship_discovery_test.py

@@ -176,3 +176,47 @@ def test_discover_relationships_from_table_definitions_filters_generic_ids() ->
 
     assert result.summary.total_relationships_found == 0
     assert not result.relationships
+
+
+def test_table_definitions_support_fully_qualified_names() -> None:
+    payload = [
+        {
+            "table_name": "demo.sales.orders",
+            "columns": [
+                {"name": "order_id", "type": "NUMBER", "is_primary_key": True},
+                {"name": "customer_id", "type": "NUMBER"},
+            ],
+        },
+        {
+            "table_name": "sales.customers",
+            "workspace": "demo",
+            "columns": [
+                {"name": "customer_id", "type": "NUMBER", "is_primary_key": True},
+                {"name": "name", "type": "STRING"},
+            ],
+        },
+        {
+            "table_name": "products",
+            "workspace": "demo",
+            "schema": "sales",
+            "columns": [
+                {"name": "product_id", "type": "NUMBER", "is_primary_key": True},
+                {"name": "name", "type": "STRING"},
+            ],
+        },
+    ]
+
+    result = discover_relationships_from_table_definitions(
+        payload,
+        default_workspace="fallback",
+        default_schema="fallback_schema",
+    )
+
+    table_names = {table.name for table in result.tables}
+    assert table_names == {"ORDERS", "CUSTOMERS", "PRODUCTS"}
+
+    # Ensure relationships include the orders -> customers edge despite mixed identifiers
+    assert any(
+        rel.left_table == "ORDERS" and rel.right_table == "CUSTOMERS"
+        for rel in result.relationships
+    )