Database and Cursor classes integration for database connection and queries execution (Unstable): 0.2

MarcoA-Pozol · MarcoA-Pozol · commit fb4aaa348b7d · 2025-03-22T15:54:37.000-06:00
diff --git a/projects/DatabaseConnectionWithOOP/classes.py b/projects/DatabaseConnectionWithOOP/classes.py
@@ -2,7 +2,7 @@
 import sqlite3
 
 # Abstract Classes 
-class AbstractDatabase():
+class AbstractDatabase(ABC):
     @abstractmethod
     def connect(self) -> None:
         pass
@@ -12,13 +12,15 @@ def close(self) -> None:
         pass
 
 # Interfaces
-class I_CustomSelectQuery:
+class I_CommonSelectQueries(ABC):
+    @abstractmethod
     def execute_simple_select_query(self, table_name:str, fields:list[str]) -> list:
         pass
 
-
-# List of Inerfaces
-INTERFACES:list = [I_CustomSelectQuery]
+class I_CommonTableQueries(ABC):
+    @abstractmethod
+    def create_table(self, table_name:str, fields:list[str]) -> None:
+        pass
 
 
 # Classes
@@ -33,25 +35,19 @@ def __init__(self, database_name:str) -> None:
         self.__database_name = database_name
         self.__conn = sqlite3.connect(f'{self.__database_name}.db')
 
-        @property
-        def database_name(self) -> str:
-            return self.__database_name
-        
-        @property
-        def conn(self) -> object | None:
-            return self.__conn
-        
-        def connect(self):
-            """
-                Connects to a SQLite3 database.
-            """
-            self.conn.connect()
-
-        def close(self):
-            """
-                Closes database connection.
-            """ 
-            self.conn.close()
+    @property
+    def database_name(self) -> str:
+        return self.__database_name
+    
+    @property
+    def conn(self) -> object | None:
+        return self.__conn
+
+    def close(self):
+        """
+            Closes database connection.
+        """ 
+        self.conn.close()
 
 class Cursor():
     def __init__(self, database_object:Database) -> None:
@@ -64,26 +60,95 @@ def __init__(self, database_object:Database) -> None:
         self.database = database_object
         self.__cursor = self.database.__conn.cursor()
 
-        @property
-        def cursor(self) -> object:
-            return self.__cursor
+    @property
+    def cursor(self) -> object:
+        return self.__cursor
+    
+    def execute_query(self, query:str) -> list | None:
+        """
+            The Cursor object executes an SQL query that the user will pass as str, for example 'SELECT * FROM Users WHERE age > 21'.
+
+            Attributes:
+                - query (str): The query that will be executed, it can be of any type (SELECT, UPDATE, DELETE, INSERT, etc.).
+        """
+        try:
+            result = self.cursor.execute(query)
+            print('Query was executed.')
+            return result.fetchall() if result else []
+        except Exception as e:
+            print('Impossible to execute the query:', e)
+            return None 
+    
+# Custom cursor for most common queries execution.
+class CustomCursor(Cursor, I_CommonTableQueries, I_CommonSelectQueries):
+    def __init__(self, database_object:Database):
+        super().__init__(database_object)
+
+    def execute_query(self, query:str):
+        """
+            Executes a simple query of any type wether SELECT, INSERT, CREATE TABLE, DELETE, etc.
+            This method leverages its class's parent class method with the same name, behavior and attributes.
+
+            Attributes:
+                - query (str): The query that will be executed.
+        """
+        return super().execute_query(query)
+    
+    def execute_simple_select_query(self, table_name:str, fields:list[str]) -> list:
+        """
+            Executes a simple query of SELECT type with the fields to show provided as parameters and the name of the table.
+        
+            Attributes:
+                - table_name (str): Name of the table from where data is going to be obtained.
+                - fields (list[str]): List of fields to fetch from the database's table.
+
+            Return:
+                - data (list): List of rows obtained from the SELECT query in str format.
+        """
+        query = f"""SELECT {', '.join(fields)} FROM {table_name};"""
+        data = self.execute_query(query)
+        return data
+    
+    def create_table(self, table_name:str, fields:list[str]) -> None:
+        """
+            Creates a table on the database based on the provided fields and table name.
+
+            Attributes:
+                - table_name (): Name of the table that is going to be created.
+                -fields (list): List of the table fields in string format. 
+            
+            Return:
+                - None
+        """
         
