adds sqlite syntax

Author: belchior

.github/workflows/pull-requests.yml

@@ -10,11 +10,18 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          toolchain: 1.62.0
       - uses: actions-rs/cargo@v1
+        name: Test standard syntax
         with:
           command: test
       - uses: actions-rs/cargo@v1
+        name: Test PostgreSQL syntax
         with:
           command: test
-          args: --features postgresql --test feature_flag_postgresql
+          args: --features postgresql
+      - uses: actions-rs/cargo@v1
+        name: Test SQLite syntax
+        with:
+          command: test
+          args: --features sqlite

.vscode/extensions.json

@@ -1,5 +1,7 @@
 {
   "recommendations": [
-    "rust-lang.rust-analyzer"
+    "rust-lang.rust-analyzer",
+    "serayuzgur.crates",
+    "tamasfe.even-better-toml",
   ]
 }

.vscode/settings.json

@@ -12,7 +12,8 @@
   "rust-analyzer.diagnostics.disabled": [
     "inactive-code"
   ],
-  "rust-analyzer.cargo.features": [
-    "postgresql"
+  "rust-analyzer.cargo.features": [],
+  "rust-analyzer.linkedProjects": [
+    "./Cargo.toml"
   ],
 }

Cargo.toml

@@ -4,17 +4,18 @@ description = "Write SQL queries in a simple and composable way"
 documentation = "https://docs.rs/sql_query_builder"
 repository = "https://github.com/belchior/sql_query_builder"
 authors = ["Belchior Oliveira <[email protected]>"]
-version = "1.1.4"
+version = "2.0.0"
 edition = "2021"
-rust-version = "1.58"
+rust-version = "1.62"
 license = "MIT"
-keywords = ["sql", "query", "postgres"]
+keywords = ["sql", "query", "postgres", "sqlite"]
 
 [features]
 postgresql = []
+sqlite = []
 
 [package.metadata.docs.rs]
-features = ["postgresql"]
+features = ["postgresql", "sqlite"]
 
 [dev-dependencies]
-pretty_assertions = "1.2.1"
+pretty_assertions = "1.4.0"

README.md

@@ -36,13 +36,14 @@ SELECT id, login FROM users WHERE login = $1 AND is_admin = true
 
 SQL Query Builder comes with the following optional features:
 - `postgresql` enable Postgres syntax
+- `sqlite` enable SQLite syntax
 
 You can enable features like
 
 ```toml
 ## Cargo.toml
 
-sql_query_builder = { version = "1.x.x", features = ["postgresql"] }
+sql_query_builder = { version = "2.x.x", features = ["postgresql"] }
 ```
 
 
@@ -68,7 +69,7 @@ let select = sql::Select::new()
 
 Methods like `limit` and `offset` will override the previous value, the two select is equivalent
 
-```text
+```ts
 use sql_query_builder as sql;
 
 let select = sql::Select::new()
@@ -154,7 +155,7 @@ let query = Some(sql::Select::new())
 println!("{}", query);
 ```
 
-Output (indented for redability)
+Output (indented for readability)
 
 ```sql
 SELECT u.id, u.name as user_name, u.login, a.name as address_name, o.name as product_name
@@ -167,7 +168,7 @@ WHERE u.login = $1 AND o.id = $2
 
 ## Raw queries
 
-You can use the raw method to accomplish some edge cases that are hard to rewrite into the Select syntax.
+You can use the raw method to reach some edge cases that are hard to rewrite into the Select syntax.
 The `select.raw()` method will put any SQL you define on top of the output
 
 ```rust
@@ -213,7 +214,7 @@ let select = sql::Select::new()
 
 ## Debugging queries
 
-Sometimes it's more ease just print de current state of the query builder, to do this just add the .debug() method at any part of the builder, note that the where clause will not be printed because the debug was added before
+Sometimes it's more ease just print de current state of the query builder, to do so adds the `.debug()` method anywhere in the builder. In the example below, the where clause will not be printed because the debug was added before the clause
 
 ```rust
 use sql_query_builder as sql;
