Struct Query 

pub struct Query<'a, T>
where
    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> Query<'a, T>

where T: 'static,

pub fn new(data: &'a [T]) -> Query<'a, T>

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/individual_crates.rs (line 136)

fn main() {
    println!("Individual Crates Example");
    println!("=========================\n");
    println!("Using rust-queries-core + rust-queries-derive directly\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. QueryExt from rust_queries_core");
    println!("   products.query().where_(price > 100).all()");
    
    let query = products
        .query()  // From QueryExt trait
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. QueryBuilder from rust_queries_derive");
    println!("   Product::query(&products).where_(stock < 10).all()");
    
    let query2 = Product::query(&products)  // From QueryBuilder derive
        .where_(Product::stock_r(), |&s| s < 10);
    let low_stock = query2.all();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. LazyQuery from rust_queries_core");
    println!("   products.lazy_query().where_(...).collect()");
    
    let electronics: Vec<_> = products
        .lazy_query()  // From QueryExt trait
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    
    println!("   Found {} electronics:", electronics.len());
    for product in electronics {
        println!("   - {}", product.name);
    }
    println!();

    println!("4. Aggregations with LazyQuery");
    println!("   products.lazy_query().sum_by(Product::price_r())");
    
    let total_value: f64 = products
        .lazy_query()
        .sum_by(Product::price_r());
    
    println!("   Total inventory value: ${:.2}", total_value);
    println!();

    println!("5. Early termination with lazy queries");
    println!("   products.lazy_query().where_(...).first()");
    
    if let Some(first_cheap) = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p < 50.0)
        .first()
    {
        println!("   First cheap product: {} (${:.2})", first_cheap.name, first_cheap.price);
    }
    println!();

    println!("6. Using Query (eager) from rust_queries_core");
    println!("   Query::new(&products).where_(...).count()");
    
    let query3 = Query::new(&products)  // Traditional approach
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query3.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ rust_queries_core provides: Query, LazyQuery, QueryExt");
    println!("✓ rust_queries_derive provides: #[derive(QueryBuilder)]");
    println!("✓ key_paths_derive provides: #[derive(Keypaths)]");
    println!("✓ All features work with individual crates!");
}

examples/without_clone.rs (line 77)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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/container_support.rs (line 46)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Container Support Demo                                       ║");
    println!("║  Query various collection types                               ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // ============================================================================
    // CONTAINER 1: Vec<T>
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Container 1: Vec<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let vec_products = vec![
        create_sample_product(1, "Laptop", 999, "Electronics"),
        create_sample_product(2, "Mouse", 29, "Electronics"),
        create_sample_product(3, "Desk", 299, "Furniture"),
    ];

    // Query Vec directly
    let vec_query = Query::new(&vec_products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let vec_results = vec_query.all();
    println!("  Vec: Found {} electronics", vec_results.len());

    // Lazy query on Vec
    let lazy_count = LazyQuery::new(&vec_products)
        .where_(Product::price_r(), |&p| p < 100)
        .count();
    println!("  Vec (lazy): {} items under $100", lazy_count);

    // ============================================================================
    // CONTAINER 2: VecDeque<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 2: VecDeque<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut deque_products = VecDeque::new();
    deque_products.push_back(create_sample_product(1, "Keyboard", 129, "Electronics"));
    deque_products.push_back(create_sample_product(2, "Monitor", 349, "Electronics"));
    deque_products.push_back(create_sample_product(3, "Chair", 199, "Furniture"));

    // Convert to owned Vec for querying
    let deque_vec: Vec<Product> = deque_products.iter().cloned().collect();
    let deque_query = Query::new(&deque_vec);
    let deque_count = deque_query.count();
    println!("  VecDeque: {} total items", deque_count);

    // More efficient: use make_contiguous for zero-copy slice access
    let contiguous = deque_products.make_contiguous();
    let contiguous_query = Query::new(contiguous);
    println!("  VecDeque (zero-copy): {} items", contiguous_query.count());

    // ============================================================================
    // CONTAINER 3: HashSet<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 3: HashSet<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut set_products = HashSet::new();
    set_products.insert(create_sample_product(1, "Tablet", 499, "Electronics"));
    set_products.insert(create_sample_product(2, "Phone", 799, "Electronics"));
    set_products.insert(create_sample_product(3, "Lamp", 39, "Furniture"));

    // Collect from HashSet to Vec for querying
    let set_vec: Vec<Product> = set_products.iter().cloned().collect();
    let set_query = Query::new(&set_vec)
        .where_(Product::price_r(), |&p| p > 500);
    let expensive = set_query.all();
    println!("  HashSet: {} expensive items", expensive.len());

    // Lazy on HashSet (convert to owned Vec first)
    let set_owned: Vec<Product> = set_products.iter().cloned().collect();
    let lazy_set: Vec<_> = LazyQuery::new(&set_owned)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    println!("  HashSet (lazy): {} electronics", lazy_set.len());

    // ============================================================================
    // CONTAINER 4: BTreeSet<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 4: BTreeSet<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut btree_set = BTreeSet::new();
    btree_set.insert(create_sample_product(1, "Webcam", 79, "Electronics"));
    btree_set.insert(create_sample_product(2, "Microphone", 129, "Electronics"));
    btree_set.insert(create_sample_product(3, "Bookshelf", 149, "Furniture"));

    let btree_vec: Vec<Product> = btree_set.iter().cloned().collect();
    let btree_query = Query::new(&btree_vec);
    println!("  BTreeSet: {} total items (sorted order!)", btree_query.count());
    
    // BTreeSet items are in sorted order
    for (i, item) in btree_vec.iter().take(3).enumerate() {
        println!("    {}. {} (ID: {})", i + 1, item.name, item.id);
    }

    // ============================================================================
    // CONTAINER 5: HashMap<K, V> - Query Values
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 5: HashMap<K, V> - Querying values");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut map_products = HashMap::new();
    map_products.insert("prod1", create_sample_product(1, "Speaker", 199, "Electronics"));
    map_products.insert("prod2", create_sample_product(2, "Headphones", 149, "Electronics"));
    map_products.insert("prod3", create_sample_product(3, "Ottoman", 249, "Furniture"));

    // Query HashMap values (convert to owned Vec)
    let map_vec: Vec<Product> = map_products.values().cloned().collect();
    let map_query = Query::new(&map_vec)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = map_query.all();
    println!("  HashMap: {} electronics", electronics.len());

    // ============================================================================
    // CONTAINER 6: BTreeMap<K, V> - Query Values
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 6: BTreeMap<K, V> - Querying values");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut btree_map = BTreeMap::new();
    btree_map.insert(1, create_sample_product(1, "Router", 89, "Electronics"));
    btree_map.insert(2, create_sample_product(2, "Switch", 129, "Electronics"));
    btree_map.insert(3, create_sample_product(3, "Sofa", 899, "Furniture"));

    let btree_map_vec: Vec<Product> = btree_map.values().cloned().collect();
    let btree_map_query = Query::new(&btree_map_vec);
    let avg_price = btree_map_query.sum(Product::price_r()) as f64 / btree_map.len() as f64;
    println!("  BTreeMap: Average price ${:.2}", avg_price);

    // ============================================================================
    // CONTAINER 7: Arrays [T; N]
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 7: Arrays [T; N]");
    println!("═══════════════════════════════════════════════════════════════\n");

    let array_products = [
        create_sample_product(1, "USB Cable", 15, "Electronics"),
        create_sample_product(2, "HDMI Cable", 25, "Electronics"),
        create_sample_product(3, "Power Strip", 35, "Electronics"),
    ];

    // Query array directly (as slice)
    let array_query = Query::new(&array_products);
    let total = array_query.sum(Product::price_r());
    println!("  Array: Total value ${}", total);

    // Lazy on array
    let lazy_array: Vec<_> = LazyQuery::new(&array_products)
        .where_(Product::price_r(), |&p| p > 20)
        .collect();
    println!("  Array (lazy): {} items over $20", lazy_array.len());

    // ============================================================================
    // CONTAINER 8: LinkedList<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 8: LinkedList<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut list_products = LinkedList::new();
    list_products.push_back(create_sample_product(1, "SSD", 159, "Electronics"));
    list_products.push_back(create_sample_product(2, "HDD", 79, "Electronics"));

    let list_vec: Vec<Product> = list_products.iter().cloned().collect();
    let list_query = Query::new(&list_vec);
    println!("  LinkedList: {} items", list_query.count());

    // ============================================================================
    // CONTAINER 9: Option<T> and Result<T, E>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 9: Option<T> and Result<T, E>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let maybe_product = Some(create_sample_product(1, "Mystery Box", 99, "Special"));
    
    if let Some(ref product) = maybe_product {
        let option_query = Query::new(std::slice::from_ref(product));
        println!("  Option (Some): {} items", option_query.count());
    }

    let none_product: Option<Product> = None;
    let none_count = none_product.iter().count();
    println!("  Option (None): {} items", none_count);

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Supported Containers Summary                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Supported container types:");
    println!("   • Vec<T>              - Standard vector");
    println!("   • &[T]                - Slices");
    println!("   • [T; N]              - Fixed-size arrays");
    println!("   • VecDeque<T>         - Double-ended queue");
    println!("   • LinkedList<T>       - Doubly-linked list");
    println!("   • HashSet<T>          - Unordered set");
    println!("   • BTreeSet<T>         - Ordered set");
    println!("   • HashMap<K, V>       - Query values");
    println!("   • BTreeMap<K, V>      - Query values (sorted)");
    println!("   • Option<T>           - 0 or 1 item");
    println!("   • Result<T, E>        - 0 or 1 item\n");

    println!("📝 Usage patterns:");
    println!("   • Direct: Query::new(&container) for Vec, slices, arrays");
    println!("   • Convert: Collect to Vec for Sets and Maps");
    println!("   • Lazy: LazyQuery::new(&slice) for any slice\n");

    println!("💡 Tips:");
    println!("   • Vec/slice: Direct support, most efficient");
    println!("   • Sets: Iterate to Vec, then query");
    println!("   • Maps: Use .values().collect() to query values");
    println!("   • VecDeque: Use .as_slices() for zero-copy");
    println!("   • For custom types: Implement Queryable trait\n");

    println!("✓ Container support demo complete!\n");
}

Additional examples can be found in:

• examples/custom_queryable.rs
• examples/sql_comparison.rs
• examples/memory_safety_verification.rs

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

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/individual_crates.rs (line 75)

fn main() {
    println!("Individual Crates Example");
    println!("=========================\n");
    println!("Using rust-queries-core + rust-queries-derive directly\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. QueryExt from rust_queries_core");
    println!("   products.query().where_(price > 100).all()");
    
    let query = products
        .query()  // From QueryExt trait
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. QueryBuilder from rust_queries_derive");
    println!("   Product::query(&products).where_(stock < 10).all()");
    
    let query2 = Product::query(&products)  // From QueryBuilder derive
        .where_(Product::stock_r(), |&s| s < 10);
    let low_stock = query2.all();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. LazyQuery from rust_queries_core");
    println!("   products.lazy_query().where_(...).collect()");
    
    let electronics: Vec<_> = products
        .lazy_query()  // From QueryExt trait
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    
    println!("   Found {} electronics:", electronics.len());
    for product in electronics {
        println!("   - {}", product.name);
    }
    println!();

    println!("4. Aggregations with LazyQuery");
    println!("   products.lazy_query().sum_by(Product::price_r())");
    
    let total_value: f64 = products
        .lazy_query()
        .sum_by(Product::price_r());
    
    println!("   Total inventory value: ${:.2}", total_value);
    println!();

    println!("5. Early termination with lazy queries");
    println!("   products.lazy_query().where_(...).first()");
    
    if let Some(first_cheap) = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p < 50.0)
        .first()
    {
        println!("   First cheap product: {} (${:.2})", first_cheap.name, first_cheap.price);
    }
    println!();

    println!("6. Using Query (eager) from rust_queries_core");
    println!("   Query::new(&products).where_(...).count()");
    
    let query3 = Query::new(&products)  // Traditional approach
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query3.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ rust_queries_core provides: Query, LazyQuery, QueryExt");
    println!("✓ rust_queries_derive provides: #[derive(QueryBuilder)]");
    println!("✓ key_paths_derive provides: #[derive(Keypaths)]");
    println!("✓ All features work with individual crates!");
}

