move database to factory

Author: Antony Bailey

BaseDBConnector.py

@@ -1,20 +1,13 @@
+from IDBConnector import IDBConnector
 from SQLYExecutionError import SQLYExecutionError
 from SQLYUtils import SQLYUtils
 
-
-class BaseDBConnector:
+class BaseDBConnector(IDBConnector):
     """
     A base class for database connectors that provides methods to execute SQL queries.
 
     Attributes:
         connection: A database connection object.
-
-    Methods:
-        execute_query(query: dict):
-            Translates a query dictionary to SQL and executes it.
-
-        _execute(sql, params):
-            Executes a given SQL statement with parameters and handles the result.
     """
     def __init__(self, connection):
         """
@@ -36,9 +29,9 @@ def execute_query(self, query: dict):
             Any: The result of the executed query.
         """
         sql, params = SQLYUtils.translate_to_sql(query)
-        return self._execute(sql, params)
+        return self.execute(sql, params)
 
-    def _execute(self, sql, params):
+    def execute(self, sql, params):
         """
         Executes a given SQL statement with the provided parameters.
 

DBConnectorFactory.py

@@ -0,0 +1,43 @@
+from SQLYExecutionError import SQLYExecutionError
+
+# Import connectors
+from SQLiteConnector import SQLiteConnector
+from MariaDBConnector import MariaDBConnector
+from PostgresConnector import PostgresConnector
+from OracleConnector import OracleConnector
+from MSSQLConnector import MSSQLConnector
+
+
+class DBConnectorFactory:
+    """
+    Factory class for creating database connectors based on database type.
+
+    This class implements the Factory Pattern to create the appropriate
+    database connector instance based on the database type.
+    """
+
+    @staticmethod
+    def create_connector(db_type, connection):
+        """
+        Creates and returns a database connector instance based on the specified database type.
+
+        Args:
+            db_type (str): The type of the database (e.g., "sqlite", "mariadb", "postgres", "oracle", "mssql").
+            connection: The connection object or parameters required to establish the database connection.
+
+        Returns:
+            An instance of the corresponding database connector class.
+
+        Raises:
+            SQLYExecutionError: If the specified database type is not supported.
+        """
+        connectors = {
+            "sqlite": SQLiteConnector,
+            "mariadb": MariaDBConnector,
+            "postgres": PostgresConnector,
+            "oracle": OracleConnector,
+            "mssql": MSSQLConnector,
+        }
+        if db_type not in connectors:
+            raise SQLYExecutionError("Unsupported database type: " + db_type)
+        return connectors[db_type](connection)

DatabaseConnector.py

@@ -1,73 +1,59 @@
-from MSSQLConnector import MSSQLConnector
-from MariaDBConnector import MariaDBConnector
-from OracleConnector import OracleConnector
-from PostgresConnector import PostgresConnector
+from DBConnectorFactory import DBConnectorFactory
 from SQLYExecutionError import SQLYExecutionError
-from SQLYUtils import SQLYUtils
-from SQLiteConnector import SQLiteConnector
 
 
 class DatabaseConnector:
     """
-    DatabaseConnector is a utility class that provides a method to obtain a specific
-    database connector instance based on the database type.
-
-    Methods:
-        get_connector(db_type: str, connection: Any) -> Any:
-            Returns an instance of the appropriate database connector class based on
-            the provided database type.
-
-            Parameters:
-                db_type (str): The type of the database (e.g., 'sqlite', 'mariadb', 'postgres', 'oracle', 'mssql').
-                connection (Any): The connection object or connection string required to establish a connection to the database.
-
-            Returns:
-                An instance of the corresponding database connector class.
-
-            Raises:
-                SQLYExecutionError: If the provided database type is not supported.
+    DatabaseConnector is a utility class that provides methods to connect to
+    and execute queries against different types of databases.
     """
-    @staticmethod
-    def get_connector(db_type, connection):
+    def __init__(self, db_type, connection):
         """
-        Returns a database connector instance based on the specified database type.
+        Initializes the DatabaseConnector with the database type and connection information.
 
         Args:
             db_type (str): The type of the database (e.g., "sqlite", "mariadb", "postgres", "oracle", "mssql").
             connection: The connection object or parameters required to establish the database connection.
