Qail

qail_core::ast::cmd

Struct Qail 

Source 
pub struct Qail {
Show 27 fields
    pub action: Action,
    pub table: String,
    pub columns: Vec<Expr>,
    pub joins: Vec<Join>,
    pub cages: Vec<Cage>,
    pub distinct: bool,
    pub index_def: Option<IndexDef>,
    pub table_constraints: Vec<TableConstraint>,
    pub set_ops: Vec<(SetOp, Box<Qail>)>,
    pub having: Vec<Condition>,
    pub group_by_mode: GroupByMode,
    pub ctes: Vec<CTEDef>,
    pub distinct_on: Vec<Expr>,
    pub returning: Option<Vec<Expr>>,
    pub on_conflict: Option<OnConflict>,
    pub source_query: Option<Box<Qail>>,
    pub channel: Option<String>,
    pub payload: Option<String>,
    pub savepoint_name: Option<String>,
    pub from_tables: Vec<String>,
    pub using_tables: Vec<String>,
    pub lock_mode: Option<LockMode>,
    pub fetch: Option<(u64, bool)>,
    pub default_values: bool,
    pub overriding: Option<OverridingKind>,
    pub sample: Option<(SampleMethod, f64, Option<u64>)>,
    pub only_table: bool,

}

Fields§

§action: Action§table: String§columns: Vec<Expr>§joins: Vec<Join>§cages: Vec<Cage>§distinct: bool§index_def: Option<IndexDef>§table_constraints: Vec<TableConstraint>§set_ops: Vec<(SetOp, Box<Qail>)>§having: Vec<Condition>§group_by_mode: GroupByMode§ctes: Vec<CTEDef>§distinct_on: Vec<Expr>§returning: Option<Vec<Expr>>§on_conflict: Option<OnConflict>§source_query: Option<Box<Qail>>§channel: Option<String>§payload: Option<String>§savepoint_name: Option<String>§from_tables: Vec<String>§using_tables: Vec<String>§lock_mode: Option<LockMode>§fetch: Option<(u64, bool)>§default_values: bool§overriding: Option<OverridingKind>§sample: Option<(SampleMethod, f64, Option<u64>)>§only_table: bool

Implementations§

Source§

impl Qail

Source

pub fn column_expr(self, expr: Expr) -> Self

Source

pub fn columns_expr<I>(self, exprs: I) -> Self
where I: IntoIterator<Item = Expr>,

Source

pub fn distinct_on<I, S>(self, cols: I) -> Self
where I: IntoIterator<Item = S>, S: AsRef<str>,

Source

pub fn distinct_on_expr<I>(self, exprs: I) -> Self
where I: IntoIterator<Item = Expr>,

Source

pub fn filter_cond(self, condition: Condition) -> Self

Source

pub fn having_cond(self, condition: Condition) -> Self

Source

pub fn having_conds( self, conditions: impl IntoIterator<Item = Condition>, ) -> Self

Source

pub fn with_ctes(self, ctes: Vec<CTEDef>) -> Self

Source

pub fn update_from<I, S>(self, tables: I) -> Self
where I: IntoIterator<Item = S>, S: AsRef<str>,

Source

pub fn delete_using<I, S>(self, tables: I) -> Self
where I: IntoIterator<Item = S>, S: AsRef<str>,

Source

pub fn for_update(self) -> Self

Source

pub fn for_no_key_update(self) -> Self

Source

pub fn for_share(self) -> Self

Source

pub fn for_key_share(self) -> Self

Source

pub fn fetch_first(self, count: u64) -> Self

Source

pub fn fetch_with_ties(self, count: u64) -> Self

Source

pub fn default_values(self) -> Self

Source

pub fn overriding_system_value(self) -> Self

Source

pub fn overriding_user_value(self) -> Self

Source

pub fn tablesample_bernoulli(self, percent: f64) -> Self

Source

pub fn tablesample_system(self, percent: f64) -> Self

Source

pub fn repeatable(self, seed: u64) -> Self

Source

pub fn only(self) -> Self

Source

pub fn left_join_as( self, table: impl AsRef<str>, alias: impl AsRef<str>, left_col: impl AsRef<str>, right_col: impl AsRef<str>, ) -> Self