examples/derive_and_ext.rs (line 60)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/without_clone.rs (line 78)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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);
    }
}

Additional examples can be found in:

• examples/container_support.rs
• examples/custom_queryable.rs
• examples/sql_comparison.rs
• examples/memory_safety_verification.rs

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

Returns all items matching the query filters.

Example

let results = query.all();

Examples found in repository

examples/individual_crates.rs (line 76)

fn main() {
    println!("Individual Crates Example");
    println!("=========================\n");
    println!("Using rust-queries-core + rust-queries-derive directly\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. QueryExt from rust_queries_core");
    println!("   products.query().where_(price > 100).all()");
    
    let query = products
        .query()  // From QueryExt trait
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. QueryBuilder from rust_queries_derive");
    println!("   Product::query(&products).where_(stock < 10).all()");
    
    let query2 = Product::query(&products)  // From QueryBuilder derive
        .where_(Product::stock_r(), |&s| s < 10);
    let low_stock = query2.all();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. LazyQuery from rust_queries_core");
    println!("   products.lazy_query().where_(...).collect()");
    
    let electronics: Vec<_> = products
        .lazy_query()  // From QueryExt trait
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    
    println!("   Found {} electronics:", electronics.len());
    for product in electronics {
        println!("   - {}", product.name);
    }
    println!();

    println!("4. Aggregations with LazyQuery");
    println!("   products.lazy_query().sum_by(Product::price_r())");
    
    let total_value: f64 = products
        .lazy_query()
        .sum_by(Product::price_r());
    
    println!("   Total inventory value: ${:.2}", total_value);
    println!();

    println!("5. Early termination with lazy queries");
    println!("   products.lazy_query().where_(...).first()");
    
    if let Some(first_cheap) = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p < 50.0)
        .first()
    {
        println!("   First cheap product: {} (${:.2})", first_cheap.name, first_cheap.price);
    }
    println!();

    println!("6. Using Query (eager) from rust_queries_core");
    println!("   Query::new(&products).where_(...).count()");
    
    let query3 = Query::new(&products)  // Traditional approach
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query3.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ rust_queries_core provides: Query, LazyQuery, QueryExt");
    println!("✓ rust_queries_derive provides: #[derive(QueryBuilder)]");
    println!("✓ key_paths_derive provides: #[derive(Keypaths)]");
    println!("✓ All features work with individual crates!");
}

examples/derive_and_ext.rs (line 61)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/without_clone.rs (line 79)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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);
    }
}

Additional examples can be found in:

• examples/container_support.rs
• examples/custom_queryable.rs
• examples/sql_comparison.rs
• examples/memory_safety_verification.rs

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

Returns the first item matching the query filters.

Example

let first = query.first();

Examples found in repository

examples/without_clone.rs (line 102)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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/individual_crates.rs (line 138)

fn main() {
    println!("Individual Crates Example");
    println!("=========================\n");
    println!("Using rust-queries-core + rust-queries-derive directly\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. QueryExt from rust_queries_core");
    println!("   products.query().where_(price > 100).all()");
    
    let query = products
        .query()  // From QueryExt trait
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. QueryBuilder from rust_queries_derive");
    println!("   Product::query(&products).where_(stock < 10).all()");
    
    let query2 = Product::query(&products)  // From QueryBuilder derive
        .where_(Product::stock_r(), |&s| s < 10);
    let low_stock = query2.all();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. LazyQuery from rust_queries_core");
    println!("   products.lazy_query().where_(...).collect()");
    
    let electronics: Vec<_> = products
        .lazy_query()  // From QueryExt trait
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    
    println!("   Found {} electronics:", electronics.len());
    for product in electronics {
        println!("   - {}", product.name);
    }
    println!();

    println!("4. Aggregations with LazyQuery");
    println!("   products.lazy_query().sum_by(Product::price_r())");
    
    let total_value: f64 = products
        .lazy_query()
        .sum_by(Product::price_r());
    
    println!("   Total inventory value: ${:.2}", total_value);
    println!();

    println!("5. Early termination with lazy queries");
    println!("   products.lazy_query().where_(...).first()");
    
    if let Some(first_cheap) = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p < 50.0)
        .first()
    {
        println!("   First cheap product: {} (${:.2})", first_cheap.name, first_cheap.price);
    }
    println!();

    println!("6. Using Query (eager) from rust_queries_core");
    println!("   Query::new(&products).where_(...).count()");
    
    let query3 = Query::new(&products)  // Traditional approach
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query3.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ rust_queries_core provides: Query, LazyQuery, QueryExt");
    println!("✓ rust_queries_derive provides: #[derive(QueryBuilder)]");
    println!("✓ key_paths_derive provides: #[derive(Keypaths)]");
    println!("✓ All features work with individual crates!");
}

examples/derive_and_ext.rs (line 104)

