Update queries.py

queries.py

@@ -1,6 +1,7 @@
 """
 Parameterized query builders for all metrics.
 Uses config.py mapping layer for table/column names.
+Updated for Hytch database schema.
 """
 
 from typing import Optional, Dict, Any, List
@@ -24,34 +25,30 @@ class QueryBuilder:
         self.history_table = get_table_name("TripHistoryDetail")
         self.address_table = get_table_name("HYUserAddress")
         self.transaction_table = get_table_name("HYTransaction")
+        self.participants_table = get_table_name("HYTripParticipant")
     
     def _build_trip_filters(
         self,
-        driver_type: Optional[str] = None,
+        driver_type: Optional[int] = None,
         is_solo: Optional[bool] = None,
-        status: Optional[int] = None,
-        sponsor_id: Optional[int] = None
+        status: Optional[int] = None
     ) -> tuple[str, Dict[str, Any]]:
         """Build WHERE clause and params for trip filters."""
         conditions = []
         params = {}
         
-        if driver_type:
-            conditions.append(f"t.{get_column_name(self.trips_table, 'driver_type')} = :driver_type")
+        if driver_type is not None:
+            conditions.append("t.driver_type = :driver_type")
             params['driver_type'] = driver_type
         
         if is_solo is not None:
-            conditions.append(f"t.{get_column_name(self.trips_table, 'is_solo')} = :is_solo")
+            conditions.append("t.is_solo_hytch = :is_solo")
             params['is_solo'] = is_solo
         
-        if status:
-            conditions.append(f"t.{get_column_name(self.trips_table, 'status')} = :status")
+        if status is not None:
+            conditions.append("t.status = :status")
             params['status'] = status
         
-        if sponsor_id:
-            conditions.append(f"t.{get_column_name(self.trips_table, 'sponsor_id')} = :sponsor_id")
-            params['sponsor_id'] = sponsor_id
-        
         where_clause = " AND " + " AND ".join(conditions) if conditions else ""
         return where_clause, params
     
@@ -67,19 +64,18 @@ class QueryBuilder:
     ) -> tuple[str, Dict[str, Any]]:
         """Query for new registered users over time."""
         date_trunc = {
-            "day": "CAST({col} AS DATE)",
-            "week": "DATEADD(week, DATEDIFF(week, 0, {col}), 0)",
-            "month": "DATEADD(month, DATEDIFF(month, 0, {col}), 0)"
+            "day": "CAST(u.created_at AS DATE)",
+            "week": "DATEADD(week, DATEDIFF(week, 0, u.created_at), 0)",
+            "month": "DATEADD(month, DATEDIFF(month, 0, u.created_at), 0)"
         }
         
-        created_col = get_column_name(self.users_table, "created_at")
-        trunc_expr = date_trunc[granularity].format(col=f"u.{created_col}")
+        trunc_expr = date_trunc.get(granularity, date_trunc["day"])
         
         query = f"""
         SELECT {trunc_expr} AS period,
                COUNT(*) AS new_users
         FROM {self.users_table} u
-        WHERE u.{created_col} BETWEEN :start_date AND :end_date
+        WHERE u.created_at BETWEEN :start_date AND :end_date
         GROUP BY {trunc_expr}
         ORDER BY period
         """
@@ -93,22 +89,23 @@ class QueryBuilder:
         end_date: datetime,
         granularity: str = "day"
     ) -> tuple[str, Dict[str, Any]]:
-        """Query for newly verified users."""
+        """Query for users with completed profiles (using complete_profile_code)."""
         date_trunc = {
-            "day": "CAST({col} AS DATE)",
-            "week": "DATEADD(week, DATEDIFF(week, 0, {col}), 0)",
-            "month": "DATEADD(month, DATEDIFF(month, 0, {col}), 0)"
+            "day": "CAST(u.updated_at AS DATE)",
+            "week": "DATEADD(week, DATEDIFF(week, 0, u.updated_at), 0)",
+            "month": "DATEADD(month, DATEDIFF(month, 0, u.updated_at), 0)"
         }
         
-        verified_col = get_column_name(self.users_table, "verified_at")
-        trunc_expr = date_trunc[granularity].format(col=f"u.{verified_col}")
+        trunc_expr = date_trunc.get(granularity, date_trunc["day"])
         
