Merge origin/main

Author: nicosuave

include/yardstick_ffi.h

@@ -252,6 +252,8 @@ char* yardstick_replace_range(
     const char* replacement
 );
 
+char* yardstick_qualify_expression(const char* expr, const char* qualifier);
+
 /**
  * Free a string allocated by yardstick functions.
  */

src/yardstick_extension.cpp

@@ -21,6 +21,7 @@ extern "C" {
     void yardstick_free_create_view_info(YardstickCreateViewInfo* info);
     char* yardstick_replace_range(const char* sql, uint32_t start, uint32_t end, const char* replacement);
     char* yardstick_apply_replacements(const char* sql, const YardstickReplacement* replacements, size_t count);
+    char* yardstick_qualify_expression(const char* expr, const char* qualifier);
     void yardstick_free_string(char* ptr);
     char* yardstick_expand_aggregate_call(
         const char* measure_name,
@@ -59,6 +60,7 @@ extern "C" {
         void (*free_create_view_info)(YardstickCreateViewInfo*),
         char* (*replace_range)(const char*, uint32_t, uint32_t, const char*),
         char* (*apply_replacements)(const char*, const YardstickReplacement*, size_t),
+        char* (*qualify_expression)(const char*, const char*),
         void (*free_string)(char*),
         char* (*expand_aggregate_call)(const char*, const char*, const YardstickAtModifier*, size_t, const char*, const char*, const char*, const char* const*, size_t)
     );
@@ -469,6 +471,7 @@ static void LoadInternal(ExtensionLoader &loader) {
         yardstick_free_create_view_info,
         yardstick_replace_range,
         yardstick_apply_replacements,
+        yardstick_qualify_expression,
         yardstick_free_string,
         yardstick_expand_aggregate_call
     );

src/yardstick_parser_ffi.cpp

@@ -87,6 +87,7 @@ static void FindAggregateCalls(ParsedExpression* expr, std::vector<AggregateCall
 static void CollectTablesFromTableRef(TableRef* ref, std::vector<YardstickTableRef>& tables);
 static bool ExpressionContainsAggregate(ParsedExpression* expr);
 static bool ExpressionContainsMeasureRef(ParsedExpression* expr);
+static void QualifyColumnRefs(ParsedExpression* expr, const std::string& qualifier);
 
 //=============================================================================
 // AST Walking: Find AGGREGATE() function calls
@@ -458,6 +459,95 @@ static bool ExpressionContainsMeasureRef(ParsedExpression* expr) {
     }
 }
 
+static void QualifyColumnRefs(ParsedExpression* expr, const std::string& qualifier) {
+    if (!expr) return;
+
+    switch (expr->expression_class) {
+        case ExpressionClass::COLUMN_REF: {
+            auto* col = static_cast<ColumnRefExpression*>(expr);
+            if (col->column_names.size() == 1) {
+                col->column_names.insert(col->column_names.begin(), qualifier);
+            }
+            break;
+        }
+        case ExpressionClass::FUNCTION: {
+            auto* func = static_cast<FunctionExpression*>(expr);
+            for (auto& child : func->children) {
+                QualifyColumnRefs(child.get(), qualifier);
+            }
+            if (func->filter) {
+                QualifyColumnRefs(func->filter.get(), qualifier);
+            }
+            break;
+        }
+        case ExpressionClass::COMPARISON: {
+            auto* comp = static_cast<ComparisonExpression*>(expr);
+            QualifyColumnRefs(comp->left.get(), qualifier);
+            QualifyColumnRefs(comp->right.get(), qualifier);
+            break;
+        }
+        case ExpressionClass::CONJUNCTION: {
+            auto* conj = static_cast<ConjunctionExpression*>(expr);
+            for (auto& child : conj->children) {
+                QualifyColumnRefs(child.get(), qualifier);
+            }
+            break;
+        }
+        case ExpressionClass::OPERATOR: {
+            auto* op = static_cast<OperatorExpression*>(expr);
+            for (auto& child : op->children) {
+                QualifyColumnRefs(child.get(), qualifier);
+            }
+            break;
+        }
+        case ExpressionClass::CASE: {
+            auto* case_expr = static_cast<CaseExpression*>(expr);
+            for (auto& check : case_expr->case_checks) {
+                QualifyColumnRefs(check.when_expr.get(), qualifier);
+                QualifyColumnRefs(check.then_expr.get(), qualifier);
+            }
+            if (case_expr->else_expr) {
+                QualifyColumnRefs(case_expr->else_expr.get(), qualifier);
+            }
+            break;
+        }
+        case ExpressionClass::CAST: {
+            auto* cast = static_cast<CastExpression*>(expr);
+            QualifyColumnRefs(cast->child.get(), qualifier);
+            break;
+        }
+        case ExpressionClass::SUBQUERY: {
+            auto* subq = static_cast<SubqueryExpression*>(expr);
+            if (subq->child) {
+                QualifyColumnRefs(subq->child.get(), qualifier);
+            }
+            break;
+        }
+        case ExpressionClass::WINDOW: {
+            auto* window = static_cast<WindowExpression*>(expr);
+            for (auto& child : window->children) {
+                QualifyColumnRefs(child.get(), qualifier);
+            }
+            for (auto& part : window->partitions) {
+                QualifyColumnRefs(part.get(), qualifier);
+            }
+            if (window->filter_expr) {
+                QualifyColumnRefs(window->filter_expr.get(), qualifier);
+            }
+            break;
+        }
+        case ExpressionClass::BETWEEN: {
+            auto* between = static_cast<BetweenExpression*>(expr);
+            QualifyColumnRefs(between->input.get(), qualifier);
+            QualifyColumnRefs(between->lower.get(), qualifier);
+            QualifyColumnRefs(between->upper.get(), qualifier);
+            break;
+        }
+        default:
+            break;
+    }
+}
+
 //=============================================================================
 // FFI Implementation: yardstick_find_aggregates
 //=============================================================================
@@ -919,6 +1009,34 @@ extern "C" char* yardstick_replace_range(
     return safe_strdup(result);
 }
 
+extern "C" char* yardstick_qualify_expression(const char* expr_str, const char* qualifier) {
+    if (!expr_str || !qualifier) return nullptr;
+
+    try {
+        auto expressions = Parser::ParseExpressionList(expr_str);
+        if (expressions.empty()) {
+            return safe_strdup(expr_str);
+        }
+
+        for (auto& expr : expressions) {
+            QualifyColumnRefs(expr.get(), qualifier);
+        }
+
+        if (expressions.size() == 1) {
+            return safe_strdup(expressions[0]->ToString());
+        }
+
+        std::string result;
+        for (size_t i = 0; i < expressions.size(); i++) {
+            if (i > 0) result += ", ";
+            result += expressions[i]->ToString();
+        }
+        return safe_strdup(result);
+    } catch (const std::exception&) {
+        return nullptr;
+    }
+}
+
 //=============================================================================
 // FFI Implementation: yardstick_free_string
 //=============================================================================

test/sql/measures.test

@@ -34,6 +34,36 @@ SEMANTIC SELECT year, region, AGGREGATE(revenue) FROM sales_v;
 2023	EU	75.0
 2023	US	150.0
 
+# =============================================================================
+# Test: CTE with AGGREGATE
+# =============================================================================
+
+query IIR rowsort
+SEMANTIC WITH a AS (
+    SELECT year, region, AGGREGATE(revenue) AS revenue
+    FROM sales_v
+)
+SELECT * FROM a;
+----
+2022	EU	50.0
+2022	US	100.0
+2023	EU	75.0
+2023	US	150.0
+
+# =============================================================================
+# Test: GROUP BY with extra spaces
+# =============================================================================
+
+query IIR rowsort
+SEMANTIC SELECT year, region, AGGREGATE(revenue) AT (ALL region) AS year_total
+FROM sales_v
+GROUP   BY year, region;
+----
+2022	EU	150.0
+2022	US	150.0
+2023	EU	225.0
+2023	US	225.0
+
 # =============================================================================
 # Test: AT (ALL dimension) - remove dimension from context
 # =============================================================================
@@ -794,6 +824,34 @@ FROM daily_orders_v
 2	320.0	840.0
 3	270.0	840.0
 
+# =============================================================================
+# Test: GROUP BY alias for expression dimension
+# =============================================================================
+
+statement ok
+CREATE TABLE monthly_sales (order_date DATE, region TEXT, amount DOUBLE);
+
+statement ok
+INSERT INTO monthly_sales VALUES
+    ('2023-01-05', 'US', 100), ('2023-01-12', 'EU', 50),
+    ('2023-02-03', 'US', 200), ('2023-02-20', 'EU', 20);
+
+statement ok
+CREATE VIEW monthly_sales_v AS
+SELECT DATE_TRUNC('month', order_date) AS month, region, SUM(amount) AS MEASURE revenue
+FROM monthly_sales
+GROUP BY DATE_TRUNC('month', order_date), region;
+
+query IIRR rowsort
+SEMANTIC SELECT month, region, AGGREGATE(revenue), AGGREGATE(revenue) AT (ALL region) AS month_total
+FROM monthly_sales_v
+;
+----
+2023-01-01	EU	50.0	150.0
+2023-01-01	US	100.0	150.0
+2023-02-01	EU	20.0	220.0
+2023-02-01	US	200.0	220.0
+
 # =============================================================================
 # Test: Multi-fact JOINs (wide tables)
 # =============================================================================
@@ -851,6 +909,40 @@ FROM fact_orders_v o JOIN fact_returns_v r ON o.year = r.year AND o.region = r.r
 2023	EU	75.0	225.0
 2023	US	150.0	225.0
 
+# =============================================================================
+# Test: JOIN with extra dimension from second table
+# =============================================================================
+
+statement ok
+CREATE TABLE salesdetails (year INT, region TEXT, product TEXT, amount DOUBLE);
+
+statement ok
+INSERT INTO salesdetails VALUES
+    (2022, 'US', 'Shoes', 2), (2022, 'US', 'Cars', 1),
+    (2022, 'EU', 'Shoes', 3),
+    (2023, 'US', 'Shoes', 4), (2023, 'US', 'Cars', 2),
+    (2023, 'EU', 'Cars', 5);
+
+statement ok
+CREATE VIEW salesdetails_v AS
+SELECT year, region, product, SUM(amount) AS MEASURE quantity
+FROM salesdetails;
+
+query IIIRRR rowsort
+SEMANTIC SELECT s.year, s.region, sd.product,
+    AGGREGATE(revenue) AS year_sales_revenue,
+    AGGREGATE(revenue) AT (ALL year) AS region_total,
+    AGGREGATE(quantity) AS product_qty
+FROM sales_v s JOIN salesdetails_v sd ON s.year = sd.year AND s.region = sd.region
+;
+----
+2022	EU	Shoes	50.0	125.0	3.0
+2022	US	Cars	100.0	250.0	1.0
+2022	US	Shoes	100.0	250.0	2.0
+2023	EU	Cars	75.0	125.0	5.0
+2023	US	Cars	150.0	250.0	2.0
+2023	US	Shoes	150.0	250.0	4.0
+
 # =============================================================================
 # Test: SET reaches beyond WHERE clause (paper semantics)
 # Per paper: SET should evaluate over data removed by outer WHERE clause

yardstick-rs/src/parser_ffi.rs

@@ -168,6 +168,7 @@ type FnParseCreateView = unsafe extern "C" fn(*const c_char) -> *mut YardstickCr
 type FnFreeCreateViewInfo = unsafe extern "C" fn(*mut YardstickCreateViewInfo);
 type FnReplaceRange = unsafe extern "C" fn(*const c_char, u32, u32, *const c_char) -> *mut c_char;
 type FnApplyReplacements = unsafe extern "C" fn(*const c_char, *const YardstickReplacement, usize) -> *mut c_char;
+type FnQualifyExpression = unsafe extern "C" fn(*const c_char, *const c_char) -> *mut c_char;
 type FnFreeString = unsafe extern "C" fn(*mut c_char);
 type FnExpandAggregateCall = unsafe extern "C" fn(
     *const c_char, *const c_char, *const YardstickAtModifier, usize,
@@ -185,6 +186,7 @@ static FN_PARSE_CREATE_VIEW: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
 static FN_FREE_CREATE_VIEW_INFO: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
 static FN_REPLACE_RANGE: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
 static FN_APPLY_REPLACEMENTS: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
+static FN_QUALIFY_EXPRESSION: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
 static FN_FREE_STRING: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
 static FN_EXPAND_AGGREGATE_CALL: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
 
@@ -201,6 +203,7 @@ pub extern "C" fn yardstick_init_parser_ffi(
     free_create_view_info: FnFreeCreateViewInfo,
     replace_range: FnReplaceRange,
     apply_replacements: FnApplyReplacements,
+    qualify_expression: FnQualifyExpression,
     free_string: FnFreeString,
     expand_aggregate_call: FnExpandAggregateCall,
 ) {
@@ -214,6 +217,7 @@ pub extern "C" fn yardstick_init_parser_ffi(
     FN_FREE_CREATE_VIEW_INFO.store(free_create_view_info as *mut (), Ordering::SeqCst);
     FN_REPLACE_RANGE.store(replace_range as *mut (), Ordering::SeqCst);
     FN_APPLY_REPLACEMENTS.store(apply_replacements as *mut (), Ordering::SeqCst);
+    FN_QUALIFY_EXPRESSION.store(qualify_expression as *mut (), Ordering::SeqCst);
     FN_FREE_STRING.store(free_string as *mut (), Ordering::SeqCst);
     FN_EXPAND_AGGREGATE_CALL.store(expand_aggregate_call as *mut (), Ordering::SeqCst);
 }
@@ -790,6 +794,27 @@ pub fn apply_replacements(sql: &str, replacements: &[Replacement]) -> Result<Str
     }
 }
 
+pub fn qualify_expression(expr: &str, qualifier: &str) -> Result<String, String> {
+    let expr_ptr = CString::new(expr).map_err(|e| format!("Invalid expression string: {e}"))?;
+    let qualifier_ptr = CString::new(qualifier).map_err(|e| format!("Invalid qualifier: {e}"))?;
+
+    let fn_ptr = FN_QUALIFY_EXPRESSION.load(Ordering::SeqCst);
+    if fn_ptr.is_null() {
+        return Err("Parser FFI not initialized".to_string());
+    }
+
+    unsafe {
+        let f: FnQualifyExpression = std::mem::transmute(fn_ptr);
+        let result_ptr = f(expr_ptr.as_ptr(), qualifier_ptr.as_ptr());
+        if result_ptr.is_null() {
+            return Err("Failed to qualify expression".to_string());
+        }
+        let result = c_str_to_string(result_ptr).unwrap_or_default();
+        yardstick_free_string(result_ptr);
+        Ok(result)
+    }
+}
+
 /// Expand a single AGGREGATE() call to SQL.
 ///
 /// Generates a correlated subquery for the measure based on the aggregation function
@@ -987,6 +1012,17 @@ mod tests {
         assert_eq!(result, "SELECT baz FROM bar");
     }
 
+    #[test]
+    #[ignore = "requires C++ library to be linked"]
+    fn test_qualify_expression() {
+        let result = qualify_expression("year between date '2023-01-01' and date '2025-01-01'", "_inner")
+            .unwrap();
+        assert_eq!(
+            result,
+            "_inner.year BETWEEN DATE '2023-01-01' AND DATE '2025-01-01'"
+        );
+    }
+
     #[test]
     #[ignore = "requires C++ library to be linked"]
     fn test_expand_aggregate_call() {