v0.8.7: fix quoting & SQLite JSON decoding

Bump crate versions to 0.8.7 and harden SQL identifier handling and SQLite JSON decoding. Add a dedicated identifier-quoting path (format_identifier_reference) and simplify column formatting to consistently quote reserved identifiers (SELECT, WHERE, GROUP BY, JOIN, ORDER BY, aliases, and direction). Preserve embedded quote escaping and tighten reserved-word quoting behavior. Fix SQLite raw JSON decoding for untyped aggregate results (e.g. COUNT/SUM) so numeric aggregates are returned as numbers instead of strings. Add unit/tests and regression tests for identifier quoting and SQLite aggregate JSON decoding. Update docs, README examples, CHANGELOG, and macro crate metadata accordingly.

Author: mohamadzoh

CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to TideORM will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.7] - 2026-03-21
+
+### Fixed
+
+- Quoted simple identifier references consistently in the manual SQL builder paths so reserved column names such as `order` and `group` no longer break generated SELECT, WHERE, GROUP BY, JOIN, and ORDER BY clauses.
+- Preserved embedded identifier-quote escaping while tightening the reserved-word quoting path, so names containing quote characters still render correctly for each backend dialect.
+- Fixed SQLite raw JSON decoding for untyped aggregate expressions such as `COUNT(*)` and `SUM(...)`, so count/exists helpers and raw JSON reads no longer degrade numeric aggregate results into strings.
+
+### Changed
+
+- Refreshed dependency examples and macro-crate docs to use the 0.8.7 release version.
+
+### Internal
+
+- Added query SQL regressions covering reserved-word identifiers and embedded quote escaping.
+- Added SQLite raw JSON regressions covering aggregate count decoding.
+- Verified the release prep with `cargo test --all-features`, `cargo clippy --lib --all-features -- -D warnings`, and `mdbook build`.
+
 ## [0.8.6] - 2026-03-21
 
 ### Fixed
@@ -606,7 +624,8 @@ This is the first public release of TideORM, a developer-friendly ORM for Rust w
 - **Repository:** [https://github.com/mohamadzoh/tideorm](https://github.com/mohamadzoh/tideorm)
 - **Documentation:** See README.md and examples/
 
-[Unreleased]: https://github.com/mohamadzoh/tideorm/compare/v0.8.6...HEAD
+[Unreleased]: https://github.com/mohamadzoh/tideorm/compare/v0.8.7...HEAD
+[0.8.7]: https://github.com/mohamadzoh/tideorm/compare/v0.8.6...v0.8.7
 [0.8.6]: https://github.com/mohamadzoh/tideorm/compare/v0.8.5...v0.8.6
 [0.8.5]: https://github.com/mohamadzoh/tideorm/compare/v0.8.4...v0.8.5
 [0.8.4]: https://github.com/mohamadzoh/tideorm/compare/v0.8.1...v0.8.4

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "tideorm"
-version = "0.8.6"
+version = "0.8.7"
 edition = "2021"
 authors = ["Mohamad Al Zohbie <alzoubi528@gmail.com>"]
 description = "A developer-friendly ORM for Rust with clean, expressive syntax"
@@ -48,7 +48,7 @@ rust_decimal = { version = "1.40.0", features = ["serde"] }
 thiserror = "2.0.18"
 
 # Derive macros (our own crate)
-tideorm-macros = { version = "0.8.6", path = "tideorm-macros" }
+tideorm-macros = { version = "0.8.7", path = "tideorm-macros" }
 
 # Utils
 parking_lot = "0.12.5"

Cargo.toml

@@ -192,22 +192,22 @@ let recent_posts = user.posts.load_with(|q| {
 ```toml
 [dependencies]
 # PostgreSQL (default)
-tideorm = { version = "0.8.6", features = ["postgres"] }
+tideorm = { version = "0.8.7", features = ["postgres"] }
 
 # MySQL
-tideorm = { version = "0.8.6", features = ["mysql"] }
+tideorm = { version = "0.8.7", features = ["mysql"] }
 
 # SQLite
-tideorm = { version = "0.8.6", features = ["sqlite"] }
+tideorm = { version = "0.8.7", features = ["sqlite"] }
 
 # Enable attachments support explicitly
-tideorm = { version = "0.8.6", features = ["postgres", "attachments"] }
+tideorm = { version = "0.8.7", features = ["postgres", "attachments"] }
 
 # Enable translations support explicitly
-tideorm = { version = "0.8.6", features = ["postgres", "translations"] }
+tideorm = { version = "0.8.7", features = ["postgres", "translations"] }
 
 # Enable full-text search support explicitly
-tideorm = { version = "0.8.6", features = ["postgres", "fulltext"] }
+tideorm = { version = "0.8.7", features = ["postgres", "fulltext"] }
 ```
 
 ### Feature Flags

README.md

@@ -514,7 +514,7 @@ TideORM provides full-text search capabilities across PostgreSQL (tsvector/tsque
 Enable the feature explicitly when you need the full-text search API:
 
 ```toml
-tideorm = { version = "0.8.6", features = ["postgres", "fulltext"] }
+tideorm = { version = "0.8.7", features = ["postgres", "fulltext"] }
 ```
 
 ### Search Basics

docs/queries.md

@@ -210,7 +210,7 @@ Enable the feature first:
 
 ```toml
 [dependencies]
-tideorm = { version = "0.8.6", features = ["postgres", "attachments"] }
+tideorm = { version = "0.8.7", features = ["postgres", "attachments"] }
 ```
 
 ### Model Setup
@@ -545,7 +545,7 @@ Enable the feature first:
 
 ```toml
 [dependencies]
-tideorm = { version = "0.8.6", features = ["postgres", "translations"] }
+tideorm = { version = "0.8.7", features = ["postgres", "translations"] }
 ```
 
 ### Model Setup

docs/relations.md

@@ -880,7 +880,7 @@ impl Database {
                     }
                     "TEXT" => Self::typed_or_fallback::<String>(result, index),
                     "BLOB" => Self::typed_or_fallback::<Vec<u8>>(result, index),
-                    _ => Self::fallback_try_get_json(result, index),
+                    _ => Self::sqlite_unknown_type_or_fallback(result, index),
                 }
             });
         }