+        # Users with complete profiles (complete_profile_code is set)
         query = f"""
         SELECT {trunc_expr} AS period,
                COUNT(*) AS verified_users
         FROM {self.users_table} u
-        WHERE u.{verified_col} BETWEEN :start_date AND :end_date
-          AND u.{verified_col} IS NOT NULL
+        WHERE u.updated_at BETWEEN :start_date AND :end_date
+          AND u.complete_profile_code IS NOT NULL
+          AND u.complete_profile_code != ''
         GROUP BY {trunc_expr}
         ORDER BY period
         """
@@ -124,25 +121,21 @@ class QueryBuilder:
     ) -> tuple[str, Dict[str, Any]]:
         """Query for users activated by their first completed trip."""
         date_trunc = {
-            "day": "CAST({col} AS DATE)",
-            "week": "DATEADD(week, DATEDIFF(week, 0, {col}), 0)",
-            "month": "DATEADD(month, DATEDIFF(month, 0, {col}), 0)"
+            "day": "CAST(f.first_trip_at AS DATE)",
+            "week": "DATEADD(week, DATEDIFF(week, 0, f.first_trip_at), 0)",
+            "month": "DATEADD(month, DATEDIFF(month, 0, f.first_trip_at), 0)"
         }
         
-        finished_col = get_column_name(self.trips_table, "finished_on")
-        owner_col = get_column_name(self.trips_table, "user_id_owner")
-        status_col = get_column_name(self.trips_table, "status")
-        
-        trunc_expr = date_trunc[granularity].format(col="f.first_trip_at")
+        trunc_expr = date_trunc.get(granularity, date_trunc["day"])
         
         query = f"""
         WITH first_trip AS (
-            SELECT t.{owner_col} AS user_id,
-                   MIN(t.{finished_col}) AS first_trip_at
+            SELECT t.owner_user_id AS user_id,
+                   MIN(t.finished_at) AS first_trip_at
             FROM {self.trips_table} t
-            WHERE t.{status_col} = :completed_status
-              AND t.{finished_col} IS NOT NULL
-            GROUP BY t.{owner_col}
+            WHERE t.status = :completed_status
+              AND t.finished_at IS NOT NULL
+            GROUP BY t.owner_user_id
         )
         SELECT {trunc_expr} AS period,
                COUNT(*) AS activated_users
@@ -165,15 +158,11 @@ class QueryBuilder:
         window_days: int = 30
     ) -> tuple[str, Dict[str, Any]]:
         """Query for rolling active users (users with trips in last N days)."""
-        finished_col = get_column_name(self.trips_table, "finished_on")
-        owner_col = get_column_name(self.trips_table, "user_id_owner")
-        status_col = get_column_name(self.trips_table, "status")
-        
         query = f"""
-        SELECT COUNT(DISTINCT t.{owner_col}) AS active_users
+        SELECT COUNT(DISTINCT t.owner_user_id) AS active_users
         FROM {self.trips_table} t
-        WHERE t.{finished_col} BETWEEN DATEADD(day, -:window_days, :as_of_date) AND :as_of_date
-          AND t.{status_col} = :completed_status
+        WHERE t.finished_at BETWEEN DATEADD(day, -:window_days, :as_of_date) AND :as_of_date
+          AND t.status = :completed_status
         """
         
         params = {
@@ -190,25 +179,19 @@ class QueryBuilder:
         retention_days: int = 7
     ) -> tuple[str, Dict[str, Any]]:
         """Query for cohort retention analysis."""
-        created_col = get_column_name(self.users_table, "created_at")
-        id_col = get_column_name(self.users_table, "id")
-        finished_col = get_column_name(self.trips_table, "finished_on")
-        owner_col = get_column_name(self.trips_table, "user_id_owner")
-        status_col = get_column_name(self.trips_table, "status")
-        
         query = f"""
         WITH cohort AS (
-            SELECT u.{id_col} AS user_id,
-                   CAST(u.{created_col} AS DATE) AS cohort_date
+            SELECT u.user_id,
+                   CAST(u.created_at AS DATE) AS cohort_date
             FROM {self.users_table} u
-            WHERE u.{created_col} BETWEEN :cohort_start AND :cohort_end
+            WHERE u.created_at BETWEEN :cohort_start AND :cohort_end
         ),
         activity AS (
-            SELECT t.{owner_col} AS user_id,
-                   CAST(t.{finished_col} AS DATE) AS active_date
+            SELECT t.owner_user_id AS user_id,
+                   CAST(t.finished_at AS DATE) AS active_date
             FROM {self.trips_table} t
-            WHERE t.{status_col} = :completed_status
-              AND t.{finished_col} IS NOT NULL
+            WHERE t.status = :completed_status
+              AND t.finished_at IS NOT NULL
         )
         SELECT c.cohort_date,
                COUNT(DISTINCT c.user_id) AS cohort_size,
