diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/sqlite/grammar/test_sqlite_delete_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/sqlite/grammar/test_sqlite_delete_grammar.py
deleted file mode 100644
index 3bd36a87..00000000
--- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/sqlite/grammar/test_sqlite_delete_grammar.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import inspect
-import unittest
-
-from src.masoniteorm.query import QueryBuilder
-from src.masoniteorm.query.grammars import SQLiteGrammar
-
-
-class BaseDeleteGrammarTest:
-    def setUp(self):
-        self.builder = QueryBuilder(SQLiteGrammar, table="users")
-
-    def test_can_compile_delete(self):
-        to_sql = self.builder.delete("id", 1, query=True).to_sql()
-
-        sql = getattr(
-            self, inspect.currentframe().f_code.co_name.replace("test_", "")
-        )()
-        self.assertEqual(to_sql, sql)
-
-    def test_can_compile_delete_in(self):
-        to_sql = self.builder.delete("id", [1, 2, 3], query=True).to_sql()
-
-        sql = getattr(
-            self, inspect.currentframe().f_code.co_name.replace("test_", "")
-        )()
-        self.assertEqual(to_sql, sql)
-
-    def test_can_compile_delete_with_where(self):
-        to_sql = (
-            self.builder.where("age", 20)
-            .where("profile", 1)
-            .delete(query=True)
-            .to_sql()
-        )
-
-        sql = getattr(
-            self, inspect.currentframe().f_code.co_name.replace("test_", "")
-        )()
-        self.assertEqual(to_sql, sql)
-
-
-class TestSqliteDeleteGrammar(BaseDeleteGrammarTest, unittest.TestCase):
-    grammar = "sqlite"
-
-    def can_compile_delete(self):
-        """
-        (
-            self.builder
-            .delete('id', 1)
-            .to_sql()
-        )
-        """
-        return """DELETE FROM "users" WHERE "id" = '1'"""
-
-    def can_compile_delete_in(self):
-        """
-        (
-            self.builder
-            .delete('id', 1)
-            .to_sql()
-        )
-        """
-        return """DELETE FROM "users" WHERE "id" IN ('1','2','3')"""
-
-    def can_compile_delete_with_where(self):
-        """
-        (
-            self.builder
-            .where('age', 20)
-            .where('profile', 1)
-            .delete()
-            .to_sql()
-        )
-        """
-        return """DELETE FROM "users" WHERE "age" = '20' AND "profile" = '1'"""
diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/sqlite/grammar/test_sqlite_insert_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/sqlite/grammar/test_sqlite_insert_grammar.py
deleted file mode 100644
index 35ee7eb9..00000000
--- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/sqlite/grammar/test_sqlite_insert_grammar.py
+++ /dev/null
@@ -1,103 +0,0 @@
-import inspect
-import unittest
-
-from src.masoniteorm.query import QueryBuilder
-from src.masoniteorm.query.grammars import SQLiteGrammar
-
-
-class BaseInsertGrammarTest:
-    def setUp(self):
-        self.builder = QueryBuilder(SQLiteGrammar, table="users")
-
-    def test_can_compile_insert(self):
-        to_sql = self.builder.create({"name": "Joe"}, query=True).to_sql()
-
-        sql = getattr(
-            self, inspect.currentframe().f_code.co_name.replace("test_", "")
-        )()
-        self.assertEqual(to_sql, sql)
-
-    def test_can_compile_insert_with_keywords(self):
-        to_sql = self.builder.create(name="Joe", query=True).to_sql()
-
-        sql = getattr(
-            self, inspect.currentframe().f_code.co_name.replace("test_", "")
-        )()
-        self.assertEqual(to_sql, sql)
-
-    def test_can_compile_bulk_create(self):
-        to_sql = self.builder.bulk_create(
-            # These keys are intentionally out of order to show column to value alignment works
-            [
-                {"name": "Joe", "age": 5},
-                {"age": 35, "name": "Bill"},
-                {"name": "John", "age": 10},
-            ],
-            query=True,
-        ).to_sql()
-
-        sql = getattr(
-            self, inspect.currentframe().f_code.co_name.replace("test_", "")
-        )()
-        self.assertEqual(to_sql, sql)
-
-    def test_can_compile_bulk_create_qmark(self):
-        to_sql = self.builder.bulk_create(
-            [{"name": "Joe"}, {"name": "Bill"}, {"name": "John"}], query=True
-        ).to_qmark()
-
-        sql = getattr(
-            self, inspect.currentframe().f_code.co_name.replace("test_", "")
-        )()
-        self.assertEqual(to_sql, sql)
-
-    def test_can_compile_bulk_create_multiple(self):
-        to_sql = self.builder.bulk_create(
-            [
-                {"name": "Joe", "active": "1"},
-                {"name": "Bill", "active": "1"},
-                {"name": "John", "active": "1"},
-            ],
-            query=True,
-        ).to_sql()
-
-        sql = getattr(
-            self, inspect.currentframe().f_code.co_name.replace("test_", "")
-        )()
-        self.assertEqual(to_sql, sql)
-
-
-class TestSqliteUpdateGrammar(BaseInsertGrammarTest, unittest.TestCase):
-    grammar = "sqlite"
-
-    def can_compile_insert(self):
-        """
-        self.builder.create({
-            'name': 'Joe'
-        }).to_sql()
-        """
-        return """INSERT INTO "users" ("name") VALUES ('Joe')"""
-
-    def can_compile_insert_with_keywords(self):
-        """
-        self.builder.create(name="Joe").to_sql()
-        """
-        return """INSERT INTO "users" ("name") VALUES ('Joe')"""
-
-    def can_compile_bulk_create(self):
-        """
-        self.builder.create(name="Joe").to_sql()
-        """
-        return """INSERT INTO "users" ("age", "name") VALUES ('5', 'Joe'), ('35', 'Bill'), ('10', 'John')"""
-
-    def can_compile_bulk_create_multiple(self):
-        """
-        self.builder.create(name="Joe").to_sql()
-        """
-        return """INSERT INTO "users" ("active", "name") VALUES ('1', 'Joe'), ('1', 'Bill'), ('1', 'John')"""
-
-    def can_compile_bulk_create_qmark(self):
-        """
-        self.builder.create(name="Joe").to_sql()
-        """
-        return """INSERT INTO "users" ("name") VALUES (?), (?), (?)"""
diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/sqlite/grammar/test_sqlite_select_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/sqlite/grammar/test_sqlite_select_grammar.py
deleted file mode 100644
index 45575648..00000000
--- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/sqlite/grammar/test_sqlite_select_grammar.py
+++ /dev/null
@@ -1,476 +0,0 @@
-import unittest
-
-from src.masoniteorm.query.grammars import SQLiteGrammar
-from src.masoniteorm.testing import BaseTestCaseSelectGrammar
-
-
-class TestSQLiteGrammar(BaseTestCaseSelectGrammar, unittest.TestCase):
-    grammar = SQLiteGrammar
-    maxDiff = None
-
-    def can_compile_select(self):
-        """
-        self.builder.to_sql()
-        """
-        return """SELECT * FROM "users\""""
-
-    def can_compile_order_by_and_first(self):
-        """
-        self.builder.order_by('id', 'asc').first()
-        """
-        return """SELECT * FROM "users" ORDER BY "id" ASC LIMIT 1"""
-
-    def can_compile_with_columns(self):
-        """
-        self.builder.select('username', 'password').to_sql()
-        """
-        return """SELECT "users"."username", "users"."password" FROM "users\""""
-
-    def can_compile_with_where(self):
-        """
-        self.builder.select('username', 'password').where('id', 1).to_sql()
-        """
-        return """SELECT "users"."username", "users"."password" FROM "users" WHERE "users"."id" = '1'"""
-
-    def can_compile_with_several_where(self):
-        """
-        self.builder.select('username', 'password').where('id', 1).where('username', 'joe').to_sql()
-        """
-        return """SELECT "users"."username", "users"."password" FROM "users" WHERE "users"."id" = '1' AND "users"."username" = 'joe'"""
-
-    def can_compile_with_several_where_and_limit(self):
-        """
-        self.builder.select('username', 'password').where('id', 1).where('username', 'joe').limit(10).to_sql()
-        """
-        return """SELECT "users"."username", "users"."password" FROM "users" WHERE "users"."id" = '1' AND "users"."username" = 'joe' LIMIT 10"""
-
-    def can_compile_with_sum(self):
-        """
-        self.builder.sum('age').to_sql()
-        """
-        return """SELECT SUM("users"."age") AS age FROM "users\""""
-
-    def can_compile_with_max(self):
-        """
-        self.builder.max('age').to_sql()
-        """
-        return """SELECT MAX("users"."age") AS age FROM "users\""""
-
-    def can_compile_with_max_and_columns(self):
-        """
-        self.builder.select('username').max('age').to_sql()
-        """
-        return """SELECT "users"."username", MAX("users"."age") AS age FROM "users\""""
-
-    def can_compile_with_max_and_columns_different_order(self):
-        """
-        self.builder.max('age').select('username').to_sql()
-        """
-        return """SELECT "users"."username", MAX("users"."age") AS age FROM "users\""""
-
-    def can_compile_with_order_by(self):
-        """
-        self.builder.select('username').order_by('age', 'desc').to_sql()
-        """
-        return """SELECT "users"."username" FROM "users" ORDER BY "age" DESC"""
-
-    def can_compile_with_multiple_order_by(self):
-        """
-        self.builder.select('username').order_by('age', 'desc').order_by('name').to_sql()
-        """
-        return (
-            """SELECT "users"."username" FROM "users" ORDER BY "age" DESC, "name" ASC"""
-        )
-
-    def can_compile_with_group_by(self):
-        """
-        self.builder.select('username').group_by('age').to_sql()
-        """
-        return """SELECT "users"."username" FROM "users" GROUP BY "users"."age\""""
-
-    def can_compile_where_in(self):
-        """
-        self.builder.select('username').where_in('age', [1,2,3]).to_sql()
-        """
-        return """SELECT "users"."username" FROM "users" WHERE "users"."age" IN ('1','2','3')"""
-
-    def can_compile_where_in_empty(self):
-        """
-        self.builder.where_in('age', []).to_sql()
-        """
-        return """SELECT * FROM "users" WHERE 0 = 1"""
-
-    def can_compile_where_not_in(self):
-        """
-        self.builder.select('username').where_not_in('age', [1,2,3]).to_sql()
-        """
-        return """SELECT "users"."username" FROM "users" WHERE "users"."age" NOT IN ('1','2','3')"""
-
-    def can_compile_where_null(self):
-        """
-        self.builder.select('username').where_null('age').to_sql()
-        """
-        return """SELECT "users"."username" FROM "users" WHERE "users"."age" IS NULL"""
-
-    def can_compile_where_not_null(self):
-        """
-        self.builder.select('username').where_not_null('age').to_sql()
-        """
-        return (
-            """SELECT "users"."username" FROM "users" WHERE "users"."age" IS NOT NULL"""
-        )
-
-    def can_compile_where_raw(self):
-        """
-        self.builder.where_raw(""age" = '18'").to_sql()
-        """
-        return """SELECT * FROM "users" WHERE "users"."age" = '18'"""
-
-    def can_compile_select_raw(self):
-        """
-        self.builder.select_raw("COUNT(*)").to_sql()
-        """
-        return """SELECT COUNT(*) FROM "users\""""
-
-    def can_compile_limit_and_offset(self):
-        """
-        self.builder.limit(10).offset(10).to_sql()
-        """
-        return """SELECT * FROM "users" LIMIT 10 OFFSET 10"""
-
-    def can_compile_select_raw_with_select(self):
-        """
-        self.builder.select('id').select_raw("COUNT(*)").to_sql()
-        """
-        return """SELECT "users"."id", COUNT(*) FROM "users\""""
-
-    def can_compile_count(self):
-        """
-        self.builder.count().to_sql()
-        """
-
-        return """SELECT COUNT(*) AS m_count_reserved FROM "users\""""
-
-    def can_compile_count_column(self):
-        """
-        self.builder.count().to_sql()
-        """
-
-        return """SELECT COUNT("users"."money") AS money FROM "users\""""
-
-    def can_compile_where_column(self):
-        """
-        self.builder.where_column('name', 'email').to_sql()
-        """
-
-        return """SELECT * FROM "users" WHERE "users"."name" = "users"."email\""""
-
-    def can_compile_or_where(self):
-        """
-        self.builder.where('name', 2).or_where('name', 3).to_sql()
-        """
-        return """SELECT * FROM "users" WHERE "users"."name" = '2' OR "users"."name" = '3'"""
-
-    def can_grouped_where(self):
-        """
-        self.builder.where(lambda query: query.where('age', 2).where('name', 'Joe')).to_sql()
-        """
-        return """SELECT * FROM "users" WHERE ("users"."age" = '2' AND "users"."name" = 'Joe')"""
-
-    def can_compile_sub_select(self):
-        """
-        self.builder.where_in('name',
-            QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('age')
-        ).to_sql()
-        """
-
-        return """SELECT * FROM "users" WHERE "users"."name" IN (SELECT "users"."age" FROM "users")"""
-
-    def can_compile_sub_select_where(self):
-        """
-        self.builder.where_in('age',
-            QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('age').where('age', 2).where('name', 'Joe')
-        ).to_sql()
-        """
-
-        return """SELECT * FROM "users" WHERE "users"."age" IN (SELECT "users"."age" FROM "users" WHERE "users"."age" = '2' AND "users"."name" = 'Joe')"""
-
-    def can_compile_sub_select_value(self):
-        """
-        self.builder.where('name',
-            self.builder.new().sum('age')
-        ).to_sql()
-        """
-
-        return """SELECT * FROM "users" WHERE "users"."name" = (SELECT SUM("users"."age") AS age FROM "users")"""
-
-    def can_compile_complex_sub_select(self):
-        """
-        self.builder.where_in('name',
-            (QueryBuilder(GrammarFactory.make(self.grammar), table='users')
-                .select('age').where_in('email',
-                    QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('email')
-            ))
-        ).to_sql()
-        """
-        return """SELECT * FROM "users" WHERE "users"."name" IN (SELECT "users"."age" FROM "users" WHERE "users"."email" IN (SELECT "users"."email" FROM "users"))"""
-
-    def can_compile_exists(self):
-        """
-        self.builder.select('age').where_exists(
-            self.builder.new().select('username').where('age', 12)
-        ).to_sql()
-        """
-        return """SELECT "users"."age" FROM "users" WHERE EXISTS (SELECT "users"."username" FROM "users" WHERE "users"."age" = '12')"""
-
-    def can_compile_not_exists(self):
-        """
-        self.builder.select('age').where_not_exists(
-            self.builder.new().select('username').where('age', 12)
-        ).to_sql()
-        """
-        return """SELECT "users"."age" FROM "users" WHERE NOT EXISTS (SELECT "users"."username" FROM "users" WHERE "users"."age" = '12')"""
-
-    def can_compile_having(self):
-        """
-        builder.sum('age').group_by('age').having('age').to_sql()
-        """
-        return """SELECT SUM("users"."age") AS age FROM "users" GROUP BY "users"."age" HAVING "users"."age\""""
-
-    def can_compile_having_order(self):
-        """
-        builder.sum('age').group_by('age').having('age').order_by('age', 'desc').to_sql()
-        """
-        return """SELECT SUM("users"."age") AS age FROM "users" GROUP BY "users"."age" HAVING "users"."age\" ORDER "users"."age" DESC"""
-
-    def can_compile_having_raw(self):
-        """
-        builder.select_raw("COUNT(*) as counts").having_raw("counts > 18").to_sql()
-        """
-        return """SELECT COUNT(*) as counts FROM "users" HAVING counts > 18"""
-
-    def can_compile_having_with_expression(self):
-        """
-        builder.sum('age').group_by('age').having('age', 10).to_sql()
-        """
-        return """SELECT SUM("users"."age") AS age FROM "users" GROUP BY "users"."age" HAVING "users"."age" = '10'"""
-
-    def can_compile_having_with_greater_than_expression(self):
-        """
-        builder.sum('age').group_by('age').having('age', '>', 10).to_sql()
-        """
-        return """SELECT SUM("users"."age") AS age FROM "users" GROUP BY "users"."age" HAVING "users"."age" > '10'"""
-
-    def can_compile_join(self):
-        """
-        builder.join('contacts', 'users.id', '=', 'contacts.user_id').to_sql()
-        """
-        return """SELECT * FROM "users" INNER JOIN "contacts" ON "users"."id" = "contacts"."user_id\""""
-
-    def can_compile_left_join(self):
-        """
-        builder.join('contacts', 'users.id', '=', 'contacts.user_id').to_sql()
-        """
-        return """SELECT * FROM "users" LEFT JOIN "contacts" ON "users"."id" = "contacts"."user_id\""""
-
-    def can_compile_multiple_join(self):
-        """
-        builder.join('contacts', 'users.id', '=', 'contacts.user_id').to_sql()
-        """
-        return """SELECT * FROM "users" INNER JOIN "contacts" ON "users"."id" = "contacts"."user_id" INNER JOIN "posts" ON "comments"."post_id" = "posts"."id\""""
-
-    def can_compile_between(self):
-        """
-        builder.between('age', 18, 21).to_sql()
-        """
-        return """SELECT * FROM "users" WHERE "users"."age" BETWEEN '18' AND '21'"""
-
-    def can_compile_not_between(self):
-        """
-        builder.not_between('age', 18, 21).to_sql()
-        """
-        return """SELECT * FROM "users" WHERE "users"."age" NOT BETWEEN '18' AND '21'"""
-
-    def test_can_compile_where_raw(self):
-        to_sql = self.builder.where_raw(""" "age" = '18'""").to_sql()
-        self.assertEqual(to_sql, """SELECT * FROM "users" WHERE "age" = '18'""")
-
-    def test_can_compile_where_raw_and_where_with_multiple_bindings(self):
-        query = self.builder.where_raw(
-            """ "age" = ? AND "is_admin" = ? """, [18, True]
-        ).where("email", "test@example.com")
-        self.assertEqual(
-            query.to_qmark(),
-            """SELECT * FROM "users" WHERE "age" = ? AND "is_admin" = ? AND "users"."email" = ?""",
-        )
-        self.assertEqual(query._bindings, [18, True, "test@example.com"])
-
-    def test_can_compile_select_raw(self):
-        to_sql = self.builder.select_raw("COUNT(*)").to_sql()
-        self.assertEqual(to_sql, """SELECT COUNT(*) FROM "users\"""")
-
-    def test_can_compile_select_raw_with_select(self):
-        to_sql = self.builder.select("id").select_raw("COUNT(*)").to_sql()
-        self.assertEqual(to_sql, """SELECT "users"."id", COUNT(*) FROM "users\"""")
-
-    def can_compile_first_or_fail(self):
-        """
-        builder = self.get_builder()
-        builder.where("is_admin", "=", True).first_or_fail()
-        """
-        return """SELECT * FROM "users" WHERE "users"."is_admin" = '1' LIMIT 1"""
-
-    def where_not_like(self):
-        """
-        builder = self.get_builder()
-        builder.where("age", "not like", "%name%").to_sql()
-        """
-        return """SELECT * FROM "users" WHERE "users"."age" NOT LIKE '%name%'"""
-
-    def where_like(self):
-        """
-        builder = self.get_builder()
-        builder.where("age", "like", "%name%").to_sql()
-        """
-        return """SELECT * FROM "users" WHERE "users"."age" LIKE '%name%'"""
-
-    def where_regexp(self):
-        """
-        builder = self.get_builder()
-        builder.where("age", "regexp", "Joe").to_sql()
-        """
-        return """SELECT * FROM "users" WHERE "users"."age" REGEXP 'Joe'"""
-
-    def where_not_regexp(self):
-        """
-        builder = self.get_builder()
-        builder.where("age", "regexp", "Joe").to_sql()
-        """
-        return """SELECT * FROM "users" WHERE "users"."age" NOT REGEXP 'Joe'"""
-
-    def can_compile_join_clause(self):
-        """
-        builder = self.get_builder()
-        clause = (
-            JoinClause("report_groups as rg")
-            .on("bgt.fund", "=", "rg.fund")
-            .on_value("bgt.active", "=", "1")
-            .or_on_value("bgt.acct", "=", "1234")
-        )
-        builder.join(clause).to_sql()
-        """
-        return """SELECT * FROM "users" INNER JOIN "report_groups" AS "rg" ON "bgt"."fund" = "rg"."fund" AND "bgt"."dept" = "rg"."dept" AND "bgt"."acct" = "rg"."acct" AND "bgt"."sub" = "rg"."sub\""""
-
-    def can_compile_join_clause_with_value(self):
-        """
-        builder = self.get_builder()
-        clause = (
-            JoinClause("report_groups as rg")
-            .on_value("bgt.active", "=", "1")
-            .or_on_value("bgt.acct", "=", "1234")
-        )
-        builder.join(clause).to_sql()
-        """
-        return """SELECT * FROM "users" INNER JOIN "report_groups" AS "rg" ON "bgt"."active" = '1' OR "bgt"."acct" = '1234'"""
-
-    def can_compile_join_clause_with_null(self):
-        """
-        builder = self.get_builder()
-        clause = (
-            JoinClause("report_groups as rg")
-            .on_null("bgt.acct")
-            .or_on_null("bgt.dept")
-            .on_value("rg.abc", 10)
-        )
-        builder.join(clause).to_sql()
-        """
-        return """SELECT * FROM "users" INNER JOIN "report_groups" AS "rg" ON "acct" IS NULL OR "dept" IS NULL AND "rg"."abc" = '10'"""
-
-    def can_compile_join_clause_with_not_null(self):
-        """
-        builder = self.get_builder()
-        clause = (
-            JoinClause("report_groups as rg")
-            .on_not_null("bgt.acct")
-            .or_on_not_null("bgt.dept")
-            .on_value("rg.abc", 10)
-        )
-        builder.join(clause).to_sql()
-        """
-        return """SELECT * FROM "users" INNER JOIN "report_groups" AS "rg" ON "acct" IS NOT NULL OR "dept" IS NOT NULL AND "rg"."abc" = '10'"""
-
-    def can_compile_join_clause_with_lambda(self):
-        """
-        builder = self.get_builder()
-        builder.join(
-            "report_groups as rg",
-            lambda clause: (
-                clause.on("bgt.fund", "=", "rg.fund")
-                .on_null("bgt")
-            ),
-        ).to_sql()
-        """
-        return """SELECT * FROM "users" INNER JOIN "report_groups" AS "rg" ON "bgt"."fund" = "rg"."fund" AND "bgt" IS NULL"""
-
-    def can_compile_left_join_clause_with_lambda(self):
-        """
-        builder = self.get_builder()
-        builder.left_join(
-            "report_groups as rg",
-            lambda clause: (
-                clause.on("bgt.fund", "=", "rg.fund")
-                .or_on_null("bgt")
-            ),
-        ).to_sql()
-        """
-        return """SELECT * FROM "users" LEFT JOIN "report_groups" AS "rg" ON "bgt"."fund" = "rg"."fund" OR "bgt" IS NULL"""
-
-    def can_compile_right_join_clause_with_lambda(self):
-        """
-        builder = self.get_builder()
-        builder.right_join(
-            "report_groups as rg",
-            lambda clause: (
-                clause.on("bgt.fund", "=", "rg.fund")
-                .or_on_null("bgt")
-            ),
-        ).to_sql()
-        """
-        return """SELECT * FROM "users" LEFT JOIN "report_groups" AS "rg" ON "bgt"."fund" = "rg"."fund" OR "bgt" IS NULL"""
-
-    def update_lock(self):
-        """
-        builder = self.get_builder()
-        builder.where("age", "not like", "%name%").to_sql()
-        """
-        return """SELECT * FROM "users" WHERE "users"."votes" >= '100'"""
-
-    def shared_lock(self):
-        """
-        builder = self.get_builder()
-        builder.where("age", "not like", "%name%").to_sql()
-        """
-        return """SELECT * FROM "users" WHERE "users"."votes" >= '100'"""
-
-    def can_user_where_raw_and_where(self):
-        """
-        builder.where_raw("age = '18'").where("name", "=", "James").to_sql()
-        """
-        return """SELECT * FROM "users" WHERE age = '18' AND "users"."name" = 'James'"""
-
-    def where_exists_with_lambda(self):
-        return """SELECT * FROM "users" WHERE EXISTS (SELECT * FROM "users" WHERE "users"."age" = '1')"""
-
-    def where_not_exists_with_lambda(self):
-        return """SELECT * FROM "users" WHERE NOT EXISTS (SELECT * FROM "users" WHERE "users"."age" = '1')"""
-
-    def where_date(self):
-        return (
-            """SELECT * FROM "users" WHERE DATE("users"."created_at") = '2022-06-01'"""
-        )
-
-    def or_where_null(self):
-        return """SELECT * FROM "users" WHERE "users"."column1" IS NULL OR "users"."column2" IS NULL"""
-
-    def select_distinct(self):
-        return """SELECT DISTINCT "users"."group" FROM "users\""""
diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/sqlite/grammar/test_sqlite_update_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/sqlite/grammar/test_sqlite_update_grammar.py
deleted file mode 100644
index 4ee26543..00000000
--- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/sqlite/grammar/test_sqlite_update_grammar.py
+++ /dev/null
@@ -1,113 +0,0 @@
-import inspect
-import unittest
-
-from src.masoniteorm.query import QueryBuilder
-from src.masoniteorm.query.grammars import SQLiteGrammar
-from src.masoniteorm.expressions import Raw
-
-
-class BaseTestCaseUpdateGrammar:
-    def setUp(self):
-        self.builder = QueryBuilder(SQLiteGrammar, table="users")
-
-    def test_can_compile_update(self):
-        to_sql = (
-            self.builder.where("name", "bob").update({"name": "Joe"}, dry=True).to_sql()
-        )
-
-        sql = getattr(
-            self, inspect.currentframe().f_code.co_name.replace("test_", "")
-        )()
-        self.assertEqual(to_sql, sql)
-
-    def test_can_compile_multiple_update(self):
-        to_sql = self.builder.update(
-            {"name": "Joe", "email": "user@email.com"}, dry=True
-        ).to_sql()
-
-        sql = getattr(
-            self, inspect.currentframe().f_code.co_name.replace("test_", "")
-        )()
-        self.assertEqual(to_sql, sql)
-
-    def test_can_compile_update_with_multiple_where(self):
-        to_sql = (
-            self.builder.where("name", "bob")
-            .where("age", 20)
-            .update({"name": "Joe"}, dry=True)
-            .to_sql()
-        )
-
-        sql = getattr(
-            self, inspect.currentframe().f_code.co_name.replace("test_", "")
-        )()
-        self.assertEqual(to_sql, sql)
-
-    # def test_can_compile_increment(self):
-    #     to_sql = self.builder.increment("age")
-    #     print(to_sql)
-
-    #     self.assertTrue(to_sql.isnumeric())
-
-    # def test_can_compile_decrement(self):
-    #     to_sql = self.builder.decrement("age", 20).to_sql()
-
-    #     sql = getattr(
-    #         self, inspect.currentframe().f_code.co_name.replace("test_", "")
-    #     )()
-    #     self.assertEqual(to_sql, sql)
-
-    def test_raw_expression(self):
-        to_sql = self.builder.update({"name": Raw('"username"')}, dry=True).to_sql()
-
-        sql = getattr(
-            self, inspect.currentframe().f_code.co_name.replace("test_", "")
-        )()
-
-        self.assertEqual(to_sql, sql)
-
-
-class TestSqliteUpdateGrammar(BaseTestCaseUpdateGrammar, unittest.TestCase):
-    grammar = "sqlite"
-
-    def can_compile_update(self):
-        """
-        builder.where('name', 'bob').update({
-            'name': 'Joe'
-        }).to_sql()
-        """
-        return """UPDATE "users" SET "name" = 'Joe' WHERE "name" = 'bob'"""
-
-    def raw_expression(self):
-        """
-        builder.where('name', 'bob').update({
-            'name': 'Joe'
-        }).to_sql()
-        """
-        return 'UPDATE "users" SET "name" = "username"'
-
-    def can_compile_multiple_update(self):
-        """
-        self.builder.update({"name": "Joe", "email": "user@email.com"}, dry=True).to_sql()
-        """
-        return """UPDATE "users" SET "name" = 'Joe', "email" = 'user@email.com'"""
-
-    def can_compile_update_with_multiple_where(self):
-        """
-        builder.where('name', 'bob').where('age', 20).update({
-            'name': 'Joe'
-        }).to_sql()
-        """
-        return """UPDATE "users" SET "name" = 'Joe' WHERE "name" = 'bob' AND "age" = '20'"""
-
-    def can_compile_increment(self):
-        """
-        builder.increment('age').to_sql()
-        """
-        return """UPDATE "users" SET "age" = "age" + '1'"""
-
-    def can_compile_decrement(self):
-        """
-        builder.decrement('age', 20).to_sql()
-        """
-        return """UPDATE "users" SET "age" = "age" - '20'"""
diff --git a/fastapi_startkit/tests/masoniteorm/sqlite/builder/test_sqlite_builder_insert.py b/fastapi_startkit/tests/masoniteorm/sqlite/builder/test_sqlite_builder_insert.py
index 6890860f..92c8da9d 100644
--- a/fastapi_startkit/tests/masoniteorm/sqlite/builder/test_sqlite_builder_insert.py
+++ b/fastapi_startkit/tests/masoniteorm/sqlite/builder/test_sqlite_builder_insert.py
@@ -1,3 +1,6 @@
+from unittest.mock import AsyncMock
+
+from ...fixtures.db import DB
 from ...fixtures.model import User
 from ..test_case import TestCase
 