Source

pub fn inner_join_as( self, table: impl AsRef<str>, alias: impl AsRef<str>, left_col: impl AsRef<str>, right_col: impl AsRef<str>, ) -> Self

Source

pub fn table_alias(self, alias: impl AsRef<str>) -> Self

Source

pub fn order_by_expr(self, expr: Expr, order: SortOrder) -> Self

Source

pub fn group_by_expr<I>(self, exprs: I) -> Self
where I: IntoIterator<Item = Expr>,

Source§

impl Qail

Source

pub fn get(table: impl Into<String>) -> Self

Examples found in repository?
examples/whatsapp_insights.rs (line 13)
11fn main() {
12    // Build the stats CTE subquery
13    let mut stats_query = Qail::get("whatsapp_messages");
14
15    // COUNT(DISTINCT phone_number) AS total_contacts
16    stats_query.columns.push(Expr::Aggregate {
17        col: "phone_number".to_string(),
18        func: AggregateFunc::Count,
19        distinct: true,
20        filter: None,
21        alias: Some("total_contacts".to_string()),
22    });
23
24    // COUNT(*) AS total_messages
25    stats_query.columns.push(Expr::Aggregate {
26        col: "*".to_string(),
27        func: AggregateFunc::Count,
28        distinct: false,
29        filter: None,
30        alias: Some("total_messages".to_string()),
31    });
32
33    // COUNT(*) FILTER (WHERE direction = 'outbound' AND created_at > NOW() - INTERVAL '24 hours') AS messages_sent_24h
34    stats_query.columns.push(Expr::Aggregate {
35        col: "*".to_string(),
36        func: AggregateFunc::Count,
37        distinct: false,
38        filter: Some(vec![
39            Condition {
40                left: Expr::Named("direction".to_string()),
41                op: Operator::Eq,
42                value: Value::String("outbound".to_string()),
43                is_array_unnest: false,
44            },
45            Condition {
46                left: Expr::Named("created_at".to_string()),
47                op: Operator::Gt,
48                value: Value::Function("NOW() - INTERVAL '24 hours'".to_string()),
49                is_array_unnest: false,
50            },
51        ]),
52        alias: Some("messages_sent_24h".to_string()),
53    });
54
55    // COUNT(*) FILTER (WHERE direction = 'inbound' AND created_at > NOW() - INTERVAL '24 hours') AS messages_received_24h
56    stats_query.columns.push(Expr::Aggregate {
57        col: "*".to_string(),
58        func: AggregateFunc::Count,
59        distinct: false,
60        filter: Some(vec![
61            Condition {
62                left: Expr::Named("direction".to_string()),
63                op: Operator::Eq,
64                value: Value::String("inbound".to_string()),
65                is_array_unnest: false,
66            },
67            Condition {
68                left: Expr::Named("created_at".to_string()),
69                op: Operator::Gt,
70                value: Value::Function("NOW() - INTERVAL '24 hours'".to_string()),
71                is_array_unnest: false,
72            },
73        ]),
74        alias: Some("messages_received_24h".to_string()),
75    });
76
77    // COUNT(*) FILTER (WHERE direction = 'inbound' AND status = 'received') AS unread_messages
78    stats_query.columns.push(Expr::Aggregate {
79        col: "*".to_string(),
80        func: AggregateFunc::Count,
81        distinct: false,
82        filter: Some(vec![
83            Condition {
84                left: Expr::Named("direction".to_string()),
85                op: Operator::Eq,
86                value: Value::String("inbound".to_string()),
87                is_array_unnest: false,
88            },
89            Condition {
90                left: Expr::Named("status".to_string()),
91                op: Operator::Eq,
92                value: Value::String("received".to_string()),
93                is_array_unnest: false,
94            },
95        ]),
96        alias: Some("unread_messages".to_string()),
97    });
98
99    // COUNT(*) FILTER (WHERE direction = 'outbound' AND created_at > NOW() - INTERVAL '24 hours' AND status IN ('delivered', 'read')) AS successful_deliveries_24h
100    stats_query.columns.push(Expr::Aggregate {
101        col: "*".to_string(),
102        func: AggregateFunc::Count,
103        distinct: false,
104        filter: Some(vec![
105            Condition {
106                left: Expr::Named("direction".to_string()),
107                op: Operator::Eq,
108                value: Value::String("outbound".to_string()),
109                is_array_unnest: false,
110            },
111            Condition {
112                left: Expr::Named("created_at".to_string()),
113                op: Operator::Gt,
114                value: Value::Function("NOW() - INTERVAL '24 hours'".to_string()),
115                is_array_unnest: false,
116            },
117            Condition {
118                left: Expr::Named("status".to_string()),
119                op: Operator::In,
120                value: Value::Array(vec![
121                    Value::String("delivered".to_string()),
122                    Value::String("read".to_string()),
123                ]),
124                is_array_unnest: false,
125            },
126        ]),
127        alias: Some("successful_deliveries_24h".to_string()),
128    });
129
130    // Create CTE definition (using new API)
131    let stats_cte = stats_query.to_cte("stats");
132
133    // Build final SELECT from CTE with CASE expression for delivery_rate
134    let mut final_query = Qail::get("stats").with_cte(stats_cte);
135    final_query.columns = vec![
136        Expr::Named("total_contacts".to_string()),
137        Expr::Named("total_messages".to_string()),
138        Expr::Named("messages_sent_24h".to_string()),
139        Expr::Named("messages_received_24h".to_string()),
140        Expr::Named("unread_messages".to_string()),
141        Expr::Case {
142            when_clauses: vec![(
143                Condition {
144                    left: Expr::Named("messages_sent_24h".to_string()),
145                    op: Operator::Gt,
146                    value: Value::Int(0),
147                    is_array_unnest: false,
148                },
149                Box::new(Expr::Binary {
150                    left: Box::new(Expr::Binary {
151                        left: Box::new(Expr::Cast {
152                            expr: Box::new(Expr::Named("successful_deliveries_24h".to_string())),
153                            target_type: "float8".to_string(),
154                            alias: None,
155                        }),
156                        op: BinaryOp::Div,
157                        right: Box::new(Expr::Cast {
158                            expr: Box::new(Expr::Named("messages_sent_24h".to_string())),
159                            target_type: "float8".to_string(),
160                            alias: None,
161                        }),
162                        alias: None,
163                    }),
164                    op: BinaryOp::Mul,
165                    right: Box::new(Expr::Named("100.0".to_string())),
166                    alias: None,
167                }),
168            )],
169            else_value: Some(Box::new(Expr::Named("0.0".to_string()))),
170            alias: Some("delivery_rate_24h".to_string()),
171        },
172    ];
173
174    // Generate SQL
175    let sql = final_query.to_sql();
176    println!("Generated SQL:\n{}", sql);
177}
Source

