general query builder (type-state)

implemented for select & insert for now. update & delete planned

tests/tests.rs

@@ -1,13 +1,17 @@
 use log::{debug, info, LevelFilter};
 use nameof::name_of;
 
+use google_bigquery_v2::data::query_builder::{
+    HasStartingData, NoClient, NoStartingData, QueryBuilder, QueryTypeInsert, QueryTypeNoType,
+    QueryTypeSelect, QueryWasNotBuilt,
+};
 use google_bigquery_v2::prelude::*;
 
-#[derive(BigDataTableDerive, Debug, Clone)]
+#[derive(BigDataTableDerive, Debug, Default, Clone)]
 #[db_name("Infos")]
-pub struct DbInfos<'a> {
+pub struct DbInfos {
     #[client]
-    client: &'a BigqueryClient,
+    client: BigqueryClient,
     #[primary_key]
     #[db_name("Id")]
     row_id: i64,
@@ -19,6 +23,57 @@ pub struct DbInfos<'a> {
     #[db_name("yes")]
     info4b: Option::<bool>,
 }
+pub struct DbInfos2{
+    client: BigqueryClient,
+    row_id: i64,
+    info1: Option::<String>,
+    info2: Option<String>,
+    info3: Option<String>,
+    info4i: Option<i32>,
+    info4b: Option<bool>,
+}
+
+//TODO: outsource this impl into the derive
+impl DbInfos {
+    fn select() -> QueryBuilder<Self, QueryTypeSelect, NoClient, QueryWasNotBuilt, NoStartingData> {
+        QueryBuilder::<Self, QueryTypeNoType, NoClient, QueryWasNotBuilt, NoStartingData>::select()
+    }
+    fn insert() -> QueryBuilder<Self, QueryTypeInsert, NoClient, QueryWasNotBuilt, NoStartingData> {
+        QueryBuilder::<Self, QueryTypeNoType, NoClient, QueryWasNotBuilt, NoStartingData>::insert()
+    }
+}
+
+#[tokio::test]
+async fn test1() {
+    init_logger();
+    let client = get_test_client().await;
+    let query_builder = DbInfos::select().with_client(client.clone());
+    debug!("{:?}", query_builder);
+    let query_builder = query_builder.build_query();
+
+    debug!("query: {:?}", query_builder);
+    let result = query_builder.clone().run().await;
+    debug!("select result: {:?}", result);
+    let sample_data = DbInfos {
+        client: client.clone(),
+        row_id: 1,
+        info1: Some("test1".to_string()),
+        info2: Some("test2".to_string()),
+        info3: Some("test3".to_string()),
+        info4i: Some(1),
+        info4b: Some(true),
+    };
+
+    let query_builder = DbInfos::insert();
+    println!("{:?}", query_builder);
+    let query_builder = query_builder.with_client(client);
+    let query_builder = query_builder.set_data(sample_data);
+    let query_builder = query_builder.build_query().expect("query builder failed");
+    println!("query: {:?}", query_builder);
+    let result = query_builder.clone().run().await;
+    println!("query: {:?}", query_builder);
+    println!("result: {:?}", result);
+}
 
 #[tokio::test]
 async fn test_get_table_name() {
@@ -34,8 +89,8 @@ async fn test_get_query_fields() {
     let fields = DbInfos::get_query_fields(true);
     log::debug!("fields: {:?}", fields);
     assert_eq!(6, fields.len(), "fields length is not correct");
-    assert_eq!("Id", fields.get("row_id").unwrap(), );
-    assert_eq!("info1", fields.get("info1").unwrap(), );
+    assert_eq!("Id", fields.get("row_id").unwrap(),);
+    assert_eq!("info1", fields.get("info1").unwrap(),);
     assert_eq!("info", fields.get("info2").unwrap());
     assert_eq!("info3", fields.get("info3").unwrap());
     assert_eq!("info4i", fields.get("info4i").unwrap());
@@ -46,7 +101,7 @@ async fn test_get_query_fields() {
 async fn test_query_builder_1() {
     init_logger();
     let client = get_test_client().await;
-    let query_builder: BigQueryBuilder<DbInfos> = DbInfos::query(&client);
+    let query_builder: BigQueryBuilder<DbInfos> = DbInfos::query(client);
     let query_builder: BigQueryBuilder<DbInfos> = query_builder
         .add_where_eq::<String>(name_of!(info1 in DbInfos), None)
         .unwrap()
@@ -88,33 +143,36 @@ async fn get_test_client() -> BigqueryClient {
 async fn simple_query() {
     init_logger();
     let client = get_test_client().await;
-    let q = DbInfos::query(&client)
+    let q: Vec<DbInfos> = DbInfos::query(client)
         .add_order_by(name_of!(row_id in DbInfos), OrderDirection::Descending)
-        .run().await.unwrap();
+        .run()
+        .await
+        .unwrap();
     let mut last_num = 999999999999999999;
     for line in q {
         info!("line: {:?}", line);
-        debug!("row_id > last: {} <= {}",line.row_id, last_num);
+        debug!("row_id > last: {} <= {}", line.row_id, last_num);
         assert!(line.row_id <= last_num);
         last_num = line.row_id;
     }
 }
+
 #[tokio::test]
 async fn test_select_limit_1() {
     init_logger();
     let client = get_test_client().await;
-    let q = DbInfos::query(&client)
-        .set_limit(1)
-        .run().await.unwrap();
+    let q: Vec<DbInfos> = DbInfos::query(client).set_limit(1).run().await.unwrap();
     assert_eq!(q.len(), 1);
 }
 
 fn init_logger() {
+    let global_level = LevelFilter::Info;
+    let own_level = LevelFilter::Debug;
     let _ = env_logger::builder()
         .is_test(true)
-        .filter_level(LevelFilter::Info)
-        .filter_module("google_bigquery_v2", LevelFilter::Trace)
-        .filter_module("google_bigquery_v2_derive", LevelFilter::Trace)
-        .filter_module("tests", LevelFilter::Trace)
+        .filter_level(global_level)
+        .filter_module("google_bigquery_v2", own_level)
+        .filter_module("google_bigquery_v2_derive", own_level)
+        .filter_module("tests", own_level)
         .try_init();
 }