diff --git a/simple_query_builder/querybuilder.py b/simple_query_builder/querybuilder.py
index 7672103..9057300 100644
--- a/simple_query_builder/querybuilder.py
+++ b/simple_query_builder/querybuilder.py
@@ -384,6 +384,15 @@ def select(self, table: Union[str, list, dict], fields: Union[str, list, dict] =
 
         return self
 
+    def select_distinct(self, table: Union[str, list, dict], fields: Union[str, list, dict] = "*"):
+        if table and fields:
+            self.select(table, fields, True)
+        else:
+            self.set_error(f"Empty table or fields in {inspect.stack()[0][3]} method")
+            return self
+
+        return self
+
     def where(self, where: Union[str, list], addition: str = ""):
         if not where:
             self.set_error(f"Empty where in {inspect.stack()[0][3]} method")
@@ -614,7 +623,7 @@ def update(self, table: Union[str, dict], fields: Union[list, dict]):
 
     def join(self, table: Union[str, dict] = "", on: Union[str, tuple, list] = (), join_type: str = "INNER"):
         join_type = join_type.upper()
-        if self._db.get_driver() == 'sqlite':
+        if self.get_driver() == 'sqlite':
             if join_type == "" or join_type not in self._SQLITE_JOIN_TYPES:
                 self.set_error(f"Empty join_type or is not allowed in {inspect.stack()[0][3]} method. Try one of these {self._SQLITE_JOIN_TYPES}")
                 return self
@@ -652,6 +661,11 @@ def union(self, union_all: bool = False):
         self._sql += " UNION ALL " if union_all else " UNION "
         return self
 
+    def union_all(self):
+        self._concat = True
+        self._sql += " UNION ALL "
+        return self
+
     def union_select(self, table: Union[str, list, dict], union_all: bool = False):
         if not table:
             self.set_error(f"Empty table in {inspect.stack()[0][3]} method")
@@ -665,6 +679,15 @@ def union_select(self, table: Union[str, list, dict], union_all: bool = False):
 
         return self
 
+    def union_select_all(self, table: Union[str, list, dict]):
+        if not table:
+            self.set_error(f"Empty table in {inspect.stack()[0][3]} method")
+            return self
+
+        self.union_select(table, True)
+
+        return self
+
     def excepts(self):
         self._concat = True
         self._sql += " EXCEPT "
@@ -700,6 +723,9 @@ def intersect_select(self, table: Union[str, list, dict]):
     def __str__(self):
         return self.get_sql(False)
 
+    def get_driver(self) -> str:
+        return self._db.get_driver().lower()
+
     def create_view(self, view_name: str, add_exists: bool = True):
         # this method will be moved to another class
         if not view_name:
diff --git a/tests/qb_delete_unittest.py b/tests/qb_delete_unittest.py
index 8796ab4..e5457dd 100644
--- a/tests/qb_delete_unittest.py
+++ b/tests/qb_delete_unittest.py
@@ -8,26 +8,71 @@
 class QBDeleteTestCase(unittest.TestCase):
     def setUp(self):
         self.qb = QueryBuilder(DataBase(), ":memory:")
+        self.maxDiff = None
 
-    def test_sql_delete_eq(self):
-        sql = self.qb.delete('comments').where([['user_id', '=', 10]]).get_sql()
-        self.assertEqual(sql, "DELETE FROM `comments` WHERE (`user_id` = 10)")
-        self.assertEqual(self.qb.get_params(), (10, ))
-
-    def test_sql_delete_no_eq(self):
-        sql = self.qb.delete('comments').where([['user_id', 10]]).get_sql()
-        self.assertEqual(sql, "DELETE FROM `comments` WHERE (`user_id` = 10)")
-        self.assertEqual(self.qb.get_params(), (10, ))
-
-    # def test_sql_delete_limit_eq(self):
-    #     sql = self.qb.delete('users').where([['name', '=', 'John']]).limit().get_sql()
-    #     self.assertEqual(sql, "DELETE FROM `users` WHERE (`name` = 'John') LIMIT 1")
-    #     self.assertEqual(self.qb.get_params(), ('John',))
-    #
-    # def test_sql_delete_limit_no_eq(self):
-    #     sql = self.qb.delete('users').where([['name', 'John']]).limit().get_sql()
-    #     self.assertEqual(sql, "DELETE FROM `users` WHERE (`name` = 'John') LIMIT 1")
-    #     self.assertEqual(self.qb.get_params(), ('John',))
+    def test_delete_empty_table(self):
+        result = self.qb.delete('')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table in delete method")
+
+    def test_delete_table_as_str(self):
+        result = self.qb.delete('comments')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "DELETE FROM `comments`")
+        self.assertEqual(result.get_params(), ())
+
+    def test_delete_table_as_dict(self):
+        result = self.qb.delete({'g': 'groups'})
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "DELETE FROM `groups` AS `g`")
+        self.assertEqual(result.get_params(), ())
+
+    def test_delete_where_eq(self):
+        result = self.qb.delete('comments').where([['user_id', '=', 10]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "DELETE FROM `comments` WHERE (`user_id` = 10)")
+        self.assertEqual(result.get_params(), (10, ))
+
+    def test_delete_where_no_eq(self):
+        result = self.qb.delete('comments').where([['user_id', 10]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "DELETE FROM `comments` WHERE (`user_id` = 10)")
+        self.assertEqual(result.get_params(), (10, ))
+
+    def test_delete_limit_eq(self):
+        result = self.qb.delete('users').where([['name', '=', 'John']]).limit()
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        if self.qb.get_driver() == 'sqlite':
+            self.assertEqual(result.get_sql(), "DELETE FROM `users` WHERE (`name` = 'John')")
+        else:
+            self.assertEqual(result.get_sql(), "DELETE FROM `users` WHERE (`name` = 'John') LIMIT 1")
+        self.assertEqual(result.get_params(), ('John',))
+
+    def test_delete_limit_no_eq(self):
+        result = self.qb.delete('users').where([['name', 'John']]).limit()
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        if self.qb.get_driver() == 'sqlite':
+            self.assertEqual(result.get_sql(), "DELETE FROM `users` WHERE (`name` = 'John')")
+        else:
+            self.assertEqual(result.get_sql(), "DELETE FROM `users` WHERE (`name` = 'John') LIMIT 1")
+        self.assertEqual(result.get_params(), ('John',))
+
+    def tearDown(self):
+        pass
 
 
 if __name__ == "__main__":
diff --git a/tests/qb_insert_unittest.py b/tests/qb_insert_unittest.py
index 1c08d53..9bd2a2a 100644
--- a/tests/qb_insert_unittest.py
+++ b/tests/qb_insert_unittest.py
@@ -8,20 +8,71 @@
 class QBInsertTestCase(unittest.TestCase):
     def setUp(self):
         self.qb = QueryBuilder(DataBase(), ":memory:")
+        self.maxDiff = None
 
-    def test_sql_insert(self):
-        sql = self.qb.insert('groups', {'name': 'Moderator', 'permissions': 'moderator'}).get_sql()
-        self.assertEqual(sql, "INSERT INTO `groups` (`name`, `permissions`) VALUES ('Moderator','moderator')")
-        self.assertEqual(self.qb.get_params(), ('Moderator', 'moderator'))
+    def test_insert_empty_table(self):
+        result = self.qb.insert('', {'param': 'new_value'})
 
-    def test_sql_insert_multiple(self):
-        sql = self.qb.insert('groups', [
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table or fields in insert method")
+
+    def test_insert_empty_fields(self):
+        result = self.qb.insert('params', {})
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table or fields in insert method")
+
+    def test_insert_empty_table_and_fields(self):
+        result = self.qb.insert('', {})
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table or fields in insert method")
+
+    def test_insert_table_as_str(self):
+        result = self.qb.insert('groups', {'name': 'Moderator', 'permissions': 'moderator'})
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "INSERT INTO `groups` (`name`, `permissions`) VALUES ('Moderator','moderator')")
+        self.assertEqual(result.get_params(), ('Moderator', 'moderator'))
+
+    def test_insert_table_as_dict(self):
+        result = self.qb.insert({'g': 'groups'}, {'name': 'Moderator', 'permissions': 'moderator'})
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "INSERT INTO `groups` AS `g` (`name`, `permissions`) VALUES ('Moderator','moderator')")
+        self.assertEqual(result.get_params(), ('Moderator', 'moderator'))
+
+    def test_insert_multiple_as_str(self):
+        result = self.qb.insert('groups', [
+                            ['name', 'role'],
+                            ['Moderator', 'moderator'], ['Moderator2', 'moderator'],
+                            ['User', 'user'], ['User2', 'user']
+                        ])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "INSERT INTO `groups` (`name`, `role`) VALUES ('Moderator','moderator'),('Moderator2','moderator'),('User','user'),('User2','user')")
+        self.assertEqual(result.get_params(), ('Moderator', 'moderator', 'Moderator2', 'moderator', 'User', 'user', 'User2', 'user'))
+
+    def test_insert_multiple_as_dict(self):
+        result = self.qb.insert({'g': 'groups'}, [
                             ['name', 'role'],
                             ['Moderator', 'moderator'], ['Moderator2', 'moderator'],
                             ['User', 'user'], ['User2', 'user']
-                        ]).get_sql()
-        self.assertEqual(sql, "INSERT INTO `groups` (`name`, `role`) VALUES ('Moderator','moderator'),('Moderator2','moderator'),('User','user'),('User2','user')")
-        self.assertEqual(self.qb.get_params(), ('Moderator', 'moderator', 'Moderator2', 'moderator', 'User', 'user', 'User2', 'user'))
+                        ])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "INSERT INTO `groups` AS `g` (`name`, `role`) VALUES ('Moderator','moderator'),('Moderator2','moderator'),('User','user'),('User2','user')")
+        self.assertEqual(result.get_params(), ('Moderator', 'moderator', 'Moderator2', 'moderator', 'User', 'user', 'User2', 'user'))
+
+    def tearDown(self):
+        pass
 
 
 if __name__ == "__main__":