pub fn raw_sql(sql: impl Into<String>) -> Self

Source

pub fn set(table: impl Into<String>) -> Self

Source

pub fn del(table: impl Into<String>) -> Self

Source

pub fn add(table: impl Into<String>) -> Self

Source

pub fn put(table: impl Into<String>) -> Self

Source

pub fn export(table: impl Into<String>) -> Self

Source

pub fn make(table: impl Into<String>) -> Self

Source

pub fn truncate(table: impl Into<String>) -> Self

Source

pub fn explain(table: impl Into<String>) -> Self

Source

pub fn explain_analyze(table: impl Into<String>) -> Self

Source

pub fn lock(table: impl Into<String>) -> Self

Source

pub fn create_materialized_view(name: impl Into<String>, query: Qail) -> Self

Source

pub fn refresh_materialized_view(name: impl Into<String>) -> Self

Source

pub fn drop_materialized_view(name: impl Into<String>) -> Self

Source§

impl Qail

Source

pub fn to_cte(self, name: impl Into<String>) -> CTEDef

Examples found in repository?
examples/whatsapp_insights.rs (line 131)
11fn main() {
12    // Build the stats CTE subquery
13    let mut stats_query = Qail::get("whatsapp_messages");
14
15    // COUNT(DISTINCT phone_number) AS total_contacts
16    stats_query.columns.push(Expr::Aggregate {
17        col: "phone_number".to_string(),
18        func: AggregateFunc::Count,
19        distinct: true,
20        filter: None,
21        alias: Some("total_contacts".to_string()),
22    });
23
24    // COUNT(*) AS total_messages
25    stats_query.columns.push(Expr::Aggregate {
26        col: "*".to_string(),
27        func: AggregateFunc::Count,
28        distinct: false,
29        filter: None,
30        alias: Some("total_messages".to_string()),
31    });
32
33    // COUNT(*) FILTER (WHERE direction = 'outbound' AND created_at > NOW() - INTERVAL '24 hours') AS messages_sent_24h
34    stats_query.columns.push(Expr::Aggregate {
35        col: "*".to_string(),
36        func: AggregateFunc::Count,
37        distinct: false,
38        filter: Some(vec![
39            Condition {
40                left: Expr::Named("direction".to_string()),
41                op: Operator::Eq,
42                value: Value::String("outbound".to_string()),
43                is_array_unnest: false,
44            },
45            Condition {
46                left: Expr::Named("created_at".to_string()),
47                op: Operator::Gt,
48                value: Value::Function("NOW() - INTERVAL '24 hours'".to_string()),
49                is_array_unnest: false,
50            },
51        ]),
52        alias: Some("messages_sent_24h".to_string()),
53    });
54
55    // COUNT(*) FILTER (WHERE direction = 'inbound' AND created_at > NOW() - INTERVAL '24 hours') AS messages_received_24h
56    stats_query.columns.push(Expr::Aggregate {
57        col: "*".to_string(),
58        func: AggregateFunc::Count,
59        distinct: false,
60        filter: Some(vec![
61            Condition {
62                left: Expr::Named("direction".to_string()),
63                op: Operator::Eq,
64                value: Value::String("inbound".to_string()),
65                is_array_unnest: false,
66            },
67            Condition {
68                left: Expr::Named("created_at".to_string()),
69                op: Operator::Gt,
70                value: Value::Function("NOW() - INTERVAL '24 hours'".to_string()),
71                is_array_unnest: false,
72            },
73        ]),
74        alias: Some("messages_received_24h".to_string()),
75    });
76
77    // COUNT(*) FILTER (WHERE direction = 'inbound' AND status = 'received') AS unread_messages
78    stats_query.columns.push(Expr::Aggregate {
79        col: "*".to_string(),
80        func: AggregateFunc::Count,
81        distinct: false,
82        filter: Some(vec![
83            Condition {
84                left: Expr::Named("direction".to_string()),
85                op: Operator::Eq,
86                value: Value::String("inbound".to_string()),
87                is_array_unnest: false,
88            },
89            Condition {
90                left: Expr::Named("status".to_string()),
91                op: Operator::Eq,
92                value: Value::String("received".to_string()),
93                is_array_unnest: false,
94            },
95        ]),
96        alias: Some("unread_messages".to_string()),
97    });
98
99    // COUNT(*) FILTER (WHERE direction = 'outbound' AND created_at > NOW() - INTERVAL '24 hours' AND status IN ('delivered', 'read')) AS successful_deliveries_24h
100    stats_query.columns.push(Expr::Aggregate {
101        col: "*".to_string(),
102        func: AggregateFunc::Count,
103        distinct: false,
104        filter: Some(vec![
105            Condition {
106                left: Expr::Named("direction".to_string()),
107                op: Operator::Eq,
108                value: Value::String("outbound".to_string()),
109                is_array_unnest: false,
110            },
111            Condition {
112                left: Expr::Named("created_at".to_string()),
113                op: Operator::Gt,
114                value: Value::Function("NOW() - INTERVAL '24 hours'".to_string()),
115                is_array_unnest: false,
116            },
117            Condition {
118                left: Expr::Named("status".to_string()),
119                op: Operator::In,
120                value: Value::Array(vec![
121                    Value::String("delivered".to_string()),
122                    Value::String("read".to_string()),
123                ]),
124                is_array_unnest: false,
125            },
126        ]),
127        alias: Some("successful_deliveries_24h".to_string()),
128    });
129
130    // Create CTE definition (using new API)
131    let stats_cte = stats_query.to_cte("stats");
132
133    // Build final SELECT from CTE with CASE expression for delivery_rate
134    let mut final_query = Qail::get("stats").with_cte(stats_cte);
135    final_query.columns = vec![
136        Expr::Named("total_contacts".to_string()),
137        Expr::Named("total_messages".to_string()),
138        Expr::Named("messages_sent_24h".to_string()),
139        Expr::Named("messages_received_24h".to_string()),
140        Expr::Named("unread_messages".to_string()),
141        Expr::Case {
142            when_clauses: vec![(
143                Condition {
144                    left: Expr::Named("messages_sent_24h".to_string()),
145                    op: Operator::Gt,
146                    value: Value::Int(0),
147                    is_array_unnest: false,
148                },
149                Box::new(Expr::Binary {
150                    left: Box::new(Expr::Binary {
151                        left: Box::new(Expr::Cast {
152                            expr: Box::new(Expr::Named("successful_deliveries_24h".to_string())),
153                            target_type: "float8".to_string(),
154                            alias: None,
155                        }),
156                        op: BinaryOp::Div,
157                        right: Box::new(Expr::Cast {
158                            expr: Box::new(Expr::Named("messages_sent_24h".to_string())),
159                            target_type: "float8".to_string(),
160                            alias: None,
161                        }),
162                        alias: None,
163                    }),
164                    op: BinaryOp::Mul,
165                    right: Box::new(Expr::Named("100.0".to_string())),
166                    alias: None,
167                }),
168            )],
169            else_value: Some(Box::new(Expr::Named("0.0".to_string()))),
170            alias: Some("delivery_rate_24h".to_string()),
171        },
172    ];
173
174    // Generate SQL
175    let sql = final_query.to_sql();
176    println!("Generated SQL:\n{}", sql);
177}
Source