-        def execute_query(self, query:str) -> list | None:
-            """
-                The Cursor object executes an SQL query that the user will pass as str, for example 'SELECT * FROM Users WHERE age > 21'.
+        # Format the fields from fields list in a single string
+        formated_fields = ', '.join(fields)
+        
+        query = f"""CREATE TABLE IF NOT EXISTS {table_name} ({formated_fields})"""
+        self.execute_query(query)
+
+    def insert_rows(self, table_name:str, fields:list[str], values:list[list[str]]) -> bool:
+        """
+            Executes a classic INSERT query receiving the name of the fields matching the values to insert and the name of the table
+            This method iterates over every row on the provided list of values to make an insertion on the database in the table..
+
+            Attributes:
+                - table_name (str): Name of the table where the data will be inserted as a new row.
+                - fields (list[str]): List of fields to determine which type of data should be inserted.
+                - values (list[list[str]]): List of rows to insert, every row is a list of every value in the desired format.  
 
-                Attributes:
-                    - query (str): The query that will be executed, it can be of any type (SELECT, UPDATE, DELETE, INSERT, etc.).
-            """
+            Return:
+                - succes (str): True if rows were inserted. False if it was not possible to insert rows.
+        """
+        formated_fields = ', '.join(fields)
+        rows_list = values
+        for row in rows_list:
             try:
-                result = self.cusor.execute(query)
+                formated_values = ', '.join(f"'{value}'" for value in row)
+                query = f"""INSERT INTO {table_name} ({formated_fields}) VALUES({formated_values});"""
+                self.execute_query(query)
             except Exception as e:
-                print('Impossible to fetch result data:', e)
-            finally:
-                self.cursor.execute(query)
-
-            if result:
-                print('Database query sucessfully executed!')
-                return result
-            print('Not result obtained from the database query execution, but it worked sucessfully!')
-            return None 
+                print(f'Error during inserting data into database on table {table_name}:', e)
+                succes = False
+        succes = True
+        return succes
diff --git a/projects/DatabaseConnectionWithOOP/main.py b/projects/DatabaseConnectionWithOOP/main.py
@@ -1,42 +1,25 @@
-from . classes import Cursor, Database
-from . classes import INTERFACES
-
-# Custom cursor for most common queries execution.
-class CustomCursor(Cursor, INTERFACES.I_CustomSelectQuery):
-    def __init__(self, database_object:Database):
-        super().__init__(database_object)
-
-    def execute_query(self, query:str):
-        """
-            Executes a simple query of any type wether SELECT, INSERT, CREATE TABLE, DELETE, etc.
-            This method leverages its class's parent class method with the same name, behavior and attributes.
-
-            Attributes:
-                query (str): The query that will be executed.
-        """
-        super().execute_query(query)
-    
-    def execute_simple_select_query(self, table_name:str, fields:list[str]) -> list:
-        table_name = table_name
-        fields = fields
-        query = f"""SELECT {[field for field in fields]} FROM {table_name};"""
-        data = self.execute_query(query)
-        return data
-    
-    def create_table(self, table_name:str, fields:list[str]) -> None:
-        self.execute_query("")
-        pass 
-        """Uncompleted yet"""
-
+from classes import Database, CustomCursor
 
 
 """ Now with a simple cursor object we can execute the most common queries like the typical 'SELECT', or create a table with ease reducing the SQL statement we have to provide to just parameters. """
 my_database = Database('MyDatabase')
 my_cursor = CustomCursor(my_database)
 
 # Creating users table
-my_cursor.create_table('users')
+my_cursor.create_table('users', ['id INTEGER PRIMARY KEY AUTOINCREMENT', 'username TEXT UNIQUE NOT NULL', 'email TEXT UNIQUE NOT NULL', 'password TEXT NOT NULL', 'age INTEGER'])
+
+# Inserting data in users table
+users_to_insert = [
+    ['Joaquin', 'joaquin@gmail.com', '123password', 22], 
+    ['Aline', 'aline@gmail.com', '123password', 21], 
+    ['Henry', 'henry@gmail.com', '123password', 35], 
+    ['James', 'james@gmail.com', '123password', 32], 
+    ['Nicole', 'nicole@gmail.com', '123password', 28],
+    ['Maria', 'maria@gmail.com', '123password', 38] 
+]
+users_fields = ['username', 'email', 'password', 'age']
+my_cursor.insert_rows('users', users_fields, users_to_insert)
 
 # Fetching data from database in users table
-result = my_cursor.execute_simple_select_query('users', ['username', 'email', 'password', 'age'])
+result = my_cursor.execute_simple_select_query('users', users_fields)
 print(result)
