diff --git a/tests/sqlite/tests/bulk_delete/mod.rs b/tests/sqlite/tests/bulk_delete/mod.rs
index 9f1796d..c973303 100644
--- a/tests/sqlite/tests/bulk_delete/mod.rs
+++ b/tests/sqlite/tests/bulk_delete/mod.rs
@@ -34,7 +34,7 @@ fn delete_from_with_where() {
         let q = Order2::all()
             .where_col(|x| x.oid.equal(1))
             .delete_sql(Syntax::Sqlite);
-        assert_eq!(q, "DELETE FROM orders WHERE ( orders.oid = ? )");
+        assert_eq!(q, "DELETE FROM orders WHERE ( orders.\"oid\" = ? )");
     })
 }
 
@@ -47,7 +47,7 @@ fn should_be_able_to_delete_with_limit() {
             .delete_sql(Syntax::Sqlite);
         assert_eq!(
             q,
-            "DELETE FROM orders WHERE (  orders.oid IN (SELECT t1.\"oid\" FROM orders t1 ORDER BY t1.oid ASC LIMIT 3 OFFSET 0 )  )"
+            "DELETE FROM orders WHERE (  orders.\"oid\" IN (SELECT t1.\"oid\" FROM orders t1 ORDER BY t1.\"oid\" ASC LIMIT 3 OFFSET 0 )  )"
         );
     })
 }
@@ -60,7 +60,7 @@ fn should_be_able_to_delete_with_existsin() {
             .delete_sql(Syntax::Sqlite);
         assert_eq!(
             q,
-            "DELETE FROM orders WHERE ( EXISTS ( SELECT pid FROM Products t1 WHERE t1.pid > ? AND t1.pid = orders.product_id ) )"
+            "DELETE FROM orders WHERE ( EXISTS ( SELECT \"pid\" FROM Products t1 WHERE t1.\"pid\" > ? AND t1.\"pid\" = orders.\"product_id\" ) )"
         );
     })
 }
@@ -74,7 +74,7 @@ fn should_be_able_to_delete_with_wherein_with_limit() {
             .delete_sql(Syntax::Sqlite);
         assert_eq!(
             q,
-            "DELETE FROM orders WHERE (  orders.product_id IN (SELECT t1.pid FROM Products t1 WHERE t1.pid > ? ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "DELETE FROM orders WHERE (  orders.\"product_id\" IN (SELECT t1.\"pid\" FROM Products t1 WHERE t1.\"pid\" > ? ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
     })
 }
diff --git a/tests/sqlite/tests/bulk_update/mod.rs b/tests/sqlite/tests/bulk_update/mod.rs
index 45b3ce4..60180b7 100644
--- a/tests/sqlite/tests/bulk_update/mod.rs
+++ b/tests/sqlite/tests/bulk_update/mod.rs
@@ -37,7 +37,7 @@ fn should_be_able_to_update_table_with_where() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q,
-            "UPDATE Products SET \"name\"=? WHERE ( Products.pid = ? )"
+            "UPDATE Products SET \"name\"=? WHERE ( Products.\"pid\" = ? )"
         );
     })
 }
@@ -51,7 +51,7 @@ fn should_be_able_to_update_table_with_where_exists_from_map_query() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q,
-            "UPDATE Products SET \"name\"=? WHERE ( EXISTS ( SELECT product_id FROM orders t1 WHERE t1.oid = ? AND t1.product_id = Products.pid ) )"
+            "UPDATE Products SET \"name\"=? WHERE ( EXISTS ( SELECT \"product_id\" FROM orders t1 WHERE t1.\"oid\" = ? AND t1.\"product_id\" = Products.\"pid\" ) )"
         );
     })
 }
@@ -66,7 +66,7 @@ fn should_be_able_to_update_table_with_where_in_from_map_query_with_limit() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q,
-            "UPDATE Products SET \"name\"=? WHERE (  Products.pid IN (SELECT t1.product_id FROM orders t1 WHERE t1.oid = ? ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "UPDATE Products SET \"name\"=? WHERE (  Products.\"pid\" IN (SELECT t1.\"product_id\" FROM orders t1 WHERE t1.\"oid\" = ? ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
     })
 }
@@ -80,7 +80,7 @@ fn should_be_able_to_update_with_just_limit() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q,
-            "UPDATE Products SET \"name\"=? WHERE (  Products.pid IN (SELECT t1.\"pid\" FROM Products t1 ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "UPDATE Products SET \"name\"=? WHERE (  Products.\"pid\" IN (SELECT t1.\"pid\" FROM Products t1 ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
     })
 }
diff --git a/tests/sqlite/tests/select_col/mod.rs b/tests/sqlite/tests/select_col/mod.rs
index d41e47c..b816a6b 100644
--- a/tests/sqlite/tests/select_col/mod.rs
+++ b/tests/sqlite/tests/select_col/mod.rs
@@ -93,7 +93,7 @@ fn should_be_able_to_select_join_with_where() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q,
-            "SELECT t1.\"oid\", t2.\"pid\" FROM orders t1 JOIN Products t2 ON t1.\"product_id\" = t2.\"pid\" WHERE ( t1.oid = ? )"
+            "SELECT t1.\"oid\", t2.\"pid\" FROM orders t1 JOIN Products t2 ON t1.\"product_id\" = t2.\"pid\" WHERE ( t1.\"oid\" = ? )"
         );
     })
 }
@@ -110,7 +110,7 @@ fn should_be_able_to_select_where_in_join() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q,
-            "SELECT t1.\"oid\", t2.\"pid\" FROM orders t1 JOIN Products t2 ON t1.\"product_id\" = t2.\"pid\" WHERE ( t2.pid = ? )"
+            "SELECT t1.\"oid\", t2.\"pid\" FROM orders t1 JOIN Products t2 ON t1.\"product_id\" = t2.\"pid\" WHERE ( t2.\"pid\" = ? )"
         );
     })
 }
@@ -247,9 +247,7 @@ fn should_be_able_to_write_order_by_with_table_and_column_aliases() {
         let query = Order2::all()
             .select(|o| o.oid)
             .select_as(|o| o.name, "aliased_column")
-            .left_join(|o| o.product, {
-                Product2::all().select(|p| p.pid)
-            })
+            .left_join(|o| o.product, { Product2::all().select(|p| p.pid) })
             .order_manual("$.oid DESC")
             .order_manual("t2.pid DESC")
             .order_manual("aliased_column ASC");
diff --git a/tests/sqlite/tests/sub_query_tests/mod.rs b/tests/sqlite/tests/sub_query_tests/mod.rs
index 0f4b979..a3e33b4 100644
--- a/tests/sqlite/tests/sub_query_tests/mod.rs
+++ b/tests/sqlite/tests/sub_query_tests/mod.rs
@@ -1,7 +1,7 @@
 use super::get_conn;
+use welds::connections::TransactStart;
 use welds::Syntax;
 use welds::WeldsModel;
-use welds::connections::TransactStart;
 
 #[derive(Debug, WeldsModel)]
 #[welds(db(Sqlite))]
@@ -30,7 +30,7 @@ fn exist_in_mapping_query_source_belongs() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q1,
-            "SELECT t2.\"pid\", t2.\"name\" FROM Products t2 WHERE ( EXISTS ( SELECT product_id FROM orders t1 WHERE t1.product_id = t2.pid ) )"
+            "SELECT t2.\"pid\", t2.\"name\" FROM Products t2 WHERE ( EXISTS ( SELECT \"product_id\" FROM orders t1 WHERE t1.\"product_id\" = t2.\"pid\" ) )"
         );
         let q2 = Order2::all()
             .limit(1)
@@ -38,7 +38,7 @@ fn exist_in_mapping_query_source_belongs() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q2,
-            "SELECT t2.\"pid\", t2.\"name\" FROM Products t2 WHERE (  t2.pid IN (SELECT t1.product_id FROM orders t1  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "SELECT t2.\"pid\", t2.\"name\" FROM Products t2 WHERE (  t2.\"pid\" IN (SELECT t1.\"product_id\" FROM orders t1  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
     })
 }