pub fn with(self, name: impl Into<String>, query: Qail) -> Self

Source

pub fn as_cte(self, name: impl Into<String>) -> Self

👎Deprecated since 0.13.0: Use .to_cte() for reusable CTEDef or .with() for inline CTE
Source

pub fn recursive(self, recursive_part: Qail) -> Self

Source

pub fn from_cte(self, cte_name: impl Into<String>) -> Self

Source

pub fn select_from_cte(self, columns: &[&str]) -> Self

Source

pub fn with_cte(self, cte: CTEDef) -> Self

Examples found in repository?
examples/whatsapp_insights.rs (line 134)
11fn main() {
12    // Build the stats CTE subquery
13    let mut stats_query = Qail::get("whatsapp_messages");
14
15    // COUNT(DISTINCT phone_number) AS total_contacts
16    stats_query.columns.push(Expr::Aggregate {
17        col: "phone_number".to_string(),
18        func: AggregateFunc::Count,
19        distinct: true,
20        filter: None,
21        alias: Some("total_contacts".to_string()),
22    });
23
24    // COUNT(*) AS total_messages
25    stats_query.columns.push(Expr::Aggregate {
26        col: "*".to_string(),
27        func: AggregateFunc::Count,
28        distinct: false,
29        filter: None,
30        alias: Some("total_messages".to_string()),
31    });
32
33    // COUNT(*) FILTER (WHERE direction = 'outbound' AND created_at > NOW() - INTERVAL '24 hours') AS messages_sent_24h
34    stats_query.columns.push(Expr::Aggregate {
35        col: "*".to_string(),
36        func: AggregateFunc::Count,
37        distinct: false,
38        filter: Some(vec![
39            Condition {
40                left: Expr::Named("direction".to_string()),
41                op: Operator::Eq,
42                value: Value::String("outbound".to_string()),
43                is_array_unnest: false,
44            },
45            Condition {
46                left: Expr::Named("created_at".to_string()),
47                op: Operator::Gt,
48                value: Value::Function("NOW() - INTERVAL '24 hours'".to_string()),
49                is_array_unnest: false,
50            },
51        ]),
52        alias: Some("messages_sent_24h".to_string()),
53    });
54
55    // COUNT(*) FILTER (WHERE direction = 'inbound' AND created_at > NOW() - INTERVAL '24 hours') AS messages_received_24h
56    stats_query.columns.push(Expr::Aggregate {
57        col: "*".to_string(),
58        func: AggregateFunc::Count,
59        distinct: false,
60        filter: Some(vec![
61            Condition {
62                left: Expr::Named("direction".to_string()),
63                op: Operator::Eq,
64                value: Value::String("inbound".to_string()),
65                is_array_unnest: false,
66            },
67            Condition {
68                left: Expr::Named("created_at".to_string()),
69                op: Operator::Gt,
70                value: Value::Function("NOW() - INTERVAL '24 hours'".to_string()),
71                is_array_unnest: false,
72            },
73        ]),
74        alias: Some("messages_received_24h".to_string()),
75    });
76
77    // COUNT(*) FILTER (WHERE direction = 'inbound' AND status = 'received') AS unread_messages
78    stats_query.columns.push(Expr::Aggregate {
79        col: "*".to_string(),
80        func: AggregateFunc::Count,
81        distinct: false,
82        filter: Some(vec![
83            Condition {
84                left: Expr::Named("direction".to_string()),
85                op: Operator::Eq,
86                value: Value::String("inbound".to_string()),
87                is_array_unnest: false,
88            },
89            Condition {
90                left: Expr::Named("status".to_string()),
91                op: Operator::Eq,
92                value: Value::String("received".to_string()),
93                is_array_unnest: false,
94            },
95        ]),
96        alias: Some("unread_messages".to_string()),
97    });
98
99    // COUNT(*) FILTER (WHERE direction = 'outbound' AND created_at > NOW() - INTERVAL '24 hours' AND status IN ('delivered', 'read')) AS successful_deliveries_24h
100    stats_query.columns.push(Expr::Aggregate {
101        col: "*".to_string(),
102        func: AggregateFunc::Count,
103        distinct: false,
104        filter: Some(vec![
105            Condition {
106                left: Expr::Named("direction".to_string()),
107                op: Operator::Eq,
108                value: Value::String("outbound".to_string()),
109                is_array_unnest: false,
110            },
111            Condition {
112                left: Expr::Named("created_at".to_string()),
113                op: Operator::Gt,
114                value: Value::Function("NOW() - INTERVAL '24 hours'".to_string()),
115                is_array_unnest: false,
116            },
117            Condition {
118                left: Expr::Named("status".to_string()),
119                op: Operator::In,
120                value: Value::Array(vec![
121                    Value::String("delivered".to_string()),
122                    Value::String("read".to_string()),
123                ]),
124                is_array_unnest: false,
125            },
126        ]),
127        alias: Some("successful_deliveries_24h".to_string()),
128    });
129
130    // Create CTE definition (using new API)
131    let stats_cte = stats_query.to_cte("stats");
132
133    // Build final SELECT from CTE with CASE expression for delivery_rate
134    let mut final_query = Qail::get("stats").with_cte(stats_cte);
135    final_query.columns = vec![
136        Expr::Named("total_contacts".to_string()),
137        Expr::Named("total_messages".to_string()),
138        Expr::Named("messages_sent_24h".to_string()),
139        Expr::Named("messages_received_24h".to_string()),
140        Expr::Named("unread_messages".to_string()),
141        Expr::Case {
142            when_clauses: vec![(
143                Condition {
144                    left: Expr::Named("messages_sent_24h".to_string()),
145                    op: Operator::Gt,
146                    value: Value::Int(0),
147                    is_array_unnest: false,
148                },
149                Box::new(Expr::Binary {
150                    left: Box::new(Expr::Binary {
151                        left: Box::new(Expr::Cast {
152                            expr: Box::new(Expr::Named("successful_deliveries_24h".to_string())),
153                            target_type: "float8".to_string(),
154                            alias: None,
155                        }),
156                        op: BinaryOp::Div,
157                        right: Box::new(Expr::Cast {
158                            expr: Box::new(Expr::Named("messages_sent_24h".to_string())),
159                            target_type: "float8".to_string(),
160                            alias: None,
161                        }),
162                        alias: None,
163                    }),
164                    op: BinaryOp::Mul,
165                    right: Box::new(Expr::Named("100.0".to_string())),
166                    alias: None,
167                }),
168            )],
169            else_value: Some(Box::new(Expr::Named("0.0".to_string()))),
170            alias: Some("delivery_rate_24h".to_string()),
171        },
172    ];
173
174    // Generate SQL
175    let sql = final_query.to_sql();
176    println!("Generated SQL:\n{}", sql);
177}
Source§

