activecube_rs/sql/
starrocks.rs

1use crate::compiler::ir::*;
2use crate::sql::dialect::SqlDialect;
3
4pub struct StarRocksDialect;
5
6impl StarRocksDialect {
7    pub fn new() -> Self {
8        Self
9    }
10}
11
12impl Default for StarRocksDialect {
13    fn default() -> Self {
14        Self::new()
15    }
16}
17
18impl SqlDialect for StarRocksDialect {
19    fn compile(&self, ir: &QueryIR) -> (String, Vec<SqlValue>) {
20        let mut bindings = Vec::new();
21        let mut sql = String::new();
22
23        sql.push_str("SELECT ");
24        let select_parts: Vec<String> = ir.selects.iter().map(|s| match s {
25            SelectExpr::Column { column, alias } => match alias {
26                Some(a) => format!("`{column}` AS `{a}`"),
27                None => format!("`{column}`"),
28            },
29            SelectExpr::Aggregate { function, column, alias, condition } => {
30                let func = function.to_uppercase();
31                match (func.as_str(), column.as_str(), condition) {
32                    ("COUNT", "*", None) => format!("COUNT(*) AS `{alias}`"),
33                    ("COUNT", "*", Some(cond)) => format!("COUNT(IF({cond}, 1, NULL)) AS `{alias}`"),
34                    ("UNIQ", col, None) => format!("COUNT(DISTINCT `{col}`) AS `{alias}`"),
35                    ("UNIQ", col, Some(cond)) => format!("COUNT(DISTINCT IF({cond}, `{col}`, NULL)) AS `{alias}`"),
36                    (f, col, None) => format!("{f}(`{col}`) AS `{alias}`"),
37                    (f, col, Some(cond)) => format!("{f}(IF({cond}, `{col}`, NULL)) AS `{alias}`"),
38                }
39            }
40        }).collect();
41        sql.push_str(&select_parts.join(", "));
42
43        sql.push_str(&format!(" FROM `{}`.`{}`", ir.schema, ir.table));
44
45        let where_clause = compile_filter(&ir.filters, &mut bindings);
46        if !where_clause.is_empty() {
47            sql.push_str(" WHERE ");
48            sql.push_str(&where_clause);
49        }
50
51        if !ir.group_by.is_empty() {
52            sql.push_str(" GROUP BY ");
53            let cols: Vec<String> = ir.group_by.iter().map(|c| format!("`{c}`")).collect();
54            sql.push_str(&cols.join(", "));
55        }
56
57        let having_clause = compile_filter(&ir.having, &mut bindings);
58        if !having_clause.is_empty() {
59            sql.push_str(" HAVING ");
60            sql.push_str(&having_clause);
61        }
62
63        if !ir.order_by.is_empty() {
64            sql.push_str(" ORDER BY ");
65            let parts: Vec<String> = ir.order_by.iter().map(|o| {
66                let dir = if o.descending { "DESC" } else { "ASC" };
67                format!("`{}` {dir}", o.column)
68            }).collect();
69            sql.push_str(&parts.join(", "));
70        }
71
72        sql.push_str(&format!(" LIMIT {}", ir.limit));
73        if ir.offset > 0 {
74            sql.push_str(&format!(" OFFSET {}", ir.offset));
75        }
76
77        (sql, bindings)
78    }
79
80    fn quote_identifier(&self, name: &str) -> String {
81        format!("`{name}`")
82    }
83
84    fn name(&self) -> &str {
85        "StarRocks"
86    }
87}
88
89fn compile_filter(node: &FilterNode, bindings: &mut Vec<SqlValue>) -> String {
90    match node {
91        FilterNode::Empty => String::new(),
92        FilterNode::Condition { column, op, value } => {
93            compile_condition(column, op, value, bindings)
94        }
95        FilterNode::And(children) => {
96            let parts: Vec<String> = children.iter()
97                .map(|c| compile_filter(c, bindings))
98                .filter(|s| !s.is_empty())
99                .collect();
100            match parts.len() {
101                0 => String::new(),
102                1 => parts.into_iter().next().unwrap(),
103                _ => format!("({})", parts.join(" AND ")),
104            }
105        }
106        FilterNode::Or(children) => {
107            let parts: Vec<String> = children.iter()
108                .map(|c| compile_filter(c, bindings))
109                .filter(|s| !s.is_empty())
110                .collect();
111            match parts.len() {
112                0 => String::new(),
113                1 => parts.into_iter().next().unwrap(),
114                _ => format!("({})", parts.join(" OR ")),
115            }
116        }
117    }
118}
119
120/// Quote a column identifier, but leave aggregate expressions (containing `(`)
121/// unquoted so that `SUM(\`col\`)` doesn't become `` `SUM(\`col\`)` ``.
122fn quote_col(column: &str) -> String {
123    if column.contains('(') {
124        column.to_string()
125    } else {
126        format!("`{column}`")
127    }
128}
129
130fn compile_condition(
131    column: &str, op: &CompareOp, value: &SqlValue, bindings: &mut Vec<SqlValue>,
132) -> String {
133    let col = quote_col(column);
134    match op {
135        CompareOp::In | CompareOp::NotIn => {
136            if let SqlValue::String(csv) = value {
137                let items: Vec<&str> = csv.split(',').collect();
138                let placeholders: Vec<&str> = items.iter().map(|_| "?").collect();
139                for item in &items {
140                    bindings.push(SqlValue::String(item.trim().to_string()));
141                }
142                format!("{col} {} ({})", op.sql_op(), placeholders.join(", "))
143            } else {
144                bindings.push(value.clone());
145                format!("{col} {} (?)", op.sql_op())
146            }
147        }
148        CompareOp::Includes => {
149            if let SqlValue::String(s) = value {
150                bindings.push(SqlValue::String(format!("%{s}%")));
151            } else {
152                bindings.push(value.clone());
153            }
154            format!("{col} LIKE ?")
155        }
156        CompareOp::IsNull | CompareOp::IsNotNull => {
157            format!("{col} {}", op.sql_op())
158        }
159        _ => {
160            bindings.push(value.clone());
161            format!("{col} {} ?", op.sql_op())
162        }
163    }
164}
165
166#[cfg(test)]
167mod tests {
168    use super::*;
169
170    fn make_dialect() -> StarRocksDialect { StarRocksDialect::new() }
171
172    #[test]
173    fn test_simple_select() {
174        let ir = QueryIR {
175            cube: "DEXTrades".into(), schema: "dexes_dwd".into(),
176            table: "sol_activities".into(),
177            selects: vec![
178                SelectExpr::Column { column: "tx_hash".into(), alias: None },
179                SelectExpr::Column { column: "buy_amount".into(), alias: None },
180            ],
181            filters: FilterNode::Empty, having: FilterNode::Empty,
182            group_by: vec![], order_by: vec![], limit: 10, offset: 0,
183            use_final: false,
184        };
185        let (sql, bindings) = make_dialect().compile(&ir);
186        assert_eq!(sql, "SELECT `tx_hash`, `buy_amount` FROM `dexes_dwd`.`sol_activities` LIMIT 10");
187        assert!(bindings.is_empty());
188    }
189
190    #[test]
191    fn test_where_and_order() {
192        let ir = QueryIR {
193            cube: "DEXTrades".into(), schema: "dexes_dwd".into(),
194            table: "sol_activities".into(),
195            selects: vec![SelectExpr::Column { column: "tx_hash".into(), alias: None }],
196            filters: FilterNode::And(vec![
197                FilterNode::Condition { column: "buy_amount_usd".into(), op: CompareOp::Gt, value: SqlValue::Float(1000.0) },
198                FilterNode::Condition { column: "success".into(), op: CompareOp::Eq, value: SqlValue::Bool(true) },
199            ]),
200            having: FilterNode::Empty, group_by: vec![],
201            order_by: vec![OrderExpr { column: "buy_amount_usd".into(), descending: true }],
202            limit: 25, offset: 0,
203            use_final: false,
204        };
205        let (sql, bindings) = make_dialect().compile(&ir);
206        assert!(sql.contains("WHERE (`buy_amount_usd` > ? AND `success` = ?)"));
207        assert!(sql.contains("ORDER BY `buy_amount_usd` DESC"));
208        assert_eq!(bindings.len(), 2);
209    }
210
211    #[test]
212    fn test_or_condition() {
213        let ir = QueryIR {
214            cube: "DEXTrades".into(), schema: "dexes_dwd".into(),
215            table: "sol_activities".into(),
216            selects: vec![SelectExpr::Column { column: "tx_hash".into(), alias: None }],
217            filters: FilterNode::And(vec![
218                FilterNode::Condition { column: "buy_amount_usd".into(), op: CompareOp::Gt, value: SqlValue::Float(1000.0) },
219                FilterNode::Or(vec![
220                    FilterNode::Condition { column: "buy_token_symbol".into(), op: CompareOp::Eq, value: SqlValue::String("SOL".into()) },
221                    FilterNode::Condition { column: "sell_token_symbol".into(), op: CompareOp::Eq, value: SqlValue::String("SOL".into()) },
222                ]),
223            ]),
224            having: FilterNode::Empty, group_by: vec![], order_by: vec![], limit: 25, offset: 0,
225            use_final: false,
226        };
227        let (sql, bindings) = make_dialect().compile(&ir);
228        assert!(sql.contains("(`buy_token_symbol` = ? OR `sell_token_symbol` = ?)"));
229        assert_eq!(bindings.len(), 3);
230    }
231
232    #[test]
233    fn test_aggregate_with_having() {
234        let ir = QueryIR {
235            cube: "DEXTrades".into(), schema: "dexes_dwd".into(),
236            table: "sol_activities".into(),
237            selects: vec![
238                SelectExpr::Column { column: "buy_token_symbol".into(), alias: None },
239                SelectExpr::Aggregate { function: "SUM".into(), column: "buy_amount_usd".into(), alias: "__sum".into(), condition: None },
240            ],
241            filters: FilterNode::Empty,
242            having: FilterNode::Condition {
243                column: "SUM(`buy_amount_usd`)".into(), op: CompareOp::Gt, value: SqlValue::Float(1000000.0),
244            },
245            group_by: vec!["buy_token_symbol".into()], order_by: vec![], limit: 25, offset: 0,
246            use_final: false,
247        };
248        let (sql, bindings) = make_dialect().compile(&ir);
249        assert!(sql.contains("GROUP BY `buy_token_symbol`"));
250        assert!(sql.contains("HAVING SUM(`buy_amount_usd`) > ?"), "HAVING clause should not backtick-wrap aggregate expressions, got: {sql}");
251        assert_eq!(bindings.len(), 1);
252    }
253
254    #[test]
255    fn test_offset() {
256        let ir = QueryIR {
257            cube: "DEXTrades".into(), schema: "dexes_dwd".into(),
258            table: "sol_activities".into(),
259            selects: vec![SelectExpr::Column { column: "tx_hash".into(), alias: None }],
260            filters: FilterNode::Empty, having: FilterNode::Empty,
261            group_by: vec![], order_by: vec![], limit: 10, offset: 20,
262            use_final: false,
263        };
264        let (sql, _) = make_dialect().compile(&ir);
265        assert!(sql.ends_with("LIMIT 10 OFFSET 20"));
266    }
267}
activecube_rs/sql/starrocks.rs

activecube_rs/sql/
starrocks.rs
