WIP strange fail with postgres driver

src/database/connection.rs

@@ -39,7 +39,7 @@ impl std::fmt::Debug for DatabaseConnection {
                 #[cfg(feature = "sqlx-mysql")]
                 Self::SqlxMySqlPoolConnection(_) => "SqlxMySqlPoolConnection",
                 #[cfg(feature = "sqlx-postgres")]
-                Self::SqlxPostgresPoolConnection(_) => "SqlxMySqlPoolConnection",
+                Self::SqlxPostgresPoolConnection(_) => "SqlxPostgresPoolConnection",
                 #[cfg(feature = "sqlx-sqlite")]
                 Self::SqlxSqlitePoolConnection(_) => "SqlxSqlitePoolConnection",
                 #[cfg(feature = "mock")]

tests/bakery_chain_tests.rs

@@ -27,10 +27,10 @@ async fn create_entities(db: &DatabaseConnection) {
     crud::create_lineitem::test_create_lineitem(db).await;
     crud::create_order::test_create_order(db).await;
 
-    crud::updates::test_update_cake(db).await;
+    // crud::updates::test_update_cake(db).await;
-    crud::updates::test_update_bakery(db).await;
+    // crud::updates::test_update_bakery(db).await;
-    crud::updates::test_update_deleted_customer(db).await;
+    // crud::updates::test_update_deleted_customer(db).await;
 
-    crud::deletes::test_delete_cake(db).await;
+    // crud::deletes::test_delete_cake(db).await;
-    crud::deletes::test_delete_bakery(db).await;
+    // crud::deletes::test_delete_bakery(db).await;
 }

tests/common/bakery_chain/lineitem.rs

@@ -15,8 +15,8 @@ pub struct Model {
     pub id: i32,
     pub price: Decimal,
     pub quantity: i32,
-    pub order_id: Option<i32>,
+    pub order_id: i32,
-    pub cake_id: Option<i32>,
+    pub cake_id: i32,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
@@ -51,7 +51,7 @@ impl ColumnTrait for Column {
     fn def(&self) -> ColumnDef {
         match self {
             Self::Id => ColumnType::Integer.def(),
-            Self::Price => ColumnType::Money(Some((19, 4))).def(),
+            Self::Price => ColumnType::Decimal(Some((19, 4))).def(),
             Self::Quantity => ColumnType::Integer.def(),
             Self::OrderId => ColumnType::Integer.def(),
             Self::CakeId => ColumnType::Integer.def(),

tests/common/bakery_chain/order.rs

@@ -15,8 +15,8 @@ impl EntityName for Entity {
 pub struct Model {
     pub id: i32,
     pub total: Decimal,
-    pub bakery_id: Option<i32>,
+    pub bakery_id: i32,
-    pub customer_id: Option<i32>,
+    pub customer_id: i32,
     pub placed_at: NaiveDateTime,
 }
 

tests/common/setup/mod.rs

@@ -3,24 +3,57 @@ pub mod schema;
 pub use schema::*;
 
 pub async fn setup(base_url: &str, db_name: &str) -> DatabaseConnection {
-    let url = format!("{}/mysql", base_url);
+    let db = if cfg!(feature = "sqlx-mysql") {
-    let db = Database::connect(&url).await.unwrap();
+        println!("sqlx-mysql");
-    let _drop_db_result = db
-        .execute(Statement::from_string(
-            DatabaseBackend::MySql,
-            format!("DROP DATABASE IF EXISTS `{}`;", db_name),
-        ))
-        .await;
 
-    let _create_db_result = db
+        let url = format!("{}/mysql", base_url);
-        .execute(Statement::from_string(
+        let db = Database::connect(&url).await.unwrap();
-            DatabaseBackend::MySql,
+        let _drop_db_result = db
-            format!("CREATE DATABASE `{}`;", db_name),
+            .execute(Statement::from_string(
-        ))
+                DatabaseBackend::MySql,
-        .await;
+                format!("DROP DATABASE IF EXISTS `{}`;", db_name),
+            ))
+            .await;
 
-    let url = format!("{}/{}", base_url, db_name);
+        let _create_db_result = db
-    let db = Database::connect(&url).await.unwrap();
+            .execute(Statement::from_string(
+                DatabaseBackend::MySql,
+                format!("CREATE DATABASE `{}`;", db_name),
+            ))
+            .await;
+
+        let url = format!("{}/{}", base_url, db_name);
+        Database::connect(&url).await.unwrap()
+    } else if cfg!(feature = "sqlx-postgres") {
+        println!("sqlx-postgres");
+
+        let url = format!("{}/postgres", base_url);
+        println!("url: {:#?}", url);
+        let db = Database::connect(&url).await.unwrap();
+        println!("db: {:#?}", db);
+        let _drop_db_result = db
+            .execute(Statement::from_string(
+                DatabaseBackend::Postgres,
+                format!("DROP DATABASE IF EXISTS \"{}\";", db_name),
+            ))
+            .await;
+
+        let _create_db_result = db
+            .execute(Statement::from_string(
+                DatabaseBackend::Postgres,
+                format!("CREATE DATABASE \"{}\";", db_name),
+            ))
+            .await;
+
+        let url = format!("{}/{}", base_url, db_name);
+        println!("url: {:#?}", url);
+
+        Database::connect(&url).await.unwrap()
+    } else {
+        println!("sqlx-sqlite");
+
+        Database::connect("sqlite::memory:").await.unwrap()
+    };
 
     assert!(schema::create_bakery_table(&db).await.is_ok());
     assert!(schema::create_baker_table(&db).await.is_ok());
@@ -33,12 +66,30 @@ pub async fn setup(base_url: &str, db_name: &str) -> DatabaseConnection {
 }
 
 pub async fn tear_down(base_url: &str, db_name: &str) {
-    let url = format!("{}/mysql", base_url);
+    if cfg!(feature = "sqlx-mysql") {
-    let db = Database::connect(&url).await.unwrap();
+        println!("sqlx-mysql");
-    let _drop_db_result = db
+
-        .execute(Statement::from_string(
+        let url = format!("{}/mysql", base_url);
-            DatabaseBackend::MySql,
+        let db = Database::connect(&url).await.unwrap();
-            format!("DROP DATABASE IF EXISTS `{}`;", db_name),
+        let _ = db
-        ))
+            .execute(Statement::from_string(
-        .await;
+                DatabaseBackend::MySql,
+                format!("DROP DATABASE IF EXISTS \"{}\";", db_name),
+            ))
+            .await;
+    } else if cfg!(feature = "sqlx-postgres") {
+        println!("sqlx-postgres");
+
+        let url = format!("{}/postgres", base_url);
+        println!("url: {:#?}", url);
+        let db = Database::connect(&url).await.unwrap();
+        let _ = db
+            .execute(Statement::from_string(
+                DatabaseBackend::Postgres,
+                format!("DROP DATABASE IF EXISTS \"{}\";", db_name),
+            ))
+            .await;
+    } else {
+        println!("sqlx-sqlite");
+    };
 }

tests/crud/create_lineitem.rs

@@ -70,8 +70,8 @@ pub async fn test_create_lineitem(db: &DbConn) {
 
     // Order
     let order_1 = order::ActiveModel {
-        bakery_id: Set(Some(bakery_insert_res.last_insert_id as i32)),
+        bakery_id: Set(bakery_insert_res.last_insert_id as i32),
-        customer_id: Set(Some(customer_insert_res.last_insert_id as i32)),
+        customer_id: Set(customer_insert_res.last_insert_id as i32),
         total: Set(dec!(7.55)),
         placed_at: Set(Utc::now().naive_utc()),
         ..Default::default()
@@ -83,8 +83,8 @@ pub async fn test_create_lineitem(db: &DbConn) {
 
     // Lineitem
     let lineitem_1 = lineitem::ActiveModel {
-        cake_id: Set(Some(cake_insert_res.last_insert_id as i32)),
+        cake_id: Set(cake_insert_res.last_insert_id as i32),
-        order_id: Set(Some(order_insert_res.last_insert_id as i32)),
+        order_id: Set(order_insert_res.last_insert_id as i32),
         price: Set(dec!(7.55)),
         quantity: Set(1),
         ..Default::default()
@@ -102,9 +102,10 @@ pub async fn test_create_lineitem(db: &DbConn) {
 
     assert!(lineitem.is_some());
     let lineitem_model = lineitem.unwrap();
+
     assert_eq!(lineitem_model.price, dec!(7.55));
 
-    let cake: Option<cake::Model> = Cake::find_by_id(lineitem_model.cake_id)
+    let cake: Option<cake::Model> = Cake::find_by_id(lineitem_model.cake_id as u64)
         .one(db)
         .await
         .expect("could not find cake");
@@ -119,7 +120,7 @@ pub async fn test_create_lineitem(db: &DbConn) {
 
     let order_model = order.unwrap();
     assert_eq!(
-        order_model.customer_id.unwrap(),
+        order_model.customer_id,
         customer_insert_res.last_insert_id as i32
     );
 }

tests/crud/create_order.rs

@@ -70,8 +70,8 @@ pub async fn test_create_order(db: &DbConn) {
 
     // Order
     let order_1 = order::ActiveModel {
-        bakery_id: Set(Some(bakery_insert_res.last_insert_id as i32)),
+        bakery_id: Set(bakery_insert_res.last_insert_id as i32),
-        customer_id: Set(Some(customer_insert_res.last_insert_id as i32)),
+        customer_id: Set(customer_insert_res.last_insert_id as i32),
         total: Set(dec!(15.10)),
         placed_at: Set(Utc::now().naive_utc()),
         ..Default::default()
@@ -81,10 +81,12 @@ pub async fn test_create_order(db: &DbConn) {
         .await
         .expect("could not insert order");
 
+    println!("order_insert_res: {:#?}", order_insert_res);
+
     // Lineitem
     let lineitem_1 = lineitem::ActiveModel {
-        cake_id: Set(Some(cake_insert_res.last_insert_id as i32)),
+        cake_id: Set(cake_insert_res.last_insert_id as i32),
-        order_id: Set(Some(order_insert_res.last_insert_id as i32)),
+        order_id: Set(order_insert_res.last_insert_id as i32),
         price: Set(dec!(7.55)),
         quantity: Set(2),
         ..Default::default()
@@ -94,37 +96,48 @@ pub async fn test_create_order(db: &DbConn) {
         .await
         .expect("could not insert lineitem");
 
+    // This fails with "error returned from database: incorrect binary data format in bind parameter 1"
     let order: Option<order::Model> = Order::find_by_id(order_insert_res.last_insert_id)
         .one(db)
         .await
         .expect("could not find order");
 
-    assert!(order.is_some());
+    // this is ok
-    let order_model = order.unwrap();
+    let orders: Vec<order::Model> = Order::find_by_id(order_insert_res.last_insert_id)
-    assert_eq!(order_model.total, dec!(15.10));
-
-    let customer: Option<customer::Model> = Customer::find_by_id(order_model.customer_id)
-        .one(db)
-        .await
-        .expect("could not find customer");
-
-    let customer_model = customer.unwrap();
-    assert_eq!(customer_model.name, "Kate");
-
-    let bakery: Option<bakery::Model> = Bakery::find_by_id(order_model.bakery_id)
-        .one(db)
-        .await
-        .expect("could not find bakery");
-
-    let bakery_model = bakery.unwrap();
-    assert_eq!(bakery_model.name, "SeaSide Bakery");
-
-    let related_lineitems: Vec<lineitem::Model> = order_model
-        .find_related(Lineitem)
         .all(db)
         .await
-        .expect("could not find related lineitems");
+        .unwrap();
-    assert_eq!(related_lineitems.len(), 1);
+    println!("order: {:#?}", orders);
-    assert_eq!(related_lineitems[0].price, dec!(7.55));
+    let order: order::Model = orders[0].clone();
-    assert_eq!(related_lineitems[0].quantity, 2);
+    println!("order: {:#?}", order);
+
+    assert_eq!(1, 2);
+    // assert!(order.is_some());
+    // let order_model = order.unwrap();
+    // assert_eq!(order_model.total, dec!(15.10));
+
+    // let customer: Option<customer::Model> = Customer::find_by_id(order_model.customer_id)
+    //     .one(db)
+    //     .await
+    //     .expect("could not find customer");
+
+    // let customer_model = customer.unwrap();
+    // assert_eq!(customer_model.name, "Kate");
+
+    // let bakery: Option<bakery::Model> = Bakery::find_by_id(order_model.bakery_id)
+    //     .one(db)
+    //     .await
+    //     .expect("could not find bakery");
+
+    // let bakery_model = bakery.unwrap();
+    // assert_eq!(bakery_model.name, "SeaSide Bakery");
+
+    // let related_lineitems: Vec<lineitem::Model> = order_model
+    //     .find_related(Lineitem)
+    //     .all(db)
+    //     .await
+    //     .expect("could not find related lineitems");
+    // assert_eq!(related_lineitems.len(), 1);
+    // assert_eq!(related_lineitems[0].price, dec!(7.55));
+    // assert_eq!(related_lineitems[0].quantity, 2);
 }

tests/pg_tests.rs

@@ -12,6 +12,7 @@ use sea_query::{ColumnDef, TableCreateStatement};
 #[cfg_attr(feature = "runtime-async-std", async_std::test)]
 #[cfg_attr(feature = "runtime-actix", actix_rt::test)]
 #[cfg_attr(feature = "runtime-tokio", tokio::test)]
+#[async_std::test]
 #[cfg(feature = "sqlx-postgres")]
 async fn main() {
     let base_url = "postgres://root:root@localhost";

tests/relational_tests.rs

@@ -124,8 +124,8 @@ pub async fn right_join() {
     .expect("could not insert customer");
 
     let _order = order::ActiveModel {
-        bakery_id: Set(Some(bakery.id.clone().unwrap())),
+        bakery_id: Set(bakery.id.clone().unwrap()),
-        customer_id: Set(Some(customer_kate.id.clone().unwrap())),
+        customer_id: Set(customer_kate.id.clone().unwrap()),
         total: Set(dec!(15.10)),
         placed_at: Set(Utc::now().naive_utc()),
 
@@ -209,8 +209,8 @@ pub async fn inner_join() {
     .expect("could not insert customer");
 
     let kate_order_1 = order::ActiveModel {
-        bakery_id: Set(Some(bakery.id.clone().unwrap())),
+        bakery_id: Set(bakery.id.clone().unwrap()),
-        customer_id: Set(Some(customer_kate.id.clone().unwrap())),
+        customer_id: Set(customer_kate.id.clone().unwrap()),
         total: Set(dec!(15.10)),
         placed_at: Set(Utc::now().naive_utc()),
 
@@ -221,8 +221,8 @@ pub async fn inner_join() {
     .expect("could not insert order");
 
     let kate_order_2 = order::ActiveModel {
-        bakery_id: Set(Some(bakery.id.clone().unwrap())),
+        bakery_id: Set(bakery.id.clone().unwrap()),
-        customer_id: Set(Some(customer_kate.id.clone().unwrap())),
+        customer_id: Set(customer_kate.id.clone().unwrap()),
         total: Set(dec!(100.00)),
         placed_at: Set(Utc::now().naive_utc()),
 
@@ -290,8 +290,8 @@ pub async fn group_by() {
     .expect("could not insert customer");
 
     let kate_order_1 = order::ActiveModel {
-        bakery_id: Set(Some(bakery.id.clone().unwrap())),
+        bakery_id: Set(bakery.id.clone().unwrap()),
-        customer_id: Set(Some(customer_kate.id.clone().unwrap())),
+        customer_id: Set(customer_kate.id.clone().unwrap()),
         total: Set(dec!(99.95)),
         placed_at: Set(Utc::now().naive_utc()),
 
@@ -302,8 +302,8 @@ pub async fn group_by() {
     .expect("could not insert order");
 
     let kate_order_2 = order::ActiveModel {
-        bakery_id: Set(Some(bakery.id.clone().unwrap())),
+        bakery_id: Set(bakery.id.clone().unwrap()),
-        customer_id: Set(Some(customer_kate.id.clone().unwrap())),
+        customer_id: Set(customer_kate.id.clone().unwrap()),
         total: Set(dec!(200.00)),
         placed_at: Set(Utc::now().naive_utc()),
 
@@ -395,8 +395,8 @@ pub async fn having() {
     .expect("could not insert customer");
 
     let kate_order_1 = order::ActiveModel {
-        bakery_id: Set(Some(bakery.id.clone().unwrap())),
+        bakery_id: Set(bakery.id.clone().unwrap()),
-        customer_id: Set(Some(customer_kate.id.clone().unwrap())),
+        customer_id: Set(customer_kate.id.clone().unwrap()),
         total: Set(dec!(100.00)),
         placed_at: Set(Utc::now().naive_utc()),
 
@@ -407,8 +407,8 @@ pub async fn having() {
     .expect("could not insert order");
 
     let _kate_order_2 = order::ActiveModel {
-        bakery_id: Set(Some(bakery.id.clone().unwrap())),
+        bakery_id: Set(bakery.id.clone().unwrap()),
-        customer_id: Set(Some(customer_kate.id.clone().unwrap())),
+        customer_id: Set(customer_kate.id.clone().unwrap()),
         total: Set(dec!(12.00)),
         placed_at: Set(Utc::now().naive_utc()),
 
@@ -427,8 +427,8 @@ pub async fn having() {
     .expect("could not insert customer");
 
     let _bob_order_1 = order::ActiveModel {
-        bakery_id: Set(Some(bakery.id.clone().unwrap())),
+        bakery_id: Set(bakery.id.clone().unwrap()),
-        customer_id: Set(Some(customer_bob.id.clone().unwrap())),
+        customer_id: Set(customer_bob.id.clone().unwrap()),
         total: Set(dec!(50.0)),
         placed_at: Set(Utc::now().naive_utc()),
 
@@ -439,8 +439,8 @@ pub async fn having() {
     .expect("could not insert order");
 
     let _bob_order_2 = order::ActiveModel {
-        bakery_id: Set(Some(bakery.id.clone().unwrap())),
+        bakery_id: Set(bakery.id.clone().unwrap()),
-        customer_id: Set(Some(customer_bob.id.clone().unwrap())),
+        customer_id: Set(customer_bob.id.clone().unwrap()),
         total: Set(dec!(50.0)),
         placed_at: Set(Utc::now().naive_utc()),
 

tests/sequential_op_tests.rs

@@ -95,8 +95,8 @@ async fn init_setup(db: &DatabaseConnection) {
     .expect("could not insert customer");
 
     let kate_order_1 = order::ActiveModel {
-        bakery_id: Set(Some(bakery.id.clone().unwrap())),
+        bakery_id: Set(bakery.id.clone().unwrap()),
-        customer_id: Set(Some(customer_kate.id.clone().unwrap())),
+        customer_id: Set(customer_kate.id.clone().unwrap()),
         total: Set(dec!(99.95)),
         placed_at: Set(Utc::now().naive_utc()),
 
@@ -107,10 +107,10 @@ async fn init_setup(db: &DatabaseConnection) {
     .expect("could not insert order");
 
     let _lineitem = lineitem::ActiveModel {
-        cake_id: Set(Some(cake_insert_res.last_insert_id as i32)),
+        cake_id: Set(cake_insert_res.last_insert_id as i32),
         price: Set(dec!(10.00)),
         quantity: Set(12),
-        order_id: Set(Some(kate_order_1.id.clone().unwrap())),
+        order_id: Set(kate_order_1.id.clone().unwrap()),
         ..Default::default()
     }
     .save(db)
@@ -118,10 +118,10 @@ async fn init_setup(db: &DatabaseConnection) {
     .expect("could not insert order");
 
     let _lineitem2 = lineitem::ActiveModel {
-        cake_id: Set(Some(cake_insert_res.last_insert_id as i32)),
+        cake_id: Set(cake_insert_res.last_insert_id as i32),
         price: Set(dec!(50.00)),
         quantity: Set(2),
-        order_id: Set(Some(kate_order_1.id.clone().unwrap())),
+        order_id: Set(kate_order_1.id.clone().unwrap()),
         ..Default::default()
     }
     .save(db)
@@ -228,8 +228,8 @@ async fn create_order(db: &DatabaseConnection, cake: cake::Model) {
     .expect("could not insert customer");
 
     let order = order::ActiveModel {
-        bakery_id: Set(Some(cake.bakery_id.unwrap())),
+        bakery_id: Set(cake.bakery_id.unwrap()),
-        customer_id: Set(Some(another_customer.id.clone().unwrap())),
+        customer_id: Set(another_customer.id.clone().unwrap()),
         total: Set(dec!(200.00)),
         placed_at: Set(Utc::now().naive_utc()),
 
@@ -240,10 +240,10 @@ async fn create_order(db: &DatabaseConnection, cake: cake::Model) {
     .expect("could not insert order");
 
     let _lineitem = lineitem::ActiveModel {
-        cake_id: Set(Some(cake.id)),
+        cake_id: Set(cake.id),
         price: Set(dec!(10.00)),
         quantity: Set(300),
-        order_id: Set(Some(order.id.clone().unwrap())),
+        order_id: Set(order.id.clone().unwrap()),
         ..Default::default()
     }
     .save(db)