impl Qail

Source

pub fn limit(self, n: i64) -> Self

Source

pub fn sort_asc(self, column: &str) -> Self

👎Deprecated since 0.11.0: Use .order_asc(column) instead
Source

pub fn select_all(self) -> Self

Source

pub fn columns<I, S>(self, cols: I) -> Self
where I: IntoIterator<Item = S>, S: AsRef<str>,

Source

pub fn column(self, col: impl AsRef<str>) -> Self

Source

pub fn filter( self, column: impl AsRef<str>, op: Operator, value: impl Into<Value>, ) -> Self

Source

pub fn or_filter( self, column: impl AsRef<str>, op: Operator, value: impl Into<Value>, ) -> Self

Source

pub fn where_eq(self, column: impl AsRef<str>, value: impl Into<Value>) -> Self

Source

pub fn order_by(self, column: impl AsRef<str>, order: SortOrder) -> Self

Source

pub fn order_desc(self, column: impl AsRef<str>) -> Self

Source

pub fn order_asc(self, column: impl AsRef<str>) -> Self

Source

pub fn offset(self, n: i64) -> Self

Source

pub fn group_by<I, S>(self, cols: I) -> Self
where I: IntoIterator<Item = S>, S: AsRef<str>,

Source

pub fn distinct_on_all(self) -> Self