@@ -13,3 +16,25 @@ async def test_insert_via_builder(self):
         user = await User.where("email", "bulk@test.com").first()
         assert user is not None
         assert user.name == "Bulk User"
+
+    async def test_bulk_insert_sql_single(self):
+        mock_insert = AsyncMock(return_value=1)
+        DB.connection("sqlite").insert = mock_insert
+
+        await User.query().insert({"name": "Joe"})
+
+        mock_insert.assert_called_once()
+        sql, bindings = mock_insert.call_args[0]
+        self.assertEqual(sql, 'INSERT INTO "users" ("name") VALUES (?)')
+        self.assertEqual(list(bindings), ["Joe"])
+
+    async def test_bulk_insert_sql_multiple(self):
+        mock_insert = AsyncMock(return_value=3)
+        DB.connection("sqlite").insert = mock_insert
+
+        await User.query().insert([{"name": "Joe"}, {"name": "Bill"}, {"name": "John"}])
+
+        mock_insert.assert_called_once()
+        sql, bindings = mock_insert.call_args[0]
+        self.assertEqual(sql, 'INSERT INTO "users" ("name") VALUES (?), (?), (?)')
+        self.assertEqual(list(bindings), ["Joe", "Bill", "John"])
diff --git a/fastapi_startkit/tests/masoniteorm/sqlite/builder/test_sqlite_query_builder.py b/fastapi_startkit/tests/masoniteorm/sqlite/builder/test_sqlite_query_builder.py
index e2c3c839..72156f93 100644
--- a/fastapi_startkit/tests/masoniteorm/sqlite/builder/test_sqlite_query_builder.py
+++ b/fastapi_startkit/tests/masoniteorm/sqlite/builder/test_sqlite_query_builder.py
@@ -1,4 +1,7 @@
+from unittest.mock import AsyncMock
+
 from ..test_case import TestCase