diff --git a/tests/qb_select_unittest.py b/tests/qb_select_unittest.py
index 145db22..99d1b32 100644
--- a/tests/qb_select_unittest.py
+++ b/tests/qb_select_unittest.py
@@ -8,192 +8,382 @@
 class QBSelectTestCase(unittest.TestCase):
     def setUp(self):
         self.qb = QueryBuilder(DataBase(), ":memory:")
+        self.maxDiff = None
 
-    def test_sql_select_all(self):
-        sql = self.qb.select('users').get_sql()
-        self.assertEqual(sql, 'SELECT * FROM `users`')
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_where_eq(self):
-        sql = self.qb.select('users').where([['id', '=', 10]]).get_sql()
-        self.assertEqual(sql, 'SELECT * FROM `users` WHERE (`id` = 10)')
-        self.assertEqual(self.qb.get_params(), (10,))
-
-    def test_sql_select_where_no_eq(self):
-        sql = self.qb.select('users').where([['id', 10]]).get_sql()
-        self.assertEqual(sql, 'SELECT * FROM `users` WHERE (`id` = 10)')
-        self.assertEqual(self.qb.get_params(), (10, ))
-
-    def test_sql_select_where_and_eq(self):
-        sql = self.qb.select('users').where([['id', '>', 1], 'and', ['group_id', '=', 2]]).get_sql()
-        self.assertEqual(sql, 'SELECT * FROM `users` WHERE (`id` > 1) AND (`group_id` = 2)')
-        self.assertEqual(self.qb.get_params(), (1, 2))
-
-    def test_sql_select_where_and_no_eq(self):
-        sql = self.qb.select('users').where([['id', '>', 1], 'and', ['group_id', 2]]).get_sql()
-        self.assertEqual(sql, 'SELECT * FROM `users` WHERE (`id` > 1) AND (`group_id` = 2)')
-        self.assertEqual(self.qb.get_params(), (1, 2))
-
-    def test_sql_select_where_or_eq(self):
-        sql = self.qb.select('users').where([['id', '>', 1], 'or', ['group_id', '=', 2]]).get_sql()
-        self.assertEqual(sql, 'SELECT * FROM `users` WHERE (`id` > 1) OR (`group_id` = 2)')
-        self.assertEqual(self.qb.get_params(), (1, 2))
-
-    def test_sql_select_where_or_no_eq(self):
-        sql = self.qb.select('users').where([['id', '>', 1], 'or', ['group_id', 2]]).get_sql()
-        self.assertEqual(sql, 'SELECT * FROM `users` WHERE (`id` > 1) OR (`group_id` = 2)')
-        self.assertEqual(self.qb.get_params(), (1, 2))
-
-    def test_sql_select_where_like(self):
-        sql = self.qb.select('users').where([['name', 'LIKE', '%John%']]).get_sql()
-        self.assertEqual(sql, "SELECT * FROM `users` WHERE (`name` LIKE '%John%')")
-        self.assertEqual(self.qb.get_params(), ('%John%',))
-
-    def test_sql_select_like_list(self):
-        sql = self.qb.select('users').like(['name', '%John%']).get_sql()
-        self.assertEqual(sql, "SELECT * FROM `users` WHERE (`name` LIKE '%John%')")
-        self.assertEqual(self.qb.get_params(), ('%John%',))
-
-    def test_sql_select_like_str(self):
-        sql = self.qb.select('users').like('name', '%John%').get_sql()
-        self.assertEqual(sql, "SELECT * FROM `users` WHERE (`name` LIKE '%John%')")
-        self.assertEqual(self.qb.get_params(), ('%John%',))
-
-    def test_sql_select_where_not_like(self):
-        sql = self.qb.select('users').where([['name', 'NOT LIKE', '%John%']]).get_sql()
-        self.assertEqual(sql, "SELECT * FROM `users` WHERE (`name` NOT LIKE '%John%')")
-        self.assertEqual(self.qb.get_params(), ('%John%',))
-
-    def test_sql_select_not_like_list(self):
-        sql = self.qb.select('users').not_like(['name', '%John%']).get_sql()
-        self.assertEqual(sql, "SELECT * FROM `users` WHERE (`name` NOT LIKE '%John%')")
-        self.assertEqual(self.qb.get_params(), ('%John%',))
-
-    def test_sql_select_not_like_str(self):
-        sql = self.qb.select('users').not_like('name', '%John%').get_sql()
-        self.assertEqual(sql, "SELECT * FROM `users` WHERE (`name` NOT LIKE '%John%')")
-        self.assertEqual(self.qb.get_params(), ('%John%',))
-
-    def test_sql_select_where_is_null(self):
-        sql = self.qb.select('users').where([['phone', 'is null']]).get_sql()
-        self.assertEqual(sql, "SELECT * FROM `users` WHERE (`phone` IS NULL)")
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_is_null(self):
-        sql = self.qb.select('users').is_null('phone').get_sql()
-        self.assertEqual(sql, "SELECT * FROM `users` WHERE (`phone` IS NULL)")
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_where_is_not_null(self):
-        sql = self.qb.select('customers').where([['address', 'is not null']]).get_sql()
-        self.assertEqual(sql, "SELECT * FROM `customers` WHERE (`address` IS NOT NULL)")
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_not_null(self):
-        sql = self.qb.select('customers').not_null('address').get_sql()
-        self.assertEqual(sql, "SELECT * FROM `customers` WHERE (`address` IS NOT NULL)")
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_is_not_null(self):
-        sql = self.qb.select('customers').is_not_null('address').get_sql()
-        self.assertEqual(sql, "SELECT * FROM `customers` WHERE (`address` IS NOT NULL)")
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_offset(self):
-        sql = self.qb.select('posts').where([['user_id', 3]]).offset(14).get_sql()
-        self.assertEqual(sql, "SELECT * FROM `posts` WHERE (`user_id` = 3) OFFSET 14")
-        self.assertEqual(self.qb.get_params(), (3,))
-
-    def test_sql_select_limit(self):
-        sql = self.qb.select('posts').where([['id', '>', 42]]).limit(7).get_sql()
-        self.assertEqual(sql, "SELECT * FROM `posts` WHERE (`id` > 42) LIMIT 7")
-        self.assertEqual(self.qb.get_params(), (42, ))
-
-    def test_sql_select_counter(self):
-        sql = self.qb.select('users', {'counter': 'COUNT(*)'}).get_sql()
-        self.assertEqual(sql, "SELECT COUNT(*) AS `counter` FROM `users`")
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_distinct_order_by(self):
-        sql = self.qb.select('customers', ['city'], True).order_by('city').get_sql()
-        self.assertEqual(sql, "SELECT DISTINCT `city` FROM `customers` ORDER BY `city` ASC")
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_distinct_order_by_2col(self):
-        sql = self.qb.select('customers', ['city', 'country'], True).order_by('country desc').get_sql()
-        self.assertEqual(sql, "SELECT DISTINCT `city`, `country` FROM `customers` ORDER BY `country` DESC")
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_order_by_two_param(self):
-        sql = self.qb.select({'b': 'branches'}, ['b.id', 'b.name'])\
-                    .where([['b.id', '>', 1], 'and', ['b.parent_id', 1]]).order_by('b.id', 'desc').get_sql()
-        self.assertEqual(sql, "SELECT `b`.`id`, `b`.`name` FROM `branches` AS `b` WHERE (`b`.`id` > 1) AND (`b`.`parent_id` = 1) ORDER BY `b`.`id` DESC")
-        self.assertEqual(self.qb.get_params(), (1, 1))
-
-    def test_sql_select_order_by_one_param(self):
-        sql = self.qb.select({'b': 'branches'}, ['b.id', 'b.name'])\
-                    .where([['b.id', '>', 1], 'and', ['b.parent_id', 1]]).order_by('b.id desc').get_sql()
-        self.assertEqual(sql, "SELECT `b`.`id`, `b`.`name` FROM `branches` AS `b` WHERE (`b`.`id` > 1) AND (`b`.`parent_id` = 1) ORDER BY `b`.`id` DESC")
-        self.assertEqual(self.qb.get_params(), (1, 1))
-
-    def test_sql_select_group_by(self):
-        sql = self.qb.select('posts', ['id', 'category', 'title'])\
-                    .where([['views', '>=', 1000]]).group_by('category').get_sql()
-        self.assertEqual(sql, "SELECT `id`, `category`, `title` FROM `posts` WHERE (`views` >= 1000) GROUP BY `category`")
-        self.assertEqual(self.qb.get_params(), (1000, ))
-
-    def test_sql_select_group_by_having_eq(self):
-        sql = self.qb.select('orders', {'month_num': 'MONTH(`created_at`)', 'total': 'SUM(`total`)'})\
+    def test_select_empty_table(self):
+        result = self.qb.select('', 'param')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table or fields in select method")
+
+    def test_select_empty_fields(self):
+        result = self.qb.select('users', [])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table or fields in select method")
+
+    def test_select_empty_table_and_fields(self):
+        result = self.qb.select('', '')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table or fields in select method")
+
+    def test_get_sql(self):
+        result = self.qb.select('users').where([['id', 1]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), 'SELECT * FROM `users` WHERE (`id` = 1)')
+        self.assertEqual(result.get_params(), (1, ))
+
+    def test_get_sql_no_values(self):
+        result = self.qb.select('users').where([['id', 1]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(False), 'SELECT * FROM `users` WHERE (`id` = ?)')
+        self.assertEqual(result.get_params(), (1, ))
+
+    def test_select_no_fields(self):
+        result = self.qb.select('users')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), 'SELECT * FROM `users`')
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_alias_all(self):
+        result = self.qb.select({'u': 'users'}, 'u.*')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), 'SELECT u.* FROM `users` AS `u`')
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_where_eq(self):
+        result = self.qb.select('users').where([['id', '=', 10]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), 'SELECT * FROM `users` WHERE (`id` = 10)')
+        self.assertEqual(result.get_params(), (10,))
+
+    def test_select_where_no_eq(self):
+        result = self.qb.select('users').where([['id', 10]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), 'SELECT * FROM `users` WHERE (`id` = 10)')
+        self.assertEqual(result.get_params(), (10, ))
+
+    def test_select_where_and_eq(self):
+        result = self.qb.select('users').where([['id', '>', 1], 'and', ['group_id', '=', 2]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), 'SELECT * FROM `users` WHERE (`id` > 1) AND (`group_id` = 2)')
+        self.assertEqual(result.get_params(), (1, 2))
+
+    def test_select_where_and_no_eq(self):
+        result = self.qb.select('users').where([['id', '>', 1], 'and', ['group_id', 2]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), 'SELECT * FROM `users` WHERE (`id` > 1) AND (`group_id` = 2)')
+        self.assertEqual(result.get_params(), (1, 2))
+
+    def test_select_where_or_eq(self):
+        result = self.qb.select('users').where([['id', '>', 1], 'or', ['group_id', '=', 2]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), 'SELECT * FROM `users` WHERE (`id` > 1) OR (`group_id` = 2)')
+        self.assertEqual(result.get_params(), (1, 2))
+
+    def test_select_where_or_no_eq(self):
+        result = self.qb.select('users').where([['id', '>', 1], 'or', ['group_id', 2]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), 'SELECT * FROM `users` WHERE (`id` > 1) OR (`group_id` = 2)')
+        self.assertEqual(result.get_params(), (1, 2))
+
+    def test_select_where_like(self):
+        result = self.qb.select('users').where([['name', 'LIKE', '%John%']])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `users` WHERE (`name` LIKE '%John%')")
+        self.assertEqual(result.get_params(), ('%John%',))
+
+    def test_select_like_list(self):
+        result = self.qb.select('users').like(['name', '%John%'])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `users` WHERE (`name` LIKE '%John%')")
+        self.assertEqual(result.get_params(), ('%John%',))
+
+    def test_select_like_str(self):
+        result = self.qb.select('users').like('name', '%John%')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `users` WHERE (`name` LIKE '%John%')")
+        self.assertEqual(result.get_params(), ('%John%',))
+
+    def test_select_where_not_like(self):
+        result = self.qb.select('users').where([['name', 'NOT LIKE', '%John%']])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `users` WHERE (`name` NOT LIKE '%John%')")
+        self.assertEqual(result.get_params(), ('%John%',))
+
+    def test_select_not_like_list(self):
+        result = self.qb.select('users').not_like(['name', '%John%'])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `users` WHERE (`name` NOT LIKE '%John%')")
+        self.assertEqual(result.get_params(), ('%John%',))
+
+    def test_select_not_like_str(self):
+        result = self.qb.select('users').not_like('name', '%John%')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `users` WHERE (`name` NOT LIKE '%John%')")
+        self.assertEqual(result.get_params(), ('%John%',))
+
+    def test_select_where_is_null(self):
+        result = self.qb.select('users').where([['phone', 'is null']])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `users` WHERE (`phone` IS NULL)")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_is_null(self):
+        result = self.qb.select('users').is_null('phone')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `users` WHERE (`phone` IS NULL)")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_where_is_not_null(self):
+        result = self.qb.select('customers').where([['address', 'is not null']])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `customers` WHERE (`address` IS NOT NULL)")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_not_null(self):
+        result = self.qb.select('customers').not_null('address')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `customers` WHERE (`address` IS NOT NULL)")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_is_not_null(self):
+        result = self.qb.select('customers').is_not_null('address')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `customers` WHERE (`address` IS NOT NULL)")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_offset(self):
+        result = self.qb.select('posts').where([['user_id', 3]]).offset(14)
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `posts` WHERE (`user_id` = 3) OFFSET 14")
+        self.assertEqual(result.get_params(), (3,))
+
+    def test_select_limit(self):
+        result = self.qb.select('posts').where([['id', '>', 42]]).limit(7)
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT * FROM `posts` WHERE (`id` > 42) LIMIT 7")
+        self.assertEqual(result.get_params(), (42, ))
+
+    def test_select_counter(self):
+        result = self.qb.select('users', {'counter': 'COUNT(*)'})
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT COUNT(*) AS `counter` FROM `users`")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_distinct_method_empty_table(self):
+        result = self.qb.select_distinct('', 'param')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table or fields in select_distinct method")
+
+    def test_select_distinct_method_empty_fields(self):
+        result = self.qb.select_distinct('users', [])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table or fields in select_distinct method")
+
+    def test_select_distinct_method_empty_table_and_fields(self):
+        result = self.qb.select_distinct('', '')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table or fields in select_distinct method")
+
+    def test_select_distinct_order_by(self):
+        result = self.qb.select('customers', ['city'], True).order_by('city')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT DISTINCT `city` FROM `customers` ORDER BY `city` ASC")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_distinct_method_order_by(self):
+        result = self.qb.select_distinct('customers', ['city']).order_by('city')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT DISTINCT `city` FROM `customers` ORDER BY `city` ASC")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_distinct_order_by_2col(self):
+        result = self.qb.select('customers', ['city', 'country'], True).order_by('country desc')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT DISTINCT `city`, `country` FROM `customers` ORDER BY `country` DESC")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_distinct_method_order_by_2col(self):
+        result = self.qb.select_distinct('customers', ['city', 'country']).order_by('country desc')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT DISTINCT `city`, `country` FROM `customers` ORDER BY `country` DESC")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_order_by_two_params(self):
+        result = self.qb.select({'b': 'branches'}, ['b.id', 'b.name'])\
+                    .where([['b.id', '>', 1], 'and', ['b.parent_id', 1]]).order_by('b.id', 'desc')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT `b`.`id`, `b`.`name` FROM `branches` AS `b` WHERE (`b`.`id` > 1) AND (`b`.`parent_id` = 1) ORDER BY `b`.`id` DESC")
+        self.assertEqual(result.get_params(), (1, 1))
+
+    def test_select_order_by_one_param(self):
+        result = self.qb.select({'b': 'branches'}, ['b.id', 'b.name'])\
+                    .where([['b.id', '>', 1], 'and', ['b.parent_id', 1]]).order_by('b.id desc')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT `b`.`id`, `b`.`name` FROM `branches` AS `b` WHERE (`b`.`id` > 1) AND (`b`.`parent_id` = 1) ORDER BY `b`.`id` DESC")
+        self.assertEqual(result.get_params(), (1, 1))
+
+    def test_select_group_by(self):
+        result = self.qb.select('posts', ['id', 'category', 'title'])\
+                    .where([['views', '>=', 1000]]).group_by('category')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT `id`, `category`, `title` FROM `posts` WHERE (`views` >= 1000) GROUP BY `category`")
+        self.assertEqual(result.get_params(), (1000, ))
+
+    def test_select_group_by_having_eq(self):
+        result = self.qb.select('orders', {'month_num': 'MONTH(`created_at`)', 'total': 'SUM(`total`)'})\
                         .where([['YEAR(`created_at`)', 2020]]).group_by('month_num')\