fn main() {
    println!("Derive Macros and Extension Traits Example");
    println!("===========================================\n");

    let products = vec![
        Product {
            id: 1,
            name: "Laptop".to_string(),
            price: 999.99,
            category: "Electronics".to_string(),
            stock: 5,
        },
        Product {
            id: 2,
            name: "Mouse".to_string(),
            price: 29.99,
            category: "Electronics".to_string(),
            stock: 50,
        },
        Product {
            id: 3,
            name: "Keyboard".to_string(),
            price: 79.99,
            category: "Electronics".to_string(),
            stock: 30,
        },
        Product {
            id: 4,
            name: "Monitor".to_string(),
            price: 299.99,
            category: "Electronics".to_string(),
            stock: 12,
        },
        Product {
            id: 5,
            name: "Desk Chair".to_string(),
            price: 199.99,
            category: "Furniture".to_string(),
            stock: 8,
        },
    ];

    println!("1. Using Extension Trait - Direct .query() on Vec");
    println!("   Query: products.query().where_(price > 100).all()");
    
    let query = products
        .query()
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive = query.all();
    
    println!("   Found {} expensive products:", expensive.len());
    for product in &expensive {
        println!("   - {} (${:.2})", product.name, product.price);
    }
    println!();

    println!("2. Using Extension Trait - Direct .lazy_query() on Vec");
    println!("   Query: products.lazy_query().where_(stock < 10).collect()");
    
    let low_stock: Vec<_> = products
        .lazy_query()
        .where_(Product::stock_r(), |&s| s < 10)
        .collect();
    
    println!("   Found {} low stock products:", low_stock.len());
    for product in &low_stock {
        println!("   - {} (stock: {})", product.name, product.stock);
    }
    println!();

    println!("3. Using Extension Trait - Chained Operations");
    println!("   Query: products.lazy_query().where_(category == Electronics).take(2).select(name).collect()");
    
    let names: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .take_lazy(2)
        .select_lazy(Product::name_r())
        .collect();
    
    println!("   First 2 electronics:");
    for name in &names {
        println!("   - {}", name);
    }
    println!();

    println!("4. Using QueryBuilder Derive - Static Methods");
    println!("   Query: Product::query(&products).where_(price > 50).count()");
    
    let query4 = Product::query(&products)
        .where_(Product::price_r(), |&p| p > 50.0);
    let count = query4.count();
    
    println!("   Products over $50: {}", count);
    println!();

    println!("5. Using QueryBuilder Derive - Lazy Static Methods");
    println!("   Query: Product::lazy_query(&products).first()");
    
    if let Some(first) = Product::lazy_query(&products).first() {
        println!("   First product: {} (${:.2})", first.name, first.price);
    }
    println!();

    println!("6. Complex Chain with Extension Trait");
    println!("   Query: products.lazy_query()");
    println!("          .where_(category == Electronics)");
    println!("          .where_(price < 500)");
    println!("          .map(|p| format!(\"{{}} - ${{:.2}}\", p.name, p.price))");
    println!("          .collect()");
    
    let formatted: Vec<String> = products
        .lazy_query()
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .where_(Product::price_r(), |&p| p < 500.0)
        .map_items(|p| format!("{} - ${:.2}", p.name, p.price))
        .collect();
    
    println!("   Affordable electronics:");
    for item in &formatted {
        println!("   - {}", item);
    }
    println!();

    println!("7. Aggregation with Extension Trait");
    println!("   Query: products.lazy_query().sum_by(Product::stock())");
    
    let total_stock = products
        .lazy_query()
        .sum_by(Product::stock_r());
    
    println!("   Total stock across all products: {}", total_stock);
    println!();

    println!("8. Find with Extension Trait");
    println!("   Query: products.lazy_query().find(|p| p.name.contains(\"Chair\"))");
    
    if let Some(chair) = products.lazy_query().find(|p| p.name.contains("Chair")) {
        println!("   Found: {} in {}", chair.name, chair.category);
    }
    println!();

    println!("9. Early Termination with Extension Trait");
    println!("   Query: products.lazy_query().where_(price > 1000).any()");
    
    let has_luxury = products
        .lazy_query()
        .where_(Product::price_r(), |&p| p > 1000.0)
        .any();
    
    println!("   Has products over $1000: {}", has_luxury);
    println!();

    println!("10. Slice Extension Trait");
    println!("    Query: (&products[..]).lazy_query().count()");
    
    let slice_count = (&products[..])
        .lazy_query()
        .count();
    
    println!("    Count from slice: {}", slice_count);
    println!();

    println!("Summary:");
    println!("--------");
    println!("✓ Extension trait QueryExt adds .query() and .lazy_query() to containers");
    println!("✓ Derive macro QueryBuilder adds static methods Product::query() and Product::lazy_query()");
    println!("✓ Both approaches provide the same query functionality");
    println!("✓ Extension trait is more ergonomic: products.query() vs Query::new(&products)");
    println!("✓ All iterator optimizations (fusion, early termination) still apply");
}

examples/without_clone.rs (line 89)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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);
    }
}

Additional examples can be found in:

• examples/container_support.rs
• examples/custom_queryable.rs
• examples/sql_comparison.rs

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/without_clone.rs (line 124)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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/without_clone.rs (line 133)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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 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/without_clone.rs (line 95)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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 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/without_clone.rs (line 110)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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/container_support.rs (line 160)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Container Support Demo                                       ║");
    println!("║  Query various collection types                               ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // ============================================================================
    // CONTAINER 1: Vec<T>
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Container 1: Vec<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let vec_products = vec![
        create_sample_product(1, "Laptop", 999, "Electronics"),
        create_sample_product(2, "Mouse", 29, "Electronics"),
        create_sample_product(3, "Desk", 299, "Furniture"),
    ];

    // Query Vec directly
    let vec_query = Query::new(&vec_products)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let vec_results = vec_query.all();
    println!("  Vec: Found {} electronics", vec_results.len());

    // Lazy query on Vec
    let lazy_count = LazyQuery::new(&vec_products)
        .where_(Product::price_r(), |&p| p < 100)
        .count();
    println!("  Vec (lazy): {} items under $100", lazy_count);

    // ============================================================================
    // CONTAINER 2: VecDeque<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 2: VecDeque<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut deque_products = VecDeque::new();
    deque_products.push_back(create_sample_product(1, "Keyboard", 129, "Electronics"));
    deque_products.push_back(create_sample_product(2, "Monitor", 349, "Electronics"));
    deque_products.push_back(create_sample_product(3, "Chair", 199, "Furniture"));

    // Convert to owned Vec for querying
    let deque_vec: Vec<Product> = deque_products.iter().cloned().collect();
    let deque_query = Query::new(&deque_vec);
    let deque_count = deque_query.count();
    println!("  VecDeque: {} total items", deque_count);

    // More efficient: use make_contiguous for zero-copy slice access
    let contiguous = deque_products.make_contiguous();
    let contiguous_query = Query::new(contiguous);
    println!("  VecDeque (zero-copy): {} items", contiguous_query.count());

    // ============================================================================
    // CONTAINER 3: HashSet<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 3: HashSet<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut set_products = HashSet::new();
    set_products.insert(create_sample_product(1, "Tablet", 499, "Electronics"));
    set_products.insert(create_sample_product(2, "Phone", 799, "Electronics"));
    set_products.insert(create_sample_product(3, "Lamp", 39, "Furniture"));

    // Collect from HashSet to Vec for querying
    let set_vec: Vec<Product> = set_products.iter().cloned().collect();
    let set_query = Query::new(&set_vec)
        .where_(Product::price_r(), |&p| p > 500);
    let expensive = set_query.all();
    println!("  HashSet: {} expensive items", expensive.len());

    // Lazy on HashSet (convert to owned Vec first)
    let set_owned: Vec<Product> = set_products.iter().cloned().collect();
    let lazy_set: Vec<_> = LazyQuery::new(&set_owned)
        .where_(Product::category_r(), |cat| cat == "Electronics")
        .collect();
    println!("  HashSet (lazy): {} electronics", lazy_set.len());

    // ============================================================================
    // CONTAINER 4: BTreeSet<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 4: BTreeSet<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut btree_set = BTreeSet::new();
    btree_set.insert(create_sample_product(1, "Webcam", 79, "Electronics"));
    btree_set.insert(create_sample_product(2, "Microphone", 129, "Electronics"));
    btree_set.insert(create_sample_product(3, "Bookshelf", 149, "Furniture"));

    let btree_vec: Vec<Product> = btree_set.iter().cloned().collect();
    let btree_query = Query::new(&btree_vec);
    println!("  BTreeSet: {} total items (sorted order!)", btree_query.count());
    
    // BTreeSet items are in sorted order
    for (i, item) in btree_vec.iter().take(3).enumerate() {
        println!("    {}. {} (ID: {})", i + 1, item.name, item.id);
    }

    // ============================================================================
    // CONTAINER 5: HashMap<K, V> - Query Values
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 5: HashMap<K, V> - Querying values");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut map_products = HashMap::new();
    map_products.insert("prod1", create_sample_product(1, "Speaker", 199, "Electronics"));
    map_products.insert("prod2", create_sample_product(2, "Headphones", 149, "Electronics"));
    map_products.insert("prod3", create_sample_product(3, "Ottoman", 249, "Furniture"));

    // Query HashMap values (convert to owned Vec)
    let map_vec: Vec<Product> = map_products.values().cloned().collect();
    let map_query = Query::new(&map_vec)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = map_query.all();
    println!("  HashMap: {} electronics", electronics.len());

    // ============================================================================
    // CONTAINER 6: BTreeMap<K, V> - Query Values
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 6: BTreeMap<K, V> - Querying values");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut btree_map = BTreeMap::new();
    btree_map.insert(1, create_sample_product(1, "Router", 89, "Electronics"));
    btree_map.insert(2, create_sample_product(2, "Switch", 129, "Electronics"));
    btree_map.insert(3, create_sample_product(3, "Sofa", 899, "Furniture"));

    let btree_map_vec: Vec<Product> = btree_map.values().cloned().collect();
    let btree_map_query = Query::new(&btree_map_vec);
    let avg_price = btree_map_query.sum(Product::price_r()) as f64 / btree_map.len() as f64;
    println!("  BTreeMap: Average price ${:.2}", avg_price);

    // ============================================================================
    // CONTAINER 7: Arrays [T; N]
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 7: Arrays [T; N]");
    println!("═══════════════════════════════════════════════════════════════\n");

    let array_products = [
        create_sample_product(1, "USB Cable", 15, "Electronics"),
        create_sample_product(2, "HDMI Cable", 25, "Electronics"),
        create_sample_product(3, "Power Strip", 35, "Electronics"),
    ];

    // Query array directly (as slice)
    let array_query = Query::new(&array_products);
    let total = array_query.sum(Product::price_r());
    println!("  Array: Total value ${}", total);

    // Lazy on array
    let lazy_array: Vec<_> = LazyQuery::new(&array_products)
        .where_(Product::price_r(), |&p| p > 20)
        .collect();
    println!("  Array (lazy): {} items over $20", lazy_array.len());

    // ============================================================================
    // CONTAINER 8: LinkedList<T>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 8: LinkedList<T>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut list_products = LinkedList::new();
    list_products.push_back(create_sample_product(1, "SSD", 159, "Electronics"));
    list_products.push_back(create_sample_product(2, "HDD", 79, "Electronics"));

    let list_vec: Vec<Product> = list_products.iter().cloned().collect();
    let list_query = Query::new(&list_vec);
    println!("  LinkedList: {} items", list_query.count());

    // ============================================================================
    // CONTAINER 9: Option<T> and Result<T, E>
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Container 9: Option<T> and Result<T, E>");
    println!("═══════════════════════════════════════════════════════════════\n");

    let maybe_product = Some(create_sample_product(1, "Mystery Box", 99, "Special"));
    
    if let Some(ref product) = maybe_product {
        let option_query = Query::new(std::slice::from_ref(product));
        println!("  Option (Some): {} items", option_query.count());
    }

    let none_product: Option<Product> = None;
    let none_count = none_product.iter().count();
    println!("  Option (None): {} items", none_count);

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Supported Containers Summary                                  ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ Supported container types:");
    println!("   • Vec<T>              - Standard vector");
    println!("   • &[T]                - Slices");
    println!("   • [T; N]              - Fixed-size arrays");
    println!("   • VecDeque<T>         - Double-ended queue");
    println!("   • LinkedList<T>       - Doubly-linked list");
    println!("   • HashSet<T>          - Unordered set");
    println!("   • BTreeSet<T>         - Ordered set");
    println!("   • HashMap<K, V>       - Query values");
    println!("   • BTreeMap<K, V>      - Query values (sorted)");
    println!("   • Option<T>           - 0 or 1 item");
    println!("   • Result<T, E>        - 0 or 1 item\n");

    println!("📝 Usage patterns:");
    println!("   • Direct: Query::new(&container) for Vec, slices, arrays");
    println!("   • Convert: Collect to Vec for Sets and Maps");
    println!("   • Lazy: LazyQuery::new(&slice) for any slice\n");

    println!("💡 Tips:");
    println!("   • Vec/slice: Direct support, most efficient");
    println!("   • Sets: Iterate to Vec, then query");
    println!("   • Maps: Use .values().collect() to query values");
    println!("   • VecDeque: Use .as_slices() for zero-copy");
    println!("   • For custom types: Implement Queryable trait\n");

    println!("✓ Container support demo complete!\n");
}