@@ -241,29 +224,26 @@ class QueryBuilder:
         start_date: datetime,
         end_date: datetime,
         granularity: str = "day",
-        driver_type: Optional[str] = None,
+        driver_type: Optional[int] = None,
         is_solo: Optional[bool] = None
     ) -> tuple[str, Dict[str, Any]]:
         """Query for trip volume over time with optional filters."""
         date_trunc = {
-            "day": "CAST({col} AS DATE)",
-            "week": "DATEADD(week, DATEDIFF(week, 0, {col}), 0)",
-            "month": "DATEADD(month, DATEDIFF(month, 0, {col}), 0)"
+            "day": "CAST(thd.completed_on AS DATE)",
+            "week": "DATEADD(week, DATEDIFF(week, 0, thd.completed_on), 0)",
+            "month": "DATEADD(month, DATEDIFF(month, 0, thd.completed_on), 0)"
         }
         
-        completed_col = get_column_name(self.history_table, "completed_on")
-        trip_id_col = get_column_name(self.history_table, "trip_id")
-        
-        trunc_expr = date_trunc[granularity].format(col=f"thd.{completed_col}")
+        trunc_expr = date_trunc.get(granularity, date_trunc["day"])
         
         trip_filters, filter_params = self._build_trip_filters(driver_type, is_solo)
         
         query = f"""
         SELECT {trunc_expr} AS period,
-               COUNT(DISTINCT thd.{trip_id_col}) AS trip_count
+               COUNT(DISTINCT thd.trip_id) AS trip_count
         FROM {self.history_table} thd
-        JOIN {self.trips_table} t ON t.{get_column_name(self.trips_table, 'id')} = thd.{trip_id_col}
-        WHERE thd.{completed_col} BETWEEN :start_date AND :end_date
+        JOIN {self.trips_table} t ON t.trip_id = thd.trip_id
+        WHERE thd.completed_on BETWEEN :start_date AND :end_date
           {trip_filters}
         GROUP BY {trunc_expr}
         ORDER BY period
@@ -277,35 +257,31 @@ class QueryBuilder:
         self,
         start_date: datetime,
         end_date: datetime,
-        driver_type: Optional[str] = None,
+        driver_type: Optional[int] = None,
         is_solo: Optional[bool] = None
     ) -> tuple[str, Dict[str, Any]]:
         """Query for aggregate trip metrics (distance, impact, etc.)."""
-        completed_col = get_column_name(self.history_table, "completed_on")
-        distance_col = get_column_name(self.history_table, "distance_miles")
-        shared_col = get_column_name(self.history_table, "shared_miles")
-        co2_col = get_column_name(self.history_table, "co2_reduced")
-        nox_col = get_column_name(self.history_table, "nox_reduced")
-        pm25_col = get_column_name(self.history_table, "pm25_reduced")
-        points_col = get_column_name(self.history_table, "points")
-        trip_id_col = get_column_name(self.history_table, "trip_id")
-        
         trip_filters, filter_params = self._build_trip_filters(driver_type, is_solo)
         
         query = f"""
         SELECT 
