1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
//! SQL-injection-safe expression building with templates and parameters.
//!
//! Modules:
//! - [`core`] - Core `Expression<T>` struct
//! - [`macros`] - `expr!` and `expr_as!` macros
//! - [`mapping`] - Type conversion utilities
//! - [`flatten`] - Expression flattening
//!
//! ## Expression
//!
//! The main `Expression<T>` struct stores a template string and typed parameters.
//! ```rust
//! use vantage_expressions::prelude::*;
//!
//! let expr = Expression::new("SELECT * WHERE id = {}", vec![ExpressiveEnum::Scalar(42)]);
//! ```
//!
//! ## Macros
//!
//! Convenient macros for creating expressions with automatic type inference.
//! ```rust
//! use vantage_expressions::prelude::*;
//!
//! let query = expr!("SELECT * FROM users WHERE age > {}", 21);
//! let typed_query = expr_as!(String, "name = {}", "John");
//! let any_query: Expression<i32> = expr_any!("id = {}", 42);
//! ```
//!
//! ## Mapping
//!
//! Convert expressions between parameter types for cross-database compatibility.
//! ```rust
//! use vantage_expressions::prelude::*;
//! use serde_json::Value;
//!
//! let string_expr: Expression<String> = expr_as!(String, "name = {}", "John");
//! let value_expr: Expression<Value> = string_expr.map();
//! // Now use mapped expression as parameter in different type
//! let query: Expression<Value> = expr!("SELECT * FROM users WHERE {}", (value_expr));
//! ```
//!
//! ## Flatten
//!
//! Resolve nested expressions into flat templates with combined parameters.
//! ```rust
//! use vantage_expressions::prelude::*;
//!
//! let where_clause = expr!("age > {} AND status = {}", 21, "active");
//! let query = expr!("SELECT * FROM users WHERE {}", (where_clause));
//! let flattener = ExpressionFlattener::new();
//! let flattened = flattener.flatten(&query);
//! // Template becomes: "SELECT * FROM users WHERE age > {} AND status = {}"
//! ```