masonite-framework-orm 3.0.1__py3-none-any.whl

masoniteorm/connections/ConnectionResolver.py

@@ -0,0 +1,132 @@
+from contextlib import contextmanager
+
+
+class ConnectionResolver:
+    _connections = {}
+    _morph_map = {}
+
+    def __init__(self, config_path=None, connection_details=None):
+        from ..connections import (
+            ConnectionFactory,
+            MSSQLConnection,
+            MySQLConnection,
+            PostgresConnection,
+            SQLiteConnection,
+        )
+
+        self.config_path = config_path
+        self._connection_details = connection_details or {}
+
+        self.connection_factory = ConnectionFactory(
+            config_path=config_path, resolver=self
+        )
+        self.register(SQLiteConnection)
+        self.register(PostgresConnection)
+        self.register(MySQLConnection)
+        self.register(MSSQLConnection)
+
+    def morph_map(self, map):
+        self._morph_map = map
+        return self
+
+    def set_connection_details(self, connection_details):
+        self._connection_details = connection_details
+        return self
+
+    def get_connection_details(self):
+        return self._connection_details
+
+    def set_connection_option(self, connection: str, options: dict):
+        self._connection_details.get(connection).update(options)
+        return self
+
+    def get_global_connections(self):
+        return self._connections
+
+    def remove_global_connection(self, name=None):
+        self._connections.pop(name)
+
+    def register(self, connection):
+        self.connection_factory.register(connection.name, connection)
+
+    def begin_transaction(self, name=None):
+        if name is None:
+            name = self.get_connection_details()["default"]
+
+        driver = self.get_connection_details()[name].get("driver")
+
+        connection = (
+            self.connection_factory.make(driver)(
+                **self.get_connection_information(name)
+            )
+            .make_connection()
+            .begin()
+        )
+        self.__class__._connections.update({name: connection})
+
+        return connection
+
+    def commit(self, name=None):
+        if name is None:
+            name = self.get_connection_details()["default"]
+        connection = self.get_global_connections()[name]
+        self.remove_global_connection(name)
+        connection.commit()
+
+    def rollback(self, name=None):
+        if name is None:
+            name = self.get_connection_details()["default"]
+
+        connection = self.get_global_connections()[name]
+        self.remove_global_connection(name)
+        connection.rollback()
+
+    @contextmanager
+    def transaction(self, name=None):
+        self.begin_transaction(name)
+        try:
+            yield self
+        except Exception:
+            self.rollback(name)
+            raise
+
+        try:
+            self.commit(name)
+        except Exception:
+            self.rollback(name)
+            raise
+
+    def get_connection_information(self, name):
+        details = self.get_connection_details()
+        return {
+            "host": details.get(name, {}).get("host"),
+            "database": details.get(name, {}).get("database"),
+            "user": details.get(name, {}).get("user"),
+            "port": details.get(name, {}).get("port"),
+            "password": details.get(name, {}).get("password"),
+            "prefix": details.get(name, {}).get("prefix"),
+            "options": details.get(name, {}).get("options", {}),
+            "full_details": details.get(name, {}),
+        }
+
+    def get_schema_builder(self, connection="default", schema=None):
+        from ..schema import Schema
+
+        return Schema(
+            connection=connection,
+            connection_details=self.get_connection_details(),
+            schema=schema,
+        )
+
+    def get_query_builder(self, connection="default"):
+        from ..query import QueryBuilder
+
+        return QueryBuilder(
+            connection=connection,
+            connection_details=self.get_connection_details(),
+        )
+
+    def statement(self, query, bindings=(), connection="default"):
+        return (
+            self.get_query_builder().on(connection).statement(query, bindings)
+        )

masoniteorm/connections/MSSQLConnection.py