-                        .having([['total', '=', 20000]]).get_sql()
-        self.assertEqual(sql, "SELECT MONTH(`created_at`) AS `month_num`, SUM(`total`) AS `total` FROM `orders` WHERE (YEAR(`created_at`) = 2020) GROUP BY `month_num` HAVING (`total` = 20000)")
-        self.assertEqual(self.qb.get_params(), (2020, 20000))
+                        .having([['total', '=', 20000]])
+        self.assertEqual(result.get_sql(), "SELECT MONTH(`created_at`) AS `month_num`, SUM(`total`) AS `total` FROM `orders` WHERE (YEAR(`created_at`) = 2020) GROUP BY `month_num` HAVING (`total` = 20000)")
+        self.assertEqual(result.get_params(), (2020, 20000))
 
-    def test_sql_select_group_by_having_no_eq_sum(self):
-        sql = self.qb.select('orders', {'month_num': 'MONTH(`created_at`)', 'total': 'SUM(`total`)'})\
+    def test_select_group_by_having_no_eq_sum(self):
+        result = self.qb.select('orders', {'month_num': 'MONTH(`created_at`)', 'total': 'SUM(`total`)'})\
                         .where([['YEAR(`created_at`)', 2020]]).group_by('month_num')\
-                        .having([['total', 20000]]).get_sql()
-        self.assertEqual(sql, "SELECT MONTH(`created_at`) AS `month_num`, SUM(`total`) AS `total` FROM `orders` WHERE (YEAR(`created_at`) = 2020) GROUP BY `month_num` HAVING (`total` = 20000)")
-        self.assertEqual(self.qb.get_params(), (2020, 20000))
+                        .having([['total', 20000]])
+        self.assertEqual(result.get_sql(), "SELECT MONTH(`created_at`) AS `month_num`, SUM(`total`) AS `total` FROM `orders` WHERE (YEAR(`created_at`) = 2020) GROUP BY `month_num` HAVING (`total` = 20000)")
+        self.assertEqual(result.get_params(), (2020, 20000))
 