@@ -51,7 +51,7 @@ fn should_be_able_to_join_limit_and_order_all_at_once() {
             .order_by_asc(|o| o.oid)
             .map_query(|o| o.product)
             .to_sql(Syntax::Sqlite);
-        let expected = "SELECT t2.\"pid\", t2.\"name\" FROM Products t2 WHERE (  t2.pid IN (SELECT t1.product_id FROM orders t1  ORDER BY t1.oid ASC LIMIT 1 OFFSET 0 )  )";
+        let expected = "SELECT t2.\"pid\", t2.\"name\" FROM Products t2 WHERE (  t2.\"pid\" IN (SELECT t1.\"product_id\" FROM orders t1  ORDER BY t1.\"oid\" ASC LIMIT 1 OFFSET 0 )  )";
         assert_eq!(expected, sql);
     })
 }
@@ -64,7 +64,7 @@ fn exist_in_mapping_query_source_many() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q1,
-            "SELECT t2.\"oid\", t2.\"product_id\" FROM orders t2 WHERE ( EXISTS ( SELECT pid FROM Products t1 WHERE t1.pid = t2.product_id ) )"
+            "SELECT t2.\"oid\", t2.\"product_id\" FROM orders t2 WHERE ( EXISTS ( SELECT \"pid\" FROM Products t1 WHERE t1.\"pid\" = t2.\"product_id\" ) )"
         );
         let q2 = Product2::all()
             .limit(1)
@@ -72,7 +72,7 @@ fn exist_in_mapping_query_source_many() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q2,
-            "SELECT t2.\"oid\", t2.\"product_id\" FROM orders t2 WHERE (  t2.product_id IN (SELECT t1.pid FROM Products t1  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "SELECT t2.\"oid\", t2.\"product_id\" FROM orders t2 WHERE (  t2.\"product_id\" IN (SELECT t1.\"pid\" FROM Products t1  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
     })
 }
@@ -86,7 +86,7 @@ fn exist_in_sub_query_source_belongs() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q1,
-            "SELECT t1.\"pid\", t1.\"name\" FROM Products t1 WHERE ( EXISTS ( SELECT product_id FROM orders t2 WHERE t2.product_id = t1.pid ) )"
+            "SELECT t1.\"pid\", t1.\"name\" FROM Products t1 WHERE ( EXISTS ( SELECT \"product_id\" FROM orders t2 WHERE t2.\"product_id\" = t1.\"pid\" ) )"
         );
 
         let sub2 = Order2::all().limit(1);
@@ -95,7 +95,7 @@ fn exist_in_sub_query_source_belongs() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q2,
-            "SELECT t1.\"pid\", t1.\"name\" FROM Products t1 WHERE (  t1.pid IN (SELECT t2.product_id FROM orders t2  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "SELECT t1.\"pid\", t1.\"name\" FROM Products t1 WHERE (  t1.\"pid\" IN (SELECT t2.\"product_id\" FROM orders t2  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
     })
 }
@@ -109,7 +109,7 @@ fn exist_in_sub_query_source_many() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q1,
-            "SELECT t1.\"oid\", t1.\"product_id\" FROM orders t1 WHERE ( EXISTS ( SELECT pid FROM Products t2 WHERE t2.pid = t1.product_id ) )"
+            "SELECT t1.\"oid\", t1.\"product_id\" FROM orders t1 WHERE ( EXISTS ( SELECT \"pid\" FROM Products t2 WHERE t2.\"pid\" = t1.\"product_id\" ) )"
         );
 
         let sub2 = Product2::all().limit(1);
@@ -118,7 +118,7 @@ fn exist_in_sub_query_source_many() {
             .to_sql(Syntax::Sqlite);
         assert_eq!(
             q2,
-            "SELECT t1.\"oid\", t1.\"product_id\" FROM orders t1 WHERE (  t1.product_id IN (SELECT t2.pid FROM Products t2  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "SELECT t1.\"oid\", t1.\"product_id\" FROM orders t1 WHERE (  t1.\"product_id\" IN (SELECT t2.\"pid\" FROM Products t2  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
     })
 }
@@ -136,7 +136,7 @@ fn three_levels_down() {
 
         assert_eq!(
             q,
-            "SELECT t3.\"pid\", t3.\"name\" FROM Products t3 WHERE ( t3.pid = ? AND EXISTS ( SELECT product_id FROM orders t2 WHERE t2.oid = ? AND t2.product_id = t3.pid AND EXISTS ( SELECT pid FROM Products t1 WHERE t1.pid = ? AND t1.pid = t2.product_id ) ) )"
+            "SELECT t3.\"pid\", t3.\"name\" FROM Products t3 WHERE ( t3.\"pid\" = ? AND EXISTS ( SELECT \"product_id\" FROM orders t2 WHERE t2.\"oid\" = ? AND t2.\"product_id\" = t3.\"pid\" AND EXISTS ( SELECT \"pid\" FROM Products t1 WHERE t1.\"pid\" = ? AND t1.\"pid\" = t2.\"product_id\" ) ) )"
         );
     })
 }
diff --git a/tests/sqlite_sync/tests/bulk_delete/mod.rs b/tests/sqlite_sync/tests/bulk_delete/mod.rs
index 9c900d8..de2c667 100644
--- a/tests/sqlite_sync/tests/bulk_delete/mod.rs
+++ b/tests/sqlite_sync/tests/bulk_delete/mod.rs
@@ -31,7 +31,7 @@ fn delete_from_with_where() {
     let q = Order2::all()
         .where_col(|x| x.oid.equal(1))
         .delete_sql(Syntax::Sqlite);
-    assert_eq!(q, "DELETE FROM orders WHERE ( orders.oid = ? )");
+    assert_eq!(q, "DELETE FROM orders WHERE ( orders.\"oid\" = ? )");
 }
 
 #[test]
@@ -42,7 +42,7 @@ fn should_be_able_to_delete_with_limit() {
         .delete_sql(Syntax::Sqlite);
     assert_eq!(
             q,
-            "DELETE FROM orders WHERE (  orders.oid IN (SELECT t1.\"oid\" FROM orders t1 ORDER BY t1.oid ASC LIMIT 3 OFFSET 0 )  )"
+            "DELETE FROM orders WHERE (  orders.\"oid\" IN (SELECT t1.\"oid\" FROM orders t1 ORDER BY t1.\"oid\" ASC LIMIT 3 OFFSET 0 )  )"
         );
 }
 
@@ -53,7 +53,7 @@ fn should_be_able_to_delete_with_existsin() {
         .delete_sql(Syntax::Sqlite);
     assert_eq!(
             q,
-            "DELETE FROM orders WHERE ( EXISTS ( SELECT pid FROM Products t1 WHERE t1.pid > ? AND t1.pid = orders.product_id ) )"
+            "DELETE FROM orders WHERE ( EXISTS ( SELECT \"pid\" FROM Products t1 WHERE t1.\"pid\" > ? AND t1.\"pid\" = orders.\"product_id\" ) )"
         );
 }
 
@@ -65,6 +65,6 @@ fn should_be_able_to_delete_with_wherein_with_limit() {
         .delete_sql(Syntax::Sqlite);
     assert_eq!(
             q,
-            "DELETE FROM orders WHERE (  orders.product_id IN (SELECT t1.pid FROM Products t1 WHERE t1.pid > ? ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "DELETE FROM orders WHERE (  orders.\"product_id\" IN (SELECT t1.\"pid\" FROM Products t1 WHERE t1.\"pid\" > ? ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
 }
diff --git a/tests/sqlite_sync/tests/bulk_update/mod.rs b/tests/sqlite_sync/tests/bulk_update/mod.rs
index d1abe5c..e90d29a 100644
--- a/tests/sqlite_sync/tests/bulk_update/mod.rs
+++ b/tests/sqlite_sync/tests/bulk_update/mod.rs
@@ -34,7 +34,7 @@ fn should_be_able_to_update_table_with_where() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
         q,
-        "UPDATE Products SET \"name\"=? WHERE ( Products.pid = ? )"
+        "UPDATE Products SET \"name\"=? WHERE ( Products.\"pid\" = ? )"
     );
 }
 