-            COUNT(DISTINCT thd.{trip_id_col}) AS total_trips,
-            AVG(thd.{distance_col}) AS avg_distance_miles,
-            SUM(thd.{distance_col}) AS total_distance_miles,
-            SUM(thd.{shared_col}) AS total_shared_miles,
-            SUM(thd.{co2_col}) AS total_co2_reduced,
-            AVG(thd.{co2_col}) AS avg_co2_per_trip,
-            SUM(thd.{nox_col}) AS total_nox_reduced,
-            SUM(thd.{pm25_col}) AS total_pm25_reduced,
-            SUM(thd.{points_col}) AS total_points
+            COUNT(DISTINCT thd.trip_id) AS total_trips,
+            AVG(thd.distance_miles) AS avg_distance_miles,
+            SUM(thd.distance_miles) AS total_distance_miles,
+            SUM(thd.shared_miles) AS total_shared_miles,
+            SUM(thd.co2_reduced) AS total_co2_reduced,
+            AVG(thd.co2_reduced) AS avg_co2_per_trip,
+            SUM(thd.nox_reduced) AS total_nox_reduced,
+            SUM(thd.pm25_reduced) AS total_pm25_reduced,
+            SUM(thd.pm10_reduced) AS total_pm10_reduced,
+            SUM(thd.voc_reduced) AS total_voc_reduced,
+            SUM(thd.co_reduced) AS total_co_reduced,
+            SUM(thd.trees_saved) AS total_trees_saved,
+            SUM(thd.points) AS total_points,
+            SUM(thd.gas_savings) AS total_gas_savings
         FROM {self.history_table} thd
-        JOIN {self.trips_table} t ON t.{get_column_name(self.trips_table, 'id')} = thd.{trip_id_col}
-        WHERE thd.{completed_col} BETWEEN :start_date AND :end_date
+        JOIN {self.trips_table} t ON t.trip_id = thd.trip_id
+        WHERE thd.completed_on BETWEEN :start_date AND :end_date
           {trip_filters}
         """
         
@@ -319,18 +295,20 @@ class QueryBuilder:
         end_date: datetime
     ) -> tuple[str, Dict[str, Any]]:
         """Query for distribution of trips by driver type."""
-        completed_col = get_column_name(self.history_table, "completed_on")
-        trip_id_col = get_column_name(self.history_table, "trip_id")
-        driver_type_col = get_column_name(self.trips_table, "driver_type")
-        
         query = f"""
-        SELECT t.{driver_type_col} AS driver_type,
-               COUNT(DISTINCT thd.{trip_id_col}) AS trip_count
+        SELECT 
+            CASE t.driver_type
+                WHEN 0 THEN 'Owner'
+                WHEN 1 THEN 'Participant'
+                WHEN 2 THEN 'External'
+                ELSE 'Unknown'
+            END AS driver_type,
+            COUNT(DISTINCT thd.trip_id) AS trip_count
         FROM {self.history_table} thd
-        JOIN {self.trips_table} t ON t.{get_column_name(self.trips_table, 'id')} = thd.{trip_id_col}
-        WHERE thd.{completed_col} BETWEEN :start_date AND :end_date
-          AND t.{driver_type_col} IS NOT NULL
-        GROUP BY t.{driver_type_col}
+        JOIN {self.trips_table} t ON t.trip_id = thd.trip_id
+        WHERE thd.completed_on BETWEEN :start_date AND :end_date
+          AND t.driver_type IS NOT NULL
+        GROUP BY t.driver_type
         ORDER BY trip_count DESC
         """
         
@@ -343,18 +321,14 @@ class QueryBuilder:
         end_date: datetime
     ) -> tuple[str, Dict[str, Any]]:
         """Query for solo vs shared trip distribution."""
-        completed_col = get_column_name(self.history_table, "completed_on")
-        trip_id_col = get_column_name(self.history_table, "trip_id")
-        is_solo_col = get_column_name(self.trips_table, "is_solo")
-        
         query = f"""
         SELECT 
-            CASE WHEN t.{is_solo_col} = 1 THEN 'Solo' ELSE 'Shared' END AS trip_type,
-            COUNT(DISTINCT thd.{trip_id_col}) AS trip_count
+            CASE WHEN t.is_solo_hytch = 1 THEN 'Solo' ELSE 'Shared' END AS trip_type,
+            COUNT(DISTINCT thd.trip_id) AS trip_count
         FROM {self.history_table} thd