Source

pub fn join( self, kind: JoinKind, table: impl AsRef<str>, left_col: impl AsRef<str>, right_col: impl AsRef<str>, ) -> Self

Source

pub fn left_join( self, table: impl AsRef<str>, left_col: impl AsRef<str>, right_col: impl AsRef<str>, ) -> Self

Source

pub fn inner_join( self, table: impl AsRef<str>, left_col: impl AsRef<str>, right_col: impl AsRef<str>, ) -> Self

Source

pub fn returning<I, S>(self, cols: I) -> Self
where I: IntoIterator<Item = S>, S: AsRef<str>,

Source

pub fn returning_all(self) -> Self

Source

pub fn values<I, V>(self, vals: I) -> Self
where I: IntoIterator<Item = V>, V: Into<Value>,

Source

pub fn set_value(self, column: impl AsRef<str>, value: impl Into<Value>) -> Self

Source§

impl Qail

Source

pub fn hook(self, cols: &[&str]) -> Self

👎Deprecated since 0.11.0: Use .columns([…]) instead
Source

pub fn cage(self, column: &str, value: impl Into<Value>) -> Self

👎Deprecated since 0.11.0: Use .filter(column, Operator::Eq, value) or .where_eq(column, value) instead

Trait Implementations§

Source§

impl Clone for Qail