-    def test_sql_select_group_by_having_max(self):
-        sql = self.qb.select('employees', ['department', {'Highest salary': 'MAX(`salary`)'}])\
+    def test_select_group_by_having_max(self):
+        result = self.qb.select('employees', ['department', {'Highest salary': 'MAX(`salary`)'}])\
                     .where([['favorite_website', 'Google.com']]).group_by('department')\
-                    .having([['MAX(`salary`)', '>=', 30000]]).get_sql()
-        self.assertEqual(sql, "SELECT `department`, MAX(`salary`) AS `Highest salary` FROM `employees` WHERE (`favorite_website` = 'Google.com') GROUP BY `department` HAVING (MAX(`salary`) >= 30000)")
-        self.assertEqual(self.qb.get_params(), ('Google.com', 30000))
+                    .having([['MAX(`salary`)', '>=', 30000]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT `department`, MAX(`salary`) AS `Highest salary` FROM `employees` WHERE (`favorite_website` = 'Google.com') GROUP BY `department` HAVING (MAX(`salary`) >= 30000)")
+        self.assertEqual(result.get_params(), ('Google.com', 30000))
 
-    def test_sql_select_group_by_having_count(self):
-        sql = self.qb.select('employees', ['department', {'Number of employees': 'COUNT(*)'}])\
+    def test_select_group_by_having_count(self):
+        result = self.qb.select('employees', ['department', {'Number of employees': 'COUNT(*)'}])\
                     .where([['state', 'Nevada']]).group_by('department')\
-                    .having([['COUNT(*)', '>', 20]]).get_sql()
-        self.assertEqual(sql, "SELECT `department`, COUNT(*) AS `Number of employees` FROM `employees` WHERE (`state` = 'Nevada') GROUP BY `department` HAVING (COUNT(*) > 20)")
-        self.assertEqual(self.qb.get_params(), ('Nevada', 20))
-
-    def test_sql_select_summ(self):
-        sql = self.qb.select("1+5 as 'res'").get_sql()
-        self.assertEqual(sql, "SELECT 1+5 as 'res'")
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_sub(self):
-        sql = self.qb.select("10 - 3 as 'res'").get_sql()
-        self.assertEqual(sql, "SELECT 10 - 3 as 'res'")
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_substr(self):
-        sql = self.qb.select("substr('Hello world!', 1, 5) as 'str'").get_sql()
-        self.assertEqual(sql, "SELECT substr('Hello world!', 1, 5) as 'str'")
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_sqlite_version(self):
-        sql = self.qb.select("sqlite_version() as ver").get_sql()
-        self.assertEqual(sql, "SELECT sqlite_version() as ver")
-        self.assertEqual(self.qb.get_params(), ())
-
-    def test_sql_select_time(self):
-        sql = self.qb.select("strftime('%Y-%m-%d %H:%M', 'now')").get_sql()
-        self.assertEqual(sql, "SELECT strftime('%Y-%m-%d %H:%M', 'now')")
-        self.assertEqual(self.qb.get_params(), ())
+                    .having([['COUNT(*)', '>', 20]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT `department`, COUNT(*) AS `Number of employees` FROM `employees` WHERE (`state` = 'Nevada') GROUP BY `department` HAVING (COUNT(*) > 20)")
+        self.assertEqual(result.get_params(), ('Nevada', 20))
+
+    def test_select_sum(self):
+        result = self.qb.select("1+5 as 'res'")
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT 1+5 as 'res'")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_sub(self):
+        result = self.qb.select("10 - 3 as 'res'")
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT 10 - 3 as 'res'")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_substr(self):
+        result = self.qb.select("substr('Hello world!', 1, 5) as 'str'")
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT substr('Hello world!', 1, 5) as 'str'")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_concat_str(self):
+        result = self.qb.select("'Hello' || ' world!' as 'str'")
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT 'Hello' || ' world!' as 'str'")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_sqlite_version(self):
+        result = self.qb.select("sqlite_version() as ver")
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT sqlite_version() as ver")
+        self.assertEqual(result.get_params(), ())
+
+    def test_select_time(self):
+        result = self.qb.select("strftime('%Y-%m-%d %H:%M', 'now')")
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "SELECT strftime('%Y-%m-%d %H:%M', 'now')")
+        self.assertEqual(result.get_params(), ())
 
     def tearDown(self):
         pass
diff --git a/tests/qb_update_unittest.py b/tests/qb_update_unittest.py
index cb33602..9fa73cd 100644
--- a/tests/qb_update_unittest.py
+++ b/tests/qb_update_unittest.py
@@ -8,24 +8,81 @@
 class QBUpdateTestCase(unittest.TestCase):
     def setUp(self):
         self.qb = QueryBuilder(DataBase(), ":memory:")
+        self.maxDiff = None
 
-    def test_sql_update(self):
-        sql = self.qb.update('posts', {'status': 'published'})\
-                    .where([['YEAR(`updated_at`)', '>', 2020]]).get_sql()
-        self.assertEqual(sql, "UPDATE `posts` SET `status` = 'published' WHERE (YEAR(`updated_at`) > 2020)")
+    def test_update_empty_table(self):
+        result = self.qb.update('', {'param': 'new_value'})
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table or fields in update method")
+
+    def test_update_empty_fields(self):
+        result = self.qb.update('params', {})
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table or fields in update method")
+
+    def test_update_empty_table_and_fields(self):
+        result = self.qb.update('', {})
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table or fields in update method")
+
+    def test_update_table_as_str(self):
+        result = self.qb.update('posts', {'status': 'published'}).where([['YEAR(`updated_at`)', '>', 2020]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "UPDATE `posts` SET `status` = 'published' WHERE (YEAR(`updated_at`) > 2020)")
+        self.assertEqual(self.qb.get_params(), ('published', 2020))
+
+    def test_update_table_as_dict(self):
+        result = self.qb.update({'p': 'posts'}, {'status': 'published'}).where([['YEAR(`updated_at`)', '>', 2020]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "UPDATE `posts` AS `p` SET `status` = 'published' WHERE (YEAR(`updated_at`) > 2020)")
         self.assertEqual(self.qb.get_params(), ('published', 2020))
 
-    def test_sql_update_limit_eq(self):
-        sql = self.qb.update('users', {'username': 'John Doe', 'status': 'new status'})\
-                    .where([['id', '=', 7]]).limit().get_sql()
-        self.assertEqual(sql, "UPDATE `users` SET `username` = 'John Doe', `status` = 'new status' WHERE (`id` = 7) LIMIT 1")
+    def test_update_where_eq(self):
+        result = self.qb.update('posts', {'status': 'draft'}).where([['user_id', '=', 10]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "UPDATE `posts` SET `status` = 'draft' WHERE (`user_id` = 10)")
+        self.assertEqual(self.qb.get_params(), ('draft', 10))
+
+    def test_update_where_no_eq(self):
+        result = self.qb.update('posts', {'status': 'draft'}).where([['user_id', 10]])
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "UPDATE `posts` SET `status` = 'draft' WHERE (`user_id` = 10)")
+        self.assertEqual(self.qb.get_params(), ('draft', 10))
+
+    def test_update_where_eq_limit(self):
+        result = self.qb.update('users', {'username': 'John Doe', 'status': 'new status'})\
+                    .where([['id', '=', 7]]).limit()
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "UPDATE `users` SET `username` = 'John Doe', `status` = 'new status' WHERE (`id` = 7) LIMIT 1")
         self.assertEqual(self.qb.get_params(), ('John Doe', 'new status', 7))
 
-    def test_sql_update_limit_no_eq(self):
-        sql = self.qb.update('users', {'username': 'John Doe', 'status': 'new status'})\
-                    .where([['id', 7]]).limit().get_sql()
-        self.assertEqual(sql, "UPDATE `users` SET `username` = 'John Doe', `status` = 'new status' WHERE (`id` = 7) LIMIT 1")
+    def test_update_where_no_eq_limit(self):
+        result = self.qb.update('users', {'username': 'John Doe', 'status': 'new status'})\
+                    .where([['id', 7]]).limit()
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "UPDATE `users` SET `username` = 'John Doe', `status` = 'new status' WHERE (`id` = 7) LIMIT 1")
         self.assertEqual(self.qb.get_params(), ('John Doe', 'new status', 7))
+    
+    def tearDown(self):
+        pass
 
 
 if __name__ == "__main__":
diff --git a/tests/qb_views_unittest.py b/tests/qb_views_unittest.py
index 7bcb1ba..3b0491e 100644
--- a/tests/qb_views_unittest.py
+++ b/tests/qb_views_unittest.py
@@ -8,31 +8,65 @@
 class QBViewsTestCase(unittest.TestCase):
     def setUp(self):
         self.qb = QueryBuilder(DataBase(), ":memory:")
+        self.maxDiff = None
 
-    def test_sql_create_view_exists(self):
-        sql = self.qb.select('users').is_null('email').create_view('users_no_email').get_sql()
-        self.assertEqual(sql, "CREATE VIEW IF NOT EXISTS `users_no_email` AS SELECT * FROM `users` WHERE (`email` IS NULL)")
+    def test_create_view_empty_view_name(self):
+        result = self.qb.create_view('')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty view_name in create_view method")
+
+    def test_create_view_no_select(self):
+        result = self.qb.delete('comments').where([['user_id', 10]]).create_view('users_no_email')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "No select found in create_view method")
+
+    def test_create_view_exists(self):
+        result = self.qb.select('users').is_null('email').create_view('users_no_email')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "CREATE VIEW IF NOT EXISTS `users_no_email` AS SELECT * FROM `users` WHERE (`email` IS NULL)")
         self.assertEqual(self.qb.get_params(), ())
 
-    def test_sql_create_view_no_exists(self):
-        sql = self.qb.select('users').is_null('email').create_view('users_no_email', False).get_sql()
-        self.assertEqual(sql, "CREATE VIEW `users_no_email` AS SELECT * FROM `users` WHERE (`email` IS NULL)")
+    def test_create_view_no_exists(self):
+        result = self.qb.select('users').is_null('email').create_view('users_no_email', False)
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "CREATE VIEW `users_no_email` AS SELECT * FROM `users` WHERE (`email` IS NULL)")
         self.assertEqual(self.qb.get_params(), ())
 
