Merge pull request #3 from marvin-hansen/main

Code formatting, linting & script to run examples

Author: marvin-hansen

README.md

@@ -99,7 +99,31 @@ pub async fn create_stream(client: &ProtonClient) -> Result<()> {
 }
 ```
 
-Check more examples [here](examples).
+## Run the examples 
+
+```bash
+make example
+```
+
+Which shows:
+
+```text
+-----------------------------------------
+Select the number of the example to run:
+-----------------------------------------
+1) prepare: Prepare Proton for the examples: create table & load data
+2) query: Query Proton with sample queries
+3) remove: Cleanup Proton and delete streams
+4) quit: Exit
+
+-----------------------------------------
+Make sure Proton is running
+-----------------------------------------
+```
+
+Please select the number of the example to run. Also,
+first run the prepare example to prepare Proton for the query example.
+See the code of all examples [here](examples).
 
 ## What's next?
 

examples/prepare/main.rs

@@ -45,7 +45,9 @@ async fn main() -> Result<()> {
 
 pub async fn create_stream(client: &ProtonClient) -> Result<()> {
     client
-        .execute_query("CREATE STREAM IF NOT EXISTS test_stream(no uint32, name string) ORDER BY no")
+        .execute_query(
+            "CREATE STREAM IF NOT EXISTS test_stream(no uint32, name string) ORDER BY no",
+        )
         .await
 }
 

examples/remove/main.rs

@@ -22,5 +22,7 @@ async fn main() -> Result<()> {
 pub async fn delete_stream(client: &ProtonClient) -> Result<()> {
     //  Drop a stream
     // https://docs.timeplus.com/proton-drop-stream
-    client.execute_query("DROP STREAM IF EXISTS test_stream").await
+    client
+        .execute_query("DROP STREAM IF EXISTS test_stream")
+        .await
 }

makefile

@@ -3,6 +3,7 @@ SHELL := /usr/bin/env bash
 
 .PHONY: help
 help:
+	@echo '    make example     	Run the example code.'
 	@echo '    make build   	Builds the code base incrementally (fast) for dev.'
 	@echo '    make check   	Checks the code base for security vulnerabilities.'
 	@echo '    make clean   	Cleans generated files and folders.'
@@ -39,6 +40,11 @@ doc:
 	@source scripts/doc.sh
 
 
+.PHONY: example
+example:
+	@source scripts/example.sh
+
+
 .PHONY: fix
 fix:
 	@source scripts/fix.sh

scripts/example.sh

@@ -0,0 +1,53 @@
+# bin/sh
+set -o errexit
+set -o nounset
+set -o pipefail
+
+# Bash Select (Make Menu) https://linuxize.com/post/bash-select/
+
+echo ""
+echo "-----------------------------------------"
+echo "Select the number of the example to run: "
+echo "-----------------------------------------"
+echo "1) prepare: Prepare Proton for the examples: create table & load data"
+echo "2) query: Query Proton with sample queries"
+echo "3) remove: Cleanup Proton and delete streams"
+echo "4) quit: Exit"
+echo ""
+echo "-----------------------------------------"
+echo "Make sure Proton is running"
+echo "-----------------------------------------"
+echo ""
+
+select opt in  prepare query remove quit;
+do
+  case $opt in
+
+    prepare)
+        echo "Selected example: Prepare Proton for the examples"
+        command cargo run --example prepare
+        break
+        ;;
+
+    query)
+        echo "Selected example: Query Proton with sample queries"
+        command cargo run --example query
+        break
+        ;;
+
+    remove)
+        echo "Selected example: Cleanup Proton and delete streams"
+        command cargo run --example remove
+        break
+        ;;
+
+    quit)
+      echo "Exiting!"
+      exit 0
+      ;;
+
+    *)
+      echo "Invalid option $REPLY"
+      ;;
+  esac
+done

src/lib/fetch.rs

@@ -33,10 +33,10 @@ impl ProtonClient {
     /// # Ok(()) }
     /// ```
     pub async fn fetch<T: Row>(&self, query: &str) -> Result<RowCursor<T>> {
-        return match self.client.query(query).fetch::<T>() {
+        match self.client.query(query).fetch::<T>() {
             Ok(cursor) => Ok(cursor),
             Err(e) => Err(ProtonClientError::FetchFailed(e.to_string())),
-        };
+        }
     }
 
     /// Executes the query and returns all the generated results, collected into a Vec.
@@ -76,10 +76,10 @@ impl ProtonClient {
     where
         T: Row + for<'b> Deserialize<'b>,
     {
-        return match self.client.query(query).fetch_all::<T>().await {
+        match self.client.query(query).fetch_all::<T>().await {
             Ok(cursor) => Ok(cursor),
             Err(e) => Err(ProtonClientError::FetchAllFailed(e.to_string())),
-        };
+        }
     }
 
     /// Executes the query and returns just a single row.
@@ -112,10 +112,10 @@ impl ProtonClient {
     where
         T: Row + for<'b> Deserialize<'b>,
     {
-        return match self.client.query(query).fetch_one::<T>().await {
+        match self.client.query(query).fetch_one::<T>().await {
             Ok(cursor) => Ok(cursor),
             Err(e) => Err(ProtonClientError::FetchOneFailed(e.to_string())),
-        };
+        }
     }
 
     /// Executes the query and returns at most one row.
@@ -158,9 +158,9 @@ impl ProtonClient {
     where
         T: Row + for<'b> Deserialize<'b>,
     {
-        return match self.client.query(query).fetch_optional::<T>().await {
+        match self.client.query(query).fetch_optional::<T>().await {
             Ok(cursor) => Ok(cursor),
             Err(e) => Err(ProtonClientError::FetchOptionalFailed(e.to_string())),
-        };
+        }
     }
 }

src/lib/insert.rs

@@ -52,10 +52,10 @@ impl ProtonClient {
     ///
     ///
     pub async fn insert<T: Row>(&self, table: &str) -> Result<insert::Insert<T>> {
-        return match self.client.insert(table) {
+        match self.client.insert(table) {
             Ok(insert) => Ok(insert),
             Err(err) => Err(ProtonClientError::InsertFailed(err.to_string())),
-        };
+        }
     }
 }
 
@@ -103,9 +103,9 @@ impl ProtonClient {
     ///  }
     ///
     pub async fn inserter<T: Row>(&self, table: &str) -> Result<inserter::Inserter<T>> {
-        return match self.client.inserter(table) {
+        match self.client.inserter(table) {
             Ok(inserter) => Ok(inserter),
             Err(err) => Err(ProtonClientError::InserterFailed(err.to_string())),
-        };
+        }
     }
 }

src/lib/query.rs

@@ -35,9 +35,9 @@ impl ProtonClient {
     ///   Ok(())
     /// }
     pub async fn execute_query(&self, query: &str) -> alias::Result<()> {
-        return match self.client.query(query).execute().await {
+        match self.client.query(query).execute().await {
             Ok(_) => Ok(()),
             Err(e) => Err(ProtonClientError::QueryFailed(e.to_string())),
-        };
+        }
     }
 }