examples/custom_queryable.rs (line 371)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Custom Queryable Implementation Demo                         ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // ============================================================================
    // DEMO 1: PaginatedCollection
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 1: PaginatedCollection (custom container)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut paginated = PaginatedCollection::new(3); // 3 items per page
    
    paginated.add(create_sample_product(1, "Laptop", 999.0, "Electronics", true));
    paginated.add(create_sample_product(2, "Mouse", 29.0, "Electronics", true));
    paginated.add(create_sample_product(3, "Keyboard", 129.0, "Electronics", true));
    paginated.add(create_sample_product(4, "Desk", 299.0, "Furniture", true));
    paginated.add(create_sample_product(5, "Chair", 199.0, "Furniture", false));

    println!("  Created paginated collection:");
    println!("    Total items: {}", paginated.total_items());
    println!("    Pages: {}", paginated.pages.len());

    // Now we can query it using the Queryable trait!
    // Collect to owned Vec for querying
    let items: Vec<Product> = paginated.query_iter().cloned().collect();
    let query = Query::new(&items)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query.all();
    
    println!("\n  Querying paginated collection:");
    println!("    Electronics found: {}", electronics.len());
    for product in electronics {
        println!("      • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // DEMO 2: CircularBuffer
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 2: CircularBuffer (fixed capacity)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut circular = CircularBuffer::new(3); // Capacity: 3
    
    circular.push(create_sample_product(1, "Product 1", 100.0, "A", true));
    circular.push(create_sample_product(2, "Product 2", 200.0, "B", true));
    circular.push(create_sample_product(3, "Product 3", 300.0, "C", true));
    circular.push(create_sample_product(4, "Product 4", 400.0, "D", true)); // Pushes out Product 1

    println!("  Circular buffer (capacity 3, added 4 items):");
    println!("    Current size: {}", circular.len());

    // Query the circular buffer
    let circ_items: Vec<Product> = circular.query_iter().cloned().collect();
    let circ_query = Query::new(&circ_items);
    let avg_price = circ_query.avg(Product::price_r()).unwrap_or(0.0);
    
    println!("\n  Querying circular buffer:");
    println!("    Average price: ${:.2}", avg_price);
    println!("    Items:");
    for (i, product) in circ_items.iter().enumerate() {
        println!("      {}. {}: ${:.2}", i + 1, product.name, product.price);
    }

    // ============================================================================
    // DEMO 3: FilteredStorage
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 3: FilteredStorage (auto-filtering container)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut filtered = FilteredStorage::new(|p: &Product| p.price < 200.0);
    
    println!("  FilteredStorage (only accepts items < $200):");
    println!("    Adding Laptop ($999): {}", filtered.add(create_sample_product(1, "Laptop", 999.0, "Electronics", true)));
    println!("    Adding Mouse ($29): {}", filtered.add(create_sample_product(2, "Mouse", 29.0, "Electronics", true)));
    println!("    Adding Keyboard ($129): {}", filtered.add(create_sample_product(3, "Keyboard", 129.0, "Electronics", true)));
    println!("    Total stored: {}", filtered.len());

    // Query the filtered storage
    let filt_items: Vec<Product> = filtered.query_iter().cloned().collect();
    let filt_query = Query::new(&filt_items)
        .where_(Product::in_stock_r(), |&v| v);
    let in_stock = filt_query.all();
    
    println!("\n  Querying filtered storage:");
    println!("    In stock items: {}", in_stock.len());

    // ============================================================================
    // DEMO 4: CategoryIndex
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 4: CategoryIndex (indexed by category)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut category_index = CategoryIndex::new();
    
    category_index.add("Electronics".to_string(), create_sample_product(1, "Monitor", 349.0, "Electronics", true));
    category_index.add("Electronics".to_string(), create_sample_product(2, "Webcam", 79.0, "Electronics", true));
    category_index.add("Furniture".to_string(), create_sample_product(3, "Desk", 299.0, "Furniture", true));
    category_index.add("Furniture".to_string(), create_sample_product(4, "Lamp", 39.0, "Furniture", true));

    println!("  CategoryIndex:");
    println!("    Categories: {:?}", category_index.categories());
    println!("    Total items: {}", category_index.total_items());

    // Query across all categories
    let idx_items: Vec<Product> = category_index.query_iter().cloned().collect();
    let idx_query = Query::new(&idx_items);
    let expensive = idx_query
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive_items = expensive.all();
    
    println!("\n  Querying category index:");
    println!("    Expensive items (>$100): {}", expensive_items.len());
    for product in expensive_items {
        println!("      • {}: ${:.2} ({})", product.name, product.price, product.category);
    }

    // ============================================================================
    // DEMO 5: LazyLoader
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 5: LazyLoader (simulated lazy loading)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let loader = LazyLoader::new(vec![
        create_sample_product(1, "Item 1", 50.0, "A", true),
        create_sample_product(2, "Item 2", 150.0, "B", true),
        create_sample_product(3, "Item 3", 250.0, "C", true),
    ]);

    println!("  LazyLoader:");
    println!("    Total available: {}", loader.total_count());
    println!("    Currently loaded: {}", loader.loaded_count());

    // Query loaded items
    let loader_items: Vec<Product> = loader.query_iter().cloned().collect();
    let loader_query = Query::new(&loader_items);
    let total_value = loader_query.sum(Product::price_r());
    
    println!("\n  Querying lazy loader:");
    println!("    Total value: ${:.2}", total_value);

    // ============================================================================
    // DEMO 6: Custom Container with LazyQuery
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 6: Using LazyQuery with custom containers");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut circular = CircularBuffer::new(5);
    for i in 1..=10 {
        circular.push(create_sample_product(
            i,
            &format!("Product {}", i),
            i as f64 * 50.0,
            if i % 2 == 0 { "Even" } else { "Odd" },
            true,
        ));
    }

    println!("  Circular buffer (capacity 5, added 10 items):");
    println!("    Current size: {}", circular.len());

    // Use LazyQuery for early termination!
    let circ_vec: Vec<Product> = circular.query_iter().cloned().collect();
    let first_expensive = LazyQuery::new(&circ_vec)
        .where_(Product::price_r(), |&p| p > 300.0)
        .first();

    if let Some(product) = first_expensive {
        println!("\n  First expensive item (lazy query):");
        println!("    {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // DEMO 7: Implementing Queryable for Wrapper Types
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 7: Queryable for wrapper types");
    println!("═══════════════════════════════════════════════════════════════\n");

    /// A simple wrapper around Vec with metadata
    struct VersionedCollection<T> {
        items: Vec<T>,
        version: u32,
        last_modified: String,
    }

    impl<T> Queryable<T> for VersionedCollection<T> {
        fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {
            Box::new(self.items.iter())
        }
    }

    let versioned = VersionedCollection {
        items: vec![
            create_sample_product(1, "V1 Product", 99.0, "Test", true),
            create_sample_product(2, "V2 Product", 199.0, "Test", true),
        ],
        version: 2,
        last_modified: "2025-10-11".to_string(),
    };

    println!("  VersionedCollection:");
    println!("    Version: {}", versioned.version);
    println!("    Last modified: {}", versioned.last_modified);

    let versioned_items: Vec<Product> = versioned.query_iter().cloned().collect();
    let query = Query::new(&versioned_items);
    println!("    Items: {}", query.count());

    // ============================================================================
    // DEMO 8: Real-World Example - Cache with TTL
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 8: Cache container (real-world example)");
    println!("═══════════════════════════════════════════════════════════════\n");

    use std::time::{Duration, SystemTime};

    struct CachedItem<T> {
        item: T,
        inserted_at: SystemTime,
        ttl: Duration,
    }

    struct Cache<T> {
        items: Vec<CachedItem<T>>,
    }

    impl<T> Cache<T> {
        fn new() -> Self {
            Self { items: Vec::new() }
        }

        fn insert(&mut self, item: T, ttl: Duration) {
            self.items.push(CachedItem {
                item,
                inserted_at: SystemTime::now(),
                ttl,
            });
        }

        fn valid_items(&self) -> Vec<&T> {
            let now = SystemTime::now();
            self.items
                .iter()
                .filter(|cached| {
                    now.duration_since(cached.inserted_at)
                        .map_or(false, |elapsed| elapsed < cached.ttl)
                })
                .map(|cached| &cached.item)
                .collect()
        }
    }

    // Implement Queryable to query only valid (non-expired) items
    impl<T> Queryable<T> for Cache<T> {
        fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {
            let now = SystemTime::now();
            Box::new(
                self.items
                    .iter()
                    .filter(move |cached| {
                        now.duration_since(cached.inserted_at)
                            .map_or(false, |elapsed| elapsed < cached.ttl)
                    })
                    .map(|cached| &cached.item),
            )
        }
    }

    let mut cache = Cache::new();
    cache.insert(create_sample_product(1, "Cached Item 1", 100.0, "A", true), Duration::from_secs(60));
    cache.insert(create_sample_product(2, "Cached Item 2", 200.0, "B", true), Duration::from_secs(60));

    let valid = cache.valid_items();
    println!("  Cache:");
    println!("    Total items: {}", cache.items.len());
    println!("    Valid items: {}", valid.len());

    // Query the cache
    let cache_items: Vec<Product> = cache.query_iter().cloned().collect();
    let cache_query = Query::new(&cache_items);
    println!("    Queryable items: {}", cache_query.count());

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: Implementing Queryable                              ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ How to make any container queryable:\n");
    println!("  1. Implement the Queryable<T> trait:");
    println!("     ```rust");
    println!("     impl<T> Queryable<T> for MyContainer<T> {{");
    println!("         fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {{");
    println!("             Box::new(self.items.iter())");
    println!("         }}");
    println!("     }}");
    println!("     ```\n");

    println!("  2. Convert to Vec or slice for querying:");
    println!("     ```rust");
    println!("     let items: Vec<&Product> = container.query_iter().collect();");
    println!("     let query = Query::new(&items);");
    println!("     ```\n");

    println!("  3. Now use all query operations:");
    println!("     ```rust");
    println!("     let results = query.where_(...).all();");
    println!("     let count = query.count();");
    println!("     let total = query.sum(field);");
    println!("     ```\n");

    println!("📝 Custom containers demonstrated:");
    println!("   • PaginatedCollection - Items stored in pages");
    println!("   • CircularBuffer - Fixed-capacity FIFO buffer");
    println!("   • FilteredStorage - Auto-filtering container");
    println!("   • CategoryIndex - Indexed by category");
    println!("   • LazyLoader - Simulated lazy loading");
    println!("   • VersionedCollection - Wrapper with metadata");
    println!("   • Cache - TTL-based cache\n");

    println!("💡 Use cases:");
    println!("   • Database result wrappers");
    println!("   • Custom data structures");
    println!("   • Specialized collections");
    println!("   • Caches and buffers");
    println!("   • Event streams");
    println!("   • Any container that holds items!\n");

    println!("✓ Custom Queryable demo complete!\n");
}

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/without_clone.rs (line 111)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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/custom_queryable.rs (line 287)

fn main() {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Custom Queryable Implementation Demo                         ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    // ============================================================================
    // DEMO 1: PaginatedCollection
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Demo 1: PaginatedCollection (custom container)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut paginated = PaginatedCollection::new(3); // 3 items per page
    
    paginated.add(create_sample_product(1, "Laptop", 999.0, "Electronics", true));
    paginated.add(create_sample_product(2, "Mouse", 29.0, "Electronics", true));
    paginated.add(create_sample_product(3, "Keyboard", 129.0, "Electronics", true));
    paginated.add(create_sample_product(4, "Desk", 299.0, "Furniture", true));
    paginated.add(create_sample_product(5, "Chair", 199.0, "Furniture", false));

    println!("  Created paginated collection:");
    println!("    Total items: {}", paginated.total_items());
    println!("    Pages: {}", paginated.pages.len());

    // Now we can query it using the Queryable trait!
    // Collect to owned Vec for querying
    let items: Vec<Product> = paginated.query_iter().cloned().collect();
    let query = Query::new(&items)
        .where_(Product::category_r(), |cat| cat == "Electronics");
    let electronics = query.all();
    
    println!("\n  Querying paginated collection:");
    println!("    Electronics found: {}", electronics.len());
    for product in electronics {
        println!("      • {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // DEMO 2: CircularBuffer
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 2: CircularBuffer (fixed capacity)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut circular = CircularBuffer::new(3); // Capacity: 3
    
    circular.push(create_sample_product(1, "Product 1", 100.0, "A", true));
    circular.push(create_sample_product(2, "Product 2", 200.0, "B", true));
    circular.push(create_sample_product(3, "Product 3", 300.0, "C", true));
    circular.push(create_sample_product(4, "Product 4", 400.0, "D", true)); // Pushes out Product 1

    println!("  Circular buffer (capacity 3, added 4 items):");
    println!("    Current size: {}", circular.len());

    // Query the circular buffer
    let circ_items: Vec<Product> = circular.query_iter().cloned().collect();
    let circ_query = Query::new(&circ_items);
    let avg_price = circ_query.avg(Product::price_r()).unwrap_or(0.0);
    
    println!("\n  Querying circular buffer:");
    println!("    Average price: ${:.2}", avg_price);
    println!("    Items:");
    for (i, product) in circ_items.iter().enumerate() {
        println!("      {}. {}: ${:.2}", i + 1, product.name, product.price);
    }

    // ============================================================================
    // DEMO 3: FilteredStorage
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 3: FilteredStorage (auto-filtering container)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut filtered = FilteredStorage::new(|p: &Product| p.price < 200.0);
    
    println!("  FilteredStorage (only accepts items < $200):");
    println!("    Adding Laptop ($999): {}", filtered.add(create_sample_product(1, "Laptop", 999.0, "Electronics", true)));
    println!("    Adding Mouse ($29): {}", filtered.add(create_sample_product(2, "Mouse", 29.0, "Electronics", true)));
    println!("    Adding Keyboard ($129): {}", filtered.add(create_sample_product(3, "Keyboard", 129.0, "Electronics", true)));
    println!("    Total stored: {}", filtered.len());

    // Query the filtered storage
    let filt_items: Vec<Product> = filtered.query_iter().cloned().collect();
    let filt_query = Query::new(&filt_items)
        .where_(Product::in_stock_r(), |&v| v);
    let in_stock = filt_query.all();
    
    println!("\n  Querying filtered storage:");
    println!("    In stock items: {}", in_stock.len());

    // ============================================================================
    // DEMO 4: CategoryIndex
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 4: CategoryIndex (indexed by category)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut category_index = CategoryIndex::new();
    
    category_index.add("Electronics".to_string(), create_sample_product(1, "Monitor", 349.0, "Electronics", true));
    category_index.add("Electronics".to_string(), create_sample_product(2, "Webcam", 79.0, "Electronics", true));
    category_index.add("Furniture".to_string(), create_sample_product(3, "Desk", 299.0, "Furniture", true));
    category_index.add("Furniture".to_string(), create_sample_product(4, "Lamp", 39.0, "Furniture", true));

    println!("  CategoryIndex:");
    println!("    Categories: {:?}", category_index.categories());
    println!("    Total items: {}", category_index.total_items());

    // Query across all categories
    let idx_items: Vec<Product> = category_index.query_iter().cloned().collect();
    let idx_query = Query::new(&idx_items);
    let expensive = idx_query
        .where_(Product::price_r(), |&p| p > 100.0);
    let expensive_items = expensive.all();
    
    println!("\n  Querying category index:");
    println!("    Expensive items (>$100): {}", expensive_items.len());
    for product in expensive_items {
        println!("      • {}: ${:.2} ({})", product.name, product.price, product.category);
    }

    // ============================================================================
    // DEMO 5: LazyLoader
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 5: LazyLoader (simulated lazy loading)");
    println!("═══════════════════════════════════════════════════════════════\n");

    let loader = LazyLoader::new(vec![
        create_sample_product(1, "Item 1", 50.0, "A", true),
        create_sample_product(2, "Item 2", 150.0, "B", true),
        create_sample_product(3, "Item 3", 250.0, "C", true),
    ]);

    println!("  LazyLoader:");
    println!("    Total available: {}", loader.total_count());
    println!("    Currently loaded: {}", loader.loaded_count());

    // Query loaded items
    let loader_items: Vec<Product> = loader.query_iter().cloned().collect();
    let loader_query = Query::new(&loader_items);
    let total_value = loader_query.sum(Product::price_r());
    
    println!("\n  Querying lazy loader:");
    println!("    Total value: ${:.2}", total_value);

    // ============================================================================
    // DEMO 6: Custom Container with LazyQuery
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 6: Using LazyQuery with custom containers");
    println!("═══════════════════════════════════════════════════════════════\n");

    let mut circular = CircularBuffer::new(5);
    for i in 1..=10 {
        circular.push(create_sample_product(
            i,
            &format!("Product {}", i),
            i as f64 * 50.0,
            if i % 2 == 0 { "Even" } else { "Odd" },
            true,
        ));
    }

    println!("  Circular buffer (capacity 5, added 10 items):");
    println!("    Current size: {}", circular.len());

    // Use LazyQuery for early termination!
    let circ_vec: Vec<Product> = circular.query_iter().cloned().collect();
    let first_expensive = LazyQuery::new(&circ_vec)
        .where_(Product::price_r(), |&p| p > 300.0)
        .first();

    if let Some(product) = first_expensive {
        println!("\n  First expensive item (lazy query):");
        println!("    {}: ${:.2}", product.name, product.price);
    }

    // ============================================================================
    // DEMO 7: Implementing Queryable for Wrapper Types
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 7: Queryable for wrapper types");
    println!("═══════════════════════════════════════════════════════════════\n");

    /// A simple wrapper around Vec with metadata
    struct VersionedCollection<T> {
        items: Vec<T>,
        version: u32,
        last_modified: String,
    }

    impl<T> Queryable<T> for VersionedCollection<T> {
        fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {
            Box::new(self.items.iter())
        }
    }

    let versioned = VersionedCollection {
        items: vec![
            create_sample_product(1, "V1 Product", 99.0, "Test", true),
            create_sample_product(2, "V2 Product", 199.0, "Test", true),
        ],
        version: 2,
        last_modified: "2025-10-11".to_string(),
    };

    println!("  VersionedCollection:");
    println!("    Version: {}", versioned.version);
    println!("    Last modified: {}", versioned.last_modified);

    let versioned_items: Vec<Product> = versioned.query_iter().cloned().collect();
    let query = Query::new(&versioned_items);
    println!("    Items: {}", query.count());

    // ============================================================================
    // DEMO 8: Real-World Example - Cache with TTL
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Demo 8: Cache container (real-world example)");
    println!("═══════════════════════════════════════════════════════════════\n");

    use std::time::{Duration, SystemTime};

    struct CachedItem<T> {
        item: T,
        inserted_at: SystemTime,
        ttl: Duration,
    }

    struct Cache<T> {
        items: Vec<CachedItem<T>>,
    }

    impl<T> Cache<T> {
        fn new() -> Self {
            Self { items: Vec::new() }
        }

        fn insert(&mut self, item: T, ttl: Duration) {
            self.items.push(CachedItem {
                item,
                inserted_at: SystemTime::now(),
                ttl,
            });
        }

        fn valid_items(&self) -> Vec<&T> {
            let now = SystemTime::now();
            self.items
                .iter()
                .filter(|cached| {
                    now.duration_since(cached.inserted_at)
                        .map_or(false, |elapsed| elapsed < cached.ttl)
                })
                .map(|cached| &cached.item)
                .collect()
        }
    }

    // Implement Queryable to query only valid (non-expired) items
    impl<T> Queryable<T> for Cache<T> {
        fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {
            let now = SystemTime::now();
            Box::new(
                self.items
                    .iter()
                    .filter(move |cached| {
                        now.duration_since(cached.inserted_at)
                            .map_or(false, |elapsed| elapsed < cached.ttl)
                    })
                    .map(|cached| &cached.item),
            )
        }
    }

    let mut cache = Cache::new();
    cache.insert(create_sample_product(1, "Cached Item 1", 100.0, "A", true), Duration::from_secs(60));
    cache.insert(create_sample_product(2, "Cached Item 2", 200.0, "B", true), Duration::from_secs(60));

    let valid = cache.valid_items();
    println!("  Cache:");
    println!("    Total items: {}", cache.items.len());
    println!("    Valid items: {}", valid.len());

    // Query the cache
    let cache_items: Vec<Product> = cache.query_iter().cloned().collect();
    let cache_query = Query::new(&cache_items);
    println!("    Queryable items: {}", cache_query.count());

    // ============================================================================
    // Summary
    // ============================================================================
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║  Summary: Implementing Queryable                              ║");
    println!("╚════════════════════════════════════════════════════════════════╝\n");

    println!("✅ How to make any container queryable:\n");
    println!("  1. Implement the Queryable<T> trait:");
    println!("     ```rust");
    println!("     impl<T> Queryable<T> for MyContainer<T> {{");
    println!("         fn query_iter(&self) -> Box<dyn Iterator<Item = &T> + '_> {{");
    println!("             Box::new(self.items.iter())");
    println!("         }}");
    println!("     }}");
    println!("     ```\n");

    println!("  2. Convert to Vec or slice for querying:");
    println!("     ```rust");
    println!("     let items: Vec<&Product> = container.query_iter().collect();");
    println!("     let query = Query::new(&items);");
    println!("     ```\n");

    println!("  3. Now use all query operations:");
    println!("     ```rust");
    println!("     let results = query.where_(...).all();");
    println!("     let count = query.count();");
    println!("     let total = query.sum(field);");
    println!("     ```\n");

    println!("📝 Custom containers demonstrated:");
    println!("   • PaginatedCollection - Items stored in pages");
    println!("   • CircularBuffer - Fixed-capacity FIFO buffer");
    println!("   • FilteredStorage - Auto-filtering container");
    println!("   • CategoryIndex - Indexed by category");
    println!("   • LazyLoader - Simulated lazy loading");
    println!("   • VersionedCollection - Wrapper with metadata");
    println!("   • Cache - TTL-based cache\n");

    println!("💡 Use cases:");
    println!("   • Database result wrappers");
    println!("   • Custom data structures");
    println!("   • Specialized collections");
    println!("   • Caches and buffers");
    println!("   • Event streams");
    println!("   • Any container that holds items!\n");

    println!("✓ Custom Queryable demo complete!\n");
}

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/without_clone.rs (line 117)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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/without_clone.rs (line 118)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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/without_clone.rs (line 143)

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║  Query Builder Without Clone - Performance Optimization   ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    let employees = vec![
        Employee {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 95000.0,
            large_data: vec![0; 1000], // Large data - expensive to clone!
        },
        Employee {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
            department: "Engineering".to_string(),
            salary: 87000.0,
            large_data: vec![0; 1000],
        },
        Employee {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@example.com".to_string(),
            department: "Sales".to_string(),
            salary: 75000.0,
            large_data: vec![0; 1000],
        },
    ];

    let departments = vec![
        Department {
            id: 1,
            name: "Engineering".to_string(),
            budget: 1000000.0,
        },
        Department {
            id: 2,
            name: "Sales".to_string(),
            budget: 500000.0,
        },
    ];

    println!("✅ Operations that DON'T require Clone:\n");

    // 1. WHERE filtering - returns Vec<&T>
    println!("1. WHERE filtering (returns references)");
    let query = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Engineering");
    let engineering = query.all();
    println!("   Found {} engineering employees", engineering.len());
    for emp in &engineering {
        println!("     - {}: ${:.0}", emp.name, emp.salary);
    }

    // 2. COUNT - no cloning needed
    println!("\n2. COUNT aggregation");
    let count = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 80000.0)
        .count();
    println!("   {} employees earn over $80k", count);

    // 3. SELECT - only clones the selected field
    println!("\n3. SELECT (only selected fields are cloned)");
    let names: Vec<String> = Query::new(&employees)
        .select(Employee::name_r());
    println!("   Employee names: {:?}", names);

    // 4. FIRST - returns Option<&T>
    println!("\n4. FIRST (returns reference)");
    let query = Query::new(&employees)
        .where_(Employee::salary_r(), |&sal| sal > 90000.0);
    if let Some(emp) = query.first() {
        println!("   First high earner: {} (${:.0})", emp.name, emp.salary);
    }

    // 5. SUM/AVG aggregations - no cloning
    println!("\n5. Aggregations (SUM/AVG)");
    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);
    println!("   Engineering total: ${:.0}", total);
    println!("   Engineering average: ${:.0}", avg);

    // 6. MIN/MAX - no cloning
    println!("\n6. MIN/MAX");
    let min = Query::new(&employees).min_float(Employee::salary_r());
    let max = Query::new(&employees).max_float(Employee::salary_r());
    println!("   Salary range: ${:.0} - ${:.0}", min.unwrap(), max.unwrap());

    // 7. LIMIT - returns Vec<&T>
    println!("\n7. LIMIT (returns references)");
    let query = Query::new(&employees);
    let first_two = query.limit(2);
    println!("   First 2 employees:");
    for emp in &first_two {
        println!("     - {}", emp.name);
    }

    // 8. SKIP/Pagination - returns Vec<&T>
    println!("\n8. SKIP/Pagination (returns references)");
    let query = Query::new(&employees);
    let page_2 = query.skip(2).limit(1);
    println!("   Page 2:");
    for emp in &page_2 {
        println!("     - {}", emp.name);
    }

    // 9. EXISTS - just checks
    println!("\n9. EXISTS check");
    let has_sales = Query::new(&employees)
        .where_(Employee::department_r(), |dept| dept == "Sales")
        .exists();
    println!("   Has Sales employees: {}", has_sales);

    // 10. JOIN - no Clone required on L or R!
    println!("\n10. JOIN operations (no Clone required!)");
    let results = JoinQuery::new(&employees, &departments)
        .inner_join(
            Employee::department_r(),
            Department::name_r(),
            |emp, dept| {
                // Mapper only clones what it needs for the result
                (emp.name.clone(), dept.budget)
            },
        );
    println!("   Employee-Department pairs:");
    for (name, budget) in &results {
        println!("     - {} works in dept with ${:.0} budget", name, budget);
    }

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Operations that REQUIRE Clone (only when needed)         ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("⚠️  The following operations require Clone because they return owned Vec<T>:");
    println!("   - order_by() / order_by_desc()");
    println!("   - order_by_float() / order_by_float_desc()");
    println!("   - group_by()");
    println!("\n   To use these, add #[derive(Clone)] to your struct:");
    println!("   ```rust");
    println!("   #[derive(Clone, Keypaths)]  // Add Clone here");
    println!("   struct Employee {{ ... }}");
    println!("   ```");

    println!("\n╔════════════════════════════════════════════════════════════╗");
    println!("║  Performance Benefits                                      ║");
    println!("╚════════════════════════════════════════════════════════════╝\n");

    println!("✅ Zero cloning for most operations");
    println!("✅ Work with large structs efficiently");
    println!("✅ No unnecessary memory allocations");
    println!("✅ Only clone when you actually need owned data");
    println!("✅ Pay for what you use");

    println!("\n✓ Example complete! Most operations work without Clone.\n");
}

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!");
}

pub fn where_after_systemtime( self, path: KeyPaths<T, SystemTime>, reference: SystemTime, ) -> Query<'a, T>

Filter by SystemTime being after a reference time.

Arguments

• path - The key-path to the SystemTime field
• reference - The reference time to compare against

Example

let recent = query.where_after_systemtime(Event::timestamp_r(), &cutoff_time);

pub fn where_before_systemtime( self, path: KeyPaths<T, SystemTime>, reference: SystemTime, ) -> Query<'a, T>

Filter by SystemTime being before a reference time.

Arguments

• path - The key-path to the SystemTime field
• reference - The reference time to compare against

Example

let old = query.where_before_systemtime(Event::timestamp_r(), &cutoff_time);

pub fn where_between_systemtime( self, path: KeyPaths<T, SystemTime>, start: SystemTime, end: SystemTime, ) -> Query<'a, T>

Filter by SystemTime being between two times (inclusive).

Arguments

• path - The key-path to the SystemTime field
• start - The start time
• end - The end time

Example

let range = query.where_between_systemtime(Event::timestamp_r(), &start, &end);

impl<'a, T> Query<'a, T>

where T: 'static + Clone,

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.

Note: This method requires T: Clone as it creates owned sorted copies.

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.

Note: This method requires T: Clone as it creates owned sorted copies.

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.

Note: This method requires T: Clone as it creates owned sorted copies.

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.

Note: This method requires T: Clone as it creates owned sorted copies.

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!();
}

