Adapter postgres url scheme

.gitignore

@@ -1,4 +1,5 @@
 target
 Cargo.lock
 *.sublime*
-.vscode
+.vscode
+.idea/

sea-orm-cli/src/main.rs

@@ -56,7 +56,7 @@ async fn run_generate_command(matches: &ArgMatches<'_>) -> Result<(), Box<dyn Er
                     .filter(|schema| filter_hidden_tables(&schema.info.name))
                     .map(|schema| schema.write())
                     .collect()
-            } else if url.starts_with("postgres://") {
+            } else if url.starts_with("postgres://") || url.starts_with("postgresql://") {
                 use sea_schema::postgres::discovery::SchemaDiscovery;
                 use sqlx::PgPool;
 

src/database/connection.rs

@@ -16,14 +16,32 @@ pub enum DatabaseConnection {
 
 pub type DbConn = DatabaseConnection;
 
+pub trait IntoDbBackend {
+    fn build(&self, statement: &impl StatementBuilder) -> Statement;
+
+    fn get_query_builder(&self) -> Box<dyn QueryBuilder>;
+}
+
 #[derive(Debug, Copy, Clone, PartialEq)]
-pub enum DatabaseBackend {
+pub enum DbBackend {
     MySql,
     Postgres,
     Sqlite,
 }
 
-pub type DbBackend = DatabaseBackend;
+impl IntoDbBackend for DbBackend {
+    fn build(&self, statement: &impl StatementBuilder) -> Statement {
+        statement.build(self)
+    }
+
+    fn get_query_builder(&self) -> Box<dyn QueryBuilder> {
+        match self {
+            Self::MySql => Box::new(MysqlQueryBuilder),
+            Self::Postgres => Box::new(PostgresQueryBuilder),
+            Self::Sqlite => Box::new(SqliteQueryBuilder),
+        }
+    }
+}
 
 impl Default for DatabaseConnection {
     fn default() -> Self {
@@ -128,23 +146,6 @@ impl DatabaseConnection {
     }
 }
 
-impl DbBackend {
-    pub fn build<S>(&self, statement: &S) -> Statement
-    where
-        S: StatementBuilder,
-    {
-        statement.build(self)
-    }
-
-    pub fn get_query_builder(&self) -> Box<dyn QueryBuilder> {
-        match self {
-            Self::MySql => Box::new(MysqlQueryBuilder),
-            Self::Postgres => Box::new(PostgresQueryBuilder),
-            Self::Sqlite => Box::new(SqliteQueryBuilder),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::DatabaseConnection;

src/database/mod.rs

@@ -12,6 +12,17 @@ pub use transaction::*;
 
 use crate::DbErr;
 
+#[derive(Debug)]
+pub struct DbScheme;
+
+impl DbScheme {
+    pub fn starts_with(base_url: &str) -> bool {
+        base_url.starts_with("postgres://")
+            || base_url.starts_with("postgresql://")
+            || base_url.starts_with("mysql://")
+    }
+}
+
 #[derive(Debug, Default)]
 pub struct Database;
 

src/database/statement.rs

@@ -1,4 +1,4 @@
-use crate::DbBackend;
+use crate::{DbBackend, IntoDbBackend};
 use sea_query::{inject_parameters, MysqlQueryBuilder, PostgresQueryBuilder, SqliteQueryBuilder};
 pub use sea_query::{Value, Values};
 use std::fmt;

src/driver/sqlx_mysql.rs

@@ -6,7 +6,7 @@ use sqlx::{
 sea_query::sea_query_driver_mysql!();
 use sea_query_driver_mysql::bind_query;
 
-use crate::{debug_print, error::*, executor::*, DatabaseConnection, Statement};
+use crate::{debug_print, error::*, executor::*, DatabaseConnection, DbScheme, Statement};
 
 use super::sqlx_common::*;
 
@@ -20,7 +20,7 @@ pub struct SqlxMySqlPoolConnection {
 
 impl SqlxMySqlConnector {
     pub fn accepts(string: &str) -> bool {
-        string.starts_with("mysql://")
+        DbScheme::starts_with(string)
     }
 
     pub async fn connect(string: &str) -> Result<DatabaseConnection, DbErr> {

src/driver/sqlx_postgres.rs

@@ -6,7 +6,7 @@ use sqlx::{
 sea_query::sea_query_driver_postgres!();
 use sea_query_driver_postgres::bind_query;
 
-use crate::{debug_print, error::*, executor::*, DatabaseConnection, Statement};
+use crate::{debug_print, error::*, executor::*, DatabaseConnection, DbScheme, Statement};
 
 use super::sqlx_common::*;
 
@@ -20,7 +20,7 @@ pub struct SqlxPostgresPoolConnection {
 
 impl SqlxPostgresConnector {
     pub fn accepts(string: &str) -> bool {
-        string.starts_with("postgres://")
+        DbScheme::starts_with(string)
     }
 
     pub async fn connect(string: &str) -> Result<DatabaseConnection, DbErr> {

src/entity/column.rs

@@ -438,14 +438,8 @@ mod tests {
             impl ActiveModelBehavior for ActiveModel {}
         }
 
-        assert_eq!(
-            hello::Column::One.def(),
-            ColumnType::Integer.def()
-        );
-        assert_eq!(
-            hello::Column::Two.def(),
-            ColumnType::Integer.def().unique()
-        );
+        assert_eq!(hello::Column::One.def(), ColumnType::Integer.def());
+        assert_eq!(hello::Column::Two.def(), ColumnType::Integer.def().unique());
         assert_eq!(
             hello::Column::Three.def(),
             ColumnType::Integer.def().indexed()

src/executor/delete.rs

@@ -1,5 +1,6 @@
 use crate::{
-    error::*, ActiveModelTrait, DatabaseConnection, DeleteMany, DeleteOne, EntityTrait, Statement,
+    error::*, ActiveModelTrait, DatabaseConnection, DeleteMany, DeleteOne, EntityTrait,
+    IntoDbBackend, Statement,
 };
 use sea_query::DeleteStatement;
 use std::future::Future;

src/executor/insert.rs

@@ -1,6 +1,6 @@
 use crate::{
-    error::*, ActiveModelTrait, DatabaseConnection, EntityTrait, Insert, PrimaryKeyTrait,
-    Statement, TryFromU64,
+    error::*, ActiveModelTrait, DatabaseConnection, EntityTrait, Insert, IntoDbBackend,
+    PrimaryKeyTrait, Statement, TryFromU64,
 };
 use sea_query::InsertStatement;
 use std::{future::Future, marker::PhantomData};

src/executor/paginator.rs

@@ -1,4 +1,4 @@
-use crate::{error::*, DatabaseConnection, SelectorTrait};
+use crate::{error::*, DatabaseConnection, IntoDbBackend, SelectorTrait};
 use async_stream::stream;
 use futures::Stream;
 use sea_query::{Alias, Expr, SelectStatement};
@@ -159,7 +159,7 @@ where
 mod tests {
     use crate::entity::prelude::*;
     use crate::tests_cfg::*;
-    use crate::{DatabaseConnection, DbBackend, MockDatabase, Transaction};
+    use crate::{DatabaseConnection, DbBackend, IntoDbBackend, MockDatabase, Transaction};
     use futures::TryStreamExt;
     use sea_query::{Alias, Expr, SelectStatement, Value};
 

src/executor/select.rs

@@ -1,7 +1,7 @@
 use crate::{
-    error::*, DatabaseConnection, EntityTrait, FromQueryResult, IdenStatic, Iterable, JsonValue,
-    ModelTrait, Paginator, PrimaryKeyToColumn, QueryResult, Select, SelectA, SelectB, SelectTwo,
-    SelectTwoMany, Statement,
+    error::*, DatabaseConnection, EntityTrait, FromQueryResult, IdenStatic, IntoDbBackend,
+    Iterable, JsonValue, ModelTrait, Paginator, PrimaryKeyToColumn, QueryResult, Select, SelectA,
+    SelectB, SelectTwo, SelectTwoMany, Statement,
 };
 use sea_query::SelectStatement;
 use std::marker::PhantomData;

src/executor/update.rs

@@ -1,5 +1,6 @@
 use crate::{
-    error::*, ActiveModelTrait, DatabaseConnection, EntityTrait, Statement, UpdateMany, UpdateOne,
+    error::*, ActiveModelTrait, DatabaseConnection, EntityTrait, IntoDbBackend, Statement,
+    UpdateMany, UpdateOne,
 };
 use sea_query::UpdateStatement;
 use std::future::Future;

src/query/traits.rs

@@ -1,4 +1,4 @@
-use crate::{DbBackend, Statement};
+use crate::{DatabaseConnection, DbBackend, IntoDbBackend, Statement};
 use sea_query::QueryStatementBuilder;
 
 pub trait QueryTrait {
@@ -22,3 +22,115 @@ pub trait QueryTrait {
         )
     }
 }
+
+#[derive(Debug)]
+pub struct DebugQuery<'a, Q, T> {
+    pub query: &'a Q,
+    pub value: T,
+}
+
+impl<'a, Q> DebugQuery<'a, Q, DbBackend>
+where
+    Q: QueryTrait,
+{
+    pub fn build(&self) -> Statement {
+        self.query.build(self.value)
+    }
+}
+
+impl<'a, Q> DebugQuery<'a, Q, &DatabaseConnection>
+where
+    Q: QueryTrait,
+{
+    pub fn build(&self) -> Statement {
+        self.query.build(self.value.get_database_backend())
+    }
+}
+
+impl<'a, Q> DebugQuery<'a, Q, DatabaseConnection>
+where
+    Q: QueryTrait,
+{
+    pub fn build(&self) -> Statement {
+        self.query.build(self.value.get_database_backend())
+    }
+}
+
+/// Make get raw_sql becomes simply. It does not need to specify a specific `DbBackend`,
+/// but can be obtained through `get_database_backend` with `DatabaseConnection`.
+/// Return a Statement type.
+///
+///
+/// # Example
+///
+/// ```
+/// # #[cfg(feature = "mock")]
+/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DbBackend};
+/// #
+/// # let conn = MockDatabase::new(DbBackend::Postgres)
+/// #     .into_connection();
+/// #
+/// use sea_orm::{entity::*, query::*, tests_cfg::cake,gen_statement};
+///
+/// let c = cake::Entity::insert(
+///    cake::ActiveModel {
+///         id: ActiveValue::set(1),
+///         name: ActiveValue::set("Apple Pie".to_owned()),
+/// });
+///
+/// let raw_sql = gen_statement!(&c,&conn).to_string();
+/// assert_eq!(raw_sql,r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie')"#);
+///
+/// let raw_sql = gen_statement!(&c,conn).to_string();
+/// assert_eq!(raw_sql,r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie')"#);
+///
+/// let raw_sql = gen_statement!(&c,DbBackend::MySql).to_string();
+/// assert_eq!(raw_sql,r#"INSERT INTO `cake` (`id`, `name`) VALUES (1, 'Apple Pie')"#);
+///
+/// ```
+#[macro_export]
+macro_rules! gen_statement {
+    ($query:expr,$value:expr) => {
+        $crate::DebugQuery {
+            query: $query,
+            value: $value,
+        }
+        .build();
+    };
+}
+
+/// Use `debug_query` macro get raw_sql.
+///
+/// # Example
+///
+/// ```
+/// # #[cfg(feature = "mock")]
+/// # use sea_orm::{error::*, tests_cfg::*, MockDatabase, MockExecResult, Transaction, DbBackend};
+/// #
+/// # let conn = MockDatabase::new(DbBackend::Postgres)
+/// #     .into_connection();
+/// #
+/// use sea_orm::{entity::*, query::*, tests_cfg::cake,debug_query};
+///
+/// let c = cake::Entity::insert(
+///    cake::ActiveModel {
+///         id: ActiveValue::set(1),
+///         name: ActiveValue::set("Apple Pie".to_owned()),
+/// });
+///
+/// let raw_sql = debug_query!(&c,&conn);
+/// assert_eq!(raw_sql,r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie')"#);
+///
+/// let raw_sql = debug_query!(&c,conn);
+/// assert_eq!(raw_sql,r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie')"#);
+///
+/// let raw_sql = debug_query!(&c,DbBackend::Sqlite);
+/// assert_eq!(raw_sql,r#"INSERT INTO `cake` (`id`, `name`) VALUES (1, 'Apple Pie')"#);
+///
+/// ```
+#[macro_export]
+macro_rules! debug_query {
+    ($query:expr,$value:expr) => {
+        $crate::gen_statement!($query, $value).to_string();
+    };
+}

tests/basic.rs

@@ -1,6 +1,6 @@
 pub mod common;
 
-pub use sea_orm::{entity::*, error::*, sea_query, tests_cfg::*, Database, DbConn};
+pub use sea_orm::{entity::*, error::*, sea_query, tests_cfg::*, Database, DbConn, IntoDbBackend};
 
 // cargo test --features sqlx-sqlite,runtime-async-std-native-tls --test basic
 #[sea_orm_macros::test]

tests/common/setup/mod.rs

@@ -1,4 +1,4 @@
-use sea_orm::{Database, DatabaseBackend, DatabaseConnection, Statement};
+use sea_orm::{Database, DatabaseConnection, DbBackend, Statement};
 pub mod schema;
 pub use schema::*;
 
@@ -8,14 +8,14 @@ pub async fn setup(base_url: &str, db_name: &str) -> DatabaseConnection {
         let db = Database::connect(&url).await.unwrap();
         let _drop_db_result = db
             .execute(Statement::from_string(
-                DatabaseBackend::MySql,
+                DbBackend::MySql,
                 format!("DROP DATABASE IF EXISTS `{}`;", db_name),
             ))
             .await;
 
         let _create_db_result = db
             .execute(Statement::from_string(
-                DatabaseBackend::MySql,
+                DbBackend::MySql,
                 format!("CREATE DATABASE `{}`;", db_name),
             ))
             .await;
@@ -27,14 +27,14 @@ pub async fn setup(base_url: &str, db_name: &str) -> DatabaseConnection {
         let db = Database::connect(&url).await.unwrap();
         let _drop_db_result = db
             .execute(Statement::from_string(
-                DatabaseBackend::Postgres,
+                DbBackend::Postgres,
                 format!("DROP DATABASE IF EXISTS \"{}\";", db_name),
             ))
             .await;
 
         let _create_db_result = db
             .execute(Statement::from_string(
-                DatabaseBackend::Postgres,
+                DbBackend::Postgres,
                 format!("CREATE DATABASE \"{}\";", db_name),
             ))
             .await;
@@ -63,7 +63,7 @@ pub async fn tear_down(base_url: &str, db_name: &str) {
         let db = Database::connect(&url).await.unwrap();
         let _ = db
             .execute(Statement::from_string(
-                DatabaseBackend::MySql,
+                DbBackend::MySql,
                 format!("DROP DATABASE IF EXISTS \"{}\";", db_name),
             ))
             .await;
@@ -72,7 +72,7 @@ pub async fn tear_down(base_url: &str, db_name: &str) {
         let db = Database::connect(&url).await.unwrap();
         let _ = db
             .execute(Statement::from_string(
-                DatabaseBackend::Postgres,
+                DbBackend::Postgres,
                 format!("DROP DATABASE IF EXISTS \"{}\";", db_name),
             ))
             .await;