draft

Author: bobozaur

.sqlx/query-07a6c51ee278a56a95e947d1f334277c85ed788706d6f7c124eae06871feba87.json

@@ -1,6 +1,6 @@
 use std::{borrow::Cow, fmt::Display};
 
-use serde::{Deserialize, Deserializer, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use sqlx_core::{column::Column, database::Database, ext::ustr::UStr};
 
 use crate::{database::Exasol, type_info::ExaTypeInfo};
@@ -13,6 +13,7 @@ pub struct ExaColumn {
     pub(crate) ordinal: usize,
     #[serde(deserialize_with = "ExaColumn::lowercase_name")]
     pub(crate) name: UStr,
+    #[serde(serialize_with = "ExaColumn::flatten_datatype")]
     pub(crate) data_type: ExaTypeInfo,
 }
 
@@ -34,6 +35,36 @@ impl ExaColumn {
             .map(|c| c.0.to_lowercase())
             .map(From::from)
     }
+
+    /// Serialization helper so that offline query files are generated correctly, as that's
+    /// the only place where the entire [`ExaColumn`] gets serialized.
+    fn flatten_datatype<S>(type_info: &ExaTypeInfo, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        type_info.data_type.serialize(serializer)
+    }
+}
+
+#[test]
+fn test_column_serde() {
+    let column_str = r#"      {
+      "ordinal": 0,
+      "name": "user_id!",
+      "dataType": {
+        "type": "DECIMAL",
+        "precision": 18,
+        "scale": 0
+      }
+    }"#;
+
+    let column: ExaColumn = serde_json::from_str(column_str).unwrap();
+    println!("{column:?}");
+    
+    let new_column_str = serde_json::to_string(&column).unwrap();
+    
+    let column: ExaColumn = serde_json::from_str(&new_column_str).unwrap();
+    println!("{column:?}");
 }
 
 impl Display for ExaColumn {

.sqlx/query-1798fb8c66823e371b0306d1cefbf5923d1d6f9d6992535049cdfb0d7b2843bf.json

@@ -37,7 +37,7 @@ impl_type_checking!(
         i128,
         f32,
         f64,
-        String,
+        String | &str,
 
         // External types
         #[cfg(feature = "uuid")]

.sqlx/query-946d756b9e0821ef66916722e44ef249429458b2ef54e46bce72f76a1ef63753.json

@@ -11,7 +11,6 @@ use sqlx_core::type_info::TypeInfo;
 // Note that the [`DataTypeName`] is automatically constructed from the provided [`ExaDataType`].
 #[derive(Debug, Clone, Copy, Deserialize)]
 #[serde(from = "ExaDataType")]
-#[serde(rename_all = "camelCase")]
 pub struct ExaTypeInfo {
     pub(crate) name: DataTypeName,
     pub(crate) data_type: ExaDataType,

.sqlx/query-ea76fbbc69c1941fe6baba8969b04ad3cf07b7ccd4f2b3b10e7eed32346b3855.json

@@ -239,3 +239,6 @@ pub mod any {
 pub use sqlx_exasol_macros;
 #[cfg(feature = "macros")]
 mod macros;
+
+// TODO:
+// - 

sqlx-exasol-impl/src/column.rs

@@ -3,13 +3,43 @@
 //! cargo run -p sqlx-exasol-cli prepare -- --features runtime-tokio --tests
 //! ```
 
-#[sqlx_exasol::test]
-async fn test_query(
+#[sqlx_exasol::test(migrations = "tests/migrations")]
+#[ignore]
+async fn test_compile_time_queries(
     mut conn: sqlx::pool::PoolConnection<sqlx_exasol::Exasol>,
 ) -> anyhow::Result<()> {
-    let x: Option<String> = sqlx_exasol::query_scalar!("SELECT dummy FROM DUAL")
-        .fetch_one(&mut *conn)
+    struct User {
+        user_id: u64,
+        username: String,
+    }
+
+    let username = "test";
+
+    sqlx_exasol::query!("INSERT INTO users (username) VALUES(?);", username)
+        .execute(&mut *conn)
         .await?;
 
+    let user_id: u64 = sqlx_exasol::query_scalar!(
+        r#"SELECT user_id as "user_id!" FROM users WHERE username = ?"#,
+        username
+    )
+    .fetch_one(&mut *conn)
+    .await?;
+
+    let user = sqlx_exasol::query_as!(
+        User,
+        r#"SELECT user_id as "user_id!", username as "username!" FROM users WHERE user_id = ?"#,
+        user_id
+    )
+    .fetch_one(&mut *conn)
+    .await?;
+
+    assert_eq!(user.user_id, user_id);
+    assert_eq!(user.username, username);
+
+    loop {
+        sqlx_exasol::__rt::sleep(std::time::Duration::from_secs(10)).await;
+    }
+
     Ok(())
 }

sqlx-exasol-impl/src/type_checking.rs

@@ -8,11 +8,4 @@ CREATE TABLE post
 
 -- Not meant to do anything, but just test that query separation
 -- in migrations is done properly.
--- We include the semicolon in the where clause because we test based on that.
--- NOTE: Putting a semicolon in a comment such as this one will cause the migration
---       to fail, because Exasol accepts a statement that is just a comment, but the 
---       second  part of the comment, after the semicolon, will always fail.
-DELETE FROM post WHERE ';' = ';'  
-;
-               
-     
+DELETE FROM post WHERE ';' = ';';