@@ -228,8 +229,10 @@ let mut select = sql::Select::new()
 Output
 
 ```sql
+-- ------------------------------------------------------------------------------
 SELECT id, login
 FROM users
+-- ------------------------------------------------------------------------------
 ```
 
 See the [documentation](https://docs.rs/sql_query_builder/) for more builders like [Insert](https://docs.rs/sql_query_builder/latest/sql_query_builder/struct.Insert.html), [Update](https://docs.rs/sql_query_builder/latest/sql_query_builder/struct.Update.html) and [Delete](https://docs.rs/sql_query_builder/latest/sql_query_builder/struct.Delete.html)

scripts/coverage_test.sh

@@ -11,9 +11,11 @@ COVERAGE_TARGET="target/coverage"
 rm -fr "$COVERAGE_TARGET"
 mkdir -p "$COVERAGE_OUTPUT"
 mkdir -p "$COVERAGE_TARGET"
+clear
 
 RUSTFLAGS="-C instrument-coverage" LLVM_PROFILE_FILE="$COVERAGE_TARGET/$PKG_NAME-%m.profraw" cargo test --target-dir $COVERAGE_TARGET;
-RUSTFLAGS="-C instrument-coverage" LLVM_PROFILE_FILE="$COVERAGE_TARGET/$PKG_NAME-%m.profraw" cargo test --target-dir $COVERAGE_TARGET --features postgresql --test feature_flag_postgresql;
+RUSTFLAGS="-C instrument-coverage" LLVM_PROFILE_FILE="$COVERAGE_TARGET/$PKG_NAME-%m.profraw" cargo test --target-dir $COVERAGE_TARGET --features postgresql;
+RUSTFLAGS="-C instrument-coverage" LLVM_PROFILE_FILE="$COVERAGE_TARGET/$PKG_NAME-%m.profraw" cargo test --target-dir $COVERAGE_TARGET --features sqlite;
 
 cargo profdata -- merge -sparse $COVERAGE_TARGET/$PKG_NAME-*.profraw -o $COVERAGE_TARGET/$PKG_NAME.profdata;
 

scripts/test.sh

@@ -2,4 +2,5 @@
 
 clear
 cargo test
-cargo test --features postgresql --test feature_flag_postgresql
+cargo test --features postgresql
+cargo test --features sqlite

scripts/watch_test.sh

@@ -3,5 +3,21 @@
 # Prerequisites
 # cargo install cargo-watch
 
+# Usage
+# ./scripts/watch_test.sh            # will run without enable feature
+# ./scripts/watch_test.sh all        # will enable all feature
+# ./scripts/watch_test.sh postgresql # will enable only the postgresql feature
+
+all_features='postgresql sqlite'
+features=''
+
+case "$@" in
+  "")    features="";;
+  "all") features="$all_features";;
+  *)     features="$@";;
+esac
+
+[ ! -z "$features" ] && features="--features $features"
+
 # cargo watch -w ./src -w ./tests -x 'test --features postgresql -- --nocapture --color always'
-cargo watch -w ./src -w ./tests -x 'test --features postgresql'
+cargo watch -w ./src -w ./tests -x "test $features"

src/behavior.rs

@@ -1,4 +1,6 @@
 use crate::fmt;
+#[cfg(feature = "sqlite")]
+use crate::structure::{InsertClause, InsertVars, UpdateClause, UpdateVars};
 use std::cmp::PartialEq;
 
 pub trait Concat {
@@ -78,8 +80,8 @@ pub trait ConcatSqlStandard<Clause: PartialEq> {
   }
 }
 