+        """
+        self.db_type = db_type
+        self.connection = connection
+        self.connector = None
 
-        Returns:
-            An instance of the corresponding database connector class.
+    def _ensure_connector(self):
+        """
+        Ensures that a connector instance exists, creating it if necessary.
 
-        Raises:
-            SQLYExecutionError: If the specified database type is not supported.
+        Returns:
+            The database connector instance.
         """
-        connectors = {
-            "sqlite": SQLiteConnector,
-            "mariadb": MariaDBConnector,
-            "postgres": PostgresConnector,
-            "oracle": OracleConnector,
-            "mssql": MSSQLConnector,
-        }
-        if db_type not in connectors:
-            raise SQLYExecutionError("Unsupported database type: " + db_type)
-        return connectors[db_type](connection)
+        if self.connector is None:
+            self.connector = DBConnectorFactory.create_connector(self.db_type, self.connection)
+        return self.connector
 
-    def execute_query(self, query: dict, db_type: str, connection: Any):
+    def execute_query(self, query: dict, db_type=None, connection=None):
         """
         Executes a SQLY query against a specified database.
 
         Args:
             query (dict): The query dictionary"
-            db_type (str): The type of the database (e.g., "sqlite", "mariadb", "postgres", "oracle", "mssql").
-            connection: The connection object or parameters required to establish the database connection.
+            db_type (str, optional): The type of the database. Defaults to the instance's db_type.
+            connection (optional): The connection object or parameters. Defaults to the instance's connection.
 
         Returns:
             The result of the executed query.
 
         Raises:
             SQLYExecutionError: If the query is invalid or an error occurs during execution.
         """
-        db_connector = DatabaseConnector.get_connector(db_type, connection)
-        sql, params = SQLYUtils.translate_to_sql(query)
-        return db_connector.execute(sql, params)
+        # Use provided values or fall back to instance attributes
+        db_type = db_type or self.db_type
+        connection = connection or self.connection
+
+        if db_type != self.db_type or connection != self.connection:
+            # If parameters differ from instance attributes, create a new connector
+            connector = DBConnectorFactory.create_connector(db_type, connection)
+        else:
+            connector = self._ensure_connector()
+
+        # Execute the query using the appropriate connector
+        return connector.execute_query(query)

IDBConnector.py

@@ -0,0 +1,42 @@
+from abc import ABC, abstractmethod
+
+
+class IDBConnector(ABC):
+    """
+    Interface for database connectors.
+
+    This abstract class defines the interface for database connectors, providing
+    a standardized way to interact with different database systems.
+
+    Classes inheriting from IDBConnector must implement the execute method.
+
+    Attributes
+    None
+
+    Methods
+    execute(sql, params)
+    """
+
+    @abstractmethod
+    def execute(self, sql, params):
+        """
+        Execute a SQL query with parameters.
+        This method executes a SQL query with the provided parameters against the database.
+        Parameters
+        ----------
+        sql : str
+            The SQL query to execute.
+        params : tuple or dict
+            The parameters to be used in the SQL query. Can be a tuple for positional
+            parameters or a dictionary for named parameters.
+        Returns
+        -------
+        Any
+            The result of the query execution, which depends on the specific database implementation.
+        Raises
+        ------
+        DatabaseError
+            If the query execution fails.
+        """
+
+        pass

SQLYExecutor.py

@@ -1,6 +1,7 @@
 from SQLYParser import SQLYParser
 from SQLYExecutionError import SQLYExecutionError
 from SQLYUtils import SQLYUtils
+from DatabaseConnector import DatabaseConnector
 
 
 class SQLYExecutor:
@@ -10,6 +11,7 @@ class SQLYExecutor:
     Attributes:
         datasource: The data source against which the queries will be executed.
         db_type: The type of the database (optional).
+        db_connector: The database connector instance.
 
     Methods:
         execute(query: str):
@@ -30,6 +32,7 @@ def __init__(self, datasource, db_type=None):
         """
         self.datasource = datasource
         self.db_type = db_type