+from ...fixtures.db import DB
 from ...fixtures.model import User
 
 
@@ -87,3 +90,47 @@ async def test_when_true_applies_condition(self):
     async def test_when_false_skips_condition(self):
         sql = User.query().when(False, lambda q: q.where("is_admin", 1)).to_sql()
         self.assertEqual(sql, 'SELECT * FROM "users"')
+
+    async def test_update_sql_and_bindings(self):
+        mock_update = AsyncMock(return_value=1)
+        DB.connection("sqlite").update = mock_update
+
+        await User.query().where("id", 1).update({"name": "Joe", "email": "joe@test.com"})
+
+        mock_update.assert_called_once()
+        sql, bindings = mock_update.call_args[0]
+        self.assertEqual(sql, 'UPDATE "users" SET "name" = ?, "email" = ? WHERE "id" = ?')
+        self.assertEqual(list(bindings), ["Joe", "joe@test.com", 1])
+
+    async def test_delete_by_column(self):
+        mock_delete = AsyncMock(return_value=1)
+        DB.connection("sqlite").delete = mock_delete
+
+        await User.query().where("id", 1).delete()
+
+        mock_delete.assert_called_once()
+        sql, bindings = mock_delete.call_args[0]
+        self.assertEqual(sql, 'DELETE FROM "users" WHERE "id" = ?')
+        self.assertEqual(list(bindings), [1])
+
+    async def test_delete_where_in(self):
+        mock_delete = AsyncMock(return_value=3)
+        DB.connection("sqlite").delete = mock_delete
+
+        await User.query().where_in("id", [1, 2, 3]).delete()
+
+        mock_delete.assert_called_once()
+        sql, bindings = mock_delete.call_args[0]
+        self.assertEqual(sql, 'DELETE FROM "users" WHERE "id" IN (?, ?, ?)')
+        self.assertEqual(list(bindings), [1, 2, 3])
+
+    async def test_delete_with_multiple_wheres(self):
+        mock_delete = AsyncMock(return_value=1)
+        DB.connection("sqlite").delete = mock_delete
+
+        await User.query().where("age", 20).where("profile", 1).delete()
+
+        mock_delete.assert_called_once()
+        sql, bindings = mock_delete.call_args[0]
+        self.assertEqual(sql, 'DELETE FROM "users" WHERE "age" = ? AND "profile" = ?')
+        self.assertEqual(list(bindings), [20, 1])