-#[cfg(feature = "postgresql")]
-pub trait ConcatPostgres<Clause: PartialEq> {
+#[cfg(any(feature = "postgresql", feature = "sqlite"))]
+pub trait ConcatCommon<Clause: PartialEq> {
   fn concat_returning(
     &self,
     items_raw_before: &Vec<(Clause, String)>,
@@ -142,6 +144,104 @@ pub trait ConcatPostgres<Clause: PartialEq> {
   }
 }
 
+#[cfg(feature = "sqlite")]
+pub trait ConcatSqlite {
+  fn concat_insert(
+    &self,
+    items_raw_before: &Vec<(InsertClause, String)>,
+    items_raw_after: &Vec<(InsertClause, String)>,
+    query: String,
+    fmts: &fmt::Formatter,
+    insert: &(InsertVars, String),
+  ) -> String {
+    let fmt::Formatter { lb, space, .. } = fmts;
+
+    let (clause, sql) = match insert {
+      (InsertVars::InsertInto, exp) if exp.is_empty() => (InsertClause::InsertInto, "".to_owned()),
+      (InsertVars::InsertInto, exp) => (InsertClause::InsertInto, format!("INSERT INTO{space}{exp}{space}{lb}")),
+
+      (InsertVars::InsertOr, exp) if exp.is_empty() => (InsertClause::InsertOr, "".to_owned()),
+      (InsertVars::InsertOr, exp) => (InsertClause::InsertOr, format!("INSERT OR{space}{exp}{space}{lb}")),
+
+      (InsertVars::ReplaceInto, exp) if exp.is_empty() => (InsertClause::ReplaceInto, "".to_owned()),
+      (InsertVars::ReplaceInto, exp) => (
+        InsertClause::ReplaceInto,
+        format!("REPLACE INTO{space}{exp}{space}{lb}"),
+      ),
+    };
+
+    concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
+  }
+
+  fn concat_join<Clause: PartialEq>(
+    &self,
+    items_raw_before: &Vec<(Clause, String)>,
+    items_raw_after: &Vec<(Clause, String)>,
+    query: String,
+    fmts: &fmt::Formatter,
+    clause: Clause,
+    join: &Vec<String>,
+  ) -> String {
+    let fmt::Formatter { lb, space, .. } = fmts;
+    let sql = if join.is_empty() == false {
+      let joins = join.join(format!("{space}{lb}").as_str());
+      format!("{joins}{space}{lb}")
+    } else {
+      "".to_owned()
+    };
+
+    concat_raw_before_after(&items_raw_before, &items_raw_after, query, fmts, clause, sql)
+  }
+
+  fn concat_update(
+    &self,
+    items_raw_before: &Vec<(UpdateClause, String)>,
+    items_raw_after: &Vec<(UpdateClause, String)>,
+    query: String,
+    fmts: &fmt::Formatter,
+    update: &(UpdateVars, String),
+  ) -> String {
+    let fmt::Formatter { lb, space, .. } = fmts;
+    let (clause, sql) = match update {
+      (UpdateVars::Update, table_name) if table_name.is_empty() => (UpdateClause::Update, "".to_string()),
+      (UpdateVars::Update, table_name) => (UpdateClause::Update, format!("UPDATE{space}{table_name}{space}{lb}")),
+
+      (UpdateVars::UpdateOr, expression) if expression.is_empty() => (UpdateClause::UpdateOr, "".to_string()),
+      (UpdateVars::UpdateOr, expression) => (
+        UpdateClause::UpdateOr,
+        format!("UPDATE OR{space}{expression}{space}{lb}"),
+      ),
+    };
+
+    concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
+  }
+
+  fn concat_values<Clause: PartialEq>(
+    &self,
+    items_raw_before: &Vec<(Clause, String)>,
+    items_raw_after: &Vec<(Clause, String)>,
+    query: String,
+    fmts: &fmt::Formatter,
+    clause: Clause,
+    values: &Vec<String>,
+    default_values: &bool,
+  ) -> String {
+    let fmt::Formatter { comma, lb, space, .. } = fmts;
+
+    let sql = if *default_values {
+      format!("DEFAULT VALUES{space}{lb}")
+    } else if values.is_empty() == false {
+      let sep = format!("{comma}{lb}");
+      let values = values.join(&sep);
+      format!("VALUES{space}{lb}{values}{space}{lb}")
+    } else {
+      "".to_owned()
+    };
+
+    concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
+  }
+}
+
 /// Represents all commands that can be used in a transaction
 pub trait TransactionQuery: Concat {}
 

src/delete/delete.rs

@@ -4,6 +4,10 @@ use crate::{
   structure::{Delete, DeleteClause},
 };
 
+impl WithQuery for Delete {}
+
+impl TransactionQuery for Delete {}
+
 impl Delete {
   /// The same as [where_clause](Delete::where_clause) method, useful to write more idiomatic SQL query
   ///
@@ -197,19 +201,19 @@ impl Delete {
   }
 }
 
-#[cfg(any(doc, feature = "postgresql"))]
+#[cfg(any(doc, feature = "postgresql", feature = "sqlite"))]
 impl Delete {
-  /// The `returning` clause, this method can be used enabling the feature flag `postgresql`
+  /// The `returning` clause, this method can be used enabling a feature flag
   pub fn returning(mut self, output_name: &str) -> Self {
     push_unique(&mut self._returning, output_name.trim().to_owned());
     self
   }
 
-  /// The `with` clause, this method can be used enabling the feature flag `postgresql`
+  /// The `with` clause, this method can be used enabling a feature flag
   ///
   /// # Example
   ///
-  /// ```text
+  /// ```ts
   /// use sql_query_builder as sql;
   ///
   /// let deactivated_users = sql::Select::new().select("id").from("users").where_clause("ative = false");
@@ -237,10 +241,6 @@ impl Delete {
   }
 }
 
-impl WithQuery for Delete {}
-
-impl TransactionQuery for Delete {}
-
 impl std::fmt::Display for Delete {
   fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
     write!(f, "{}", self.as_string())

src/delete/delete_internal.rs

@@ -1,5 +1,5 @@
-#[cfg(feature = "postgresql")]
-use crate::behavior::ConcatPostgres;
+#[cfg(any(feature = "postgresql", feature = "sqlite"))]
+use crate::behavior::ConcatCommon;
 use crate::{
   behavior::{concat_raw_before_after, Concat, ConcatSqlStandard},
   fmt,
@@ -8,9 +8,6 @@ use crate::{
 
 impl ConcatSqlStandard<DeleteClause> for Delete {}
 
-#[cfg(feature = "postgresql")]
-impl ConcatPostgres<DeleteClause> for Delete {}
-
 impl Delete {
   fn concat_delete_from(&self, query: String, fmts: &fmt::Formatter) -> String {
     let fmt::Formatter { lb, space, .. } = fmts;
@@ -37,7 +34,7 @@ impl Concat for Delete {
     let mut query = "".to_owned();
 
     query = self.concat_raw(query, &fmts, &self._raw);
-    #[cfg(feature = "postgresql")]
+    #[cfg(any(feature = "postgresql", feature = "sqlite"))]
     {
       query = self.concat_with(
         &self._raw_before,
@@ -57,7 +54,7 @@ impl Concat for Delete {
       DeleteClause::Where,
       &self._where,
     );
-    #[cfg(feature = "postgresql")]
+    #[cfg(any(feature = "postgresql", feature = "sqlite"))]
     {
       query = self.concat_returning(
         &self._raw_before,
@@ -72,3 +69,6 @@ impl Concat for Delete {
     query.trim_end().to_owned()
   }
 }
+
+#[cfg(any(feature = "postgresql", feature = "sqlite"))]
+impl ConcatCommon<DeleteClause> for Delete {}