@@ -46,7 +46,7 @@ fn should_be_able_to_update_table_with_where_exists_from_map_query() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q,
-            "UPDATE Products SET \"name\"=? WHERE ( EXISTS ( SELECT product_id FROM orders t1 WHERE t1.oid = ? AND t1.product_id = Products.pid ) )"
+            "UPDATE Products SET \"name\"=? WHERE ( EXISTS ( SELECT \"product_id\" FROM orders t1 WHERE t1.\"oid\" = ? AND t1.\"product_id\" = Products.\"pid\" ) )"
         );
 }
 
@@ -59,7 +59,7 @@ fn should_be_able_to_update_table_with_where_in_from_map_query_with_limit() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q,
-            "UPDATE Products SET \"name\"=? WHERE (  Products.pid IN (SELECT t1.product_id FROM orders t1 WHERE t1.oid = ? ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "UPDATE Products SET \"name\"=? WHERE (  Products.\"pid\" IN (SELECT t1.\"product_id\" FROM orders t1 WHERE t1.\"oid\" = ? ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
 }
 
@@ -71,6 +71,6 @@ fn should_be_able_to_update_with_just_limit() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q,
-            "UPDATE Products SET \"name\"=? WHERE (  Products.pid IN (SELECT t1.\"pid\" FROM Products t1 ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "UPDATE Products SET \"name\"=? WHERE (  Products.\"pid\" IN (SELECT t1.\"pid\" FROM Products t1 ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
 }
diff --git a/tests/sqlite_sync/tests/select_col/mod.rs b/tests/sqlite_sync/tests/select_col/mod.rs
index 2a493c5..f25d445 100644
--- a/tests/sqlite_sync/tests/select_col/mod.rs
+++ b/tests/sqlite_sync/tests/select_col/mod.rs
@@ -82,7 +82,7 @@ fn should_be_able_to_select_join_with_where() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q,
-            "SELECT t1.\"oid\", t2.\"pid\" FROM orders t1 JOIN Products t2 ON t1.\"product_id\" = t2.\"pid\" WHERE ( t1.oid = ? )"
+            "SELECT t1.\"oid\", t2.\"pid\" FROM orders t1 JOIN Products t2 ON t1.\"product_id\" = t2.\"pid\" WHERE ( t1.\"oid\" = ? )"
         );
 }
 
@@ -97,7 +97,7 @@ fn should_be_able_to_select_where_in_join() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q,
-            "SELECT t1.\"oid\", t2.\"pid\" FROM orders t1 JOIN Products t2 ON t1.\"product_id\" = t2.\"pid\" WHERE ( t2.pid = ? )"
+            "SELECT t1.\"oid\", t2.\"pid\" FROM orders t1 JOIN Products t2 ON t1.\"product_id\" = t2.\"pid\" WHERE ( t2.\"pid\" = ? )"
         );
 }
 
diff --git a/tests/sqlite_sync/tests/sub_query_tests/mod.rs b/tests/sqlite_sync/tests/sub_query_tests/mod.rs
index 5c0ca76..9e18ded 100644
--- a/tests/sqlite_sync/tests/sub_query_tests/mod.rs
+++ b/tests/sqlite_sync/tests/sub_query_tests/mod.rs
@@ -29,7 +29,7 @@ fn exist_in_mapping_query_source_belongs() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q1,
-            "SELECT t2.\"pid\", t2.\"name\" FROM Products t2 WHERE ( EXISTS ( SELECT product_id FROM orders t1 WHERE t1.product_id = t2.pid ) )"
+            "SELECT t2.\"pid\", t2.\"name\" FROM Products t2 WHERE ( EXISTS ( SELECT \"product_id\" FROM orders t1 WHERE t1.\"product_id\" = t2.\"pid\" ) )"
         );
     let q2 = Order2::all()
         .limit(1)
@@ -37,7 +37,7 @@ fn exist_in_mapping_query_source_belongs() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q2,
-            "SELECT t2.\"pid\", t2.\"name\" FROM Products t2 WHERE (  t2.pid IN (SELECT t1.product_id FROM orders t1  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "SELECT t2.\"pid\", t2.\"name\" FROM Products t2 WHERE (  t2.\"pid\" IN (SELECT t1.\"product_id\" FROM orders t1  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
 }
 
@@ -48,7 +48,7 @@ fn should_be_able_to_join_limit_and_order_all_at_once() {
         .order_by_asc(|o| o.oid)
         .map_query(|o| o.product)
         .to_sql(Syntax::Sqlite);
-    let expected = "SELECT t2.\"pid\", t2.\"name\" FROM Products t2 WHERE (  t2.pid IN (SELECT t1.product_id FROM orders t1  ORDER BY t1.oid ASC LIMIT 1 OFFSET 0 )  )";
+    let expected = "SELECT t2.\"pid\", t2.\"name\" FROM Products t2 WHERE (  t2.\"pid\" IN (SELECT t1.\"product_id\" FROM orders t1  ORDER BY t1.\"oid\" ASC LIMIT 1 OFFSET 0 )  )";
     assert_eq!(expected, sql);
 }
 
@@ -59,7 +59,7 @@ fn exist_in_mapping_query_source_many() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q1,
-            "SELECT t2.\"oid\", t2.\"product_id\" FROM orders t2 WHERE ( EXISTS ( SELECT pid FROM Products t1 WHERE t1.pid = t2.product_id ) )"
+            "SELECT t2.\"oid\", t2.\"product_id\" FROM orders t2 WHERE ( EXISTS ( SELECT \"pid\" FROM Products t1 WHERE t1.\"pid\" = t2.\"product_id\" ) )"
         );
     let q2 = Product2::all()
         .limit(1)
@@ -67,7 +67,7 @@ fn exist_in_mapping_query_source_many() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q2,
-            "SELECT t2.\"oid\", t2.\"product_id\" FROM orders t2 WHERE (  t2.product_id IN (SELECT t1.pid FROM Products t1  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "SELECT t2.\"oid\", t2.\"product_id\" FROM orders t2 WHERE (  t2.\"product_id\" IN (SELECT t1.\"pid\" FROM Products t1  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
 }
 
@@ -79,7 +79,7 @@ fn exist_in_sub_query_source_belongs() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q1,
-            "SELECT t1.\"pid\", t1.\"name\" FROM Products t1 WHERE ( EXISTS ( SELECT product_id FROM orders t2 WHERE t2.product_id = t1.pid ) )"
+            "SELECT t1.\"pid\", t1.\"name\" FROM Products t1 WHERE ( EXISTS ( SELECT \"product_id\" FROM orders t2 WHERE t2.\"product_id\" = t1.\"pid\" ) )"
         );
 
     let sub2 = Order2::all().limit(1);
@@ -88,7 +88,7 @@ fn exist_in_sub_query_source_belongs() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q2,
-            "SELECT t1.\"pid\", t1.\"name\" FROM Products t1 WHERE (  t1.pid IN (SELECT t2.product_id FROM orders t2  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "SELECT t1.\"pid\", t1.\"name\" FROM Products t1 WHERE (  t1.\"pid\" IN (SELECT t2.\"product_id\" FROM orders t2  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
 }
 
@@ -100,7 +100,7 @@ fn exist_in_sub_query_source_many() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q1,
-            "SELECT t1.\"oid\", t1.\"product_id\" FROM orders t1 WHERE ( EXISTS ( SELECT pid FROM Products t2 WHERE t2.pid = t1.product_id ) )"
+            "SELECT t1.\"oid\", t1.\"product_id\" FROM orders t1 WHERE ( EXISTS ( SELECT \"pid\" FROM Products t2 WHERE t2.\"pid\" = t1.\"product_id\" ) )"
         );
 
     let sub2 = Product2::all().limit(1);
@@ -109,7 +109,7 @@ fn exist_in_sub_query_source_many() {
         .to_sql(Syntax::Sqlite);
     assert_eq!(
             q2,
-            "SELECT t1.\"oid\", t1.\"product_id\" FROM orders t1 WHERE (  t1.product_id IN (SELECT t2.pid FROM Products t2  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
+            "SELECT t1.\"oid\", t1.\"product_id\" FROM orders t1 WHERE (  t1.\"product_id\" IN (SELECT t2.\"pid\" FROM Products t2  ORDER BY 1 LIMIT 1 OFFSET 0 )  )"
         );
 }
 