+        self.db_connector = DatabaseConnector(db_type, datasource) if db_type else None
 
     def execute(self, query: str):
         """
@@ -66,6 +69,9 @@ def _run_query(self, parsed_query: dict):
             SQLYExecutionError: If there is an error during query execution.
         """
         try:
-            return SQLYUtils.execute_query(parsed_query, self.datasource, self.db_type)
+            if not self.db_connector:
+                raise SQLYExecutionError("Database type not specified for the executor.")
+
+            return self.db_connector.execute_query(parsed_query)
         except Exception as e:
             raise SQLYExecutionError("Query execution error: " + str(e)) from e

SQLYUtils.py

@@ -3,24 +3,14 @@
 
 class SQLYUtils:
     """
-    SQLYUtils is a utility class that provides static methods for validating and executing SQLY queries.
+    SQLYUtils is a utility class that provides static methods for validating and translating SQLY queries.
 
     Methods:
         validate_query(query: dict) -> bool:
             Checks if the provided query dictionary contains the necessary fields for a SQLY query.
-            Args:
-                query (dict): The query dictionary to validate.
-            Returns:
-                bool: True if the query contains the "select" and "from" fields, False otherwise.
 
-        execute_query(query: dict, datasource, db_type):
-            Executes a SQLY query against a specified database.
-            Args:
-                query (dict): The query dictionary to execute.
-                datasource: The data source to connect to.
-                db_type: The type of the database (e.g., MySQL, PostgreSQL).
-            Returns:
-                The result of the executed query.
+        translate_to_sql(query: dict) -> tuple[str, list]:
+            Translates a dictionary query representation into a SQL query and its parameters.
     """
     @staticmethod
     def validate_query(query: dict) -> bool:
@@ -35,22 +25,6 @@ def validate_query(query: dict) -> bool:
         """
         return isinstance(query, dict) and "select" in query and "from" in query
 
-    @staticmethod
-    def execute_query(query: dict, datasource, db_type):
-        """
-        Executes a SQLY query against a database.
-
-        Args:
-            query (dict): The SQLY query to be executed.
-            datasource: The data source to connect to.
-            db_type: The type of the database (e.g., MySQL, PostgreSQL).
-
-        Returns:
-            The result of the executed query.
-        """
-        db_connector = DatabaseConnector.DatabaseConnector(db_type, datasource)
-        return db_connector.execute_query(query, db_type, datasource)
-
     @staticmethod
     def translate_to_sql(query: dict) -> tuple[str, list]:
         """

__init__.py

@@ -1,15 +1,21 @@
-from SQLYParser import SQLYParser
-from SQLYExecutor import SQLYExecutor
-from SQLYError import SQLYError
-from SQLYParseError import SQLYParseError
-from SQLYExecutionError import SQLYExecutionError
-from SQLiteConnector import SQLiteConnector
-from MariaDBConnector import MariaDBConnector
-from PostgresConnector import PostgresConnector
-from OracleConnector import OracleConnector
-from MSSQLConnector import MSSQLConnector
+from .IDBConnector import IDBConnector
+from .SQLYParser import SQLYParser
+from .SQLYExecutor import SQLYExecutor
+from .SQLYError import SQLYError
+from .SQLYParseError import SQLYParseError
+from .SQLYExecutionError import SQLYExecutionError
+from .SQLYUtils import SQLYUtils
+from .BaseDBConnector import BaseDBConnector
+from .DatabaseConnector import DatabaseConnector
+from .DBConnectorFactory import DBConnectorFactory
+from .SQLiteConnector import SQLiteConnector
+from .MariaDBConnector import MariaDBConnector
+from .PostgresConnector import PostgresConnector
+from .OracleConnector import OracleConnector
+from .MSSQLConnector import MSSQLConnector
 
 __all__ = [
     "SQLYParser", "SQLYExecutor", "SQLYError", "SQLYParseError", "SQLYExecutionError",
+    "SQLYUtils", "BaseDBConnector", "IDBConnector", "DatabaseConnector", "DBConnectorFactory",
     "SQLiteConnector", "MariaDBConnector", "PostgresConnector", "OracleConnector", "MSSQLConnector"
 ]