@@ -905,10 +905,10 @@ impl Database {
             .or_else(|| Self::try_get_json::<chrono::NaiveDateTime>(row, index))
             .or_else(|| Self::try_get_json::<chrono::NaiveDate>(row, index))
             .or_else(|| Self::try_get_json::<chrono::NaiveTime>(row, index))
-            .or_else(|| Self::try_get_json::<bool>(row, index))
             .or_else(|| Self::try_get_json::<i64>(row, index))
             .or_else(|| Self::try_get_json::<u64>(row, index))
             .or_else(|| Self::try_get_json::<f64>(row, index))
+            .or_else(|| Self::try_get_json::<bool>(row, index))
             .or_else(|| Self::try_get_json::<String>(row, index))
             .unwrap_or(serde_json::Value::Null)
     }
@@ -926,6 +926,26 @@ impl Database {
             .unwrap_or_else(|| Self::fallback_try_get_json(row, index))
     }
 
+    #[cfg(feature = "sqlite")]
+    fn sqlite_unknown_type_or_fallback(
+        row: &crate::internal::QueryResult,
+        index: usize,
+    ) -> serde_json::Value {
+        let value = Self::fallback_try_get_json(row, index);
+
+        if let serde_json::Value::String(text) = &value {
+            if let Ok(integer) = text.parse::<i64>() {
+                return serde_json::json!(integer);
+            }
+
+            if let Ok(unsigned) = text.parse::<u64>() {
+                return serde_json::json!(unsigned);
+            }
+        }
+
+        value
+    }
+
     fn try_get_decimal_json(
         row: &crate::internal::QueryResult,
         index: usize,

src/database.rs

@@ -238,6 +238,36 @@ pub fn quote_ident(db_type: DatabaseType, name: &str) -> String {
     format!("{}{}{}", q, escaped, q)
 }
 
+/// Quote a simple identifier reference like `column` or `table.column`.
+pub fn format_identifier_reference(db_type: DatabaseType, value: &str) -> Option<String> {
+    let trimmed = value.trim();
+    if trimmed.is_empty()
+        || trimmed.starts_with('"')
+        || trimmed.ends_with('"')
+        || trimmed.starts_with('`')
+        || trimmed.ends_with('`')
+        || trimmed.contains('(')
+        || trimmed.contains(')')
+        || trimmed.contains('*')
+        || trimmed.contains(' ')
+    {
+        return None;
+    }
+
+    let parts: Vec<&str> = trimmed.split('.').collect();
+    if parts.iter().any(|part| part.is_empty()) {
+        return None;
+    }
+
+    Some(
+        parts
+            .into_iter()
+            .map(|part| quote_ident(db_type, part))
+            .collect::<Vec<_>>()
+            .join("."),
+    )
+}
+
 /// Generate JSON contains expression
 ///
 /// - PostgreSQL: `column @> 'value'`
@@ -497,22 +527,7 @@ pub fn array_overlaps(db_type: DatabaseType, column: &str, values: &[String]) ->
 
 /// Format a column identifier for the database
 pub fn format_column(db_type: DatabaseType, column: &str) -> String {
-    if column.contains('(') || column.contains('*') {
-        column.to_string()
-    } else if column.contains('.') {
-        let parts: Vec<&str> = column.split('.').collect();
-        if parts.len() == 2 {
-            format!(
-                "{}.{}",
-                quote_ident(db_type, parts[0]),
-                quote_ident(db_type, parts[1])
-            )
-        } else {
-            column.to_string()
-        }
-    } else {
-        quote_ident(db_type, column)
-    }
+    format_identifier_reference(db_type, column).unwrap_or_else(|| column.to_string())
 }
 
 /// Generate aggregate function with proper casting for the database

src/query/db_sql.rs

@@ -872,10 +872,72 @@ impl<M: Model> QueryBuilder<M> {
     }
 
     fn format_column_for_db(&self, db_type: DatabaseType, column: &str) -> String {
-        if column.contains(' ') {
-            column.to_string()
-        } else {
-            db_sql::format_column(db_type, column)
+        let trimmed = column.trim();
+        let parts: Vec<&str> = trimmed.split_whitespace().collect();
+
+        match parts.as_slice() {
+            [identifier] => db_sql::format_column(db_type, identifier),
+            [identifier, direction]
+                if direction.eq_ignore_ascii_case("asc")
+                    || direction.eq_ignore_ascii_case("desc") =>
+            {
+                db_sql::format_identifier_reference(db_type, identifier)
+                    .map(|identifier| format!("{} {}", identifier, direction.to_ascii_uppercase()))
+                    .unwrap_or_else(|| trimmed.to_string())
+            }
+            [identifier, as_keyword, alias] if as_keyword.eq_ignore_ascii_case("as") => {
+                match (
+                    db_sql::format_identifier_reference(db_type, identifier),
+                    db_sql::format_identifier_reference(db_type, alias),
+                ) {
+                    (Some(identifier), Some(alias)) => format!("{} AS {}", identifier, alias),
+                    _ => trimmed.to_string(),
+                }
+            }
+            _ => trimmed.to_string(),
+        }
+    }
+
+    fn format_select_column_for_db(&self, db_type: DatabaseType, table: &str, column: &str) -> String {
+        let trimmed = column.trim();
+        let parts: Vec<&str> = trimmed.split_whitespace().collect();
+
+        match parts.as_slice() {
+            [identifier]
+                if !identifier.contains('(')
+                    && !identifier.contains('*')
+                    && db_sql::format_identifier_reference(db_type, identifier).is_some() =>
+            {
+                if identifier.contains('.') {
+                    self.format_column_for_db(db_type, identifier)
+                } else {
+                    format!(
+                        "{}.{}",
+                        db_sql::quote_ident(db_type, table),
+                        db_sql::quote_ident(db_type, identifier)
+                    )
+                }
+            }
+            [identifier, as_keyword, alias]
+                if as_keyword.eq_ignore_ascii_case("as")
+                    && !identifier.contains('(')
+                    && !identifier.contains('*')
+                    && db_sql::format_identifier_reference(db_type, identifier).is_some()
+                    && db_sql::format_identifier_reference(db_type, alias).is_some() =>
+            {
+                let identifier = if identifier.contains('.') {
+                    self.format_column_for_db(db_type, identifier)
+                } else {
+                    format!(
+                        "{}.{}",
+                        db_sql::quote_ident(db_type, table),
+                        db_sql::quote_ident(db_type, identifier)
+                    )
+                };
+
+                format!("{} AS {}", identifier, db_sql::quote_ident(db_type, alias))
+            }
+            _ => trimmed.to_string(),
         }
     }
 
@@ -893,24 +955,7 @@ impl<M: Model> QueryBuilder<M> {
         if let Some(columns) = &self.select_columns {
             let mut rendered_columns: Vec<String> = columns
                 .iter()
-                .map(|column| {
-                    if column.contains('(')
-                        || column.contains('*')
-                        || column.contains('"')
-                        || column.contains('`')
-                        || column.contains(' ')
-                    {
-                        column.clone()
-                    } else if column.contains('.') {
-                        self.format_column_for_db(db_type, column)
-                    } else {
-                        format!(
-                            "{}.{}",
-                            db_sql::quote_ident(db_type, table),
-                            db_sql::quote_ident(db_type, column)
-                        )
-                    }
-                })
+                .map(|column| self.format_select_column_for_db(db_type, table, column))
                 .collect();
 
             for window_function in &self.window_functions {

src/query/sql.rs

@@ -193,3 +193,43 @@ async fn raw_json_preserves_decimal_and_datetime_column_types() {
         })]
     );
 }
+
+#[cfg(all(feature = "sqlite", feature = "runtime-tokio"))]
+#[tokio::test]
+async fn raw_json_preserves_count_aggregates_as_numbers() {
+    let db = Database::connect("sqlite::memory:")
+        .await
+        .expect("sqlite in-memory connection should succeed");
+
+    db.__execute_with_params(
+        "CREATE TABLE raw_json_count_probe (enabled BOOLEAN NOT NULL)",
+        vec![],
+    )
+    .await
+    .expect("creating count probe table should succeed");
+
+    for enabled in [true, true, false] {
+        db.__execute_with_params(
+            "INSERT INTO raw_json_count_probe (enabled) VALUES (?)",
+            vec![crate::internal::Value::Bool(Some(enabled))],
+        )
+        .await
+        .expect("inserting count probe row should succeed");
+    }
+
+    let rows = db
+        .__raw_json_with_params(
+            "SELECT COUNT(*) AS count, SUM(enabled) AS enabled_total FROM raw_json_count_probe",
+            vec![],
+        )
+        .await
+        .expect("querying count aggregate JSON rows should succeed");
+
+    assert_eq!(
+        rows,
+        vec![serde_json::json!({
+            "count": 3,
+            "enabled_total": 2,
+        })]
+    );
+}