@@ -0,0 +1,176 @@
+from ..exceptions import DriverNotFound, QueryException
+from ..query.grammars import MSSQLGrammar
+from ..query.processors import MSSQLPostProcessor
+from ..schema.platforms import MSSQLPlatform
+from .BaseConnection import BaseConnection
+
+CONNECTION_POOL = []
+
+
+class MSSQLConnection(BaseConnection):
+    """MSSQL Connection class."""
+
+    name = "mssql"
+
+    def __init__(
+        self,
+        host=None,
+        database=None,
+        user=None,
+        port=None,
+        password=None,
+        prefix=None,
+        options=None,
+        full_details=None,
+        name=None,
+    ):
+        self.host = host
+        if port:
+            self.port = int(port)
+        else:
+            self.port = port
+        self.database = database
+        self.user = user
+        self.password = password
+        self.prefix = prefix
+        self.full_details = full_details or {}
+        self.options = options or {}
+        self._cursor = None
+        self.transaction_level = 0
+        self.open = 0
+        if name:
+            self.name = name
+
+    def make_connection(self):
+        """This sets the connection on the connection class"""
+        try:
+            import pyodbc
+        except ModuleNotFoundError:
+            raise DriverNotFound(
+                "You must have the 'pyodbc' package installed to make a connection to Microsoft SQL Server. Please install it using 'pip install pyodbc'"
+            )
+
+        if self.has_global_connection():
+            return self.get_global_connection()
+
+        driver = self.options.get("driver", "ODBC Driver 17 for SQL Server")
+        integrated_security = self.options.get("integrated_security")
+        connection_timeout = str(self.options.get("connection_timeout", "30"))
+        authentication = self.options.get("authentication")
+        instance = self.options.get("instance", "")
+        trusted_connection = self.options.get("trusted_connection")
+
+        if instance:
+            instance = "\\" + instance
+
+        self._connection = pyodbc.connect(
+            f"DRIVER={driver};SERVER={self.host}{instance if instance else ''},{self.port};Connection Timeout={connection_timeout};DATABASE={self.database}{f';Integrated Security={integrated_security}' if integrated_security else ''};UID={self.user};PWD={self.password}{f';Trusted_Connection={trusted_connection}' if trusted_connection else ''}{f';Authentication={authentication}' if authentication else ''}",
+            autocommit=True,
+        )
+
+        self.enable_disable_foreign_keys()
+
+        self.open = 1
+        return self
+
+    def get_database_name(self):
+        return self.database
+
+    @classmethod
+    def get_default_query_grammar(cls):
+        return MSSQLGrammar
+
+    @classmethod
+    def get_default_platform(cls):
+        return MSSQLPlatform
+
+    @classmethod
+    def get_default_post_processor(cls):
+        return MSSQLPostProcessor
+
+    def reconnect(self):
+        pass
+
+    def commit(self):
+        """Transaction"""
+        if self.get_transaction_level() == 1:
+            self._connection.commit()
+            self._connection.autocommit = True
+
+        self.transaction_level -= 1
+
+    def begin(self):
+        """MSSQL Transaction"""
+        self._connection.autocommit = False
+        self.transaction_level += 1
+        return self
+
+    def rollback(self):
+        """Transaction"""
+        if self.get_transaction_level() == 1:
+            self._connection.rollback()
+            self._connection.autocommit = True
+
+        self.transaction_level -= 1
+
+    def get_transaction_level(self):
+        """Transaction"""
+        return self.transaction_level
+
+    def get_cursor(self):
+        return self._cursor
+
+    def query(self, query, bindings=(), results="*"):
+        """Make the actual query that will reach the database and come back with a result.
+
+        Arguments:
+            query {string} -- A string query. This could be a qmarked string or a regular query.
+            bindings {tuple} -- A tuple of bindings
+
+        Keyword Arguments:
+            results {str|1} -- If the results is equal to an asterisks it will call 'fetchAll'
+                    else it will return 'fetchOne' and return a single record. (default: {"*"})
+
+        Returns:
+            dict|None -- Returns a dictionary of results or None
+        """
+
+        try:
+            if not self.open:
+                self.make_connection()
+            self._cursor = self._connection.cursor()
+            with self._cursor as cursor:
+                if isinstance(query, list) and not self._dry:
+                    for q in query:
+                        self.statement(q, ())
+                    return
+                self.statement(query, bindings)
+                if results == 1:
+                    if not cursor.description:
+                        return {}
+                    columnNames = [column[0] for column in cursor.description]
+                    result = cursor.fetchone()
+                    return (
+                        dict(zip(columnNames, result))
+                        if result is not None
+                        else {}
+                    )
+                else:
+                    if not cursor.description:
+                        return {}
+                    return self.format_cursor_results(cursor.fetchall())
+
+                return {}
+        except Exception as e:
+            raise QueryException(str(e)) from e
+        finally:
+            if self.get_transaction_level() <= 0:
+                self._connection.close()
+
+    def format_cursor_results(self, cursor_result):
+        columnNames = [column[0] for column in self.get_cursor().description]
+        results = []
+        for record in cursor_result:
+            results.append(dict(zip(columnNames, record)))
+
+        return results

masoniteorm/connections/MySQLConnection.py