@@ -125,7 +125,7 @@ fn three_levels_down() {
 
     assert_eq!(
             q,
-            "SELECT t3.\"pid\", t3.\"name\" FROM Products t3 WHERE ( t3.pid = ? AND EXISTS ( SELECT product_id FROM orders t2 WHERE t2.oid = ? AND t2.product_id = t3.pid AND EXISTS ( SELECT pid FROM Products t1 WHERE t1.pid = ? AND t1.pid = t2.product_id ) ) )"
+            "SELECT t3.\"pid\", t3.\"name\" FROM Products t3 WHERE ( t3.\"pid\" = ? AND EXISTS ( SELECT \"product_id\" FROM orders t2 WHERE t2.\"oid\" = ? AND t2.\"product_id\" = t3.\"pid\" AND EXISTS ( SELECT \"pid\" FROM Products t1 WHERE t1.\"pid\" = ? AND t1.\"pid\" = t2.\"product_id\" ) ) )"
         );
 }
 
diff --git a/welds/src/migrations/create_table/tests.rs b/welds/src/migrations/create_table/tests.rs
index 4ccec7b..912e3f8 100644
--- a/welds/src/migrations/create_table/tests.rs
+++ b/welds/src/migrations/create_table/tests.rs
@@ -17,19 +17,19 @@ fn should_create_basic_table() {
     //postgres
     let sql2 = MigrationWriter::up_sql(&m, Syntax::Postgres).join("; ");
     let expected = r#"
-    CREATE TABLE s1.MyTable ( id SERIAL PRIMARY KEY NOT NULL, name TEXT NOT NULL )"#;
+    CREATE TABLE s1.MyTable ( "id" SERIAL PRIMARY KEY NOT NULL, "name" TEXT NOT NULL )"#;
     assert_eq!(sql2, expected.trim());
 
     //mysql
     let sql = MigrationWriter::up_sql(&m, Syntax::Mssql).join("; ");
     let expected = r#"
-    CREATE TABLE s1.MyTable ( id INT IDENTITY(1,1) PRIMARY KEY NOT NULL, name NVARCHAR(MAX) NOT NULL )"#;
+    CREATE TABLE s1.MyTable ( "id" INT IDENTITY(1,1) PRIMARY KEY NOT NULL, "name" NVARCHAR(MAX) NOT NULL )"#;
     assert_eq!(sql, expected.trim());
 
     //sqlite
     let sql2 = MigrationWriter::up_sql(&m, Syntax::Sqlite).join("; ");
     let expected = r#"
-    CREATE TABLE s1.MyTable ( id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, name TEXT NOT NULL )"#;
+    CREATE TABLE s1.MyTable ( "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "name" TEXT NOT NULL )"#;
     assert_eq!(sql2, expected.trim());
 }
 
@@ -48,12 +48,12 @@ fn should_be_able_to_make_a_fk() {
 
     //postgres
     let sql = MigrationWriter::up_sql(&m, Syntax::Postgres).pop().unwrap();
-    let expected = r#"ALTER TABLE s1.MyTable ADD CONSTRAINT fk_MyTable_other_id FOREIGN KEY (other_id) REFERENCES others (o_id) ON DELETE CASCADE"#;
+    let expected = r#"ALTER TABLE s1.MyTable ADD CONSTRAINT fk_MyTable_other_id FOREIGN KEY ("other_id") REFERENCES others ("o_id") ON DELETE CASCADE"#;
     assert_eq!(sql, expected.trim());
 
     //mysql
     let sql = MigrationWriter::up_sql(&m, Syntax::Mssql).pop().unwrap();
-    let expected = r#"ALTER TABLE s1.MyTable ADD CONSTRAINT fk_MyTable_other_id FOREIGN KEY (other_id) REFERENCES others (o_id) ON DELETE CASCADE"#;
+    let expected = r#"ALTER TABLE s1.MyTable ADD CONSTRAINT fk_MyTable_other_id FOREIGN KEY ("other_id") REFERENCES others ("o_id") ON DELETE CASCADE"#;
     assert_eq!(sql, expected.trim());
 
     //sqlite
diff --git a/welds/src/migrations/tablemod/tests.rs b/welds/src/migrations/tablemod/tests.rs
index d4d1e5b..436d7f0 100644
--- a/welds/src/migrations/tablemod/tests.rs
+++ b/welds/src/migrations/tablemod/tests.rs
@@ -43,7 +43,7 @@ fn down_should_recreate_the_table() {
     let table = mock_table(Syntax::Postgres);
     let m = table.drop();
     let expected = r#"
-    CREATE TABLE s2.cars ( id SERIAL PRIMARY KEY NOT NULL, name TEXT NOT NULL )"#;
+    CREATE TABLE s2.cars ( "id" SERIAL PRIMARY KEY NOT NULL, "name" TEXT NOT NULL )"#;
     let sql = MigrationWriter::down_sql(&m, Syntax::Postgres).join("; ");
     assert_eq!(sql, expected.trim());
 }
@@ -54,11 +54,11 @@ fn should_be_able_to_rename_column() {
     let m = table.change("name").rename("name2");
     // up sql
     let sql = MigrationWriter::up_sql(&m, Syntax::Postgres).join("; ");
-    let expected_up = r#"ALTER TABLE s2.cars RENAME name TO name2"#;
+    let expected_up = r#"ALTER TABLE s2.cars RENAME "name" TO "name2""#;
     assert_eq!(sql, expected_up);
     // down sql
     let sql = MigrationWriter::down_sql(&m, Syntax::Postgres).join("; ");
-    let expected_down = r#"ALTER TABLE s2.cars RENAME name2 TO name"#;
+    let expected_down = r#"ALTER TABLE s2.cars RENAME "name2" TO "name""#;
     assert_eq!(sql, expected_down);
 }
 
@@ -82,7 +82,7 @@ fn should_be_able_to_drop_a_column() {
     let m = table.change("name").drop_column();
     // up sql
     let sql = MigrationWriter::up_sql(&m, Syntax::Mssql).join("; ");
-    let expected_up = r#"ALTER TABLE s2.cars DROP COLUMN name"#;
+    let expected_up = r#"ALTER TABLE s2.cars DROP COLUMN "name""#;
     assert_eq!(sql, expected_up);
 }
 
diff --git a/welds/src/migrations/writers/add_column.rs b/welds/src/migrations/writers/add_column.rs
index 9bb7d94..c5395a0 100644
--- a/welds/src/migrations/writers/add_column.rs
+++ b/welds/src/migrations/writers/add_column.rs
@@ -1,4 +1,4 @@
-use crate::writers::TableWriter;
+use crate::writers::{ColumnWriter, TableWriter};
 use welds_connections::Syntax;
 
 use crate::detect::TableDef;
@@ -13,6 +13,7 @@ pub fn write(
 ) -> String {
     let tablename: String = TableWriter::new(syntax).write(&table.ident());
     let col: String = sanitize_column(col.into());
+    let col = ColumnWriter::new(syntax).excape(&col);
     let ty: String = ty.into();
     let null = if nullable { "NULL" } else { "NOT NULL" };
     let coldef = format!("{ty} {null}");
diff --git a/welds/src/migrations/writers/alter_column_type/mod.rs b/welds/src/migrations/writers/alter_column_type/mod.rs
index 1aad6c3..46bf38c 100644
--- a/welds/src/migrations/writers/alter_column_type/mod.rs
+++ b/welds/src/migrations/writers/alter_column_type/mod.rs
@@ -2,7 +2,7 @@ use crate::Syntax;
 use crate::detect::{ColumnDef, TableDef};
 mod pg_writer;
 mod sqlite_writer;
-use crate::writers::TableWriter;
+use crate::writers::{ColumnWriter, TableWriter};
 
 /// writes the up SQL change the type/null of a column
 pub fn write_up(
@@ -17,6 +17,7 @@ pub fn write_up(
 
     let current_col = column.name();
     let colname: String = sanitize_column(colname.into());
+    let colname_esc = ColumnWriter::new(syntax).excape(&colname);
     let ty: String = ty.into();
     let null = if nullable { "NULL" } else { "NOT NULL" };
 
@@ -24,10 +25,10 @@ pub fn write_up(
         Syntax::Sqlite => sqlite_writer::up_sql(syntax, table, current_col, colname, ty, nullable),
         Syntax::Postgres => pg_writer::up_sql(syntax, table, column, colname, ty, nullable),
         Syntax::Mssql => vec![format!(
-            "ALTER TABLE {tablename} ALTER COLUMN {colname} {ty} {null}"
+            "ALTER TABLE {tablename} ALTER COLUMN {colname_esc} {ty} {null}"
         )],
         Syntax::Mysql => vec![format!(
-            "ALTER TABLE {tablename} MODIFY COLUMN {colname} {ty} {null}"
+            "ALTER TABLE {tablename} MODIFY COLUMN {colname_esc} {ty} {null}"
         )],
     }
 }
@@ -45,6 +46,7 @@ pub fn write_down(
 
     let current_col = column.name();
     let colname: String = sanitize_column(colname.into());
+    let colname_esc = ColumnWriter::new(syntax).excape(&colname);
     let ty: String = ty.into();
     let null = if nullable { "NULL" } else { "NOT NULL" };
 
@@ -54,10 +56,10 @@ pub fn write_down(
         }
         Syntax::Postgres => pg_writer::down_sql(syntax, table, column, colname, ty, nullable),
         Syntax::Mssql => vec![format!(
-            "ALTER TABLE {tablename} ALTER COLUMN {colname} {ty} {null}"
+            "ALTER TABLE {tablename} ALTER COLUMN {colname_esc} {ty} {null}"
         )],
         Syntax::Mysql => vec![format!(
-            "ALTER TABLE {tablename} MODIFY COLUMN {colname} {ty} {null}"
+            "ALTER TABLE {tablename} MODIFY COLUMN {colname_esc} {ty} {null}"
         )],
     }
 }
diff --git a/welds/src/migrations/writers/alter_column_type/pg_writer.rs b/welds/src/migrations/writers/alter_column_type/pg_writer.rs
index 7a811a7..7959677 100644
--- a/welds/src/migrations/writers/alter_column_type/pg_writer.rs
+++ b/welds/src/migrations/writers/alter_column_type/pg_writer.rs
@@ -12,6 +12,7 @@ pub(crate) fn up_sql(
 ) -> Vec<String> {
     let mut cmds = Vec::default();
     let tablename: String = TableWriter::new(syntax).write(&table.ident());
+    let colname = ColumnWriter::new(syntax).excape(&colname);
 
     // Change the type
     if column.ty() != ty {
@@ -44,6 +45,7 @@ pub(crate) fn down_sql(
 ) -> Vec<String> {
     let mut cmds = Vec::default();
     let tablename: String = TableWriter::new(syntax).write(&table.ident());
+    let colname = ColumnWriter::new(syntax).excape(&colname);
 
     // NOTE: changing the type to the type it currently is is valid in PG
     // IE: table has type TEXT for column name, and changing it to type TEXT
diff --git a/welds/src/migrations/writers/alter_column_type/sqlite_writer.rs b/welds/src/migrations/writers/alter_column_type/sqlite_writer.rs
index 31957d8..8e73bf1 100644
--- a/welds/src/migrations/writers/alter_column_type/sqlite_writer.rs
+++ b/welds/src/migrations/writers/alter_column_type/sqlite_writer.rs
@@ -1,6 +1,6 @@
 use crate::Syntax;
 use crate::detect::TableDef;
-use crate::writers::TableWriter;
+use crate::writers::{ColumnWriter, TableWriter};
 
 pub(crate) fn down_sql(
     syntax: Syntax,
@@ -66,7 +66,7 @@ fn write_col(col: &Col) -> String {
     if col.primary_key {
         return write_pk(col);
     }
-    let name = &col.name;
+    let name = ColumnWriter::new(Syntax::Sqlite).excape(&col.name);
     let ty = &col.ty;
     let nullable = if col.nullable { "NULL" } else { "NOT NULL" };
     format!("{name} {ty} {nullable}")
@@ -74,7 +74,7 @@ fn write_col(col: &Col) -> String {
 
 /// write the primary key column part for a create table
 fn write_pk(col: &Col) -> String {
-    let name = &col.name;
+    let name = ColumnWriter::new(Syntax::Sqlite).excape(&col.name);
     let mut ty = col.ty.as_str();
     let mut auto = "";
     if is_int(ty) {
@@ -148,15 +148,19 @@ fn build_copy_data(
     dest_table: &str,
     dest_cols: &[Col],
 ) -> String {
-    let dest_col_parts: Vec<_> = dest_cols.iter().map(|c| c.name.as_str()).collect();
+    let dest_col_parts: Vec<_> = dest_cols
+        .iter()
+        .map(|c| ColumnWriter::new(Syntax::Sqlite).excape(c.name.as_str()))
+        .collect();
     let dest_col_joined = dest_col_parts.join(", ");
 
     let mut src_col_parts = Vec::default();
     for (src, dest) in src_cols.iter().zip(dest_cols) {
+        let name = ColumnWriter::new(Syntax::Sqlite).excape(&src.name);
         if src.ty == dest.ty {
-            src_col_parts.push(src.name.to_string());
+            src_col_parts.push(name);
         } else {
-            let convert = format!("CAST({} AS {})", src.name, dest.ty);
+            let convert = format!("CAST({} AS {})", name, dest.ty);
             src_col_parts.push(convert);
         }
     }
diff --git a/welds/src/migrations/writers/create_indexes.rs b/welds/src/migrations/writers/create_indexes.rs
index 84e47fe..7616bff 100644
--- a/welds/src/migrations/writers/create_indexes.rs
+++ b/welds/src/migrations/writers/create_indexes.rs
@@ -3,11 +3,12 @@ use crate::migrations::create_table::ColumnBuilder;
 use crate::migrations::types::Index;
 use crate::migrations::types::OnDelete;
 use crate::model_traits::TableIdent;
+use crate::writers::ColumnWriter;
 use crate::writers::TableWriter;
 
 pub fn write(syntax: Syntax, table: &TableIdent, col: &ColumnBuilder) -> String {
     let tablename = TableWriter::new(syntax).write(table);
-    let colname = col.name.as_str();
+    let colname = ColumnWriter::new(syntax).excape(col.name.as_str());
 
     let indexname = match &col.index_name {
         Some(n) => n.to_owned(),
@@ -36,11 +37,12 @@ pub(crate) fn write_inline_fk(syntax: Syntax, col: &ColumnBuilder) -> Option<Str
     }
 
     // pull out the info about the FK to create
-    let colname = col.name.as_str();
+    let colname = ColumnWriter::new(syntax).excape(col.name.as_str());
     let (f_table, f_column, on_delete) = match col.index.as_ref()? {
         Index::ForeignKey(fk_args) => fk_args,
         _ => return None,
     };
+    let f_column = ColumnWriter::new(syntax).excape(f_column.as_str());
 
     let on_delete_str = match on_delete {
         OnDelete::Cascade => "CASCADE",
@@ -81,7 +83,8 @@ fn write_fk(
     };
 
     let tablename = TableWriter::new(syntax).write(table);
-    let colname = col.name.as_str();
+    let colname = ColumnWriter::new(syntax).excape(col.name.as_str());
+    let foreign_column = ColumnWriter::new(syntax).excape(foreign_column);
 
     format!(
         "ALTER TABLE {tablename} ADD CONSTRAINT {indexname} FOREIGN KEY ({colname}) REFERENCES {foreign_table} ({foreign_column}) ON DELETE {on_delete_str}"
diff --git a/welds/src/migrations/writers/create_table.rs b/welds/src/migrations/writers/create_table.rs
index d09befe..89976b5 100644
--- a/welds/src/migrations/writers/create_table.rs
+++ b/welds/src/migrations/writers/create_table.rs
@@ -5,6 +5,7 @@ use crate::migrations::create_table::ColumnBuilder;
 use crate::migrations::create_table::IdBuilder;
 use crate::migrations::create_table::TableBuilder;
 use crate::migrations::types::Type;
+use crate::writers::ColumnWriter;
 use crate::writers::TableWriter;
 use crate::writers::types::pk_override;
 
@@ -76,7 +77,7 @@ fn build_columns(syntax: Syntax, idcol: &IdBuilder, cols: &[ColumnBuilder]) -> V
 }
 
 fn build_id_column(syntax: Syntax, col: &IdBuilder) -> String {
-    let name = &col.name;
+    let name = ColumnWriter::new(syntax).excape(&col.name);
     let ty: String = col.ty.db_id_type(syntax);
     let mut tail = "PRIMARY KEY";
     if col.ty == Type::Int || col.ty == Type::IntSmall || col.ty == Type::IntBig {
@@ -91,7 +92,7 @@ fn build_id_column(syntax: Syntax, col: &IdBuilder) -> String {
 }
 
 fn build_column(syntax: Syntax, col: &ColumnBuilder) -> String {
-    let name = &col.name;
+    let name = ColumnWriter::new(syntax).excape(col.name.as_str());
     let ty: String = col.ty.db_type(syntax);
 
     let null = if col.nullable { "NULL" } else { "NOT NULL" };
diff --git a/welds/src/migrations/writers/drop_column.rs b/welds/src/migrations/writers/drop_column.rs
index 6aaba81..cd7ae40 100644
--- a/welds/src/migrations/writers/drop_column.rs
+++ b/welds/src/migrations/writers/drop_column.rs
@@ -1,11 +1,12 @@
 use crate::Syntax;
 use crate::detect::TableDef;
-use crate::writers::TableWriter;
+use crate::writers::{ColumnWriter, TableWriter};
 
 /// writes the SQL to Renames a column on a table
 pub fn write(syntax: Syntax, table: &TableDef, col: impl Into<String>) -> String {
     let tablename: String = TableWriter::new(syntax).write(&table.ident());
     let col: String = sanitize_column(col.into());
+    let col = ColumnWriter::new(syntax).excape(&col);
     format!("ALTER TABLE {tablename} DROP COLUMN {col}")
 }
 
diff --git a/welds/src/migrations/writers/rename_column.rs b/welds/src/migrations/writers/rename_column.rs
index d535360..c2e0ddf 100644
--- a/welds/src/migrations/writers/rename_column.rs
+++ b/welds/src/migrations/writers/rename_column.rs
@@ -1,6 +1,6 @@
 use crate::Syntax;
 use crate::model_traits::TableIdent;
-use crate::writers::TableWriter;
+use crate::writers::{ColumnWriter, TableWriter};
 
 /// writes the SQL to Renames a column on a table
 pub fn write(
@@ -10,13 +10,17 @@ pub fn write(
     new_name: impl Into<String>,
 ) -> String {
     let oldname: String = sanitize_column(old_name.into());
+    let oldname_esc = ColumnWriter::new(syntax).excape(&oldname);
     let newname: String = sanitize_column(new_name.into());
+    let newname_esc = ColumnWriter::new(syntax).excape(&newname);
     let tablename: String = TableWriter::new(syntax).write(table);
 
     match syntax {
         Syntax::Mssql => format!("EXEC sp_rename '{tablename}.{oldname}', '{newname}', 'COLUMN'"),
-        Syntax::Mysql => format!("ALTER TABLE {tablename} RENAME COLUMN {oldname} TO {newname}"),
-        _ => format!("ALTER TABLE {tablename} RENAME {oldname} TO {newname}"),
+        Syntax::Mysql => {
+            format!("ALTER TABLE {tablename} RENAME COLUMN {oldname_esc} TO {newname_esc}")
+        }
+        _ => format!("ALTER TABLE {tablename} RENAME {oldname_esc} TO {newname_esc}"),
     }
 }
 
diff --git a/welds/src/query/builder/tests.rs b/welds/src/query/builder/tests.rs
index cbed0f5..e3175f0 100644
--- a/welds/src/query/builder/tests.rs
+++ b/welds/src/query/builder/tests.rs
@@ -28,7 +28,7 @@ fn should_be_able_to_map_query_from_belongs_to() {
     futures::executor::block_on(async move {
         let q = ProductC::all().map_query(|p| p.orders);
         let sql = q.to_sql(Syntax::Mssql);
-        let valid = r#"SELECT t2."id", t2."product_id", t2."price" FROM orders t2 WHERE ( EXISTS ( SELECT pid FROM products t1 WHERE t1.pid = t2.product_id ) )"#;
+        let valid = r#"SELECT t2."id", t2."product_id", t2."price" FROM orders t2 WHERE ( EXISTS ( SELECT "pid" FROM products t1 WHERE t1."pid" = t2."product_id" ) )"#;
         assert_eq!(sql, valid);
     });
 }
@@ -38,7 +38,7 @@ fn should_be_able_to_map_query_from_has_many() {
     futures::executor::block_on(async move {
         let q = OrderC::all().map_query(|p| p.product);
         let sql = q.to_sql(Syntax::Mssql);
-        let valid = r#"SELECT t2."pid", t2."name" FROM products t2 WHERE ( EXISTS ( SELECT product_id FROM orders t1 WHERE t1.product_id = t2.pid ) )"#;
+        let valid = r#"SELECT t2."pid", t2."name" FROM products t2 WHERE ( EXISTS ( SELECT "product_id" FROM orders t1 WHERE t1."product_id" = t2."pid" ) )"#;
         assert_eq!(sql, valid);
     });
 }
diff --git a/welds/src/query/clause/clause_adder.rs b/welds/src/query/clause/clause_adder.rs
index e3b8a6a..6dcd9e5 100644
--- a/welds/src/query/clause/clause_adder.rs
+++ b/welds/src/query/clause/clause_adder.rs
@@ -1,7 +1,7 @@
 use super::{ClauseColManual, ClauseColVal, ClauseColValEqual, ClauseColValIn, ClauseColValList};
 use super::{Param, ParamArgs};
 use crate::Syntax;
-use crate::writers::NextParam;
+use crate::writers::{ColumnWriter, NextParam};
 
 /// A `ClauseAdder` is a trait used to write the "clause" part of
 /// a where, join, etc..
@@ -32,7 +32,8 @@ where
 
     fn clause(&self, syntax: Syntax, alias: &str, next_params: &NextParam) -> Option<String> {
         // build the column name
-        let col = format!("{}.{}", alias, self.col);
+        let col_writer = ColumnWriter::new(syntax);
+        let col = format!("{}.{}", alias, col_writer.excape(&self.col));
         let mut parts = vec![col.as_str()];
 
         // handle null clones
@@ -84,9 +85,10 @@ where
         }
     }
 
-    fn clause(&self, _syntax: Syntax, alias: &str, next_params: &NextParam) -> Option<String> {
+    fn clause(&self, syntax: Syntax, alias: &str, next_params: &NextParam) -> Option<String> {
         // build the column name
-        let col = format!("{}.{}", alias, self.col);
+        let col_writer = ColumnWriter::new(syntax);
+        let col = format!("{}.{}", alias, col_writer.excape(&self.col));
         let mut parts = vec![col.as_str()];
 
         // handle null clones
@@ -120,9 +122,10 @@ where
         args.push(&self.list);
     }
 
-    fn clause(&self, _syntax: Syntax, alias: &str, next_params: &NextParam) -> Option<String> {
+    fn clause(&self, syntax: Syntax, alias: &str, next_params: &NextParam) -> Option<String> {
         // build the column name
-        let col = format!("{}.{}", alias, self.col);
+        let col_writer = ColumnWriter::new(syntax);
+        let col = format!("{}.{}", alias, col_writer.excape(&self.col));
         let mut parts = vec![col.as_str()];
 
         // normal path
@@ -149,8 +152,9 @@ where
         }
     }
 
-    fn clause(&self, _syntax: Syntax, alias: &str, next_params: &NextParam) -> Option<String> {
-        let col = format!("{}.{}", alias, self.col);
+    fn clause(&self, syntax: Syntax, alias: &str, next_params: &NextParam) -> Option<String> {
+        let col_writer = ColumnWriter::new(syntax);
+        let col = format!("{}.{}", alias, col_writer.excape(&self.col));
         let mut parts = vec![col];
 
         parts.push(" ".to_string());
@@ -179,11 +183,12 @@ impl ClauseAdder for ClauseColManual {
         }
     }
 
-    fn clause(&self, _syntax: Syntax, alias: &str, next_params: &NextParam) -> Option<String> {
+    fn clause(&self, syntax: Syntax, alias: &str, next_params: &NextParam) -> Option<String> {
         // build the column name
         let mut parts = vec![];
+        let col_writer = ColumnWriter::new(syntax);
         if let Some(colname) = &self.col {
-            let col = format!("{}.{} ", alias, colname);
+            let col = format!("{}.{} ", alias, col_writer.excape(&colname));
             parts.push(col);
         }
 
@@ -201,4 +206,3 @@ impl ClauseAdder for ClauseColManual {
         Some(clause)
     }
 }
-
diff --git a/welds/src/query/clause/exists.rs b/welds/src/query/clause/exists.rs
index b801615..119819e 100644
--- a/welds/src/query/clause/exists.rs
+++ b/welds/src/query/clause/exists.rs
@@ -3,6 +3,7 @@ use crate::Syntax;
 use crate::query::builder::QueryBuilder;
 use crate::query::clause::OrderBy;
 use crate::query::clause::ParamArgs;
+use crate::writers::ColumnWriter;
 use crate::writers::NextParam;
 use crate::writers::TableWriter;
 use crate::writers::alias::TableAlias;
@@ -50,10 +51,14 @@ impl ExistIn {
         }
     }
 
-    fn inner_fk_equal(&self, tablealias: &str) -> String {
+    fn inner_fk_equal(&self, syntax: Syntax, tablealias: &str) -> String {
+        let col_writer = ColumnWriter::new(syntax);
         format!(
             "{}.{} = {}.{}",
-            self.inner_tablealias, self.inner_column, tablealias, self.outer_column
+            self.inner_tablealias,
+            col_writer.excape(&self.inner_column),
+            tablealias,
+            col_writer.excape(&self.outer_column)
         )
     }
 
@@ -66,15 +71,25 @@ impl ExistIn {
     fn exists_clause(&self, syntax: Syntax, _tablealias: &str, inner_clauses: &str) -> String {
         let tails = self.tails(syntax, &self.inner_tablealias);
         let inner_tablename = TableWriter::new(syntax).write2(self.inner_tablename);
+        let col_writer = ColumnWriter::new(syntax);
         format!(
             "EXISTS ( SELECT {} FROM {} {} WHERE {} {})",
-            self.inner_column, inner_tablename, self.inner_tablealias, inner_clauses, tails
+            col_writer.excape(&self.inner_column),
+            inner_tablename,
+            &self.inner_tablealias,
+            inner_clauses,
+            tails
         )
     }
 
     fn in_clause(&self, syntax: Syntax, tablealias: &str, inner_clauses: &str) -> String {
-        let outcol = format!("{}.{}", tablealias, self.outer_column);
-        let innercol = format!("{}.{}", self.inner_tablealias, self.inner_column);
+        let col_writer = ColumnWriter::new(syntax);
+        let outcol = format!("{}.{}", tablealias, col_writer.excape(&self.outer_column));
+        let innercol = format!(
+            "{}.{}",
+            self.inner_tablealias,
+            col_writer.excape(&self.inner_column)
+        );
         let inner_tablename = TableWriter::new(syntax).write2(self.inner_tablename);
         let tails = self.tails(syntax, &self.inner_tablealias);
         let mut wheres = "".to_string();
@@ -111,7 +126,7 @@ impl ClauseAdder for ExistIn {
             .collect();
 
         if !using_in {
-            inner_wheres.push(self.inner_fk_equal(self_tablealias));
+            inner_wheres.push(self.inner_fk_equal(syntax, self_tablealias));
         }
 
         // exists inside this exist clause
diff --git a/welds/src/query/clause/or_and.rs b/welds/src/query/clause/or_and.rs
index 8344f43..6a5429e 100644
--- a/welds/src/query/clause/or_and.rs
+++ b/welds/src/query/clause/or_and.rs
@@ -121,7 +121,7 @@ mod tests {
 
         let sql = and_clause.clause(Syntax::Postgres, "t1", &NextParam::new(Syntax::Postgres));
         assert!(sql.is_some());
-        assert_eq!(sql.unwrap(), "(t1.id = $1 AND t1.is_active = $2)");
+        assert_eq!(sql.unwrap(), r#"(t1."id" = $1 AND t1."is_active" = $2)"#);
     }
 
     #[test]
@@ -132,7 +132,10 @@ mod tests {
 
         let sql = or_clause.clause(Syntax::Postgres, "t1", &NextParam::new(Syntax::Postgres));
         assert!(sql.is_some());
-        assert_eq!(sql.unwrap(), "(t1.score > $1 OR t1.name_column = $2)");
+        assert_eq!(
+            sql.unwrap(),
+            r#"(t1."score" > $1 OR t1."name_column" = $2)"#
+        );
     }
 
     #[test]
@@ -150,7 +153,7 @@ mod tests {
         assert!(sql_str.contains("OR"));
         assert_eq!(
             sql_str,
-            "((t1.id = $1 AND t1.is_active = $2) OR t1.score >= $3)"
+            r#"((t1."id" = $1 AND t1."is_active" = $2) OR t1."score" >= $3)"#
         );
     }
 }
diff --git a/welds/src/query/clause/orderby.rs b/welds/src/query/clause/orderby.rs
index 76728c0..c71142d 100644
--- a/welds/src/query/clause/orderby.rs
+++ b/welds/src/query/clause/orderby.rs
@@ -1,3 +1,7 @@
+use welds_connections::Syntax;
+
+use crate::writers::ColumnWriter;
+
 #[derive(Clone)]
 pub struct OrderBy {
     pub(crate) field: String,
@@ -22,22 +26,28 @@ impl OrderBy {
         }
     }
 
-    pub(crate) fn write(&self, table_alias: &str) -> String {
+    pub(crate) fn write(&self, syntax: Syntax, table_alias: &str) -> String {
+        let col_writer = ColumnWriter::new(syntax);
         if self.manual {
             self.field.replace("$", table_alias)
         } else {
-            format!("{}.{} {}", table_alias, self.field, self.direction)
+            format!(
+                "{}.{} {}",
+                table_alias,
+                col_writer.excape(&self.field),
+                self.direction
+            )
         }
     }
 }
 
-pub(crate) fn to_sql(parts: &[OrderBy], table_alias: &str) -> String {
+pub(crate) fn to_sql(syntax: Syntax, parts: &[OrderBy], table_alias: &str) -> String {
     if parts.is_empty() {
         return "".to_owned();
     }
     let bys: Vec<String> = parts
         .iter()
-        .map(|order_by| order_by.write(table_alias))
+        .map(|order_by| order_by.write(syntax, table_alias))
         .collect();
     let bys = bys.join(", ");
     format!("ORDER BY {}", bys)
@@ -50,8 +60,8 @@ fn single_order_by_field() {
         direction: "desc".to_owned(),
         manual: false,
     }];
-    let clause = to_sql(&parts, "t1");
-    assert_eq!(clause.as_str(), "ORDER BY t1.f1 desc")
+    let clause = to_sql(Syntax::Sqlite, &parts, "t1");
+    assert_eq!(clause.as_str(), r#"ORDER BY t1."f1" desc"#)
 }
 
 #[test]
@@ -68,6 +78,6 @@ fn order_by_field_two_fields() {
             manual: false,
         },
     ];
-    let clause = to_sql(&parts, "t33");
-    assert_eq!(clause.as_str(), "ORDER BY t33.f1 desc, t33.f2 asc")
+    let clause = to_sql(Syntax::Sqlite, &parts, "t33");
+    assert_eq!(clause.as_str(), r#"ORDER BY t33."f1" desc, t33."f2" asc"#)
 }
diff --git a/welds/src/query/clause/wherein.rs b/welds/src/query/clause/wherein.rs
index df843cc..9c5077f 100644
--- a/welds/src/query/clause/wherein.rs
+++ b/welds/src/query/clause/wherein.rs
@@ -26,9 +26,10 @@ where
         WhereIn { qb }
     }
 
-    fn outer_tablecolumn(&self, outer_tablealias: &str) -> String {
+    fn outer_tablecolumn(&self, syntax: Syntax, outer_tablealias: &str) -> String {
         let column = T::Schema::id_column();
-        format!("{}.{}", outer_tablealias, column.name())
+        let col_writer = ColumnWriter::new(syntax);
+        format!("{}.{}", outer_tablealias, col_writer.excape(column.name()))
     }
 }
 
@@ -52,7 +53,7 @@ where
     fn clause(&self, syntax: Syntax, alias: &str, next_params: &NextParam) -> Option<String> {
         // writes => ID IN ( SELECT ID FROM ... )
 
-        let outcol = self.outer_tablecolumn(alias);
+        let outcol = self.outer_tablecolumn(syntax, alias);
         let inner_alias = &self.qb.alias;
         let mut args = None;
         let inner_sql = join_sql_parts(&[
diff --git a/welds/src/query/select/tests/basic.rs b/welds/src/query/select/tests/basic.rs
index 3e72fb9..b185825 100644
--- a/welds/src/query/select/tests/basic.rs
+++ b/welds/src/query/select/tests/basic.rs
@@ -72,7 +72,7 @@ fn should_be_able_to_write_sql_with_basic_where() {
     let q = QueryBuilder::<Product>::new().where_col(|c| c.name.equal("bla"));
     let sql = q.to_sql(Syntax::Sqlite);
     assert_eq!(
-        "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.dbname = ? )",
+        "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.\"dbname\" = ? )",
         &sql
     );
 }
@@ -82,7 +82,7 @@ fn should_be_able_to_write_sql_count_with_basic_where() {
     let q = QueryBuilder::<Product>::new().where_col(|c| c.name.equal("bla"));
     let sql = q.to_sql_count(Syntax::Sqlite);
     assert_eq!(
-        "SELECT CAST( COUNT(*) as BIGINT ) FROM da_schemaname.da_tablename t1 WHERE ( t1.dbname = ? )",
+        "SELECT CAST( COUNT(*) as BIGINT ) FROM da_schemaname.da_tablename t1 WHERE ( t1.\"dbname\" = ? )",
         &sql
     );
 }
@@ -97,7 +97,7 @@ fn should_exec_basic_with_where() {
     })
     .unwrap();
     assert_eq!(
-        "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.dbname = @p1 )",
+        "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.\"dbname\" = @p1 )",
         &ran_sql
     );
 }
@@ -112,7 +112,7 @@ fn sqlite_syntax_should_be_translated_to_like() {
     })
     .unwrap();
     assert_eq!(
-        "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.dbname like ? )",
+        "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.\"dbname\" like ? )",
         &ran_sql
     );
 }
diff --git a/welds/src/query/select/tests/basicopt.rs b/welds/src/query/select/tests/basicopt.rs
index fecf947..659830b 100644
--- a/welds/src/query/select/tests/basicopt.rs
+++ b/welds/src/query/select/tests/basicopt.rs
@@ -70,7 +70,7 @@ fn should_exec_basicopt_with_where_with_value() {
         q.run(&client).await.unwrap();
         let ran_sql = client.last_sql().unwrap();
         let expected =
-            "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.dbname = @p1 )";
+            "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.\"dbname\" = @p1 )";
         assert_eq!(expected, &ran_sql);
     });
 }
@@ -82,8 +82,7 @@ fn should_exec_basicopt_with_where_with_none() {
         let client = welds_connections::noop::build(Syntax::Mssql);
         q.run(&client).await.unwrap();
         let ran_sql = client.last_sql().unwrap();
-        let expected =
-            "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.dbname IS NULL )";
+        let expected = "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.\"dbname\" IS NULL )";
         assert_eq!(expected, &ran_sql);
     });
 }
@@ -97,7 +96,7 @@ fn should_exec_basicopt_with_where_with_some() {
         q.run(&client).await.unwrap();
         let ran_sql = client.last_sql().unwrap();
         let expected =
-            "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.dbname = @p1 )";
+            "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.\"dbname\" = @p1 )";
         assert_eq!(expected, &ran_sql);
     });
 }
diff --git a/welds/src/query/select/tests/sql_tails.rs b/welds/src/query/select/tests/sql_tails.rs
index 188a835..ab4257e 100644
--- a/welds/src/query/select/tests/sql_tails.rs
+++ b/welds/src/query/select/tests/sql_tails.rs
@@ -85,7 +85,7 @@ fn should_order_by_asc() {
     })
     .unwrap();
     assert_eq!(
-        "SELECT t1.\"a\", t1.\"b\" FROM nums t1 ORDER BY t1.a ASC",
+        "SELECT t1.\"a\", t1.\"b\" FROM nums t1 ORDER BY t1.\"a\" ASC",
         &ran_sql
     );
 }
@@ -102,7 +102,7 @@ fn should_order_by_two_columns() {
     })
     .unwrap();
     assert_eq!(
-        "SELECT t1.\"a\", t1.\"b\" FROM nums t1 ORDER BY t1.a ASC, t1.b DESC",
+        "SELECT t1.\"a\", t1.\"b\" FROM nums t1 ORDER BY t1.\"a\" ASC, t1.\"b\" DESC",
         &ran_sql
     );
 }
diff --git a/welds/src/query/select_cols/tests.rs b/welds/src/query/select_cols/tests.rs
index e2febc6..882dce4 100644
--- a/welds/src/query/select_cols/tests.rs
+++ b/welds/src/query/select_cols/tests.rs
@@ -55,7 +55,7 @@ fn should_be_able_to_select_join_with_order_by() {
         let sql = q.to_sql(Syntax::Postgres);
         assert_eq!(
             sql,
-            "SELECT t1.\"id\", t2.\"price\" FROM products t1 JOIN orders t2 ON t1.\"id\" = t2.\"product_id\" ORDER BY t1.id ASC"
+            "SELECT t1.\"id\", t2.\"price\" FROM products t1 JOIN orders t2 ON t1.\"id\" = t2.\"product_id\" ORDER BY t1.\"id\" ASC"
         );
     });
 }
diff --git a/welds/src/query/tail.rs b/welds/src/query/tail.rs
index c3d10be..d446850 100644
--- a/welds/src/query/tail.rs
+++ b/welds/src/query/tail.rs
@@ -25,7 +25,7 @@ pub(crate) fn write(
     }
 
     if !orders.is_empty() {
-        parts.push_front(orderby::to_sql(orders, table_alias));
+        parts.push_front(orderby::to_sql(syntax, orders, table_alias));
     }
 
     if parts.is_empty() {
diff --git a/welds/src/query/update/bulk/tests.rs b/welds/src/query/update/bulk/tests.rs
index 4c647b6..eb42317 100644
--- a/welds/src/query/update/bulk/tests.rs
+++ b/welds/src/query/update/bulk/tests.rs
@@ -55,7 +55,7 @@ fn should_be_able_to_write_complex_set_values() {
             .last_sql()
             .expect("Expected to get SQL back from client");
 
-        let expected = "UPDATE nums SET \"a\"=$1, \"b\"=$2 WHERE ( nums.id > $3 )";
+        let expected = "UPDATE nums SET \"a\"=$1, \"b\"=$2 WHERE ( nums.\"id\" > $3 )";
         assert_eq!(expected, &ran_sql);
 
         assert_eq!(client.args_count().unwrap(), 3);
@@ -78,7 +78,7 @@ fn should_be_able_to_write_complex_set_col_values() {
             .expect("Expected to get SQL back from client");
 
         //let expected = "UPDATE nums SET nums.a = $1, nums.b = $2 WHERE ( nums.id > $3 )";
-        let expected = "UPDATE nums SET \"a\"=$1, \"b\"=$2 WHERE ( nums.id > $3 )";
+        let expected = "UPDATE nums SET \"a\"=$1, \"b\"=$2 WHERE ( nums.\"id\" > $3 )";
         assert_eq!(expected, &ran_sql);
     });
 }
@@ -100,7 +100,7 @@ fn should_be_able_to_write_a_custom_set_statement() {
             .last_sql()
             .expect("Expected to get SQL back from client");
 
-        let expected = "UPDATE nums SET \"a\" = ( nums.b + $1 ) WHERE ( nums.id > $2 )";
+        let expected = "UPDATE nums SET \"a\" = ( nums.b + $1 ) WHERE ( nums.\"id\" > $2 )";
         assert_eq!(expected, &ran_sql);
     });
 }