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

masoniteorm/connections/PostgresConnection.py

@@ -0,0 +1,225 @@
+from ..exceptions import DriverNotFound, QueryException
+from ..query.grammars import PostgresGrammar
+from ..query.processors import PostgresPostProcessor
+from ..schema.platforms import PostgresPlatform
+from .BaseConnection import BaseConnection
+
+CONNECTION_POOL = []
+
+
+class PostgresConnection(BaseConnection):
+    """Postgres Connection class."""
+
+    name = "postgres"
+
+    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.connection_pool_size = full_details.get(
+            "connection_pooling_max_size", 100
+        )
+        self.options = options or {}
+        self._cursor = None
+        self.transaction_level = 0
+        self.open = 0
+        self.schema = None
+        if name:
+            self.name = name
+
+    def make_connection(self):
+        """This sets the connection on the connection class"""
+        if self.has_global_connection():
+            return self.get_global_connection()
+
+        self._connection = self.create_connection()
+
+        self._connection.autocommit = True
+
+        self.enable_disable_foreign_keys()
+
+        self.open = 1
+
+        return self
+
+    def create_connection(self):
+        try:
+            import psycopg2
+        except ModuleNotFoundError:
+            raise DriverNotFound(
+                "You must have the 'psycopg2' package installed to make a connection to Postgres. Please install it using 'pip install psycopg2-binary'"
+            )
+
+        # Initialize the connection pool if the option is set
+        initialize_size = self.full_details.get("connection_pooling_min_size")
+        if (
+            self.full_details.get("connection_pooling_enabled")
+            and initialize_size
+            and len(CONNECTION_POOL) < initialize_size
+        ):
+            for _ in range(initialize_size - len(CONNECTION_POOL)):
+                connection = psycopg2.connect(
+                    database=self.database,
+                    user=self.user,
+                    password=self.password,
+                    host=self.host,
+                    port=self.port,
+                    sslmode=self.options.get("sslmode"),
+                    sslcert=self.options.get("sslcert"),
+                    sslkey=self.options.get("sslkey"),
+                    sslrootcert=self.options.get("sslrootcert"),
+                    options=(
+                        f"-c search_path={self.schema or self.full_details.get('schema')}"
+                        if self.schema or self.full_details.get("schema")
+                        else ""
+                    ),
+                )
+                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 = psycopg2.connect(
+                database=self.database,
+                user=self.user,
+                password=self.password,
+                host=self.host,
+                port=self.port,
+                sslmode=self.options.get("sslmode"),
+                sslcert=self.options.get("sslcert"),
+                sslkey=self.options.get("sslkey"),
+                sslrootcert=self.options.get("sslrootcert"),
+                options=(
+                    f"-c search_path={self.schema or self.full_details.get('schema')}"
+                    if self.schema or self.full_details.get("schema")
+                    else ""
+                ),
+            )
+
+        return connection
+
+    def get_database_name(self):
+        return self.database
+
+    @classmethod
+    def get_default_query_grammar(cls):
+        return PostgresGrammar
+
+    @classmethod
+    def get_default_platform(cls):
+        return PostgresPlatform
+
+    @classmethod
+    def get_default_post_processor(cls):
+        return PostgresPostProcessor
+
+    def reconnect(self):
+        pass
+
+    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)
+        else:
+            self._connection.close()
+
+        self._connection = None
+
+    def commit(self):
+        """Transaction"""
+        if self.get_transaction_level() == 1:
+            self._connection.commit()
+            self._connection.autocommit = True
+
+        self.transaction_level -= 1
+
+    def begin(self):
+        """Postgres 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 set_cursor(self):
+        from psycopg2.extras import RealDictCursor
+
+        self._cursor = self._connection.cursor(cursor_factory=RealDictCursor)
+        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._connection or self._connection.closed:
+                self.make_connection()
+
+            self.set_cursor()
+
+            with self._cursor as cursor:
+                if isinstance(query, list) and not self._dry:
+                    for q in query:
+                        self.statement(q, ())
+                    return
+
+                query = query.replace("?", "%s")
+                self.statement(query, bindings)
+                if results == 1:
+                    return dict(cursor.fetchone() or {})
+                else:
+                    if "SELECT" in cursor.statusmessage:
+                        return cursor.fetchall()
+                    return {}
+        except Exception as e:
+            raise QueryException(str(e)) from e
+        finally:
+            if self.get_transaction_level() <= 0:
+                self.open = 0
+                self.close_connection()
+                # self._connection.close()

masoniteorm/connections/SQLiteConnection.py

@@ -0,0 +1,179 @@
+import re
+
+from ..exceptions import DriverNotFound, QueryException
+from ..query.grammars import SQLiteGrammar
+from ..query.processors import SQLitePostProcessor
+from ..schema.platforms import SQLitePlatform
+from .BaseConnection import BaseConnection
+
+
+def regexp(expr, item):
+    reg = re.compile(expr)
+    return reg.search(item) is not None
+
+
+class SQLiteConnection(BaseConnection):
+    """SQLite Connection class."""
+
+    name = "sqlite"
+
+    _connection = None
+
+    def __init__(
+        self,
+        host=None,
+        database=None,
+        user=None,
+        port=None,
+        password=None,
+        prefix=None,
+        full_details=None,
+        options=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 sqlite3
+        except ModuleNotFoundError:
+            raise DriverNotFound(
+                "You must have the 'sqlite3' package installed to make a connection to SQLite."
+            )
+
+        if self.has_global_connection():
+            return self.get_global_connection()
+
+        self._connection = sqlite3.connect(self.database, isolation_level=None)
+        self._connection.create_function("REGEXP", 2, regexp)
+
+        self._connection.row_factory = sqlite3.Row
+
+        self.enable_disable_foreign_keys()
+
+        self.open = 1
+
+        return self
+
+    @classmethod
+    def get_default_query_grammar(cls):
+        return SQLiteGrammar
+
+    @classmethod
+    def get_default_platform(cls):
+        return SQLitePlatform
+
+    @classmethod
+    def get_default_post_processor(cls):
+        return SQLitePostProcessor
+
+    def get_database_name(self):
+        return self.database
+
+    def reconnect(self):
+        pass
+
+    def commit(self):
+        """Transaction"""
+
+        if self.get_transaction_level() == 1:
+            self.transaction_level -= 1
+            self._connection.commit()
+            self._connection.isolation_level = None
+            self._connection.close()
+            self.open = 0
+
+        self.transaction_level -= 1
+        return self
+
+    def begin(self):
+        """Sqlite Transaction"""
+        self._connection.isolation_level = "DEFERRED"
+        self.transaction_level += 1
+        return self
+
+    def rollback(self):
+        """Transaction"""
+        if self.get_transaction_level() == 1:
+            self.transaction_level -= 1
+            self._connection.rollback()
+            self._connection.close()
+            self.open = 0
+
+        self.transaction_level -= 1
+        return self
+
+    def get_cursor(self):
+        return self._cursor
+
+    def get_transaction_level(self):
+        return self.transaction_level
+
+    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 not self.open:
+            self.make_connection()
+
+        try:
+            self._cursor = self._connection.cursor()
+
+            if isinstance(query, list):
+                for query in query:
+                    self.statement(query)
+            else:
+                self.statement(query, bindings)
+                if results == 1:
+                    result = [dict(row) for row in self._cursor.fetchall()]
+                    if result:
+                        return result[0]
+                else:
+                    return [dict(row) for row in self._cursor.fetchall()]
+        except Exception as e:
+            raise QueryException(str(e)) from e
+        finally:
+            if self.get_transaction_level() <= 0:
+                self._connection.close()
+                self.open = 0
+
+    def format_cursor_results(self, cursor_result):
+        return [dict(row) for row in cursor_result]
+
+    def select_many(self, query, bindings, amount):
+        self._cursor = self._connection.cursor()
+        self.statement(query)
+        if not self.open:
+            self.make_connection()
+
+        result = self.format_cursor_results(self._cursor.fetchmany(amount))
+        while result:
+            yield result
+
+            result = self.format_cursor_results(self._cursor.fetchmany(amount))

masoniteorm/connections/__init__.py

@@ -0,0 +1,6 @@
+from .ConnectionFactory import ConnectionFactory
+from .ConnectionResolver import ConnectionResolver
+from .MSSQLConnection import MSSQLConnection
+from .MySQLConnection import MySQLConnection
+from .PostgresConnection import PostgresConnection
+from .SQLiteConnection import SQLiteConnection

masoniteorm/exceptions.py

@@ -0,0 +1,38 @@
+class DriverNotFound(Exception):
+    pass
+
+
+class ModelNotFound(Exception):
+    pass
+
+
+class HTTP404(Exception):
+    pass
+
+
+class ConnectionNotRegistered(Exception):
+    pass
+
+
+class QueryException(Exception):
+    pass
+
+
+class MigrationNotFound(Exception):
+    pass
+
+
+class ConfigurationNotFound(Exception):
+    pass
+
+
+class InvalidUrlConfiguration(Exception):
+    pass
+
+
+class MultipleRecordsFound(Exception):
+    pass
+
+
+class InvalidArgument(Exception):
+    pass

masoniteorm/expressions/__init__.py

@@ -0,0 +1 @@
+from .expressions import JoinClause, Raw