-        JOIN {self.trips_table} t ON t.{get_column_name(self.trips_table, 'id')} = thd.{trip_id_col}
-        WHERE thd.{completed_col} BETWEEN :start_date AND :end_date
-        GROUP BY t.{is_solo_col}
+        JOIN {self.trips_table} t ON t.trip_id = thd.trip_id
+        WHERE thd.completed_on BETWEEN :start_date AND :end_date
+        GROUP BY t.is_solo_hytch
         """
         
         params = {"start_date": start_date, "end_date": end_date}
@@ -366,19 +340,15 @@ class QueryBuilder:
         end_date: datetime
     ) -> tuple[str, Dict[str, Any]]:
         """Query for trip completion rate."""
-        started_col = get_column_name(self.trips_table, "started_on")
-        status_col = get_column_name(self.trips_table, "status")
-        id_col = get_column_name(self.trips_table, "id")
-        
         query = f"""
         SELECT 
-            COUNT(DISTINCT t.{id_col}) AS total_started,
-            COUNT(DISTINCT CASE WHEN t.{status_col} = :completed_status THEN t.{id_col} END) AS completed,
-            CAST(COUNT(DISTINCT CASE WHEN t.{status_col} = :completed_status THEN t.{id_col} END) AS FLOAT) * 100.0 
-                / NULLIF(COUNT(DISTINCT t.{id_col}), 0) AS completion_rate
+            COUNT(DISTINCT t.trip_id) AS total_started,
+            COUNT(DISTINCT CASE WHEN t.status = :completed_status THEN t.trip_id END) AS completed,
+            CAST(COUNT(DISTINCT CASE WHEN t.status = :completed_status THEN t.trip_id END) AS FLOAT) * 100.0 
+                / NULLIF(COUNT(DISTINCT t.trip_id), 0) AS completion_rate
         FROM {self.trips_table} t
-        WHERE t.{started_col} BETWEEN :start_date AND :end_date
-          AND t.{started_col} IS NOT NULL
+        WHERE t.started_at BETWEEN :start_date AND :end_date
+          AND t.started_at IS NOT NULL
         """
         
         params = {
@@ -388,31 +358,45 @@ class QueryBuilder:
         }
         return query, params
     
+    def get_trip_impact_grade_distribution_query(
+        self,
+        start_date: datetime,
+        end_date: datetime
+    ) -> tuple[str, Dict[str, Any]]:
+        """Query for distribution of trips by environmental impact grade."""
+        query = f"""
+        SELECT 
+            thd.trip_impact_grade AS grade,
+            COUNT(*) AS trip_count
+        FROM {self.history_table} thd
+        WHERE thd.completed_on BETWEEN :start_date AND :end_date
+          AND thd.trip_impact_grade IS NOT NULL
+        GROUP BY thd.trip_impact_grade
+        ORDER BY thd.trip_impact_grade
+        """
+        
+        params = {"start_date": start_date, "end_date": end_date}
+        return query, params
+    
     # =========================================================================
     # GEOGRAPHY QUERIES
     # =========================================================================
     
     def get_user_locations_query(self) -> tuple[str, Dict[str, Any]]:
         """Query for user home locations (for heat map)."""
-        user_id_col = get_column_name(self.address_table, "user_id")
-        type_col = get_column_name(self.address_table, "address_type")
-        lat_col = get_column_name(self.address_table, "latitude")
-        lon_col = get_column_name(self.address_table, "longitude")
-        city_col = get_column_name(self.address_table, "city")
-        state_col = get_column_name(self.address_table, "state")
-        
         query = f"""
         SELECT 
-            ua.{lat_col} AS latitude,
-            ua.{lon_col} AS longitude,
-            ua.{city_col} AS city,
-            ua.{state_col} AS state,
-            COUNT(DISTINCT ua.{user_id_col}) AS user_count
+            ua.latitude,
+            ua.longitude,
+            ua.city,
+            ua.state,
+            ua.zip_code,
+            COUNT(DISTINCT ua.user_id) AS user_count
         FROM {self.address_table} ua
