Replacing Syntax & *BuilderBackend with DatabaseBackend

sea-orm-codegen/tests/mod.rs

@@ -2,7 +2,7 @@ mod entity;
 
 use entity::*;
 
-use sea_orm::{entity::*, error::*, MockDatabase, MockExecResult, Syntax, Transaction};
+use sea_orm::{entity::*, error::*, DatabaseBackend, MockDatabase, MockExecResult, Transaction};
 
 #[async_std::test]
 async fn test_insert() -> Result<(), DbErr> {
@@ -11,7 +11,7 @@ async fn test_insert() -> Result<(), DbErr> {
         rows_affected: 1,
     };
 
-    let db = MockDatabase::new(Syntax::Postgres)
+    let db = MockDatabase::new(DatabaseBackend::Postgres)
         .append_exec_results(vec![exec_result.clone()])
         .into_connection();
 
@@ -27,7 +27,7 @@ async fn test_insert() -> Result<(), DbErr> {
     assert_eq!(
         db.into_transaction_log(),
         vec![Transaction::from_sql_and_values(
-            Syntax::Postgres,
+            DatabaseBackend::Postgres,
             r#"INSERT INTO "cake" ("name") VALUES ($1)"#,
             vec!["Apple Pie".into()]
         )]
@@ -43,7 +43,7 @@ async fn test_select() -> Result<(), DbErr> {
         filling_id: 3,
     }];
 
-    let db = MockDatabase::new(Syntax::Postgres)
+    let db = MockDatabase::new(DatabaseBackend::Postgres)
         .append_query_results(vec![query_results.clone()])
         .into_connection();
 
@@ -54,7 +54,7 @@ async fn test_select() -> Result<(), DbErr> {
     assert_eq!(
         db.into_transaction_log(),
         vec![Transaction::from_sql_and_values(
-            Syntax::Postgres,
+            DatabaseBackend::Postgres,
             [
                 r#"SELECT "cake_filling"."cake_id", "cake_filling"."filling_id" FROM "cake_filling""#,
                 r#"WHERE "cake_filling"."cake_id" = $1 AND "cake_filling"."filling_id" = $2"#,
@@ -73,7 +73,7 @@ async fn test_update() -> Result<(), DbErr> {
         rows_affected: 1,
     };
 
-    let db = MockDatabase::new(Syntax::Postgres)
+    let db = MockDatabase::new(DatabaseBackend::Postgres)
         .append_exec_results(vec![exec_result.clone()])
         .into_connection();
 
@@ -90,7 +90,7 @@ async fn test_update() -> Result<(), DbErr> {
     assert_eq!(
         db.into_transaction_log(),
         vec![Transaction::from_sql_and_values(
-            Syntax::Postgres,
+            DatabaseBackend::Postgres,
             r#"UPDATE "fruit" SET "name" = $1 WHERE "fruit"."id" = $2"#,
             vec!["Orange".into(), 1i32.into()]
         )]
@@ -106,7 +106,7 @@ async fn test_delete() -> Result<(), DbErr> {
         rows_affected: 1,
     };
 
-    let db = MockDatabase::new(Syntax::Postgres)
+    let db = MockDatabase::new(DatabaseBackend::Postgres)
         .append_exec_results(vec![exec_result.clone()])
         .into_connection();
 
@@ -122,7 +122,7 @@ async fn test_delete() -> Result<(), DbErr> {
     assert_eq!(
         db.into_transaction_log(),
         vec![Transaction::from_sql_and_values(
-            Syntax::Postgres,
+            DatabaseBackend::Postgres,
             r#"DELETE FROM "fruit" WHERE "fruit"."id" = $1"#,
             vec![3i32.into()]
         )]

src/database/connection.rs

@@ -1,8 +1,5 @@
-use crate::{error::*, ExecResult, QueryResult, Statement, Syntax};
+use crate::{error::*, ExecResult, IntoStatement, QueryResult, Statement};
-use sea_query::{
+use sea_query::{MysqlQueryBuilder, PostgresQueryBuilder, QueryBuilder, SqliteQueryBuilder};
-    MysqlQueryBuilder, PostgresQueryBuilder, QueryStatementBuilder, SchemaStatementBuilder,
-    SqliteQueryBuilder,
-};
 
 pub enum DatabaseConnection {
     #[cfg(feature = "sqlx-mysql")]
@@ -16,13 +13,8 @@ pub enum DatabaseConnection {
 
 pub type DbConn = DatabaseConnection;
 
-pub enum QueryBuilderBackend {
+#[derive(Debug, Copy, Clone, PartialEq)]
-    MySql,
+pub enum DatabaseBackend {
-    Postgres,
-    Sqlite,
-}
-
-pub enum SchemaBuilderBackend {
     MySql,
     Postgres,
     Sqlite,
@@ -53,26 +45,14 @@ impl std::fmt::Debug for DatabaseConnection {
 }
 
 impl DatabaseConnection {
-    pub fn get_query_builder_backend(&self) -> QueryBuilderBackend {
+    pub fn get_database_backend(&self) -> DatabaseBackend {
         match self {
             #[cfg(feature = "sqlx-mysql")]
-            DatabaseConnection::SqlxMySqlPoolConnection(_) => QueryBuilderBackend::MySql,
+            DatabaseConnection::SqlxMySqlPoolConnection(_) => DatabaseBackend::MySql,
             #[cfg(feature = "sqlx-sqlite")]
-            DatabaseConnection::SqlxSqlitePoolConnection(_) => QueryBuilderBackend::Sqlite,
+            DatabaseConnection::SqlxSqlitePoolConnection(_) => DatabaseBackend::Sqlite,
             #[cfg(feature = "mock")]
-            DatabaseConnection::MockDatabaseConnection(conn) => conn.get_query_builder_backend(),
+            DatabaseConnection::MockDatabaseConnection(conn) => conn.get_database_backend(),
-            DatabaseConnection::Disconnected => panic!("Disconnected"),
-        }
-    }
-
-    pub fn get_schema_builder_backend(&self) -> SchemaBuilderBackend {
-        match self {
-            #[cfg(feature = "sqlx-mysql")]
-            DatabaseConnection::SqlxMySqlPoolConnection(_) => SchemaBuilderBackend::MySql,
-            #[cfg(feature = "sqlx-sqlite")]
-            DatabaseConnection::SqlxSqlitePoolConnection(_) => SchemaBuilderBackend::Sqlite,
-            #[cfg(feature = "mock")]
-            DatabaseConnection::MockDatabaseConnection(conn) => conn.get_schema_builder_backend(),
             DatabaseConnection::Disconnected => panic!("Disconnected"),
         }
     }
@@ -133,50 +113,19 @@ impl DatabaseConnection {
     }
 }
 
-impl QueryBuilderBackend {
+impl DatabaseBackend {
-    pub fn syntax(&self) -> Syntax {
-        match self {
-            Self::MySql => Syntax::MySql,
-            Self::Postgres => Syntax::Postgres,
-            Self::Sqlite => Syntax::Sqlite,
-        }
-    }
-
     pub fn build<S>(&self, statement: &S) -> Statement
     where
-        S: QueryStatementBuilder,
+        S: IntoStatement,
     {
-        Statement::from_string_values_tuple(
+        statement.into_statement(self)
-            self.syntax(),
-            match self {
-                Self::MySql => statement.build(MysqlQueryBuilder),
-                Self::Postgres => statement.build(PostgresQueryBuilder),
-                Self::Sqlite => statement.build(SqliteQueryBuilder),
-            },
-        )
-    }
-}
-
-impl SchemaBuilderBackend {
-    pub fn syntax(&self) -> Syntax {
-        match self {
-            Self::MySql => Syntax::MySql,
-            Self::Postgres => Syntax::Postgres,
-            Self::Sqlite => Syntax::Sqlite,
-        }
     }
 
-    pub fn build<S>(&self, statement: &S) -> Statement
+    pub fn get_query_builder(&self) -> Box<dyn QueryBuilder> {
-    where
-        S: SchemaStatementBuilder,
-    {
-        Statement::from_string(
-            self.syntax(),
         match self {
-                Self::MySql => statement.build(MysqlQueryBuilder),
+            Self::MySql => Box::new(MysqlQueryBuilder),
-                Self::Postgres => statement.build(PostgresQueryBuilder),
+            Self::Postgres => Box::new(PostgresQueryBuilder),
-                Self::Sqlite => statement.build(SqliteQueryBuilder),
+            Self::Sqlite => Box::new(SqliteQueryBuilder),
-            },
+        }
-        )
     }
 }

src/database/mock.rs

@@ -1,14 +1,14 @@
 use crate::{
-    error::*, DatabaseConnection, EntityTrait, ExecResult, ExecResultHolder, Iden, Iterable,
+    error::*, DatabaseBackend, DatabaseConnection, EntityTrait, ExecResult, ExecResultHolder, Iden,
-    MockDatabaseConnection, MockDatabaseTrait, ModelTrait, QueryResult, QueryResultRow, Statement,
+    Iterable, MockDatabaseConnection, MockDatabaseTrait, ModelTrait, QueryResult, QueryResultRow,
-    Syntax, Transaction,
+    Statement, Transaction,
 };
 use sea_query::{Value, ValueType};
 use std::collections::BTreeMap;
 
 #[derive(Debug)]
 pub struct MockDatabase {
-    syntax: Syntax,
+    db_backend: DatabaseBackend,
     transaction_log: Vec<Transaction>,
     exec_results: Vec<MockExecResult>,
     query_results: Vec<Vec<MockRow>>,
@@ -43,9 +43,9 @@ where
 }
 
 impl MockDatabase {
-    pub fn new(syntax: Syntax) -> Self {
+    pub fn new(db_backend: DatabaseBackend) -> Self {
         Self {
-            syntax,
+            db_backend,
             transaction_log: Vec::new(),
             exec_results: Vec::new(),
             query_results: Vec::new(),
@@ -103,8 +103,8 @@ impl MockDatabaseTrait for MockDatabase {
         std::mem::take(&mut self.transaction_log)
     }
 
-    fn get_syntax(&self) -> Syntax {
+    fn get_database_backend(&self) -> DatabaseBackend {
-        self.syntax
+        self.db_backend
     }
 }
 

src/database/statement.rs

@@ -1,38 +1,37 @@
-use crate::{QueryBuilderBackend, QueryBuilderWithSyntax, SchemaBuilderBackend};
+use crate::DatabaseBackend;
 use sea_query::{
-    inject_parameters, MysqlQueryBuilder, PostgresQueryBuilder, QueryBuilder, SqliteQueryBuilder,
+    inject_parameters, MysqlQueryBuilder, PostgresQueryBuilder, SqliteQueryBuilder, Values,
-    Values,
 };
 use std::fmt;
 
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum Syntax {
-    MySql,
-    Postgres,
-    Sqlite,
-}
-
 #[derive(Debug, Clone, PartialEq)]
 pub struct Statement {
     pub sql: String,
     pub values: Option<Values>,
-    pub syntax: Syntax,
+    pub db_backend: DatabaseBackend,
+}
+
+pub trait IntoStatement {
+    fn into_statement(&self, db_backend: &DatabaseBackend) -> Statement;
 }
 
 impl Statement {
-    pub fn from_string(syntax: Syntax, stmt: String) -> Statement {
+    pub fn from_string(db_backend: DatabaseBackend, stmt: String) -> Statement {
         Statement {
             sql: stmt,
             values: None,
-            syntax,
+            db_backend,
         }
     }
 
-    pub fn from_string_values_tuple(syntax: Syntax, stmt: (String, Values)) -> Statement {
+    pub fn from_string_values_tuple(
+        db_backend: DatabaseBackend,
+        stmt: (String, Values),
+    ) -> Statement {
         Statement {
             sql: stmt.0,
             values: Some(stmt.1),
-            syntax,
+            db_backend,
         }
     }
 }
@@ -44,7 +43,7 @@ impl fmt::Display for Statement {
                 let string = inject_parameters(
                     &self.sql,
                     values.0.clone(),
-                    self.syntax.get_query_builder().as_ref(),
+                    self.db_backend.get_query_builder().as_ref(),
                 );
                 write!(f, "{}", &string)
             }
@@ -55,46 +54,45 @@ impl fmt::Display for Statement {
     }
 }
 
-impl Syntax {
+macro_rules! build_any_stmt {
-    pub fn get_query_builder(&self) -> Box<dyn QueryBuilder> {
+    ($stmt: expr, $db_backend: expr) => {
-        match self {
+        match $db_backend {
-            Self::MySql => Box::new(MysqlQueryBuilder),
+            DatabaseBackend::MySql => $stmt.build(MysqlQueryBuilder),
-            Self::Postgres => Box::new(PostgresQueryBuilder),
+            DatabaseBackend::Postgres => $stmt.build(PostgresQueryBuilder),
-            Self::Sqlite => Box::new(SqliteQueryBuilder),
+            DatabaseBackend::Sqlite => $stmt.build(SqliteQueryBuilder),
-        }
-    }
-
-    pub fn get_query_builder_backend(&self) -> QueryBuilderBackend {
-        match self {
-            Self::MySql => QueryBuilderBackend::MySql,
-            Self::Postgres => QueryBuilderBackend::Postgres,
-            Self::Sqlite => QueryBuilderBackend::Sqlite,
-        }
-    }
-
-    pub fn get_schema_builder_backend(&self) -> SchemaBuilderBackend {
-        match self {
-            Self::MySql => SchemaBuilderBackend::MySql,
-            Self::Postgres => SchemaBuilderBackend::Postgres,
-            Self::Sqlite => SchemaBuilderBackend::Sqlite,
-        }
         }
+    };
 }
 
-impl QueryBuilderWithSyntax for MysqlQueryBuilder {
+macro_rules! build_query_stmt {
-    fn syntax(&self) -> Syntax {
+    ($stmt: ty) => {
-        Syntax::MySql
+        impl IntoStatement for $stmt {
+            fn into_statement(&self, db_backend: &DatabaseBackend) -> Statement {
+                let stmt = build_any_stmt!(self, db_backend);
+                Statement::from_string_values_tuple(*db_backend, stmt)
             }
+        }
+    };
 }
 
-impl QueryBuilderWithSyntax for PostgresQueryBuilder {
+build_query_stmt!(sea_query::InsertStatement);
-    fn syntax(&self) -> Syntax {
+build_query_stmt!(sea_query::SelectStatement);
-        Syntax::Postgres
+build_query_stmt!(sea_query::UpdateStatement);
+build_query_stmt!(sea_query::DeleteStatement);
+
+macro_rules! build_schema_stmt {
+    ($stmt: ty) => {
+        impl IntoStatement for $stmt {
+            fn into_statement(&self, db_backend: &DatabaseBackend) -> Statement {
+                let stmt = build_any_stmt!(self, db_backend);
+                Statement::from_string(*db_backend, stmt)
             }
+        }
+    };
 }
 
-impl QueryBuilderWithSyntax for SqliteQueryBuilder {
+build_schema_stmt!(sea_query::TableCreateStatement);
-    fn syntax(&self) -> Syntax {
+build_schema_stmt!(sea_query::TableDropStatement);
-        Syntax::Sqlite
+build_schema_stmt!(sea_query::TableAlterStatement);
-    }
+build_schema_stmt!(sea_query::TableRenameStatement);
-}
+build_schema_stmt!(sea_query::TableTruncateStatement);

src/database/transaction.rs

@@ -1,4 +1,4 @@
-use crate::{Statement, Syntax};
+use crate::{DatabaseBackend, Statement};
 use sea_query::{Value, Values};
 
 #[derive(Debug, Clone, PartialEq)]
@@ -7,12 +7,12 @@ pub struct Transaction {
 }
 
 impl Transaction {
-    pub fn from_sql_and_values<I>(syntax: Syntax, sql: &str, values: I) -> Self
+    pub fn from_sql_and_values<I>(db_backend: DatabaseBackend, sql: &str, values: I) -> Self
     where
         I: IntoIterator<Item = Value>,
     {
         Self::one(Statement::from_string_values_tuple(
-            syntax,
+            db_backend,
             (sql.to_string(), Values(values.into_iter().collect())),
         ))
     }

src/driver/mock.rs

@@ -1,6 +1,6 @@
 use crate::{
-    debug_print, error::*, DatabaseConnection, ExecResult, MockDatabase, QueryBuilderBackend,
+    debug_print, error::*, DatabaseBackend, DatabaseConnection, ExecResult, MockDatabase,
-    QueryResult, SchemaBuilderBackend, Statement, Syntax, Transaction,
+    QueryResult, Statement, Transaction,
 };
 use std::sync::{
     atomic::{AtomicUsize, Ordering},
@@ -21,7 +21,7 @@ pub trait MockDatabaseTrait: Send {
 
     fn drain_transaction_log(&mut self) -> Vec<Transaction>;
 
-    fn get_syntax(&self) -> Syntax;
+    fn get_database_backend(&self) -> DatabaseBackend;
 }
 
 impl MockDatabaseConnector {
@@ -48,13 +48,13 @@ impl MockDatabaseConnector {
 
         #[cfg(feature = "sqlx-mysql")]
         if crate::SqlxMySqlConnector::accepts(string) {
-            return connect_mock_db!(Syntax::MySql);
+            return connect_mock_db!(DatabaseBackend::MySql);
         }
         #[cfg(feature = "sqlx-sqlite")]
         if crate::SqlxSqliteConnector::accepts(string) {
-            return connect_mock_db!(Syntax::Sqlite);
+            return connect_mock_db!(DatabaseBackend::Sqlite);
         }
-        connect_mock_db!(Syntax::Postgres)
+        connect_mock_db!(DatabaseBackend::Postgres)
     }
 }
 
@@ -92,19 +92,7 @@ impl MockDatabaseConnection {
         self.mocker.lock().unwrap().query(counter, statement)
     }
 
-    pub fn get_query_builder_backend(&self) -> QueryBuilderBackend {
+    pub fn get_database_backend(&self) -> DatabaseBackend {
-        self.mocker
+        self.mocker.lock().unwrap().get_database_backend()
-            .lock()
-            .unwrap()
-            .get_syntax()
-            .get_query_builder_backend()
-    }
-
-    pub fn get_schema_builder_backend(&self) -> SchemaBuilderBackend {
-        self.mocker
-            .lock()
-            .unwrap()
-            .get_syntax()
-            .get_schema_builder_backend()
     }
 }

src/entity/base_entity.rs

@@ -70,9 +70,9 @@ pub trait EntityTrait: EntityName {
     ///
     /// ```
     /// # #[cfg(feature = "mock")]
-    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, Transaction, Syntax};
+    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, Transaction, DatabaseBackend};
     /// #
-    /// # let db = MockDatabase::new(Syntax::Postgres)
+    /// # let db = MockDatabase::new(DatabaseBackend::Postgres)
     /// #     .append_query_results(vec![
     /// #         vec![
     /// #             cake::Model {
@@ -126,10 +126,10 @@ pub trait EntityTrait: EntityName {
     ///     db.into_transaction_log(),
     ///     vec![
     ///     Transaction::from_sql_and_values(
-    ///         Syntax::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake" LIMIT $1"#, vec![1u64.into()]
+    ///         DatabaseBackend::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake" LIMIT $1"#, vec![1u64.into()]
     ///     ),
     ///     Transaction::from_sql_and_values(
-    ///         Syntax::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake""#, vec![]
+    ///         DatabaseBackend::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake""#, vec![]
     ///     ),
     /// ]);
     /// ```
@@ -143,9 +143,9 @@ pub trait EntityTrait: EntityName {
     ///
     /// ```
     /// # #[cfg(feature = "mock")]
-    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, Transaction, Syntax};
+    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, Transaction, DatabaseBackend};
     /// #
-    /// # let db = MockDatabase::new(Syntax::Postgres)
+    /// # let db = MockDatabase::new(DatabaseBackend::Postgres)
     /// #     .append_query_results(vec![
     /// #         vec![
     /// #             cake::Model {
@@ -174,15 +174,15 @@ pub trait EntityTrait: EntityName {
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         Syntax::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE "cake"."id" = $1"#, vec![11i32.into()]
+    ///         DatabaseBackend::Postgres, r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE "cake"."id" = $1"#, vec![11i32.into()]
     ///     )]);
     /// ```
     /// Find by composite key
     /// ```
     /// # #[cfg(feature = "mock")]
-    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, Transaction, Syntax};
+    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, Transaction, DatabaseBackend};
     /// #
-    /// # let db = MockDatabase::new(Syntax::Postgres)
+    /// # let db = MockDatabase::new(DatabaseBackend::Postgres)
     /// #     .append_query_results(vec![
     /// #         vec![
     /// #             cake_filling::Model {
@@ -211,7 +211,7 @@ pub trait EntityTrait: EntityName {
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         Syntax::Postgres,
+    ///         DatabaseBackend::Postgres,
     ///         [
     ///             r#"SELECT "cake_filling"."cake_id", "cake_filling"."filling_id" FROM "cake_filling""#,
     ///             r#"WHERE "cake_filling"."cake_id" = $1 AND "cake_filling"."filling_id" = $2"#,
@@ -245,9 +245,9 @@ pub trait EntityTrait: EntityName {
     ///
     /// ```
     /// # #[cfg(feature = "mock")]
-    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, Syntax};
+    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DatabaseBackend};
     /// #
-    /// # let db = MockDatabase::new(Syntax::Postgres)
+    /// # let db = MockDatabase::new(DatabaseBackend::Postgres)
     /// #     .append_exec_results(vec![
     /// #         MockExecResult {
     /// #             last_insert_id: 15,
@@ -276,7 +276,7 @@ pub trait EntityTrait: EntityName {
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         Syntax::Postgres, r#"INSERT INTO "cake" ("name") VALUES ($1)"#, vec!["Apple Pie".into()]
+    ///         DatabaseBackend::Postgres, r#"INSERT INTO "cake" ("name") VALUES ($1)"#, vec!["Apple Pie".into()]
     ///     )]);
     /// ```
     fn insert<A>(model: A) -> Insert<A>
@@ -292,9 +292,9 @@ pub trait EntityTrait: EntityName {
     ///
     /// ```
     /// # #[cfg(feature = "mock")]
-    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, Syntax};
+    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DatabaseBackend};
     /// #
-    /// # let db = MockDatabase::new(Syntax::Postgres)
+    /// # let db = MockDatabase::new(DatabaseBackend::Postgres)
     /// #     .append_exec_results(vec![
     /// #         MockExecResult {
     /// #             last_insert_id: 28,
@@ -327,7 +327,7 @@ pub trait EntityTrait: EntityName {
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         Syntax::Postgres, r#"INSERT INTO "cake" ("name") VALUES ($1), ($2)"#,
+    ///         DatabaseBackend::Postgres, r#"INSERT INTO "cake" ("name") VALUES ($1), ($2)"#,
     ///         vec!["Apple Pie".into(), "Orange Scone".into()]
     ///     )]);
     /// ```
@@ -347,9 +347,9 @@ pub trait EntityTrait: EntityName {
     ///
     /// ```
     /// # #[cfg(feature = "mock")]
-    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, Syntax};
+    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DatabaseBackend};
     /// #
-    /// # let db = MockDatabase::new(Syntax::Postgres)
+    /// # let db = MockDatabase::new(DatabaseBackend::Postgres)
     /// #     .append_exec_results(vec![
     /// #         MockExecResult {
     /// #             last_insert_id: 0,
@@ -379,7 +379,7 @@ pub trait EntityTrait: EntityName {
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         Syntax::Postgres, r#"UPDATE "fruit" SET "name" = $1 WHERE "fruit"."id" = $2"#, vec!["Orange".into(), 1i32.into()]
+    ///         DatabaseBackend::Postgres, r#"UPDATE "fruit" SET "name" = $1 WHERE "fruit"."id" = $2"#, vec!["Orange".into(), 1i32.into()]
     ///     )]);
     /// ```
     fn update<A>(model: A) -> UpdateOne<A>
@@ -397,9 +397,9 @@ pub trait EntityTrait: EntityName {
     ///
     /// ```
     /// # #[cfg(feature = "mock")]
-    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, Syntax};
+    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DatabaseBackend};
     /// #
-    /// # let db = MockDatabase::new(Syntax::Postgres)
+    /// # let db = MockDatabase::new(DatabaseBackend::Postgres)
     /// #     .append_exec_results(vec![
     /// #         MockExecResult {
     /// #             last_insert_id: 0,
@@ -426,7 +426,7 @@ pub trait EntityTrait: EntityName {
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         Syntax::Postgres, r#"UPDATE "fruit" SET "cake_id" = $1 WHERE "fruit"."name" LIKE $2"#, vec![Value::Null, "%Apple%".into()]
+    ///         DatabaseBackend::Postgres, r#"UPDATE "fruit" SET "cake_id" = $1 WHERE "fruit"."name" LIKE $2"#, vec![Value::Null, "%Apple%".into()]
     ///     )]);
     /// ```
     fn update_many() -> UpdateMany<Self> {
@@ -441,9 +441,9 @@ pub trait EntityTrait: EntityName {
     ///
     /// ```
     /// # #[cfg(feature = "mock")]
-    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, Syntax};
+    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DatabaseBackend};
     /// #
-    /// # let db = MockDatabase::new(Syntax::Postgres)
+    /// # let db = MockDatabase::new(DatabaseBackend::Postgres)
     /// #     .append_exec_results(vec![
     /// #         MockExecResult {
     /// #             last_insert_id: 0,
@@ -471,7 +471,7 @@ pub trait EntityTrait: EntityName {
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         Syntax::Postgres, r#"DELETE FROM "fruit" WHERE "fruit"."id" = $1"#, vec![3i32.into()]
+    ///         DatabaseBackend::Postgres, r#"DELETE FROM "fruit" WHERE "fruit"."id" = $1"#, vec![3i32.into()]
     ///     )]);
     /// ```
     fn delete<A>(model: A) -> DeleteOne<A>
@@ -489,9 +489,9 @@ pub trait EntityTrait: EntityName {
     ///
     /// ```
     /// # #[cfg(feature = "mock")]
-    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, Syntax};
+    /// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DatabaseBackend};
     /// #
-    /// # let db = MockDatabase::new(Syntax::Postgres)
+    /// # let db = MockDatabase::new(DatabaseBackend::Postgres)
     /// #     .append_exec_results(vec![
     /// #         MockExecResult {
     /// #             last_insert_id: 0,
@@ -517,7 +517,7 @@ pub trait EntityTrait: EntityName {
     /// assert_eq!(
     ///     db.into_transaction_log(),
     ///     vec![Transaction::from_sql_and_values(
-    ///         Syntax::Postgres, r#"DELETE FROM "fruit" WHERE "fruit"."name" LIKE $1"#, vec!["%Apple%".into()]
+    ///         DatabaseBackend::Postgres, r#"DELETE FROM "fruit" WHERE "fruit"."name" LIKE $1"#, vec!["%Apple%".into()]
     ///     )]);
     /// ```
     fn delete_many() -> DeleteMany<Self> {

src/entity/column.rs

@@ -88,12 +88,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
     bind_oper!(lte);
 
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .filter(cake::Column::Id.between(2,3))
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`id` BETWEEN 2 AND 3"
     /// );
@@ -106,12 +106,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
     }
 
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .filter(cake::Column::Id.not_between(2,3))
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`id` NOT BETWEEN 2 AND 3"
     /// );
@@ -124,12 +124,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
     }
 
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .filter(cake::Column::Name.like("cheese"))
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE 'cheese'"
     /// );
@@ -139,12 +139,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
     }
 
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .filter(cake::Column::Name.not_like("cheese"))
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` NOT LIKE 'cheese'"
     /// );
@@ -154,12 +154,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
     }
 
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .filter(cake::Column::Name.starts_with("cheese"))
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE 'cheese%'"
     /// );
@@ -170,12 +170,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
     }
 
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .filter(cake::Column::Name.ends_with("cheese"))
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE '%cheese'"
     /// );
@@ -186,12 +186,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
     }
 
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .filter(cake::Column::Name.contains("cheese"))
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`name` LIKE '%cheese%'"
     /// );

src/executor/delete.rs

@@ -49,7 +49,7 @@ impl Deleter {
         self,
         db: &DatabaseConnection,
     ) -> impl Future<Output = Result<DeleteResult, DbErr>> + '_ {
-        let builder = db.get_query_builder_backend();
+        let builder = db.get_database_backend();
         exec_delete(builder.build(&self.query), db)
     }
 }

src/executor/insert.rs

@@ -34,7 +34,7 @@ impl Inserter {
         self,
         db: &DatabaseConnection,
     ) -> impl Future<Output = Result<InsertResult, DbErr>> + '_ {
-        let builder = db.get_query_builder_backend();
+        let builder = db.get_database_backend();
         exec_insert(builder.build(&self.query), db)
     }
 }

src/executor/paginator.rs

@@ -30,7 +30,7 @@ where
             .limit(self.page_size as u64)
             .offset((self.page_size * page) as u64)
             .to_owned();
-        let builder = self.db.get_query_builder_backend();
+        let builder = self.db.get_database_backend();
         let stmt = builder.build(&query);
         let rows = self.db.query_all(stmt).await?;
         let mut buffer = Vec::with_capacity(rows.len());
@@ -48,7 +48,7 @@ where
 
     /// Get the total number of pages
     pub async fn num_pages(&self) -> Result<usize, DbErr> {
-        let builder = self.db.get_query_builder_backend();
+        let builder = self.db.get_database_backend();
         let stmt = builder.build(
             SelectStatement::new()
                 .expr(Expr::cust("COUNT(*) AS num_rows"))
@@ -103,7 +103,7 @@ where
 mod tests {
     use crate::entity::prelude::*;
     use crate::tests_cfg::*;
-    use crate::{DatabaseConnection, MockDatabase, Syntax, Transaction};
+    use crate::{DatabaseBackend, DatabaseConnection, MockDatabase, Transaction};
     use futures::TryStreamExt;
     use sea_query::{Alias, Expr, SelectStatement, Value};
 
@@ -129,7 +129,7 @@ mod tests {
 
         let page3 = Vec::<fruit::Model>::new();
 
-        let db = MockDatabase::new(Syntax::Postgres)
+        let db = MockDatabase::new(DatabaseBackend::Postgres)
             .append_query_results(vec![page1.clone(), page2.clone(), page3.clone()])
             .into_connection();
 
@@ -138,7 +138,7 @@ mod tests {
 
     fn setup_num_rows() -> (DatabaseConnection, i32) {
         let num_rows = 3;
-        let db = MockDatabase::new(Syntax::Postgres)
+        let db = MockDatabase::new(DatabaseBackend::Postgres)
             .append_query_results(vec![vec![maplit::btreemap! {
                 "num_rows" => Into::<Value>::into(num_rows),
             }]])
@@ -166,7 +166,7 @@ mod tests {
             .from(fruit::Entity)
             .to_owned();
 
-        let query_builder = db.get_query_builder_backend();
+        let query_builder = db.get_database_backend();
         let stmts = vec![
             query_builder.build(select.clone().offset(0).limit(2)),
             query_builder.build(select.clone().offset(2).limit(2)),
@@ -200,7 +200,7 @@ mod tests {
             .from(fruit::Entity)
             .to_owned();
 
-        let query_builder = db.get_query_builder_backend();
+        let query_builder = db.get_database_backend();
         let stmts = vec![
             query_builder.build(select.clone().offset(0).limit(2)),
             query_builder.build(select.clone().offset(2).limit(2)),
@@ -236,7 +236,7 @@ mod tests {
             .from_subquery(sub_query, Alias::new("sub_query"))
             .to_owned();
 
-        let query_builder = db.get_query_builder_backend();
+        let query_builder = db.get_database_backend();
         let stmts = vec![query_builder.build(&select)];
 
         assert_eq!(db.into_transaction_log(), Transaction::wrap(stmts));
@@ -283,7 +283,7 @@ mod tests {
             .from(fruit::Entity)
             .to_owned();
 
-        let query_builder = db.get_query_builder_backend();
+        let query_builder = db.get_database_backend();
         let stmts = vec![
             query_builder.build(select.clone().offset(0).limit(2)),
             query_builder.build(select.clone().offset(2).limit(2)),
@@ -315,7 +315,7 @@ mod tests {
             .from(fruit::Entity)
             .to_owned();
 
-        let query_builder = db.get_query_builder_backend();
+        let query_builder = db.get_database_backend();
         let stmts = vec![
             query_builder.build(select.clone().offset(0).limit(2)),
             query_builder.build(select.clone().offset(2).limit(2)),

src/executor/select.rs

@@ -186,7 +186,7 @@ where
     S: SelectorTrait,
 {
     pub async fn one(mut self, db: &DatabaseConnection) -> Result<Option<S::Item>, DbErr> {
-        let builder = db.get_query_builder_backend();
+        let builder = db.get_database_backend();
         self.query.limit(1);
         let row = db.query_one(builder.build(&self.query)).await?;
         match row {
@@ -196,7 +196,7 @@ where
     }
 
     pub async fn all(self, db: &DatabaseConnection) -> Result<Vec<S::Item>, DbErr> {
-        let builder = db.get_query_builder_backend();
+        let builder = db.get_database_backend();
         let rows = db.query_all(builder.build(&self.query)).await?;
         let mut models = Vec::new();
         for row in rows.into_iter() {

src/executor/update.rs

@@ -46,7 +46,7 @@ impl Updater {
         self,
         db: &DatabaseConnection,
     ) -> impl Future<Output = Result<UpdateResult, DbErr>> + '_ {
-        let builder = db.get_query_builder_backend();
+        let builder = db.get_database_backend();
         exec_update(builder.build(&self.query), db)
     }
 }

src/query/combine.rs

@@ -113,7 +113,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::tests_cfg::{cake, fruit};
-    use crate::{ColumnTrait, EntityTrait, QueryFilter, QuerySelect, QueryTrait, Syntax};
+    use crate::{ColumnTrait, DatabaseBackend, EntityTrait, QueryFilter, QuerySelect, QueryTrait};
 
     #[test]
     fn alias_1() {
@@ -121,7 +121,7 @@ mod tests {
             cake::Entity::find()
                 .column_as(cake::Column::Id, "B")
                 .apply_alias("A_")
-                .build(Syntax::MySql)
+                .build(DatabaseBackend::MySql)
                 .to_string(),
             "SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`, `cake`.`id` AS `A_B` FROM `cake`",
         );
@@ -133,7 +133,7 @@ mod tests {
             cake::Entity::find()
                 .left_join(fruit::Entity)
                 .select_also(fruit::Entity)
-                .build(Syntax::MySql)
+                .build(DatabaseBackend::MySql)
                 .to_string(),
             [
                 "SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,",
@@ -149,7 +149,7 @@ mod tests {
             cake::Entity::find()
                 .left_join(fruit::Entity)
                 .select_with(fruit::Entity)
-                .build(Syntax::MySql)
+                .build(DatabaseBackend::MySql)
                 .to_string(),
             [
                 "SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,",
@@ -168,7 +168,7 @@ mod tests {
                 .select_also(fruit::Entity)
                 .filter(cake::Column::Id.eq(1))
                 .filter(fruit::Column::Id.eq(2))
-                .build(Syntax::MySql)
+                .build(DatabaseBackend::MySql)
                 .to_string(),
             [
                 "SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,",
@@ -187,7 +187,7 @@ mod tests {
                 .select_with(fruit::Entity)
                 .filter(cake::Column::Id.eq(1))
                 .filter(fruit::Column::Id.eq(2))
-                .build(Syntax::MySql)
+                .build(DatabaseBackend::MySql)
                 .to_string(),
             [
                 "SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,",

src/query/delete.rs

@@ -31,28 +31,28 @@ impl Delete {
     ///
     /// Model
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     Delete::one(cake::Model {
     ///         id: 1,
     ///         name: "Apple Pie".to_owned(),
     ///     })
-    ///     .build(Syntax::Postgres)
+    ///     .build(DatabaseBackend::Postgres)
     ///     .to_string(),
     ///     r#"DELETE FROM "cake" WHERE "cake"."id" = 1"#,
     /// );
     /// ```
     /// ActiveModel
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     Delete::one(cake::ActiveModel {
     ///         id: ActiveValue::set(1),
     ///         name: ActiveValue::set("Apple Pie".to_owned()),
     ///     })
-    ///     .build(Syntax::Postgres)
+    ///     .build(DatabaseBackend::Postgres)
     ///     .to_string(),
     ///     r#"DELETE FROM "cake" WHERE "cake"."id" = 1"#,
     /// );
@@ -75,12 +75,12 @@ impl Delete {
     /// Delete many ActiveModel
     ///
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::fruit, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::fruit, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     Delete::many(fruit::Entity)
     ///         .filter(fruit::Column::Name.contains("Apple"))
-    ///         .build(Syntax::Postgres)
+    ///         .build(DatabaseBackend::Postgres)
     ///         .to_string(),
     ///     r#"DELETE FROM "fruit" WHERE "fruit"."name" LIKE '%Apple%'"#,
     /// );
@@ -179,7 +179,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::tests_cfg::{cake, fruit};
-    use crate::{entity::*, query::*, Syntax};
+    use crate::{entity::*, query::*, DatabaseBackend};
 
     #[test]
     fn delete_1() {
@@ -188,7 +188,7 @@ mod tests {
                 id: 1,
                 name: "Apple Pie".to_owned(),
             })
-            .build(Syntax::Postgres)
+            .build(DatabaseBackend::Postgres)
             .to_string(),
             r#"DELETE FROM "cake" WHERE "cake"."id" = 1"#,
         );
@@ -197,7 +197,7 @@ mod tests {
                 id: ActiveValue::set(1),
                 name: ActiveValue::set("Apple Pie".to_owned()),
             })
-            .build(Syntax::Postgres)
+            .build(DatabaseBackend::Postgres)
             .to_string(),
             r#"DELETE FROM "cake" WHERE "cake"."id" = 1"#,
         );
@@ -208,7 +208,7 @@ mod tests {
         assert_eq!(
             Delete::many(fruit::Entity)
                 .filter(fruit::Column::Name.contains("Cheese"))
-                .build(Syntax::Postgres)
+                .build(DatabaseBackend::Postgres)
                 .to_string(),
             r#"DELETE FROM "fruit" WHERE "fruit"."name" LIKE '%Cheese%'"#,
         );

src/query/helper.rs

@@ -23,13 +23,13 @@ pub trait QuerySelect: Sized {
 
     /// Add a select column
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .select_only()
     ///         .column(cake::Column::Name)
-    ///         .build(Syntax::Postgres)
+    ///         .build(DatabaseBackend::Postgres)
     ///         .to_string(),
     ///     r#"SELECT "cake"."name" FROM "cake""#
     /// );
@@ -44,13 +44,13 @@ pub trait QuerySelect: Sized {
 
     /// Add a select column with alias
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .select_only()
     ///         .column_as(cake::Column::Id.count(), "count")
-    ///         .build(Syntax::Postgres)
+    ///         .build(DatabaseBackend::Postgres)
     ///         .to_string(),
     ///     r#"SELECT COUNT("cake"."id") AS "count" FROM "cake""#
     /// );
@@ -68,14 +68,14 @@ pub trait QuerySelect: Sized {
 
     /// Add a group by column
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .select_only()
     ///         .column(cake::Column::Name)
     ///         .group_by(cake::Column::Name)
-    ///         .build(Syntax::Postgres)
+    ///         .build(DatabaseBackend::Postgres)
     ///         .to_string(),
     ///     r#"SELECT "cake"."name" FROM "cake" GROUP BY "cake"."name""#
     /// );
@@ -90,13 +90,13 @@ pub trait QuerySelect: Sized {
 
     /// Add an AND HAVING expression
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .having(cake::Column::Id.eq(4))
     ///         .having(cake::Column::Id.eq(5))
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` HAVING `cake`.`id` = 4 AND `cake`.`id` = 5"
     /// );
@@ -151,13 +151,13 @@ pub trait QueryOrder: Sized {
 
     /// Add an order_by expression
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .order_by(cake::Column::Id, Order::Asc)
     ///         .order_by(cake::Column::Name, Order::Desc)
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` ORDER BY `cake`.`id` ASC, `cake`.`name` DESC"
     /// );
@@ -172,12 +172,12 @@ pub trait QueryOrder: Sized {
 
     /// Add an order_by expression (ascending)
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .order_by_asc(cake::Column::Id)
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` ORDER BY `cake`.`id` ASC"
     /// );
@@ -193,12 +193,12 @@ pub trait QueryOrder: Sized {
 
     /// Add an order_by expression (descending)
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .order_by_desc(cake::Column::Id)
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` ORDER BY `cake`.`id` DESC"
     /// );
@@ -221,13 +221,13 @@ pub trait QueryFilter: Sized {
 
     /// Add an AND WHERE expression
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
     ///         .filter(cake::Column::Id.eq(4))
     ///         .filter(cake::Column::Id.eq(5))
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`id` = 4 AND `cake`.`id` = 5"
     /// );
@@ -235,7 +235,7 @@ pub trait QueryFilter: Sized {
     ///
     /// Add a condition tree.
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     cake::Entity::find()
@@ -244,7 +244,7 @@ pub trait QueryFilter: Sized {
     ///                 .add(cake::Column::Id.eq(4))
     ///                 .add(cake::Column::Id.eq(5))
     ///         )
-    ///         .build(Syntax::MySql)
+    ///         .build(DatabaseBackend::MySql)
     ///         .to_string(),
     ///     "SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`id` = 4 OR `cake`.`id` = 5"
     /// );

src/query/insert.rs

@@ -39,28 +39,28 @@ where
     ///
     /// Model
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     Insert::one(cake::Model {
     ///             id: 1,
     ///             name: "Apple Pie".to_owned(),
     ///         })
-    ///         .build(Syntax::Postgres)
+    ///         .build(DatabaseBackend::Postgres)
     ///         .to_string(),
     ///     r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie')"#,
     /// );
     /// ```
     /// ActiveModel
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     Insert::one(cake::ActiveModel {
     ///             id: Unset(None),
     ///             name: Set("Apple Pie".to_owned()),
     ///         })
-    ///         .build(Syntax::Postgres)
+    ///         .build(DatabaseBackend::Postgres)
     ///         .to_string(),
     ///     r#"INSERT INTO "cake" ("name") VALUES ('Apple Pie')"#,
     /// );
@@ -75,7 +75,7 @@ where
     /// Insert many Model or ActiveModel
     ///
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     Insert::many(vec![
@@ -88,7 +88,7 @@ where
     ///                 name: "Orange Scone".to_owned(),
     ///             }
     ///         ])
-    ///         .build(Syntax::Postgres)
+    ///         .build(DatabaseBackend::Postgres)
     ///         .to_string(),
     ///     r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie'), (2, 'Orange Scone')"#,
     /// );
@@ -162,7 +162,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::tests_cfg::cake;
-    use crate::{ActiveValue, Insert, QueryTrait, Syntax};
+    use crate::{ActiveValue, DatabaseBackend, Insert, QueryTrait};
 
     #[test]
     fn insert_1() {
@@ -172,7 +172,7 @@ mod tests {
                     id: ActiveValue::unset(),
                     name: ActiveValue::set("Apple Pie".to_owned()),
                 })
-                .build(Syntax::Postgres)
+                .build(DatabaseBackend::Postgres)
                 .to_string(),
             r#"INSERT INTO "cake" ("name") VALUES ('Apple Pie')"#,
         );
@@ -186,7 +186,7 @@ mod tests {
                     id: ActiveValue::set(1),
                     name: ActiveValue::set("Apple Pie".to_owned()),
                 })
-                .build(Syntax::Postgres)
+                .build(DatabaseBackend::Postgres)
                 .to_string(),
             r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie')"#,
         );
@@ -200,7 +200,7 @@ mod tests {
                     id: 1,
                     name: "Apple Pie".to_owned(),
                 })
-                .build(Syntax::Postgres)
+                .build(DatabaseBackend::Postgres)
                 .to_string(),
             r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie')"#,
         );
@@ -220,7 +220,7 @@ mod tests {
                         name: "Orange Scone".to_owned(),
                     }
                 ])
-                .build(Syntax::Postgres)
+                .build(DatabaseBackend::Postgres)
                 .to_string(),
             r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie'), (2, 'Orange Scone')"#,
         );
@@ -240,7 +240,7 @@ mod tests {
         assert_eq!(
             Insert::<cake::ActiveModel>::new()
                 .add_many(vec![apple, orange])
-                .build(Syntax::Postgres)
+                .build(DatabaseBackend::Postgres)
                 .to_string(),
             r#"INSERT INTO "cake" ("id", "name") VALUES (NULL, 'Apple'), (2, 'Orange')"#,
         );

src/query/join.rs

@@ -62,14 +62,14 @@ where
 #[cfg(test)]
 mod tests {
     use crate::tests_cfg::{cake, filling, fruit};
-    use crate::{ColumnTrait, EntityTrait, ModelTrait, QueryFilter, QueryTrait, Syntax};
+    use crate::{ColumnTrait, DatabaseBackend, EntityTrait, ModelTrait, QueryFilter, QueryTrait};
 
     #[test]
     fn join_1() {
         assert_eq!(
             cake::Entity::find()
                 .left_join(fruit::Entity)
-                .build(Syntax::MySql)
+                .build(DatabaseBackend::MySql)
                 .to_string(),
             [
                 "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
@@ -85,7 +85,7 @@ mod tests {
             cake::Entity::find()
                 .inner_join(fruit::Entity)
                 .filter(fruit::Column::Name.contains("cherry"))
-                .build(Syntax::MySql)
+                .build(DatabaseBackend::MySql)
                 .to_string(),
             [
                 "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
@@ -101,7 +101,7 @@ mod tests {
         assert_eq!(
             fruit::Entity::find()
                 .reverse_join(cake::Entity)
-                .build(Syntax::MySql)
+                .build(DatabaseBackend::MySql)
                 .to_string(),
             [
                 "SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit`",
@@ -119,7 +119,7 @@ mod tests {
         assert_eq!(
             find_fruit
                 .filter(cake::Column::Id.eq(11))
-                .build(Syntax::MySql)
+                .build(DatabaseBackend::MySql)
                 .to_string(),
             [
                 "SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit`",
@@ -140,7 +140,7 @@ mod tests {
         assert_eq!(
             cake_model
                 .find_related(fruit::Entity)
-                .build(Syntax::MySql)
+                .build(DatabaseBackend::MySql)
                 .to_string(),
             [
                 "SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit`",
@@ -156,7 +156,7 @@ mod tests {
         assert_eq!(
             cake::Entity::find()
                 .left_join(filling::Entity)
-                .build(Syntax::MySql)
+                .build(DatabaseBackend::MySql)
                 .to_string(),
             [
                 "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
@@ -173,7 +173,7 @@ mod tests {
 
         let find_filling: Select<filling::Entity> = cake::Entity::find_related();
         assert_eq!(
-            find_filling.build(Syntax::MySql).to_string(),
+            find_filling.build(DatabaseBackend::MySql).to_string(),
             [
                 "SELECT `filling`.`id`, `filling`.`name` FROM `filling`",
                 "INNER JOIN `cake_filling` ON `cake_filling`.`filling_id` = `filling`.`id`",

src/query/json.rs

@@ -102,12 +102,12 @@ impl FromQueryResult for JsonValue {
 #[cfg(feature = "mock")]
 mod tests {
     use crate::tests_cfg::cake;
-    use crate::{entity::*, MockDatabase, Syntax};
+    use crate::{entity::*, DatabaseBackend, MockDatabase};
     use sea_query::Value;
 
     #[async_std::test]
     async fn to_json_1() {
-        let db = MockDatabase::new(Syntax::Postgres)
+        let db = MockDatabase::new(DatabaseBackend::Postgres)
             .append_query_results(vec![vec![maplit::btreemap! {
                 "id" => Into::<Value>::into(128), "name" => Into::<Value>::into("apple")
             }]])

src/query/traits.rs

@@ -1,5 +1,5 @@
-use crate::{Statement, Syntax};
+use crate::{DatabaseBackend, Statement};
-use sea_query::{QueryBuilder, QueryStatementBuilder};
+use sea_query::QueryStatementBuilder;
 
 pub trait QueryTrait {
     type QueryStatement: QueryStatementBuilder;
@@ -14,15 +14,11 @@ pub trait QueryTrait {
     fn into_query(self) -> Self::QueryStatement;
 
     /// Build the query as [`Statement`]
-    fn build(&self, syntax: Syntax) -> Statement {
+    fn build(&self, db_backend: DatabaseBackend) -> Statement {
-        let query_builder = syntax.get_query_builder();
+        let query_builder = db_backend.get_query_builder();
         Statement::from_string_values_tuple(
-            syntax,
+            db_backend,
             self.as_query().build_any(query_builder.as_ref()),
         )
     }
 }
-
-pub trait QueryBuilderWithSyntax: QueryBuilder {
-    fn syntax(&self) -> Syntax;
-}

src/query/update.rs

@@ -30,14 +30,14 @@ impl Update {
     /// Update one ActiveModel
     ///
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::cake, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     Update::one(cake::ActiveModel {
     ///         id: ActiveValue::set(1),
     ///         name: ActiveValue::set("Apple Pie".to_owned()),
     ///     })
-    ///     .build(Syntax::Postgres)
+    ///     .build(DatabaseBackend::Postgres)
     ///     .to_string(),
     ///     r#"UPDATE "cake" SET "name" = 'Apple Pie' WHERE "cake"."id" = 1"#,
     /// );
@@ -59,13 +59,13 @@ impl Update {
     /// Update many ActiveModel
     ///
     /// ```
-    /// use sea_orm::{entity::*, query::*, tests_cfg::fruit, sea_query::Expr, Syntax};
+    /// use sea_orm::{entity::*, query::*, tests_cfg::fruit, sea_query::Expr, DatabaseBackend};
     ///
     /// assert_eq!(
     ///     Update::many(fruit::Entity)
     ///         .col_expr(fruit::Column::Name, Expr::value("Golden Apple"))
     ///         .filter(fruit::Column::Name.contains("Apple"))
-    ///         .build(Syntax::Postgres)
+    ///         .build(DatabaseBackend::Postgres)
     ///         .to_string(),
     ///     r#"UPDATE "fruit" SET "name" = 'Golden Apple' WHERE "fruit"."name" LIKE '%Apple%'"#,
     /// );
@@ -184,7 +184,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::tests_cfg::{cake, fruit};
-    use crate::{entity::*, query::*, Syntax};
+    use crate::{entity::*, query::*, DatabaseBackend};
     use sea_query::{Expr, Value};
 
     #[test]
@@ -194,7 +194,7 @@ mod tests {
                 id: ActiveValue::set(1),
                 name: ActiveValue::set("Apple Pie".to_owned()),
             })
-            .build(Syntax::Postgres)
+            .build(DatabaseBackend::Postgres)
             .to_string(),
             r#"UPDATE "cake" SET "name" = 'Apple Pie' WHERE "cake"."id" = 1"#,
         );
@@ -208,7 +208,7 @@ mod tests {
                 name: ActiveValue::set("Orange".to_owned()),
                 cake_id: ActiveValue::unset(),
             })
-            .build(Syntax::Postgres)
+            .build(DatabaseBackend::Postgres)
             .to_string(),
             r#"UPDATE "fruit" SET "name" = 'Orange' WHERE "fruit"."id" = 1"#,
         );
@@ -222,7 +222,7 @@ mod tests {
                 name: ActiveValue::unchanged("Apple".to_owned()),
                 cake_id: ActiveValue::set(Some(3)),
             })
-            .build(Syntax::Postgres)
+            .build(DatabaseBackend::Postgres)
             .to_string(),
             r#"UPDATE "fruit" SET "cake_id" = 3 WHERE "fruit"."id" = 2"#,
         );
@@ -234,7 +234,7 @@ mod tests {
             Update::many(fruit::Entity)
                 .col_expr(fruit::Column::CakeId, Expr::value(Value::Null))
                 .filter(fruit::Column::Id.eq(2))
-                .build(Syntax::Postgres)
+                .build(DatabaseBackend::Postgres)
                 .to_string(),
             r#"UPDATE "fruit" SET "cake_id" = NULL WHERE "fruit"."id" = 2"#,
         );

tests/basic.rs

@@ -1,4 +1,4 @@
-use sea_orm::{entity::*, error::*, sea_query, tests_cfg::*, DbConn, Statement, Syntax};
+use sea_orm::{entity::*, error::*, sea_query, tests_cfg::*, DatabaseBackend, DbConn, Statement};
 
 mod setup;
 
@@ -28,7 +28,7 @@ async fn setup_schema(db: &DbConn) {
         .build(SqliteQueryBuilder);
 
     let result = db
-        .execute(Statement::from_string(Syntax::Sqlite, stmt))
+        .execute(Statement::from_string(DatabaseBackend::Sqlite, stmt))
         .await;
     println!("Create table cake: {:?}", result);
 }

tests/schema/mod.rs

@@ -4,7 +4,7 @@ use sea_query::{ColumnDef, ForeignKey, ForeignKeyAction, Index, TableCreateState
 pub use super::bakery_chain::*;
 
 async fn create_table(db: &DbConn, stmt: &TableCreateStatement) -> Result<ExecResult, DbErr> {
-    let builder = db.get_schema_builder_backend();
+    let builder = db.get_database_backend();
     db.execute(builder.build(stmt)).await
 }