add databend backend

Cargo.toml

@@ -50,6 +50,7 @@ pretty_assertions = { version = "1" }
 
 [features]
 # STUB
+backend-databend = []
 backend-mysql = []
 backend-postgres = []
 backend-sqlite = []
@@ -119,6 +120,11 @@ name = "test-sqlite"
 path = "tests/sqlite/mod.rs"
 required-features = ["tests-cfg", "backend-sqlite"]
 
+[[test]]
+name = "test-databend"
+path = "tests/databend/mod.rs"
+required-features = ["tests-cfg", "backend-databend"]
+
 [[test]]
 name = "option-more-parentheses"
 path = "tests/more-parentheses.rs"

src/backend/databend/foreign_key.rs

@@ -0,0 +1,21 @@
+use super::*;
+
+impl ForeignKeyBuilder for DatabendQueryBuilder {
+    fn prepare_table_ref_fk_stmt(&self, _table_ref: &TableRef, _sql: &mut dyn SqlWriter) {}
+
+    fn prepare_foreign_key_drop_statement_internal(
+        &self,
+        _drop: &ForeignKeyDropStatement,
+        _sql: &mut dyn SqlWriter,
+        _mode: Mode,
+    ) {
+    }
+
+    fn prepare_foreign_key_create_statement_internal(
+        &self,
+        _create: &ForeignKeyCreateStatement,
+        _sql: &mut dyn SqlWriter,
+        _mode: Mode,
+    ) {
+    }
+}

src/backend/databend/index.rs

@@ -0,0 +1,18 @@
+use super::*;
+
+impl IndexBuilder for DatabendQueryBuilder {
+    fn prepare_index_create_statement(
+        &self,
+        _create: &IndexCreateStatement,
+        _sql: &mut dyn SqlWriter,
+    ) {
+    }
+
+    fn prepare_table_ref_index_stmt(&self, _table_ref: &TableRef, _sql: &mut dyn SqlWriter) {}
+
+    fn prepare_index_drop_statement(&self, _drop: &IndexDropStatement, _sql: &mut dyn SqlWriter) {}
+
+    fn prepare_index_prefix(&self, _create: &IndexCreateStatement, _sql: &mut dyn SqlWriter) {}
+
+    fn write_column_index_prefix(&self, _col_prefix: &Option<u32>, _sql: &mut dyn SqlWriter) {}
+}

src/backend/databend/mod.rs

@@ -0,0 +1,40 @@
+pub(crate) mod foreign_key;
+pub(crate) mod index;
+pub(crate) mod query;
+pub(crate) mod table;
+
+use super::*;
+
+/// Sqlite query builder.
+#[derive(Default, Debug)]
+pub struct DatabendQueryBuilder;
+
+impl GenericBuilder for DatabendQueryBuilder {}
+
+impl SchemaBuilder for DatabendQueryBuilder {}
+
+impl QuotedBuilder for DatabendQueryBuilder {
+    fn quote(&self) -> Quote {
+        MysqlQueryBuilder.quote()
+    }
+}
+
+impl EscapeBuilder for DatabendQueryBuilder {}
+
+impl TableRefBuilder for DatabendQueryBuilder {}
+
+impl PrecedenceDecider for DatabendQueryBuilder {
+    fn inner_expr_well_known_greater_precedence(
+        &self,
+        inner: &SimpleExpr,
+        outer_oper: &Oper,
+    ) -> bool {
+        common_inner_expr_well_known_greater_precedence(inner, outer_oper)
+    }
+}
+
+impl OperLeftAssocDecider for DatabendQueryBuilder {
+    fn well_known_left_associative(&self, op: &BinOper) -> bool {
+        common_well_known_left_associative(op)
+    }
+}

src/backend/databend/query.rs

@@ -0,0 +1,99 @@
+use super::*;
+
+impl QueryBuilder for DatabendQueryBuilder {
+    fn prepare_insert_statement(&self, insert: &InsertStatement, sql: &mut dyn SqlWriter) {
+        self.prepare_insert(insert.replace, sql);
+
+        if let Some(table) = &insert.table {
+            write!(sql, " INTO ").unwrap();
+            self.prepare_table_ref(table, sql);
+        }
+
+        self.prepare_output(&insert.returning, sql);
+
+        write!(sql, " ").unwrap();
+
+        if insert.default_values.is_some() && insert.columns.is_empty() && insert.source.is_none() {
+            let num_rows = insert.default_values.unwrap();
+            self.insert_default_values(num_rows, sql);
+        } else {
+            write!(sql, "(").unwrap();
+            insert.columns.iter().fold(true, |first, col| {
+                if !first {
+                    write!(sql, ", ").unwrap()
+                }
+                col.prepare(sql.as_writer(), self.quote());
+                false
+            });
+            write!(sql, ")").unwrap();
+
+            if insert.replace {
+                self.prepare_on_conflict(&insert.on_conflict, sql);
+            }
+
+            if let Some(source) = &insert.source {
+                write!(sql, " ").unwrap();
+                match source {
+                    InsertValueSource::Values(values) => {
+                        write!(sql, "VALUES ").unwrap();
+                        values.iter().fold(true, |first, row| {
+                            if !first {
+                                write!(sql, ", ").unwrap()
+                            }
+                            write!(sql, "(").unwrap();
+                            row.iter().fold(true, |first, col| {
+                                if !first {
+                                    write!(sql, ", ").unwrap()
+                                }
+                                self.prepare_simple_expr(col, sql);
+                                false
+                            });
+                            write!(sql, ")").unwrap();
+                            false
+                        });
+                    }
+                    InsertValueSource::Select(select_query) => {
+                        self.prepare_select_statement(select_query, sql);
+                    }
+                }
+            }
+        }
+    }
+    fn prepare_on_conflict_keywords(&self, sql: &mut dyn SqlWriter) {
+        write!(sql, " ON ").unwrap();
+    }
+    fn prepare_on_conflict(&self, on_conflict: &Option<OnConflict>, sql: &mut dyn SqlWriter) {
+        if let Some(on_conflict) = on_conflict {
+            self.prepare_on_conflict_keywords(sql);
+            self.prepare_on_conflict_target(&on_conflict.targets, sql);
+        }
+    }
+
+    fn prepare_select_lock(&self, _select_lock: &LockClause, _sql: &mut dyn SqlWriter) {}
+
+    fn prepare_query_statement(&self, query: &SubQueryStatement, sql: &mut dyn SqlWriter) {
+        query.prepare_statement(self, sql);
+    }
+
+    fn prepare_on_conflict_condition(&self, _: &ConditionHolder, _: &mut dyn SqlWriter) {}
+
+    fn prepare_returning(&self, _returning: &Option<ReturningClause>, _sql: &mut dyn SqlWriter) {}
+
+    fn prepare_with_clause_recursive_options(&self, _: &WithClause, _: &mut dyn SqlWriter) {
+        // Sqlite doesn't support sql recursive with query 'SEARCH' and 'CYCLE' options.
+    }
+
+    fn prepare_order_expr(&self, order_expr: &OrderExpr, sql: &mut dyn SqlWriter) {
+        MysqlQueryBuilder.prepare_order_expr(order_expr, sql)
+    }
+
+    fn prepare_value(&self, value: &Value, sql: &mut dyn SqlWriter) {
+        let v = self.value_to_string(value);
+        write!(sql, "{v}").unwrap();
+        // sql.push_param(value.clone(), self as _);
+    }
+
+    fn insert_default_keyword(&self) -> &str {
+        "()"
+    }
+}