-        WHERE ua.{type_col} = 'home'
-          AND ua.{lat_col} IS NOT NULL
-          AND ua.{lon_col} IS NOT NULL
-        GROUP BY ua.{lat_col}, ua.{lon_col}, ua.{city_col}, ua.{state_col}
+        WHERE ua.address_type = 'home'
+          AND ua.latitude IS NOT NULL
+          AND ua.longitude IS NOT NULL
+        GROUP BY ua.latitude, ua.longitude, ua.city, ua.state, ua.zip_code
         """
         
         return query, {}
@@ -424,34 +408,29 @@ class QueryBuilder:
         level: str = "state"  # state, city, or zip
     ) -> tuple[str, Dict[str, Any]]:
         """Query for geographic distribution of users or trips."""
-        user_id_col = get_column_name(self.users_table, "id")
-        type_col = get_column_name(self.address_table, "address_type")
-        city_col = get_column_name(self.address_table, "city")
-        state_col = get_column_name(self.address_table, "state")
-        zip_col = get_column_name(self.address_table, "zip_code")
-        addr_user_col = get_column_name(self.address_table, "user_id")
-        created_col = get_column_name(self.users_table, "created_at")
-        
-        group_col = {
-            "state": state_col,
-            "city": f"ua.{city_col}, ua.{state_col}",
-            "zip": zip_col
-        }.get(level, state_col)
+        group_cols = {
+            "state": "ua.state",
+            "city": "ua.city, ua.state",
+            "zip": "ua.zip_code"
+        }
         
         select_cols = {
-            "state": f"ua.{state_col} AS region",
-            "city": f"ua.{city_col} AS city, ua.{state_col} AS state",
-            "zip": f"ua.{zip_col} AS zip_code"
-        }.get(level, f"ua.{state_col} AS region")
+            "state": "ua.state AS region",
+            "city": "ua.city AS city, ua.state AS state",
+            "zip": "ua.zip_code AS zip_code"
+        }
+        
+        group_col = group_cols.get(level, group_cols["state"])
+        select_col = select_cols.get(level, select_cols["state"])
         
         query = f"""
         SELECT 
-            {select_cols},
-            COUNT(DISTINCT u.{user_id_col}) AS user_count
+            {select_col},
+            COUNT(DISTINCT u.user_id) AS user_count
         FROM {self.users_table} u
-        JOIN {self.address_table} ua ON ua.{addr_user_col} = u.{user_id_col}
-        WHERE u.{created_col} BETWEEN :start_date AND :end_date
-          AND ua.{type_col} = 'home'
+        JOIN {self.address_table} ua ON ua.user_id = u.user_id
+        WHERE u.created_at BETWEEN :start_date AND :end_date
+          AND ua.address_type = 'home'
         GROUP BY {group_col}
         ORDER BY user_count DESC
         """
@@ -459,6 +438,28 @@ class QueryBuilder:
         params = {"start_date": start_date, "end_date": end_date}
         return query, params
     
+    def get_trip_locations_query(
+        self,
+        start_date: datetime,
+        end_date: datetime
+    ) -> tuple[str, Dict[str, Any]]:
+        """Query for trip start locations from location_history."""
+        query = f"""
+        SELECT 
+            lh.latitude,
+            lh.longitude,
+            COUNT(DISTINCT lh.trip_id) AS trip_count
+        FROM location_history lh
+        JOIN {self.trips_table} t ON t.trip_id = lh.trip_id
+        WHERE t.started_at BETWEEN :start_date AND :end_date
+          AND lh.latitude IS NOT NULL
+          AND lh.longitude IS NOT NULL
+        GROUP BY lh.latitude, lh.longitude
+        """
+        
+        params = {"start_date": start_date, "end_date": end_date}
+        return query, params
+    
     # =========================================================================
     # TRANSACTION/REWARD QUERIES
     # =========================================================================
@@ -468,37 +469,32 @@ class QueryBuilder:
         start_date: datetime,
         end_date: datetime,
         granularity: str = "day",
-        transaction_type: Optional[str] = None
+        transaction_type: Optional[int] = None
     ) -> tuple[str, Dict[str, Any]]:
         """Query for transaction volume and amounts over time."""
         date_trunc = {
-            "day": "CAST({col} AS DATE)",
-            "week": "DATEADD(week, DATEDIFF(week, 0, {col}), 0)",
-            "month": "DATEADD(month, DATEDIFF(month, 0, {col}), 0)"
+            "day": "CAST(tr.created_at AS DATE)",
+            "week": "DATEADD(week, DATEDIFF(week, 0, tr.created_at), 0)",
+            "month": "DATEADD(month, DATEDIFF(month, 0, tr.created_at), 0)"
         }
         
-        date_col = get_column_name(self.transaction_table, "date")
-        amount_col = get_column_name(self.transaction_table, "amount")
-        type_col = get_column_name(self.transaction_table, "type")
-        id_col = get_column_name(self.transaction_table, "id")
-        
-        trunc_expr = date_trunc[granularity].format(col=f"tr.{date_col}")
+        trunc_expr = date_trunc.get(granularity, date_trunc["day"])
         
-        type_filter = f"AND tr.{type_col} = :transaction_type" if transaction_type else ""
+        type_filter = "AND tr.type = :transaction_type" if transaction_type is not None else ""
         
         query = f"""
         SELECT {trunc_expr} AS period,
