Fixed identifier in sqlite if identifier matches a builtin

Author: myOmikron

src/conditional.rs

@@ -235,7 +235,7 @@ impl<'a> BuildCondition<'a> for Condition<'a> {
                     #[cfg(feature = "sqlite")]
                     DBImpl::SQLite => {
                         if let Some(table_name) = table_name {
-                            write!(writer, "{table_name}.")?;
+                            write!(writer, "\"{table_name}\".")?;
                         }
                         write!(writer, "{column_name}")
                     }

src/delete.rs

@@ -78,7 +78,7 @@ impl<'until_build, 'post_query> Delete<'until_build, 'post_query>
         match self {
             #[cfg(feature = "sqlite")]
             DeleteImpl::SQLite(mut d) => {
-                let mut s = format!("DELETE FROM {} ", d.model);
+                let mut s = format!("DELETE FROM \"{}\" ", d.model);
 
                 if d.where_clause.is_some() {
                     write!(

src/drop_table.rs

@@ -63,7 +63,7 @@ impl DropTable for DropTableImpl<'_> {
         match self {
             #[cfg(feature = "sqlite")]
             DropTableImpl::SQLite(d) => format!(
-                "DROP TABLE {}{};",
+                "DROP TABLE \"{}\"{};",
                 d.name,
                 if d.if_exists { " IF EXISTS" } else { "" }
             ),

src/insert.rs

@@ -89,7 +89,7 @@ impl<'post_build> Insert<'post_build> for InsertImpl<'_, 'post_build> {
                 // Handle case, if no columns should be inserted, aka an empty insert
                 if d.columns.is_empty() {
                     let mut s = format!(
-                        "INSERT {}INTO {} DEFAULT VALUES",
+                        "INSERT {}INTO \"{}\" DEFAULT VALUES",
                         match d.on_conflict {
                             OnConflict::ABORT => "OR ABORT ",
                             OnConflict::ROLLBACK => "OR ROLLBACK ",
@@ -114,15 +114,15 @@ impl<'post_build> Insert<'post_build> for InsertImpl<'_, 'post_build> {
                 }
 
                 let mut s = format!(
-                    "INSERT {}INTO {} (",
+                    "INSERT {}INTO \"{}\" (",
                     match d.on_conflict {
                         OnConflict::ABORT => "OR ABORT ",
                         OnConflict::ROLLBACK => "OR ROLLBACK ",
                     },
                     d.into_clause,
                 );
                 for (idx, x) in d.columns.iter().enumerate() {
-                    write!(s, "{x}").unwrap();
+                    write!(s, "\"{x}\"").unwrap();
                     if idx != d.columns.len() - 1 {
                         write!(s, ", ").unwrap();
                     }
@@ -133,7 +133,7 @@ impl<'post_build> Insert<'post_build> for InsertImpl<'_, 'post_build> {
                     write!(s, "(").unwrap();
                     for (idx_2, y) in x.iter().enumerate() {
                         match y {
-                            Value::Ident(st) => write!(s, "{}", *st).unwrap(),
+                            Value::Ident(st) => write!(s, "\"{}\"", *st).unwrap(),
                             Value::Choice(c) => write!(s, "{}", sqlite::fmt(c)).unwrap(),
                             Value::Null(NullType::Choice) => write!(s, "NULL").unwrap(),
                             _ => {

src/join_table.rs

@@ -112,7 +112,7 @@ impl<'post_query> JoinTable<'post_query> for JoinTableImpl<'_, 'post_query> {
             #[cfg(feature = "sqlite")]
             JoinTableImpl::SQLite(d) => write!(
                 s,
-                "{} {} AS {} ON {}",
+                "{} \"{}\" AS {} ON {}",
                 d.join_type,
                 d.table_name,
                 d.join_alias,

src/lib.rs

@@ -412,6 +412,7 @@ impl DBImpl {
     */
     pub fn update<'until_build, 'post_query>(
         &self,
+
         table_name: &'until_build str,
     ) -> impl Update<'until_build, 'post_query>
     where

src/select.rs

@@ -135,7 +135,7 @@ impl<'until_build, 'post_build> Select<'until_build, 'post_build>
                     }
                 }
 
-                write!(s, " FROM {}", d.from_clause).unwrap();
+                write!(s, " FROM \"{}\"", d.from_clause).unwrap();
 
                 for x in d.join_tables {
                     write!(s, " ").unwrap();

src/select_column.rs

@@ -64,10 +64,10 @@ impl SelectColumn for SelectColumnImpl<'_> {
                 }
 
                 if let Some(table_name) = d.table_name {
-                    write!(s, "{table_name}.").unwrap();
+                    write!(s, "\"{table_name}\".").unwrap();
                 }
 
-                write!(s, "{}", d.column_name).unwrap();
+                write!(s, "\"{}\"", d.column_name).unwrap();
 
                 if d.aggregation.is_some() {
                     write!(s, ")").unwrap();

src/update.rs

@@ -150,11 +150,11 @@ impl<'until_build, 'post_build> Update<'until_build, 'post_build>
                 let update_index = d.updates.len() - 1;
                 for (idx, (name, value)) in d.updates.into_iter().enumerate() {
                     if let Value::Choice(c) = value {
-                        write!(s, "{name} = {}", sqlite::fmt(c)).unwrap();
+                        write!(s, "\"{name}\" = {}", sqlite::fmt(c)).unwrap();
                     } else if let Value::Null(NullType::Choice) = value {
-                        write!(s, "{name} = NULL").unwrap();
+                        write!(s, "\"{name}\" = NULL").unwrap();
                     } else {
-                        write!(s, "{name} = ?").unwrap();
+                        write!(s, "\"{name}\" = ?").unwrap();
                         d.lookup.push(value);
                     }
                     if idx != update_index {