-    def test_sql_create_view(self):
-        sql = self.qb.select('users').where([['email', 'is null'], 'or', ['email', '']])\
-               .create_view('users_no_email').get_sql()
-        self.assertEqual(sql, "CREATE VIEW IF NOT EXISTS `users_no_email` AS SELECT * FROM `users` WHERE (`email` IS NULL) OR (`email` = '')")
+    def test_create_view(self):
+        result = self.qb.select('users').where([['email', 'is null'], 'or', ['email', '']])\
+               .create_view('users_no_email')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "CREATE VIEW IF NOT EXISTS `users_no_email` AS SELECT * FROM `users` WHERE (`email` IS NULL) OR (`email` = '')")
         self.assertEqual(self.qb.get_params(), ('', ))
-        # self.qb.go()
 
-    def test_sql_drop_view_no_exists(self):
-        sql = self.qb.drop_view('users_no_email', False).get_sql()
-        self.assertEqual(sql, "DROP VIEW `users_no_email`")
+    def test_drop_view_no_exists(self):
+        result = self.qb.drop_view('users_no_email', False)
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "DROP VIEW `users_no_email`")
+        self.assertEqual(self.qb.get_params(), ())
+
+    def test_drop_view_exists(self):
+        result = self.qb.drop_view('users_no_email')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "DROP VIEW IF EXISTS `users_no_email`")
+        self.assertEqual(self.qb.get_params(), ())
 
