masonite-orm 2.23.1__tar.gz → 2.23.2__tar.gz

{masonite-orm-2.23.1/src/masonite_orm.egg-info → masonite-orm-2.23.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: masonite-orm
-Version: 2.23.1
+Version: 2.23.2
 Summary: The Official Masonite ORM
 Home-page: https://github.com/masoniteframework/orm
 Author: Joe Mancuso

{masonite-orm-2.23.1 → masonite-orm-2.23.2}/setup.py

@@ -8,7 +8,7 @@ setup(
     # Versions should comply with PEP440.  For a discussion on single-sourcing
     # the version across setup.py and the project code, see
     # https://packaging.python.org/en/latest/single_source_version.html
-    version="2.23.1",
+    version="2.23.2",
     package_dir={"": "src"},
     description="The Official Masonite ORM",
     long_description=long_description,

{masonite-orm-2.23.1 → masonite-orm-2.23.2/src/masonite_orm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: masonite-orm
-Version: 2.23.1
+Version: 2.23.2
 Summary: The Official Masonite ORM
 Home-page: https://github.com/masoniteframework/orm
 Author: Joe Mancuso

{masonite-orm-2.23.1 → masonite-orm-2.23.2}/src/masoniteorm/connections/MySQLConnection.py

@@ -31,10 +31,12 @@ class MySQLConnection(BaseConnection):
         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
@@ -48,42 +50,80 @@ class MySQLConnection(BaseConnection):
         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'"
+                "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
 
-        try:
-            import pendulum
-            import pymysql.converters
-
-            pymysql.converters.conversions[
-                pendulum.DateTime
-            ] = pymysql.converters.escape_datetime
-        except ImportError:
-            pass
-
-        if self.has_global_connection():
-            return self.get_global_connection()
-
-        self._connection = pymysql.connect(
-            cursorclass=pymysql.cursors.DictCursor,
-            autocommit=True,
-            host=self.host,
-            user=self.user,
-            password=self.password,
-            port=self.port,
-            db=self.database,
-            **self.options
+        pymysql.converters.conversions[pendulum.DateTime] = (
+            pymysql.converters.escape_datetime
         )
 
-        self.enable_disable_foreign_keys()
+        # 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 self
+        return connection
 
     def reconnect(self):
         self._connection.connect()
@@ -139,15 +179,19 @@ class MySQLConnection(BaseConnection):
         return self._cursor
 
     def query(self, query, bindings=(), results="*"):
-        """Make the actual query that will reach the database and come back with a result.
+        """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.
+            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: {"*"})
+            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
@@ -156,7 +200,10 @@ class MySQLConnection(BaseConnection):
         if self._dry:
             return {}
 
-        if not self._connection.open:
+        if not self.open:
+            if self._connection is None:
+                self._connection = self.create_connection()
+
             self._connection.connect()
 
         self._cursor = self._connection.cursor()

{masonite-orm-2.23.1 → masonite-orm-2.23.2}/src/masoniteorm/connections/PostgresConnection.py

@@ -34,8 +34,10 @@ class PostgresConnection(BaseConnection):
         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
@@ -56,16 +58,7 @@ class PostgresConnection(BaseConnection):
         if self.has_global_connection():
             return self.get_global_connection()
 
-        schema = self.schema or self.full_details.get("schema")
-
-        self._connection = psycopg2.connect(
-            database=self.database,
-            user=self.user,
-            password=self.password,
-            host=self.host,
-            port=self.port,
-            options=f"-c search_path={schema}" if schema else "",
-        )
+        self._connection = self.create_connection()
 
         self._connection.autocommit = True
 
@@ -75,6 +68,61 @@ class PostgresConnection(BaseConnection):
 
         return self
 
+    def create_connection(self):
+        import psycopg2
+
+        # 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
 
@@ -93,6 +141,17 @@ class PostgresConnection(BaseConnection):
     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:
@@ -140,7 +199,7 @@ class PostgresConnection(BaseConnection):
             dict|None -- Returns a dictionary of results or None
         """
         try:
-            if self._connection.closed:
+            if not self._connection or self._connection.closed:
                 self.make_connection()
 
             self.set_cursor()
@@ -164,4 +223,5 @@ class PostgresConnection(BaseConnection):
         finally:
             if self.get_transaction_level() <= 0:
                 self.open = 0
-                self._connection.close()
+                self.close_connection()
+                # self._connection.close()

{masonite-orm-2.23.1 → masonite-orm-2.23.2}/src/masoniteorm/models/Model.py

@@ -354,7 +354,10 @@ class Model(TimeStampsMixin, ObservesEvents, metaclass=ModelMeta):
             dry=self.__dry__,
         )
 
-        return self.builder.select(*self.__selects__)
+        return self.builder.select(*self.get_selects())
+
+    def get_selects(self):
+        return self.__selects__
 
     @classmethod
     def get_columns(cls):
@@ -426,12 +429,12 @@ class Model(TimeStampsMixin, ObservesEvents, metaclass=ModelMeta):
             builder = cls().where(cls.get_primary_key(), record_id)
 
         if query:
-            return builder.to_sql()
+            return builder
         else:
             if isinstance(record_id, (list, tuple)):
                 return builder.get()
 
-            return builder.first()
+        return builder.first()
 
     @classmethod
     def find_or_fail(cls, record_id, query=False):
@@ -560,9 +563,7 @@ class Model(TimeStampsMixin, ObservesEvents, metaclass=ModelMeta):
             self: A hydrated version of a model
         """
         if query:
-            return cls.builder.create(
-                dictionary, query=True, cast=cast, **kwargs
-            ).to_sql()
+            return cls.builder.create(dictionary, query=True, cast=cast, **kwargs)
 
         return cls.builder.create(dictionary, cast=cast, **kwargs)
 
@@ -897,7 +898,7 @@ class Model(TimeStampsMixin, ObservesEvents, metaclass=ModelMeta):
         if self.is_loaded():
             result = builder.update(
                 self.__dirty_attributes__, dry=query, ignore_mass_assignment=True
-            ).to_sql()
+            )
         else:
             result = self.create(self.__dirty_attributes__, query=query)
 

{masonite-orm-2.23.1 → masonite-orm-2.23.2}/src/masoniteorm/query/QueryBuilder.py

@@ -1710,15 +1710,12 @@ class QueryBuilder(ObservesEvents):
         if not fields:
             fields = []
 
-        if fields:
-            self.select(fields)
+        self.select(fields).limit(1)
 
         if query:
-            return self.limit(1)
+            return self
 
-        result = self.new_connection().query(
-            self.limit(1).to_qmark(), self._bindings, results=1
-        )
+        result = self.new_connection().query(self.to_qmark(), self._bindings, results=1)
 
         return self.prepare_result(result)
 
@@ -1778,11 +1775,13 @@ class QueryBuilder(ObservesEvents):
             dictionary -- Returns a dictionary of results.
         """
         _column = column if column else self._model.get_primary_key()
+        self.limit(1).order_by(_column, direction="DESC")
+
         if query:
-            return self.limit(1).order_by(_column, direction="DESC")
+            return self
 
         result = self.new_connection().query(
-            self.limit(1).order_by(_column, direction="DESC").to_qmark(),
+            self.to_qmark(),
             self._bindings,
             results=1,
         )
@@ -1792,7 +1791,7 @@ class QueryBuilder(ObservesEvents):
     def _get_eager_load_result(self, related, collection):
         return related.eager_load_from_collection(collection)
 
-    def find(self, record_id):
+    def find(self, record_id, query=False):
         """Finds a row by the primary key ID. Requires a model
 
         Arguments:
@@ -1801,8 +1800,12 @@ class QueryBuilder(ObservesEvents):
         Returns:
             Model|None
         """
+        self.where(self._model.get_primary_key(), record_id)
 
-        return self.where(self._model.get_primary_key(), record_id).first()
+        if query:
+            return self
+
+        return self.first()
 
     def find_or(self, record_id: int, callback: Callable, args=None):
         """Finds a row by the primary key ID (Requires a model) or raise a ModelNotFound exception.
@@ -1868,7 +1871,7 @@ class QueryBuilder(ObservesEvents):
         """
 
         if query:
-            return self.limit(1)
+            return self.first(query=True)
 
         result = self.first()
 
@@ -1963,10 +1966,7 @@ class QueryBuilder(ObservesEvents):
         return self
 
     def _map_related(self, related_result, related):
-        if related.__class__.__name__ == 'MorphTo':
-            return related_result
-
-        return related_result.group_by(related.foreign_key)
+        return related.map_related(related_result)
 
     def all(self, selects=[], query=False):
         """Returns all records from the table.
@@ -1974,9 +1974,11 @@ class QueryBuilder(ObservesEvents):
         Returns:
             dictionary -- Returns a dictionary of results.
         """
+
         self.select(*selects)
+
         if query:
-            return self.to_sql()
+            return self
 
         result = self.new_connection().query(self.to_qmark(), self._bindings) or []
 
@@ -2088,9 +2090,8 @@ class QueryBuilder(ObservesEvents):
         Returns:
             self
         """
-        for name, scope in self._global_scopes.get(self._action, {}).items():
-            scope(self)
 
+        self.run_scopes()
         grammar = self.get_grammar()
         sql = grammar.compile(self._action, qmark=False).to_sql()
         return sql
@@ -2117,11 +2118,9 @@ class QueryBuilder(ObservesEvents):
         Returns:
             self
         """
-        for name, scope in self._global_scopes.get(self._action, {}).items():
-            scope(self)
 
+        self.run_scopes()
         grammar = self.get_grammar()
-
         sql = grammar.compile(self._action, qmark=True).to_sql()
 
         self._bindings = grammar._bindings

{masonite-orm-2.23.1 → masonite-orm-2.23.2}/src/masoniteorm/query/grammars/BaseGrammar.py

@@ -10,7 +10,6 @@ from ...expressions.expressions import (
 
 
 class BaseGrammar:
-
     """The keys in this dictionary is how the ORM will reference these aggregates
 
     The values on the right are the matching functions for the grammar
@@ -251,13 +250,13 @@ class BaseGrammar:
                         on_string += f"{keyword} {self._table_column_string(clause.column1)} {clause.equality} {self._table_column_string(clause.column2)} "
                     else:
                         if clause.value_type == "NULL":
-                            sql_string = self.where_null_string()
+                            sql_string = f"{self.where_null_string()} "
                             on_string += sql_string.format(
                                 keyword=keyword,
                                 column=self.process_column(clause.column),
                             )
                         elif clause.value_type == "NOT NULL":
-                            sql_string = self.where_not_null_string()
+                            sql_string = f"{self.where_not_null_string()} "
                             on_string += sql_string.format(
                                 keyword=keyword,
                                 column=self.process_column(clause.column),

{masonite-orm-2.23.1 → masonite-orm-2.23.2}/src/masoniteorm/relationships/BaseRelationship.py

@@ -193,3 +193,6 @@ class BaseRelationship:
         )
 
         return related_builder
+
+    def map_related(self, related_result):
+        return related_result

{masonite-orm-2.23.1 → masonite-orm-2.23.2}/src/masoniteorm/relationships/BelongsTo.py

@@ -66,3 +66,6 @@ class BelongsTo(BaseRelationship):
         related = collection.get(getattr(model, self.local_key), None)
 
         model.add_relation({key: related[0] if related else None})
+
+    def map_related(self, related_result):
+        return related_result.group_by(self.foreign_key)

{masonite-orm-2.23.1 → masonite-orm-2.23.2}/src/masoniteorm/relationships/HasMany.py

@@ -30,3 +30,6 @@ class HasMany(BaseRelationship):
         model.add_relation(
             {key: collection.get(getattr(model, self.local_key)) or Collection()}
         )
+
+    def map_related(self, related_result):
+        return related_result.group_by(self.foreign_key)