-               COUNT(DISTINCT tr.{id_col}) AS transaction_count,
-               SUM(tr.{amount_col}) AS total_amount
+               COUNT(DISTINCT tr.transaction_id) AS transaction_count,
+               SUM(tr.amount) AS total_amount
         FROM {self.transaction_table} tr
-        WHERE tr.{date_col} BETWEEN :start_date AND :end_date
+        WHERE tr.created_at BETWEEN :start_date AND :end_date
           {type_filter}
         GROUP BY {trunc_expr}
         ORDER BY period
         """
         
         params = {"start_date": start_date, "end_date": end_date}
-        if transaction_type:
+        if transaction_type is not None:
             params["transaction_type"] = transaction_type
         
         return query, params
@@ -508,22 +504,48 @@ class QueryBuilder:
         start_date: datetime,
         end_date: datetime
     ) -> tuple[str, Dict[str, Any]]:
-        """Query for sponsor-level transaction/reward activity."""
-        date_col = get_column_name(self.transaction_table, "date")
-        amount_col = get_column_name(self.transaction_table, "amount")
-        sponsor_col = get_column_name(self.transaction_table, "sponsor_id")
-        id_col = get_column_name(self.transaction_table, "id")
+        """Query for sponsor-level point activity."""
+        query = f"""
+        SELECT 
+            ms.sponsor_id,
+            ms.name AS sponsor_name,
+            COUNT(DISTINCT usa.user_id) AS user_count,
+            SUM(usa.points_earned) AS total_points
+        FROM market_sponsors ms
+        JOIN user_sponsor_associations usa ON usa.sponsor_id = ms.sponsor_id
+        WHERE usa.created_at BETWEEN :start_date AND :end_date
+          AND ms.is_active = 1
+        GROUP BY ms.sponsor_id, ms.name
+        ORDER BY total_points DESC
+        """
         
+        params = {"start_date": start_date, "end_date": end_date}
+        return query, params
+    
+    # =========================================================================
+    # PARTICIPANT QUERIES
+    # =========================================================================
+    
+    def get_participant_stats_query(
+        self,
+        start_date: datetime,
+        end_date: datetime
+    ) -> tuple[str, Dict[str, Any]]:
+        """Query for trip participant statistics."""
         query = f"""
         SELECT 
-            tr.{sponsor_col} AS sponsor_id,
-            COUNT(DISTINCT tr.{id_col}) AS transaction_count,
-            SUM(tr.{amount_col}) AS total_amount
-        FROM {self.transaction_table} tr
-        WHERE tr.{date_col} BETWEEN :start_date AND :end_date
-          AND tr.{sponsor_col} IS NOT NULL
-        GROUP BY tr.{sponsor_col}
-        ORDER BY total_amount DESC
+            COUNT(DISTINCT tp.participant_id) AS total_participations,
+            COUNT(DISTINCT tp.user_id) AS unique_participants,
+            COUNT(DISTINCT tp.trip_id) AS trips_with_participants,
+            AVG(participants_per_trip.participant_count) AS avg_participants_per_trip
+        FROM {self.participants_table} tp
+        JOIN {self.trips_table} t ON t.trip_id = tp.trip_id
+        JOIN (
+            SELECT trip_id, COUNT(*) AS participant_count
+            FROM {self.participants_table}
+            GROUP BY trip_id
+        ) participants_per_trip ON participants_per_trip.trip_id = tp.trip_id
+        WHERE t.started_at BETWEEN :start_date AND :end_date
         """
         
         params = {"start_date": start_date, "end_date": end_date}
@@ -531,4 +553,4 @@ class QueryBuilder:
 
 
 # Global query builder instance
-query_builder = QueryBuilder()
+query_builder = QueryBuilder()