Source§

fn clone(&self) -> Qail

Returns a duplicate of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Debug for Qail

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl Default for Qail

Source§

fn default() -> Self

Returns the “default value” for a type. Read more
Source§

impl<'de> Deserialize<'de> for Qail

Source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
Source§

impl PartialEq for Qail

Source§

fn eq(&self, other: &Qail) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl Serialize for Qail

Source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where __S: Serializer,

Serialize this value into the given Serde serializer. Read more
Source§

impl ToDynamo for Qail

Source§

fn to_dynamo(&self) -> String

Source§

impl ToMongo for Qail

Source§

fn to_mongo(&self) -> String

Source§

impl ToQdrant for Qail

Source§

impl ToSql for Qail

Source§

fn to_sql_with_dialect(&self, dialect: Dialect) -> String

Convert this node to a SQL string with specific dialect.
Source§

fn to_sql(&self) -> String

Convert this node to a SQL string using default dialect.
Source§

impl ToSqlParameterized for Qail

Source§

fn to_sql_parameterized_with_dialect(&self, dialect: Dialect) -> TranspileResult

Convert to SQL with extracted parameters for specific dialect.
Source§

fn to_sql_parameterized(&self) -> TranspileResult

Convert to SQL with extracted parameters (default dialect).
Source§

impl StructuralPartialEq for Qail

Auto Trait Implementations§

§

impl Freeze for Qail

§

impl RefUnwindSafe for Qail

§

impl Send for Qail

§

impl Sync for Qail

§

impl Unpin for Qail

§

impl UnwindSafe for Qail

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,