Struct Query 

pub struct Query<'a, T: 'static> { /* private fields */ }

A query builder for filtering, selecting, ordering, grouping, and aggregating data.

Type Parameters

• 'a - The lifetime of the data being queried
• T - The type of items in the collection

Example

let products = vec![/* ... */];
let query = Query::new(&products)
    .where_(Product::price_r(), |&price| price < 100.0)
    .order_by_float(Product::price_r());

Implementations

impl<'a, T: 'static + Clone> Query<'a, T>

pub fn new(data: &'a [T]) -> Self

Creates a new query from a slice of data.

Arguments

• data - A slice of items to query

Example

let query = Query::new(&products);

Examples found in repository

examples/doc_examples.rs (line 42)

fn main() {
    println!("Testing documentation examples...\n");

    // Example from README - Quick Start
    println!("Test 1: README Quick Start Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let affordable_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price < 100.0);
        let affordable_electronics = affordable_query.all();

        println!("  Found {} affordable electronics ✅", affordable_electronics.len());
    }

    // Example from README - Filtering
    println!("\nTest 2: Filtering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");
        let electronics = electronics_query.all();

        println!("  Found {} electronics ✅", electronics.len());
    }

    // Example from README - Selecting
    println!("\nTest 3: Selecting Fields Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let names: Vec<String> = Query::new(&products)
            .select(Product::name_r());

        println!("  Selected {} names ✅", names.len());
    }

    // Example from README - Ordering
    println!("\nTest 4: Ordering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let by_price = Query::new(&products).order_by_float(Product::price_r());
        println!("  Ordered {} products ✅", by_price.len());
    }

    // Example from README - Aggregations
    println!("\nTest 5: Aggregations Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");

        let count = electronics_query.count();
        let total_value: f64 = electronics_query.sum(Product::price_r());
        let avg_price = electronics_query.avg(Product::price_r()).unwrap_or(0.0);

        println!("  Count: {}, Total: ${:.2}, Avg: ${:.2} ✅", count, total_value, avg_price);
    }

    // Example from README - Grouping
    println!("\nTest 6: Grouping Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let by_category = Query::new(&products).group_by(Product::category_r());
        println!("  Grouped into {} categories ✅", by_category.len());
    }

    // Example from README - Pagination
    println!("\nTest 7: Pagination Example");
    {
        let products = vec![
            Product { id: 1, name: "P1".to_string(), price: 10.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 2, name: "P2".to_string(), price: 20.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 3, name: "P3".to_string(), price: 30.0, category: "A".to_string(), stock: 1, rating: 4.0 },
        ];

        let query = Query::new(&products);
        let first_10 = query.limit(10);
        let page_1 = query.skip(0).limit(10);

        println!("  Limited to {} products ✅", first_10.len());
        println!("  Page 1 has {} products ✅", page_1.len());
    }

    // Example from README - Join
    println!("\nTest 8: Join Example");
    {
        let users = vec![
            User { id: 1, name: "Alice".to_string() },
            User { id: 2, name: "Bob".to_string() },
        ];

        let orders = vec![
            Order { id: 101, user_id: 1, total: 99.99 },
            Order { id: 102, user_id: 1, total: 149.99 },
        ];

        let user_orders = JoinQuery::new(&users, &orders).inner_join(
            User::id_r(),
            Order::user_id_r(),
            |user, order| (user.name.clone(), order.total),
        );

        println!("  Joined {} user-order pairs ✅", user_orders.len());
    }

    // Example from SQL_COMPARISON - SELECT with WHERE
    println!("\nTest 9: SQL Comparison - SELECT with WHERE");
    {
        #[derive(Clone, Keypaths)]
        struct Employee {
            department: String,
        }

        let employees = vec![
            Employee { department: "Engineering".to_string() },
            Employee { department: "Sales".to_string() },
        ];

        let engineering_query = Query::new(&employees)
            .where_(Employee::department_r(), |dept| dept == "Engineering");
        let engineering = engineering_query.all();

        println!("  Found {} engineering employees ✅", engineering.len());
    }

    // Example from USAGE.md - Complex Filtering
    println!("\nTest 10: USAGE - Complex Filtering");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let results_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price >= 100.0 && price <= 500.0)
            .where_(Product::stock_r(), |&stock| stock > 10);
        let results = results_query.order_by_float(Product::price_r());

        println!("  Filtered {} products ✅", results.len());
    }

    println!("\n✅ All documentation examples compile and run successfully!");
}

examples/advanced_query_builder.rs (line 118)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_verification.rs (line 44)

fn main() {
    let employees = create_test_data();
    
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  SQL Equivalence Verification Tests                           ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // TEST 1: ORDER BY maintains exact SQL ordering (DESC)
    println!("Test 1: ORDER BY DESC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC;");
    
    let ordered = Query::new(&employees).order_by_float_desc(Employee::salary_r());
    let expected_order = vec![105000.0, 95000.0, 87000.0, 82000.0, 75000.0, 71000.0];
    let actual_order: Vec<f64> = ordered.iter().map(|e| e.salary).collect();
    
    let test1_pass = expected_order == actual_order;
    print_test("ORDER BY salary DESC produces correct order", test1_pass);
    if !test1_pass {
        println!("  Expected: {:?}", expected_order);
        println!("  Got: {:?}", actual_order);
    }

    // TEST 2: ORDER BY maintains exact SQL ordering (ASC)
    println!("\nTest 2: ORDER BY ASC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary ASC;");
    
    let ordered_asc = Query::new(&employees).order_by_float(Employee::salary_r());
    let expected_asc = vec![71000.0, 75000.0, 82000.0, 87000.0, 95000.0, 105000.0];
    let actual_asc: Vec<f64> = ordered_asc.iter().map(|e| e.salary).collect();
    
    let test2_pass = expected_asc == actual_asc;
    print_test("ORDER BY salary ASC produces correct order", test2_pass);
    if !test2_pass {
        println!("  Expected: {:?}", expected_asc);
        println!("  Got: {:?}", actual_asc);
    }

    // TEST 3: String ordering (alphabetical)
    println!("\nTest 3: ORDER BY name (alphabetical)");
    println!("SQL: SELECT name FROM employees ORDER BY name;");
    
    let ordered_names = Query::new(&employees).order_by(Employee::name_r());
    let expected_names = vec!["Alice Cooper", "Alice Johnson", "Bob Smith", "Carol White", "David Brown", "Eve Davis"];
    let actual_names: Vec<&str> = ordered_names.iter().map(|e| e.name.as_str()).collect();
    
    let test3_pass = expected_names == actual_names;
    print_test("ORDER BY name produces correct alphabetical order", test3_pass);
    if !test3_pass {
        println!("  Expected: {:?}", expected_names);
        println!("  Got: {:?}", actual_names);
    }

    // TEST 4: LIKE equivalent - starts with
    println!("\nTest 4: LIKE 'Alice%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE 'Alice%';");
    
    let like_alice_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.starts_with("Alice"));
    let like_alice = like_alice_query.all();
    
    let test4_pass = like_alice.len() == 2 
        && like_alice.iter().all(|e| e.name.starts_with("Alice"));
    print_test("LIKE 'Alice%' (starts_with) works correctly", test4_pass);
    if test4_pass {
        for emp in &like_alice {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 5: LIKE equivalent - ends with
    println!("\nTest 5: LIKE '%son' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%son';");
    
    let like_son_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.ends_with("son"));
    let like_son = like_son_query.all();
    
    let test5_pass = like_son.len() == 1 && like_son[0].name == "Alice Johnson";
    print_test("LIKE '%son' (ends_with) works correctly", test5_pass);
    if test5_pass {
        for emp in &like_son {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 6: LIKE equivalent - contains
    println!("\nTest 6: LIKE '%mit%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%mit%';");
    
    let like_mit_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.contains("mit"));
    let like_mit = like_mit_query.all();
    
    let test6_pass = like_mit.len() == 1 && like_mit[0].name == "Bob Smith";
    print_test("LIKE '%mit%' (contains) works correctly", test6_pass);
    if test6_pass {
        for emp in &like_mit {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 7: IN clause equivalent
    println!("\nTest 7: IN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE department IN ('Engineering', 'Sales');");
    
    let in_depts_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales");
    let in_depts = in_depts_query.all();
    
    let test7_pass = in_depts.len() == 5 // 3 Engineering + 2 Sales
        && in_depts.iter().all(|e| e.department == "Engineering" || e.department == "Sales");
    print_test("IN clause works correctly", test7_pass);
    println!("  Found {} employees in Engineering or Sales", in_depts.len());

    // TEST 8: BETWEEN equivalent
    println!("\nTest 8: BETWEEN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE salary BETWEEN 75000 AND 90000;");
    
    let between_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal >= 75000.0 && sal <= 90000.0);
    let between = between_query.all();
    
    let test8_pass = between.len() == 3;
    print_test("BETWEEN clause works correctly", test8_pass);
    println!("  Found {} employees with salary between 75K-90K", between.len());

    // TEST 9: COUNT with WHERE
    println!("\nTest 9: COUNT with WHERE");
    println!("SQL: SELECT COUNT(*) FROM employees WHERE department = 'Engineering';");
    
    let count_eng = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .count();
    
    let test9_pass = count_eng == 3;
    print_test("COUNT with WHERE produces correct result", test9_pass);
    println!("  Count: {} (expected 3)", count_eng);

    // TEST 10: AVG produces exact result
    println!("\nTest 10: AVG aggregation accuracy");
    println!("SQL: SELECT AVG(salary) FROM employees WHERE department = 'Engineering';");
    
    let avg_sal = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .avg(Employee::salary_r())
        .unwrap_or(0.0);
    
    let expected_avg = (95000.0 + 87000.0 + 105000.0) / 3.0;
    let test10_pass = (avg_sal - expected_avg).abs() < 0.01;
    print_test("AVG produces mathematically correct result", test10_pass);
    println!("  Average: ${:.2} (expected ${:.2})", avg_sal, expected_avg);

    // TEST 11: MIN and MAX
    println!("\nTest 11: MIN and MAX aggregations");
    println!("SQL: SELECT MIN(salary), MAX(salary) FROM employees;");
    
    let min_sal = Query::new(&employees).min_float(Employee::salary_r()).unwrap_or(0.0);
    let max_sal = Query::new(&employees).max_float(Employee::salary_r()).unwrap_or(0.0);
    
    let test11_pass = min_sal == 71000.0 && max_sal == 105000.0;
    print_test("MIN and MAX produce correct results", test11_pass);
    println!("  MIN: ${:.2}, MAX: ${:.2}", min_sal, max_sal);

    // TEST 12: Complex WHERE with AND/OR
    println!("\nTest 12: Complex WHERE (AND + OR)");
    println!("SQL: SELECT * FROM employees WHERE (department = 'Engineering' OR department = 'Sales') AND salary > 80000;");
    
    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal > 80000.0);
    let complex = complex_query.all();
    
    let test12_pass = complex.len() == 4; // Alice J ($95k), Bob ($87k), David ($82k), Alice C ($105k)
    print_test("Complex WHERE clause works correctly", test12_pass);
    println!("  Found {} employees", complex.len());

    // TEST 13: Case-sensitive string comparison (SQL default)
    println!("\nTest 13: Case-sensitive comparison (like SQL)");
    println!("SQL: SELECT * FROM employees WHERE department = 'engineering'; -- should find 0");
    
    let case_sensitive = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "engineering") // lowercase
        .count();
    
    let test13_pass = case_sensitive == 0;
    print_test("Case-sensitive comparison (SQL default)", test13_pass);
    println!("  Found {} with lowercase 'engineering' (expected 0)", case_sensitive);

    // TEST 14: Case-insensitive LIKE equivalent
    println!("\nTest 14: Case-insensitive LIKE (ILIKE equivalent)");
    println!("SQL: SELECT * FROM employees WHERE LOWER(name) LIKE '%alice%';");
    
    let ilike_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.to_lowercase().contains("alice"));
    let ilike = ilike_query.all();
    
    let test14_pass = ilike.len() == 2;
    print_test("Case-insensitive LIKE works correctly", test14_pass);
    println!("  Found {} employees with 'alice' (case-insensitive)", ilike.len());

    // TEST 15: LIMIT produces exact subset
    println!("\nTest 15: LIMIT clause");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC LIMIT 3;");
    
    let limited = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r())
        .into_iter()
        .take(3)
        .collect::<Vec<_>>();
    
    let test15_pass = limited.len() == 3 
        && limited[0].salary == 105000.0
        && limited[1].salary == 95000.0
        && limited[2].salary == 87000.0;
    print_test("LIMIT returns correct top-N results", test15_pass);
    println!("  Top 3 salaries: ${:.0}, ${:.0}, ${:.0}", 
        limited[0].salary, limited[1].salary, limited[2].salary);

    // TEST 16: GROUP BY produces correct groups
    println!("\nTest 16: GROUP BY");
    println!("SQL: SELECT department, COUNT(*) FROM employees GROUP BY department;");
    
    let grouped = Query::new(&employees).group_by(Employee::department_r());
    let eng_count = grouped.get("Engineering").map(|v| v.len()).unwrap_or(0);
    let sales_count = grouped.get("Sales").map(|v| v.len()).unwrap_or(0);
    let marketing_count = grouped.get("Marketing").map(|v| v.len()).unwrap_or(0);
    
    let test16_pass = eng_count == 3 && sales_count == 2 && marketing_count == 1;
    print_test("GROUP BY produces correct counts", test16_pass);
    println!("  Engineering: {}, Sales: {}, Marketing: {}", eng_count, sales_count, marketing_count);

    // TEST 17: Email pattern matching (regex-like)
    println!("\nTest 17: Email domain filtering (LIKE '%@example.com')");
    println!("SQL: SELECT * FROM employees WHERE email LIKE '%@example.com';");
    
    let example_emails = Query::new(&employees)
        .where_(Employee::email_r(), |email| email.ends_with("@example.com"))
        .count();
    
    let test17_pass = example_emails == 6; // All employees have @example.com emails
    print_test("Email pattern matching works correctly", test17_pass);
    println!("  Found {} employees with @example.com emails", example_emails);

    // Summary
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Test Summary                                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");
    
    let tests = vec![
        ("ORDER BY DESC", test1_pass),
        ("ORDER BY ASC", test2_pass),
        ("ORDER BY name", test3_pass),
        ("LIKE 'prefix%'", test4_pass),
        ("LIKE '%suffix'", test5_pass),
        ("LIKE '%contains%'", test6_pass),
        ("IN clause", test7_pass),
        ("BETWEEN clause", test8_pass),
        ("COUNT", test9_pass),
        ("AVG accuracy", test10_pass),
        ("MIN/MAX", test11_pass),
        ("Complex WHERE", test12_pass),
        ("Case-sensitive", test13_pass),
        ("Case-insensitive", test14_pass),
        ("LIMIT", test15_pass),
        ("GROUP BY", test16_pass),
        ("Email patterns", test17_pass),
    ];
    
    let passed = tests.iter().filter(|(_, p)| *p).count();
    let total = tests.len();
    
    println!("Results: {}/{} tests passed", passed, total);
    
    if passed == total {
        println!("\n🎉 All tests PASSED! Rust Query Builder produces exact SQL-equivalent results!");
        println!("\n✅ Verified:");
        println!("  • Exact ordering (ASC/DESC)");
        println!("  • LIKE operations (starts_with, ends_with, contains)");
        println!("  • IN clause (OR conditions)");
        println!("  • BETWEEN clause");
        println!("  • Aggregations (COUNT, AVG, MIN, MAX)");
        println!("  • Complex WHERE conditions");
        println!("  • Case sensitivity");
        println!("  • LIMIT clause");
        println!("  • GROUP BY");
        println!("  • Pattern matching");
    } else {
        println!("\n⚠️  {} test(s) failed. See details above.", total - passed);
    }
}

examples/sql_comparison.rs (line 103)

fn main() {
    let employees = create_employees();
    let departments = create_departments();
    let projects = create_projects();

    println!("\n╔════════════════════════════════════════════════════════════════════════╗");
    println!("║     SQL vs Rust Query Builder Comparison                              ║");
    println!("║     Demonstrating equivalent operations                               ║");
    println!("╚════════════════════════════════════════════════════════════════════════╝");

    // ============================================================================
    // EXAMPLE 1: Simple SELECT with WHERE
    // ============================================================================
    print_separator("Example 1: SELECT with WHERE clause");
    print_query(
        "SELECT * FROM employees WHERE department = 'Engineering';",
        "Filter employees by department"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering_employees = eng_query.all();

    for emp in &engineering_employees {
        println!("  ID: {}, Name: {}, Salary: ${:.2}", emp.id, emp.name, emp.salary);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\")");
    println!("    .all()");
    println!("✓ Found {} employees", engineering_employees.len());

    // ============================================================================
    // EXAMPLE 2: SELECT specific columns
    // ============================================================================
    print_separator("Example 2: SELECT specific columns (Projection)");
    print_query(
        "SELECT name FROM employees WHERE salary > 80000;",
        "Get names of high-earning employees"
    );

    let high_earners = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 80000.0)
        .select(Employee::name_r());

    for name in &high_earners {
        println!("  {}", name);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 80000.0)");
    println!("    .select(Employee::name_r())");
    println!("✓ Found {} employees", high_earners.len());

    // ============================================================================
    // EXAMPLE 3: COUNT
    // ============================================================================
    print_separator("Example 3: COUNT aggregation");
    print_query(
        "SELECT COUNT(*) FROM employees WHERE age < 30;",
        "Count young employees"
    );

    let young_count = Query::new(&employees)
        .where_(Employee::age_r(), |&age| age < 30)
        .count();

    println!("  Count: {}", young_count);
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::age_r(), |&age| age < 30)");
    println!("    .count()");
    println!("✓ Result: {}", young_count);

    // ============================================================================
    // EXAMPLE 4: SUM, AVG, MIN, MAX
    // ============================================================================
    print_separator("Example 4: Aggregate functions (SUM, AVG, MIN, MAX)");
    print_query(
        "SELECT \n\
         SUM(salary) as total_salary,\n\
         AVG(salary) as avg_salary,\n\
         MIN(salary) as min_salary,\n\
         MAX(salary) as max_salary\n\
         FROM employees WHERE department = 'Engineering';",
        "Engineering department salary statistics"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");

    let total = eng_query.sum(Employee::salary_r());
    let avg = eng_query.avg(Employee::salary_r()).unwrap_or(0.0);
    let min = eng_query.min_float(Employee::salary_r()).unwrap_or(0.0);
    let max = eng_query.max_float(Employee::salary_r()).unwrap_or(0.0);

    println!("  Total Salary: ${:.2}", total);
    println!("  Avg Salary:   ${:.2}", avg);
    println!("  Min Salary:   ${:.2}", min);
    println!("  Max Salary:   ${:.2}", max);

    println!("\nRust Query Builder:");
    println!("let query = Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\");");
    println!("query.sum(Employee::salary_r())  // ${:.2}", total);
    println!("query.avg(Employee::salary_r())  // ${:.2}", avg);
    println!("query.min_float(Employee::salary_r())  // ${:.2}", min);
    println!("query.max_float(Employee::salary_r())  // ${:.2}", max);

    // ============================================================================
    // EXAMPLE 5: GROUP BY with aggregation
    // ============================================================================
    print_separator("Example 5: GROUP BY with aggregation");
    print_query(
        "SELECT \n\
         department,\n\
         COUNT(*) as emp_count,\n\
         AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY department;",
        "Statistics by department"
    );

    let by_dept = Query::new(&employees).group_by(Employee::department_r());

    for (dept, emps) in &by_dept {
        let dept_query = Query::new(emps);
        let count = emps.len();
        let avg_sal = dept_query.avg(Employee::salary_r()).unwrap_or(0.0);
        println!("  {}: {} employees, avg salary ${:.2}", dept, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_dept = Query::new(&employees).group_by(Employee::department_r());");
    println!("for (dept, emps) in &by_dept {{");
    println!("    let dept_query = Query::new(emps);");
    println!("    dept_query.avg(Employee::salary_r())");
    println!("}}");

    // ============================================================================
    // EXAMPLE 6: ORDER BY
    // ============================================================================
    print_separator("Example 6: ORDER BY");
    print_query(
        "SELECT name, salary FROM employees\n\
         WHERE department = 'Sales'\n\
         ORDER BY salary DESC;",
        "Sales employees ordered by salary (descending)"
    );

    let sales_sorted = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .order_by_float_desc(Employee::salary_r());

    for emp in &sales_sorted {
        println!("  {}: ${:.2}", emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Sales\")");
    println!("    .order_by_float_desc(Employee::salary_r())");

    // ============================================================================
    // EXAMPLE 7: Multiple WHERE conditions (AND)
    // ============================================================================
    print_separator("Example 7: Multiple WHERE conditions (AND)");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > 70000 AND age < 35;",
        "High-earning young employees"
    );

    let filter_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 70000.0)
        .where_(Employee::age_r(), |&age| age < 35);
    let filtered = filter_query.all();

    for emp in &filtered {
        println!("  {}: Age {}, Salary ${:.2}", emp.name, emp.age, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 70000.0)");
    println!("    .where_(Employee::age_r(), |&age| age < 35)");
    println!("    .all()");
    println!("✓ Found {} employees", filtered.len());

    // ============================================================================
    // EXAMPLE 8: LIMIT (TOP N)
    // ============================================================================
    print_separator("Example 8: LIMIT / TOP N");
    print_query(
        "SELECT TOP 3 name, salary FROM employees\n\
         ORDER BY salary DESC;",
        "Top 3 highest paid employees"
    );

    let top_earners = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r());

    for (i, emp) in top_earners.iter().take(3).enumerate() {
        println!("  {}. {}: ${:.2}", i + 1, emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("    .into_iter().take(3)");

    // ============================================================================
    // EXAMPLE 9: OFFSET and LIMIT (Pagination)
    // ============================================================================
    print_separator("Example 9: OFFSET and LIMIT (Pagination)");
    print_query(
        "SELECT name FROM employees\n\
         ORDER BY name\n\
         LIMIT 3 OFFSET 3;",
        "Page 2 of employee names (3 per page)"
    );

    let page_2 = Query::new(&employees)
        .order_by(Employee::name_r())
        .into_iter()
        .skip(3)
        .take(3)
        .collect::<Vec<_>>();

    for emp in &page_2 {
        println!("  {}", emp.name);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by(Employee::name_r())");
    println!("    .into_iter().skip(3).take(3)");

    // ============================================================================
    // EXAMPLE 10: INNER JOIN
    // ============================================================================
    print_separator("Example 10: INNER JOIN");
    print_query(
        "SELECT e.name, d.name as dept_name, d.budget\n\
         FROM employees e\n\
         INNER JOIN departments d ON e.department = d.name;",
        "Employees with their department info"
    );

    let emp_dept = JoinQuery::new(&employees, &departments).inner_join(
        Employee::department_r(),
        Department::name_r(),
        |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget),
    );

    for (emp_name, dept_name, budget) in emp_dept.iter().take(5) {
        println!("  {} works in {} (Budget: ${:.0})", emp_name, dept_name, budget);
    }
    println!("  ... (showing first 5)");

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&employees, &departments).inner_join(");
    println!("    Employee::department_r(),");
    println!("    Department::name_r(),");
    println!("    |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget)");
    println!(")");
    println!("✓ Found {} matches", emp_dept.len());

    // ============================================================================
    // EXAMPLE 11: GROUP BY with HAVING equivalent
    // ============================================================================
    print_separator("Example 11: GROUP BY with filtering (HAVING equivalent)");
    print_query(
        "SELECT city, COUNT(*) as emp_count, AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY city\n\
         HAVING COUNT(*) > 1;",
        "Cities with multiple employees"
    );

    let by_city = Query::new(&employees).group_by(Employee::city_r());
    let mut city_stats: Vec<_> = by_city
        .iter()
        .filter(|(_, emps)| emps.len() > 1) // HAVING equivalent
        .map(|(city, emps)| {
            let avg_sal = Query::new(emps).avg(Employee::salary_r()).unwrap_or(0.0);
            (city.clone(), emps.len(), avg_sal)
        })
        .collect();
    
    city_stats.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count

    for (city, count, avg_sal) in &city_stats {
        println!("  {}: {} employees, avg salary ${:.2}", city, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_city = Query::new(&employees).group_by(Employee::city_r());");
    println!("by_city.iter()");
    println!("    .filter(|(_, emps)| emps.len() > 1)  // HAVING equivalent");
    println!("    .map(|(city, emps)| {{");
    println!("        let avg = Query::new(emps).avg(Employee::salary_r());");
    println!("        (city, emps.len(), avg)");
    println!("    }})");

    // ============================================================================
    // EXAMPLE 12: Complex query with multiple operations
    // ============================================================================
    print_separator("Example 12: Complex multi-operation query");
    print_query(
        "SELECT name, salary, age\n\
         FROM employees\n\
         WHERE department IN ('Engineering', 'Sales')\n\
         AND salary BETWEEN 80000 AND 100000\n\
         AND age >= 30\n\
         ORDER BY salary DESC;",
        "Experienced mid-to-senior level employees in core departments"
    );

    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)
        .where_(Employee::age_r(), |&age| age >= 30)
        .order_by_float_desc(Employee::salary_r());

    for emp in &complex_query {
        println!("  {}: Age {}, {} dept, ${:.2}", emp.name, emp.age, emp.department, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\" || dept == \"Sales\")");
    println!("    .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)");
    println!("    .where_(Employee::age_r(), |&age| age >= 30)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("✓ Found {} employees", complex_query.len());

    // ============================================================================
    // EXAMPLE 13: Three-table JOIN
    // ============================================================================
    print_separator("Example 13: Three-table JOIN");
    print_query(
        "SELECT p.name as project, d.name as department, d.location\n\
         FROM projects p\n\
         INNER JOIN departments d ON p.department_id = d.id;",
        "Projects with their department details"
    );

    let proj_dept = JoinQuery::new(&projects, &departments).inner_join(
        Project::department_id_r(),
        Department::id_r(),
        |proj, dept| {
            (proj.name.clone(), dept.name.clone(), dept.location.clone(), proj.budget)
        },
    );

    for (proj_name, dept_name, location, budget) in &proj_dept {
        println!("  {}: {} dept in {} (${:.0})", proj_name, dept_name, location, budget);
    }

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&projects, &departments).inner_join(");
    println!("    Project::department_id_r(),");
    println!("    Department::id_r(),");
    println!("    |proj, dept| (proj.name, dept.name, dept.location, proj.budget)");
    println!(")");

    // ============================================================================
    // EXAMPLE 14: Subquery equivalent (using intermediate results)
    // ============================================================================
    print_separator("Example 14: Subquery equivalent");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > (SELECT AVG(salary) FROM employees);",
        "Employees earning above average"
    );

    let avg_salary = Query::new(&employees)
        .avg(Employee::salary_r())
        .unwrap_or(0.0);

    let above_avg_query = Query::new(&employees)
        .where_(Employee::salary_r(), move |&sal| sal > avg_salary);
    let above_avg = above_avg_query.all();

    println!("  Average salary: ${:.2}", avg_salary);
    for emp in &above_avg {
        println!("  {}: ${:.2} ({:.1}% above average)", 
            emp.name, emp.salary, ((emp.salary - avg_salary) / avg_salary * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let avg = Query::new(&employees).avg(Employee::salary_r()).unwrap_or(0.0);");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&sal| sal > avg)");
    println!("    .all()");
    println!("✓ Found {} employees above average", above_avg.len());

    // ============================================================================
    // EXAMPLE 15: Advanced aggregation (revenue calculation)
    // ============================================================================
    print_separator("Example 15: Advanced aggregation");
    print_query(
        "SELECT \n\
         d.name,\n\
         d.budget as dept_budget,\n\
         SUM(p.budget) as total_project_budget,\n\
         (d.budget - SUM(p.budget)) as remaining_budget\n\
         FROM departments d\n\
         LEFT JOIN projects p ON d.id = p.department_id\n\
         GROUP BY d.name, d.budget;",
        "Department budget utilization"
    );

    // Join departments with projects
    let dept_projects = JoinQuery::new(&departments, &projects).left_join(
        Department::id_r(),
        Project::department_id_r(),
        |dept, proj| (dept.clone(), proj.map(|p| p.clone())),
    );

    // Aggregate by department
    let mut dept_budget_map: HashMap<String, (f64, Vec<f64>)> = HashMap::new();
    for (dept, proj) in dept_projects {
        let entry = dept_budget_map
            .entry(dept.name.clone())
            .or_insert((dept.budget, Vec::new()));
        if let Some(p) = proj {
            entry.1.push(p.budget);
        }
    }

    for (dept_name, (total_budget, project_budgets)) in dept_budget_map.iter() {
        let used: f64 = project_budgets.iter().sum();
        let remaining = total_budget - used;
        println!("  {}: Budget ${:.0}, Used ${:.0}, Remaining ${:.0} ({:.1}% utilized)",
            dept_name, total_budget, used, remaining, (used / total_budget * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let dept_projects = JoinQuery::new(&departments, &projects)");
    println!("    .left_join(Department::id_r(), Project::department_id_r(), ...)");
    println!("// Then aggregate using HashMap");

    // ============================================================================
    // Summary
    // ============================================================================
    print_separator("Summary");
    println!("\n✓ All 15 SQL queries successfully replicated with Rust Query Builder!");
    println!("\nDemonstrated equivalents for:");
    println!("  • SELECT with WHERE");
    println!("  • Projection (SELECT specific columns)");
    println!("  • Aggregations (COUNT, SUM, AVG, MIN, MAX)");
    println!("  • GROUP BY");
    println!("  • ORDER BY");
    println!("  • LIMIT and OFFSET");
    println!("  • INNER JOIN and LEFT JOIN");
    println!("  • Complex conditions (AND, OR, BETWEEN)");
    println!("  • Subqueries");
    println!("  • Multi-table operations");
    println!("\n🎯 Type-safe, compile-time checked, and zero runtime overhead!");
    println!();
}

pub fn where_<F>( self, path: KeyPaths<T, F>, predicate: impl Fn(&F) -> bool + 'static, ) -> Self

where F: 'static,

Adds a filter predicate using a key-path.

Arguments

• path - The key-path to the field to filter on
• predicate - A function that returns true for items to keep

Example

let query = Query::new(&products)
    .where_(Product::category_r(), |cat| cat == "Electronics");

Examples found in repository

examples/doc_examples.rs (line 43)

fn main() {
    println!("Testing documentation examples...\n");

    // Example from README - Quick Start
    println!("Test 1: README Quick Start Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let affordable_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price < 100.0);
        let affordable_electronics = affordable_query.all();

        println!("  Found {} affordable electronics ✅", affordable_electronics.len());
    }

    // Example from README - Filtering
    println!("\nTest 2: Filtering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");
        let electronics = electronics_query.all();

        println!("  Found {} electronics ✅", electronics.len());
    }

    // Example from README - Selecting
    println!("\nTest 3: Selecting Fields Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let names: Vec<String> = Query::new(&products)
            .select(Product::name_r());

        println!("  Selected {} names ✅", names.len());
    }

    // Example from README - Ordering
    println!("\nTest 4: Ordering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let by_price = Query::new(&products).order_by_float(Product::price_r());
        println!("  Ordered {} products ✅", by_price.len());
    }

    // Example from README - Aggregations
    println!("\nTest 5: Aggregations Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");

        let count = electronics_query.count();
        let total_value: f64 = electronics_query.sum(Product::price_r());
        let avg_price = electronics_query.avg(Product::price_r()).unwrap_or(0.0);

        println!("  Count: {}, Total: ${:.2}, Avg: ${:.2} ✅", count, total_value, avg_price);
    }

    // Example from README - Grouping
    println!("\nTest 6: Grouping Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let by_category = Query::new(&products).group_by(Product::category_r());
        println!("  Grouped into {} categories ✅", by_category.len());
    }

    // Example from README - Pagination
    println!("\nTest 7: Pagination Example");
    {
        let products = vec![
            Product { id: 1, name: "P1".to_string(), price: 10.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 2, name: "P2".to_string(), price: 20.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 3, name: "P3".to_string(), price: 30.0, category: "A".to_string(), stock: 1, rating: 4.0 },
        ];

        let query = Query::new(&products);
        let first_10 = query.limit(10);
        let page_1 = query.skip(0).limit(10);

        println!("  Limited to {} products ✅", first_10.len());
        println!("  Page 1 has {} products ✅", page_1.len());
    }

    // Example from README - Join
    println!("\nTest 8: Join Example");
    {
        let users = vec![
            User { id: 1, name: "Alice".to_string() },
            User { id: 2, name: "Bob".to_string() },
        ];

        let orders = vec![
            Order { id: 101, user_id: 1, total: 99.99 },
            Order { id: 102, user_id: 1, total: 149.99 },
        ];

        let user_orders = JoinQuery::new(&users, &orders).inner_join(
            User::id_r(),
            Order::user_id_r(),
            |user, order| (user.name.clone(), order.total),
        );

        println!("  Joined {} user-order pairs ✅", user_orders.len());
    }

    // Example from SQL_COMPARISON - SELECT with WHERE
    println!("\nTest 9: SQL Comparison - SELECT with WHERE");
    {
        #[derive(Clone, Keypaths)]
        struct Employee {
            department: String,
        }

        let employees = vec![
            Employee { department: "Engineering".to_string() },
            Employee { department: "Sales".to_string() },
        ];

        let engineering_query = Query::new(&employees)
            .where_(Employee::department_r(), |dept| dept == "Engineering");
        let engineering = engineering_query.all();

        println!("  Found {} engineering employees ✅", engineering.len());
    }

    // Example from USAGE.md - Complex Filtering
    println!("\nTest 10: USAGE - Complex Filtering");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let results_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price >= 100.0 && price <= 500.0)
            .where_(Product::stock_r(), |&stock| stock > 10);
        let results = results_query.order_by_float(Product::price_r());

        println!("  Filtered {} products ✅", results.len());
    }

    println!("\n✅ All documentation examples compile and run successfully!");
}

examples/advanced_query_builder.rs (line 151)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_verification.rs (line 90)

fn main() {
    let employees = create_test_data();
    
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  SQL Equivalence Verification Tests                           ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // TEST 1: ORDER BY maintains exact SQL ordering (DESC)
    println!("Test 1: ORDER BY DESC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC;");
    
    let ordered = Query::new(&employees).order_by_float_desc(Employee::salary_r());
    let expected_order = vec![105000.0, 95000.0, 87000.0, 82000.0, 75000.0, 71000.0];
    let actual_order: Vec<f64> = ordered.iter().map(|e| e.salary).collect();
    
    let test1_pass = expected_order == actual_order;
    print_test("ORDER BY salary DESC produces correct order", test1_pass);
    if !test1_pass {
        println!("  Expected: {:?}", expected_order);
        println!("  Got: {:?}", actual_order);
    }

    // TEST 2: ORDER BY maintains exact SQL ordering (ASC)
    println!("\nTest 2: ORDER BY ASC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary ASC;");
    
    let ordered_asc = Query::new(&employees).order_by_float(Employee::salary_r());
    let expected_asc = vec![71000.0, 75000.0, 82000.0, 87000.0, 95000.0, 105000.0];
    let actual_asc: Vec<f64> = ordered_asc.iter().map(|e| e.salary).collect();
    
    let test2_pass = expected_asc == actual_asc;
    print_test("ORDER BY salary ASC produces correct order", test2_pass);
    if !test2_pass {
        println!("  Expected: {:?}", expected_asc);
        println!("  Got: {:?}", actual_asc);
    }

    // TEST 3: String ordering (alphabetical)
    println!("\nTest 3: ORDER BY name (alphabetical)");
    println!("SQL: SELECT name FROM employees ORDER BY name;");
    
    let ordered_names = Query::new(&employees).order_by(Employee::name_r());
    let expected_names = vec!["Alice Cooper", "Alice Johnson", "Bob Smith", "Carol White", "David Brown", "Eve Davis"];
    let actual_names: Vec<&str> = ordered_names.iter().map(|e| e.name.as_str()).collect();
    
    let test3_pass = expected_names == actual_names;
    print_test("ORDER BY name produces correct alphabetical order", test3_pass);
    if !test3_pass {
        println!("  Expected: {:?}", expected_names);
        println!("  Got: {:?}", actual_names);
    }

    // TEST 4: LIKE equivalent - starts with
    println!("\nTest 4: LIKE 'Alice%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE 'Alice%';");
    
    let like_alice_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.starts_with("Alice"));
    let like_alice = like_alice_query.all();
    
    let test4_pass = like_alice.len() == 2 
        && like_alice.iter().all(|e| e.name.starts_with("Alice"));
    print_test("LIKE 'Alice%' (starts_with) works correctly", test4_pass);
    if test4_pass {
        for emp in &like_alice {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 5: LIKE equivalent - ends with
    println!("\nTest 5: LIKE '%son' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%son';");
    
    let like_son_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.ends_with("son"));
    let like_son = like_son_query.all();
    
    let test5_pass = like_son.len() == 1 && like_son[0].name == "Alice Johnson";
    print_test("LIKE '%son' (ends_with) works correctly", test5_pass);
    if test5_pass {
        for emp in &like_son {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 6: LIKE equivalent - contains
    println!("\nTest 6: LIKE '%mit%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%mit%';");
    
    let like_mit_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.contains("mit"));
    let like_mit = like_mit_query.all();
    
    let test6_pass = like_mit.len() == 1 && like_mit[0].name == "Bob Smith";
    print_test("LIKE '%mit%' (contains) works correctly", test6_pass);
    if test6_pass {
        for emp in &like_mit {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 7: IN clause equivalent
    println!("\nTest 7: IN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE department IN ('Engineering', 'Sales');");
    
    let in_depts_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales");
    let in_depts = in_depts_query.all();
    
    let test7_pass = in_depts.len() == 5 // 3 Engineering + 2 Sales
        && in_depts.iter().all(|e| e.department == "Engineering" || e.department == "Sales");
    print_test("IN clause works correctly", test7_pass);
    println!("  Found {} employees in Engineering or Sales", in_depts.len());

    // TEST 8: BETWEEN equivalent
    println!("\nTest 8: BETWEEN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE salary BETWEEN 75000 AND 90000;");
    
    let between_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal >= 75000.0 && sal <= 90000.0);
    let between = between_query.all();
    
    let test8_pass = between.len() == 3;
    print_test("BETWEEN clause works correctly", test8_pass);
    println!("  Found {} employees with salary between 75K-90K", between.len());

    // TEST 9: COUNT with WHERE
    println!("\nTest 9: COUNT with WHERE");
    println!("SQL: SELECT COUNT(*) FROM employees WHERE department = 'Engineering';");
    
    let count_eng = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .count();
    
    let test9_pass = count_eng == 3;
    print_test("COUNT with WHERE produces correct result", test9_pass);
    println!("  Count: {} (expected 3)", count_eng);

    // TEST 10: AVG produces exact result
    println!("\nTest 10: AVG aggregation accuracy");
    println!("SQL: SELECT AVG(salary) FROM employees WHERE department = 'Engineering';");
    
    let avg_sal = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .avg(Employee::salary_r())
        .unwrap_or(0.0);
    
    let expected_avg = (95000.0 + 87000.0 + 105000.0) / 3.0;
    let test10_pass = (avg_sal - expected_avg).abs() < 0.01;
    print_test("AVG produces mathematically correct result", test10_pass);
    println!("  Average: ${:.2} (expected ${:.2})", avg_sal, expected_avg);

    // TEST 11: MIN and MAX
    println!("\nTest 11: MIN and MAX aggregations");
    println!("SQL: SELECT MIN(salary), MAX(salary) FROM employees;");
    
    let min_sal = Query::new(&employees).min_float(Employee::salary_r()).unwrap_or(0.0);
    let max_sal = Query::new(&employees).max_float(Employee::salary_r()).unwrap_or(0.0);
    
    let test11_pass = min_sal == 71000.0 && max_sal == 105000.0;
    print_test("MIN and MAX produce correct results", test11_pass);
    println!("  MIN: ${:.2}, MAX: ${:.2}", min_sal, max_sal);

    // TEST 12: Complex WHERE with AND/OR
    println!("\nTest 12: Complex WHERE (AND + OR)");
    println!("SQL: SELECT * FROM employees WHERE (department = 'Engineering' OR department = 'Sales') AND salary > 80000;");
    
    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal > 80000.0);
    let complex = complex_query.all();
    
    let test12_pass = complex.len() == 4; // Alice J ($95k), Bob ($87k), David ($82k), Alice C ($105k)
    print_test("Complex WHERE clause works correctly", test12_pass);
    println!("  Found {} employees", complex.len());

    // TEST 13: Case-sensitive string comparison (SQL default)
    println!("\nTest 13: Case-sensitive comparison (like SQL)");
    println!("SQL: SELECT * FROM employees WHERE department = 'engineering'; -- should find 0");
    
    let case_sensitive = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "engineering") // lowercase
        .count();
    
    let test13_pass = case_sensitive == 0;
    print_test("Case-sensitive comparison (SQL default)", test13_pass);
    println!("  Found {} with lowercase 'engineering' (expected 0)", case_sensitive);

    // TEST 14: Case-insensitive LIKE equivalent
    println!("\nTest 14: Case-insensitive LIKE (ILIKE equivalent)");
    println!("SQL: SELECT * FROM employees WHERE LOWER(name) LIKE '%alice%';");
    
    let ilike_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.to_lowercase().contains("alice"));
    let ilike = ilike_query.all();
    
    let test14_pass = ilike.len() == 2;
    print_test("Case-insensitive LIKE works correctly", test14_pass);
    println!("  Found {} employees with 'alice' (case-insensitive)", ilike.len());

    // TEST 15: LIMIT produces exact subset
    println!("\nTest 15: LIMIT clause");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC LIMIT 3;");
    
    let limited = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r())
        .into_iter()
        .take(3)
        .collect::<Vec<_>>();
    
    let test15_pass = limited.len() == 3 
        && limited[0].salary == 105000.0
        && limited[1].salary == 95000.0
        && limited[2].salary == 87000.0;
    print_test("LIMIT returns correct top-N results", test15_pass);
    println!("  Top 3 salaries: ${:.0}, ${:.0}, ${:.0}", 
        limited[0].salary, limited[1].salary, limited[2].salary);

    // TEST 16: GROUP BY produces correct groups
    println!("\nTest 16: GROUP BY");
    println!("SQL: SELECT department, COUNT(*) FROM employees GROUP BY department;");
    
    let grouped = Query::new(&employees).group_by(Employee::department_r());
    let eng_count = grouped.get("Engineering").map(|v| v.len()).unwrap_or(0);
    let sales_count = grouped.get("Sales").map(|v| v.len()).unwrap_or(0);
    let marketing_count = grouped.get("Marketing").map(|v| v.len()).unwrap_or(0);
    
    let test16_pass = eng_count == 3 && sales_count == 2 && marketing_count == 1;
    print_test("GROUP BY produces correct counts", test16_pass);
    println!("  Engineering: {}, Sales: {}, Marketing: {}", eng_count, sales_count, marketing_count);

    // TEST 17: Email pattern matching (regex-like)
    println!("\nTest 17: Email domain filtering (LIKE '%@example.com')");
    println!("SQL: SELECT * FROM employees WHERE email LIKE '%@example.com';");
    
    let example_emails = Query::new(&employees)
        .where_(Employee::email_r(), |email| email.ends_with("@example.com"))
        .count();
    
    let test17_pass = example_emails == 6; // All employees have @example.com emails
    print_test("Email pattern matching works correctly", test17_pass);
    println!("  Found {} employees with @example.com emails", example_emails);

    // Summary
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Test Summary                                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");
    
    let tests = vec![
        ("ORDER BY DESC", test1_pass),
        ("ORDER BY ASC", test2_pass),
        ("ORDER BY name", test3_pass),
        ("LIKE 'prefix%'", test4_pass),
        ("LIKE '%suffix'", test5_pass),
        ("LIKE '%contains%'", test6_pass),
        ("IN clause", test7_pass),
        ("BETWEEN clause", test8_pass),
        ("COUNT", test9_pass),
        ("AVG accuracy", test10_pass),
        ("MIN/MAX", test11_pass),
        ("Complex WHERE", test12_pass),
        ("Case-sensitive", test13_pass),
        ("Case-insensitive", test14_pass),
        ("LIMIT", test15_pass),
        ("GROUP BY", test16_pass),
        ("Email patterns", test17_pass),
    ];
    
    let passed = tests.iter().filter(|(_, p)| *p).count();
    let total = tests.len();
    
    println!("Results: {}/{} tests passed", passed, total);
    
    if passed == total {
        println!("\n🎉 All tests PASSED! Rust Query Builder produces exact SQL-equivalent results!");
        println!("\n✅ Verified:");
        println!("  • Exact ordering (ASC/DESC)");
        println!("  • LIKE operations (starts_with, ends_with, contains)");
        println!("  • IN clause (OR conditions)");
        println!("  • BETWEEN clause");
        println!("  • Aggregations (COUNT, AVG, MIN, MAX)");
        println!("  • Complex WHERE conditions");
        println!("  • Case sensitivity");
        println!("  • LIMIT clause");
        println!("  • GROUP BY");
        println!("  • Pattern matching");
    } else {
        println!("\n⚠️  {} test(s) failed. See details above.", total - passed);
    }
}

examples/sql_comparison.rs (line 104)

fn main() {
    let employees = create_employees();
    let departments = create_departments();
    let projects = create_projects();

    println!("\n╔════════════════════════════════════════════════════════════════════════╗");
    println!("║     SQL vs Rust Query Builder Comparison                              ║");
    println!("║     Demonstrating equivalent operations                               ║");
    println!("╚════════════════════════════════════════════════════════════════════════╝");

    // ============================================================================
    // EXAMPLE 1: Simple SELECT with WHERE
    // ============================================================================
    print_separator("Example 1: SELECT with WHERE clause");
    print_query(
        "SELECT * FROM employees WHERE department = 'Engineering';",
        "Filter employees by department"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering_employees = eng_query.all();

    for emp in &engineering_employees {
        println!("  ID: {}, Name: {}, Salary: ${:.2}", emp.id, emp.name, emp.salary);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\")");
    println!("    .all()");
    println!("✓ Found {} employees", engineering_employees.len());

    // ============================================================================
    // EXAMPLE 2: SELECT specific columns
    // ============================================================================
    print_separator("Example 2: SELECT specific columns (Projection)");
    print_query(
        "SELECT name FROM employees WHERE salary > 80000;",
        "Get names of high-earning employees"
    );

    let high_earners = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 80000.0)
        .select(Employee::name_r());

    for name in &high_earners {
        println!("  {}", name);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 80000.0)");
    println!("    .select(Employee::name_r())");
    println!("✓ Found {} employees", high_earners.len());

    // ============================================================================
    // EXAMPLE 3: COUNT
    // ============================================================================
    print_separator("Example 3: COUNT aggregation");
    print_query(
        "SELECT COUNT(*) FROM employees WHERE age < 30;",
        "Count young employees"
    );

    let young_count = Query::new(&employees)
        .where_(Employee::age_r(), |&age| age < 30)
        .count();

    println!("  Count: {}", young_count);
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::age_r(), |&age| age < 30)");
    println!("    .count()");
    println!("✓ Result: {}", young_count);

    // ============================================================================
    // EXAMPLE 4: SUM, AVG, MIN, MAX
    // ============================================================================
    print_separator("Example 4: Aggregate functions (SUM, AVG, MIN, MAX)");
    print_query(
        "SELECT \n\
         SUM(salary) as total_salary,\n\
         AVG(salary) as avg_salary,\n\
         MIN(salary) as min_salary,\n\
         MAX(salary) as max_salary\n\
         FROM employees WHERE department = 'Engineering';",
        "Engineering department salary statistics"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");

    let total = eng_query.sum(Employee::salary_r());
    let avg = eng_query.avg(Employee::salary_r()).unwrap_or(0.0);
    let min = eng_query.min_float(Employee::salary_r()).unwrap_or(0.0);
    let max = eng_query.max_float(Employee::salary_r()).unwrap_or(0.0);

    println!("  Total Salary: ${:.2}", total);
    println!("  Avg Salary:   ${:.2}", avg);
    println!("  Min Salary:   ${:.2}", min);
    println!("  Max Salary:   ${:.2}", max);

    println!("\nRust Query Builder:");
    println!("let query = Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\");");
    println!("query.sum(Employee::salary_r())  // ${:.2}", total);
    println!("query.avg(Employee::salary_r())  // ${:.2}", avg);
    println!("query.min_float(Employee::salary_r())  // ${:.2}", min);
    println!("query.max_float(Employee::salary_r())  // ${:.2}", max);

    // ============================================================================
    // EXAMPLE 5: GROUP BY with aggregation
    // ============================================================================
    print_separator("Example 5: GROUP BY with aggregation");
    print_query(
        "SELECT \n\
         department,\n\
         COUNT(*) as emp_count,\n\
         AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY department;",
        "Statistics by department"
    );

    let by_dept = Query::new(&employees).group_by(Employee::department_r());

    for (dept, emps) in &by_dept {
        let dept_query = Query::new(emps);
        let count = emps.len();
        let avg_sal = dept_query.avg(Employee::salary_r()).unwrap_or(0.0);
        println!("  {}: {} employees, avg salary ${:.2}", dept, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_dept = Query::new(&employees).group_by(Employee::department_r());");
    println!("for (dept, emps) in &by_dept {{");
    println!("    let dept_query = Query::new(emps);");
    println!("    dept_query.avg(Employee::salary_r())");
    println!("}}");

    // ============================================================================
    // EXAMPLE 6: ORDER BY
    // ============================================================================
    print_separator("Example 6: ORDER BY");
    print_query(
        "SELECT name, salary FROM employees\n\
         WHERE department = 'Sales'\n\
         ORDER BY salary DESC;",
        "Sales employees ordered by salary (descending)"
    );

    let sales_sorted = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .order_by_float_desc(Employee::salary_r());

    for emp in &sales_sorted {
        println!("  {}: ${:.2}", emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Sales\")");
    println!("    .order_by_float_desc(Employee::salary_r())");

    // ============================================================================
    // EXAMPLE 7: Multiple WHERE conditions (AND)
    // ============================================================================
    print_separator("Example 7: Multiple WHERE conditions (AND)");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > 70000 AND age < 35;",
        "High-earning young employees"
    );

    let filter_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 70000.0)
        .where_(Employee::age_r(), |&age| age < 35);
    let filtered = filter_query.all();

    for emp in &filtered {
        println!("  {}: Age {}, Salary ${:.2}", emp.name, emp.age, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 70000.0)");
    println!("    .where_(Employee::age_r(), |&age| age < 35)");
    println!("    .all()");
    println!("✓ Found {} employees", filtered.len());

    // ============================================================================
    // EXAMPLE 8: LIMIT (TOP N)
    // ============================================================================
    print_separator("Example 8: LIMIT / TOP N");
    print_query(
        "SELECT TOP 3 name, salary FROM employees\n\
         ORDER BY salary DESC;",
        "Top 3 highest paid employees"
    );

    let top_earners = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r());

    for (i, emp) in top_earners.iter().take(3).enumerate() {
        println!("  {}. {}: ${:.2}", i + 1, emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("    .into_iter().take(3)");

    // ============================================================================
    // EXAMPLE 9: OFFSET and LIMIT (Pagination)
    // ============================================================================
    print_separator("Example 9: OFFSET and LIMIT (Pagination)");
    print_query(
        "SELECT name FROM employees\n\
         ORDER BY name\n\
         LIMIT 3 OFFSET 3;",
        "Page 2 of employee names (3 per page)"
    );

    let page_2 = Query::new(&employees)
        .order_by(Employee::name_r())
        .into_iter()
        .skip(3)
        .take(3)
        .collect::<Vec<_>>();

    for emp in &page_2 {
        println!("  {}", emp.name);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by(Employee::name_r())");
    println!("    .into_iter().skip(3).take(3)");

    // ============================================================================
    // EXAMPLE 10: INNER JOIN
    // ============================================================================
    print_separator("Example 10: INNER JOIN");
    print_query(
        "SELECT e.name, d.name as dept_name, d.budget\n\
         FROM employees e\n\
         INNER JOIN departments d ON e.department = d.name;",
        "Employees with their department info"
    );

    let emp_dept = JoinQuery::new(&employees, &departments).inner_join(
        Employee::department_r(),
        Department::name_r(),
        |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget),
    );

    for (emp_name, dept_name, budget) in emp_dept.iter().take(5) {
        println!("  {} works in {} (Budget: ${:.0})", emp_name, dept_name, budget);
    }
    println!("  ... (showing first 5)");

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&employees, &departments).inner_join(");
    println!("    Employee::department_r(),");
    println!("    Department::name_r(),");
    println!("    |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget)");
    println!(")");
    println!("✓ Found {} matches", emp_dept.len());

    // ============================================================================
    // EXAMPLE 11: GROUP BY with HAVING equivalent
    // ============================================================================
    print_separator("Example 11: GROUP BY with filtering (HAVING equivalent)");
    print_query(
        "SELECT city, COUNT(*) as emp_count, AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY city\n\
         HAVING COUNT(*) > 1;",
        "Cities with multiple employees"
    );

    let by_city = Query::new(&employees).group_by(Employee::city_r());
    let mut city_stats: Vec<_> = by_city
        .iter()
        .filter(|(_, emps)| emps.len() > 1) // HAVING equivalent
        .map(|(city, emps)| {
            let avg_sal = Query::new(emps).avg(Employee::salary_r()).unwrap_or(0.0);
            (city.clone(), emps.len(), avg_sal)
        })
        .collect();
    
    city_stats.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count

    for (city, count, avg_sal) in &city_stats {
        println!("  {}: {} employees, avg salary ${:.2}", city, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_city = Query::new(&employees).group_by(Employee::city_r());");
    println!("by_city.iter()");
    println!("    .filter(|(_, emps)| emps.len() > 1)  // HAVING equivalent");
    println!("    .map(|(city, emps)| {{");
    println!("        let avg = Query::new(emps).avg(Employee::salary_r());");
    println!("        (city, emps.len(), avg)");
    println!("    }})");

    // ============================================================================
    // EXAMPLE 12: Complex query with multiple operations
    // ============================================================================
    print_separator("Example 12: Complex multi-operation query");
    print_query(
        "SELECT name, salary, age\n\
         FROM employees\n\
         WHERE department IN ('Engineering', 'Sales')\n\
         AND salary BETWEEN 80000 AND 100000\n\
         AND age >= 30\n\
         ORDER BY salary DESC;",
        "Experienced mid-to-senior level employees in core departments"
    );

    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)
        .where_(Employee::age_r(), |&age| age >= 30)
        .order_by_float_desc(Employee::salary_r());

    for emp in &complex_query {
        println!("  {}: Age {}, {} dept, ${:.2}", emp.name, emp.age, emp.department, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\" || dept == \"Sales\")");
    println!("    .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)");
    println!("    .where_(Employee::age_r(), |&age| age >= 30)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("✓ Found {} employees", complex_query.len());

    // ============================================================================
    // EXAMPLE 13: Three-table JOIN
    // ============================================================================
    print_separator("Example 13: Three-table JOIN");
    print_query(
        "SELECT p.name as project, d.name as department, d.location\n\
         FROM projects p\n\
         INNER JOIN departments d ON p.department_id = d.id;",
        "Projects with their department details"
    );

    let proj_dept = JoinQuery::new(&projects, &departments).inner_join(
        Project::department_id_r(),
        Department::id_r(),
        |proj, dept| {
            (proj.name.clone(), dept.name.clone(), dept.location.clone(), proj.budget)
        },
    );

    for (proj_name, dept_name, location, budget) in &proj_dept {
        println!("  {}: {} dept in {} (${:.0})", proj_name, dept_name, location, budget);
    }

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&projects, &departments).inner_join(");
    println!("    Project::department_id_r(),");
    println!("    Department::id_r(),");
    println!("    |proj, dept| (proj.name, dept.name, dept.location, proj.budget)");
    println!(")");

    // ============================================================================
    // EXAMPLE 14: Subquery equivalent (using intermediate results)
    // ============================================================================
    print_separator("Example 14: Subquery equivalent");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > (SELECT AVG(salary) FROM employees);",
        "Employees earning above average"
    );

    let avg_salary = Query::new(&employees)
        .avg(Employee::salary_r())
        .unwrap_or(0.0);

    let above_avg_query = Query::new(&employees)
        .where_(Employee::salary_r(), move |&sal| sal > avg_salary);
    let above_avg = above_avg_query.all();

    println!("  Average salary: ${:.2}", avg_salary);
    for emp in &above_avg {
        println!("  {}: ${:.2} ({:.1}% above average)", 
            emp.name, emp.salary, ((emp.salary - avg_salary) / avg_salary * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let avg = Query::new(&employees).avg(Employee::salary_r()).unwrap_or(0.0);");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&sal| sal > avg)");
    println!("    .all()");
    println!("✓ Found {} employees above average", above_avg.len());

    // ============================================================================
    // EXAMPLE 15: Advanced aggregation (revenue calculation)
    // ============================================================================
    print_separator("Example 15: Advanced aggregation");
    print_query(
        "SELECT \n\
         d.name,\n\
         d.budget as dept_budget,\n\
         SUM(p.budget) as total_project_budget,\n\
         (d.budget - SUM(p.budget)) as remaining_budget\n\
         FROM departments d\n\
         LEFT JOIN projects p ON d.id = p.department_id\n\
         GROUP BY d.name, d.budget;",
        "Department budget utilization"
    );

    // Join departments with projects
    let dept_projects = JoinQuery::new(&departments, &projects).left_join(
        Department::id_r(),
        Project::department_id_r(),
        |dept, proj| (dept.clone(), proj.map(|p| p.clone())),
    );

    // Aggregate by department
    let mut dept_budget_map: HashMap<String, (f64, Vec<f64>)> = HashMap::new();
    for (dept, proj) in dept_projects {
        let entry = dept_budget_map
            .entry(dept.name.clone())
            .or_insert((dept.budget, Vec::new()));
        if let Some(p) = proj {
            entry.1.push(p.budget);
        }
    }

    for (dept_name, (total_budget, project_budgets)) in dept_budget_map.iter() {
        let used: f64 = project_budgets.iter().sum();
        let remaining = total_budget - used;
        println!("  {}: Budget ${:.0}, Used ${:.0}, Remaining ${:.0} ({:.1}% utilized)",
            dept_name, total_budget, used, remaining, (used / total_budget * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let dept_projects = JoinQuery::new(&departments, &projects)");
    println!("    .left_join(Department::id_r(), Project::department_id_r(), ...)");
    println!("// Then aggregate using HashMap");

    // ============================================================================
    // Summary
    // ============================================================================
    print_separator("Summary");
    println!("\n✓ All 15 SQL queries successfully replicated with Rust Query Builder!");
    println!("\nDemonstrated equivalents for:");
    println!("  • SELECT with WHERE");
    println!("  • Projection (SELECT specific columns)");
    println!("  • Aggregations (COUNT, SUM, AVG, MIN, MAX)");
    println!("  • GROUP BY");
    println!("  • ORDER BY");
    println!("  • LIMIT and OFFSET");
    println!("  • INNER JOIN and LEFT JOIN");
    println!("  • Complex conditions (AND, OR, BETWEEN)");
    println!("  • Subqueries");
    println!("  • Multi-table operations");
    println!("\n🎯 Type-safe, compile-time checked, and zero runtime overhead!");
    println!();
}

pub fn all(&self) -> Vec<&T>

Returns all items matching the query filters.

Example

let results = query.all();

Examples found in repository

examples/doc_examples.rs (line 45)

fn main() {
    println!("Testing documentation examples...\n");

    // Example from README - Quick Start
    println!("Test 1: README Quick Start Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let affordable_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price < 100.0);
        let affordable_electronics = affordable_query.all();

        println!("  Found {} affordable electronics ✅", affordable_electronics.len());
    }

    // Example from README - Filtering
    println!("\nTest 2: Filtering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");
        let electronics = electronics_query.all();

        println!("  Found {} electronics ✅", electronics.len());
    }

    // Example from README - Selecting
    println!("\nTest 3: Selecting Fields Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let names: Vec<String> = Query::new(&products)
            .select(Product::name_r());

        println!("  Selected {} names ✅", names.len());
    }

    // Example from README - Ordering
    println!("\nTest 4: Ordering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let by_price = Query::new(&products).order_by_float(Product::price_r());
        println!("  Ordered {} products ✅", by_price.len());
    }

    // Example from README - Aggregations
    println!("\nTest 5: Aggregations Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");

        let count = electronics_query.count();
        let total_value: f64 = electronics_query.sum(Product::price_r());
        let avg_price = electronics_query.avg(Product::price_r()).unwrap_or(0.0);

        println!("  Count: {}, Total: ${:.2}, Avg: ${:.2} ✅", count, total_value, avg_price);
    }

    // Example from README - Grouping
    println!("\nTest 6: Grouping Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let by_category = Query::new(&products).group_by(Product::category_r());
        println!("  Grouped into {} categories ✅", by_category.len());
    }

    // Example from README - Pagination
    println!("\nTest 7: Pagination Example");
    {
        let products = vec![
            Product { id: 1, name: "P1".to_string(), price: 10.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 2, name: "P2".to_string(), price: 20.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 3, name: "P3".to_string(), price: 30.0, category: "A".to_string(), stock: 1, rating: 4.0 },
        ];

        let query = Query::new(&products);
        let first_10 = query.limit(10);
        let page_1 = query.skip(0).limit(10);

        println!("  Limited to {} products ✅", first_10.len());
        println!("  Page 1 has {} products ✅", page_1.len());
    }

    // Example from README - Join
    println!("\nTest 8: Join Example");
    {
        let users = vec![
            User { id: 1, name: "Alice".to_string() },
            User { id: 2, name: "Bob".to_string() },
        ];

        let orders = vec![
            Order { id: 101, user_id: 1, total: 99.99 },
            Order { id: 102, user_id: 1, total: 149.99 },
        ];

        let user_orders = JoinQuery::new(&users, &orders).inner_join(
            User::id_r(),
            Order::user_id_r(),
            |user, order| (user.name.clone(), order.total),
        );

        println!("  Joined {} user-order pairs ✅", user_orders.len());
    }

    // Example from SQL_COMPARISON - SELECT with WHERE
    println!("\nTest 9: SQL Comparison - SELECT with WHERE");
    {
        #[derive(Clone, Keypaths)]
        struct Employee {
            department: String,
        }

        let employees = vec![
            Employee { department: "Engineering".to_string() },
            Employee { department: "Sales".to_string() },
        ];

        let engineering_query = Query::new(&employees)
            .where_(Employee::department_r(), |dept| dept == "Engineering");
        let engineering = engineering_query.all();

        println!("  Found {} engineering employees ✅", engineering.len());
    }

    // Example from USAGE.md - Complex Filtering
    println!("\nTest 10: USAGE - Complex Filtering");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let results_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price >= 100.0 && price <= 500.0)
            .where_(Product::stock_r(), |&stock| stock > 10);
        let results = results_query.order_by_float(Product::price_r());

        println!("  Filtered {} products ✅", results.len());
    }

    println!("\n✅ All documentation examples compile and run successfully!");
}

examples/advanced_query_builder.rs (line 243)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_verification.rs (line 91)

fn main() {
    let employees = create_test_data();
    
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  SQL Equivalence Verification Tests                           ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // TEST 1: ORDER BY maintains exact SQL ordering (DESC)
    println!("Test 1: ORDER BY DESC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC;");
    
    let ordered = Query::new(&employees).order_by_float_desc(Employee::salary_r());
    let expected_order = vec![105000.0, 95000.0, 87000.0, 82000.0, 75000.0, 71000.0];
    let actual_order: Vec<f64> = ordered.iter().map(|e| e.salary).collect();
    
    let test1_pass = expected_order == actual_order;
    print_test("ORDER BY salary DESC produces correct order", test1_pass);
    if !test1_pass {
        println!("  Expected: {:?}", expected_order);
        println!("  Got: {:?}", actual_order);
    }

    // TEST 2: ORDER BY maintains exact SQL ordering (ASC)
    println!("\nTest 2: ORDER BY ASC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary ASC;");
    
    let ordered_asc = Query::new(&employees).order_by_float(Employee::salary_r());
    let expected_asc = vec![71000.0, 75000.0, 82000.0, 87000.0, 95000.0, 105000.0];
    let actual_asc: Vec<f64> = ordered_asc.iter().map(|e| e.salary).collect();
    
    let test2_pass = expected_asc == actual_asc;
    print_test("ORDER BY salary ASC produces correct order", test2_pass);
    if !test2_pass {
        println!("  Expected: {:?}", expected_asc);
        println!("  Got: {:?}", actual_asc);
    }

    // TEST 3: String ordering (alphabetical)
    println!("\nTest 3: ORDER BY name (alphabetical)");
    println!("SQL: SELECT name FROM employees ORDER BY name;");
    
    let ordered_names = Query::new(&employees).order_by(Employee::name_r());
    let expected_names = vec!["Alice Cooper", "Alice Johnson", "Bob Smith", "Carol White", "David Brown", "Eve Davis"];
    let actual_names: Vec<&str> = ordered_names.iter().map(|e| e.name.as_str()).collect();
    
    let test3_pass = expected_names == actual_names;
    print_test("ORDER BY name produces correct alphabetical order", test3_pass);
    if !test3_pass {
        println!("  Expected: {:?}", expected_names);
        println!("  Got: {:?}", actual_names);
    }

    // TEST 4: LIKE equivalent - starts with
    println!("\nTest 4: LIKE 'Alice%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE 'Alice%';");
    
    let like_alice_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.starts_with("Alice"));
    let like_alice = like_alice_query.all();
    
    let test4_pass = like_alice.len() == 2 
        && like_alice.iter().all(|e| e.name.starts_with("Alice"));
    print_test("LIKE 'Alice%' (starts_with) works correctly", test4_pass);
    if test4_pass {
        for emp in &like_alice {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 5: LIKE equivalent - ends with
    println!("\nTest 5: LIKE '%son' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%son';");
    
    let like_son_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.ends_with("son"));
    let like_son = like_son_query.all();
    
    let test5_pass = like_son.len() == 1 && like_son[0].name == "Alice Johnson";
    print_test("LIKE '%son' (ends_with) works correctly", test5_pass);
    if test5_pass {
        for emp in &like_son {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 6: LIKE equivalent - contains
    println!("\nTest 6: LIKE '%mit%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%mit%';");
    
    let like_mit_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.contains("mit"));
    let like_mit = like_mit_query.all();
    
    let test6_pass = like_mit.len() == 1 && like_mit[0].name == "Bob Smith";
    print_test("LIKE '%mit%' (contains) works correctly", test6_pass);
    if test6_pass {
        for emp in &like_mit {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 7: IN clause equivalent
    println!("\nTest 7: IN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE department IN ('Engineering', 'Sales');");
    
    let in_depts_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales");
    let in_depts = in_depts_query.all();
    
    let test7_pass = in_depts.len() == 5 // 3 Engineering + 2 Sales
        && in_depts.iter().all(|e| e.department == "Engineering" || e.department == "Sales");
    print_test("IN clause works correctly", test7_pass);
    println!("  Found {} employees in Engineering or Sales", in_depts.len());

    // TEST 8: BETWEEN equivalent
    println!("\nTest 8: BETWEEN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE salary BETWEEN 75000 AND 90000;");
    
    let between_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal >= 75000.0 && sal <= 90000.0);
    let between = between_query.all();
    
    let test8_pass = between.len() == 3;
    print_test("BETWEEN clause works correctly", test8_pass);
    println!("  Found {} employees with salary between 75K-90K", between.len());

    // TEST 9: COUNT with WHERE
    println!("\nTest 9: COUNT with WHERE");
    println!("SQL: SELECT COUNT(*) FROM employees WHERE department = 'Engineering';");
    
    let count_eng = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .count();
    
    let test9_pass = count_eng == 3;
    print_test("COUNT with WHERE produces correct result", test9_pass);
    println!("  Count: {} (expected 3)", count_eng);

    // TEST 10: AVG produces exact result
    println!("\nTest 10: AVG aggregation accuracy");
    println!("SQL: SELECT AVG(salary) FROM employees WHERE department = 'Engineering';");
    
    let avg_sal = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .avg(Employee::salary_r())
        .unwrap_or(0.0);
    
    let expected_avg = (95000.0 + 87000.0 + 105000.0) / 3.0;
    let test10_pass = (avg_sal - expected_avg).abs() < 0.01;
    print_test("AVG produces mathematically correct result", test10_pass);
    println!("  Average: ${:.2} (expected ${:.2})", avg_sal, expected_avg);

    // TEST 11: MIN and MAX
    println!("\nTest 11: MIN and MAX aggregations");
    println!("SQL: SELECT MIN(salary), MAX(salary) FROM employees;");
    
    let min_sal = Query::new(&employees).min_float(Employee::salary_r()).unwrap_or(0.0);
    let max_sal = Query::new(&employees).max_float(Employee::salary_r()).unwrap_or(0.0);
    
    let test11_pass = min_sal == 71000.0 && max_sal == 105000.0;
    print_test("MIN and MAX produce correct results", test11_pass);
    println!("  MIN: ${:.2}, MAX: ${:.2}", min_sal, max_sal);

    // TEST 12: Complex WHERE with AND/OR
    println!("\nTest 12: Complex WHERE (AND + OR)");
    println!("SQL: SELECT * FROM employees WHERE (department = 'Engineering' OR department = 'Sales') AND salary > 80000;");
    
    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal > 80000.0);
    let complex = complex_query.all();
    
    let test12_pass = complex.len() == 4; // Alice J ($95k), Bob ($87k), David ($82k), Alice C ($105k)
    print_test("Complex WHERE clause works correctly", test12_pass);
    println!("  Found {} employees", complex.len());

    // TEST 13: Case-sensitive string comparison (SQL default)
    println!("\nTest 13: Case-sensitive comparison (like SQL)");
    println!("SQL: SELECT * FROM employees WHERE department = 'engineering'; -- should find 0");
    
    let case_sensitive = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "engineering") // lowercase
        .count();
    
    let test13_pass = case_sensitive == 0;
    print_test("Case-sensitive comparison (SQL default)", test13_pass);
    println!("  Found {} with lowercase 'engineering' (expected 0)", case_sensitive);

    // TEST 14: Case-insensitive LIKE equivalent
    println!("\nTest 14: Case-insensitive LIKE (ILIKE equivalent)");
    println!("SQL: SELECT * FROM employees WHERE LOWER(name) LIKE '%alice%';");
    
    let ilike_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.to_lowercase().contains("alice"));
    let ilike = ilike_query.all();
    
    let test14_pass = ilike.len() == 2;
    print_test("Case-insensitive LIKE works correctly", test14_pass);
    println!("  Found {} employees with 'alice' (case-insensitive)", ilike.len());

    // TEST 15: LIMIT produces exact subset
    println!("\nTest 15: LIMIT clause");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC LIMIT 3;");
    
    let limited = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r())
        .into_iter()
        .take(3)
        .collect::<Vec<_>>();
    
    let test15_pass = limited.len() == 3 
        && limited[0].salary == 105000.0
        && limited[1].salary == 95000.0
        && limited[2].salary == 87000.0;
    print_test("LIMIT returns correct top-N results", test15_pass);
    println!("  Top 3 salaries: ${:.0}, ${:.0}, ${:.0}", 
        limited[0].salary, limited[1].salary, limited[2].salary);

    // TEST 16: GROUP BY produces correct groups
    println!("\nTest 16: GROUP BY");
    println!("SQL: SELECT department, COUNT(*) FROM employees GROUP BY department;");
    
    let grouped = Query::new(&employees).group_by(Employee::department_r());
    let eng_count = grouped.get("Engineering").map(|v| v.len()).unwrap_or(0);
    let sales_count = grouped.get("Sales").map(|v| v.len()).unwrap_or(0);
    let marketing_count = grouped.get("Marketing").map(|v| v.len()).unwrap_or(0);
    
    let test16_pass = eng_count == 3 && sales_count == 2 && marketing_count == 1;
    print_test("GROUP BY produces correct counts", test16_pass);
    println!("  Engineering: {}, Sales: {}, Marketing: {}", eng_count, sales_count, marketing_count);

    // TEST 17: Email pattern matching (regex-like)
    println!("\nTest 17: Email domain filtering (LIKE '%@example.com')");
    println!("SQL: SELECT * FROM employees WHERE email LIKE '%@example.com';");
    
    let example_emails = Query::new(&employees)
        .where_(Employee::email_r(), |email| email.ends_with("@example.com"))
        .count();
    
    let test17_pass = example_emails == 6; // All employees have @example.com emails
    print_test("Email pattern matching works correctly", test17_pass);
    println!("  Found {} employees with @example.com emails", example_emails);

    // Summary
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Test Summary                                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");
    
    let tests = vec![
        ("ORDER BY DESC", test1_pass),
        ("ORDER BY ASC", test2_pass),
        ("ORDER BY name", test3_pass),
        ("LIKE 'prefix%'", test4_pass),
        ("LIKE '%suffix'", test5_pass),
        ("LIKE '%contains%'", test6_pass),
        ("IN clause", test7_pass),
        ("BETWEEN clause", test8_pass),
        ("COUNT", test9_pass),
        ("AVG accuracy", test10_pass),
        ("MIN/MAX", test11_pass),
        ("Complex WHERE", test12_pass),
        ("Case-sensitive", test13_pass),
        ("Case-insensitive", test14_pass),
        ("LIMIT", test15_pass),
        ("GROUP BY", test16_pass),
        ("Email patterns", test17_pass),
    ];
    
    let passed = tests.iter().filter(|(_, p)| *p).count();
    let total = tests.len();
    
    println!("Results: {}/{} tests passed", passed, total);
    
    if passed == total {
        println!("\n🎉 All tests PASSED! Rust Query Builder produces exact SQL-equivalent results!");
        println!("\n✅ Verified:");
        println!("  • Exact ordering (ASC/DESC)");
        println!("  • LIKE operations (starts_with, ends_with, contains)");
        println!("  • IN clause (OR conditions)");
        println!("  • BETWEEN clause");
        println!("  • Aggregations (COUNT, AVG, MIN, MAX)");
        println!("  • Complex WHERE conditions");
        println!("  • Case sensitivity");
        println!("  • LIMIT clause");
        println!("  • GROUP BY");
        println!("  • Pattern matching");
    } else {
        println!("\n⚠️  {} test(s) failed. See details above.", total - passed);
    }
}

examples/sql_comparison.rs (line 105)

fn main() {
    let employees = create_employees();
    let departments = create_departments();
    let projects = create_projects();

    println!("\n╔════════════════════════════════════════════════════════════════════════╗");
    println!("║     SQL vs Rust Query Builder Comparison                              ║");
    println!("║     Demonstrating equivalent operations                               ║");
    println!("╚════════════════════════════════════════════════════════════════════════╝");

    // ============================================================================
    // EXAMPLE 1: Simple SELECT with WHERE
    // ============================================================================
    print_separator("Example 1: SELECT with WHERE clause");
    print_query(
        "SELECT * FROM employees WHERE department = 'Engineering';",
        "Filter employees by department"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering_employees = eng_query.all();

    for emp in &engineering_employees {
        println!("  ID: {}, Name: {}, Salary: ${:.2}", emp.id, emp.name, emp.salary);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\")");
    println!("    .all()");
    println!("✓ Found {} employees", engineering_employees.len());

    // ============================================================================
    // EXAMPLE 2: SELECT specific columns
    // ============================================================================
    print_separator("Example 2: SELECT specific columns (Projection)");
    print_query(
        "SELECT name FROM employees WHERE salary > 80000;",
        "Get names of high-earning employees"
    );

    let high_earners = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 80000.0)
        .select(Employee::name_r());

    for name in &high_earners {
        println!("  {}", name);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 80000.0)");
    println!("    .select(Employee::name_r())");
    println!("✓ Found {} employees", high_earners.len());

    // ============================================================================
    // EXAMPLE 3: COUNT
    // ============================================================================
    print_separator("Example 3: COUNT aggregation");
    print_query(
        "SELECT COUNT(*) FROM employees WHERE age < 30;",
        "Count young employees"
    );

    let young_count = Query::new(&employees)
        .where_(Employee::age_r(), |&age| age < 30)
        .count();

    println!("  Count: {}", young_count);
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::age_r(), |&age| age < 30)");
    println!("    .count()");
    println!("✓ Result: {}", young_count);

    // ============================================================================
    // EXAMPLE 4: SUM, AVG, MIN, MAX
    // ============================================================================
    print_separator("Example 4: Aggregate functions (SUM, AVG, MIN, MAX)");
    print_query(
        "SELECT \n\
         SUM(salary) as total_salary,\n\
         AVG(salary) as avg_salary,\n\
         MIN(salary) as min_salary,\n\
         MAX(salary) as max_salary\n\
         FROM employees WHERE department = 'Engineering';",
        "Engineering department salary statistics"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");

    let total = eng_query.sum(Employee::salary_r());
    let avg = eng_query.avg(Employee::salary_r()).unwrap_or(0.0);
    let min = eng_query.min_float(Employee::salary_r()).unwrap_or(0.0);
    let max = eng_query.max_float(Employee::salary_r()).unwrap_or(0.0);

    println!("  Total Salary: ${:.2}", total);
    println!("  Avg Salary:   ${:.2}", avg);
    println!("  Min Salary:   ${:.2}", min);
    println!("  Max Salary:   ${:.2}", max);

    println!("\nRust Query Builder:");
    println!("let query = Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\");");
    println!("query.sum(Employee::salary_r())  // ${:.2}", total);
    println!("query.avg(Employee::salary_r())  // ${:.2}", avg);
    println!("query.min_float(Employee::salary_r())  // ${:.2}", min);
    println!("query.max_float(Employee::salary_r())  // ${:.2}", max);

    // ============================================================================
    // EXAMPLE 5: GROUP BY with aggregation
    // ============================================================================
    print_separator("Example 5: GROUP BY with aggregation");
    print_query(
        "SELECT \n\
         department,\n\
         COUNT(*) as emp_count,\n\
         AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY department;",
        "Statistics by department"
    );

    let by_dept = Query::new(&employees).group_by(Employee::department_r());

    for (dept, emps) in &by_dept {
        let dept_query = Query::new(emps);
        let count = emps.len();
        let avg_sal = dept_query.avg(Employee::salary_r()).unwrap_or(0.0);
        println!("  {}: {} employees, avg salary ${:.2}", dept, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_dept = Query::new(&employees).group_by(Employee::department_r());");
    println!("for (dept, emps) in &by_dept {{");
    println!("    let dept_query = Query::new(emps);");
    println!("    dept_query.avg(Employee::salary_r())");
    println!("}}");

    // ============================================================================
    // EXAMPLE 6: ORDER BY
    // ============================================================================
    print_separator("Example 6: ORDER BY");
    print_query(
        "SELECT name, salary FROM employees\n\
         WHERE department = 'Sales'\n\
         ORDER BY salary DESC;",
        "Sales employees ordered by salary (descending)"
    );

    let sales_sorted = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .order_by_float_desc(Employee::salary_r());

    for emp in &sales_sorted {
        println!("  {}: ${:.2}", emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Sales\")");
    println!("    .order_by_float_desc(Employee::salary_r())");

    // ============================================================================
    // EXAMPLE 7: Multiple WHERE conditions (AND)
    // ============================================================================
    print_separator("Example 7: Multiple WHERE conditions (AND)");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > 70000 AND age < 35;",
        "High-earning young employees"
    );

    let filter_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 70000.0)
        .where_(Employee::age_r(), |&age| age < 35);
    let filtered = filter_query.all();

    for emp in &filtered {
        println!("  {}: Age {}, Salary ${:.2}", emp.name, emp.age, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 70000.0)");
    println!("    .where_(Employee::age_r(), |&age| age < 35)");
    println!("    .all()");
    println!("✓ Found {} employees", filtered.len());

    // ============================================================================
    // EXAMPLE 8: LIMIT (TOP N)
    // ============================================================================
    print_separator("Example 8: LIMIT / TOP N");
    print_query(
        "SELECT TOP 3 name, salary FROM employees\n\
         ORDER BY salary DESC;",
        "Top 3 highest paid employees"
    );

    let top_earners = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r());

    for (i, emp) in top_earners.iter().take(3).enumerate() {
        println!("  {}. {}: ${:.2}", i + 1, emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("    .into_iter().take(3)");

    // ============================================================================
    // EXAMPLE 9: OFFSET and LIMIT (Pagination)
    // ============================================================================
    print_separator("Example 9: OFFSET and LIMIT (Pagination)");
    print_query(
        "SELECT name FROM employees\n\
         ORDER BY name\n\
         LIMIT 3 OFFSET 3;",
        "Page 2 of employee names (3 per page)"
    );

    let page_2 = Query::new(&employees)
        .order_by(Employee::name_r())
        .into_iter()
        .skip(3)
        .take(3)
        .collect::<Vec<_>>();

    for emp in &page_2 {
        println!("  {}", emp.name);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by(Employee::name_r())");
    println!("    .into_iter().skip(3).take(3)");

    // ============================================================================
    // EXAMPLE 10: INNER JOIN
    // ============================================================================
    print_separator("Example 10: INNER JOIN");
    print_query(
        "SELECT e.name, d.name as dept_name, d.budget\n\
         FROM employees e\n\
         INNER JOIN departments d ON e.department = d.name;",
        "Employees with their department info"
    );

    let emp_dept = JoinQuery::new(&employees, &departments).inner_join(
        Employee::department_r(),
        Department::name_r(),
        |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget),
    );

    for (emp_name, dept_name, budget) in emp_dept.iter().take(5) {
        println!("  {} works in {} (Budget: ${:.0})", emp_name, dept_name, budget);
    }
    println!("  ... (showing first 5)");

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&employees, &departments).inner_join(");
    println!("    Employee::department_r(),");
    println!("    Department::name_r(),");
    println!("    |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget)");
    println!(")");
    println!("✓ Found {} matches", emp_dept.len());

    // ============================================================================
    // EXAMPLE 11: GROUP BY with HAVING equivalent
    // ============================================================================
    print_separator("Example 11: GROUP BY with filtering (HAVING equivalent)");
    print_query(
        "SELECT city, COUNT(*) as emp_count, AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY city\n\
         HAVING COUNT(*) > 1;",
        "Cities with multiple employees"
    );

    let by_city = Query::new(&employees).group_by(Employee::city_r());
    let mut city_stats: Vec<_> = by_city
        .iter()
        .filter(|(_, emps)| emps.len() > 1) // HAVING equivalent
        .map(|(city, emps)| {
            let avg_sal = Query::new(emps).avg(Employee::salary_r()).unwrap_or(0.0);
            (city.clone(), emps.len(), avg_sal)
        })
        .collect();
    
    city_stats.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count

    for (city, count, avg_sal) in &city_stats {
        println!("  {}: {} employees, avg salary ${:.2}", city, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_city = Query::new(&employees).group_by(Employee::city_r());");
    println!("by_city.iter()");
    println!("    .filter(|(_, emps)| emps.len() > 1)  // HAVING equivalent");
    println!("    .map(|(city, emps)| {{");
    println!("        let avg = Query::new(emps).avg(Employee::salary_r());");
    println!("        (city, emps.len(), avg)");
    println!("    }})");

    // ============================================================================
    // EXAMPLE 12: Complex query with multiple operations
    // ============================================================================
    print_separator("Example 12: Complex multi-operation query");
    print_query(
        "SELECT name, salary, age\n\
         FROM employees\n\
         WHERE department IN ('Engineering', 'Sales')\n\
         AND salary BETWEEN 80000 AND 100000\n\
         AND age >= 30\n\
         ORDER BY salary DESC;",
        "Experienced mid-to-senior level employees in core departments"
    );

    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)
        .where_(Employee::age_r(), |&age| age >= 30)
        .order_by_float_desc(Employee::salary_r());

    for emp in &complex_query {
        println!("  {}: Age {}, {} dept, ${:.2}", emp.name, emp.age, emp.department, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\" || dept == \"Sales\")");
    println!("    .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)");
    println!("    .where_(Employee::age_r(), |&age| age >= 30)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("✓ Found {} employees", complex_query.len());

    // ============================================================================
    // EXAMPLE 13: Three-table JOIN
    // ============================================================================
    print_separator("Example 13: Three-table JOIN");
    print_query(
        "SELECT p.name as project, d.name as department, d.location\n\
         FROM projects p\n\
         INNER JOIN departments d ON p.department_id = d.id;",
        "Projects with their department details"
    );

    let proj_dept = JoinQuery::new(&projects, &departments).inner_join(
        Project::department_id_r(),
        Department::id_r(),
        |proj, dept| {
            (proj.name.clone(), dept.name.clone(), dept.location.clone(), proj.budget)
        },
    );

    for (proj_name, dept_name, location, budget) in &proj_dept {
        println!("  {}: {} dept in {} (${:.0})", proj_name, dept_name, location, budget);
    }

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&projects, &departments).inner_join(");
    println!("    Project::department_id_r(),");
    println!("    Department::id_r(),");
    println!("    |proj, dept| (proj.name, dept.name, dept.location, proj.budget)");
    println!(")");

    // ============================================================================
    // EXAMPLE 14: Subquery equivalent (using intermediate results)
    // ============================================================================
    print_separator("Example 14: Subquery equivalent");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > (SELECT AVG(salary) FROM employees);",
        "Employees earning above average"
    );

    let avg_salary = Query::new(&employees)
        .avg(Employee::salary_r())
        .unwrap_or(0.0);

    let above_avg_query = Query::new(&employees)
        .where_(Employee::salary_r(), move |&sal| sal > avg_salary);
    let above_avg = above_avg_query.all();

    println!("  Average salary: ${:.2}", avg_salary);
    for emp in &above_avg {
        println!("  {}: ${:.2} ({:.1}% above average)", 
            emp.name, emp.salary, ((emp.salary - avg_salary) / avg_salary * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let avg = Query::new(&employees).avg(Employee::salary_r()).unwrap_or(0.0);");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&sal| sal > avg)");
    println!("    .all()");
    println!("✓ Found {} employees above average", above_avg.len());

    // ============================================================================
    // EXAMPLE 15: Advanced aggregation (revenue calculation)
    // ============================================================================
    print_separator("Example 15: Advanced aggregation");
    print_query(
        "SELECT \n\
         d.name,\n\
         d.budget as dept_budget,\n\
         SUM(p.budget) as total_project_budget,\n\
         (d.budget - SUM(p.budget)) as remaining_budget\n\
         FROM departments d\n\
         LEFT JOIN projects p ON d.id = p.department_id\n\
         GROUP BY d.name, d.budget;",
        "Department budget utilization"
    );

    // Join departments with projects
    let dept_projects = JoinQuery::new(&departments, &projects).left_join(
        Department::id_r(),
        Project::department_id_r(),
        |dept, proj| (dept.clone(), proj.map(|p| p.clone())),
    );

    // Aggregate by department
    let mut dept_budget_map: HashMap<String, (f64, Vec<f64>)> = HashMap::new();
    for (dept, proj) in dept_projects {
        let entry = dept_budget_map
            .entry(dept.name.clone())
            .or_insert((dept.budget, Vec::new()));
        if let Some(p) = proj {
            entry.1.push(p.budget);
        }
    }

    for (dept_name, (total_budget, project_budgets)) in dept_budget_map.iter() {
        let used: f64 = project_budgets.iter().sum();
        let remaining = total_budget - used;
        println!("  {}: Budget ${:.0}, Used ${:.0}, Remaining ${:.0} ({:.1}% utilized)",
            dept_name, total_budget, used, remaining, (used / total_budget * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let dept_projects = JoinQuery::new(&departments, &projects)");
    println!("    .left_join(Department::id_r(), Project::department_id_r(), ...)");
    println!("// Then aggregate using HashMap");

    // ============================================================================
    // Summary
    // ============================================================================
    print_separator("Summary");
    println!("\n✓ All 15 SQL queries successfully replicated with Rust Query Builder!");
    println!("\nDemonstrated equivalents for:");
    println!("  • SELECT with WHERE");
    println!("  • Projection (SELECT specific columns)");
    println!("  • Aggregations (COUNT, SUM, AVG, MIN, MAX)");
    println!("  • GROUP BY");
    println!("  • ORDER BY");
    println!("  • LIMIT and OFFSET");
    println!("  • INNER JOIN and LEFT JOIN");
    println!("  • Complex conditions (AND, OR, BETWEEN)");
    println!("  • Subqueries");
    println!("  • Multi-table operations");
    println!("\n🎯 Type-safe, compile-time checked, and zero runtime overhead!");
    println!();
}

pub fn first(&self) -> Option<&T>

Returns the first item matching the query filters.

Example

let first = query.first();

Examples found in repository

examples/advanced_query_builder.rs (line 194)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

pub fn count(&self) -> usize

Returns the count of items matching the query filters.

Example

let count = query.count();

Examples found in repository

examples/doc_examples.rs (line 101)

fn main() {
    println!("Testing documentation examples...\n");

    // Example from README - Quick Start
    println!("Test 1: README Quick Start Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let affordable_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price < 100.0);
        let affordable_electronics = affordable_query.all();

        println!("  Found {} affordable electronics ✅", affordable_electronics.len());
    }

    // Example from README - Filtering
    println!("\nTest 2: Filtering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");
        let electronics = electronics_query.all();

        println!("  Found {} electronics ✅", electronics.len());
    }

    // Example from README - Selecting
    println!("\nTest 3: Selecting Fields Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let names: Vec<String> = Query::new(&products)
            .select(Product::name_r());

        println!("  Selected {} names ✅", names.len());
    }

    // Example from README - Ordering
    println!("\nTest 4: Ordering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let by_price = Query::new(&products).order_by_float(Product::price_r());
        println!("  Ordered {} products ✅", by_price.len());
    }

    // Example from README - Aggregations
    println!("\nTest 5: Aggregations Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");

        let count = electronics_query.count();
        let total_value: f64 = electronics_query.sum(Product::price_r());
        let avg_price = electronics_query.avg(Product::price_r()).unwrap_or(0.0);

        println!("  Count: {}, Total: ${:.2}, Avg: ${:.2} ✅", count, total_value, avg_price);
    }

    // Example from README - Grouping
    println!("\nTest 6: Grouping Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let by_category = Query::new(&products).group_by(Product::category_r());
        println!("  Grouped into {} categories ✅", by_category.len());
    }

    // Example from README - Pagination
    println!("\nTest 7: Pagination Example");
    {
        let products = vec![
            Product { id: 1, name: "P1".to_string(), price: 10.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 2, name: "P2".to_string(), price: 20.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 3, name: "P3".to_string(), price: 30.0, category: "A".to_string(), stock: 1, rating: 4.0 },
        ];

        let query = Query::new(&products);
        let first_10 = query.limit(10);
        let page_1 = query.skip(0).limit(10);

        println!("  Limited to {} products ✅", first_10.len());
        println!("  Page 1 has {} products ✅", page_1.len());
    }

    // Example from README - Join
    println!("\nTest 8: Join Example");
    {
        let users = vec![
            User { id: 1, name: "Alice".to_string() },
            User { id: 2, name: "Bob".to_string() },
        ];

        let orders = vec![
            Order { id: 101, user_id: 1, total: 99.99 },
            Order { id: 102, user_id: 1, total: 149.99 },
        ];

        let user_orders = JoinQuery::new(&users, &orders).inner_join(
            User::id_r(),
            Order::user_id_r(),
            |user, order| (user.name.clone(), order.total),
        );

        println!("  Joined {} user-order pairs ✅", user_orders.len());
    }

    // Example from SQL_COMPARISON - SELECT with WHERE
    println!("\nTest 9: SQL Comparison - SELECT with WHERE");
    {
        #[derive(Clone, Keypaths)]
        struct Employee {
            department: String,
        }

        let employees = vec![
            Employee { department: "Engineering".to_string() },
            Employee { department: "Sales".to_string() },
        ];

        let engineering_query = Query::new(&employees)
            .where_(Employee::department_r(), |dept| dept == "Engineering");
        let engineering = engineering_query.all();

        println!("  Found {} engineering employees ✅", engineering.len());
    }

    // Example from USAGE.md - Complex Filtering
    println!("\nTest 10: USAGE - Complex Filtering");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let results_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price >= 100.0 && price <= 500.0)
            .where_(Product::stock_r(), |&stock| stock > 10);
        let results = results_query.order_by_float(Product::price_r());

        println!("  Filtered {} products ✅", results.len());
    }

    println!("\n✅ All documentation examples compile and run successfully!");
}

examples/advanced_query_builder.rs (line 153)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_verification.rs (line 165)

fn main() {
    let employees = create_test_data();
    
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  SQL Equivalence Verification Tests                           ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // TEST 1: ORDER BY maintains exact SQL ordering (DESC)
    println!("Test 1: ORDER BY DESC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC;");
    
    let ordered = Query::new(&employees).order_by_float_desc(Employee::salary_r());
    let expected_order = vec![105000.0, 95000.0, 87000.0, 82000.0, 75000.0, 71000.0];
    let actual_order: Vec<f64> = ordered.iter().map(|e| e.salary).collect();
    
    let test1_pass = expected_order == actual_order;
    print_test("ORDER BY salary DESC produces correct order", test1_pass);
    if !test1_pass {
        println!("  Expected: {:?}", expected_order);
        println!("  Got: {:?}", actual_order);
    }

    // TEST 2: ORDER BY maintains exact SQL ordering (ASC)
    println!("\nTest 2: ORDER BY ASC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary ASC;");
    
    let ordered_asc = Query::new(&employees).order_by_float(Employee::salary_r());
    let expected_asc = vec![71000.0, 75000.0, 82000.0, 87000.0, 95000.0, 105000.0];
    let actual_asc: Vec<f64> = ordered_asc.iter().map(|e| e.salary).collect();
    
    let test2_pass = expected_asc == actual_asc;
    print_test("ORDER BY salary ASC produces correct order", test2_pass);
    if !test2_pass {
        println!("  Expected: {:?}", expected_asc);
        println!("  Got: {:?}", actual_asc);
    }

    // TEST 3: String ordering (alphabetical)
    println!("\nTest 3: ORDER BY name (alphabetical)");
    println!("SQL: SELECT name FROM employees ORDER BY name;");
    
    let ordered_names = Query::new(&employees).order_by(Employee::name_r());
    let expected_names = vec!["Alice Cooper", "Alice Johnson", "Bob Smith", "Carol White", "David Brown", "Eve Davis"];
    let actual_names: Vec<&str> = ordered_names.iter().map(|e| e.name.as_str()).collect();
    
    let test3_pass = expected_names == actual_names;
    print_test("ORDER BY name produces correct alphabetical order", test3_pass);
    if !test3_pass {
        println!("  Expected: {:?}", expected_names);
        println!("  Got: {:?}", actual_names);
    }

    // TEST 4: LIKE equivalent - starts with
    println!("\nTest 4: LIKE 'Alice%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE 'Alice%';");
    
    let like_alice_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.starts_with("Alice"));
    let like_alice = like_alice_query.all();
    
    let test4_pass = like_alice.len() == 2 
        && like_alice.iter().all(|e| e.name.starts_with("Alice"));
    print_test("LIKE 'Alice%' (starts_with) works correctly", test4_pass);
    if test4_pass {
        for emp in &like_alice {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 5: LIKE equivalent - ends with
    println!("\nTest 5: LIKE '%son' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%son';");
    
    let like_son_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.ends_with("son"));
    let like_son = like_son_query.all();
    
    let test5_pass = like_son.len() == 1 && like_son[0].name == "Alice Johnson";
    print_test("LIKE '%son' (ends_with) works correctly", test5_pass);
    if test5_pass {
        for emp in &like_son {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 6: LIKE equivalent - contains
    println!("\nTest 6: LIKE '%mit%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%mit%';");
    
    let like_mit_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.contains("mit"));
    let like_mit = like_mit_query.all();
    
    let test6_pass = like_mit.len() == 1 && like_mit[0].name == "Bob Smith";
    print_test("LIKE '%mit%' (contains) works correctly", test6_pass);
    if test6_pass {
        for emp in &like_mit {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 7: IN clause equivalent
    println!("\nTest 7: IN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE department IN ('Engineering', 'Sales');");
    
    let in_depts_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales");
    let in_depts = in_depts_query.all();
    
    let test7_pass = in_depts.len() == 5 // 3 Engineering + 2 Sales
        && in_depts.iter().all(|e| e.department == "Engineering" || e.department == "Sales");
    print_test("IN clause works correctly", test7_pass);
    println!("  Found {} employees in Engineering or Sales", in_depts.len());

    // TEST 8: BETWEEN equivalent
    println!("\nTest 8: BETWEEN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE salary BETWEEN 75000 AND 90000;");
    
    let between_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal >= 75000.0 && sal <= 90000.0);
    let between = between_query.all();
    
    let test8_pass = between.len() == 3;
    print_test("BETWEEN clause works correctly", test8_pass);
    println!("  Found {} employees with salary between 75K-90K", between.len());

    // TEST 9: COUNT with WHERE
    println!("\nTest 9: COUNT with WHERE");
    println!("SQL: SELECT COUNT(*) FROM employees WHERE department = 'Engineering';");
    
    let count_eng = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .count();
    
    let test9_pass = count_eng == 3;
    print_test("COUNT with WHERE produces correct result", test9_pass);
    println!("  Count: {} (expected 3)", count_eng);

    // TEST 10: AVG produces exact result
    println!("\nTest 10: AVG aggregation accuracy");
    println!("SQL: SELECT AVG(salary) FROM employees WHERE department = 'Engineering';");
    
    let avg_sal = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .avg(Employee::salary_r())
        .unwrap_or(0.0);
    
    let expected_avg = (95000.0 + 87000.0 + 105000.0) / 3.0;
    let test10_pass = (avg_sal - expected_avg).abs() < 0.01;
    print_test("AVG produces mathematically correct result", test10_pass);
    println!("  Average: ${:.2} (expected ${:.2})", avg_sal, expected_avg);

    // TEST 11: MIN and MAX
    println!("\nTest 11: MIN and MAX aggregations");
    println!("SQL: SELECT MIN(salary), MAX(salary) FROM employees;");
    
    let min_sal = Query::new(&employees).min_float(Employee::salary_r()).unwrap_or(0.0);
    let max_sal = Query::new(&employees).max_float(Employee::salary_r()).unwrap_or(0.0);
    
    let test11_pass = min_sal == 71000.0 && max_sal == 105000.0;
    print_test("MIN and MAX produce correct results", test11_pass);
    println!("  MIN: ${:.2}, MAX: ${:.2}", min_sal, max_sal);

    // TEST 12: Complex WHERE with AND/OR
    println!("\nTest 12: Complex WHERE (AND + OR)");
    println!("SQL: SELECT * FROM employees WHERE (department = 'Engineering' OR department = 'Sales') AND salary > 80000;");
    
    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal > 80000.0);
    let complex = complex_query.all();
    
    let test12_pass = complex.len() == 4; // Alice J ($95k), Bob ($87k), David ($82k), Alice C ($105k)
    print_test("Complex WHERE clause works correctly", test12_pass);
    println!("  Found {} employees", complex.len());

    // TEST 13: Case-sensitive string comparison (SQL default)
    println!("\nTest 13: Case-sensitive comparison (like SQL)");
    println!("SQL: SELECT * FROM employees WHERE department = 'engineering'; -- should find 0");
    
    let case_sensitive = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "engineering") // lowercase
        .count();
    
    let test13_pass = case_sensitive == 0;
    print_test("Case-sensitive comparison (SQL default)", test13_pass);
    println!("  Found {} with lowercase 'engineering' (expected 0)", case_sensitive);

    // TEST 14: Case-insensitive LIKE equivalent
    println!("\nTest 14: Case-insensitive LIKE (ILIKE equivalent)");
    println!("SQL: SELECT * FROM employees WHERE LOWER(name) LIKE '%alice%';");
    
    let ilike_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.to_lowercase().contains("alice"));
    let ilike = ilike_query.all();
    
    let test14_pass = ilike.len() == 2;
    print_test("Case-insensitive LIKE works correctly", test14_pass);
    println!("  Found {} employees with 'alice' (case-insensitive)", ilike.len());

    // TEST 15: LIMIT produces exact subset
    println!("\nTest 15: LIMIT clause");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC LIMIT 3;");
    
    let limited = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r())
        .into_iter()
        .take(3)
        .collect::<Vec<_>>();
    
    let test15_pass = limited.len() == 3 
        && limited[0].salary == 105000.0
        && limited[1].salary == 95000.0
        && limited[2].salary == 87000.0;
    print_test("LIMIT returns correct top-N results", test15_pass);
    println!("  Top 3 salaries: ${:.0}, ${:.0}, ${:.0}", 
        limited[0].salary, limited[1].salary, limited[2].salary);

    // TEST 16: GROUP BY produces correct groups
    println!("\nTest 16: GROUP BY");
    println!("SQL: SELECT department, COUNT(*) FROM employees GROUP BY department;");
    
    let grouped = Query::new(&employees).group_by(Employee::department_r());
    let eng_count = grouped.get("Engineering").map(|v| v.len()).unwrap_or(0);
    let sales_count = grouped.get("Sales").map(|v| v.len()).unwrap_or(0);
    let marketing_count = grouped.get("Marketing").map(|v| v.len()).unwrap_or(0);
    
    let test16_pass = eng_count == 3 && sales_count == 2 && marketing_count == 1;
    print_test("GROUP BY produces correct counts", test16_pass);
    println!("  Engineering: {}, Sales: {}, Marketing: {}", eng_count, sales_count, marketing_count);

    // TEST 17: Email pattern matching (regex-like)
    println!("\nTest 17: Email domain filtering (LIKE '%@example.com')");
    println!("SQL: SELECT * FROM employees WHERE email LIKE '%@example.com';");
    
    let example_emails = Query::new(&employees)
        .where_(Employee::email_r(), |email| email.ends_with("@example.com"))
        .count();
    
    let test17_pass = example_emails == 6; // All employees have @example.com emails
    print_test("Email pattern matching works correctly", test17_pass);
    println!("  Found {} employees with @example.com emails", example_emails);

    // Summary
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Test Summary                                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");
    
    let tests = vec![
        ("ORDER BY DESC", test1_pass),
        ("ORDER BY ASC", test2_pass),
        ("ORDER BY name", test3_pass),
        ("LIKE 'prefix%'", test4_pass),
        ("LIKE '%suffix'", test5_pass),
        ("LIKE '%contains%'", test6_pass),
        ("IN clause", test7_pass),
        ("BETWEEN clause", test8_pass),
        ("COUNT", test9_pass),
        ("AVG accuracy", test10_pass),
        ("MIN/MAX", test11_pass),
        ("Complex WHERE", test12_pass),
        ("Case-sensitive", test13_pass),
        ("Case-insensitive", test14_pass),
        ("LIMIT", test15_pass),
        ("GROUP BY", test16_pass),
        ("Email patterns", test17_pass),
    ];
    
    let passed = tests.iter().filter(|(_, p)| *p).count();
    let total = tests.len();
    
    println!("Results: {}/{} tests passed", passed, total);
    
    if passed == total {
        println!("\n🎉 All tests PASSED! Rust Query Builder produces exact SQL-equivalent results!");
        println!("\n✅ Verified:");
        println!("  • Exact ordering (ASC/DESC)");
        println!("  • LIKE operations (starts_with, ends_with, contains)");
        println!("  • IN clause (OR conditions)");
        println!("  • BETWEEN clause");
        println!("  • Aggregations (COUNT, AVG, MIN, MAX)");
        println!("  • Complex WHERE conditions");
        println!("  • Case sensitivity");
        println!("  • LIMIT clause");
        println!("  • GROUP BY");
        println!("  • Pattern matching");
    } else {
        println!("\n⚠️  {} test(s) failed. See details above.", total - passed);
    }
}

examples/sql_comparison.rs (line 149)

fn main() {
    let employees = create_employees();
    let departments = create_departments();
    let projects = create_projects();

    println!("\n╔════════════════════════════════════════════════════════════════════════╗");
    println!("║     SQL vs Rust Query Builder Comparison                              ║");
    println!("║     Demonstrating equivalent operations                               ║");
    println!("╚════════════════════════════════════════════════════════════════════════╝");

    // ============================================================================
    // EXAMPLE 1: Simple SELECT with WHERE
    // ============================================================================
    print_separator("Example 1: SELECT with WHERE clause");
    print_query(
        "SELECT * FROM employees WHERE department = 'Engineering';",
        "Filter employees by department"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering_employees = eng_query.all();

    for emp in &engineering_employees {
        println!("  ID: {}, Name: {}, Salary: ${:.2}", emp.id, emp.name, emp.salary);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\")");
    println!("    .all()");
    println!("✓ Found {} employees", engineering_employees.len());

    // ============================================================================
    // EXAMPLE 2: SELECT specific columns
    // ============================================================================
    print_separator("Example 2: SELECT specific columns (Projection)");
    print_query(
        "SELECT name FROM employees WHERE salary > 80000;",
        "Get names of high-earning employees"
    );

    let high_earners = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 80000.0)
        .select(Employee::name_r());

    for name in &high_earners {
        println!("  {}", name);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 80000.0)");
    println!("    .select(Employee::name_r())");
    println!("✓ Found {} employees", high_earners.len());

    // ============================================================================
    // EXAMPLE 3: COUNT
    // ============================================================================
    print_separator("Example 3: COUNT aggregation");
    print_query(
        "SELECT COUNT(*) FROM employees WHERE age < 30;",
        "Count young employees"
    );

    let young_count = Query::new(&employees)
        .where_(Employee::age_r(), |&age| age < 30)
        .count();

    println!("  Count: {}", young_count);
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::age_r(), |&age| age < 30)");
    println!("    .count()");
    println!("✓ Result: {}", young_count);

    // ============================================================================
    // EXAMPLE 4: SUM, AVG, MIN, MAX
    // ============================================================================
    print_separator("Example 4: Aggregate functions (SUM, AVG, MIN, MAX)");
    print_query(
        "SELECT \n\
         SUM(salary) as total_salary,\n\
         AVG(salary) as avg_salary,\n\
         MIN(salary) as min_salary,\n\
         MAX(salary) as max_salary\n\
         FROM employees WHERE department = 'Engineering';",
        "Engineering department salary statistics"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");

    let total = eng_query.sum(Employee::salary_r());
    let avg = eng_query.avg(Employee::salary_r()).unwrap_or(0.0);
    let min = eng_query.min_float(Employee::salary_r()).unwrap_or(0.0);
    let max = eng_query.max_float(Employee::salary_r()).unwrap_or(0.0);

    println!("  Total Salary: ${:.2}", total);
    println!("  Avg Salary:   ${:.2}", avg);
    println!("  Min Salary:   ${:.2}", min);
    println!("  Max Salary:   ${:.2}", max);

    println!("\nRust Query Builder:");
    println!("let query = Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\");");
    println!("query.sum(Employee::salary_r())  // ${:.2}", total);
    println!("query.avg(Employee::salary_r())  // ${:.2}", avg);
    println!("query.min_float(Employee::salary_r())  // ${:.2}", min);
    println!("query.max_float(Employee::salary_r())  // ${:.2}", max);

    // ============================================================================
    // EXAMPLE 5: GROUP BY with aggregation
    // ============================================================================
    print_separator("Example 5: GROUP BY with aggregation");
    print_query(
        "SELECT \n\
         department,\n\
         COUNT(*) as emp_count,\n\
         AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY department;",
        "Statistics by department"
    );

    let by_dept = Query::new(&employees).group_by(Employee::department_r());

    for (dept, emps) in &by_dept {
        let dept_query = Query::new(emps);
        let count = emps.len();
        let avg_sal = dept_query.avg(Employee::salary_r()).unwrap_or(0.0);
        println!("  {}: {} employees, avg salary ${:.2}", dept, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_dept = Query::new(&employees).group_by(Employee::department_r());");
    println!("for (dept, emps) in &by_dept {{");
    println!("    let dept_query = Query::new(emps);");
    println!("    dept_query.avg(Employee::salary_r())");
    println!("}}");

    // ============================================================================
    // EXAMPLE 6: ORDER BY
    // ============================================================================
    print_separator("Example 6: ORDER BY");
    print_query(
        "SELECT name, salary FROM employees\n\
         WHERE department = 'Sales'\n\
         ORDER BY salary DESC;",
        "Sales employees ordered by salary (descending)"
    );

    let sales_sorted = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .order_by_float_desc(Employee::salary_r());

    for emp in &sales_sorted {
        println!("  {}: ${:.2}", emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Sales\")");
    println!("    .order_by_float_desc(Employee::salary_r())");

    // ============================================================================
    // EXAMPLE 7: Multiple WHERE conditions (AND)
    // ============================================================================
    print_separator("Example 7: Multiple WHERE conditions (AND)");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > 70000 AND age < 35;",
        "High-earning young employees"
    );

    let filter_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 70000.0)
        .where_(Employee::age_r(), |&age| age < 35);
    let filtered = filter_query.all();

    for emp in &filtered {
        println!("  {}: Age {}, Salary ${:.2}", emp.name, emp.age, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 70000.0)");
    println!("    .where_(Employee::age_r(), |&age| age < 35)");
    println!("    .all()");
    println!("✓ Found {} employees", filtered.len());

    // ============================================================================
    // EXAMPLE 8: LIMIT (TOP N)
    // ============================================================================
    print_separator("Example 8: LIMIT / TOP N");
    print_query(
        "SELECT TOP 3 name, salary FROM employees\n\
         ORDER BY salary DESC;",
        "Top 3 highest paid employees"
    );

    let top_earners = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r());

    for (i, emp) in top_earners.iter().take(3).enumerate() {
        println!("  {}. {}: ${:.2}", i + 1, emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("    .into_iter().take(3)");

    // ============================================================================
    // EXAMPLE 9: OFFSET and LIMIT (Pagination)
    // ============================================================================
    print_separator("Example 9: OFFSET and LIMIT (Pagination)");
    print_query(
        "SELECT name FROM employees\n\
         ORDER BY name\n\
         LIMIT 3 OFFSET 3;",
        "Page 2 of employee names (3 per page)"
    );

    let page_2 = Query::new(&employees)
        .order_by(Employee::name_r())
        .into_iter()
        .skip(3)
        .take(3)
        .collect::<Vec<_>>();

    for emp in &page_2 {
        println!("  {}", emp.name);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by(Employee::name_r())");
    println!("    .into_iter().skip(3).take(3)");

    // ============================================================================
    // EXAMPLE 10: INNER JOIN
    // ============================================================================
    print_separator("Example 10: INNER JOIN");
    print_query(
        "SELECT e.name, d.name as dept_name, d.budget\n\
         FROM employees e\n\
         INNER JOIN departments d ON e.department = d.name;",
        "Employees with their department info"
    );

    let emp_dept = JoinQuery::new(&employees, &departments).inner_join(
        Employee::department_r(),
        Department::name_r(),
        |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget),
    );

    for (emp_name, dept_name, budget) in emp_dept.iter().take(5) {
        println!("  {} works in {} (Budget: ${:.0})", emp_name, dept_name, budget);
    }
    println!("  ... (showing first 5)");

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&employees, &departments).inner_join(");
    println!("    Employee::department_r(),");
    println!("    Department::name_r(),");
    println!("    |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget)");
    println!(")");
    println!("✓ Found {} matches", emp_dept.len());

    // ============================================================================
    // EXAMPLE 11: GROUP BY with HAVING equivalent
    // ============================================================================
    print_separator("Example 11: GROUP BY with filtering (HAVING equivalent)");
    print_query(
        "SELECT city, COUNT(*) as emp_count, AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY city\n\
         HAVING COUNT(*) > 1;",
        "Cities with multiple employees"
    );

    let by_city = Query::new(&employees).group_by(Employee::city_r());
    let mut city_stats: Vec<_> = by_city
        .iter()
        .filter(|(_, emps)| emps.len() > 1) // HAVING equivalent
        .map(|(city, emps)| {
            let avg_sal = Query::new(emps).avg(Employee::salary_r()).unwrap_or(0.0);
            (city.clone(), emps.len(), avg_sal)
        })
        .collect();
    
    city_stats.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count

    for (city, count, avg_sal) in &city_stats {
        println!("  {}: {} employees, avg salary ${:.2}", city, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_city = Query::new(&employees).group_by(Employee::city_r());");
    println!("by_city.iter()");
    println!("    .filter(|(_, emps)| emps.len() > 1)  // HAVING equivalent");
    println!("    .map(|(city, emps)| {{");
    println!("        let avg = Query::new(emps).avg(Employee::salary_r());");
    println!("        (city, emps.len(), avg)");
    println!("    }})");

    // ============================================================================
    // EXAMPLE 12: Complex query with multiple operations
    // ============================================================================
    print_separator("Example 12: Complex multi-operation query");
    print_query(
        "SELECT name, salary, age\n\
         FROM employees\n\
         WHERE department IN ('Engineering', 'Sales')\n\
         AND salary BETWEEN 80000 AND 100000\n\
         AND age >= 30\n\
         ORDER BY salary DESC;",
        "Experienced mid-to-senior level employees in core departments"
    );

    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)
        .where_(Employee::age_r(), |&age| age >= 30)
        .order_by_float_desc(Employee::salary_r());

    for emp in &complex_query {
        println!("  {}: Age {}, {} dept, ${:.2}", emp.name, emp.age, emp.department, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\" || dept == \"Sales\")");
    println!("    .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)");
    println!("    .where_(Employee::age_r(), |&age| age >= 30)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("✓ Found {} employees", complex_query.len());

    // ============================================================================
    // EXAMPLE 13: Three-table JOIN
    // ============================================================================
    print_separator("Example 13: Three-table JOIN");
    print_query(
        "SELECT p.name as project, d.name as department, d.location\n\
         FROM projects p\n\
         INNER JOIN departments d ON p.department_id = d.id;",
        "Projects with their department details"
    );

    let proj_dept = JoinQuery::new(&projects, &departments).inner_join(
        Project::department_id_r(),
        Department::id_r(),
        |proj, dept| {
            (proj.name.clone(), dept.name.clone(), dept.location.clone(), proj.budget)
        },
    );

    for (proj_name, dept_name, location, budget) in &proj_dept {
        println!("  {}: {} dept in {} (${:.0})", proj_name, dept_name, location, budget);
    }

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&projects, &departments).inner_join(");
    println!("    Project::department_id_r(),");
    println!("    Department::id_r(),");
    println!("    |proj, dept| (proj.name, dept.name, dept.location, proj.budget)");
    println!(")");

    // ============================================================================
    // EXAMPLE 14: Subquery equivalent (using intermediate results)
    // ============================================================================
    print_separator("Example 14: Subquery equivalent");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > (SELECT AVG(salary) FROM employees);",
        "Employees earning above average"
    );

    let avg_salary = Query::new(&employees)
        .avg(Employee::salary_r())
        .unwrap_or(0.0);

    let above_avg_query = Query::new(&employees)
        .where_(Employee::salary_r(), move |&sal| sal > avg_salary);
    let above_avg = above_avg_query.all();

    println!("  Average salary: ${:.2}", avg_salary);
    for emp in &above_avg {
        println!("  {}: ${:.2} ({:.1}% above average)", 
            emp.name, emp.salary, ((emp.salary - avg_salary) / avg_salary * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let avg = Query::new(&employees).avg(Employee::salary_r()).unwrap_or(0.0);");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&sal| sal > avg)");
    println!("    .all()");
    println!("✓ Found {} employees above average", above_avg.len());

    // ============================================================================
    // EXAMPLE 15: Advanced aggregation (revenue calculation)
    // ============================================================================
    print_separator("Example 15: Advanced aggregation");
    print_query(
        "SELECT \n\
         d.name,\n\
         d.budget as dept_budget,\n\
         SUM(p.budget) as total_project_budget,\n\
         (d.budget - SUM(p.budget)) as remaining_budget\n\
         FROM departments d\n\
         LEFT JOIN projects p ON d.id = p.department_id\n\
         GROUP BY d.name, d.budget;",
        "Department budget utilization"
    );

    // Join departments with projects
    let dept_projects = JoinQuery::new(&departments, &projects).left_join(
        Department::id_r(),
        Project::department_id_r(),
        |dept, proj| (dept.clone(), proj.map(|p| p.clone())),
    );

    // Aggregate by department
    let mut dept_budget_map: HashMap<String, (f64, Vec<f64>)> = HashMap::new();
    for (dept, proj) in dept_projects {
        let entry = dept_budget_map
            .entry(dept.name.clone())
            .or_insert((dept.budget, Vec::new()));
        if let Some(p) = proj {
            entry.1.push(p.budget);
        }
    }

    for (dept_name, (total_budget, project_budgets)) in dept_budget_map.iter() {
        let used: f64 = project_budgets.iter().sum();
        let remaining = total_budget - used;
        println!("  {}: Budget ${:.0}, Used ${:.0}, Remaining ${:.0} ({:.1}% utilized)",
            dept_name, total_budget, used, remaining, (used / total_budget * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let dept_projects = JoinQuery::new(&departments, &projects)");
    println!("    .left_join(Department::id_r(), Project::department_id_r(), ...)");
    println!("// Then aggregate using HashMap");

    // ============================================================================
    // Summary
    // ============================================================================
    print_separator("Summary");
    println!("\n✓ All 15 SQL queries successfully replicated with Rust Query Builder!");
    println!("\nDemonstrated equivalents for:");
    println!("  • SELECT with WHERE");
    println!("  • Projection (SELECT specific columns)");
    println!("  • Aggregations (COUNT, SUM, AVG, MIN, MAX)");
    println!("  • GROUP BY");
    println!("  • ORDER BY");
    println!("  • LIMIT and OFFSET");
    println!("  • INNER JOIN and LEFT JOIN");
    println!("  • Complex conditions (AND, OR, BETWEEN)");
    println!("  • Subqueries");
    println!("  • Multi-table operations");
    println!("\n🎯 Type-safe, compile-time checked, and zero runtime overhead!");
    println!();
}

pub fn limit(&self, n: usize) -> Vec<&T>

Returns the first n items matching the query filters.

Arguments

• n - The maximum number of items to return

Example

let first_10 = query.limit(10);

Examples found in repository

examples/doc_examples.rs (line 131)

fn main() {
    println!("Testing documentation examples...\n");

    // Example from README - Quick Start
    println!("Test 1: README Quick Start Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let affordable_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price < 100.0);
        let affordable_electronics = affordable_query.all();

        println!("  Found {} affordable electronics ✅", affordable_electronics.len());
    }

    // Example from README - Filtering
    println!("\nTest 2: Filtering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");
        let electronics = electronics_query.all();

        println!("  Found {} electronics ✅", electronics.len());
    }

    // Example from README - Selecting
    println!("\nTest 3: Selecting Fields Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let names: Vec<String> = Query::new(&products)
            .select(Product::name_r());

        println!("  Selected {} names ✅", names.len());
    }

    // Example from README - Ordering
    println!("\nTest 4: Ordering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let by_price = Query::new(&products).order_by_float(Product::price_r());
        println!("  Ordered {} products ✅", by_price.len());
    }

    // Example from README - Aggregations
    println!("\nTest 5: Aggregations Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");

        let count = electronics_query.count();
        let total_value: f64 = electronics_query.sum(Product::price_r());
        let avg_price = electronics_query.avg(Product::price_r()).unwrap_or(0.0);

        println!("  Count: {}, Total: ${:.2}, Avg: ${:.2} ✅", count, total_value, avg_price);
    }

    // Example from README - Grouping
    println!("\nTest 6: Grouping Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let by_category = Query::new(&products).group_by(Product::category_r());
        println!("  Grouped into {} categories ✅", by_category.len());
    }

    // Example from README - Pagination
    println!("\nTest 7: Pagination Example");
    {
        let products = vec![
            Product { id: 1, name: "P1".to_string(), price: 10.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 2, name: "P2".to_string(), price: 20.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 3, name: "P3".to_string(), price: 30.0, category: "A".to_string(), stock: 1, rating: 4.0 },
        ];

        let query = Query::new(&products);
        let first_10 = query.limit(10);
        let page_1 = query.skip(0).limit(10);

        println!("  Limited to {} products ✅", first_10.len());
        println!("  Page 1 has {} products ✅", page_1.len());
    }

    // Example from README - Join
    println!("\nTest 8: Join Example");
    {
        let users = vec![
            User { id: 1, name: "Alice".to_string() },
            User { id: 2, name: "Bob".to_string() },
        ];

        let orders = vec![
            Order { id: 101, user_id: 1, total: 99.99 },
            Order { id: 102, user_id: 1, total: 149.99 },
        ];

        let user_orders = JoinQuery::new(&users, &orders).inner_join(
            User::id_r(),
            Order::user_id_r(),
            |user, order| (user.name.clone(), order.total),
        );

        println!("  Joined {} user-order pairs ✅", user_orders.len());
    }

    // Example from SQL_COMPARISON - SELECT with WHERE
    println!("\nTest 9: SQL Comparison - SELECT with WHERE");
    {
        #[derive(Clone, Keypaths)]
        struct Employee {
            department: String,
        }

        let employees = vec![
            Employee { department: "Engineering".to_string() },
            Employee { department: "Sales".to_string() },
        ];

        let engineering_query = Query::new(&employees)
            .where_(Employee::department_r(), |dept| dept == "Engineering");
        let engineering = engineering_query.all();

        println!("  Found {} engineering employees ✅", engineering.len());
    }

    // Example from USAGE.md - Complex Filtering
    println!("\nTest 10: USAGE - Complex Filtering");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let results_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price >= 100.0 && price <= 500.0)
            .where_(Product::stock_r(), |&stock| stock > 10);
        let results = results_query.order_by_float(Product::price_r());

        println!("  Filtered {} products ✅", results.len());
    }

    println!("\n✅ All documentation examples compile and run successfully!");
}

examples/advanced_query_builder.rs (line 177)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

pub fn skip<'b>(&'b self, offset: usize) -> QueryWithSkip<'a, 'b, T>

Skips the first offset items for pagination.

Arguments

• offset - The number of items to skip

Example

let page_2 = query.skip(20).limit(10);

Examples found in repository

examples/doc_examples.rs (line 132)

fn main() {
    println!("Testing documentation examples...\n");

    // Example from README - Quick Start
    println!("Test 1: README Quick Start Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let affordable_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price < 100.0);
        let affordable_electronics = affordable_query.all();

        println!("  Found {} affordable electronics ✅", affordable_electronics.len());
    }

    // Example from README - Filtering
    println!("\nTest 2: Filtering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");
        let electronics = electronics_query.all();

        println!("  Found {} electronics ✅", electronics.len());
    }

    // Example from README - Selecting
    println!("\nTest 3: Selecting Fields Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let names: Vec<String> = Query::new(&products)
            .select(Product::name_r());

        println!("  Selected {} names ✅", names.len());
    }

    // Example from README - Ordering
    println!("\nTest 4: Ordering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let by_price = Query::new(&products).order_by_float(Product::price_r());
        println!("  Ordered {} products ✅", by_price.len());
    }

    // Example from README - Aggregations
    println!("\nTest 5: Aggregations Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");

        let count = electronics_query.count();
        let total_value: f64 = electronics_query.sum(Product::price_r());
        let avg_price = electronics_query.avg(Product::price_r()).unwrap_or(0.0);

        println!("  Count: {}, Total: ${:.2}, Avg: ${:.2} ✅", count, total_value, avg_price);
    }

    // Example from README - Grouping
    println!("\nTest 6: Grouping Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let by_category = Query::new(&products).group_by(Product::category_r());
        println!("  Grouped into {} categories ✅", by_category.len());
    }

    // Example from README - Pagination
    println!("\nTest 7: Pagination Example");
    {
        let products = vec![
            Product { id: 1, name: "P1".to_string(), price: 10.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 2, name: "P2".to_string(), price: 20.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 3, name: "P3".to_string(), price: 30.0, category: "A".to_string(), stock: 1, rating: 4.0 },
        ];

        let query = Query::new(&products);
        let first_10 = query.limit(10);
        let page_1 = query.skip(0).limit(10);

        println!("  Limited to {} products ✅", first_10.len());
        println!("  Page 1 has {} products ✅", page_1.len());
    }

    // Example from README - Join
    println!("\nTest 8: Join Example");
    {
        let users = vec![
            User { id: 1, name: "Alice".to_string() },
            User { id: 2, name: "Bob".to_string() },
        ];

        let orders = vec![
            Order { id: 101, user_id: 1, total: 99.99 },
            Order { id: 102, user_id: 1, total: 149.99 },
        ];

        let user_orders = JoinQuery::new(&users, &orders).inner_join(
            User::id_r(),
            Order::user_id_r(),
            |user, order| (user.name.clone(), order.total),
        );

        println!("  Joined {} user-order pairs ✅", user_orders.len());
    }

    // Example from SQL_COMPARISON - SELECT with WHERE
    println!("\nTest 9: SQL Comparison - SELECT with WHERE");
    {
        #[derive(Clone, Keypaths)]
        struct Employee {
            department: String,
        }

        let employees = vec![
            Employee { department: "Engineering".to_string() },
            Employee { department: "Sales".to_string() },
        ];

        let engineering_query = Query::new(&employees)
            .where_(Employee::department_r(), |dept| dept == "Engineering");
        let engineering = engineering_query.all();

        println!("  Found {} engineering employees ✅", engineering.len());
    }

    // Example from USAGE.md - Complex Filtering
    println!("\nTest 10: USAGE - Complex Filtering");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let results_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price >= 100.0 && price <= 500.0)
            .where_(Product::stock_r(), |&stock| stock > 10);
        let results = results_query.order_by_float(Product::price_r());

        println!("  Filtered {} products ✅", results.len());
    }

    println!("\n✅ All documentation examples compile and run successfully!");
}

examples/advanced_query_builder.rs (line 185)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

pub fn order_by<F>(&self, path: KeyPaths<T, F>) -> Vec<T>

where F: Ord + Clone + 'static,

Orders results by a field in ascending order.

Arguments

• path - The key-path to the field to order by

Example

let sorted = query.order_by(Product::name_r());

Examples found in repository

examples/advanced_query_builder.rs (line 253)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_verification.rs (line 74)

fn main() {
    let employees = create_test_data();
    
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  SQL Equivalence Verification Tests                           ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // TEST 1: ORDER BY maintains exact SQL ordering (DESC)
    println!("Test 1: ORDER BY DESC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC;");
    
    let ordered = Query::new(&employees).order_by_float_desc(Employee::salary_r());
    let expected_order = vec![105000.0, 95000.0, 87000.0, 82000.0, 75000.0, 71000.0];
    let actual_order: Vec<f64> = ordered.iter().map(|e| e.salary).collect();
    
    let test1_pass = expected_order == actual_order;
    print_test("ORDER BY salary DESC produces correct order", test1_pass);
    if !test1_pass {
        println!("  Expected: {:?}", expected_order);
        println!("  Got: {:?}", actual_order);
    }

    // TEST 2: ORDER BY maintains exact SQL ordering (ASC)
    println!("\nTest 2: ORDER BY ASC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary ASC;");
    
    let ordered_asc = Query::new(&employees).order_by_float(Employee::salary_r());
    let expected_asc = vec![71000.0, 75000.0, 82000.0, 87000.0, 95000.0, 105000.0];
    let actual_asc: Vec<f64> = ordered_asc.iter().map(|e| e.salary).collect();
    
    let test2_pass = expected_asc == actual_asc;
    print_test("ORDER BY salary ASC produces correct order", test2_pass);
    if !test2_pass {
        println!("  Expected: {:?}", expected_asc);
        println!("  Got: {:?}", actual_asc);
    }

    // TEST 3: String ordering (alphabetical)
    println!("\nTest 3: ORDER BY name (alphabetical)");
    println!("SQL: SELECT name FROM employees ORDER BY name;");
    
    let ordered_names = Query::new(&employees).order_by(Employee::name_r());
    let expected_names = vec!["Alice Cooper", "Alice Johnson", "Bob Smith", "Carol White", "David Brown", "Eve Davis"];
    let actual_names: Vec<&str> = ordered_names.iter().map(|e| e.name.as_str()).collect();
    
    let test3_pass = expected_names == actual_names;
    print_test("ORDER BY name produces correct alphabetical order", test3_pass);
    if !test3_pass {
        println!("  Expected: {:?}", expected_names);
        println!("  Got: {:?}", actual_names);
    }

    // TEST 4: LIKE equivalent - starts with
    println!("\nTest 4: LIKE 'Alice%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE 'Alice%';");
    
    let like_alice_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.starts_with("Alice"));
    let like_alice = like_alice_query.all();
    
    let test4_pass = like_alice.len() == 2 
        && like_alice.iter().all(|e| e.name.starts_with("Alice"));
    print_test("LIKE 'Alice%' (starts_with) works correctly", test4_pass);
    if test4_pass {
        for emp in &like_alice {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 5: LIKE equivalent - ends with
    println!("\nTest 5: LIKE '%son' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%son';");
    
    let like_son_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.ends_with("son"));
    let like_son = like_son_query.all();
    
    let test5_pass = like_son.len() == 1 && like_son[0].name == "Alice Johnson";
    print_test("LIKE '%son' (ends_with) works correctly", test5_pass);
    if test5_pass {
        for emp in &like_son {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 6: LIKE equivalent - contains
    println!("\nTest 6: LIKE '%mit%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%mit%';");
    
    let like_mit_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.contains("mit"));
    let like_mit = like_mit_query.all();
    
    let test6_pass = like_mit.len() == 1 && like_mit[0].name == "Bob Smith";
    print_test("LIKE '%mit%' (contains) works correctly", test6_pass);
    if test6_pass {
        for emp in &like_mit {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 7: IN clause equivalent
    println!("\nTest 7: IN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE department IN ('Engineering', 'Sales');");
    
    let in_depts_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales");
    let in_depts = in_depts_query.all();
    
    let test7_pass = in_depts.len() == 5 // 3 Engineering + 2 Sales
        && in_depts.iter().all(|e| e.department == "Engineering" || e.department == "Sales");
    print_test("IN clause works correctly", test7_pass);
    println!("  Found {} employees in Engineering or Sales", in_depts.len());

    // TEST 8: BETWEEN equivalent
    println!("\nTest 8: BETWEEN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE salary BETWEEN 75000 AND 90000;");
    
    let between_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal >= 75000.0 && sal <= 90000.0);
    let between = between_query.all();
    
    let test8_pass = between.len() == 3;
    print_test("BETWEEN clause works correctly", test8_pass);
    println!("  Found {} employees with salary between 75K-90K", between.len());

    // TEST 9: COUNT with WHERE
    println!("\nTest 9: COUNT with WHERE");
    println!("SQL: SELECT COUNT(*) FROM employees WHERE department = 'Engineering';");
    
    let count_eng = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .count();
    
    let test9_pass = count_eng == 3;
    print_test("COUNT with WHERE produces correct result", test9_pass);
    println!("  Count: {} (expected 3)", count_eng);

    // TEST 10: AVG produces exact result
    println!("\nTest 10: AVG aggregation accuracy");
    println!("SQL: SELECT AVG(salary) FROM employees WHERE department = 'Engineering';");
    
    let avg_sal = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .avg(Employee::salary_r())
        .unwrap_or(0.0);
    
    let expected_avg = (95000.0 + 87000.0 + 105000.0) / 3.0;
    let test10_pass = (avg_sal - expected_avg).abs() < 0.01;
    print_test("AVG produces mathematically correct result", test10_pass);
    println!("  Average: ${:.2} (expected ${:.2})", avg_sal, expected_avg);

    // TEST 11: MIN and MAX
    println!("\nTest 11: MIN and MAX aggregations");
    println!("SQL: SELECT MIN(salary), MAX(salary) FROM employees;");
    
    let min_sal = Query::new(&employees).min_float(Employee::salary_r()).unwrap_or(0.0);
    let max_sal = Query::new(&employees).max_float(Employee::salary_r()).unwrap_or(0.0);
    
    let test11_pass = min_sal == 71000.0 && max_sal == 105000.0;
    print_test("MIN and MAX produce correct results", test11_pass);
    println!("  MIN: ${:.2}, MAX: ${:.2}", min_sal, max_sal);

    // TEST 12: Complex WHERE with AND/OR
    println!("\nTest 12: Complex WHERE (AND + OR)");
    println!("SQL: SELECT * FROM employees WHERE (department = 'Engineering' OR department = 'Sales') AND salary > 80000;");
    
    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal > 80000.0);
    let complex = complex_query.all();
    
    let test12_pass = complex.len() == 4; // Alice J ($95k), Bob ($87k), David ($82k), Alice C ($105k)
    print_test("Complex WHERE clause works correctly", test12_pass);
    println!("  Found {} employees", complex.len());

    // TEST 13: Case-sensitive string comparison (SQL default)
    println!("\nTest 13: Case-sensitive comparison (like SQL)");
    println!("SQL: SELECT * FROM employees WHERE department = 'engineering'; -- should find 0");
    
    let case_sensitive = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "engineering") // lowercase
        .count();
    
    let test13_pass = case_sensitive == 0;
    print_test("Case-sensitive comparison (SQL default)", test13_pass);
    println!("  Found {} with lowercase 'engineering' (expected 0)", case_sensitive);

    // TEST 14: Case-insensitive LIKE equivalent
    println!("\nTest 14: Case-insensitive LIKE (ILIKE equivalent)");
    println!("SQL: SELECT * FROM employees WHERE LOWER(name) LIKE '%alice%';");
    
    let ilike_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.to_lowercase().contains("alice"));
    let ilike = ilike_query.all();
    
    let test14_pass = ilike.len() == 2;
    print_test("Case-insensitive LIKE works correctly", test14_pass);
    println!("  Found {} employees with 'alice' (case-insensitive)", ilike.len());

    // TEST 15: LIMIT produces exact subset
    println!("\nTest 15: LIMIT clause");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC LIMIT 3;");
    
    let limited = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r())
        .into_iter()
        .take(3)
        .collect::<Vec<_>>();
    
    let test15_pass = limited.len() == 3 
        && limited[0].salary == 105000.0
        && limited[1].salary == 95000.0
        && limited[2].salary == 87000.0;
    print_test("LIMIT returns correct top-N results", test15_pass);
    println!("  Top 3 salaries: ${:.0}, ${:.0}, ${:.0}", 
        limited[0].salary, limited[1].salary, limited[2].salary);

    // TEST 16: GROUP BY produces correct groups
    println!("\nTest 16: GROUP BY");
    println!("SQL: SELECT department, COUNT(*) FROM employees GROUP BY department;");
    
    let grouped = Query::new(&employees).group_by(Employee::department_r());
    let eng_count = grouped.get("Engineering").map(|v| v.len()).unwrap_or(0);
    let sales_count = grouped.get("Sales").map(|v| v.len()).unwrap_or(0);
    let marketing_count = grouped.get("Marketing").map(|v| v.len()).unwrap_or(0);
    
    let test16_pass = eng_count == 3 && sales_count == 2 && marketing_count == 1;
    print_test("GROUP BY produces correct counts", test16_pass);
    println!("  Engineering: {}, Sales: {}, Marketing: {}", eng_count, sales_count, marketing_count);

    // TEST 17: Email pattern matching (regex-like)
    println!("\nTest 17: Email domain filtering (LIKE '%@example.com')");
    println!("SQL: SELECT * FROM employees WHERE email LIKE '%@example.com';");
    
    let example_emails = Query::new(&employees)
        .where_(Employee::email_r(), |email| email.ends_with("@example.com"))
        .count();
    
    let test17_pass = example_emails == 6; // All employees have @example.com emails
    print_test("Email pattern matching works correctly", test17_pass);
    println!("  Found {} employees with @example.com emails", example_emails);

    // Summary
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Test Summary                                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");
    
    let tests = vec![
        ("ORDER BY DESC", test1_pass),
        ("ORDER BY ASC", test2_pass),
        ("ORDER BY name", test3_pass),
        ("LIKE 'prefix%'", test4_pass),
        ("LIKE '%suffix'", test5_pass),
        ("LIKE '%contains%'", test6_pass),
        ("IN clause", test7_pass),
        ("BETWEEN clause", test8_pass),
        ("COUNT", test9_pass),
        ("AVG accuracy", test10_pass),
        ("MIN/MAX", test11_pass),
        ("Complex WHERE", test12_pass),
        ("Case-sensitive", test13_pass),
        ("Case-insensitive", test14_pass),
        ("LIMIT", test15_pass),
        ("GROUP BY", test16_pass),
        ("Email patterns", test17_pass),
    ];
    
    let passed = tests.iter().filter(|(_, p)| *p).count();
    let total = tests.len();
    
    println!("Results: {}/{} tests passed", passed, total);
    
    if passed == total {
        println!("\n🎉 All tests PASSED! Rust Query Builder produces exact SQL-equivalent results!");
        println!("\n✅ Verified:");
        println!("  • Exact ordering (ASC/DESC)");
        println!("  • LIKE operations (starts_with, ends_with, contains)");
        println!("  • IN clause (OR conditions)");
        println!("  • BETWEEN clause");
        println!("  • Aggregations (COUNT, AVG, MIN, MAX)");
        println!("  • Complex WHERE conditions");
        println!("  • Case sensitivity");
        println!("  • LIMIT clause");
        println!("  • GROUP BY");
        println!("  • Pattern matching");
    } else {
        println!("\n⚠️  {} test(s) failed. See details above.", total - passed);
    }
}

examples/sql_comparison.rs (line 307)

fn main() {
    let employees = create_employees();
    let departments = create_departments();
    let projects = create_projects();

    println!("\n╔════════════════════════════════════════════════════════════════════════╗");
    println!("║     SQL vs Rust Query Builder Comparison                              ║");
    println!("║     Demonstrating equivalent operations                               ║");
    println!("╚════════════════════════════════════════════════════════════════════════╝");

    // ============================================================================
    // EXAMPLE 1: Simple SELECT with WHERE
    // ============================================================================
    print_separator("Example 1: SELECT with WHERE clause");
    print_query(
        "SELECT * FROM employees WHERE department = 'Engineering';",
        "Filter employees by department"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering_employees = eng_query.all();

    for emp in &engineering_employees {
        println!("  ID: {}, Name: {}, Salary: ${:.2}", emp.id, emp.name, emp.salary);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\")");
    println!("    .all()");
    println!("✓ Found {} employees", engineering_employees.len());

    // ============================================================================
    // EXAMPLE 2: SELECT specific columns
    // ============================================================================
    print_separator("Example 2: SELECT specific columns (Projection)");
    print_query(
        "SELECT name FROM employees WHERE salary > 80000;",
        "Get names of high-earning employees"
    );

    let high_earners = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 80000.0)
        .select(Employee::name_r());

    for name in &high_earners {
        println!("  {}", name);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 80000.0)");
    println!("    .select(Employee::name_r())");
    println!("✓ Found {} employees", high_earners.len());

    // ============================================================================
    // EXAMPLE 3: COUNT
    // ============================================================================
    print_separator("Example 3: COUNT aggregation");
    print_query(
        "SELECT COUNT(*) FROM employees WHERE age < 30;",
        "Count young employees"
    );

    let young_count = Query::new(&employees)
        .where_(Employee::age_r(), |&age| age < 30)
        .count();

    println!("  Count: {}", young_count);
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::age_r(), |&age| age < 30)");
    println!("    .count()");
    println!("✓ Result: {}", young_count);

    // ============================================================================
    // EXAMPLE 4: SUM, AVG, MIN, MAX
    // ============================================================================
    print_separator("Example 4: Aggregate functions (SUM, AVG, MIN, MAX)");
    print_query(
        "SELECT \n\
         SUM(salary) as total_salary,\n\
         AVG(salary) as avg_salary,\n\
         MIN(salary) as min_salary,\n\
         MAX(salary) as max_salary\n\
         FROM employees WHERE department = 'Engineering';",
        "Engineering department salary statistics"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");

    let total = eng_query.sum(Employee::salary_r());
    let avg = eng_query.avg(Employee::salary_r()).unwrap_or(0.0);
    let min = eng_query.min_float(Employee::salary_r()).unwrap_or(0.0);
    let max = eng_query.max_float(Employee::salary_r()).unwrap_or(0.0);

    println!("  Total Salary: ${:.2}", total);
    println!("  Avg Salary:   ${:.2}", avg);
    println!("  Min Salary:   ${:.2}", min);
    println!("  Max Salary:   ${:.2}", max);

    println!("\nRust Query Builder:");
    println!("let query = Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\");");
    println!("query.sum(Employee::salary_r())  // ${:.2}", total);
    println!("query.avg(Employee::salary_r())  // ${:.2}", avg);
    println!("query.min_float(Employee::salary_r())  // ${:.2}", min);
    println!("query.max_float(Employee::salary_r())  // ${:.2}", max);

    // ============================================================================
    // EXAMPLE 5: GROUP BY with aggregation
    // ============================================================================
    print_separator("Example 5: GROUP BY with aggregation");
    print_query(
        "SELECT \n\
         department,\n\
         COUNT(*) as emp_count,\n\
         AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY department;",
        "Statistics by department"
    );

    let by_dept = Query::new(&employees).group_by(Employee::department_r());

    for (dept, emps) in &by_dept {
        let dept_query = Query::new(emps);
        let count = emps.len();
        let avg_sal = dept_query.avg(Employee::salary_r()).unwrap_or(0.0);
        println!("  {}: {} employees, avg salary ${:.2}", dept, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_dept = Query::new(&employees).group_by(Employee::department_r());");
    println!("for (dept, emps) in &by_dept {{");
    println!("    let dept_query = Query::new(emps);");
    println!("    dept_query.avg(Employee::salary_r())");
    println!("}}");

    // ============================================================================
    // EXAMPLE 6: ORDER BY
    // ============================================================================
    print_separator("Example 6: ORDER BY");
    print_query(
        "SELECT name, salary FROM employees\n\
         WHERE department = 'Sales'\n\
         ORDER BY salary DESC;",
        "Sales employees ordered by salary (descending)"
    );

    let sales_sorted = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .order_by_float_desc(Employee::salary_r());

    for emp in &sales_sorted {
        println!("  {}: ${:.2}", emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Sales\")");
    println!("    .order_by_float_desc(Employee::salary_r())");

    // ============================================================================
    // EXAMPLE 7: Multiple WHERE conditions (AND)
    // ============================================================================
    print_separator("Example 7: Multiple WHERE conditions (AND)");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > 70000 AND age < 35;",
        "High-earning young employees"
    );

    let filter_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 70000.0)
        .where_(Employee::age_r(), |&age| age < 35);
    let filtered = filter_query.all();

    for emp in &filtered {
        println!("  {}: Age {}, Salary ${:.2}", emp.name, emp.age, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 70000.0)");
    println!("    .where_(Employee::age_r(), |&age| age < 35)");
    println!("    .all()");
    println!("✓ Found {} employees", filtered.len());

    // ============================================================================
    // EXAMPLE 8: LIMIT (TOP N)
    // ============================================================================
    print_separator("Example 8: LIMIT / TOP N");
    print_query(
        "SELECT TOP 3 name, salary FROM employees\n\
         ORDER BY salary DESC;",
        "Top 3 highest paid employees"
    );

    let top_earners = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r());

    for (i, emp) in top_earners.iter().take(3).enumerate() {
        println!("  {}. {}: ${:.2}", i + 1, emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("    .into_iter().take(3)");

    // ============================================================================
    // EXAMPLE 9: OFFSET and LIMIT (Pagination)
    // ============================================================================
    print_separator("Example 9: OFFSET and LIMIT (Pagination)");
    print_query(
        "SELECT name FROM employees\n\
         ORDER BY name\n\
         LIMIT 3 OFFSET 3;",
        "Page 2 of employee names (3 per page)"
    );

    let page_2 = Query::new(&employees)
        .order_by(Employee::name_r())
        .into_iter()
        .skip(3)
        .take(3)
        .collect::<Vec<_>>();

    for emp in &page_2 {
        println!("  {}", emp.name);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by(Employee::name_r())");
    println!("    .into_iter().skip(3).take(3)");

    // ============================================================================
    // EXAMPLE 10: INNER JOIN
    // ============================================================================
    print_separator("Example 10: INNER JOIN");
    print_query(
        "SELECT e.name, d.name as dept_name, d.budget\n\
         FROM employees e\n\
         INNER JOIN departments d ON e.department = d.name;",
        "Employees with their department info"
    );

    let emp_dept = JoinQuery::new(&employees, &departments).inner_join(
        Employee::department_r(),
        Department::name_r(),
        |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget),
    );

    for (emp_name, dept_name, budget) in emp_dept.iter().take(5) {
        println!("  {} works in {} (Budget: ${:.0})", emp_name, dept_name, budget);
    }
    println!("  ... (showing first 5)");

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&employees, &departments).inner_join(");
    println!("    Employee::department_r(),");
    println!("    Department::name_r(),");
    println!("    |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget)");
    println!(")");
    println!("✓ Found {} matches", emp_dept.len());

    // ============================================================================
    // EXAMPLE 11: GROUP BY with HAVING equivalent
    // ============================================================================
    print_separator("Example 11: GROUP BY with filtering (HAVING equivalent)");
    print_query(
        "SELECT city, COUNT(*) as emp_count, AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY city\n\
         HAVING COUNT(*) > 1;",
        "Cities with multiple employees"
    );

    let by_city = Query::new(&employees).group_by(Employee::city_r());
    let mut city_stats: Vec<_> = by_city
        .iter()
        .filter(|(_, emps)| emps.len() > 1) // HAVING equivalent
        .map(|(city, emps)| {
            let avg_sal = Query::new(emps).avg(Employee::salary_r()).unwrap_or(0.0);
            (city.clone(), emps.len(), avg_sal)
        })
        .collect();
    
    city_stats.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count

    for (city, count, avg_sal) in &city_stats {
        println!("  {}: {} employees, avg salary ${:.2}", city, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_city = Query::new(&employees).group_by(Employee::city_r());");
    println!("by_city.iter()");
    println!("    .filter(|(_, emps)| emps.len() > 1)  // HAVING equivalent");
    println!("    .map(|(city, emps)| {{");
    println!("        let avg = Query::new(emps).avg(Employee::salary_r());");
    println!("        (city, emps.len(), avg)");
    println!("    }})");

    // ============================================================================
    // EXAMPLE 12: Complex query with multiple operations
    // ============================================================================
    print_separator("Example 12: Complex multi-operation query");
    print_query(
        "SELECT name, salary, age\n\
         FROM employees\n\
         WHERE department IN ('Engineering', 'Sales')\n\
         AND salary BETWEEN 80000 AND 100000\n\
         AND age >= 30\n\
         ORDER BY salary DESC;",
        "Experienced mid-to-senior level employees in core departments"
    );

    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)
        .where_(Employee::age_r(), |&age| age >= 30)
        .order_by_float_desc(Employee::salary_r());

    for emp in &complex_query {
        println!("  {}: Age {}, {} dept, ${:.2}", emp.name, emp.age, emp.department, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\" || dept == \"Sales\")");
    println!("    .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)");
    println!("    .where_(Employee::age_r(), |&age| age >= 30)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("✓ Found {} employees", complex_query.len());

    // ============================================================================
    // EXAMPLE 13: Three-table JOIN
    // ============================================================================
    print_separator("Example 13: Three-table JOIN");
    print_query(
        "SELECT p.name as project, d.name as department, d.location\n\
         FROM projects p\n\
         INNER JOIN departments d ON p.department_id = d.id;",
        "Projects with their department details"
    );

    let proj_dept = JoinQuery::new(&projects, &departments).inner_join(
        Project::department_id_r(),
        Department::id_r(),
        |proj, dept| {
            (proj.name.clone(), dept.name.clone(), dept.location.clone(), proj.budget)
        },
    );

    for (proj_name, dept_name, location, budget) in &proj_dept {
        println!("  {}: {} dept in {} (${:.0})", proj_name, dept_name, location, budget);
    }

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&projects, &departments).inner_join(");
    println!("    Project::department_id_r(),");
    println!("    Department::id_r(),");
    println!("    |proj, dept| (proj.name, dept.name, dept.location, proj.budget)");
    println!(")");

    // ============================================================================
    // EXAMPLE 14: Subquery equivalent (using intermediate results)
    // ============================================================================
    print_separator("Example 14: Subquery equivalent");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > (SELECT AVG(salary) FROM employees);",
        "Employees earning above average"
    );

    let avg_salary = Query::new(&employees)
        .avg(Employee::salary_r())
        .unwrap_or(0.0);

    let above_avg_query = Query::new(&employees)
        .where_(Employee::salary_r(), move |&sal| sal > avg_salary);
    let above_avg = above_avg_query.all();

    println!("  Average salary: ${:.2}", avg_salary);
    for emp in &above_avg {
        println!("  {}: ${:.2} ({:.1}% above average)", 
            emp.name, emp.salary, ((emp.salary - avg_salary) / avg_salary * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let avg = Query::new(&employees).avg(Employee::salary_r()).unwrap_or(0.0);");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&sal| sal > avg)");
    println!("    .all()");
    println!("✓ Found {} employees above average", above_avg.len());

    // ============================================================================
    // EXAMPLE 15: Advanced aggregation (revenue calculation)
    // ============================================================================
    print_separator("Example 15: Advanced aggregation");
    print_query(
        "SELECT \n\
         d.name,\n\
         d.budget as dept_budget,\n\
         SUM(p.budget) as total_project_budget,\n\
         (d.budget - SUM(p.budget)) as remaining_budget\n\
         FROM departments d\n\
         LEFT JOIN projects p ON d.id = p.department_id\n\
         GROUP BY d.name, d.budget;",
        "Department budget utilization"
    );

    // Join departments with projects
    let dept_projects = JoinQuery::new(&departments, &projects).left_join(
        Department::id_r(),
        Project::department_id_r(),
        |dept, proj| (dept.clone(), proj.map(|p| p.clone())),
    );

    // Aggregate by department
    let mut dept_budget_map: HashMap<String, (f64, Vec<f64>)> = HashMap::new();
    for (dept, proj) in dept_projects {
        let entry = dept_budget_map
            .entry(dept.name.clone())
            .or_insert((dept.budget, Vec::new()));
        if let Some(p) = proj {
            entry.1.push(p.budget);
        }
    }

    for (dept_name, (total_budget, project_budgets)) in dept_budget_map.iter() {
        let used: f64 = project_budgets.iter().sum();
        let remaining = total_budget - used;
        println!("  {}: Budget ${:.0}, Used ${:.0}, Remaining ${:.0} ({:.1}% utilized)",
            dept_name, total_budget, used, remaining, (used / total_budget * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let dept_projects = JoinQuery::new(&departments, &projects)");
    println!("    .left_join(Department::id_r(), Project::department_id_r(), ...)");
    println!("// Then aggregate using HashMap");

    // ============================================================================
    // Summary
    // ============================================================================
    print_separator("Summary");
    println!("\n✓ All 15 SQL queries successfully replicated with Rust Query Builder!");
    println!("\nDemonstrated equivalents for:");
    println!("  • SELECT with WHERE");
    println!("  • Projection (SELECT specific columns)");
    println!("  • Aggregations (COUNT, SUM, AVG, MIN, MAX)");
    println!("  • GROUP BY");
    println!("  • ORDER BY");
    println!("  • LIMIT and OFFSET");
    println!("  • INNER JOIN and LEFT JOIN");
    println!("  • Complex conditions (AND, OR, BETWEEN)");
    println!("  • Subqueries");
    println!("  • Multi-table operations");
    println!("\n🎯 Type-safe, compile-time checked, and zero runtime overhead!");
    println!();
}

pub fn order_by_desc<F>(&self, path: KeyPaths<T, F>) -> Vec<T>

where F: Ord + Clone + 'static,

Orders results by a field in descending order.

Arguments

• path - The key-path to the field to order by

Example

let sorted = query.order_by_desc(Product::stock_r());

pub fn order_by_float(&self, path: KeyPaths<T, f64>) -> Vec<T>

Orders results by a float field in ascending order.

Arguments

• path - The key-path to the f64 field to order by

Example

let sorted = query.order_by_float(Product::price_r());

Examples found in repository

examples/doc_examples.rs (line 86)

fn main() {
    println!("Testing documentation examples...\n");

    // Example from README - Quick Start
    println!("Test 1: README Quick Start Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let affordable_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price < 100.0);
        let affordable_electronics = affordable_query.all();

        println!("  Found {} affordable electronics ✅", affordable_electronics.len());
    }

    // Example from README - Filtering
    println!("\nTest 2: Filtering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");
        let electronics = electronics_query.all();

        println!("  Found {} electronics ✅", electronics.len());
    }

    // Example from README - Selecting
    println!("\nTest 3: Selecting Fields Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let names: Vec<String> = Query::new(&products)
            .select(Product::name_r());

        println!("  Selected {} names ✅", names.len());
    }

    // Example from README - Ordering
    println!("\nTest 4: Ordering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let by_price = Query::new(&products).order_by_float(Product::price_r());
        println!("  Ordered {} products ✅", by_price.len());
    }

    // Example from README - Aggregations
    println!("\nTest 5: Aggregations Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");

        let count = electronics_query.count();
        let total_value: f64 = electronics_query.sum(Product::price_r());
        let avg_price = electronics_query.avg(Product::price_r()).unwrap_or(0.0);

        println!("  Count: {}, Total: ${:.2}, Avg: ${:.2} ✅", count, total_value, avg_price);
    }

    // Example from README - Grouping
    println!("\nTest 6: Grouping Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let by_category = Query::new(&products).group_by(Product::category_r());
        println!("  Grouped into {} categories ✅", by_category.len());
    }

    // Example from README - Pagination
    println!("\nTest 7: Pagination Example");
    {
        let products = vec![
            Product { id: 1, name: "P1".to_string(), price: 10.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 2, name: "P2".to_string(), price: 20.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 3, name: "P3".to_string(), price: 30.0, category: "A".to_string(), stock: 1, rating: 4.0 },
        ];

        let query = Query::new(&products);
        let first_10 = query.limit(10);
        let page_1 = query.skip(0).limit(10);

        println!("  Limited to {} products ✅", first_10.len());
        println!("  Page 1 has {} products ✅", page_1.len());
    }

    // Example from README - Join
    println!("\nTest 8: Join Example");
    {
        let users = vec![
            User { id: 1, name: "Alice".to_string() },
            User { id: 2, name: "Bob".to_string() },
        ];

        let orders = vec![
            Order { id: 101, user_id: 1, total: 99.99 },
            Order { id: 102, user_id: 1, total: 149.99 },
        ];

        let user_orders = JoinQuery::new(&users, &orders).inner_join(
            User::id_r(),
            Order::user_id_r(),
            |user, order| (user.name.clone(), order.total),
        );

        println!("  Joined {} user-order pairs ✅", user_orders.len());
    }

    // Example from SQL_COMPARISON - SELECT with WHERE
    println!("\nTest 9: SQL Comparison - SELECT with WHERE");
    {
        #[derive(Clone, Keypaths)]
        struct Employee {
            department: String,
        }

        let employees = vec![
            Employee { department: "Engineering".to_string() },
            Employee { department: "Sales".to_string() },
        ];

        let engineering_query = Query::new(&employees)
            .where_(Employee::department_r(), |dept| dept == "Engineering");
        let engineering = engineering_query.all();

        println!("  Found {} engineering employees ✅", engineering.len());
    }

    // Example from USAGE.md - Complex Filtering
    println!("\nTest 10: USAGE - Complex Filtering");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let results_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price >= 100.0 && price <= 500.0)
            .where_(Product::stock_r(), |&stock| stock > 10);
        let results = results_query.order_by_float(Product::price_r());

        println!("  Filtered {} products ✅", results.len());
    }

    println!("\n✅ All documentation examples compile and run successfully!");
}

examples/advanced_query_builder.rs (line 126)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_verification.rs (line 59)

fn main() {
    let employees = create_test_data();
    
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  SQL Equivalence Verification Tests                           ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // TEST 1: ORDER BY maintains exact SQL ordering (DESC)
    println!("Test 1: ORDER BY DESC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC;");
    
    let ordered = Query::new(&employees).order_by_float_desc(Employee::salary_r());
    let expected_order = vec![105000.0, 95000.0, 87000.0, 82000.0, 75000.0, 71000.0];
    let actual_order: Vec<f64> = ordered.iter().map(|e| e.salary).collect();
    
    let test1_pass = expected_order == actual_order;
    print_test("ORDER BY salary DESC produces correct order", test1_pass);
    if !test1_pass {
        println!("  Expected: {:?}", expected_order);
        println!("  Got: {:?}", actual_order);
    }

    // TEST 2: ORDER BY maintains exact SQL ordering (ASC)
    println!("\nTest 2: ORDER BY ASC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary ASC;");
    
    let ordered_asc = Query::new(&employees).order_by_float(Employee::salary_r());
    let expected_asc = vec![71000.0, 75000.0, 82000.0, 87000.0, 95000.0, 105000.0];
    let actual_asc: Vec<f64> = ordered_asc.iter().map(|e| e.salary).collect();
    
    let test2_pass = expected_asc == actual_asc;
    print_test("ORDER BY salary ASC produces correct order", test2_pass);
    if !test2_pass {
        println!("  Expected: {:?}", expected_asc);
        println!("  Got: {:?}", actual_asc);
    }

    // TEST 3: String ordering (alphabetical)
    println!("\nTest 3: ORDER BY name (alphabetical)");
    println!("SQL: SELECT name FROM employees ORDER BY name;");
    
    let ordered_names = Query::new(&employees).order_by(Employee::name_r());
    let expected_names = vec!["Alice Cooper", "Alice Johnson", "Bob Smith", "Carol White", "David Brown", "Eve Davis"];
    let actual_names: Vec<&str> = ordered_names.iter().map(|e| e.name.as_str()).collect();
    
    let test3_pass = expected_names == actual_names;
    print_test("ORDER BY name produces correct alphabetical order", test3_pass);
    if !test3_pass {
        println!("  Expected: {:?}", expected_names);
        println!("  Got: {:?}", actual_names);
    }

    // TEST 4: LIKE equivalent - starts with
    println!("\nTest 4: LIKE 'Alice%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE 'Alice%';");
    
    let like_alice_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.starts_with("Alice"));
    let like_alice = like_alice_query.all();
    
    let test4_pass = like_alice.len() == 2 
        && like_alice.iter().all(|e| e.name.starts_with("Alice"));
    print_test("LIKE 'Alice%' (starts_with) works correctly", test4_pass);
    if test4_pass {
        for emp in &like_alice {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 5: LIKE equivalent - ends with
    println!("\nTest 5: LIKE '%son' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%son';");
    
    let like_son_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.ends_with("son"));
    let like_son = like_son_query.all();
    
    let test5_pass = like_son.len() == 1 && like_son[0].name == "Alice Johnson";
    print_test("LIKE '%son' (ends_with) works correctly", test5_pass);
    if test5_pass {
        for emp in &like_son {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 6: LIKE equivalent - contains
    println!("\nTest 6: LIKE '%mit%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%mit%';");
    
    let like_mit_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.contains("mit"));
    let like_mit = like_mit_query.all();
    
    let test6_pass = like_mit.len() == 1 && like_mit[0].name == "Bob Smith";
    print_test("LIKE '%mit%' (contains) works correctly", test6_pass);
    if test6_pass {
        for emp in &like_mit {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 7: IN clause equivalent
    println!("\nTest 7: IN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE department IN ('Engineering', 'Sales');");
    
    let in_depts_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales");
    let in_depts = in_depts_query.all();
    
    let test7_pass = in_depts.len() == 5 // 3 Engineering + 2 Sales
        && in_depts.iter().all(|e| e.department == "Engineering" || e.department == "Sales");
    print_test("IN clause works correctly", test7_pass);
    println!("  Found {} employees in Engineering or Sales", in_depts.len());

    // TEST 8: BETWEEN equivalent
    println!("\nTest 8: BETWEEN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE salary BETWEEN 75000 AND 90000;");
    
    let between_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal >= 75000.0 && sal <= 90000.0);
    let between = between_query.all();
    
    let test8_pass = between.len() == 3;
    print_test("BETWEEN clause works correctly", test8_pass);
    println!("  Found {} employees with salary between 75K-90K", between.len());

    // TEST 9: COUNT with WHERE
    println!("\nTest 9: COUNT with WHERE");
    println!("SQL: SELECT COUNT(*) FROM employees WHERE department = 'Engineering';");
    
    let count_eng = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .count();
    
    let test9_pass = count_eng == 3;
    print_test("COUNT with WHERE produces correct result", test9_pass);
    println!("  Count: {} (expected 3)", count_eng);

    // TEST 10: AVG produces exact result
    println!("\nTest 10: AVG aggregation accuracy");
    println!("SQL: SELECT AVG(salary) FROM employees WHERE department = 'Engineering';");
    
    let avg_sal = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .avg(Employee::salary_r())
        .unwrap_or(0.0);
    
    let expected_avg = (95000.0 + 87000.0 + 105000.0) / 3.0;
    let test10_pass = (avg_sal - expected_avg).abs() < 0.01;
    print_test("AVG produces mathematically correct result", test10_pass);
    println!("  Average: ${:.2} (expected ${:.2})", avg_sal, expected_avg);

    // TEST 11: MIN and MAX
    println!("\nTest 11: MIN and MAX aggregations");
    println!("SQL: SELECT MIN(salary), MAX(salary) FROM employees;");
    
    let min_sal = Query::new(&employees).min_float(Employee::salary_r()).unwrap_or(0.0);
    let max_sal = Query::new(&employees).max_float(Employee::salary_r()).unwrap_or(0.0);
    
    let test11_pass = min_sal == 71000.0 && max_sal == 105000.0;
    print_test("MIN and MAX produce correct results", test11_pass);
    println!("  MIN: ${:.2}, MAX: ${:.2}", min_sal, max_sal);

    // TEST 12: Complex WHERE with AND/OR
    println!("\nTest 12: Complex WHERE (AND + OR)");
    println!("SQL: SELECT * FROM employees WHERE (department = 'Engineering' OR department = 'Sales') AND salary > 80000;");
    
    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal > 80000.0);
    let complex = complex_query.all();
    
    let test12_pass = complex.len() == 4; // Alice J ($95k), Bob ($87k), David ($82k), Alice C ($105k)
    print_test("Complex WHERE clause works correctly", test12_pass);
    println!("  Found {} employees", complex.len());

    // TEST 13: Case-sensitive string comparison (SQL default)
    println!("\nTest 13: Case-sensitive comparison (like SQL)");
    println!("SQL: SELECT * FROM employees WHERE department = 'engineering'; -- should find 0");
    
    let case_sensitive = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "engineering") // lowercase
        .count();
    
    let test13_pass = case_sensitive == 0;
    print_test("Case-sensitive comparison (SQL default)", test13_pass);
    println!("  Found {} with lowercase 'engineering' (expected 0)", case_sensitive);

    // TEST 14: Case-insensitive LIKE equivalent
    println!("\nTest 14: Case-insensitive LIKE (ILIKE equivalent)");
    println!("SQL: SELECT * FROM employees WHERE LOWER(name) LIKE '%alice%';");
    
    let ilike_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.to_lowercase().contains("alice"));
    let ilike = ilike_query.all();
    
    let test14_pass = ilike.len() == 2;
    print_test("Case-insensitive LIKE works correctly", test14_pass);
    println!("  Found {} employees with 'alice' (case-insensitive)", ilike.len());

    // TEST 15: LIMIT produces exact subset
    println!("\nTest 15: LIMIT clause");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC LIMIT 3;");
    
    let limited = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r())
        .into_iter()
        .take(3)
        .collect::<Vec<_>>();
    
    let test15_pass = limited.len() == 3 
        && limited[0].salary == 105000.0
        && limited[1].salary == 95000.0
        && limited[2].salary == 87000.0;
    print_test("LIMIT returns correct top-N results", test15_pass);
    println!("  Top 3 salaries: ${:.0}, ${:.0}, ${:.0}", 
        limited[0].salary, limited[1].salary, limited[2].salary);

    // TEST 16: GROUP BY produces correct groups
    println!("\nTest 16: GROUP BY");
    println!("SQL: SELECT department, COUNT(*) FROM employees GROUP BY department;");
    
    let grouped = Query::new(&employees).group_by(Employee::department_r());
    let eng_count = grouped.get("Engineering").map(|v| v.len()).unwrap_or(0);
    let sales_count = grouped.get("Sales").map(|v| v.len()).unwrap_or(0);
    let marketing_count = grouped.get("Marketing").map(|v| v.len()).unwrap_or(0);
    
    let test16_pass = eng_count == 3 && sales_count == 2 && marketing_count == 1;
    print_test("GROUP BY produces correct counts", test16_pass);
    println!("  Engineering: {}, Sales: {}, Marketing: {}", eng_count, sales_count, marketing_count);

    // TEST 17: Email pattern matching (regex-like)
    println!("\nTest 17: Email domain filtering (LIKE '%@example.com')");
    println!("SQL: SELECT * FROM employees WHERE email LIKE '%@example.com';");
    
    let example_emails = Query::new(&employees)
        .where_(Employee::email_r(), |email| email.ends_with("@example.com"))
        .count();
    
    let test17_pass = example_emails == 6; // All employees have @example.com emails
    print_test("Email pattern matching works correctly", test17_pass);
    println!("  Found {} employees with @example.com emails", example_emails);

    // Summary
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Test Summary                                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");
    
    let tests = vec![
        ("ORDER BY DESC", test1_pass),
        ("ORDER BY ASC", test2_pass),
        ("ORDER BY name", test3_pass),
        ("LIKE 'prefix%'", test4_pass),
        ("LIKE '%suffix'", test5_pass),
        ("LIKE '%contains%'", test6_pass),
        ("IN clause", test7_pass),
        ("BETWEEN clause", test8_pass),
        ("COUNT", test9_pass),
        ("AVG accuracy", test10_pass),
        ("MIN/MAX", test11_pass),
        ("Complex WHERE", test12_pass),
        ("Case-sensitive", test13_pass),
        ("Case-insensitive", test14_pass),
        ("LIMIT", test15_pass),
        ("GROUP BY", test16_pass),
        ("Email patterns", test17_pass),
    ];
    
    let passed = tests.iter().filter(|(_, p)| *p).count();
    let total = tests.len();
    
    println!("Results: {}/{} tests passed", passed, total);
    
    if passed == total {
        println!("\n🎉 All tests PASSED! Rust Query Builder produces exact SQL-equivalent results!");
        println!("\n✅ Verified:");
        println!("  • Exact ordering (ASC/DESC)");
        println!("  • LIKE operations (starts_with, ends_with, contains)");
        println!("  • IN clause (OR conditions)");
        println!("  • BETWEEN clause");
        println!("  • Aggregations (COUNT, AVG, MIN, MAX)");
        println!("  • Complex WHERE conditions");
        println!("  • Case sensitivity");
        println!("  • LIMIT clause");
        println!("  • GROUP BY");
        println!("  • Pattern matching");
    } else {
        println!("\n⚠️  {} test(s) failed. See details above.", total - passed);
    }
}

pub fn order_by_float_desc(&self, path: KeyPaths<T, f64>) -> Vec<T>

Orders results by a float field in descending order.

Arguments

• path - The key-path to the f64 field to order by

Example

let sorted = query.order_by_float_desc(Product::rating_r());

Examples found in repository

examples/advanced_query_builder.rs (line 133)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_verification.rs (line 44)

fn main() {
    let employees = create_test_data();
    
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  SQL Equivalence Verification Tests                           ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // TEST 1: ORDER BY maintains exact SQL ordering (DESC)
    println!("Test 1: ORDER BY DESC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC;");
    
    let ordered = Query::new(&employees).order_by_float_desc(Employee::salary_r());
    let expected_order = vec![105000.0, 95000.0, 87000.0, 82000.0, 75000.0, 71000.0];
    let actual_order: Vec<f64> = ordered.iter().map(|e| e.salary).collect();
    
    let test1_pass = expected_order == actual_order;
    print_test("ORDER BY salary DESC produces correct order", test1_pass);
    if !test1_pass {
        println!("  Expected: {:?}", expected_order);
        println!("  Got: {:?}", actual_order);
    }

    // TEST 2: ORDER BY maintains exact SQL ordering (ASC)
    println!("\nTest 2: ORDER BY ASC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary ASC;");
    
    let ordered_asc = Query::new(&employees).order_by_float(Employee::salary_r());
    let expected_asc = vec![71000.0, 75000.0, 82000.0, 87000.0, 95000.0, 105000.0];
    let actual_asc: Vec<f64> = ordered_asc.iter().map(|e| e.salary).collect();
    
    let test2_pass = expected_asc == actual_asc;
    print_test("ORDER BY salary ASC produces correct order", test2_pass);
    if !test2_pass {
        println!("  Expected: {:?}", expected_asc);
        println!("  Got: {:?}", actual_asc);
    }

    // TEST 3: String ordering (alphabetical)
    println!("\nTest 3: ORDER BY name (alphabetical)");
    println!("SQL: SELECT name FROM employees ORDER BY name;");
    
    let ordered_names = Query::new(&employees).order_by(Employee::name_r());
    let expected_names = vec!["Alice Cooper", "Alice Johnson", "Bob Smith", "Carol White", "David Brown", "Eve Davis"];
    let actual_names: Vec<&str> = ordered_names.iter().map(|e| e.name.as_str()).collect();
    
    let test3_pass = expected_names == actual_names;
    print_test("ORDER BY name produces correct alphabetical order", test3_pass);
    if !test3_pass {
        println!("  Expected: {:?}", expected_names);
        println!("  Got: {:?}", actual_names);
    }

    // TEST 4: LIKE equivalent - starts with
    println!("\nTest 4: LIKE 'Alice%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE 'Alice%';");
    
    let like_alice_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.starts_with("Alice"));
    let like_alice = like_alice_query.all();
    
    let test4_pass = like_alice.len() == 2 
        && like_alice.iter().all(|e| e.name.starts_with("Alice"));
    print_test("LIKE 'Alice%' (starts_with) works correctly", test4_pass);
    if test4_pass {
        for emp in &like_alice {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 5: LIKE equivalent - ends with
    println!("\nTest 5: LIKE '%son' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%son';");
    
    let like_son_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.ends_with("son"));
    let like_son = like_son_query.all();
    
    let test5_pass = like_son.len() == 1 && like_son[0].name == "Alice Johnson";
    print_test("LIKE '%son' (ends_with) works correctly", test5_pass);
    if test5_pass {
        for emp in &like_son {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 6: LIKE equivalent - contains
    println!("\nTest 6: LIKE '%mit%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%mit%';");
    
    let like_mit_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.contains("mit"));
    let like_mit = like_mit_query.all();
    
    let test6_pass = like_mit.len() == 1 && like_mit[0].name == "Bob Smith";
    print_test("LIKE '%mit%' (contains) works correctly", test6_pass);
    if test6_pass {
        for emp in &like_mit {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 7: IN clause equivalent
    println!("\nTest 7: IN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE department IN ('Engineering', 'Sales');");
    
    let in_depts_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales");
    let in_depts = in_depts_query.all();
    
    let test7_pass = in_depts.len() == 5 // 3 Engineering + 2 Sales
        && in_depts.iter().all(|e| e.department == "Engineering" || e.department == "Sales");
    print_test("IN clause works correctly", test7_pass);
    println!("  Found {} employees in Engineering or Sales", in_depts.len());

    // TEST 8: BETWEEN equivalent
    println!("\nTest 8: BETWEEN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE salary BETWEEN 75000 AND 90000;");
    
    let between_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal >= 75000.0 && sal <= 90000.0);
    let between = between_query.all();
    
    let test8_pass = between.len() == 3;
    print_test("BETWEEN clause works correctly", test8_pass);
    println!("  Found {} employees with salary between 75K-90K", between.len());

    // TEST 9: COUNT with WHERE
    println!("\nTest 9: COUNT with WHERE");
    println!("SQL: SELECT COUNT(*) FROM employees WHERE department = 'Engineering';");
    
    let count_eng = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .count();
    
    let test9_pass = count_eng == 3;
    print_test("COUNT with WHERE produces correct result", test9_pass);
    println!("  Count: {} (expected 3)", count_eng);

    // TEST 10: AVG produces exact result
    println!("\nTest 10: AVG aggregation accuracy");
    println!("SQL: SELECT AVG(salary) FROM employees WHERE department = 'Engineering';");
    
    let avg_sal = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .avg(Employee::salary_r())
        .unwrap_or(0.0);
    
    let expected_avg = (95000.0 + 87000.0 + 105000.0) / 3.0;
    let test10_pass = (avg_sal - expected_avg).abs() < 0.01;
    print_test("AVG produces mathematically correct result", test10_pass);
    println!("  Average: ${:.2} (expected ${:.2})", avg_sal, expected_avg);

    // TEST 11: MIN and MAX
    println!("\nTest 11: MIN and MAX aggregations");
    println!("SQL: SELECT MIN(salary), MAX(salary) FROM employees;");
    
    let min_sal = Query::new(&employees).min_float(Employee::salary_r()).unwrap_or(0.0);
    let max_sal = Query::new(&employees).max_float(Employee::salary_r()).unwrap_or(0.0);
    
    let test11_pass = min_sal == 71000.0 && max_sal == 105000.0;
    print_test("MIN and MAX produce correct results", test11_pass);
    println!("  MIN: ${:.2}, MAX: ${:.2}", min_sal, max_sal);

    // TEST 12: Complex WHERE with AND/OR
    println!("\nTest 12: Complex WHERE (AND + OR)");
    println!("SQL: SELECT * FROM employees WHERE (department = 'Engineering' OR department = 'Sales') AND salary > 80000;");
    
    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal > 80000.0);
    let complex = complex_query.all();
    
    let test12_pass = complex.len() == 4; // Alice J ($95k), Bob ($87k), David ($82k), Alice C ($105k)
    print_test("Complex WHERE clause works correctly", test12_pass);
    println!("  Found {} employees", complex.len());

    // TEST 13: Case-sensitive string comparison (SQL default)
    println!("\nTest 13: Case-sensitive comparison (like SQL)");
    println!("SQL: SELECT * FROM employees WHERE department = 'engineering'; -- should find 0");
    
    let case_sensitive = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "engineering") // lowercase
        .count();
    
    let test13_pass = case_sensitive == 0;
    print_test("Case-sensitive comparison (SQL default)", test13_pass);
    println!("  Found {} with lowercase 'engineering' (expected 0)", case_sensitive);

    // TEST 14: Case-insensitive LIKE equivalent
    println!("\nTest 14: Case-insensitive LIKE (ILIKE equivalent)");
    println!("SQL: SELECT * FROM employees WHERE LOWER(name) LIKE '%alice%';");
    
    let ilike_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.to_lowercase().contains("alice"));
    let ilike = ilike_query.all();
    
    let test14_pass = ilike.len() == 2;
    print_test("Case-insensitive LIKE works correctly", test14_pass);
    println!("  Found {} employees with 'alice' (case-insensitive)", ilike.len());

    // TEST 15: LIMIT produces exact subset
    println!("\nTest 15: LIMIT clause");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC LIMIT 3;");
    
    let limited = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r())
        .into_iter()
        .take(3)
        .collect::<Vec<_>>();
    
    let test15_pass = limited.len() == 3 
        && limited[0].salary == 105000.0
        && limited[1].salary == 95000.0
        && limited[2].salary == 87000.0;
    print_test("LIMIT returns correct top-N results", test15_pass);
    println!("  Top 3 salaries: ${:.0}, ${:.0}, ${:.0}", 
        limited[0].salary, limited[1].salary, limited[2].salary);

    // TEST 16: GROUP BY produces correct groups
    println!("\nTest 16: GROUP BY");
    println!("SQL: SELECT department, COUNT(*) FROM employees GROUP BY department;");
    
    let grouped = Query::new(&employees).group_by(Employee::department_r());
    let eng_count = grouped.get("Engineering").map(|v| v.len()).unwrap_or(0);
    let sales_count = grouped.get("Sales").map(|v| v.len()).unwrap_or(0);
    let marketing_count = grouped.get("Marketing").map(|v| v.len()).unwrap_or(0);
    
    let test16_pass = eng_count == 3 && sales_count == 2 && marketing_count == 1;
    print_test("GROUP BY produces correct counts", test16_pass);
    println!("  Engineering: {}, Sales: {}, Marketing: {}", eng_count, sales_count, marketing_count);

    // TEST 17: Email pattern matching (regex-like)
    println!("\nTest 17: Email domain filtering (LIKE '%@example.com')");
    println!("SQL: SELECT * FROM employees WHERE email LIKE '%@example.com';");
    
    let example_emails = Query::new(&employees)
        .where_(Employee::email_r(), |email| email.ends_with("@example.com"))
        .count();
    
    let test17_pass = example_emails == 6; // All employees have @example.com emails
    print_test("Email pattern matching works correctly", test17_pass);
    println!("  Found {} employees with @example.com emails", example_emails);

    // Summary
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Test Summary                                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");
    
    let tests = vec![
        ("ORDER BY DESC", test1_pass),
        ("ORDER BY ASC", test2_pass),
        ("ORDER BY name", test3_pass),
        ("LIKE 'prefix%'", test4_pass),
        ("LIKE '%suffix'", test5_pass),
        ("LIKE '%contains%'", test6_pass),
        ("IN clause", test7_pass),
        ("BETWEEN clause", test8_pass),
        ("COUNT", test9_pass),
        ("AVG accuracy", test10_pass),
        ("MIN/MAX", test11_pass),
        ("Complex WHERE", test12_pass),
        ("Case-sensitive", test13_pass),
        ("Case-insensitive", test14_pass),
        ("LIMIT", test15_pass),
        ("GROUP BY", test16_pass),
        ("Email patterns", test17_pass),
    ];
    
    let passed = tests.iter().filter(|(_, p)| *p).count();
    let total = tests.len();
    
    println!("Results: {}/{} tests passed", passed, total);
    
    if passed == total {
        println!("\n🎉 All tests PASSED! Rust Query Builder produces exact SQL-equivalent results!");
        println!("\n✅ Verified:");
        println!("  • Exact ordering (ASC/DESC)");
        println!("  • LIKE operations (starts_with, ends_with, contains)");
        println!("  • IN clause (OR conditions)");
        println!("  • BETWEEN clause");
        println!("  • Aggregations (COUNT, AVG, MIN, MAX)");
        println!("  • Complex WHERE conditions");
        println!("  • Case sensitivity");
        println!("  • LIMIT clause");
        println!("  • GROUP BY");
        println!("  • Pattern matching");
    } else {
        println!("\n⚠️  {} test(s) failed. See details above.", total - passed);
    }
}

examples/sql_comparison.rs (line 236)

fn main() {
    let employees = create_employees();
    let departments = create_departments();
    let projects = create_projects();

    println!("\n╔════════════════════════════════════════════════════════════════════════╗");
    println!("║     SQL vs Rust Query Builder Comparison                              ║");
    println!("║     Demonstrating equivalent operations                               ║");
    println!("╚════════════════════════════════════════════════════════════════════════╝");

    // ============================================================================
    // EXAMPLE 1: Simple SELECT with WHERE
    // ============================================================================
    print_separator("Example 1: SELECT with WHERE clause");
    print_query(
        "SELECT * FROM employees WHERE department = 'Engineering';",
        "Filter employees by department"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering_employees = eng_query.all();

    for emp in &engineering_employees {
        println!("  ID: {}, Name: {}, Salary: ${:.2}", emp.id, emp.name, emp.salary);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\")");
    println!("    .all()");
    println!("✓ Found {} employees", engineering_employees.len());

    // ============================================================================
    // EXAMPLE 2: SELECT specific columns
    // ============================================================================
    print_separator("Example 2: SELECT specific columns (Projection)");
    print_query(
        "SELECT name FROM employees WHERE salary > 80000;",
        "Get names of high-earning employees"
    );

    let high_earners = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 80000.0)
        .select(Employee::name_r());

    for name in &high_earners {
        println!("  {}", name);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 80000.0)");
    println!("    .select(Employee::name_r())");
    println!("✓ Found {} employees", high_earners.len());

    // ============================================================================
    // EXAMPLE 3: COUNT
    // ============================================================================
    print_separator("Example 3: COUNT aggregation");
    print_query(
        "SELECT COUNT(*) FROM employees WHERE age < 30;",
        "Count young employees"
    );

    let young_count = Query::new(&employees)
        .where_(Employee::age_r(), |&age| age < 30)
        .count();

    println!("  Count: {}", young_count);
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::age_r(), |&age| age < 30)");
    println!("    .count()");
    println!("✓ Result: {}", young_count);

    // ============================================================================
    // EXAMPLE 4: SUM, AVG, MIN, MAX
    // ============================================================================
    print_separator("Example 4: Aggregate functions (SUM, AVG, MIN, MAX)");
    print_query(
        "SELECT \n\
         SUM(salary) as total_salary,\n\
         AVG(salary) as avg_salary,\n\
         MIN(salary) as min_salary,\n\
         MAX(salary) as max_salary\n\
         FROM employees WHERE department = 'Engineering';",
        "Engineering department salary statistics"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");

    let total = eng_query.sum(Employee::salary_r());
    let avg = eng_query.avg(Employee::salary_r()).unwrap_or(0.0);
    let min = eng_query.min_float(Employee::salary_r()).unwrap_or(0.0);
    let max = eng_query.max_float(Employee::salary_r()).unwrap_or(0.0);

    println!("  Total Salary: ${:.2}", total);
    println!("  Avg Salary:   ${:.2}", avg);
    println!("  Min Salary:   ${:.2}", min);
    println!("  Max Salary:   ${:.2}", max);

    println!("\nRust Query Builder:");
    println!("let query = Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\");");
    println!("query.sum(Employee::salary_r())  // ${:.2}", total);
    println!("query.avg(Employee::salary_r())  // ${:.2}", avg);
    println!("query.min_float(Employee::salary_r())  // ${:.2}", min);
    println!("query.max_float(Employee::salary_r())  // ${:.2}", max);

    // ============================================================================
    // EXAMPLE 5: GROUP BY with aggregation
    // ============================================================================
    print_separator("Example 5: GROUP BY with aggregation");
    print_query(
        "SELECT \n\
         department,\n\
         COUNT(*) as emp_count,\n\
         AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY department;",
        "Statistics by department"
    );

    let by_dept = Query::new(&employees).group_by(Employee::department_r());

    for (dept, emps) in &by_dept {
        let dept_query = Query::new(emps);
        let count = emps.len();
        let avg_sal = dept_query.avg(Employee::salary_r()).unwrap_or(0.0);
        println!("  {}: {} employees, avg salary ${:.2}", dept, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_dept = Query::new(&employees).group_by(Employee::department_r());");
    println!("for (dept, emps) in &by_dept {{");
    println!("    let dept_query = Query::new(emps);");
    println!("    dept_query.avg(Employee::salary_r())");
    println!("}}");

    // ============================================================================
    // EXAMPLE 6: ORDER BY
    // ============================================================================
    print_separator("Example 6: ORDER BY");
    print_query(
        "SELECT name, salary FROM employees\n\
         WHERE department = 'Sales'\n\
         ORDER BY salary DESC;",
        "Sales employees ordered by salary (descending)"
    );

    let sales_sorted = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .order_by_float_desc(Employee::salary_r());

    for emp in &sales_sorted {
        println!("  {}: ${:.2}", emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Sales\")");
    println!("    .order_by_float_desc(Employee::salary_r())");

    // ============================================================================
    // EXAMPLE 7: Multiple WHERE conditions (AND)
    // ============================================================================
    print_separator("Example 7: Multiple WHERE conditions (AND)");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > 70000 AND age < 35;",
        "High-earning young employees"
    );

    let filter_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 70000.0)
        .where_(Employee::age_r(), |&age| age < 35);
    let filtered = filter_query.all();

    for emp in &filtered {
        println!("  {}: Age {}, Salary ${:.2}", emp.name, emp.age, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 70000.0)");
    println!("    .where_(Employee::age_r(), |&age| age < 35)");
    println!("    .all()");
    println!("✓ Found {} employees", filtered.len());

    // ============================================================================
    // EXAMPLE 8: LIMIT (TOP N)
    // ============================================================================
    print_separator("Example 8: LIMIT / TOP N");
    print_query(
        "SELECT TOP 3 name, salary FROM employees\n\
         ORDER BY salary DESC;",
        "Top 3 highest paid employees"
    );

    let top_earners = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r());

    for (i, emp) in top_earners.iter().take(3).enumerate() {
        println!("  {}. {}: ${:.2}", i + 1, emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("    .into_iter().take(3)");

    // ============================================================================
    // EXAMPLE 9: OFFSET and LIMIT (Pagination)
    // ============================================================================
    print_separator("Example 9: OFFSET and LIMIT (Pagination)");
    print_query(
        "SELECT name FROM employees\n\
         ORDER BY name\n\
         LIMIT 3 OFFSET 3;",
        "Page 2 of employee names (3 per page)"
    );

    let page_2 = Query::new(&employees)
        .order_by(Employee::name_r())
        .into_iter()
        .skip(3)
        .take(3)
        .collect::<Vec<_>>();

    for emp in &page_2 {
        println!("  {}", emp.name);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by(Employee::name_r())");
    println!("    .into_iter().skip(3).take(3)");

    // ============================================================================
    // EXAMPLE 10: INNER JOIN
    // ============================================================================
    print_separator("Example 10: INNER JOIN");
    print_query(
        "SELECT e.name, d.name as dept_name, d.budget\n\
         FROM employees e\n\
         INNER JOIN departments d ON e.department = d.name;",
        "Employees with their department info"
    );

    let emp_dept = JoinQuery::new(&employees, &departments).inner_join(
        Employee::department_r(),
        Department::name_r(),
        |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget),
    );

    for (emp_name, dept_name, budget) in emp_dept.iter().take(5) {
        println!("  {} works in {} (Budget: ${:.0})", emp_name, dept_name, budget);
    }
    println!("  ... (showing first 5)");

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&employees, &departments).inner_join(");
    println!("    Employee::department_r(),");
    println!("    Department::name_r(),");
    println!("    |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget)");
    println!(")");
    println!("✓ Found {} matches", emp_dept.len());

    // ============================================================================
    // EXAMPLE 11: GROUP BY with HAVING equivalent
    // ============================================================================
    print_separator("Example 11: GROUP BY with filtering (HAVING equivalent)");
    print_query(
        "SELECT city, COUNT(*) as emp_count, AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY city\n\
         HAVING COUNT(*) > 1;",
        "Cities with multiple employees"
    );

    let by_city = Query::new(&employees).group_by(Employee::city_r());
    let mut city_stats: Vec<_> = by_city
        .iter()
        .filter(|(_, emps)| emps.len() > 1) // HAVING equivalent
        .map(|(city, emps)| {
            let avg_sal = Query::new(emps).avg(Employee::salary_r()).unwrap_or(0.0);
            (city.clone(), emps.len(), avg_sal)
        })
        .collect();
    
    city_stats.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count

    for (city, count, avg_sal) in &city_stats {
        println!("  {}: {} employees, avg salary ${:.2}", city, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_city = Query::new(&employees).group_by(Employee::city_r());");
    println!("by_city.iter()");
    println!("    .filter(|(_, emps)| emps.len() > 1)  // HAVING equivalent");
    println!("    .map(|(city, emps)| {{");
    println!("        let avg = Query::new(emps).avg(Employee::salary_r());");
    println!("        (city, emps.len(), avg)");
    println!("    }})");

    // ============================================================================
    // EXAMPLE 12: Complex query with multiple operations
    // ============================================================================
    print_separator("Example 12: Complex multi-operation query");
    print_query(
        "SELECT name, salary, age\n\
         FROM employees\n\
         WHERE department IN ('Engineering', 'Sales')\n\
         AND salary BETWEEN 80000 AND 100000\n\
         AND age >= 30\n\
         ORDER BY salary DESC;",
        "Experienced mid-to-senior level employees in core departments"
    );

    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)
        .where_(Employee::age_r(), |&age| age >= 30)
        .order_by_float_desc(Employee::salary_r());

    for emp in &complex_query {
        println!("  {}: Age {}, {} dept, ${:.2}", emp.name, emp.age, emp.department, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\" || dept == \"Sales\")");
    println!("    .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)");
    println!("    .where_(Employee::age_r(), |&age| age >= 30)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("✓ Found {} employees", complex_query.len());

    // ============================================================================
    // EXAMPLE 13: Three-table JOIN
    // ============================================================================
    print_separator("Example 13: Three-table JOIN");
    print_query(
        "SELECT p.name as project, d.name as department, d.location\n\
         FROM projects p\n\
         INNER JOIN departments d ON p.department_id = d.id;",
        "Projects with their department details"
    );

    let proj_dept = JoinQuery::new(&projects, &departments).inner_join(
        Project::department_id_r(),
        Department::id_r(),
        |proj, dept| {
            (proj.name.clone(), dept.name.clone(), dept.location.clone(), proj.budget)
        },
    );

    for (proj_name, dept_name, location, budget) in &proj_dept {
        println!("  {}: {} dept in {} (${:.0})", proj_name, dept_name, location, budget);
    }

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&projects, &departments).inner_join(");
    println!("    Project::department_id_r(),");
    println!("    Department::id_r(),");
    println!("    |proj, dept| (proj.name, dept.name, dept.location, proj.budget)");
    println!(")");

    // ============================================================================
    // EXAMPLE 14: Subquery equivalent (using intermediate results)
    // ============================================================================
    print_separator("Example 14: Subquery equivalent");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > (SELECT AVG(salary) FROM employees);",
        "Employees earning above average"
    );

    let avg_salary = Query::new(&employees)
        .avg(Employee::salary_r())
        .unwrap_or(0.0);

    let above_avg_query = Query::new(&employees)
        .where_(Employee::salary_r(), move |&sal| sal > avg_salary);
    let above_avg = above_avg_query.all();

    println!("  Average salary: ${:.2}", avg_salary);
    for emp in &above_avg {
        println!("  {}: ${:.2} ({:.1}% above average)", 
            emp.name, emp.salary, ((emp.salary - avg_salary) / avg_salary * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let avg = Query::new(&employees).avg(Employee::salary_r()).unwrap_or(0.0);");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&sal| sal > avg)");
    println!("    .all()");
    println!("✓ Found {} employees above average", above_avg.len());

    // ============================================================================
    // EXAMPLE 15: Advanced aggregation (revenue calculation)
    // ============================================================================
    print_separator("Example 15: Advanced aggregation");
    print_query(
        "SELECT \n\
         d.name,\n\
         d.budget as dept_budget,\n\
         SUM(p.budget) as total_project_budget,\n\
         (d.budget - SUM(p.budget)) as remaining_budget\n\
         FROM departments d\n\
         LEFT JOIN projects p ON d.id = p.department_id\n\
         GROUP BY d.name, d.budget;",
        "Department budget utilization"
    );

    // Join departments with projects
    let dept_projects = JoinQuery::new(&departments, &projects).left_join(
        Department::id_r(),
        Project::department_id_r(),
        |dept, proj| (dept.clone(), proj.map(|p| p.clone())),
    );

    // Aggregate by department
    let mut dept_budget_map: HashMap<String, (f64, Vec<f64>)> = HashMap::new();
    for (dept, proj) in dept_projects {
        let entry = dept_budget_map
            .entry(dept.name.clone())
            .or_insert((dept.budget, Vec::new()));
        if let Some(p) = proj {
            entry.1.push(p.budget);
        }
    }

    for (dept_name, (total_budget, project_budgets)) in dept_budget_map.iter() {
        let used: f64 = project_budgets.iter().sum();
        let remaining = total_budget - used;
        println!("  {}: Budget ${:.0}, Used ${:.0}, Remaining ${:.0} ({:.1}% utilized)",
            dept_name, total_budget, used, remaining, (used / total_budget * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let dept_projects = JoinQuery::new(&departments, &projects)");
    println!("    .left_join(Department::id_r(), Project::department_id_r(), ...)");
    println!("// Then aggregate using HashMap");

    // ============================================================================
    // Summary
    // ============================================================================
    print_separator("Summary");
    println!("\n✓ All 15 SQL queries successfully replicated with Rust Query Builder!");
    println!("\nDemonstrated equivalents for:");
    println!("  • SELECT with WHERE");
    println!("  • Projection (SELECT specific columns)");
    println!("  • Aggregations (COUNT, SUM, AVG, MIN, MAX)");
    println!("  • GROUP BY");
    println!("  • ORDER BY");
    println!("  • LIMIT and OFFSET");
    println!("  • INNER JOIN and LEFT JOIN");
    println!("  • Complex conditions (AND, OR, BETWEEN)");
    println!("  • Subqueries");
    println!("  • Multi-table operations");
    println!("\n🎯 Type-safe, compile-time checked, and zero runtime overhead!");
    println!();
}

pub fn select<F>(&self, path: KeyPaths<T, F>) -> Vec<F>

where F: Clone + 'static,

Projects/selects a single field from results.

Arguments

• path - The key-path to the field to select

Example

let names = query.select(Product::name_r());

Examples found in repository

examples/doc_examples.rs (line 73)

fn main() {
    println!("Testing documentation examples...\n");

    // Example from README - Quick Start
    println!("Test 1: README Quick Start Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let affordable_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price < 100.0);
        let affordable_electronics = affordable_query.all();

        println!("  Found {} affordable electronics ✅", affordable_electronics.len());
    }

    // Example from README - Filtering
    println!("\nTest 2: Filtering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");
        let electronics = electronics_query.all();

        println!("  Found {} electronics ✅", electronics.len());
    }

    // Example from README - Selecting
    println!("\nTest 3: Selecting Fields Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let names: Vec<String> = Query::new(&products)
            .select(Product::name_r());

        println!("  Selected {} names ✅", names.len());
    }

    // Example from README - Ordering
    println!("\nTest 4: Ordering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let by_price = Query::new(&products).order_by_float(Product::price_r());
        println!("  Ordered {} products ✅", by_price.len());
    }

    // Example from README - Aggregations
    println!("\nTest 5: Aggregations Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");

        let count = electronics_query.count();
        let total_value: f64 = electronics_query.sum(Product::price_r());
        let avg_price = electronics_query.avg(Product::price_r()).unwrap_or(0.0);

        println!("  Count: {}, Total: ${:.2}, Avg: ${:.2} ✅", count, total_value, avg_price);
    }

    // Example from README - Grouping
    println!("\nTest 6: Grouping Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let by_category = Query::new(&products).group_by(Product::category_r());
        println!("  Grouped into {} categories ✅", by_category.len());
    }

    // Example from README - Pagination
    println!("\nTest 7: Pagination Example");
    {
        let products = vec![
            Product { id: 1, name: "P1".to_string(), price: 10.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 2, name: "P2".to_string(), price: 20.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 3, name: "P3".to_string(), price: 30.0, category: "A".to_string(), stock: 1, rating: 4.0 },
        ];

        let query = Query::new(&products);
        let first_10 = query.limit(10);
        let page_1 = query.skip(0).limit(10);

        println!("  Limited to {} products ✅", first_10.len());
        println!("  Page 1 has {} products ✅", page_1.len());
    }

    // Example from README - Join
    println!("\nTest 8: Join Example");
    {
        let users = vec![
            User { id: 1, name: "Alice".to_string() },
            User { id: 2, name: "Bob".to_string() },
        ];

        let orders = vec![
            Order { id: 101, user_id: 1, total: 99.99 },
            Order { id: 102, user_id: 1, total: 149.99 },
        ];

        let user_orders = JoinQuery::new(&users, &orders).inner_join(
            User::id_r(),
            Order::user_id_r(),
            |user, order| (user.name.clone(), order.total),
        );

        println!("  Joined {} user-order pairs ✅", user_orders.len());
    }

    // Example from SQL_COMPARISON - SELECT with WHERE
    println!("\nTest 9: SQL Comparison - SELECT with WHERE");
    {
        #[derive(Clone, Keypaths)]
        struct Employee {
            department: String,
        }

        let employees = vec![
            Employee { department: "Engineering".to_string() },
            Employee { department: "Sales".to_string() },
        ];

        let engineering_query = Query::new(&employees)
            .where_(Employee::department_r(), |dept| dept == "Engineering");
        let engineering = engineering_query.all();

        println!("  Found {} engineering employees ✅", engineering.len());
    }

    // Example from USAGE.md - Complex Filtering
    println!("\nTest 10: USAGE - Complex Filtering");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let results_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price >= 100.0 && price <= 500.0)
            .where_(Product::stock_r(), |&stock| stock > 10);
        let results = results_query.order_by_float(Product::price_r());

        println!("  Filtered {} products ✅", results.len());
    }

    println!("\n✅ All documentation examples compile and run successfully!");
}

examples/advanced_query_builder.rs (line 118)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_comparison.rs (line 127)

fn main() {
    let employees = create_employees();
    let departments = create_departments();
    let projects = create_projects();

    println!("\n╔════════════════════════════════════════════════════════════════════════╗");
    println!("║     SQL vs Rust Query Builder Comparison                              ║");
    println!("║     Demonstrating equivalent operations                               ║");
    println!("╚════════════════════════════════════════════════════════════════════════╝");

    // ============================================================================
    // EXAMPLE 1: Simple SELECT with WHERE
    // ============================================================================
    print_separator("Example 1: SELECT with WHERE clause");
    print_query(
        "SELECT * FROM employees WHERE department = 'Engineering';",
        "Filter employees by department"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering_employees = eng_query.all();

    for emp in &engineering_employees {
        println!("  ID: {}, Name: {}, Salary: ${:.2}", emp.id, emp.name, emp.salary);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\")");
    println!("    .all()");
    println!("✓ Found {} employees", engineering_employees.len());

    // ============================================================================
    // EXAMPLE 2: SELECT specific columns
    // ============================================================================
    print_separator("Example 2: SELECT specific columns (Projection)");
    print_query(
        "SELECT name FROM employees WHERE salary > 80000;",
        "Get names of high-earning employees"
    );

    let high_earners = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 80000.0)
        .select(Employee::name_r());

    for name in &high_earners {
        println!("  {}", name);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 80000.0)");
    println!("    .select(Employee::name_r())");
    println!("✓ Found {} employees", high_earners.len());

    // ============================================================================
    // EXAMPLE 3: COUNT
    // ============================================================================
    print_separator("Example 3: COUNT aggregation");
    print_query(
        "SELECT COUNT(*) FROM employees WHERE age < 30;",
        "Count young employees"
    );

    let young_count = Query::new(&employees)
        .where_(Employee::age_r(), |&age| age < 30)
        .count();

    println!("  Count: {}", young_count);
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::age_r(), |&age| age < 30)");
    println!("    .count()");
    println!("✓ Result: {}", young_count);

    // ============================================================================
    // EXAMPLE 4: SUM, AVG, MIN, MAX
    // ============================================================================
    print_separator("Example 4: Aggregate functions (SUM, AVG, MIN, MAX)");
    print_query(
        "SELECT \n\
         SUM(salary) as total_salary,\n\
         AVG(salary) as avg_salary,\n\
         MIN(salary) as min_salary,\n\
         MAX(salary) as max_salary\n\
         FROM employees WHERE department = 'Engineering';",
        "Engineering department salary statistics"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");

    let total = eng_query.sum(Employee::salary_r());
    let avg = eng_query.avg(Employee::salary_r()).unwrap_or(0.0);
    let min = eng_query.min_float(Employee::salary_r()).unwrap_or(0.0);
    let max = eng_query.max_float(Employee::salary_r()).unwrap_or(0.0);

    println!("  Total Salary: ${:.2}", total);
    println!("  Avg Salary:   ${:.2}", avg);
    println!("  Min Salary:   ${:.2}", min);
    println!("  Max Salary:   ${:.2}", max);

    println!("\nRust Query Builder:");
    println!("let query = Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\");");
    println!("query.sum(Employee::salary_r())  // ${:.2}", total);
    println!("query.avg(Employee::salary_r())  // ${:.2}", avg);
    println!("query.min_float(Employee::salary_r())  // ${:.2}", min);
    println!("query.max_float(Employee::salary_r())  // ${:.2}", max);

    // ============================================================================
    // EXAMPLE 5: GROUP BY with aggregation
    // ============================================================================
    print_separator("Example 5: GROUP BY with aggregation");
    print_query(
        "SELECT \n\
         department,\n\
         COUNT(*) as emp_count,\n\
         AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY department;",
        "Statistics by department"
    );

    let by_dept = Query::new(&employees).group_by(Employee::department_r());

    for (dept, emps) in &by_dept {
        let dept_query = Query::new(emps);
        let count = emps.len();
        let avg_sal = dept_query.avg(Employee::salary_r()).unwrap_or(0.0);
        println!("  {}: {} employees, avg salary ${:.2}", dept, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_dept = Query::new(&employees).group_by(Employee::department_r());");
    println!("for (dept, emps) in &by_dept {{");
    println!("    let dept_query = Query::new(emps);");
    println!("    dept_query.avg(Employee::salary_r())");
    println!("}}");

    // ============================================================================
    // EXAMPLE 6: ORDER BY
    // ============================================================================
    print_separator("Example 6: ORDER BY");
    print_query(
        "SELECT name, salary FROM employees\n\
         WHERE department = 'Sales'\n\
         ORDER BY salary DESC;",
        "Sales employees ordered by salary (descending)"
    );

    let sales_sorted = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .order_by_float_desc(Employee::salary_r());

    for emp in &sales_sorted {
        println!("  {}: ${:.2}", emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Sales\")");
    println!("    .order_by_float_desc(Employee::salary_r())");

    // ============================================================================
    // EXAMPLE 7: Multiple WHERE conditions (AND)
    // ============================================================================
    print_separator("Example 7: Multiple WHERE conditions (AND)");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > 70000 AND age < 35;",
        "High-earning young employees"
    );

    let filter_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 70000.0)
        .where_(Employee::age_r(), |&age| age < 35);
    let filtered = filter_query.all();

    for emp in &filtered {
        println!("  {}: Age {}, Salary ${:.2}", emp.name, emp.age, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 70000.0)");
    println!("    .where_(Employee::age_r(), |&age| age < 35)");
    println!("    .all()");
    println!("✓ Found {} employees", filtered.len());

    // ============================================================================
    // EXAMPLE 8: LIMIT (TOP N)
    // ============================================================================
    print_separator("Example 8: LIMIT / TOP N");
    print_query(
        "SELECT TOP 3 name, salary FROM employees\n\
         ORDER BY salary DESC;",
        "Top 3 highest paid employees"
    );

    let top_earners = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r());

    for (i, emp) in top_earners.iter().take(3).enumerate() {
        println!("  {}. {}: ${:.2}", i + 1, emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("    .into_iter().take(3)");

    // ============================================================================
    // EXAMPLE 9: OFFSET and LIMIT (Pagination)
    // ============================================================================
    print_separator("Example 9: OFFSET and LIMIT (Pagination)");
    print_query(
        "SELECT name FROM employees\n\
         ORDER BY name\n\
         LIMIT 3 OFFSET 3;",
        "Page 2 of employee names (3 per page)"
    );

    let page_2 = Query::new(&employees)
        .order_by(Employee::name_r())
        .into_iter()
        .skip(3)
        .take(3)
        .collect::<Vec<_>>();

    for emp in &page_2 {
        println!("  {}", emp.name);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by(Employee::name_r())");
    println!("    .into_iter().skip(3).take(3)");

    // ============================================================================
    // EXAMPLE 10: INNER JOIN
    // ============================================================================
    print_separator("Example 10: INNER JOIN");
    print_query(
        "SELECT e.name, d.name as dept_name, d.budget\n\
         FROM employees e\n\
         INNER JOIN departments d ON e.department = d.name;",
        "Employees with their department info"
    );

    let emp_dept = JoinQuery::new(&employees, &departments).inner_join(
        Employee::department_r(),
        Department::name_r(),
        |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget),
    );

    for (emp_name, dept_name, budget) in emp_dept.iter().take(5) {
        println!("  {} works in {} (Budget: ${:.0})", emp_name, dept_name, budget);
    }
    println!("  ... (showing first 5)");

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&employees, &departments).inner_join(");
    println!("    Employee::department_r(),");
    println!("    Department::name_r(),");
    println!("    |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget)");
    println!(")");
    println!("✓ Found {} matches", emp_dept.len());

    // ============================================================================
    // EXAMPLE 11: GROUP BY with HAVING equivalent
    // ============================================================================
    print_separator("Example 11: GROUP BY with filtering (HAVING equivalent)");
    print_query(
        "SELECT city, COUNT(*) as emp_count, AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY city\n\
         HAVING COUNT(*) > 1;",
        "Cities with multiple employees"
    );

    let by_city = Query::new(&employees).group_by(Employee::city_r());
    let mut city_stats: Vec<_> = by_city
        .iter()
        .filter(|(_, emps)| emps.len() > 1) // HAVING equivalent
        .map(|(city, emps)| {
            let avg_sal = Query::new(emps).avg(Employee::salary_r()).unwrap_or(0.0);
            (city.clone(), emps.len(), avg_sal)
        })
        .collect();
    
    city_stats.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count

    for (city, count, avg_sal) in &city_stats {
        println!("  {}: {} employees, avg salary ${:.2}", city, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_city = Query::new(&employees).group_by(Employee::city_r());");
    println!("by_city.iter()");
    println!("    .filter(|(_, emps)| emps.len() > 1)  // HAVING equivalent");
    println!("    .map(|(city, emps)| {{");
    println!("        let avg = Query::new(emps).avg(Employee::salary_r());");
    println!("        (city, emps.len(), avg)");
    println!("    }})");

    // ============================================================================
    // EXAMPLE 12: Complex query with multiple operations
    // ============================================================================
    print_separator("Example 12: Complex multi-operation query");
    print_query(
        "SELECT name, salary, age\n\
         FROM employees\n\
         WHERE department IN ('Engineering', 'Sales')\n\
         AND salary BETWEEN 80000 AND 100000\n\
         AND age >= 30\n\
         ORDER BY salary DESC;",
        "Experienced mid-to-senior level employees in core departments"
    );

    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)
        .where_(Employee::age_r(), |&age| age >= 30)
        .order_by_float_desc(Employee::salary_r());

    for emp in &complex_query {
        println!("  {}: Age {}, {} dept, ${:.2}", emp.name, emp.age, emp.department, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\" || dept == \"Sales\")");
    println!("    .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)");
    println!("    .where_(Employee::age_r(), |&age| age >= 30)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("✓ Found {} employees", complex_query.len());

    // ============================================================================
    // EXAMPLE 13: Three-table JOIN
    // ============================================================================
    print_separator("Example 13: Three-table JOIN");
    print_query(
        "SELECT p.name as project, d.name as department, d.location\n\
         FROM projects p\n\
         INNER JOIN departments d ON p.department_id = d.id;",
        "Projects with their department details"
    );

    let proj_dept = JoinQuery::new(&projects, &departments).inner_join(
        Project::department_id_r(),
        Department::id_r(),
        |proj, dept| {
            (proj.name.clone(), dept.name.clone(), dept.location.clone(), proj.budget)
        },
    );

    for (proj_name, dept_name, location, budget) in &proj_dept {
        println!("  {}: {} dept in {} (${:.0})", proj_name, dept_name, location, budget);
    }

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&projects, &departments).inner_join(");
    println!("    Project::department_id_r(),");
    println!("    Department::id_r(),");
    println!("    |proj, dept| (proj.name, dept.name, dept.location, proj.budget)");
    println!(")");

    // ============================================================================
    // EXAMPLE 14: Subquery equivalent (using intermediate results)
    // ============================================================================
    print_separator("Example 14: Subquery equivalent");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > (SELECT AVG(salary) FROM employees);",
        "Employees earning above average"
    );

    let avg_salary = Query::new(&employees)
        .avg(Employee::salary_r())
        .unwrap_or(0.0);

    let above_avg_query = Query::new(&employees)
        .where_(Employee::salary_r(), move |&sal| sal > avg_salary);
    let above_avg = above_avg_query.all();

    println!("  Average salary: ${:.2}", avg_salary);
    for emp in &above_avg {
        println!("  {}: ${:.2} ({:.1}% above average)", 
            emp.name, emp.salary, ((emp.salary - avg_salary) / avg_salary * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let avg = Query::new(&employees).avg(Employee::salary_r()).unwrap_or(0.0);");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&sal| sal > avg)");
    println!("    .all()");
    println!("✓ Found {} employees above average", above_avg.len());

    // ============================================================================
    // EXAMPLE 15: Advanced aggregation (revenue calculation)
    // ============================================================================
    print_separator("Example 15: Advanced aggregation");
    print_query(
        "SELECT \n\
         d.name,\n\
         d.budget as dept_budget,\n\
         SUM(p.budget) as total_project_budget,\n\
         (d.budget - SUM(p.budget)) as remaining_budget\n\
         FROM departments d\n\
         LEFT JOIN projects p ON d.id = p.department_id\n\
         GROUP BY d.name, d.budget;",
        "Department budget utilization"
    );

    // Join departments with projects
    let dept_projects = JoinQuery::new(&departments, &projects).left_join(
        Department::id_r(),
        Project::department_id_r(),
        |dept, proj| (dept.clone(), proj.map(|p| p.clone())),
    );

    // Aggregate by department
    let mut dept_budget_map: HashMap<String, (f64, Vec<f64>)> = HashMap::new();
    for (dept, proj) in dept_projects {
        let entry = dept_budget_map
            .entry(dept.name.clone())
            .or_insert((dept.budget, Vec::new()));
        if let Some(p) = proj {
            entry.1.push(p.budget);
        }
    }

    for (dept_name, (total_budget, project_budgets)) in dept_budget_map.iter() {
        let used: f64 = project_budgets.iter().sum();
        let remaining = total_budget - used;
        println!("  {}: Budget ${:.0}, Used ${:.0}, Remaining ${:.0} ({:.1}% utilized)",
            dept_name, total_budget, used, remaining, (used / total_budget * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let dept_projects = JoinQuery::new(&departments, &projects)");
    println!("    .left_join(Department::id_r(), Project::department_id_r(), ...)");
    println!("// Then aggregate using HashMap");

    // ============================================================================
    // Summary
    // ============================================================================
    print_separator("Summary");
    println!("\n✓ All 15 SQL queries successfully replicated with Rust Query Builder!");
    println!("\nDemonstrated equivalents for:");
    println!("  • SELECT with WHERE");
    println!("  • Projection (SELECT specific columns)");
    println!("  • Aggregations (COUNT, SUM, AVG, MIN, MAX)");
    println!("  • GROUP BY");
    println!("  • ORDER BY");
    println!("  • LIMIT and OFFSET");
    println!("  • INNER JOIN and LEFT JOIN");
    println!("  • Complex conditions (AND, OR, BETWEEN)");
    println!("  • Subqueries");
    println!("  • Multi-table operations");
    println!("\n🎯 Type-safe, compile-time checked, and zero runtime overhead!");
    println!();
}

pub fn group_by<F>(&self, path: KeyPaths<T, F>) -> HashMap<F, Vec<T>>

where F: Eq + Hash + Clone + 'static,

Groups results by a field value.

Arguments

• path - The key-path to the field to group by

Example

let by_category = query.group_by(Product::category_r());

Examples found in repository

examples/doc_examples.rs (line 117)

fn main() {
    println!("Testing documentation examples...\n");

    // Example from README - Quick Start
    println!("Test 1: README Quick Start Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let affordable_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price < 100.0);
        let affordable_electronics = affordable_query.all();

        println!("  Found {} affordable electronics ✅", affordable_electronics.len());
    }

    // Example from README - Filtering
    println!("\nTest 2: Filtering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");
        let electronics = electronics_query.all();

        println!("  Found {} electronics ✅", electronics.len());
    }

    // Example from README - Selecting
    println!("\nTest 3: Selecting Fields Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let names: Vec<String> = Query::new(&products)
            .select(Product::name_r());

        println!("  Selected {} names ✅", names.len());
    }

    // Example from README - Ordering
    println!("\nTest 4: Ordering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let by_price = Query::new(&products).order_by_float(Product::price_r());
        println!("  Ordered {} products ✅", by_price.len());
    }

    // Example from README - Aggregations
    println!("\nTest 5: Aggregations Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");

        let count = electronics_query.count();
        let total_value: f64 = electronics_query.sum(Product::price_r());
        let avg_price = electronics_query.avg(Product::price_r()).unwrap_or(0.0);

        println!("  Count: {}, Total: ${:.2}, Avg: ${:.2} ✅", count, total_value, avg_price);
    }

    // Example from README - Grouping
    println!("\nTest 6: Grouping Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let by_category = Query::new(&products).group_by(Product::category_r());
        println!("  Grouped into {} categories ✅", by_category.len());
    }

    // Example from README - Pagination
    println!("\nTest 7: Pagination Example");
    {
        let products = vec![
            Product { id: 1, name: "P1".to_string(), price: 10.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 2, name: "P2".to_string(), price: 20.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 3, name: "P3".to_string(), price: 30.0, category: "A".to_string(), stock: 1, rating: 4.0 },
        ];

        let query = Query::new(&products);
        let first_10 = query.limit(10);
        let page_1 = query.skip(0).limit(10);

        println!("  Limited to {} products ✅", first_10.len());
        println!("  Page 1 has {} products ✅", page_1.len());
    }

    // Example from README - Join
    println!("\nTest 8: Join Example");
    {
        let users = vec![
            User { id: 1, name: "Alice".to_string() },
            User { id: 2, name: "Bob".to_string() },
        ];

        let orders = vec![
            Order { id: 101, user_id: 1, total: 99.99 },
            Order { id: 102, user_id: 1, total: 149.99 },
        ];

        let user_orders = JoinQuery::new(&users, &orders).inner_join(
            User::id_r(),
            Order::user_id_r(),
            |user, order| (user.name.clone(), order.total),
        );

        println!("  Joined {} user-order pairs ✅", user_orders.len());
    }

    // Example from SQL_COMPARISON - SELECT with WHERE
    println!("\nTest 9: SQL Comparison - SELECT with WHERE");
    {
        #[derive(Clone, Keypaths)]
        struct Employee {
            department: String,
        }

        let employees = vec![
            Employee { department: "Engineering".to_string() },
            Employee { department: "Sales".to_string() },
        ];

        let engineering_query = Query::new(&employees)
            .where_(Employee::department_r(), |dept| dept == "Engineering");
        let engineering = engineering_query.all();

        println!("  Found {} engineering employees ✅", engineering.len());
    }

    // Example from USAGE.md - Complex Filtering
    println!("\nTest 10: USAGE - Complex Filtering");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let results_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price >= 100.0 && price <= 500.0)
            .where_(Product::stock_r(), |&stock| stock > 10);
        let results = results_query.order_by_float(Product::price_r());

        println!("  Filtered {} products ✅", results.len());
    }

    println!("\n✅ All documentation examples compile and run successfully!");
}

examples/advanced_query_builder.rs (line 140)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_verification.rs (line 255)

fn main() {
    let employees = create_test_data();
    
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  SQL Equivalence Verification Tests                           ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // TEST 1: ORDER BY maintains exact SQL ordering (DESC)
    println!("Test 1: ORDER BY DESC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC;");
    
    let ordered = Query::new(&employees).order_by_float_desc(Employee::salary_r());
    let expected_order = vec![105000.0, 95000.0, 87000.0, 82000.0, 75000.0, 71000.0];
    let actual_order: Vec<f64> = ordered.iter().map(|e| e.salary).collect();
    
    let test1_pass = expected_order == actual_order;
    print_test("ORDER BY salary DESC produces correct order", test1_pass);
    if !test1_pass {
        println!("  Expected: {:?}", expected_order);
        println!("  Got: {:?}", actual_order);
    }

    // TEST 2: ORDER BY maintains exact SQL ordering (ASC)
    println!("\nTest 2: ORDER BY ASC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary ASC;");
    
    let ordered_asc = Query::new(&employees).order_by_float(Employee::salary_r());
    let expected_asc = vec![71000.0, 75000.0, 82000.0, 87000.0, 95000.0, 105000.0];
    let actual_asc: Vec<f64> = ordered_asc.iter().map(|e| e.salary).collect();
    
    let test2_pass = expected_asc == actual_asc;
    print_test("ORDER BY salary ASC produces correct order", test2_pass);
    if !test2_pass {
        println!("  Expected: {:?}", expected_asc);
        println!("  Got: {:?}", actual_asc);
    }

    // TEST 3: String ordering (alphabetical)
    println!("\nTest 3: ORDER BY name (alphabetical)");
    println!("SQL: SELECT name FROM employees ORDER BY name;");
    
    let ordered_names = Query::new(&employees).order_by(Employee::name_r());
    let expected_names = vec!["Alice Cooper", "Alice Johnson", "Bob Smith", "Carol White", "David Brown", "Eve Davis"];
    let actual_names: Vec<&str> = ordered_names.iter().map(|e| e.name.as_str()).collect();
    
    let test3_pass = expected_names == actual_names;
    print_test("ORDER BY name produces correct alphabetical order", test3_pass);
    if !test3_pass {
        println!("  Expected: {:?}", expected_names);
        println!("  Got: {:?}", actual_names);
    }

    // TEST 4: LIKE equivalent - starts with
    println!("\nTest 4: LIKE 'Alice%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE 'Alice%';");
    
    let like_alice_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.starts_with("Alice"));
    let like_alice = like_alice_query.all();
    
    let test4_pass = like_alice.len() == 2 
        && like_alice.iter().all(|e| e.name.starts_with("Alice"));
    print_test("LIKE 'Alice%' (starts_with) works correctly", test4_pass);
    if test4_pass {
        for emp in &like_alice {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 5: LIKE equivalent - ends with
    println!("\nTest 5: LIKE '%son' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%son';");
    
    let like_son_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.ends_with("son"));
    let like_son = like_son_query.all();
    
    let test5_pass = like_son.len() == 1 && like_son[0].name == "Alice Johnson";
    print_test("LIKE '%son' (ends_with) works correctly", test5_pass);
    if test5_pass {
        for emp in &like_son {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 6: LIKE equivalent - contains
    println!("\nTest 6: LIKE '%mit%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%mit%';");
    
    let like_mit_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.contains("mit"));
    let like_mit = like_mit_query.all();
    
    let test6_pass = like_mit.len() == 1 && like_mit[0].name == "Bob Smith";
    print_test("LIKE '%mit%' (contains) works correctly", test6_pass);
    if test6_pass {
        for emp in &like_mit {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 7: IN clause equivalent
    println!("\nTest 7: IN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE department IN ('Engineering', 'Sales');");
    
    let in_depts_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales");
    let in_depts = in_depts_query.all();
    
    let test7_pass = in_depts.len() == 5 // 3 Engineering + 2 Sales
        && in_depts.iter().all(|e| e.department == "Engineering" || e.department == "Sales");
    print_test("IN clause works correctly", test7_pass);
    println!("  Found {} employees in Engineering or Sales", in_depts.len());

    // TEST 8: BETWEEN equivalent
    println!("\nTest 8: BETWEEN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE salary BETWEEN 75000 AND 90000;");
    
    let between_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal >= 75000.0 && sal <= 90000.0);
    let between = between_query.all();
    
    let test8_pass = between.len() == 3;
    print_test("BETWEEN clause works correctly", test8_pass);
    println!("  Found {} employees with salary between 75K-90K", between.len());

    // TEST 9: COUNT with WHERE
    println!("\nTest 9: COUNT with WHERE");
    println!("SQL: SELECT COUNT(*) FROM employees WHERE department = 'Engineering';");
    
    let count_eng = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .count();
    
    let test9_pass = count_eng == 3;
    print_test("COUNT with WHERE produces correct result", test9_pass);
    println!("  Count: {} (expected 3)", count_eng);

    // TEST 10: AVG produces exact result
    println!("\nTest 10: AVG aggregation accuracy");
    println!("SQL: SELECT AVG(salary) FROM employees WHERE department = 'Engineering';");
    
    let avg_sal = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .avg(Employee::salary_r())
        .unwrap_or(0.0);
    
    let expected_avg = (95000.0 + 87000.0 + 105000.0) / 3.0;
    let test10_pass = (avg_sal - expected_avg).abs() < 0.01;
    print_test("AVG produces mathematically correct result", test10_pass);
    println!("  Average: ${:.2} (expected ${:.2})", avg_sal, expected_avg);

    // TEST 11: MIN and MAX
    println!("\nTest 11: MIN and MAX aggregations");
    println!("SQL: SELECT MIN(salary), MAX(salary) FROM employees;");
    
    let min_sal = Query::new(&employees).min_float(Employee::salary_r()).unwrap_or(0.0);
    let max_sal = Query::new(&employees).max_float(Employee::salary_r()).unwrap_or(0.0);
    
    let test11_pass = min_sal == 71000.0 && max_sal == 105000.0;
    print_test("MIN and MAX produce correct results", test11_pass);
    println!("  MIN: ${:.2}, MAX: ${:.2}", min_sal, max_sal);

    // TEST 12: Complex WHERE with AND/OR
    println!("\nTest 12: Complex WHERE (AND + OR)");
    println!("SQL: SELECT * FROM employees WHERE (department = 'Engineering' OR department = 'Sales') AND salary > 80000;");
    
    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal > 80000.0);
    let complex = complex_query.all();
    
    let test12_pass = complex.len() == 4; // Alice J ($95k), Bob ($87k), David ($82k), Alice C ($105k)
    print_test("Complex WHERE clause works correctly", test12_pass);
    println!("  Found {} employees", complex.len());

    // TEST 13: Case-sensitive string comparison (SQL default)
    println!("\nTest 13: Case-sensitive comparison (like SQL)");
    println!("SQL: SELECT * FROM employees WHERE department = 'engineering'; -- should find 0");
    
    let case_sensitive = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "engineering") // lowercase
        .count();
    
    let test13_pass = case_sensitive == 0;
    print_test("Case-sensitive comparison (SQL default)", test13_pass);
    println!("  Found {} with lowercase 'engineering' (expected 0)", case_sensitive);

    // TEST 14: Case-insensitive LIKE equivalent
    println!("\nTest 14: Case-insensitive LIKE (ILIKE equivalent)");
    println!("SQL: SELECT * FROM employees WHERE LOWER(name) LIKE '%alice%';");
    
    let ilike_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.to_lowercase().contains("alice"));
    let ilike = ilike_query.all();
    
    let test14_pass = ilike.len() == 2;
    print_test("Case-insensitive LIKE works correctly", test14_pass);
    println!("  Found {} employees with 'alice' (case-insensitive)", ilike.len());

    // TEST 15: LIMIT produces exact subset
    println!("\nTest 15: LIMIT clause");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC LIMIT 3;");
    
    let limited = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r())
        .into_iter()
        .take(3)
        .collect::<Vec<_>>();
    
    let test15_pass = limited.len() == 3 
        && limited[0].salary == 105000.0
        && limited[1].salary == 95000.0
        && limited[2].salary == 87000.0;
    print_test("LIMIT returns correct top-N results", test15_pass);
    println!("  Top 3 salaries: ${:.0}, ${:.0}, ${:.0}", 
        limited[0].salary, limited[1].salary, limited[2].salary);

    // TEST 16: GROUP BY produces correct groups
    println!("\nTest 16: GROUP BY");
    println!("SQL: SELECT department, COUNT(*) FROM employees GROUP BY department;");
    
    let grouped = Query::new(&employees).group_by(Employee::department_r());
    let eng_count = grouped.get("Engineering").map(|v| v.len()).unwrap_or(0);
    let sales_count = grouped.get("Sales").map(|v| v.len()).unwrap_or(0);
    let marketing_count = grouped.get("Marketing").map(|v| v.len()).unwrap_or(0);
    
    let test16_pass = eng_count == 3 && sales_count == 2 && marketing_count == 1;
    print_test("GROUP BY produces correct counts", test16_pass);
    println!("  Engineering: {}, Sales: {}, Marketing: {}", eng_count, sales_count, marketing_count);

    // TEST 17: Email pattern matching (regex-like)
    println!("\nTest 17: Email domain filtering (LIKE '%@example.com')");
    println!("SQL: SELECT * FROM employees WHERE email LIKE '%@example.com';");
    
    let example_emails = Query::new(&employees)
        .where_(Employee::email_r(), |email| email.ends_with("@example.com"))
        .count();
    
    let test17_pass = example_emails == 6; // All employees have @example.com emails
    print_test("Email pattern matching works correctly", test17_pass);
    println!("  Found {} employees with @example.com emails", example_emails);

    // Summary
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Test Summary                                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");
    
    let tests = vec![
        ("ORDER BY DESC", test1_pass),
        ("ORDER BY ASC", test2_pass),
        ("ORDER BY name", test3_pass),
        ("LIKE 'prefix%'", test4_pass),
        ("LIKE '%suffix'", test5_pass),
        ("LIKE '%contains%'", test6_pass),
        ("IN clause", test7_pass),
        ("BETWEEN clause", test8_pass),
        ("COUNT", test9_pass),
        ("AVG accuracy", test10_pass),
        ("MIN/MAX", test11_pass),
        ("Complex WHERE", test12_pass),
        ("Case-sensitive", test13_pass),
        ("Case-insensitive", test14_pass),
        ("LIMIT", test15_pass),
        ("GROUP BY", test16_pass),
        ("Email patterns", test17_pass),
    ];
    
    let passed = tests.iter().filter(|(_, p)| *p).count();
    let total = tests.len();
    
    println!("Results: {}/{} tests passed", passed, total);
    
    if passed == total {
        println!("\n🎉 All tests PASSED! Rust Query Builder produces exact SQL-equivalent results!");
        println!("\n✅ Verified:");
        println!("  • Exact ordering (ASC/DESC)");
        println!("  • LIKE operations (starts_with, ends_with, contains)");
        println!("  • IN clause (OR conditions)");
        println!("  • BETWEEN clause");
        println!("  • Aggregations (COUNT, AVG, MIN, MAX)");
        println!("  • Complex WHERE conditions");
        println!("  • Case sensitivity");
        println!("  • LIMIT clause");
        println!("  • GROUP BY");
        println!("  • Pattern matching");
    } else {
        println!("\n⚠️  {} test(s) failed. See details above.", total - passed);
    }
}

examples/sql_comparison.rs (line 207)

fn main() {
    let employees = create_employees();
    let departments = create_departments();
    let projects = create_projects();

    println!("\n╔════════════════════════════════════════════════════════════════════════╗");
    println!("║     SQL vs Rust Query Builder Comparison                              ║");
    println!("║     Demonstrating equivalent operations                               ║");
    println!("╚════════════════════════════════════════════════════════════════════════╝");

    // ============================================================================
    // EXAMPLE 1: Simple SELECT with WHERE
    // ============================================================================
    print_separator("Example 1: SELECT with WHERE clause");
    print_query(
        "SELECT * FROM employees WHERE department = 'Engineering';",
        "Filter employees by department"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering_employees = eng_query.all();

    for emp in &engineering_employees {
        println!("  ID: {}, Name: {}, Salary: ${:.2}", emp.id, emp.name, emp.salary);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\")");
    println!("    .all()");
    println!("✓ Found {} employees", engineering_employees.len());

    // ============================================================================
    // EXAMPLE 2: SELECT specific columns
    // ============================================================================
    print_separator("Example 2: SELECT specific columns (Projection)");
    print_query(
        "SELECT name FROM employees WHERE salary > 80000;",
        "Get names of high-earning employees"
    );

    let high_earners = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 80000.0)
        .select(Employee::name_r());

    for name in &high_earners {
        println!("  {}", name);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 80000.0)");
    println!("    .select(Employee::name_r())");
    println!("✓ Found {} employees", high_earners.len());

    // ============================================================================
    // EXAMPLE 3: COUNT
    // ============================================================================
    print_separator("Example 3: COUNT aggregation");
    print_query(
        "SELECT COUNT(*) FROM employees WHERE age < 30;",
        "Count young employees"
    );

    let young_count = Query::new(&employees)
        .where_(Employee::age_r(), |&age| age < 30)
        .count();

    println!("  Count: {}", young_count);
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::age_r(), |&age| age < 30)");
    println!("    .count()");
    println!("✓ Result: {}", young_count);

    // ============================================================================
    // EXAMPLE 4: SUM, AVG, MIN, MAX
    // ============================================================================
    print_separator("Example 4: Aggregate functions (SUM, AVG, MIN, MAX)");
    print_query(
        "SELECT \n\
         SUM(salary) as total_salary,\n\
         AVG(salary) as avg_salary,\n\
         MIN(salary) as min_salary,\n\
         MAX(salary) as max_salary\n\
         FROM employees WHERE department = 'Engineering';",
        "Engineering department salary statistics"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");

    let total = eng_query.sum(Employee::salary_r());
    let avg = eng_query.avg(Employee::salary_r()).unwrap_or(0.0);
    let min = eng_query.min_float(Employee::salary_r()).unwrap_or(0.0);
    let max = eng_query.max_float(Employee::salary_r()).unwrap_or(0.0);

    println!("  Total Salary: ${:.2}", total);
    println!("  Avg Salary:   ${:.2}", avg);
    println!("  Min Salary:   ${:.2}", min);
    println!("  Max Salary:   ${:.2}", max);

    println!("\nRust Query Builder:");
    println!("let query = Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\");");
    println!("query.sum(Employee::salary_r())  // ${:.2}", total);
    println!("query.avg(Employee::salary_r())  // ${:.2}", avg);
    println!("query.min_float(Employee::salary_r())  // ${:.2}", min);
    println!("query.max_float(Employee::salary_r())  // ${:.2}", max);

    // ============================================================================
    // EXAMPLE 5: GROUP BY with aggregation
    // ============================================================================
    print_separator("Example 5: GROUP BY with aggregation");
    print_query(
        "SELECT \n\
         department,\n\
         COUNT(*) as emp_count,\n\
         AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY department;",
        "Statistics by department"
    );

    let by_dept = Query::new(&employees).group_by(Employee::department_r());

    for (dept, emps) in &by_dept {
        let dept_query = Query::new(emps);
        let count = emps.len();
        let avg_sal = dept_query.avg(Employee::salary_r()).unwrap_or(0.0);
        println!("  {}: {} employees, avg salary ${:.2}", dept, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_dept = Query::new(&employees).group_by(Employee::department_r());");
    println!("for (dept, emps) in &by_dept {{");
    println!("    let dept_query = Query::new(emps);");
    println!("    dept_query.avg(Employee::salary_r())");
    println!("}}");

    // ============================================================================
    // EXAMPLE 6: ORDER BY
    // ============================================================================
    print_separator("Example 6: ORDER BY");
    print_query(
        "SELECT name, salary FROM employees\n\
         WHERE department = 'Sales'\n\
         ORDER BY salary DESC;",
        "Sales employees ordered by salary (descending)"
    );

    let sales_sorted = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .order_by_float_desc(Employee::salary_r());

    for emp in &sales_sorted {
        println!("  {}: ${:.2}", emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Sales\")");
    println!("    .order_by_float_desc(Employee::salary_r())");

    // ============================================================================
    // EXAMPLE 7: Multiple WHERE conditions (AND)
    // ============================================================================
    print_separator("Example 7: Multiple WHERE conditions (AND)");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > 70000 AND age < 35;",
        "High-earning young employees"
    );

    let filter_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 70000.0)
        .where_(Employee::age_r(), |&age| age < 35);
    let filtered = filter_query.all();

    for emp in &filtered {
        println!("  {}: Age {}, Salary ${:.2}", emp.name, emp.age, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 70000.0)");
    println!("    .where_(Employee::age_r(), |&age| age < 35)");
    println!("    .all()");
    println!("✓ Found {} employees", filtered.len());

    // ============================================================================
    // EXAMPLE 8: LIMIT (TOP N)
    // ============================================================================
    print_separator("Example 8: LIMIT / TOP N");
    print_query(
        "SELECT TOP 3 name, salary FROM employees\n\
         ORDER BY salary DESC;",
        "Top 3 highest paid employees"
    );

    let top_earners = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r());

    for (i, emp) in top_earners.iter().take(3).enumerate() {
        println!("  {}. {}: ${:.2}", i + 1, emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("    .into_iter().take(3)");

    // ============================================================================
    // EXAMPLE 9: OFFSET and LIMIT (Pagination)
    // ============================================================================
    print_separator("Example 9: OFFSET and LIMIT (Pagination)");
    print_query(
        "SELECT name FROM employees\n\
         ORDER BY name\n\
         LIMIT 3 OFFSET 3;",
        "Page 2 of employee names (3 per page)"
    );

    let page_2 = Query::new(&employees)
        .order_by(Employee::name_r())
        .into_iter()
        .skip(3)
        .take(3)
        .collect::<Vec<_>>();

    for emp in &page_2 {
        println!("  {}", emp.name);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by(Employee::name_r())");
    println!("    .into_iter().skip(3).take(3)");

    // ============================================================================
    // EXAMPLE 10: INNER JOIN
    // ============================================================================
    print_separator("Example 10: INNER JOIN");
    print_query(
        "SELECT e.name, d.name as dept_name, d.budget\n\
         FROM employees e\n\
         INNER JOIN departments d ON e.department = d.name;",
        "Employees with their department info"
    );

    let emp_dept = JoinQuery::new(&employees, &departments).inner_join(
        Employee::department_r(),
        Department::name_r(),
        |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget),
    );

    for (emp_name, dept_name, budget) in emp_dept.iter().take(5) {
        println!("  {} works in {} (Budget: ${:.0})", emp_name, dept_name, budget);
    }
    println!("  ... (showing first 5)");

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&employees, &departments).inner_join(");
    println!("    Employee::department_r(),");
    println!("    Department::name_r(),");
    println!("    |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget)");
    println!(")");
    println!("✓ Found {} matches", emp_dept.len());

    // ============================================================================
    // EXAMPLE 11: GROUP BY with HAVING equivalent
    // ============================================================================
    print_separator("Example 11: GROUP BY with filtering (HAVING equivalent)");
    print_query(
        "SELECT city, COUNT(*) as emp_count, AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY city\n\
         HAVING COUNT(*) > 1;",
        "Cities with multiple employees"
    );

    let by_city = Query::new(&employees).group_by(Employee::city_r());
    let mut city_stats: Vec<_> = by_city
        .iter()
        .filter(|(_, emps)| emps.len() > 1) // HAVING equivalent
        .map(|(city, emps)| {
            let avg_sal = Query::new(emps).avg(Employee::salary_r()).unwrap_or(0.0);
            (city.clone(), emps.len(), avg_sal)
        })
        .collect();
    
    city_stats.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count

    for (city, count, avg_sal) in &city_stats {
        println!("  {}: {} employees, avg salary ${:.2}", city, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_city = Query::new(&employees).group_by(Employee::city_r());");
    println!("by_city.iter()");
    println!("    .filter(|(_, emps)| emps.len() > 1)  // HAVING equivalent");
    println!("    .map(|(city, emps)| {{");
    println!("        let avg = Query::new(emps).avg(Employee::salary_r());");
    println!("        (city, emps.len(), avg)");
    println!("    }})");

    // ============================================================================
    // EXAMPLE 12: Complex query with multiple operations
    // ============================================================================
    print_separator("Example 12: Complex multi-operation query");
    print_query(
        "SELECT name, salary, age\n\
         FROM employees\n\
         WHERE department IN ('Engineering', 'Sales')\n\
         AND salary BETWEEN 80000 AND 100000\n\
         AND age >= 30\n\
         ORDER BY salary DESC;",
        "Experienced mid-to-senior level employees in core departments"
    );

    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)
        .where_(Employee::age_r(), |&age| age >= 30)
        .order_by_float_desc(Employee::salary_r());

    for emp in &complex_query {
        println!("  {}: Age {}, {} dept, ${:.2}", emp.name, emp.age, emp.department, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\" || dept == \"Sales\")");
    println!("    .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)");
    println!("    .where_(Employee::age_r(), |&age| age >= 30)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("✓ Found {} employees", complex_query.len());

    // ============================================================================
    // EXAMPLE 13: Three-table JOIN
    // ============================================================================
    print_separator("Example 13: Three-table JOIN");
    print_query(
        "SELECT p.name as project, d.name as department, d.location\n\
         FROM projects p\n\
         INNER JOIN departments d ON p.department_id = d.id;",
        "Projects with their department details"
    );

    let proj_dept = JoinQuery::new(&projects, &departments).inner_join(
        Project::department_id_r(),
        Department::id_r(),
        |proj, dept| {
            (proj.name.clone(), dept.name.clone(), dept.location.clone(), proj.budget)
        },
    );

    for (proj_name, dept_name, location, budget) in &proj_dept {
        println!("  {}: {} dept in {} (${:.0})", proj_name, dept_name, location, budget);
    }

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&projects, &departments).inner_join(");
    println!("    Project::department_id_r(),");
    println!("    Department::id_r(),");
    println!("    |proj, dept| (proj.name, dept.name, dept.location, proj.budget)");
    println!(")");

    // ============================================================================
    // EXAMPLE 14: Subquery equivalent (using intermediate results)
    // ============================================================================
    print_separator("Example 14: Subquery equivalent");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > (SELECT AVG(salary) FROM employees);",
        "Employees earning above average"
    );

    let avg_salary = Query::new(&employees)
        .avg(Employee::salary_r())
        .unwrap_or(0.0);

    let above_avg_query = Query::new(&employees)
        .where_(Employee::salary_r(), move |&sal| sal > avg_salary);
    let above_avg = above_avg_query.all();

    println!("  Average salary: ${:.2}", avg_salary);
    for emp in &above_avg {
        println!("  {}: ${:.2} ({:.1}% above average)", 
            emp.name, emp.salary, ((emp.salary - avg_salary) / avg_salary * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let avg = Query::new(&employees).avg(Employee::salary_r()).unwrap_or(0.0);");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&sal| sal > avg)");
    println!("    .all()");
    println!("✓ Found {} employees above average", above_avg.len());

    // ============================================================================
    // EXAMPLE 15: Advanced aggregation (revenue calculation)
    // ============================================================================
    print_separator("Example 15: Advanced aggregation");
    print_query(
        "SELECT \n\
         d.name,\n\
         d.budget as dept_budget,\n\
         SUM(p.budget) as total_project_budget,\n\
         (d.budget - SUM(p.budget)) as remaining_budget\n\
         FROM departments d\n\
         LEFT JOIN projects p ON d.id = p.department_id\n\
         GROUP BY d.name, d.budget;",
        "Department budget utilization"
    );

    // Join departments with projects
    let dept_projects = JoinQuery::new(&departments, &projects).left_join(
        Department::id_r(),
        Project::department_id_r(),
        |dept, proj| (dept.clone(), proj.map(|p| p.clone())),
    );

    // Aggregate by department
    let mut dept_budget_map: HashMap<String, (f64, Vec<f64>)> = HashMap::new();
    for (dept, proj) in dept_projects {
        let entry = dept_budget_map
            .entry(dept.name.clone())
            .or_insert((dept.budget, Vec::new()));
        if let Some(p) = proj {
            entry.1.push(p.budget);
        }
    }

    for (dept_name, (total_budget, project_budgets)) in dept_budget_map.iter() {
        let used: f64 = project_budgets.iter().sum();
        let remaining = total_budget - used;
        println!("  {}: Budget ${:.0}, Used ${:.0}, Remaining ${:.0} ({:.1}% utilized)",
            dept_name, total_budget, used, remaining, (used / total_budget * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let dept_projects = JoinQuery::new(&departments, &projects)");
    println!("    .left_join(Department::id_r(), Project::department_id_r(), ...)");
    println!("// Then aggregate using HashMap");

    // ============================================================================
    // Summary
    // ============================================================================
    print_separator("Summary");
    println!("\n✓ All 15 SQL queries successfully replicated with Rust Query Builder!");
    println!("\nDemonstrated equivalents for:");
    println!("  • SELECT with WHERE");
    println!("  • Projection (SELECT specific columns)");
    println!("  • Aggregations (COUNT, SUM, AVG, MIN, MAX)");
    println!("  • GROUP BY");
    println!("  • ORDER BY");
    println!("  • LIMIT and OFFSET");
    println!("  • INNER JOIN and LEFT JOIN");
    println!("  • Complex conditions (AND, OR, BETWEEN)");
    println!("  • Subqueries");
    println!("  • Multi-table operations");
    println!("\n🎯 Type-safe, compile-time checked, and zero runtime overhead!");
    println!();
}

pub fn sum<F>(&self, path: KeyPaths<T, F>) -> F

where F: Clone + Add<Output = F> + Default + 'static,

Computes the sum of a numeric field.

Arguments

• path - The key-path to the numeric field

Example

let total_price = query.sum(Product::price_r());

Examples found in repository

examples/doc_examples.rs (line 102)

fn main() {
    println!("Testing documentation examples...\n");

    // Example from README - Quick Start
    println!("Test 1: README Quick Start Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let affordable_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price < 100.0);
        let affordable_electronics = affordable_query.all();

        println!("  Found {} affordable electronics ✅", affordable_electronics.len());
    }

    // Example from README - Filtering
    println!("\nTest 2: Filtering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");
        let electronics = electronics_query.all();

        println!("  Found {} electronics ✅", electronics.len());
    }

    // Example from README - Selecting
    println!("\nTest 3: Selecting Fields Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let names: Vec<String> = Query::new(&products)
            .select(Product::name_r());

        println!("  Selected {} names ✅", names.len());
    }

    // Example from README - Ordering
    println!("\nTest 4: Ordering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let by_price = Query::new(&products).order_by_float(Product::price_r());
        println!("  Ordered {} products ✅", by_price.len());
    }

    // Example from README - Aggregations
    println!("\nTest 5: Aggregations Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");

        let count = electronics_query.count();
        let total_value: f64 = electronics_query.sum(Product::price_r());
        let avg_price = electronics_query.avg(Product::price_r()).unwrap_or(0.0);

        println!("  Count: {}, Total: ${:.2}, Avg: ${:.2} ✅", count, total_value, avg_price);
    }

    // Example from README - Grouping
    println!("\nTest 6: Grouping Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let by_category = Query::new(&products).group_by(Product::category_r());
        println!("  Grouped into {} categories ✅", by_category.len());
    }

    // Example from README - Pagination
    println!("\nTest 7: Pagination Example");
    {
        let products = vec![
            Product { id: 1, name: "P1".to_string(), price: 10.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 2, name: "P2".to_string(), price: 20.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 3, name: "P3".to_string(), price: 30.0, category: "A".to_string(), stock: 1, rating: 4.0 },
        ];

        let query = Query::new(&products);
        let first_10 = query.limit(10);
        let page_1 = query.skip(0).limit(10);

        println!("  Limited to {} products ✅", first_10.len());
        println!("  Page 1 has {} products ✅", page_1.len());
    }

    // Example from README - Join
    println!("\nTest 8: Join Example");
    {
        let users = vec![
            User { id: 1, name: "Alice".to_string() },
            User { id: 2, name: "Bob".to_string() },
        ];

        let orders = vec![
            Order { id: 101, user_id: 1, total: 99.99 },
            Order { id: 102, user_id: 1, total: 149.99 },
        ];

        let user_orders = JoinQuery::new(&users, &orders).inner_join(
            User::id_r(),
            Order::user_id_r(),
            |user, order| (user.name.clone(), order.total),
        );

        println!("  Joined {} user-order pairs ✅", user_orders.len());
    }

    // Example from SQL_COMPARISON - SELECT with WHERE
    println!("\nTest 9: SQL Comparison - SELECT with WHERE");
    {
        #[derive(Clone, Keypaths)]
        struct Employee {
            department: String,
        }

        let employees = vec![
            Employee { department: "Engineering".to_string() },
            Employee { department: "Sales".to_string() },
        ];

        let engineering_query = Query::new(&employees)
            .where_(Employee::department_r(), |dept| dept == "Engineering");
        let engineering = engineering_query.all();

        println!("  Found {} engineering employees ✅", engineering.len());
    }

    // Example from USAGE.md - Complex Filtering
    println!("\nTest 10: USAGE - Complex Filtering");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let results_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price >= 100.0 && price <= 500.0)
            .where_(Product::stock_r(), |&stock| stock > 10);
        let results = results_query.order_by_float(Product::price_r());

        println!("  Filtered {} products ✅", results.len());
    }

    println!("\n✅ All documentation examples compile and run successfully!");
}

examples/advanced_query_builder.rs (line 154)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_comparison.rs (line 175)

fn main() {
    let employees = create_employees();
    let departments = create_departments();
    let projects = create_projects();

    println!("\n╔════════════════════════════════════════════════════════════════════════╗");
    println!("║     SQL vs Rust Query Builder Comparison                              ║");
    println!("║     Demonstrating equivalent operations                               ║");
    println!("╚════════════════════════════════════════════════════════════════════════╝");

    // ============================================================================
    // EXAMPLE 1: Simple SELECT with WHERE
    // ============================================================================
    print_separator("Example 1: SELECT with WHERE clause");
    print_query(
        "SELECT * FROM employees WHERE department = 'Engineering';",
        "Filter employees by department"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering_employees = eng_query.all();

    for emp in &engineering_employees {
        println!("  ID: {}, Name: {}, Salary: ${:.2}", emp.id, emp.name, emp.salary);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\")");
    println!("    .all()");
    println!("✓ Found {} employees", engineering_employees.len());

    // ============================================================================
    // EXAMPLE 2: SELECT specific columns
    // ============================================================================
    print_separator("Example 2: SELECT specific columns (Projection)");
    print_query(
        "SELECT name FROM employees WHERE salary > 80000;",
        "Get names of high-earning employees"
    );

    let high_earners = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 80000.0)
        .select(Employee::name_r());

    for name in &high_earners {
        println!("  {}", name);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 80000.0)");
    println!("    .select(Employee::name_r())");
    println!("✓ Found {} employees", high_earners.len());

    // ============================================================================
    // EXAMPLE 3: COUNT
    // ============================================================================
    print_separator("Example 3: COUNT aggregation");
    print_query(
        "SELECT COUNT(*) FROM employees WHERE age < 30;",
        "Count young employees"
    );

    let young_count = Query::new(&employees)
        .where_(Employee::age_r(), |&age| age < 30)
        .count();

    println!("  Count: {}", young_count);
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::age_r(), |&age| age < 30)");
    println!("    .count()");
    println!("✓ Result: {}", young_count);

    // ============================================================================
    // EXAMPLE 4: SUM, AVG, MIN, MAX
    // ============================================================================
    print_separator("Example 4: Aggregate functions (SUM, AVG, MIN, MAX)");
    print_query(
        "SELECT \n\
         SUM(salary) as total_salary,\n\
         AVG(salary) as avg_salary,\n\
         MIN(salary) as min_salary,\n\
         MAX(salary) as max_salary\n\
         FROM employees WHERE department = 'Engineering';",
        "Engineering department salary statistics"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");

    let total = eng_query.sum(Employee::salary_r());
    let avg = eng_query.avg(Employee::salary_r()).unwrap_or(0.0);
    let min = eng_query.min_float(Employee::salary_r()).unwrap_or(0.0);
    let max = eng_query.max_float(Employee::salary_r()).unwrap_or(0.0);

    println!("  Total Salary: ${:.2}", total);
    println!("  Avg Salary:   ${:.2}", avg);
    println!("  Min Salary:   ${:.2}", min);
    println!("  Max Salary:   ${:.2}", max);

    println!("\nRust Query Builder:");
    println!("let query = Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\");");
    println!("query.sum(Employee::salary_r())  // ${:.2}", total);
    println!("query.avg(Employee::salary_r())  // ${:.2}", avg);
    println!("query.min_float(Employee::salary_r())  // ${:.2}", min);
    println!("query.max_float(Employee::salary_r())  // ${:.2}", max);

    // ============================================================================
    // EXAMPLE 5: GROUP BY with aggregation
    // ============================================================================
    print_separator("Example 5: GROUP BY with aggregation");
    print_query(
        "SELECT \n\
         department,\n\
         COUNT(*) as emp_count,\n\
         AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY department;",
        "Statistics by department"
    );

    let by_dept = Query::new(&employees).group_by(Employee::department_r());

    for (dept, emps) in &by_dept {
        let dept_query = Query::new(emps);
        let count = emps.len();
        let avg_sal = dept_query.avg(Employee::salary_r()).unwrap_or(0.0);
        println!("  {}: {} employees, avg salary ${:.2}", dept, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_dept = Query::new(&employees).group_by(Employee::department_r());");
    println!("for (dept, emps) in &by_dept {{");
    println!("    let dept_query = Query::new(emps);");
    println!("    dept_query.avg(Employee::salary_r())");
    println!("}}");

    // ============================================================================
    // EXAMPLE 6: ORDER BY
    // ============================================================================
    print_separator("Example 6: ORDER BY");
    print_query(
        "SELECT name, salary FROM employees\n\
         WHERE department = 'Sales'\n\
         ORDER BY salary DESC;",
        "Sales employees ordered by salary (descending)"
    );

    let sales_sorted = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .order_by_float_desc(Employee::salary_r());

    for emp in &sales_sorted {
        println!("  {}: ${:.2}", emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Sales\")");
    println!("    .order_by_float_desc(Employee::salary_r())");

    // ============================================================================
    // EXAMPLE 7: Multiple WHERE conditions (AND)
    // ============================================================================
    print_separator("Example 7: Multiple WHERE conditions (AND)");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > 70000 AND age < 35;",
        "High-earning young employees"
    );

    let filter_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 70000.0)
        .where_(Employee::age_r(), |&age| age < 35);
    let filtered = filter_query.all();

    for emp in &filtered {
        println!("  {}: Age {}, Salary ${:.2}", emp.name, emp.age, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 70000.0)");
    println!("    .where_(Employee::age_r(), |&age| age < 35)");
    println!("    .all()");
    println!("✓ Found {} employees", filtered.len());

    // ============================================================================
    // EXAMPLE 8: LIMIT (TOP N)
    // ============================================================================
    print_separator("Example 8: LIMIT / TOP N");
    print_query(
        "SELECT TOP 3 name, salary FROM employees\n\
         ORDER BY salary DESC;",
        "Top 3 highest paid employees"
    );

    let top_earners = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r());

    for (i, emp) in top_earners.iter().take(3).enumerate() {
        println!("  {}. {}: ${:.2}", i + 1, emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("    .into_iter().take(3)");

    // ============================================================================
    // EXAMPLE 9: OFFSET and LIMIT (Pagination)
    // ============================================================================
    print_separator("Example 9: OFFSET and LIMIT (Pagination)");
    print_query(
        "SELECT name FROM employees\n\
         ORDER BY name\n\
         LIMIT 3 OFFSET 3;",
        "Page 2 of employee names (3 per page)"
    );

    let page_2 = Query::new(&employees)
        .order_by(Employee::name_r())
        .into_iter()
        .skip(3)
        .take(3)
        .collect::<Vec<_>>();

    for emp in &page_2 {
        println!("  {}", emp.name);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by(Employee::name_r())");
    println!("    .into_iter().skip(3).take(3)");

    // ============================================================================
    // EXAMPLE 10: INNER JOIN
    // ============================================================================
    print_separator("Example 10: INNER JOIN");
    print_query(
        "SELECT e.name, d.name as dept_name, d.budget\n\
         FROM employees e\n\
         INNER JOIN departments d ON e.department = d.name;",
        "Employees with their department info"
    );

    let emp_dept = JoinQuery::new(&employees, &departments).inner_join(
        Employee::department_r(),
        Department::name_r(),
        |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget),
    );

    for (emp_name, dept_name, budget) in emp_dept.iter().take(5) {
        println!("  {} works in {} (Budget: ${:.0})", emp_name, dept_name, budget);
    }
    println!("  ... (showing first 5)");

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&employees, &departments).inner_join(");
    println!("    Employee::department_r(),");
    println!("    Department::name_r(),");
    println!("    |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget)");
    println!(")");
    println!("✓ Found {} matches", emp_dept.len());

    // ============================================================================
    // EXAMPLE 11: GROUP BY with HAVING equivalent
    // ============================================================================
    print_separator("Example 11: GROUP BY with filtering (HAVING equivalent)");
    print_query(
        "SELECT city, COUNT(*) as emp_count, AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY city\n\
         HAVING COUNT(*) > 1;",
        "Cities with multiple employees"
    );

    let by_city = Query::new(&employees).group_by(Employee::city_r());
    let mut city_stats: Vec<_> = by_city
        .iter()
        .filter(|(_, emps)| emps.len() > 1) // HAVING equivalent
        .map(|(city, emps)| {
            let avg_sal = Query::new(emps).avg(Employee::salary_r()).unwrap_or(0.0);
            (city.clone(), emps.len(), avg_sal)
        })
        .collect();
    
    city_stats.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count

    for (city, count, avg_sal) in &city_stats {
        println!("  {}: {} employees, avg salary ${:.2}", city, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_city = Query::new(&employees).group_by(Employee::city_r());");
    println!("by_city.iter()");
    println!("    .filter(|(_, emps)| emps.len() > 1)  // HAVING equivalent");
    println!("    .map(|(city, emps)| {{");
    println!("        let avg = Query::new(emps).avg(Employee::salary_r());");
    println!("        (city, emps.len(), avg)");
    println!("    }})");

    // ============================================================================
    // EXAMPLE 12: Complex query with multiple operations
    // ============================================================================
    print_separator("Example 12: Complex multi-operation query");
    print_query(
        "SELECT name, salary, age\n\
         FROM employees\n\
         WHERE department IN ('Engineering', 'Sales')\n\
         AND salary BETWEEN 80000 AND 100000\n\
         AND age >= 30\n\
         ORDER BY salary DESC;",
        "Experienced mid-to-senior level employees in core departments"
    );

    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)
        .where_(Employee::age_r(), |&age| age >= 30)
        .order_by_float_desc(Employee::salary_r());

    for emp in &complex_query {
        println!("  {}: Age {}, {} dept, ${:.2}", emp.name, emp.age, emp.department, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\" || dept == \"Sales\")");
    println!("    .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)");
    println!("    .where_(Employee::age_r(), |&age| age >= 30)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("✓ Found {} employees", complex_query.len());

    // ============================================================================
    // EXAMPLE 13: Three-table JOIN
    // ============================================================================
    print_separator("Example 13: Three-table JOIN");
    print_query(
        "SELECT p.name as project, d.name as department, d.location\n\
         FROM projects p\n\
         INNER JOIN departments d ON p.department_id = d.id;",
        "Projects with their department details"
    );

    let proj_dept = JoinQuery::new(&projects, &departments).inner_join(
        Project::department_id_r(),
        Department::id_r(),
        |proj, dept| {
            (proj.name.clone(), dept.name.clone(), dept.location.clone(), proj.budget)
        },
    );

    for (proj_name, dept_name, location, budget) in &proj_dept {
        println!("  {}: {} dept in {} (${:.0})", proj_name, dept_name, location, budget);
    }

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&projects, &departments).inner_join(");
    println!("    Project::department_id_r(),");
    println!("    Department::id_r(),");
    println!("    |proj, dept| (proj.name, dept.name, dept.location, proj.budget)");
    println!(")");

    // ============================================================================
    // EXAMPLE 14: Subquery equivalent (using intermediate results)
    // ============================================================================
    print_separator("Example 14: Subquery equivalent");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > (SELECT AVG(salary) FROM employees);",
        "Employees earning above average"
    );

    let avg_salary = Query::new(&employees)
        .avg(Employee::salary_r())
        .unwrap_or(0.0);

    let above_avg_query = Query::new(&employees)
        .where_(Employee::salary_r(), move |&sal| sal > avg_salary);
    let above_avg = above_avg_query.all();

    println!("  Average salary: ${:.2}", avg_salary);
    for emp in &above_avg {
        println!("  {}: ${:.2} ({:.1}% above average)", 
            emp.name, emp.salary, ((emp.salary - avg_salary) / avg_salary * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let avg = Query::new(&employees).avg(Employee::salary_r()).unwrap_or(0.0);");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&sal| sal > avg)");
    println!("    .all()");
    println!("✓ Found {} employees above average", above_avg.len());

    // ============================================================================
    // EXAMPLE 15: Advanced aggregation (revenue calculation)
    // ============================================================================
    print_separator("Example 15: Advanced aggregation");
    print_query(
        "SELECT \n\
         d.name,\n\
         d.budget as dept_budget,\n\
         SUM(p.budget) as total_project_budget,\n\
         (d.budget - SUM(p.budget)) as remaining_budget\n\
         FROM departments d\n\
         LEFT JOIN projects p ON d.id = p.department_id\n\
         GROUP BY d.name, d.budget;",
        "Department budget utilization"
    );

    // Join departments with projects
    let dept_projects = JoinQuery::new(&departments, &projects).left_join(
        Department::id_r(),
        Project::department_id_r(),
        |dept, proj| (dept.clone(), proj.map(|p| p.clone())),
    );

    // Aggregate by department
    let mut dept_budget_map: HashMap<String, (f64, Vec<f64>)> = HashMap::new();
    for (dept, proj) in dept_projects {
        let entry = dept_budget_map
            .entry(dept.name.clone())
            .or_insert((dept.budget, Vec::new()));
        if let Some(p) = proj {
            entry.1.push(p.budget);
        }
    }

    for (dept_name, (total_budget, project_budgets)) in dept_budget_map.iter() {
        let used: f64 = project_budgets.iter().sum();
        let remaining = total_budget - used;
        println!("  {}: Budget ${:.0}, Used ${:.0}, Remaining ${:.0} ({:.1}% utilized)",
            dept_name, total_budget, used, remaining, (used / total_budget * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let dept_projects = JoinQuery::new(&departments, &projects)");
    println!("    .left_join(Department::id_r(), Project::department_id_r(), ...)");
    println!("// Then aggregate using HashMap");

    // ============================================================================
    // Summary
    // ============================================================================
    print_separator("Summary");
    println!("\n✓ All 15 SQL queries successfully replicated with Rust Query Builder!");
    println!("\nDemonstrated equivalents for:");
    println!("  • SELECT with WHERE");
    println!("  • Projection (SELECT specific columns)");
    println!("  • Aggregations (COUNT, SUM, AVG, MIN, MAX)");
    println!("  • GROUP BY");
    println!("  • ORDER BY");
    println!("  • LIMIT and OFFSET");
    println!("  • INNER JOIN and LEFT JOIN");
    println!("  • Complex conditions (AND, OR, BETWEEN)");
    println!("  • Subqueries");
    println!("  • Multi-table operations");
    println!("\n🎯 Type-safe, compile-time checked, and zero runtime overhead!");
    println!();
}

pub fn avg(&self, path: KeyPaths<T, f64>) -> Option<f64>

Computes the average of a float field.

Arguments

• path - The key-path to the f64 field

Example

let avg_price = query.avg(Product::price_r()).unwrap_or(0.0);

Examples found in repository

examples/doc_examples.rs (line 103)

fn main() {
    println!("Testing documentation examples...\n");

    // Example from README - Quick Start
    println!("Test 1: README Quick Start Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let affordable_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price < 100.0);
        let affordable_electronics = affordable_query.all();

        println!("  Found {} affordable electronics ✅", affordable_electronics.len());
    }

    // Example from README - Filtering
    println!("\nTest 2: Filtering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");
        let electronics = electronics_query.all();

        println!("  Found {} electronics ✅", electronics.len());
    }

    // Example from README - Selecting
    println!("\nTest 3: Selecting Fields Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let names: Vec<String> = Query::new(&products)
            .select(Product::name_r());

        println!("  Selected {} names ✅", names.len());
    }

    // Example from README - Ordering
    println!("\nTest 4: Ordering Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let by_price = Query::new(&products).order_by_float(Product::price_r());
        println!("  Ordered {} products ✅", by_price.len());
    }

    // Example from README - Aggregations
    println!("\nTest 5: Aggregations Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
        ];

        let electronics_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics");

        let count = electronics_query.count();
        let total_value: f64 = electronics_query.sum(Product::price_r());
        let avg_price = electronics_query.avg(Product::price_r()).unwrap_or(0.0);

        println!("  Count: {}, Total: ${:.2}, Avg: ${:.2} ✅", count, total_value, avg_price);
    }

    // Example from README - Grouping
    println!("\nTest 6: Grouping Example");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
            Product { id: 2, name: "Mouse".to_string(), price: 29.99, category: "Electronics".to_string(), stock: 50, rating: 4.0 },
            Product { id: 3, name: "Desk".to_string(), price: 299.99, category: "Furniture".to_string(), stock: 10, rating: 4.8 },
        ];

        let by_category = Query::new(&products).group_by(Product::category_r());
        println!("  Grouped into {} categories ✅", by_category.len());
    }

    // Example from README - Pagination
    println!("\nTest 7: Pagination Example");
    {
        let products = vec![
            Product { id: 1, name: "P1".to_string(), price: 10.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 2, name: "P2".to_string(), price: 20.0, category: "A".to_string(), stock: 1, rating: 4.0 },
            Product { id: 3, name: "P3".to_string(), price: 30.0, category: "A".to_string(), stock: 1, rating: 4.0 },
        ];

        let query = Query::new(&products);
        let first_10 = query.limit(10);
        let page_1 = query.skip(0).limit(10);

        println!("  Limited to {} products ✅", first_10.len());
        println!("  Page 1 has {} products ✅", page_1.len());
    }

    // Example from README - Join
    println!("\nTest 8: Join Example");
    {
        let users = vec![
            User { id: 1, name: "Alice".to_string() },
            User { id: 2, name: "Bob".to_string() },
        ];

        let orders = vec![
            Order { id: 101, user_id: 1, total: 99.99 },
            Order { id: 102, user_id: 1, total: 149.99 },
        ];

        let user_orders = JoinQuery::new(&users, &orders).inner_join(
            User::id_r(),
            Order::user_id_r(),
            |user, order| (user.name.clone(), order.total),
        );

        println!("  Joined {} user-order pairs ✅", user_orders.len());
    }

    // Example from SQL_COMPARISON - SELECT with WHERE
    println!("\nTest 9: SQL Comparison - SELECT with WHERE");
    {
        #[derive(Clone, Keypaths)]
        struct Employee {
            department: String,
        }

        let employees = vec![
            Employee { department: "Engineering".to_string() },
            Employee { department: "Sales".to_string() },
        ];

        let engineering_query = Query::new(&employees)
            .where_(Employee::department_r(), |dept| dept == "Engineering");
        let engineering = engineering_query.all();

        println!("  Found {} engineering employees ✅", engineering.len());
    }

    // Example from USAGE.md - Complex Filtering
    println!("\nTest 10: USAGE - Complex Filtering");
    {
        let products = vec![
            Product { id: 1, name: "Laptop".to_string(), price: 999.99, category: "Electronics".to_string(), stock: 15, rating: 4.5 },
        ];

        let results_query = Query::new(&products)
            .where_(Product::category_r(), |cat| cat == "Electronics")
            .where_(Product::price_r(), |&price| price >= 100.0 && price <= 500.0)
            .where_(Product::stock_r(), |&stock| stock > 10);
        let results = results_query.order_by_float(Product::price_r());

        println!("  Filtered {} products ✅", results.len());
    }

    println!("\n✅ All documentation examples compile and run successfully!");
}

examples/advanced_query_builder.rs (line 155)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_verification.rs (line 177)

fn main() {
    let employees = create_test_data();
    
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  SQL Equivalence Verification Tests                           ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // TEST 1: ORDER BY maintains exact SQL ordering (DESC)
    println!("Test 1: ORDER BY DESC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC;");
    
    let ordered = Query::new(&employees).order_by_float_desc(Employee::salary_r());
    let expected_order = vec![105000.0, 95000.0, 87000.0, 82000.0, 75000.0, 71000.0];
    let actual_order: Vec<f64> = ordered.iter().map(|e| e.salary).collect();
    
    let test1_pass = expected_order == actual_order;
    print_test("ORDER BY salary DESC produces correct order", test1_pass);
    if !test1_pass {
        println!("  Expected: {:?}", expected_order);
        println!("  Got: {:?}", actual_order);
    }

    // TEST 2: ORDER BY maintains exact SQL ordering (ASC)
    println!("\nTest 2: ORDER BY ASC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary ASC;");
    
    let ordered_asc = Query::new(&employees).order_by_float(Employee::salary_r());
    let expected_asc = vec![71000.0, 75000.0, 82000.0, 87000.0, 95000.0, 105000.0];
    let actual_asc: Vec<f64> = ordered_asc.iter().map(|e| e.salary).collect();
    
    let test2_pass = expected_asc == actual_asc;
    print_test("ORDER BY salary ASC produces correct order", test2_pass);
    if !test2_pass {
        println!("  Expected: {:?}", expected_asc);
        println!("  Got: {:?}", actual_asc);
    }

    // TEST 3: String ordering (alphabetical)
    println!("\nTest 3: ORDER BY name (alphabetical)");
    println!("SQL: SELECT name FROM employees ORDER BY name;");
    
    let ordered_names = Query::new(&employees).order_by(Employee::name_r());
    let expected_names = vec!["Alice Cooper", "Alice Johnson", "Bob Smith", "Carol White", "David Brown", "Eve Davis"];
    let actual_names: Vec<&str> = ordered_names.iter().map(|e| e.name.as_str()).collect();
    
    let test3_pass = expected_names == actual_names;
    print_test("ORDER BY name produces correct alphabetical order", test3_pass);
    if !test3_pass {
        println!("  Expected: {:?}", expected_names);
        println!("  Got: {:?}", actual_names);
    }

    // TEST 4: LIKE equivalent - starts with
    println!("\nTest 4: LIKE 'Alice%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE 'Alice%';");
    
    let like_alice_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.starts_with("Alice"));
    let like_alice = like_alice_query.all();
    
    let test4_pass = like_alice.len() == 2 
        && like_alice.iter().all(|e| e.name.starts_with("Alice"));
    print_test("LIKE 'Alice%' (starts_with) works correctly", test4_pass);
    if test4_pass {
        for emp in &like_alice {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 5: LIKE equivalent - ends with
    println!("\nTest 5: LIKE '%son' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%son';");
    
    let like_son_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.ends_with("son"));
    let like_son = like_son_query.all();
    
    let test5_pass = like_son.len() == 1 && like_son[0].name == "Alice Johnson";
    print_test("LIKE '%son' (ends_with) works correctly", test5_pass);
    if test5_pass {
        for emp in &like_son {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 6: LIKE equivalent - contains
    println!("\nTest 6: LIKE '%mit%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%mit%';");
    
    let like_mit_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.contains("mit"));
    let like_mit = like_mit_query.all();
    
    let test6_pass = like_mit.len() == 1 && like_mit[0].name == "Bob Smith";
    print_test("LIKE '%mit%' (contains) works correctly", test6_pass);
    if test6_pass {
        for emp in &like_mit {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 7: IN clause equivalent
    println!("\nTest 7: IN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE department IN ('Engineering', 'Sales');");
    
    let in_depts_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales");
    let in_depts = in_depts_query.all();
    
    let test7_pass = in_depts.len() == 5 // 3 Engineering + 2 Sales
        && in_depts.iter().all(|e| e.department == "Engineering" || e.department == "Sales");
    print_test("IN clause works correctly", test7_pass);
    println!("  Found {} employees in Engineering or Sales", in_depts.len());

    // TEST 8: BETWEEN equivalent
    println!("\nTest 8: BETWEEN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE salary BETWEEN 75000 AND 90000;");
    
    let between_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal >= 75000.0 && sal <= 90000.0);
    let between = between_query.all();
    
    let test8_pass = between.len() == 3;
    print_test("BETWEEN clause works correctly", test8_pass);
    println!("  Found {} employees with salary between 75K-90K", between.len());

    // TEST 9: COUNT with WHERE
    println!("\nTest 9: COUNT with WHERE");
    println!("SQL: SELECT COUNT(*) FROM employees WHERE department = 'Engineering';");
    
    let count_eng = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .count();
    
    let test9_pass = count_eng == 3;
    print_test("COUNT with WHERE produces correct result", test9_pass);
    println!("  Count: {} (expected 3)", count_eng);

    // TEST 10: AVG produces exact result
    println!("\nTest 10: AVG aggregation accuracy");
    println!("SQL: SELECT AVG(salary) FROM employees WHERE department = 'Engineering';");
    
    let avg_sal = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .avg(Employee::salary_r())
        .unwrap_or(0.0);
    
    let expected_avg = (95000.0 + 87000.0 + 105000.0) / 3.0;
    let test10_pass = (avg_sal - expected_avg).abs() < 0.01;
    print_test("AVG produces mathematically correct result", test10_pass);
    println!("  Average: ${:.2} (expected ${:.2})", avg_sal, expected_avg);

    // TEST 11: MIN and MAX
    println!("\nTest 11: MIN and MAX aggregations");
    println!("SQL: SELECT MIN(salary), MAX(salary) FROM employees;");
    
    let min_sal = Query::new(&employees).min_float(Employee::salary_r()).unwrap_or(0.0);
    let max_sal = Query::new(&employees).max_float(Employee::salary_r()).unwrap_or(0.0);
    
    let test11_pass = min_sal == 71000.0 && max_sal == 105000.0;
    print_test("MIN and MAX produce correct results", test11_pass);
    println!("  MIN: ${:.2}, MAX: ${:.2}", min_sal, max_sal);

    // TEST 12: Complex WHERE with AND/OR
    println!("\nTest 12: Complex WHERE (AND + OR)");
    println!("SQL: SELECT * FROM employees WHERE (department = 'Engineering' OR department = 'Sales') AND salary > 80000;");
    
    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal > 80000.0);
    let complex = complex_query.all();
    
    let test12_pass = complex.len() == 4; // Alice J ($95k), Bob ($87k), David ($82k), Alice C ($105k)
    print_test("Complex WHERE clause works correctly", test12_pass);
    println!("  Found {} employees", complex.len());

    // TEST 13: Case-sensitive string comparison (SQL default)
    println!("\nTest 13: Case-sensitive comparison (like SQL)");
    println!("SQL: SELECT * FROM employees WHERE department = 'engineering'; -- should find 0");
    
    let case_sensitive = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "engineering") // lowercase
        .count();
    
    let test13_pass = case_sensitive == 0;
    print_test("Case-sensitive comparison (SQL default)", test13_pass);
    println!("  Found {} with lowercase 'engineering' (expected 0)", case_sensitive);

    // TEST 14: Case-insensitive LIKE equivalent
    println!("\nTest 14: Case-insensitive LIKE (ILIKE equivalent)");
    println!("SQL: SELECT * FROM employees WHERE LOWER(name) LIKE '%alice%';");
    
    let ilike_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.to_lowercase().contains("alice"));
    let ilike = ilike_query.all();
    
    let test14_pass = ilike.len() == 2;
    print_test("Case-insensitive LIKE works correctly", test14_pass);
    println!("  Found {} employees with 'alice' (case-insensitive)", ilike.len());

    // TEST 15: LIMIT produces exact subset
    println!("\nTest 15: LIMIT clause");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC LIMIT 3;");
    
    let limited = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r())
        .into_iter()
        .take(3)
        .collect::<Vec<_>>();
    
    let test15_pass = limited.len() == 3 
        && limited[0].salary == 105000.0
        && limited[1].salary == 95000.0
        && limited[2].salary == 87000.0;
    print_test("LIMIT returns correct top-N results", test15_pass);
    println!("  Top 3 salaries: ${:.0}, ${:.0}, ${:.0}", 
        limited[0].salary, limited[1].salary, limited[2].salary);

    // TEST 16: GROUP BY produces correct groups
    println!("\nTest 16: GROUP BY");
    println!("SQL: SELECT department, COUNT(*) FROM employees GROUP BY department;");
    
    let grouped = Query::new(&employees).group_by(Employee::department_r());
    let eng_count = grouped.get("Engineering").map(|v| v.len()).unwrap_or(0);
    let sales_count = grouped.get("Sales").map(|v| v.len()).unwrap_or(0);
    let marketing_count = grouped.get("Marketing").map(|v| v.len()).unwrap_or(0);
    
    let test16_pass = eng_count == 3 && sales_count == 2 && marketing_count == 1;
    print_test("GROUP BY produces correct counts", test16_pass);
    println!("  Engineering: {}, Sales: {}, Marketing: {}", eng_count, sales_count, marketing_count);

    // TEST 17: Email pattern matching (regex-like)
    println!("\nTest 17: Email domain filtering (LIKE '%@example.com')");
    println!("SQL: SELECT * FROM employees WHERE email LIKE '%@example.com';");
    
    let example_emails = Query::new(&employees)
        .where_(Employee::email_r(), |email| email.ends_with("@example.com"))
        .count();
    
    let test17_pass = example_emails == 6; // All employees have @example.com emails
    print_test("Email pattern matching works correctly", test17_pass);
    println!("  Found {} employees with @example.com emails", example_emails);

    // Summary
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Test Summary                                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");
    
    let tests = vec![
        ("ORDER BY DESC", test1_pass),
        ("ORDER BY ASC", test2_pass),
        ("ORDER BY name", test3_pass),
        ("LIKE 'prefix%'", test4_pass),
        ("LIKE '%suffix'", test5_pass),
        ("LIKE '%contains%'", test6_pass),
        ("IN clause", test7_pass),
        ("BETWEEN clause", test8_pass),
        ("COUNT", test9_pass),
        ("AVG accuracy", test10_pass),
        ("MIN/MAX", test11_pass),
        ("Complex WHERE", test12_pass),
        ("Case-sensitive", test13_pass),
        ("Case-insensitive", test14_pass),
        ("LIMIT", test15_pass),
        ("GROUP BY", test16_pass),
        ("Email patterns", test17_pass),
    ];
    
    let passed = tests.iter().filter(|(_, p)| *p).count();
    let total = tests.len();
    
    println!("Results: {}/{} tests passed", passed, total);
    
    if passed == total {
        println!("\n🎉 All tests PASSED! Rust Query Builder produces exact SQL-equivalent results!");
        println!("\n✅ Verified:");
        println!("  • Exact ordering (ASC/DESC)");
        println!("  • LIKE operations (starts_with, ends_with, contains)");
        println!("  • IN clause (OR conditions)");
        println!("  • BETWEEN clause");
        println!("  • Aggregations (COUNT, AVG, MIN, MAX)");
        println!("  • Complex WHERE conditions");
        println!("  • Case sensitivity");
        println!("  • LIMIT clause");
        println!("  • GROUP BY");
        println!("  • Pattern matching");
    } else {
        println!("\n⚠️  {} test(s) failed. See details above.", total - passed);
    }
}

examples/sql_comparison.rs (line 176)

fn main() {
    let employees = create_employees();
    let departments = create_departments();
    let projects = create_projects();

    println!("\n╔════════════════════════════════════════════════════════════════════════╗");
    println!("║     SQL vs Rust Query Builder Comparison                              ║");
    println!("║     Demonstrating equivalent operations                               ║");
    println!("╚════════════════════════════════════════════════════════════════════════╝");

    // ============================================================================
    // EXAMPLE 1: Simple SELECT with WHERE
    // ============================================================================
    print_separator("Example 1: SELECT with WHERE clause");
    print_query(
        "SELECT * FROM employees WHERE department = 'Engineering';",
        "Filter employees by department"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering_employees = eng_query.all();

    for emp in &engineering_employees {
        println!("  ID: {}, Name: {}, Salary: ${:.2}", emp.id, emp.name, emp.salary);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\")");
    println!("    .all()");
    println!("✓ Found {} employees", engineering_employees.len());

    // ============================================================================
    // EXAMPLE 2: SELECT specific columns
    // ============================================================================
    print_separator("Example 2: SELECT specific columns (Projection)");
    print_query(
        "SELECT name FROM employees WHERE salary > 80000;",
        "Get names of high-earning employees"
    );

    let high_earners = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 80000.0)
        .select(Employee::name_r());

    for name in &high_earners {
        println!("  {}", name);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 80000.0)");
    println!("    .select(Employee::name_r())");
    println!("✓ Found {} employees", high_earners.len());

    // ============================================================================
    // EXAMPLE 3: COUNT
    // ============================================================================
    print_separator("Example 3: COUNT aggregation");
    print_query(
        "SELECT COUNT(*) FROM employees WHERE age < 30;",
        "Count young employees"
    );

    let young_count = Query::new(&employees)
        .where_(Employee::age_r(), |&age| age < 30)
        .count();

    println!("  Count: {}", young_count);
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::age_r(), |&age| age < 30)");
    println!("    .count()");
    println!("✓ Result: {}", young_count);

    // ============================================================================
    // EXAMPLE 4: SUM, AVG, MIN, MAX
    // ============================================================================
    print_separator("Example 4: Aggregate functions (SUM, AVG, MIN, MAX)");
    print_query(
        "SELECT \n\
         SUM(salary) as total_salary,\n\
         AVG(salary) as avg_salary,\n\
         MIN(salary) as min_salary,\n\
         MAX(salary) as max_salary\n\
         FROM employees WHERE department = 'Engineering';",
        "Engineering department salary statistics"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");

    let total = eng_query.sum(Employee::salary_r());
    let avg = eng_query.avg(Employee::salary_r()).unwrap_or(0.0);
    let min = eng_query.min_float(Employee::salary_r()).unwrap_or(0.0);
    let max = eng_query.max_float(Employee::salary_r()).unwrap_or(0.0);

    println!("  Total Salary: ${:.2}", total);
    println!("  Avg Salary:   ${:.2}", avg);
    println!("  Min Salary:   ${:.2}", min);
    println!("  Max Salary:   ${:.2}", max);

    println!("\nRust Query Builder:");
    println!("let query = Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\");");
    println!("query.sum(Employee::salary_r())  // ${:.2}", total);
    println!("query.avg(Employee::salary_r())  // ${:.2}", avg);
    println!("query.min_float(Employee::salary_r())  // ${:.2}", min);
    println!("query.max_float(Employee::salary_r())  // ${:.2}", max);

    // ============================================================================
    // EXAMPLE 5: GROUP BY with aggregation
    // ============================================================================
    print_separator("Example 5: GROUP BY with aggregation");
    print_query(
        "SELECT \n\
         department,\n\
         COUNT(*) as emp_count,\n\
         AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY department;",
        "Statistics by department"
    );

    let by_dept = Query::new(&employees).group_by(Employee::department_r());

    for (dept, emps) in &by_dept {
        let dept_query = Query::new(emps);
        let count = emps.len();
        let avg_sal = dept_query.avg(Employee::salary_r()).unwrap_or(0.0);
        println!("  {}: {} employees, avg salary ${:.2}", dept, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_dept = Query::new(&employees).group_by(Employee::department_r());");
    println!("for (dept, emps) in &by_dept {{");
    println!("    let dept_query = Query::new(emps);");
    println!("    dept_query.avg(Employee::salary_r())");
    println!("}}");

    // ============================================================================
    // EXAMPLE 6: ORDER BY
    // ============================================================================
    print_separator("Example 6: ORDER BY");
    print_query(
        "SELECT name, salary FROM employees\n\
         WHERE department = 'Sales'\n\
         ORDER BY salary DESC;",
        "Sales employees ordered by salary (descending)"
    );

    let sales_sorted = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .order_by_float_desc(Employee::salary_r());

    for emp in &sales_sorted {
        println!("  {}: ${:.2}", emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Sales\")");
    println!("    .order_by_float_desc(Employee::salary_r())");

    // ============================================================================
    // EXAMPLE 7: Multiple WHERE conditions (AND)
    // ============================================================================
    print_separator("Example 7: Multiple WHERE conditions (AND)");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > 70000 AND age < 35;",
        "High-earning young employees"
    );

    let filter_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 70000.0)
        .where_(Employee::age_r(), |&age| age < 35);
    let filtered = filter_query.all();

    for emp in &filtered {
        println!("  {}: Age {}, Salary ${:.2}", emp.name, emp.age, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 70000.0)");
    println!("    .where_(Employee::age_r(), |&age| age < 35)");
    println!("    .all()");
    println!("✓ Found {} employees", filtered.len());

    // ============================================================================
    // EXAMPLE 8: LIMIT (TOP N)
    // ============================================================================
    print_separator("Example 8: LIMIT / TOP N");
    print_query(
        "SELECT TOP 3 name, salary FROM employees\n\
         ORDER BY salary DESC;",
        "Top 3 highest paid employees"
    );

    let top_earners = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r());

    for (i, emp) in top_earners.iter().take(3).enumerate() {
        println!("  {}. {}: ${:.2}", i + 1, emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("    .into_iter().take(3)");

    // ============================================================================
    // EXAMPLE 9: OFFSET and LIMIT (Pagination)
    // ============================================================================
    print_separator("Example 9: OFFSET and LIMIT (Pagination)");
    print_query(
        "SELECT name FROM employees\n\
         ORDER BY name\n\
         LIMIT 3 OFFSET 3;",
        "Page 2 of employee names (3 per page)"
    );

    let page_2 = Query::new(&employees)
        .order_by(Employee::name_r())
        .into_iter()
        .skip(3)
        .take(3)
        .collect::<Vec<_>>();

    for emp in &page_2 {
        println!("  {}", emp.name);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by(Employee::name_r())");
    println!("    .into_iter().skip(3).take(3)");

    // ============================================================================
    // EXAMPLE 10: INNER JOIN
    // ============================================================================
    print_separator("Example 10: INNER JOIN");
    print_query(
        "SELECT e.name, d.name as dept_name, d.budget\n\
         FROM employees e\n\
         INNER JOIN departments d ON e.department = d.name;",
        "Employees with their department info"
    );

    let emp_dept = JoinQuery::new(&employees, &departments).inner_join(
        Employee::department_r(),
        Department::name_r(),
        |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget),
    );

    for (emp_name, dept_name, budget) in emp_dept.iter().take(5) {
        println!("  {} works in {} (Budget: ${:.0})", emp_name, dept_name, budget);
    }
    println!("  ... (showing first 5)");

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&employees, &departments).inner_join(");
    println!("    Employee::department_r(),");
    println!("    Department::name_r(),");
    println!("    |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget)");
    println!(")");
    println!("✓ Found {} matches", emp_dept.len());

    // ============================================================================
    // EXAMPLE 11: GROUP BY with HAVING equivalent
    // ============================================================================
    print_separator("Example 11: GROUP BY with filtering (HAVING equivalent)");
    print_query(
        "SELECT city, COUNT(*) as emp_count, AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY city\n\
         HAVING COUNT(*) > 1;",
        "Cities with multiple employees"
    );

    let by_city = Query::new(&employees).group_by(Employee::city_r());
    let mut city_stats: Vec<_> = by_city
        .iter()
        .filter(|(_, emps)| emps.len() > 1) // HAVING equivalent
        .map(|(city, emps)| {
            let avg_sal = Query::new(emps).avg(Employee::salary_r()).unwrap_or(0.0);
            (city.clone(), emps.len(), avg_sal)
        })
        .collect();
    
    city_stats.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count

    for (city, count, avg_sal) in &city_stats {
        println!("  {}: {} employees, avg salary ${:.2}", city, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_city = Query::new(&employees).group_by(Employee::city_r());");
    println!("by_city.iter()");
    println!("    .filter(|(_, emps)| emps.len() > 1)  // HAVING equivalent");
    println!("    .map(|(city, emps)| {{");
    println!("        let avg = Query::new(emps).avg(Employee::salary_r());");
    println!("        (city, emps.len(), avg)");
    println!("    }})");

    // ============================================================================
    // EXAMPLE 12: Complex query with multiple operations
    // ============================================================================
    print_separator("Example 12: Complex multi-operation query");
    print_query(
        "SELECT name, salary, age\n\
         FROM employees\n\
         WHERE department IN ('Engineering', 'Sales')\n\
         AND salary BETWEEN 80000 AND 100000\n\
         AND age >= 30\n\
         ORDER BY salary DESC;",
        "Experienced mid-to-senior level employees in core departments"
    );

    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)
        .where_(Employee::age_r(), |&age| age >= 30)
        .order_by_float_desc(Employee::salary_r());

    for emp in &complex_query {
        println!("  {}: Age {}, {} dept, ${:.2}", emp.name, emp.age, emp.department, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\" || dept == \"Sales\")");
    println!("    .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)");
    println!("    .where_(Employee::age_r(), |&age| age >= 30)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("✓ Found {} employees", complex_query.len());

    // ============================================================================
    // EXAMPLE 13: Three-table JOIN
    // ============================================================================
    print_separator("Example 13: Three-table JOIN");
    print_query(
        "SELECT p.name as project, d.name as department, d.location\n\
         FROM projects p\n\
         INNER JOIN departments d ON p.department_id = d.id;",
        "Projects with their department details"
    );

    let proj_dept = JoinQuery::new(&projects, &departments).inner_join(
        Project::department_id_r(),
        Department::id_r(),
        |proj, dept| {
            (proj.name.clone(), dept.name.clone(), dept.location.clone(), proj.budget)
        },
    );

    for (proj_name, dept_name, location, budget) in &proj_dept {
        println!("  {}: {} dept in {} (${:.0})", proj_name, dept_name, location, budget);
    }

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&projects, &departments).inner_join(");
    println!("    Project::department_id_r(),");
    println!("    Department::id_r(),");
    println!("    |proj, dept| (proj.name, dept.name, dept.location, proj.budget)");
    println!(")");

    // ============================================================================
    // EXAMPLE 14: Subquery equivalent (using intermediate results)
    // ============================================================================
    print_separator("Example 14: Subquery equivalent");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > (SELECT AVG(salary) FROM employees);",
        "Employees earning above average"
    );

    let avg_salary = Query::new(&employees)
        .avg(Employee::salary_r())
        .unwrap_or(0.0);

    let above_avg_query = Query::new(&employees)
        .where_(Employee::salary_r(), move |&sal| sal > avg_salary);
    let above_avg = above_avg_query.all();

    println!("  Average salary: ${:.2}", avg_salary);
    for emp in &above_avg {
        println!("  {}: ${:.2} ({:.1}% above average)", 
            emp.name, emp.salary, ((emp.salary - avg_salary) / avg_salary * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let avg = Query::new(&employees).avg(Employee::salary_r()).unwrap_or(0.0);");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&sal| sal > avg)");
    println!("    .all()");
    println!("✓ Found {} employees above average", above_avg.len());

    // ============================================================================
    // EXAMPLE 15: Advanced aggregation (revenue calculation)
    // ============================================================================
    print_separator("Example 15: Advanced aggregation");
    print_query(
        "SELECT \n\
         d.name,\n\
         d.budget as dept_budget,\n\
         SUM(p.budget) as total_project_budget,\n\
         (d.budget - SUM(p.budget)) as remaining_budget\n\
         FROM departments d\n\
         LEFT JOIN projects p ON d.id = p.department_id\n\
         GROUP BY d.name, d.budget;",
        "Department budget utilization"
    );

    // Join departments with projects
    let dept_projects = JoinQuery::new(&departments, &projects).left_join(
        Department::id_r(),
        Project::department_id_r(),
        |dept, proj| (dept.clone(), proj.map(|p| p.clone())),
    );

    // Aggregate by department
    let mut dept_budget_map: HashMap<String, (f64, Vec<f64>)> = HashMap::new();
    for (dept, proj) in dept_projects {
        let entry = dept_budget_map
            .entry(dept.name.clone())
            .or_insert((dept.budget, Vec::new()));
        if let Some(p) = proj {
            entry.1.push(p.budget);
        }
    }

    for (dept_name, (total_budget, project_budgets)) in dept_budget_map.iter() {
        let used: f64 = project_budgets.iter().sum();
        let remaining = total_budget - used;
        println!("  {}: Budget ${:.0}, Used ${:.0}, Remaining ${:.0} ({:.1}% utilized)",
            dept_name, total_budget, used, remaining, (used / total_budget * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let dept_projects = JoinQuery::new(&departments, &projects)");
    println!("    .left_join(Department::id_r(), Project::department_id_r(), ...)");
    println!("// Then aggregate using HashMap");

    // ============================================================================
    // Summary
    // ============================================================================
    print_separator("Summary");
    println!("\n✓ All 15 SQL queries successfully replicated with Rust Query Builder!");
    println!("\nDemonstrated equivalents for:");
    println!("  • SELECT with WHERE");
    println!("  • Projection (SELECT specific columns)");
    println!("  • Aggregations (COUNT, SUM, AVG, MIN, MAX)");
    println!("  • GROUP BY");
    println!("  • ORDER BY");
    println!("  • LIMIT and OFFSET");
    println!("  • INNER JOIN and LEFT JOIN");
    println!("  • Complex conditions (AND, OR, BETWEEN)");
    println!("  • Subqueries");
    println!("  • Multi-table operations");
    println!("\n🎯 Type-safe, compile-time checked, and zero runtime overhead!");
    println!();
}

pub fn min<F>(&self, path: KeyPaths<T, F>) -> Option<F>

where F: Ord + Clone + 'static,

Finds the minimum value of a field.

Arguments

• path - The key-path to the field

Example

let min_stock = query.min(Product::stock_r());

pub fn max<F>(&self, path: KeyPaths<T, F>) -> Option<F>

where F: Ord + Clone + 'static,

Finds the maximum value of a field.

Arguments

• path - The key-path to the field

Example

let max_stock = query.max(Product::stock_r());

pub fn min_float(&self, path: KeyPaths<T, f64>) -> Option<f64>

Finds the minimum value of a float field.

Arguments

• path - The key-path to the f64 field

Example

let min_price = query.min_float(Product::price_r());

Examples found in repository

examples/advanced_query_builder.rs (line 156)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_verification.rs (line 189)

fn main() {
    let employees = create_test_data();
    
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  SQL Equivalence Verification Tests                           ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // TEST 1: ORDER BY maintains exact SQL ordering (DESC)
    println!("Test 1: ORDER BY DESC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC;");
    
    let ordered = Query::new(&employees).order_by_float_desc(Employee::salary_r());
    let expected_order = vec![105000.0, 95000.0, 87000.0, 82000.0, 75000.0, 71000.0];
    let actual_order: Vec<f64> = ordered.iter().map(|e| e.salary).collect();
    
    let test1_pass = expected_order == actual_order;
    print_test("ORDER BY salary DESC produces correct order", test1_pass);
    if !test1_pass {
        println!("  Expected: {:?}", expected_order);
        println!("  Got: {:?}", actual_order);
    }

    // TEST 2: ORDER BY maintains exact SQL ordering (ASC)
    println!("\nTest 2: ORDER BY ASC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary ASC;");
    
    let ordered_asc = Query::new(&employees).order_by_float(Employee::salary_r());
    let expected_asc = vec![71000.0, 75000.0, 82000.0, 87000.0, 95000.0, 105000.0];
    let actual_asc: Vec<f64> = ordered_asc.iter().map(|e| e.salary).collect();
    
    let test2_pass = expected_asc == actual_asc;
    print_test("ORDER BY salary ASC produces correct order", test2_pass);
    if !test2_pass {
        println!("  Expected: {:?}", expected_asc);
        println!("  Got: {:?}", actual_asc);
    }

    // TEST 3: String ordering (alphabetical)
    println!("\nTest 3: ORDER BY name (alphabetical)");
    println!("SQL: SELECT name FROM employees ORDER BY name;");
    
    let ordered_names = Query::new(&employees).order_by(Employee::name_r());
    let expected_names = vec!["Alice Cooper", "Alice Johnson", "Bob Smith", "Carol White", "David Brown", "Eve Davis"];
    let actual_names: Vec<&str> = ordered_names.iter().map(|e| e.name.as_str()).collect();
    
    let test3_pass = expected_names == actual_names;
    print_test("ORDER BY name produces correct alphabetical order", test3_pass);
    if !test3_pass {
        println!("  Expected: {:?}", expected_names);
        println!("  Got: {:?}", actual_names);
    }

    // TEST 4: LIKE equivalent - starts with
    println!("\nTest 4: LIKE 'Alice%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE 'Alice%';");
    
    let like_alice_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.starts_with("Alice"));
    let like_alice = like_alice_query.all();
    
    let test4_pass = like_alice.len() == 2 
        && like_alice.iter().all(|e| e.name.starts_with("Alice"));
    print_test("LIKE 'Alice%' (starts_with) works correctly", test4_pass);
    if test4_pass {
        for emp in &like_alice {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 5: LIKE equivalent - ends with
    println!("\nTest 5: LIKE '%son' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%son';");
    
    let like_son_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.ends_with("son"));
    let like_son = like_son_query.all();
    
    let test5_pass = like_son.len() == 1 && like_son[0].name == "Alice Johnson";
    print_test("LIKE '%son' (ends_with) works correctly", test5_pass);
    if test5_pass {
        for emp in &like_son {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 6: LIKE equivalent - contains
    println!("\nTest 6: LIKE '%mit%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%mit%';");
    
    let like_mit_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.contains("mit"));
    let like_mit = like_mit_query.all();
    
    let test6_pass = like_mit.len() == 1 && like_mit[0].name == "Bob Smith";
    print_test("LIKE '%mit%' (contains) works correctly", test6_pass);
    if test6_pass {
        for emp in &like_mit {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 7: IN clause equivalent
    println!("\nTest 7: IN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE department IN ('Engineering', 'Sales');");
    
    let in_depts_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales");
    let in_depts = in_depts_query.all();
    
    let test7_pass = in_depts.len() == 5 // 3 Engineering + 2 Sales
        && in_depts.iter().all(|e| e.department == "Engineering" || e.department == "Sales");
    print_test("IN clause works correctly", test7_pass);
    println!("  Found {} employees in Engineering or Sales", in_depts.len());

    // TEST 8: BETWEEN equivalent
    println!("\nTest 8: BETWEEN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE salary BETWEEN 75000 AND 90000;");
    
    let between_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal >= 75000.0 && sal <= 90000.0);
    let between = between_query.all();
    
    let test8_pass = between.len() == 3;
    print_test("BETWEEN clause works correctly", test8_pass);
    println!("  Found {} employees with salary between 75K-90K", between.len());

    // TEST 9: COUNT with WHERE
    println!("\nTest 9: COUNT with WHERE");
    println!("SQL: SELECT COUNT(*) FROM employees WHERE department = 'Engineering';");
    
    let count_eng = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .count();
    
    let test9_pass = count_eng == 3;
    print_test("COUNT with WHERE produces correct result", test9_pass);
    println!("  Count: {} (expected 3)", count_eng);

    // TEST 10: AVG produces exact result
    println!("\nTest 10: AVG aggregation accuracy");
    println!("SQL: SELECT AVG(salary) FROM employees WHERE department = 'Engineering';");
    
    let avg_sal = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .avg(Employee::salary_r())
        .unwrap_or(0.0);
    
    let expected_avg = (95000.0 + 87000.0 + 105000.0) / 3.0;
    let test10_pass = (avg_sal - expected_avg).abs() < 0.01;
    print_test("AVG produces mathematically correct result", test10_pass);
    println!("  Average: ${:.2} (expected ${:.2})", avg_sal, expected_avg);

    // TEST 11: MIN and MAX
    println!("\nTest 11: MIN and MAX aggregations");
    println!("SQL: SELECT MIN(salary), MAX(salary) FROM employees;");
    
    let min_sal = Query::new(&employees).min_float(Employee::salary_r()).unwrap_or(0.0);
    let max_sal = Query::new(&employees).max_float(Employee::salary_r()).unwrap_or(0.0);
    
    let test11_pass = min_sal == 71000.0 && max_sal == 105000.0;
    print_test("MIN and MAX produce correct results", test11_pass);
    println!("  MIN: ${:.2}, MAX: ${:.2}", min_sal, max_sal);

    // TEST 12: Complex WHERE with AND/OR
    println!("\nTest 12: Complex WHERE (AND + OR)");
    println!("SQL: SELECT * FROM employees WHERE (department = 'Engineering' OR department = 'Sales') AND salary > 80000;");
    
    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal > 80000.0);
    let complex = complex_query.all();
    
    let test12_pass = complex.len() == 4; // Alice J ($95k), Bob ($87k), David ($82k), Alice C ($105k)
    print_test("Complex WHERE clause works correctly", test12_pass);
    println!("  Found {} employees", complex.len());

    // TEST 13: Case-sensitive string comparison (SQL default)
    println!("\nTest 13: Case-sensitive comparison (like SQL)");
    println!("SQL: SELECT * FROM employees WHERE department = 'engineering'; -- should find 0");
    
    let case_sensitive = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "engineering") // lowercase
        .count();
    
    let test13_pass = case_sensitive == 0;
    print_test("Case-sensitive comparison (SQL default)", test13_pass);
    println!("  Found {} with lowercase 'engineering' (expected 0)", case_sensitive);

    // TEST 14: Case-insensitive LIKE equivalent
    println!("\nTest 14: Case-insensitive LIKE (ILIKE equivalent)");
    println!("SQL: SELECT * FROM employees WHERE LOWER(name) LIKE '%alice%';");
    
    let ilike_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.to_lowercase().contains("alice"));
    let ilike = ilike_query.all();
    
    let test14_pass = ilike.len() == 2;
    print_test("Case-insensitive LIKE works correctly", test14_pass);
    println!("  Found {} employees with 'alice' (case-insensitive)", ilike.len());

    // TEST 15: LIMIT produces exact subset
    println!("\nTest 15: LIMIT clause");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC LIMIT 3;");
    
    let limited = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r())
        .into_iter()
        .take(3)
        .collect::<Vec<_>>();
    
    let test15_pass = limited.len() == 3 
        && limited[0].salary == 105000.0
        && limited[1].salary == 95000.0
        && limited[2].salary == 87000.0;
    print_test("LIMIT returns correct top-N results", test15_pass);
    println!("  Top 3 salaries: ${:.0}, ${:.0}, ${:.0}", 
        limited[0].salary, limited[1].salary, limited[2].salary);

    // TEST 16: GROUP BY produces correct groups
    println!("\nTest 16: GROUP BY");
    println!("SQL: SELECT department, COUNT(*) FROM employees GROUP BY department;");
    
    let grouped = Query::new(&employees).group_by(Employee::department_r());
    let eng_count = grouped.get("Engineering").map(|v| v.len()).unwrap_or(0);
    let sales_count = grouped.get("Sales").map(|v| v.len()).unwrap_or(0);
    let marketing_count = grouped.get("Marketing").map(|v| v.len()).unwrap_or(0);
    
    let test16_pass = eng_count == 3 && sales_count == 2 && marketing_count == 1;
    print_test("GROUP BY produces correct counts", test16_pass);
    println!("  Engineering: {}, Sales: {}, Marketing: {}", eng_count, sales_count, marketing_count);

    // TEST 17: Email pattern matching (regex-like)
    println!("\nTest 17: Email domain filtering (LIKE '%@example.com')");
    println!("SQL: SELECT * FROM employees WHERE email LIKE '%@example.com';");
    
    let example_emails = Query::new(&employees)
        .where_(Employee::email_r(), |email| email.ends_with("@example.com"))
        .count();
    
    let test17_pass = example_emails == 6; // All employees have @example.com emails
    print_test("Email pattern matching works correctly", test17_pass);
    println!("  Found {} employees with @example.com emails", example_emails);

    // Summary
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Test Summary                                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");
    
    let tests = vec![
        ("ORDER BY DESC", test1_pass),
        ("ORDER BY ASC", test2_pass),
        ("ORDER BY name", test3_pass),
        ("LIKE 'prefix%'", test4_pass),
        ("LIKE '%suffix'", test5_pass),
        ("LIKE '%contains%'", test6_pass),
        ("IN clause", test7_pass),
        ("BETWEEN clause", test8_pass),
        ("COUNT", test9_pass),
        ("AVG accuracy", test10_pass),
        ("MIN/MAX", test11_pass),
        ("Complex WHERE", test12_pass),
        ("Case-sensitive", test13_pass),
        ("Case-insensitive", test14_pass),
        ("LIMIT", test15_pass),
        ("GROUP BY", test16_pass),
        ("Email patterns", test17_pass),
    ];
    
    let passed = tests.iter().filter(|(_, p)| *p).count();
    let total = tests.len();
    
    println!("Results: {}/{} tests passed", passed, total);
    
    if passed == total {
        println!("\n🎉 All tests PASSED! Rust Query Builder produces exact SQL-equivalent results!");
        println!("\n✅ Verified:");
        println!("  • Exact ordering (ASC/DESC)");
        println!("  • LIKE operations (starts_with, ends_with, contains)");
        println!("  • IN clause (OR conditions)");
        println!("  • BETWEEN clause");
        println!("  • Aggregations (COUNT, AVG, MIN, MAX)");
        println!("  • Complex WHERE conditions");
        println!("  • Case sensitivity");
        println!("  • LIMIT clause");
        println!("  • GROUP BY");
        println!("  • Pattern matching");
    } else {
        println!("\n⚠️  {} test(s) failed. See details above.", total - passed);
    }
}

examples/sql_comparison.rs (line 177)

fn main() {
    let employees = create_employees();
    let departments = create_departments();
    let projects = create_projects();

    println!("\n╔════════════════════════════════════════════════════════════════════════╗");
    println!("║     SQL vs Rust Query Builder Comparison                              ║");
    println!("║     Demonstrating equivalent operations                               ║");
    println!("╚════════════════════════════════════════════════════════════════════════╝");

    // ============================================================================
    // EXAMPLE 1: Simple SELECT with WHERE
    // ============================================================================
    print_separator("Example 1: SELECT with WHERE clause");
    print_query(
        "SELECT * FROM employees WHERE department = 'Engineering';",
        "Filter employees by department"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering_employees = eng_query.all();

    for emp in &engineering_employees {
        println!("  ID: {}, Name: {}, Salary: ${:.2}", emp.id, emp.name, emp.salary);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\")");
    println!("    .all()");
    println!("✓ Found {} employees", engineering_employees.len());

    // ============================================================================
    // EXAMPLE 2: SELECT specific columns
    // ============================================================================
    print_separator("Example 2: SELECT specific columns (Projection)");
    print_query(
        "SELECT name FROM employees WHERE salary > 80000;",
        "Get names of high-earning employees"
    );

    let high_earners = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 80000.0)
        .select(Employee::name_r());

    for name in &high_earners {
        println!("  {}", name);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 80000.0)");
    println!("    .select(Employee::name_r())");
    println!("✓ Found {} employees", high_earners.len());

    // ============================================================================
    // EXAMPLE 3: COUNT
    // ============================================================================
    print_separator("Example 3: COUNT aggregation");
    print_query(
        "SELECT COUNT(*) FROM employees WHERE age < 30;",
        "Count young employees"
    );

    let young_count = Query::new(&employees)
        .where_(Employee::age_r(), |&age| age < 30)
        .count();

    println!("  Count: {}", young_count);
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::age_r(), |&age| age < 30)");
    println!("    .count()");
    println!("✓ Result: {}", young_count);

    // ============================================================================
    // EXAMPLE 4: SUM, AVG, MIN, MAX
    // ============================================================================
    print_separator("Example 4: Aggregate functions (SUM, AVG, MIN, MAX)");
    print_query(
        "SELECT \n\
         SUM(salary) as total_salary,\n\
         AVG(salary) as avg_salary,\n\
         MIN(salary) as min_salary,\n\
         MAX(salary) as max_salary\n\
         FROM employees WHERE department = 'Engineering';",
        "Engineering department salary statistics"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");

    let total = eng_query.sum(Employee::salary_r());
    let avg = eng_query.avg(Employee::salary_r()).unwrap_or(0.0);
    let min = eng_query.min_float(Employee::salary_r()).unwrap_or(0.0);
    let max = eng_query.max_float(Employee::salary_r()).unwrap_or(0.0);

    println!("  Total Salary: ${:.2}", total);
    println!("  Avg Salary:   ${:.2}", avg);
    println!("  Min Salary:   ${:.2}", min);
    println!("  Max Salary:   ${:.2}", max);

    println!("\nRust Query Builder:");
    println!("let query = Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\");");
    println!("query.sum(Employee::salary_r())  // ${:.2}", total);
    println!("query.avg(Employee::salary_r())  // ${:.2}", avg);
    println!("query.min_float(Employee::salary_r())  // ${:.2}", min);
    println!("query.max_float(Employee::salary_r())  // ${:.2}", max);

    // ============================================================================
    // EXAMPLE 5: GROUP BY with aggregation
    // ============================================================================
    print_separator("Example 5: GROUP BY with aggregation");
    print_query(
        "SELECT \n\
         department,\n\
         COUNT(*) as emp_count,\n\
         AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY department;",
        "Statistics by department"
    );

    let by_dept = Query::new(&employees).group_by(Employee::department_r());

    for (dept, emps) in &by_dept {
        let dept_query = Query::new(emps);
        let count = emps.len();
        let avg_sal = dept_query.avg(Employee::salary_r()).unwrap_or(0.0);
        println!("  {}: {} employees, avg salary ${:.2}", dept, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_dept = Query::new(&employees).group_by(Employee::department_r());");
    println!("for (dept, emps) in &by_dept {{");
    println!("    let dept_query = Query::new(emps);");
    println!("    dept_query.avg(Employee::salary_r())");
    println!("}}");

    // ============================================================================
    // EXAMPLE 6: ORDER BY
    // ============================================================================
    print_separator("Example 6: ORDER BY");
    print_query(
        "SELECT name, salary FROM employees\n\
         WHERE department = 'Sales'\n\
         ORDER BY salary DESC;",
        "Sales employees ordered by salary (descending)"
    );

    let sales_sorted = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .order_by_float_desc(Employee::salary_r());

    for emp in &sales_sorted {
        println!("  {}: ${:.2}", emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Sales\")");
    println!("    .order_by_float_desc(Employee::salary_r())");

    // ============================================================================
    // EXAMPLE 7: Multiple WHERE conditions (AND)
    // ============================================================================
    print_separator("Example 7: Multiple WHERE conditions (AND)");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > 70000 AND age < 35;",
        "High-earning young employees"
    );

    let filter_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 70000.0)
        .where_(Employee::age_r(), |&age| age < 35);
    let filtered = filter_query.all();

    for emp in &filtered {
        println!("  {}: Age {}, Salary ${:.2}", emp.name, emp.age, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 70000.0)");
    println!("    .where_(Employee::age_r(), |&age| age < 35)");
    println!("    .all()");
    println!("✓ Found {} employees", filtered.len());

    // ============================================================================
    // EXAMPLE 8: LIMIT (TOP N)
    // ============================================================================
    print_separator("Example 8: LIMIT / TOP N");
    print_query(
        "SELECT TOP 3 name, salary FROM employees\n\
         ORDER BY salary DESC;",
        "Top 3 highest paid employees"
    );

    let top_earners = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r());

    for (i, emp) in top_earners.iter().take(3).enumerate() {
        println!("  {}. {}: ${:.2}", i + 1, emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("    .into_iter().take(3)");

    // ============================================================================
    // EXAMPLE 9: OFFSET and LIMIT (Pagination)
    // ============================================================================
    print_separator("Example 9: OFFSET and LIMIT (Pagination)");
    print_query(
        "SELECT name FROM employees\n\
         ORDER BY name\n\
         LIMIT 3 OFFSET 3;",
        "Page 2 of employee names (3 per page)"
    );

    let page_2 = Query::new(&employees)
        .order_by(Employee::name_r())
        .into_iter()
        .skip(3)
        .take(3)
        .collect::<Vec<_>>();

    for emp in &page_2 {
        println!("  {}", emp.name);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by(Employee::name_r())");
    println!("    .into_iter().skip(3).take(3)");

    // ============================================================================
    // EXAMPLE 10: INNER JOIN
    // ============================================================================
    print_separator("Example 10: INNER JOIN");
    print_query(
        "SELECT e.name, d.name as dept_name, d.budget\n\
         FROM employees e\n\
         INNER JOIN departments d ON e.department = d.name;",
        "Employees with their department info"
    );

    let emp_dept = JoinQuery::new(&employees, &departments).inner_join(
        Employee::department_r(),
        Department::name_r(),
        |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget),
    );

    for (emp_name, dept_name, budget) in emp_dept.iter().take(5) {
        println!("  {} works in {} (Budget: ${:.0})", emp_name, dept_name, budget);
    }
    println!("  ... (showing first 5)");

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&employees, &departments).inner_join(");
    println!("    Employee::department_r(),");
    println!("    Department::name_r(),");
    println!("    |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget)");
    println!(")");
    println!("✓ Found {} matches", emp_dept.len());

    // ============================================================================
    // EXAMPLE 11: GROUP BY with HAVING equivalent
    // ============================================================================
    print_separator("Example 11: GROUP BY with filtering (HAVING equivalent)");
    print_query(
        "SELECT city, COUNT(*) as emp_count, AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY city\n\
         HAVING COUNT(*) > 1;",
        "Cities with multiple employees"
    );

    let by_city = Query::new(&employees).group_by(Employee::city_r());
    let mut city_stats: Vec<_> = by_city
        .iter()
        .filter(|(_, emps)| emps.len() > 1) // HAVING equivalent
        .map(|(city, emps)| {
            let avg_sal = Query::new(emps).avg(Employee::salary_r()).unwrap_or(0.0);
            (city.clone(), emps.len(), avg_sal)
        })
        .collect();
    
    city_stats.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count

    for (city, count, avg_sal) in &city_stats {
        println!("  {}: {} employees, avg salary ${:.2}", city, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_city = Query::new(&employees).group_by(Employee::city_r());");
    println!("by_city.iter()");
    println!("    .filter(|(_, emps)| emps.len() > 1)  // HAVING equivalent");
    println!("    .map(|(city, emps)| {{");
    println!("        let avg = Query::new(emps).avg(Employee::salary_r());");
    println!("        (city, emps.len(), avg)");
    println!("    }})");

    // ============================================================================
    // EXAMPLE 12: Complex query with multiple operations
    // ============================================================================
    print_separator("Example 12: Complex multi-operation query");
    print_query(
        "SELECT name, salary, age\n\
         FROM employees\n\
         WHERE department IN ('Engineering', 'Sales')\n\
         AND salary BETWEEN 80000 AND 100000\n\
         AND age >= 30\n\
         ORDER BY salary DESC;",
        "Experienced mid-to-senior level employees in core departments"
    );

    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)
        .where_(Employee::age_r(), |&age| age >= 30)
        .order_by_float_desc(Employee::salary_r());

    for emp in &complex_query {
        println!("  {}: Age {}, {} dept, ${:.2}", emp.name, emp.age, emp.department, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\" || dept == \"Sales\")");
    println!("    .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)");
    println!("    .where_(Employee::age_r(), |&age| age >= 30)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("✓ Found {} employees", complex_query.len());

    // ============================================================================
    // EXAMPLE 13: Three-table JOIN
    // ============================================================================
    print_separator("Example 13: Three-table JOIN");
    print_query(
        "SELECT p.name as project, d.name as department, d.location\n\
         FROM projects p\n\
         INNER JOIN departments d ON p.department_id = d.id;",
        "Projects with their department details"
    );

    let proj_dept = JoinQuery::new(&projects, &departments).inner_join(
        Project::department_id_r(),
        Department::id_r(),
        |proj, dept| {
            (proj.name.clone(), dept.name.clone(), dept.location.clone(), proj.budget)
        },
    );

    for (proj_name, dept_name, location, budget) in &proj_dept {
        println!("  {}: {} dept in {} (${:.0})", proj_name, dept_name, location, budget);
    }

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&projects, &departments).inner_join(");
    println!("    Project::department_id_r(),");
    println!("    Department::id_r(),");
    println!("    |proj, dept| (proj.name, dept.name, dept.location, proj.budget)");
    println!(")");

    // ============================================================================
    // EXAMPLE 14: Subquery equivalent (using intermediate results)
    // ============================================================================
    print_separator("Example 14: Subquery equivalent");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > (SELECT AVG(salary) FROM employees);",
        "Employees earning above average"
    );

    let avg_salary = Query::new(&employees)
        .avg(Employee::salary_r())
        .unwrap_or(0.0);

    let above_avg_query = Query::new(&employees)
        .where_(Employee::salary_r(), move |&sal| sal > avg_salary);
    let above_avg = above_avg_query.all();

    println!("  Average salary: ${:.2}", avg_salary);
    for emp in &above_avg {
        println!("  {}: ${:.2} ({:.1}% above average)", 
            emp.name, emp.salary, ((emp.salary - avg_salary) / avg_salary * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let avg = Query::new(&employees).avg(Employee::salary_r()).unwrap_or(0.0);");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&sal| sal > avg)");
    println!("    .all()");
    println!("✓ Found {} employees above average", above_avg.len());

    // ============================================================================
    // EXAMPLE 15: Advanced aggregation (revenue calculation)
    // ============================================================================
    print_separator("Example 15: Advanced aggregation");
    print_query(
        "SELECT \n\
         d.name,\n\
         d.budget as dept_budget,\n\
         SUM(p.budget) as total_project_budget,\n\
         (d.budget - SUM(p.budget)) as remaining_budget\n\
         FROM departments d\n\
         LEFT JOIN projects p ON d.id = p.department_id\n\
         GROUP BY d.name, d.budget;",
        "Department budget utilization"
    );

    // Join departments with projects
    let dept_projects = JoinQuery::new(&departments, &projects).left_join(
        Department::id_r(),
        Project::department_id_r(),
        |dept, proj| (dept.clone(), proj.map(|p| p.clone())),
    );

    // Aggregate by department
    let mut dept_budget_map: HashMap<String, (f64, Vec<f64>)> = HashMap::new();
    for (dept, proj) in dept_projects {
        let entry = dept_budget_map
            .entry(dept.name.clone())
            .or_insert((dept.budget, Vec::new()));
        if let Some(p) = proj {
            entry.1.push(p.budget);
        }
    }

    for (dept_name, (total_budget, project_budgets)) in dept_budget_map.iter() {
        let used: f64 = project_budgets.iter().sum();
        let remaining = total_budget - used;
        println!("  {}: Budget ${:.0}, Used ${:.0}, Remaining ${:.0} ({:.1}% utilized)",
            dept_name, total_budget, used, remaining, (used / total_budget * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let dept_projects = JoinQuery::new(&departments, &projects)");
    println!("    .left_join(Department::id_r(), Project::department_id_r(), ...)");
    println!("// Then aggregate using HashMap");

    // ============================================================================
    // Summary
    // ============================================================================
    print_separator("Summary");
    println!("\n✓ All 15 SQL queries successfully replicated with Rust Query Builder!");
    println!("\nDemonstrated equivalents for:");
    println!("  • SELECT with WHERE");
    println!("  • Projection (SELECT specific columns)");
    println!("  • Aggregations (COUNT, SUM, AVG, MIN, MAX)");
    println!("  • GROUP BY");
    println!("  • ORDER BY");
    println!("  • LIMIT and OFFSET");
    println!("  • INNER JOIN and LEFT JOIN");
    println!("  • Complex conditions (AND, OR, BETWEEN)");
    println!("  • Subqueries");
    println!("  • Multi-table operations");
    println!("\n🎯 Type-safe, compile-time checked, and zero runtime overhead!");
    println!();
}

pub fn max_float(&self, path: KeyPaths<T, f64>) -> Option<f64>

Finds the maximum value of a float field.

Arguments

• path - The key-path to the f64 field

Example

let max_price = query.max_float(Product::price_r());

Examples found in repository

examples/advanced_query_builder.rs (line 157)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}

examples/sql_verification.rs (line 190)

fn main() {
    let employees = create_test_data();
    
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  SQL Equivalence Verification Tests                           ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // TEST 1: ORDER BY maintains exact SQL ordering (DESC)
    println!("Test 1: ORDER BY DESC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC;");
    
    let ordered = Query::new(&employees).order_by_float_desc(Employee::salary_r());
    let expected_order = vec![105000.0, 95000.0, 87000.0, 82000.0, 75000.0, 71000.0];
    let actual_order: Vec<f64> = ordered.iter().map(|e| e.salary).collect();
    
    let test1_pass = expected_order == actual_order;
    print_test("ORDER BY salary DESC produces correct order", test1_pass);
    if !test1_pass {
        println!("  Expected: {:?}", expected_order);
        println!("  Got: {:?}", actual_order);
    }

    // TEST 2: ORDER BY maintains exact SQL ordering (ASC)
    println!("\nTest 2: ORDER BY ASC - Exact ordering");
    println!("SQL: SELECT * FROM employees ORDER BY salary ASC;");
    
    let ordered_asc = Query::new(&employees).order_by_float(Employee::salary_r());
    let expected_asc = vec![71000.0, 75000.0, 82000.0, 87000.0, 95000.0, 105000.0];
    let actual_asc: Vec<f64> = ordered_asc.iter().map(|e| e.salary).collect();
    
    let test2_pass = expected_asc == actual_asc;
    print_test("ORDER BY salary ASC produces correct order", test2_pass);
    if !test2_pass {
        println!("  Expected: {:?}", expected_asc);
        println!("  Got: {:?}", actual_asc);
    }

    // TEST 3: String ordering (alphabetical)
    println!("\nTest 3: ORDER BY name (alphabetical)");
    println!("SQL: SELECT name FROM employees ORDER BY name;");
    
    let ordered_names = Query::new(&employees).order_by(Employee::name_r());
    let expected_names = vec!["Alice Cooper", "Alice Johnson", "Bob Smith", "Carol White", "David Brown", "Eve Davis"];
    let actual_names: Vec<&str> = ordered_names.iter().map(|e| e.name.as_str()).collect();
    
    let test3_pass = expected_names == actual_names;
    print_test("ORDER BY name produces correct alphabetical order", test3_pass);
    if !test3_pass {
        println!("  Expected: {:?}", expected_names);
        println!("  Got: {:?}", actual_names);
    }

    // TEST 4: LIKE equivalent - starts with
    println!("\nTest 4: LIKE 'Alice%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE 'Alice%';");
    
    let like_alice_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.starts_with("Alice"));
    let like_alice = like_alice_query.all();
    
    let test4_pass = like_alice.len() == 2 
        && like_alice.iter().all(|e| e.name.starts_with("Alice"));
    print_test("LIKE 'Alice%' (starts_with) works correctly", test4_pass);
    if test4_pass {
        for emp in &like_alice {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 5: LIKE equivalent - ends with
    println!("\nTest 5: LIKE '%son' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%son';");
    
    let like_son_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.ends_with("son"));
    let like_son = like_son_query.all();
    
    let test5_pass = like_son.len() == 1 && like_son[0].name == "Alice Johnson";
    print_test("LIKE '%son' (ends_with) works correctly", test5_pass);
    if test5_pass {
        for emp in &like_son {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 6: LIKE equivalent - contains
    println!("\nTest 6: LIKE '%mit%' equivalent");
    println!("SQL: SELECT * FROM employees WHERE name LIKE '%mit%';");
    
    let like_mit_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.contains("mit"));
    let like_mit = like_mit_query.all();
    
    let test6_pass = like_mit.len() == 1 && like_mit[0].name == "Bob Smith";
    print_test("LIKE '%mit%' (contains) works correctly", test6_pass);
    if test6_pass {
        for emp in &like_mit {
            println!("  Found: {}", emp.name);
        }
    }

    // TEST 7: IN clause equivalent
    println!("\nTest 7: IN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE department IN ('Engineering', 'Sales');");
    
    let in_depts_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales");
    let in_depts = in_depts_query.all();
    
    let test7_pass = in_depts.len() == 5 // 3 Engineering + 2 Sales
        && in_depts.iter().all(|e| e.department == "Engineering" || e.department == "Sales");
    print_test("IN clause works correctly", test7_pass);
    println!("  Found {} employees in Engineering or Sales", in_depts.len());

    // TEST 8: BETWEEN equivalent
    println!("\nTest 8: BETWEEN clause equivalent");
    println!("SQL: SELECT * FROM employees WHERE salary BETWEEN 75000 AND 90000;");
    
    let between_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal >= 75000.0 && sal <= 90000.0);
    let between = between_query.all();
    
    let test8_pass = between.len() == 3;
    print_test("BETWEEN clause works correctly", test8_pass);
    println!("  Found {} employees with salary between 75K-90K", between.len());

    // TEST 9: COUNT with WHERE
    println!("\nTest 9: COUNT with WHERE");
    println!("SQL: SELECT COUNT(*) FROM employees WHERE department = 'Engineering';");
    
    let count_eng = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .count();
    
    let test9_pass = count_eng == 3;
    print_test("COUNT with WHERE produces correct result", test9_pass);
    println!("  Count: {} (expected 3)", count_eng);

    // TEST 10: AVG produces exact result
    println!("\nTest 10: AVG aggregation accuracy");
    println!("SQL: SELECT AVG(salary) FROM employees WHERE department = 'Engineering';");
    
    let avg_sal = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering")
        .avg(Employee::salary_r())
        .unwrap_or(0.0);
    
    let expected_avg = (95000.0 + 87000.0 + 105000.0) / 3.0;
    let test10_pass = (avg_sal - expected_avg).abs() < 0.01;
    print_test("AVG produces mathematically correct result", test10_pass);
    println!("  Average: ${:.2} (expected ${:.2})", avg_sal, expected_avg);

    // TEST 11: MIN and MAX
    println!("\nTest 11: MIN and MAX aggregations");
    println!("SQL: SELECT MIN(salary), MAX(salary) FROM employees;");
    
    let min_sal = Query::new(&employees).min_float(Employee::salary_r()).unwrap_or(0.0);
    let max_sal = Query::new(&employees).max_float(Employee::salary_r()).unwrap_or(0.0);
    
    let test11_pass = min_sal == 71000.0 && max_sal == 105000.0;
    print_test("MIN and MAX produce correct results", test11_pass);
    println!("  MIN: ${:.2}, MAX: ${:.2}", min_sal, max_sal);

    // TEST 12: Complex WHERE with AND/OR
    println!("\nTest 12: Complex WHERE (AND + OR)");
    println!("SQL: SELECT * FROM employees WHERE (department = 'Engineering' OR department = 'Sales') AND salary > 80000;");
    
    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal > 80000.0);
    let complex = complex_query.all();
    
    let test12_pass = complex.len() == 4; // Alice J ($95k), Bob ($87k), David ($82k), Alice C ($105k)
    print_test("Complex WHERE clause works correctly", test12_pass);
    println!("  Found {} employees", complex.len());

    // TEST 13: Case-sensitive string comparison (SQL default)
    println!("\nTest 13: Case-sensitive comparison (like SQL)");
    println!("SQL: SELECT * FROM employees WHERE department = 'engineering'; -- should find 0");
    
    let case_sensitive = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "engineering") // lowercase
        .count();
    
    let test13_pass = case_sensitive == 0;
    print_test("Case-sensitive comparison (SQL default)", test13_pass);
    println!("  Found {} with lowercase 'engineering' (expected 0)", case_sensitive);

    // TEST 14: Case-insensitive LIKE equivalent
    println!("\nTest 14: Case-insensitive LIKE (ILIKE equivalent)");
    println!("SQL: SELECT * FROM employees WHERE LOWER(name) LIKE '%alice%';");
    
    let ilike_query = Query::new(&employees)
        .where_(Employee::name_r(), |name| name.to_lowercase().contains("alice"));
    let ilike = ilike_query.all();
    
    let test14_pass = ilike.len() == 2;
    print_test("Case-insensitive LIKE works correctly", test14_pass);
    println!("  Found {} employees with 'alice' (case-insensitive)", ilike.len());

    // TEST 15: LIMIT produces exact subset
    println!("\nTest 15: LIMIT clause");
    println!("SQL: SELECT * FROM employees ORDER BY salary DESC LIMIT 3;");
    
    let limited = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r())
        .into_iter()
        .take(3)
        .collect::<Vec<_>>();
    
    let test15_pass = limited.len() == 3 
        && limited[0].salary == 105000.0
        && limited[1].salary == 95000.0
        && limited[2].salary == 87000.0;
    print_test("LIMIT returns correct top-N results", test15_pass);
    println!("  Top 3 salaries: ${:.0}, ${:.0}, ${:.0}", 
        limited[0].salary, limited[1].salary, limited[2].salary);

    // TEST 16: GROUP BY produces correct groups
    println!("\nTest 16: GROUP BY");
    println!("SQL: SELECT department, COUNT(*) FROM employees GROUP BY department;");
    
    let grouped = Query::new(&employees).group_by(Employee::department_r());
    let eng_count = grouped.get("Engineering").map(|v| v.len()).unwrap_or(0);
    let sales_count = grouped.get("Sales").map(|v| v.len()).unwrap_or(0);
    let marketing_count = grouped.get("Marketing").map(|v| v.len()).unwrap_or(0);
    
    let test16_pass = eng_count == 3 && sales_count == 2 && marketing_count == 1;
    print_test("GROUP BY produces correct counts", test16_pass);
    println!("  Engineering: {}, Sales: {}, Marketing: {}", eng_count, sales_count, marketing_count);

    // TEST 17: Email pattern matching (regex-like)
    println!("\nTest 17: Email domain filtering (LIKE '%@example.com')");
    println!("SQL: SELECT * FROM employees WHERE email LIKE '%@example.com';");
    
    let example_emails = Query::new(&employees)
        .where_(Employee::email_r(), |email| email.ends_with("@example.com"))
        .count();
    
    let test17_pass = example_emails == 6; // All employees have @example.com emails
    print_test("Email pattern matching works correctly", test17_pass);
    println!("  Found {} employees with @example.com emails", example_emails);

    // Summary
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Test Summary                                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");
    
    let tests = vec![
        ("ORDER BY DESC", test1_pass),
        ("ORDER BY ASC", test2_pass),
        ("ORDER BY name", test3_pass),
        ("LIKE 'prefix%'", test4_pass),
        ("LIKE '%suffix'", test5_pass),
        ("LIKE '%contains%'", test6_pass),
        ("IN clause", test7_pass),
        ("BETWEEN clause", test8_pass),
        ("COUNT", test9_pass),
        ("AVG accuracy", test10_pass),
        ("MIN/MAX", test11_pass),
        ("Complex WHERE", test12_pass),
        ("Case-sensitive", test13_pass),
        ("Case-insensitive", test14_pass),
        ("LIMIT", test15_pass),
        ("GROUP BY", test16_pass),
        ("Email patterns", test17_pass),
    ];
    
    let passed = tests.iter().filter(|(_, p)| *p).count();
    let total = tests.len();
    
    println!("Results: {}/{} tests passed", passed, total);
    
    if passed == total {
        println!("\n🎉 All tests PASSED! Rust Query Builder produces exact SQL-equivalent results!");
        println!("\n✅ Verified:");
        println!("  • Exact ordering (ASC/DESC)");
        println!("  • LIKE operations (starts_with, ends_with, contains)");
        println!("  • IN clause (OR conditions)");
        println!("  • BETWEEN clause");
        println!("  • Aggregations (COUNT, AVG, MIN, MAX)");
        println!("  • Complex WHERE conditions");
        println!("  • Case sensitivity");
        println!("  • LIMIT clause");
        println!("  • GROUP BY");
        println!("  • Pattern matching");
    } else {
        println!("\n⚠️  {} test(s) failed. See details above.", total - passed);
    }
}

examples/sql_comparison.rs (line 178)

fn main() {
    let employees = create_employees();
    let departments = create_departments();
    let projects = create_projects();

    println!("\n╔════════════════════════════════════════════════════════════════════════╗");
    println!("║     SQL vs Rust Query Builder Comparison                              ║");
    println!("║     Demonstrating equivalent operations                               ║");
    println!("╚════════════════════════════════════════════════════════════════════════╝");

    // ============================================================================
    // EXAMPLE 1: Simple SELECT with WHERE
    // ============================================================================
    print_separator("Example 1: SELECT with WHERE clause");
    print_query(
        "SELECT * FROM employees WHERE department = 'Engineering';",
        "Filter employees by department"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering_employees = eng_query.all();

    for emp in &engineering_employees {
        println!("  ID: {}, Name: {}, Salary: ${:.2}", emp.id, emp.name, emp.salary);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\")");
    println!("    .all()");
    println!("✓ Found {} employees", engineering_employees.len());

    // ============================================================================
    // EXAMPLE 2: SELECT specific columns
    // ============================================================================
    print_separator("Example 2: SELECT specific columns (Projection)");
    print_query(
        "SELECT name FROM employees WHERE salary > 80000;",
        "Get names of high-earning employees"
    );

    let high_earners = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 80000.0)
        .select(Employee::name_r());

    for name in &high_earners {
        println!("  {}", name);
    }
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 80000.0)");
    println!("    .select(Employee::name_r())");
    println!("✓ Found {} employees", high_earners.len());

    // ============================================================================
    // EXAMPLE 3: COUNT
    // ============================================================================
    print_separator("Example 3: COUNT aggregation");
    print_query(
        "SELECT COUNT(*) FROM employees WHERE age < 30;",
        "Count young employees"
    );

    let young_count = Query::new(&employees)
        .where_(Employee::age_r(), |&age| age < 30)
        .count();

    println!("  Count: {}", young_count);
    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::age_r(), |&age| age < 30)");
    println!("    .count()");
    println!("✓ Result: {}", young_count);

    // ============================================================================
    // EXAMPLE 4: SUM, AVG, MIN, MAX
    // ============================================================================
    print_separator("Example 4: Aggregate functions (SUM, AVG, MIN, MAX)");
    print_query(
        "SELECT \n\
         SUM(salary) as total_salary,\n\
         AVG(salary) as avg_salary,\n\
         MIN(salary) as min_salary,\n\
         MAX(salary) as max_salary\n\
         FROM employees WHERE department = 'Engineering';",
        "Engineering department salary statistics"
    );

    let eng_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");

    let total = eng_query.sum(Employee::salary_r());
    let avg = eng_query.avg(Employee::salary_r()).unwrap_or(0.0);
    let min = eng_query.min_float(Employee::salary_r()).unwrap_or(0.0);
    let max = eng_query.max_float(Employee::salary_r()).unwrap_or(0.0);

    println!("  Total Salary: ${:.2}", total);
    println!("  Avg Salary:   ${:.2}", avg);
    println!("  Min Salary:   ${:.2}", min);
    println!("  Max Salary:   ${:.2}", max);

    println!("\nRust Query Builder:");
    println!("let query = Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\");");
    println!("query.sum(Employee::salary_r())  // ${:.2}", total);
    println!("query.avg(Employee::salary_r())  // ${:.2}", avg);
    println!("query.min_float(Employee::salary_r())  // ${:.2}", min);
    println!("query.max_float(Employee::salary_r())  // ${:.2}", max);

    // ============================================================================
    // EXAMPLE 5: GROUP BY with aggregation
    // ============================================================================
    print_separator("Example 5: GROUP BY with aggregation");
    print_query(
        "SELECT \n\
         department,\n\
         COUNT(*) as emp_count,\n\
         AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY department;",
        "Statistics by department"
    );

    let by_dept = Query::new(&employees).group_by(Employee::department_r());

    for (dept, emps) in &by_dept {
        let dept_query = Query::new(emps);
        let count = emps.len();
        let avg_sal = dept_query.avg(Employee::salary_r()).unwrap_or(0.0);
        println!("  {}: {} employees, avg salary ${:.2}", dept, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_dept = Query::new(&employees).group_by(Employee::department_r());");
    println!("for (dept, emps) in &by_dept {{");
    println!("    let dept_query = Query::new(emps);");
    println!("    dept_query.avg(Employee::salary_r())");
    println!("}}");

    // ============================================================================
    // EXAMPLE 6: ORDER BY
    // ============================================================================
    print_separator("Example 6: ORDER BY");
    print_query(
        "SELECT name, salary FROM employees\n\
         WHERE department = 'Sales'\n\
         ORDER BY salary DESC;",
        "Sales employees ordered by salary (descending)"
    );

    let sales_sorted = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .order_by_float_desc(Employee::salary_r());

    for emp in &sales_sorted {
        println!("  {}: ${:.2}", emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Sales\")");
    println!("    .order_by_float_desc(Employee::salary_r())");

    // ============================================================================
    // EXAMPLE 7: Multiple WHERE conditions (AND)
    // ============================================================================
    print_separator("Example 7: Multiple WHERE conditions (AND)");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > 70000 AND age < 35;",
        "High-earning young employees"
    );

    let filter_query = Query::new(&employees)
        .where_(Employee::salary_r(), |&salary| salary > 70000.0)
        .where_(Employee::age_r(), |&age| age < 35);
    let filtered = filter_query.all();

    for emp in &filtered {
        println!("  {}: Age {}, Salary ${:.2}", emp.name, emp.age, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&salary| salary > 70000.0)");
    println!("    .where_(Employee::age_r(), |&age| age < 35)");
    println!("    .all()");
    println!("✓ Found {} employees", filtered.len());

    // ============================================================================
    // EXAMPLE 8: LIMIT (TOP N)
    // ============================================================================
    print_separator("Example 8: LIMIT / TOP N");
    print_query(
        "SELECT TOP 3 name, salary FROM employees\n\
         ORDER BY salary DESC;",
        "Top 3 highest paid employees"
    );

    let top_earners = Query::new(&employees)
        .order_by_float_desc(Employee::salary_r());

    for (i, emp) in top_earners.iter().take(3).enumerate() {
        println!("  {}. {}: ${:.2}", i + 1, emp.name, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("    .into_iter().take(3)");

    // ============================================================================
    // EXAMPLE 9: OFFSET and LIMIT (Pagination)
    // ============================================================================
    print_separator("Example 9: OFFSET and LIMIT (Pagination)");
    print_query(
        "SELECT name FROM employees\n\
         ORDER BY name\n\
         LIMIT 3 OFFSET 3;",
        "Page 2 of employee names (3 per page)"
    );

    let page_2 = Query::new(&employees)
        .order_by(Employee::name_r())
        .into_iter()
        .skip(3)
        .take(3)
        .collect::<Vec<_>>();

    for emp in &page_2 {
        println!("  {}", emp.name);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .order_by(Employee::name_r())");
    println!("    .into_iter().skip(3).take(3)");

    // ============================================================================
    // EXAMPLE 10: INNER JOIN
    // ============================================================================
    print_separator("Example 10: INNER JOIN");
    print_query(
        "SELECT e.name, d.name as dept_name, d.budget\n\
         FROM employees e\n\
         INNER JOIN departments d ON e.department = d.name;",
        "Employees with their department info"
    );

    let emp_dept = JoinQuery::new(&employees, &departments).inner_join(
        Employee::department_r(),
        Department::name_r(),
        |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget),
    );

    for (emp_name, dept_name, budget) in emp_dept.iter().take(5) {
        println!("  {} works in {} (Budget: ${:.0})", emp_name, dept_name, budget);
    }
    println!("  ... (showing first 5)");

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&employees, &departments).inner_join(");
    println!("    Employee::department_r(),");
    println!("    Department::name_r(),");
    println!("    |emp, dept| (emp.name.clone(), dept.name.clone(), dept.budget)");
    println!(")");
    println!("✓ Found {} matches", emp_dept.len());

    // ============================================================================
    // EXAMPLE 11: GROUP BY with HAVING equivalent
    // ============================================================================
    print_separator("Example 11: GROUP BY with filtering (HAVING equivalent)");
    print_query(
        "SELECT city, COUNT(*) as emp_count, AVG(salary) as avg_salary\n\
         FROM employees\n\
         GROUP BY city\n\
         HAVING COUNT(*) > 1;",
        "Cities with multiple employees"
    );

    let by_city = Query::new(&employees).group_by(Employee::city_r());
    let mut city_stats: Vec<_> = by_city
        .iter()
        .filter(|(_, emps)| emps.len() > 1) // HAVING equivalent
        .map(|(city, emps)| {
            let avg_sal = Query::new(emps).avg(Employee::salary_r()).unwrap_or(0.0);
            (city.clone(), emps.len(), avg_sal)
        })
        .collect();
    
    city_stats.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count

    for (city, count, avg_sal) in &city_stats {
        println!("  {}: {} employees, avg salary ${:.2}", city, count, avg_sal);
    }

    println!("\nRust Query Builder:");
    println!("let by_city = Query::new(&employees).group_by(Employee::city_r());");
    println!("by_city.iter()");
    println!("    .filter(|(_, emps)| emps.len() > 1)  // HAVING equivalent");
    println!("    .map(|(city, emps)| {{");
    println!("        let avg = Query::new(emps).avg(Employee::salary_r());");
    println!("        (city, emps.len(), avg)");
    println!("    }})");

    // ============================================================================
    // EXAMPLE 12: Complex query with multiple operations
    // ============================================================================
    print_separator("Example 12: Complex multi-operation query");
    print_query(
        "SELECT name, salary, age\n\
         FROM employees\n\
         WHERE department IN ('Engineering', 'Sales')\n\
         AND salary BETWEEN 80000 AND 100000\n\
         AND age >= 30\n\
         ORDER BY salary DESC;",
        "Experienced mid-to-senior level employees in core departments"
    );

    let complex_query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering" || dept == "Sales")
        .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)
        .where_(Employee::age_r(), |&age| age >= 30)
        .order_by_float_desc(Employee::salary_r());

    for emp in &complex_query {
        println!("  {}: Age {}, {} dept, ${:.2}", emp.name, emp.age, emp.department, emp.salary);
    }

    println!("\nRust Query Builder:");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::department_r(), |dept| dept == \"Engineering\" || dept == \"Sales\")");
    println!("    .where_(Employee::salary_r(), |&sal| sal >= 80000.0 && sal <= 100000.0)");
    println!("    .where_(Employee::age_r(), |&age| age >= 30)");
    println!("    .order_by_float_desc(Employee::salary_r())");
    println!("✓ Found {} employees", complex_query.len());

    // ============================================================================
    // EXAMPLE 13: Three-table JOIN
    // ============================================================================
    print_separator("Example 13: Three-table JOIN");
    print_query(
        "SELECT p.name as project, d.name as department, d.location\n\
         FROM projects p\n\
         INNER JOIN departments d ON p.department_id = d.id;",
        "Projects with their department details"
    );

    let proj_dept = JoinQuery::new(&projects, &departments).inner_join(
        Project::department_id_r(),
        Department::id_r(),
        |proj, dept| {
            (proj.name.clone(), dept.name.clone(), dept.location.clone(), proj.budget)
        },
    );

    for (proj_name, dept_name, location, budget) in &proj_dept {
        println!("  {}: {} dept in {} (${:.0})", proj_name, dept_name, location, budget);
    }

    println!("\nRust Query Builder:");
    println!("JoinQuery::new(&projects, &departments).inner_join(");
    println!("    Project::department_id_r(),");
    println!("    Department::id_r(),");
    println!("    |proj, dept| (proj.name, dept.name, dept.location, proj.budget)");
    println!(")");

    // ============================================================================
    // EXAMPLE 14: Subquery equivalent (using intermediate results)
    // ============================================================================
    print_separator("Example 14: Subquery equivalent");
    print_query(
        "SELECT * FROM employees\n\
         WHERE salary > (SELECT AVG(salary) FROM employees);",
        "Employees earning above average"
    );

    let avg_salary = Query::new(&employees)
        .avg(Employee::salary_r())
        .unwrap_or(0.0);

    let above_avg_query = Query::new(&employees)
        .where_(Employee::salary_r(), move |&sal| sal > avg_salary);
    let above_avg = above_avg_query.all();

    println!("  Average salary: ${:.2}", avg_salary);
    for emp in &above_avg {
        println!("  {}: ${:.2} ({:.1}% above average)", 
            emp.name, emp.salary, ((emp.salary - avg_salary) / avg_salary * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let avg = Query::new(&employees).avg(Employee::salary_r()).unwrap_or(0.0);");
    println!("Query::new(&employees)");
    println!("    .where_(Employee::salary_r(), |&sal| sal > avg)");
    println!("    .all()");
    println!("✓ Found {} employees above average", above_avg.len());

    // ============================================================================
    // EXAMPLE 15: Advanced aggregation (revenue calculation)
    // ============================================================================
    print_separator("Example 15: Advanced aggregation");
    print_query(
        "SELECT \n\
         d.name,\n\
         d.budget as dept_budget,\n\
         SUM(p.budget) as total_project_budget,\n\
         (d.budget - SUM(p.budget)) as remaining_budget\n\
         FROM departments d\n\
         LEFT JOIN projects p ON d.id = p.department_id\n\
         GROUP BY d.name, d.budget;",
        "Department budget utilization"
    );

    // Join departments with projects
    let dept_projects = JoinQuery::new(&departments, &projects).left_join(
        Department::id_r(),
        Project::department_id_r(),
        |dept, proj| (dept.clone(), proj.map(|p| p.clone())),
    );

    // Aggregate by department
    let mut dept_budget_map: HashMap<String, (f64, Vec<f64>)> = HashMap::new();
    for (dept, proj) in dept_projects {
        let entry = dept_budget_map
            .entry(dept.name.clone())
            .or_insert((dept.budget, Vec::new()));
        if let Some(p) = proj {
            entry.1.push(p.budget);
        }
    }

    for (dept_name, (total_budget, project_budgets)) in dept_budget_map.iter() {
        let used: f64 = project_budgets.iter().sum();
        let remaining = total_budget - used;
        println!("  {}: Budget ${:.0}, Used ${:.0}, Remaining ${:.0} ({:.1}% utilized)",
            dept_name, total_budget, used, remaining, (used / total_budget * 100.0));
    }

    println!("\nRust Query Builder:");
    println!("let dept_projects = JoinQuery::new(&departments, &projects)");
    println!("    .left_join(Department::id_r(), Project::department_id_r(), ...)");
    println!("// Then aggregate using HashMap");

    // ============================================================================
    // Summary
    // ============================================================================
    print_separator("Summary");
    println!("\n✓ All 15 SQL queries successfully replicated with Rust Query Builder!");
    println!("\nDemonstrated equivalents for:");
    println!("  • SELECT with WHERE");
    println!("  • Projection (SELECT specific columns)");
    println!("  • Aggregations (COUNT, SUM, AVG, MIN, MAX)");
    println!("  • GROUP BY");
    println!("  • ORDER BY");
    println!("  • LIMIT and OFFSET");
    println!("  • INNER JOIN and LEFT JOIN");
    println!("  • Complex conditions (AND, OR, BETWEEN)");
    println!("  • Subqueries");
    println!("  • Multi-table operations");
    println!("\n🎯 Type-safe, compile-time checked, and zero runtime overhead!");
    println!();
}

pub fn exists(&self) -> bool

Checks if any items match the query filters.

Example

let has_results = query.exists();

Examples found in repository

examples/advanced_query_builder.rs (line 206)

fn main() {
    println!("=== Advanced Query Builder Demo ===\n");

    let products = create_product_catalog();
    println!("Total products in catalog: {}\n", products.len());

    // Query 1: Select all product names
    println!("--- Query 1: Select All Product Names ---");
    let names = Query::new(&products).select(Product::name_r());
    println!("Product names ({}):", names.len());
    for name in &names {
        println!("  • {}", name);
    }

    // Query 2: Order by price (ascending)
    println!("\n--- Query 2: Products Ordered by Price (Ascending) ---");
    let ordered = Query::new(&products).order_by_float(Product::price_r());
    for product in ordered.iter().take(5) {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 3: Order by rating (descending)
    println!("\n--- Query 3: Top-Rated Products (Descending) ---");
    let top_rated = Query::new(&products).order_by_float_desc(Product::rating_r());
    for product in top_rated.iter().take(5) {
        println!("  • {} - Rating: {:.1}", product.name, product.rating);
    }

    // Query 4: Group by category
    println!("\n--- Query 4: Products Grouped by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());
    for (category, items) in &by_category {
        println!("  {}: {} products", category, items.len());
        for item in items {
            println!("    - {} (${:.2})", item.name, item.price);
        }
    }

    // Query 5: Aggregations - Electronics statistics
    println!("\n--- Query 5: Electronics Category Statistics ---");
    let electronics_query = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");

    println!("  Count: {}", electronics_query.count());
    println!("  Total Value: ${:.2}", electronics_query.sum(Product::price_r()));
    println!("  Average Price: ${:.2}", electronics_query.avg(Product::price_r()).unwrap_or(0.0));
    println!("  Min Price: ${:.2}", electronics_query.min_float(Product::price_r()).unwrap_or(0.0));
    println!("  Max Price: ${:.2}", electronics_query.max_float(Product::price_r()).unwrap_or(0.0));
    println!("  Total Stock: {}", electronics_query.sum(Product::stock_r()));

    // Query 6: Complex filtering with ordering
    println!("\n--- Query 6: Electronics Under $200, Ordered by Rating ---");
    let affordable_electronics = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&price| price < 200.0)
        .order_by_float_desc(Product::rating_r());

    for product in &affordable_electronics {
        println!(
            "  • {} - ${:.2} - Rating: {:.1}",
            product.name, product.price, product.rating
        );
    }

    // Query 7: Limit results
    println!("\n--- Query 7: First 3 Products ---");
    let query7 = Query::new(&products);
    let first_three = query7.limit(3);
    for product in &first_three {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 8: Pagination
    println!("\n--- Query 8: Pagination (Page 2, 3 items per page) ---");
    let query8 = Query::new(&products);
    let page_2 = query8.skip(3).limit(3);
    for product in &page_2 {
        println!("  • {} (ID: {})", product.name, product.id);
    }

    // Query 9: First matching item
    println!("\n--- Query 9: Find First Product Over $1000 ---");
    let query9 = Query::new(&products)
        .where_(Product::price_r(), |&price| price > 1000.0);
    let expensive = query9.first();

    if let Some(product) = expensive {
        println!("  Found: {} - ${:.2}", product.name, product.price);
    } else {
        println!("  No products found over $1000");
    }

    // Query 10: Check existence
    println!("\n--- Query 10: Check if Any Furniture Exists ---");
    let has_furniture = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Furniture")
        .exists();
    println!("  Furniture available: {}", has_furniture);

    // Query 11: Multiple aggregations by group
    println!("\n--- Query 11: Category Statistics ---");
    let grouped = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &grouped {
        let cat_query = Query::new(items);
        println!("\n  {} Statistics:", category);
        println!("    Products: {}", items.len());
        println!("    Total Value: ${:.2}", cat_query.sum(Product::price_r()));
        println!("    Avg Price: ${:.2}", cat_query.avg(Product::price_r()).unwrap_or(0.0));
        println!("    Total Stock: {}", cat_query.sum(Product::stock_r()));
        println!("    Avg Rating: {:.2}", cat_query.avg(Product::rating_r()).unwrap_or(0.0));
    }

    // Query 12: Complex multi-stage query
    println!("\n--- Query 12: Top 3 Highly-Rated Products (Rating > 4.5) by Price ---");
    let top_products = Query::new(&products)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float_desc(Product::price_r());

    for (i, product) in top_products.iter().take(3).enumerate() {
        println!(
            "  {}. {} - ${:.2} - Rating: {:.1}",
            i + 1,
            product.name,
            product.price,
            product.rating
        );
    }

    // Query 13: Select multiple fields (simulated with tuples)
    println!("\n--- Query 13: Select Name and Price for Electronics ---");
    let query13 = Query::new(&products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query13.all();

    for product in electronics {
        println!("  • {} - ${:.2}", product.name, product.price);
    }

    // Query 14: Stock analysis
    println!("\n--- Query 14: Low Stock Alert (Stock < 20) ---");
    let low_stock = Query::new(&products)
        .where_(Product::stock_r(), |&stock| stock < 20)
        .order_by(Product::stock_r());

    for product in &low_stock {
        println!("  ⚠️  {} - Only {} in stock", product.name, product.stock);
    }

    // Query 15: Price range query with multiple conditions
    println!("\n--- Query 15: Mid-Range Products ($50-$300) with Good Ratings (>4.5) ---");
    let mid_range = Query::new(&products)
        .where_(Product::price_r(), |&price| price >= 50.0 && price <= 300.0)
        .where_(Product::rating_r(), |&rating| rating > 4.5)
        .order_by_float(Product::price_r());

    for product in &mid_range {
        println!(
            "  • {} - ${:.2} - Rating: {:.1} - Stock: {}",
            product.name, product.price, product.rating, product.stock
        );
    }

    // Query 16: Revenue calculation
    println!("\n--- Query 16: Potential Revenue by Category ---");
    let by_category = Query::new(&products).group_by(Product::category_r());

    for (category, items) in &by_category {
        let revenue: f64 = items.iter().map(|p| p.price * p.stock as f64).sum();
        println!("  {}: ${:.2}", category, revenue);
    }

    println!("\n✓ Advanced query builder demo complete!");
}