dbt-cube-sync 0.1.0a2__tar.gz → 0.1.0a4__tar.gz

{dbt_cube_sync-0.1.0a2 → dbt_cube_sync-0.1.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbt-cube-sync
-Version: 0.1.0a2
+Version: 0.1.0a4
 Summary: Synchronization tool for dbt models to Cube.js schemas and BI tools
 Author: Ponder
 Requires-Python: >=3.9,<4.0

{dbt_cube_sync-0.1.0a2 → dbt_cube_sync-0.1.0a4}/dbt_cube_sync/connectors/superset.py

@@ -191,19 +191,7 @@ class SupersetConnector(BaseConnector):
         
         cube_name = cube_name_match.group(1)
         
-        # Use public schema and cube name for Superset dataset
-        schema_name = "public"
-        table_name = cube_name  # Use cube name (not database table name)
-        
-        # Extract actual database table for reference (but don't use it for dataset)
-        sql_match = re.search(r'sql:\s*[`"\']\s*SELECT\s+.*FROM\s+(\w+\.\w+)', content, re.IGNORECASE)
-        actual_db_table = None
-        if sql_match:
-            actual_db_table = sql_match.group(1)
-        
         print(f"  Cube: {cube_name}")
-        print(f"  Schema: {schema_name}")
-        print(f"  Table: {table_name}")
         
         # Parse dimensions
         dimensions = self._parse_dimensions(content)
@@ -213,9 +201,8 @@ class SupersetConnector(BaseConnector):
         
         return {
             'cube_name': cube_name,
-            'schema': schema_name,
-            'table_name': table_name,  # This is now the cube name for dataset creation
-            'actual_db_table': actual_db_table,  # This is the real DB table
+            'schema': 'public',             # Always use public schema for Cube.js
+            'table_name': cube_name,        # Use cube name as table name (e.g., CoursePerformanceSummary)
             'dimensions': dimensions,
             'measures': measures
         }
@@ -350,12 +337,26 @@ class SupersetConnector(BaseConnector):
             'count_distinct': 'COUNT(DISTINCT'
         }
         
+        # Remove Cube.js ${} syntax and convert to plain SQL column references
+        cleaned_expression = self._clean_cube_expression(sql_expression)
+        
         agg_func = agg_mapping.get(agg_type, 'SUM')
         
         if agg_type == 'count_distinct':
-            return f"{agg_func} {sql_expression})"
+            return f"{agg_func} {cleaned_expression})"
         else:
-            return f"{agg_func}({sql_expression})"
+            return f"{agg_func}({cleaned_expression})"
+    
+    def _clean_cube_expression(self, expression: str) -> str:
+        """Convert Cube.js expressions to SQL column references for Superset"""
+        import re
+        
+        # Remove ${} syntax - convert ${column_name} to column_name
+        cleaned = re.sub(r'\$\{([^}]+)\}', r'\1', expression)
+        
+        # Handle more complex expressions like arithmetic
+        # Keep parentheses and operators but clean column references
+        return cleaned
     
     def _create_or_update_dataset(self, schema_info: Dict[str, Any]) -> int:
         """Create a new dataset or update existing one"""
@@ -409,27 +410,14 @@ class SupersetConnector(BaseConnector):
         """Create a new dataset in Superset"""
         dataset_url = f"{self.base_url}/api/v1/dataset/"
         
-        # If we have actual DB table info, use custom SQL, otherwise use table reference
-        if schema_info.get('actual_db_table'):
-            # Create a custom SQL dataset that references the actual table but is named with cube name
-            sql_query = f"SELECT * FROM {schema_info['actual_db_table']}"
-            payload = {
-                "database": self.database_id,
-                "schema": schema_info['schema'],  # "public"
-                "table_name": schema_info['table_name'],  # cube name like "CoursePerformanceSummary" 
-                "sql": sql_query,
-                "normalize_columns": False,
-                "always_filter_main_dttm": False
-            }
-        else:
-            # Fallback to direct table reference
-            payload = {
-                "database": self.database_id,
-                "schema": schema_info['schema'],
-                "table_name": schema_info['table_name'],
-                "normalize_columns": False,
-                "always_filter_main_dttm": False
-            }
+        # Create a simple table dataset (Cube.js will handle the actual data source)
+        payload = {
+            "database": self.database_id,
+            "schema": schema_info['schema'],              # "public"
+            "table_name": schema_info['table_name'],      # cube name like "CoursePerformanceSummary"
+            "normalize_columns": False,
+            "always_filter_main_dttm": False
+        }
         
         print(f"\\n📊 Creating new dataset: {schema_info['table_name']}")
         response = self.session.post(dataset_url, json=payload)
@@ -532,37 +520,41 @@ class SupersetConnector(BaseConnector):
     
     def _update_metrics(self, existing_metrics: List[dict], measures: List[dict]) -> List[dict]:
         """Update metrics with new measures"""
-        # Clean existing metrics
+        # Clean existing metrics and create a lookup by name
         updated_metrics = []
+        existing_metric_names = {}
+        
         for metric in existing_metrics:
             clean_metric = {k: v for k, v in metric.items() 
                           if k not in ['created_on', 'changed_on', 'uuid']}
+            existing_metric_names[metric.get('metric_name')] = len(updated_metrics)
             updated_metrics.append(clean_metric)
         
-        # Add new metrics
-        existing_metric_names = {m.get('metric_name') for m in existing_metrics}
-        added_count = 0
-        
+        # Add or update metrics
         for measure in measures:
             metric_name = measure['metric_name']
             
-            if metric_name not in existing_metric_names:
-                new_metric = {
-                    'metric_name': metric_name,
-                    'verbose_name': measure['verbose_name'],
-                    'expression': measure['expression'],
-                    'description': measure['description'],
-                    'metric_type': 'simple',
-                    'currency': None,
-                    'd3format': None,
-                    'extra': None,
-                    'warning_text': None
-                }
-                updated_metrics.append(new_metric)
-                print(f"  ✓ Prepared '{metric_name}': {measure['expression']}")
-                added_count += 1
+            new_metric = {
+                'metric_name': metric_name,
+                'verbose_name': measure['verbose_name'],
+                'expression': measure['expression'],
+                'description': measure['description'],
+                'metric_type': 'simple',
+                'currency': None,
+                'd3format': None,
+                'extra': None,
+                'warning_text': None
+            }
+            
+            if metric_name in existing_metric_names:
+                # Update existing metric
+                index = existing_metric_names[metric_name]
+                updated_metrics[index].update(new_metric)
+                print(f"  ✓ Updated '{metric_name}': {measure['expression']}")
             else:
-                print(f"  ⊘ Skipping '{metric_name}' (already exists)")
+                # Add new metric
+                updated_metrics.append(new_metric)
+                print(f"  ✓ Added '{metric_name}': {measure['expression']}")
         
         return updated_metrics
 

{dbt_cube_sync-0.1.0a2 → dbt_cube_sync-0.1.0a4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dbt-cube-sync"
-version = "0.1.0a2"
+version = "0.1.0a4"
 description = "Synchronization tool for dbt models to Cube.js schemas and BI tools"
 authors = ["Ponder"]
 readme = "README.md"