@@ -0,0 +1,232 @@
+from ..exceptions import DriverNotFound, QueryException
+from ..query.grammars import MySQLGrammar
+from ..query.processors import MySQLPostProcessor
+from ..schema.platforms import MySQLPlatform
+from .BaseConnection import BaseConnection
+
+CONNECTION_POOL = []
+
+
+class MySQLConnection(BaseConnection):
+    """MYSQL Connection class."""
+
+    name = "mysql"
+    _dry = False
+
+    def __init__(
+        self,
+        host=None,
+        database=None,
+        user=None,
+        port=None,
+        password=None,
+        prefix=None,
+        options=None,
+        full_details=None,
+        name=None,
+    ):
+        self.host = host
+        self.port = port
+        if str(port).isdigit():
+            self.port = int(self.port)
+        self.database = database
+
+        self.user = user
+        self.password = password
+        self.prefix = prefix
+        self.full_details = full_details or {}
+        self.connection_pool_size = full_details.get(
+            "connection_pooling_max_size", 100
+        )
+        self.options = options or {}
+        self._cursor = None
+        self.open = 0
+        self.transaction_level = 0
+        if name:
+            self.name = name
+
+    def make_connection(self):
+        """This sets the connection on the connection class"""
+
+        if self._dry:
+            return
+
+        if self.has_global_connection():
+            return self.get_global_connection()
+
+        # Check if there is an available connection in the pool
+        self._connection = self.create_connection()
+        self.enable_disable_foreign_keys()
+
+        return self
+
+    def close_connection(self):
+        if (
+            self.full_details.get("connection_pooling_enabled")
+            and len(CONNECTION_POOL) < self.connection_pool_size
+        ):
+            CONNECTION_POOL.append(self._connection)
+        self.open = 0
+        self._connection = None
+
+    def create_connection(self, autocommit=True):
+
+        try:
+            import pymysql
+        except ModuleNotFoundError:
+            raise DriverNotFound(
+                "You must have the 'pymysql' package "
+                "installed to make a connection to MySQL. "
+                "Please install it using 'pip install pymysql'"
+            )
+        import pendulum
+        import pymysql.converters
+
+        pymysql.converters.conversions[pendulum.DateTime] = (
+            pymysql.converters.escape_datetime
+        )
+
+        # Initialize the connection pool if the option is set
+        initialize_size = self.full_details.get("connection_pooling_min_size")
+        if initialize_size and len(CONNECTION_POOL) < initialize_size:
+            for _ in range(initialize_size - len(CONNECTION_POOL)):
+                connection = pymysql.connect(
+                    cursorclass=pymysql.cursors.DictCursor,
+                    autocommit=autocommit,
+                    host=self.host,
+                    user=self.user,
+                    password=self.password,
+                    port=self.port,
+                    database=self.database,
+                    **self.options,
+                )
+                CONNECTION_POOL.append(connection)
+
+        if (
+            self.full_details.get("connection_pooling_enabled")
+            and CONNECTION_POOL
+            and len(CONNECTION_POOL) > 0
+        ):
+            connection = CONNECTION_POOL.pop()
+        else:
+            connection = pymysql.connect(
+                cursorclass=pymysql.cursors.DictCursor,
+                autocommit=autocommit,
+                host=self.host,
+                user=self.user,
+                password=self.password,
+                port=self.port,
+                database=self.database,
+                **self.options,
+            )
+
+        connection.close = self.close_connection
+
+        self.open = 1
+
+        return connection
+
+    def reconnect(self):
+        self._connection.connect()
+        return self
+
+    @classmethod
+    def get_default_query_grammar(cls):
+        return MySQLGrammar
+
+    @classmethod
+    def get_default_platform(cls):
+        return MySQLPlatform
+
+    @classmethod
+    def get_default_post_processor(cls):
+        return MySQLPostProcessor
+
+    def get_database_name(self):
+        return self.database
+
+    def commit(self):
+        """Transaction"""
+        self._connection.commit()
+        self.transaction_level -= 1
+        if self.get_transaction_level() <= 0:
+            self.open = 0
+            self._connection.close()
+
+    def dry(self):
+        """Transaction"""
+        self._dry = True
+        return self
+
+    def begin(self):
+        """Mysql Transaction"""
+        self._connection.begin()
+        self.transaction_level += 1
+        return self
+
+    def rollback(self):
+        """Transaction"""
+        self._connection.rollback()
+        self.transaction_level -= 1
+        if self.get_transaction_level() <= 0:
+            self.open = 0
+            self._connection.close()
+
+    def get_transaction_level(self):
+        """Transaction"""
+        return self.transaction_level
+
+    def get_cursor(self):
+        return self._cursor
+
+    def query(self, query, bindings=(), results="*"):
+        """Make the actual query that
+        will reach the database and come back with a result.
+
+        Arguments:
+            query {string} -- A string query.
+            This could be a qmarked string or a regular query.
+            bindings {tuple} -- A tuple of bindings
+
+        Keyword Arguments:
+            results {str|1} -- If the results is equal to an
+            asterisks it will call 'fetchAll'
+            else it will return 'fetchOne' and
+            return a single record. (default: {"*"})
+
+        Returns:
+            dict|None -- Returns a dictionary of results or None
+        """
+
+        if self._dry:
+            return {}
+
+        if not self.open:
+            if self._connection is None:
+                self._connection = self.create_connection()
+
+            self._connection.connect()
+
+        self._cursor = self._connection.cursor()
+
+        try:
+            with self._cursor as cursor:
+                if isinstance(query, list):
+                    for q in query:
+                        q = q.replace("?", "%s")
+                        self.statement(q, ())
+                    return
+
+                query = query.replace("?", "%s")
+                self.statement(query, bindings)
+                if results == 1:
+                    return self.format_cursor_results(cursor.fetchone())
+                else:
+                    return self.format_cursor_results(cursor.fetchall())
+        except Exception as e:
+            raise QueryException(str(e)) from e
+        finally:
+            self._cursor.close()
+            if self.get_transaction_level() <= 0:
+                self.open = 0
+                self._connection.close()