-    def test_sql_drop_view_exists(self):
-        sql = self.qb.drop_view('users_no_email').get_sql()
-        self.assertEqual(sql, "DROP VIEW IF EXISTS `users_no_email`")
+    def tearDown(self):
+        pass
 
 
 if __name__ == "__main__":
diff --git a/tests/tb_unittest.py b/tests/tb_unittest.py
index 6fcd298..06583cc 100644
--- a/tests/tb_unittest.py
+++ b/tests/tb_unittest.py
@@ -3,24 +3,53 @@
 
 # test run
 # python .\tb_unittest.py -v
-# python -m unittest .\tb_unittest.py
 
 
 class TBTestCase(unittest.TestCase):
     def setUp(self):
         self.qb = QueryBuilder(DataBase(), ":memory:")
+        self.maxDiff = None
 
-    def test_sql_drop_table_no_exists(self):
-        sql = self.qb.drop('temporary', False).get_sql()
-        self.assertEqual(sql, "DROP TABLE `temporary`")
+    def test_drop_table_empty_name(self):
+        result = self.qb.drop('')
 
-    def test_sql_drop_table_exists(self):
-        sql = self.qb.drop('temporary').get_sql()
-        self.assertEqual(sql, "DROP TABLE IF EXISTS `temporary`")
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table in drop method")
 
-    def test_sql_truncate_table(self):
-        sql = self.qb.truncate('users').get_sql()
-        self.assertEqual(sql, "TRUNCATE TABLE `users`")
+    def test_drop_table_no_exists(self):
+        result = self.qb.drop('temporary', False)
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "DROP TABLE `temporary`")
+        self.assertEqual(result.get_params(), ())
+
+    def test_drop_table_exists(self):
+        result = self.qb.drop('temporary')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "DROP TABLE IF EXISTS `temporary`")
+        self.assertEqual(result.get_params(), ())
+
+    def test_truncate_table_empty_name(self):
+        result = self.qb.truncate('')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), True)
+        self.assertEqual(result.get_error_message(), "Empty table in truncate method")
+
+    def test_truncate_table(self):
+        result = self.qb.truncate('users')
+
+        self.assertEqual(result, self.qb)
+        self.assertEqual(result.has_error(), False)
+        self.assertEqual(result.get_sql(), "TRUNCATE TABLE `users`")
+        self.assertEqual(result.get_params(), ())
+
+    def tearDown(self):
+        pass
 
 
 if __name__ == "__main__":