examples/memory_safety_verification.rs (line 199)

fn main() {
    println!("\n╔═══════════════════════════════════════════════════════════════╗");
    println!("║  Memory Safety Verification                                   ║");
    println!("║  Proving 'static doesn't cause memory leaks                   ║");
    println!("╚═══════════════════════════════════════════════════════════════╝\n");

    println!("🔍 Understanding 'static:\n");
    println!("  • T: 'static means: Type T doesn't contain non-'static references");
    println!("  • It does NOT mean: Data lives for entire program");
    println!("  • It's needed for: Storing types in trait objects");
    println!("  • Safety: Compiler ensures no dangling references\n");

    // ============================================================================
    // TEST 1: Basic Query - Verify Cleanup
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Test 1: Basic WHERE query - verify all data is dropped");
    println!("═══════════════════════════════════════════════════════════════\n");

    reset_stats();
    {
        let employees = vec![
            create_employee(1, "Alice", "Engineering", 95000.0),
            create_employee(2, "Bob", "Engineering", 87000.0),
            create_employee(3, "Carol", "Sales", 75000.0),
        ];
        print_memory_status("After creating employees");

        {
            let query = Query::new(&employees)
                .where_(Employee::department_r(), |dept| dept == "Engineering");
            let results = query.all();
            
            println!("  Found {} engineering employees", results.len());
            print_memory_status("During query execution");
        }
        
        print_memory_status("After query scope ends");
    }
    
    print_memory_status("After employees scope ends");
    println!();

    // ============================================================================
    // TEST 2: Multiple Queries - No Accumulation
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Test 2: Multiple queries - verify no memory accumulation");
    println!("═══════════════════════════════════════════════════════════════\n");

    reset_stats();
    {
        let employees = vec![
            create_employee(1, "Alice", "Engineering", 95000.0),
            create_employee(2, "Bob", "Sales", 75000.0),
        ];

        let initial_stats = get_stats();
        println!("  Initial allocations: {}", initial_stats.0);

        // Run 10 queries
        for i in 1..=10 {
            let query = Query::new(&employees)
                .where_(Employee::salary_r(), |&s| s > 70000.0);
            let _results = query.all();
            
            if i % 3 == 0 {
                let (allocs, drops) = get_stats();
                println!("  After {} queries - Allocated: {}, Dropped: {}", i, allocs, drops);
            }
        }

        let final_stats = get_stats();
        println!("\n  After 10 queries:");
        println!("    Allocations: {} (should be same as initial)", final_stats.0);
        println!("    ✅ No memory accumulation from queries!");
    }

    print_memory_status("After all queries and employees dropped");
    println!();

    // ============================================================================
    // TEST 3: ORDER BY (requires Clone) - Track Cloning
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Test 3: ORDER BY (with Clone) - verify controlled cloning");
    println!("═══════════════════════════════════════════════════════════════\n");

    reset_stats();
    {
        let employees = vec![
            create_employee(1, "Alice", "Engineering", 95000.0),
            create_employee(2, "Bob", "Sales", 87000.0),
            create_employee(3, "Carol", "Marketing", 75000.0),
        ];
        
        let (before_allocs, _) = get_stats();
        println!("  Before sorting: {} allocations", before_allocs);

        {
            let sorted = Query::new(&employees)
                .order_by_float_desc(Employee::salary_r());
            
            let (after_allocs, _) = get_stats();
            println!("  After sorting: {} allocations", after_allocs);
            println!("  Cloned items: {} (expected: {})", after_allocs - before_allocs, employees.len());
            println!("  Sorted {} employees by salary", sorted.len());
            
            // sorted goes out of scope here
        }
        
        print_memory_status("After sorted results dropped");
    }
    
    print_memory_status("After employees dropped");
    println!();

    // ============================================================================
    // TEST 4: JOIN Operations - No Leaks
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Test 4: JOIN operations - verify no memory leaks");
    println!("═══════════════════════════════════════════════════════════════\n");

    #[derive(Keypaths)]
    struct Department {
        id: u32,
        name: String,
        drop_tracker: DropTracker,
    }

    reset_stats();
    {
        let employees = vec![
            create_employee(1, "Alice", "Engineering", 95000.0),
            create_employee(2, "Bob", "Sales", 87000.0),
        ];

        let departments = vec![
            Department {
                id: 1,
                name: "Engineering".to_string(),
                drop_tracker: DropTracker::new(),
            },
            Department {
                id: 2,
                name: "Sales".to_string(),
                drop_tracker: DropTracker::new(),
            },
        ];

        print_memory_status("After creating data");

        {
            let results = JoinQuery::new(&employees, &departments)
                .inner_join(
                    Employee::department_r(),
                    Department::name_r(),
                    |emp, dept| (emp.name.clone(), dept.name.clone()),
                );
            
            println!("  Joined {} pairs", results.len());
            print_memory_status("During join results");
        }

        print_memory_status("After join results dropped");
    }

    print_memory_status("After all data dropped");
    println!();

    // ============================================================================
    // TEST 5: Large Scale - Memory Behavior
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Test 5: Large scale (1000 items) - verify cleanup");
    println!("═══════════════════════════════════════════════════════════════\n");

    reset_stats();
    {
        let mut large_dataset = Vec::new();
        for i in 0..1000 {
            large_dataset.push(create_employee(
                i,
                &format!("Employee {}", i),
                if i % 3 == 0 { "Engineering" } else if i % 3 == 1 { "Sales" } else { "Marketing" },
                50000.0 + (i as f64 * 100.0),
            ));
        }

        let (initial_allocs, _) = get_stats();
        println!("  Created 1000 employees: {} allocations (~10MB)", initial_allocs);

        // Run complex query
        {
            let query = Query::new(&large_dataset)
                .where_(Employee::salary_r(), |&s| s > 80000.0)
                .where_(Employee::department_r(), |d| d == "Engineering");
            let results = query.all();
            
            println!("  Filtered to {} employees", results.len());
            
            let (during_allocs, _) = get_stats();
            let extra = during_allocs - initial_allocs;
            println!("  Extra allocations during query: {} (should be 0)", extra);
            
            if extra == 0 {
                println!("  ✅ Zero-copy filtering confirmed!");
            }
        }

        print_memory_status("After query results dropped");
    }

    print_memory_status("After 1000 employees dropped");
    println!();

    // ============================================================================
    // TEST 6: Explanation of 'static
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Explanation: Why 'static is safe and doesn't leak");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("❓ What does T: 'static mean?\n");
    println!("  WRONG ❌: \"T lives for the entire program\"");
    println!("  RIGHT ✅: \"T doesn't contain non-'static references\"\n");

    println!("Examples:\n");
    println!("  struct OwnedData {{          // T: 'static ✅");
    println!("      id: u32,                 // Owned data");
    println!("      name: String,            // Owned data");
    println!("  }}");
    println!();
    println!("  struct WithReference<'a> {{  // NOT 'static ❌");
    println!("      data: &'a String,        // Contains reference");
    println!("  }}");
    println!();

    println!("Why we use T: 'static:\n");
    println!("  1. Store type in trait objects: Box<dyn Fn(&T) -> bool>");
    println!("  2. Prevent dangling references in closures");
    println!("  3. Ensure type safety at compile time");
    println!();

    println!("Lifetime of data:\n");
    println!("  • Data is owned by your Vec<T>");
    println!("  • Query just borrows &'a [T]");
    println!("  • When Vec<T> is dropped, all T are dropped");
    println!("  • No memory leaks possible!\n");

    // ============================================================================
    // TEST 7: Drop Order Verification
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Test 7: Drop order - verify proper RAII");
    println!("═══════════════════════════════════════════════════════════════\n");

    reset_stats();
    
    println!("Creating scoped data...");
    {
        let employees = vec![
            create_employee(1, "Alice", "Engineering", 95000.0),
            create_employee(2, "Bob", "Sales", 87000.0),
        ];
        println!("  Created 2 employees");

        {
            println!("  Creating query...");
            let query = Query::new(&employees)
                .where_(Employee::department_r(), |dept| dept == "Engineering");
            
            {
                println!("  Executing query...");
                let results = query.all();
                println!("    Found {} results", results.len());
                println!("  Query results going out of scope...");
            }
            println!("  Results dropped (just Vec<&Employee>, no Employee drops)");
            
            println!("  Query going out of scope...");
        }
        println!("  Query dropped (just filters, no Employee drops)");
        
        println!("  Employees vector going out of scope...");
    }
    println!("  Employees dropped - NOW Employees are freed!\n");
    
    let (allocs, drops) = get_stats();
    println!("Final stats:");
    println!("  Allocated: {}", allocs);
    println!("  Dropped: {}", drops);
    println!("  Leaked: {}", allocs - drops);
    
    if allocs == drops {
        println!("\n✅ Perfect! All allocated memory was freed!");
    } else {
        println!("\n❌ Memory leak detected!");
    }

    // ============================================================================
    // TEST 8: Arc/Rc Compatibility
    // ============================================================================
    println!("\n═══════════════════════════════════════════════════════════════");
    println!("Test 8: Arc/Rc compatibility - shared ownership works");
    println!("═══════════════════════════════════════════════════════════════\n");

    {
        use std::sync::Arc;
        
        #[derive(Keypaths)]
        struct SharedData {
            id: u32,
            value: Arc<String>,  // Shared ownership
        }

        let shared_string = Arc::new("Shared Value".to_string());
        println!("  Arc strong count: {}", Arc::strong_count(&shared_string));

        let data = vec![
            SharedData { id: 1, value: Arc::clone(&shared_string) },
            SharedData { id: 2, value: Arc::clone(&shared_string) },
        ];
        
        println!("  Arc strong count after creating data: {}", Arc::strong_count(&shared_string));

        {
            let query = Query::new(&data)
                .where_(SharedData::id_r(), |&id| id > 0);
            let results = query.all();
            println!("  Found {} items", results.len());
            println!("  Arc strong count during query: {}", Arc::strong_count(&shared_string));
        }

        println!("  Arc strong count after query: {}", Arc::strong_count(&shared_string));
    }
    
    println!("  ✅ Arc reference counting works correctly!\n");

    // ============================================================================
    // TEST 9: Large Data Without Clone - Zero Copy
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Test 9: Large data without Clone - verify zero-copy");
    println!("═══════════════════════════════════════════════════════════════\n");

    #[derive(Keypaths)]  // NO Clone!
    struct LargeRecord {
        id: u32,
        // Simulate 1MB of data that we DON'T want to clone
        huge_data: Vec<u8>,
    }

    {
        println!("  Creating 10 records (1MB each = 10MB total)...");
        let large_records: Vec<LargeRecord> = (0..10)
            .map(|i| LargeRecord {
                id: i,
                huge_data: vec![i as u8; 1_000_000], // 1MB each
            })
            .collect();

        println!("  Total memory: ~10MB");

        {
            println!("\n  Running query without Clone...");
            let query = Query::new(&large_records)
                .where_(LargeRecord::id_r(), |&id| id < 5);
            let results = query.all();  // Vec<&LargeRecord> - NO CLONING!
            
            println!("  Found {} records", results.len());
            println!("  Memory copied: 0 bytes (just references)");
            println!("  ✅ Zero-copy achieved!");
        }

        println!("\n  Query dropped - no memory freed (no cloning happened)");
    }
    
    println!("  Records dropped - 10MB freed\n");

    // ============================================================================
    // TEST 10: Lifetime Safety
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Test 10: Lifetime safety - compiler prevents dangling refs");
    println!("═══════════════════════════════════════════════════════════════\n");

    println!("  The following code WILL NOT COMPILE (by design):\n");
    println!("  ```rust");
    println!("  let query;");
    println!("  {{");
    println!("      let data = vec![...];");
    println!("      query = Query::new(&data);  // data borrowed here");
    println!("  }}  // data dropped");
    println!("  let results = query.all();  // ❌ ERROR: data doesn't live long enough");
    println!("  ```\n");
    println!("  ✅ Rust's borrow checker prevents use-after-free!");
    println!("  ✅ 'static bound + lifetimes = memory safety guaranteed!\n");

    // ============================================================================
    // Summary
    // ============================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!("Summary: Memory Safety Guarantees");
    println!("═══════════════════════════════════════════════════════════════\n");

    let (total_allocs, total_drops) = get_stats();
    let leaked = total_allocs.saturating_sub(total_drops);

    println!("Overall Statistics:");
    println!("  Total allocations: {}", total_allocs);
    println!("  Total drops: {}", total_drops);
    println!("  Memory leaks: {}", leaked);

    if leaked == 0 {
        println!("\n🎉 VERIFIED: Zero memory leaks!\n");
    } else {
        println!("\n⚠️  WARNING: Potential memory leak detected!\n");
    }

    println!("Guarantees Verified:");
    println!("  ✅ 'static doesn't cause data to live forever");
    println!("  ✅ All allocated memory is properly freed");
    println!("  ✅ No memory leaks from queries");
    println!("  ✅ Query only holds references, not ownership");
    println!("  ✅ Rust's borrow checker prevents dangling references");
    println!("  ✅ RAII ensures proper cleanup");
    println!("  ✅ Zero-copy operations don't allocate");
    println!("  ✅ Clone operations are explicit and controlled\n");

    println!("Performance Benefits:");
    println!("  ✅ Filtering: 0 bytes copied (v0.2.0) vs 10MB (v0.1.0)");
    println!("  ✅ Counting: 0 bytes copied");
    println!("  ✅ Aggregations: 0 bytes copied");
    println!("  ✅ Only ordering/grouping clone when needed\n");

    println!("Safety Guarantees:");
    println!("  ✅ Compile-time prevention of dangling references");
    println!("  ✅ No use-after-free possible");
    println!("  ✅ No double-free possible");
    println!("  ✅ Automatic cleanup via RAII\n");

    println!("✓ All memory safety tests PASSED!\n");
}

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.

Note: This method requires T: Clone as it creates owned copies in groups.

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!();
}