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

masoniteorm/query/grammars/SQLiteGrammar.py

@@ -0,0 +1,228 @@
+import re
+
+from .BaseGrammar import BaseGrammar
+
+
+class SQLiteGrammar(BaseGrammar):
+    """SQLite grammar class."""
+
+    aggregate_options = {
+        "SUM": "SUM",
+        "MAX": "MAX",
+        "MIN": "MIN",
+        "AVG": "AVG",
+        "COUNT": "COUNT",
+    }
+
+    join_keywords = {
+        "inner": "INNER JOIN",
+        "join": "INNER JOIN",
+        "outer": "OUTER JOIN",
+        "left": "LEFT JOIN",
+        "right": "LEFT JOIN",
+        "left_inner": "LEFT INNER JOIN",
+        "right_inner": "LEFT INNER JOIN",
+    }
+
+    column_strings = {
+        "select": '{table}."{column}"{alias}{separator}',
+        "select_all": "{table}.*{separator}",
+        "insert": '"{column}"{separator}',
+        "update": '"{column}"{separator}',
+        "delete": '"{column}"{separator}',
+    }
+
+    locks = {"share": "", "update": ""}
+
+    def select_format(self):
+        return "SELECT {keyword} {columns} FROM {table} {joins} {wheres} {group_by} {having} {order_by} {limit} {offset} {lock}"
+
+    def select_no_table(self):
+        return "SELECT {columns} {lock}"
+
+    def update_format(self):
+        return "UPDATE {table} SET {key_equals} {wheres}"
+
+    def insert_format(self):
+        return "INSERT INTO {table} ({columns}) VALUES ({values})"
+
+    def bulk_insert_format(self):
+        return "INSERT INTO {table} ({columns}) VALUES {values}"
+
+    def delete_format(self):
+        return "DELETE FROM {table} {wheres}"
+
+    def aggregate_string_with_alias(self):
+        return "{aggregate_function}({column}) AS {alias}"
+
+    def aggregate_string_without_alias(self):
+        return "{aggregate_function}({column})"
+
+    def subquery_string(self):
+        return "({query})"
+
+    def default_string(self):
+        return " DEFAULT {default} "
+
+    def raw_query_string(self):
+        return "{keyword} {query}"
+
+    def where_group_string(self):
+        return "{keyword} {value}"
+
+    def between_string(self):
+        return "{keyword} {column} BETWEEN {low} AND {high}"
+
+    def not_between_string(self):
+        return "{keyword} {column} NOT BETWEEN {low} AND {high}"
+
+    def where_exists_string(self):
+        return "{keyword} EXISTS {value}"
+
+    def where_not_exists_string(self):
+        return "{keyword} NOT EXISTS {value}"
+
+    def where_like_string(self):
+        return "{keyword} {column} LIKE {value}"
+
+    def where_not_like_string(self):
+        return "{keyword} {column} NOT LIKE {value}"
+
+    def subquery_alias_string(self):
+        return "AS {alias}"
+
+    def key_value_string(self):
+        return "{column} = {value}{separator}"
+
+    def column_value_string(self):
+        return "{column} = {value}{separator}"
+
+    def increment_string(self):
+        return "{column} = {column} + {value}"
+
+    def decrement_string(self):
+        return "{column} = {column} - {value}"
+
+    def column_exists_string(self):
+        return "SELECT column_name FROM information_schema.columns WHERE table_name='{clean_table}' and column_name={value}"
+
+    def table_exists_string(self):
+        return "SELECT name FROM sqlite_master WHERE type='table' AND name='{clean_table}'"
+
+    def to_sql(self):
+        """Cleans up the SQL string and returns the SQL
+
+        Returns:
+            string
+        """
+
+        if self.queries and (not self._columns and not self._creates):
+            sql = ""
+            for query in self.queries:
+                query += "; "
+                sql += re.sub(" +", " ", query)
+            return sql.rstrip(" ")
+        else:
+            sql = re.sub(" +", " ", self._sql.strip().replace(",)", ")"))
+            for query in self.queries:
+                sql += "; "
+                sql += re.sub(" +", " ", query.strip())
+
+            return sql
+
+    def table_string(self):
+        return '"{table}"'
+
+    def order_by_format(self):
+        return "{column} {direction}"
+
+    def order_by_string(self):
+        return "ORDER BY {order_columns}"
+
+    def column_string(self):
+        return '"{column}"{separator}'
+
+    def value_string(self):
+        return "'{value}'{separator}"
+
+    def join_string(self):
+        return "{keyword} {foreign_table}{alias} {on}"
+
+    def limit_string(self, offset=False):
+        if offset:
+            return ""
+        return "LIMIT {limit}"
+
+    def offset_string(self):
+        return "LIMIT {limit} OFFSET {offset}"
+
+    def first_where_string(self):
+        return "WHERE"
+
+    def additional_where_string(self):
+        return "AND"
+
+    def or_where_string(self):
+        return "OR"
+
+    def where_in_string(self):
+        return "WHERE IN ({values})"
+
+    def where_string(self):
+        return " {keyword} {column} {equality} {value}"
+
+    def having_string(self):
+        return "HAVING {column}"
+
+    def having_equality_string(self):
+        return "HAVING {column} {equality} {value}"
+
+    def where_null_string(self):
+        return " {keyword} {column} IS NULL"
+
+    def where_date_string(self):
+        return "{keyword} DATE({column}) {equality} {value}"
+
+    def value_equal_string(self):
+        return "{keyword} {value1} = {value2}"
+
+    def where_not_null_string(self):
+        return " {keyword} {column} IS NOT NULL"
+
+    def enable_foreign_key_constraints(self):
+        return "PRAGMA foreign_keys = ON"
+
+    def disable_foreign_key_constraints(self):
+        return "PRAGMA foreign_keys = OFF"
+
+    def get_true_column_string(self):
+        return "{keyword} {column} = '1'"
+
+    def get_false_column_string(self):
+        return "{keyword} {column} = '0'"
+
+    def truncate_table(self, table, foreign_keys=False):
+        # SQLite do not have TRUNCATE TABLE command but we can
+        # use SQLite DELETE command to delete complete data from an existing table
+        if not foreign_keys:
+            return f"DELETE FROM {self.wrap_table(table)}"
+
+        return [
+            self.disable_foreign_key_constraints(),
+            f"DELETE FROM {self.wrap_table(table)}",
+            self.enable_foreign_key_constraints(),
+        ]
+
+    def compile_random(self):
+        return "random()"
+
+    def process_offset(self):
+        """Compiles the offset expression.
+
+        Returns:
+            self
+        """
+        if not self._limit:
+            self._limit = int(-1)
+
+        return super().process_offset()

masoniteorm/query/grammars/__init__.py

@@ -0,0 +1,4 @@
+from .MSSQLGrammar import MSSQLGrammar
+from .MySQLGrammar import MySQLGrammar
+from .PostgresGrammar import PostgresGrammar
+from .SQLiteGrammar import SQLiteGrammar

masoniteorm/query/processors/MSSQLPostProcessor.py

@@ -0,0 +1,58 @@
+class MSSQLPostProcessor:
+    """Post processor classes are responsable for modifying the result after a query.
+
+    Post Processors are called after the connection calls the database in the
+    Query Builder but before the result is returned in that builder method.
+
+    We can use this oppurtunity to get things like the inserted ID.
+
+    For the Postgres Post Processor we have a RETURNING * string in the insert so the result
+    will already have the full inserted record in the results. Therefore, we can just return
+    the results
+    """
+
+    def process_insert_get_id(self, builder, results, id_key):
+        """Process the results from the query to the database.
+
+        Args:
+            builder (masoniteorm.builder.QueryBuilder): The query builder class
+            results (dict): The result from an insert query or the creates from the query builder.
+            This is usually a dictionary.
+            id_key (string): The key to set the primary key to. This is usually the primary key of the table.
+
+        Returns:
+            dictionary: Should return the modified dictionary.
+        """
+
+        last_id = builder.new_connection().query(
+            "SELECT @@Identity as [id]", results=1
+        )
+
+        id = last_id["id"]
+
+        if str(id).isdigit():
+            id = int(id)
+        else:
+            id = str(id)
+
+        results.update({id_key: id})
+        return results
+
+    def get_column_value(self, builder, column, results, id_key, id_value):
+        """Gets the specific column value from a table. Typically done after an update to
+        refetch the new value of a field.
+
+            builder (masoniteorm.builder.QueryBuilder): The query builder class
+            column (string): The column to refetch the value for.
+            results (dict): The result from an update query from the query builder.
+            This is usually a dictionary.
+            id_key (string): The key to fetch the primary key for. This is usually the primary key of the table.
+            id_value (string): The value of the primary key to fetch
+        """
+
+        new_builder = builder.select(column)
+        if id_key and id_value:
+            new_builder.where(id_key, id_value)
+            return new_builder.first()[column]
+
+        return {}

masoniteorm/query/processors/MySQLPostProcessor.py

@@ -0,0 +1,48 @@
+class MySQLPostProcessor:
+    """Post processor classes are responsable for modifying the result after a query.
+
+    Post Processors are called after the connection calls the database in the
+    Query Builder but before the result is returned in that builder method.
+
+    We can use this oppurtunity to get things like the inserted ID.
+
+    For the SQLite Post Processor we have an attribute on the connection class we can use to fetch the ID.
+    """
+
+    def process_insert_get_id(self, builder, results, id_key):
+        """Process the results from the query to the database.
+
+        Args:
+            builder (masoniteorm.builder.QueryBuilder): The query builder class
+            results (dict): The result from an insert query or the creates from the query builder.
+            This is usually a dictionary.
+            id_key (string): The key to set the primary key to. This is usually the primary key of the table.
+
+        Returns:
+            dictionary: Should return the modified dictionary.
+        """
+
+        if id_key not in results:
+            results.update(
+                {id_key: builder._connection.get_cursor().lastrowid}
+            )
+        return results
+
+    def get_column_value(self, builder, column, results, id_key, id_value):
+        """Gets the specific column value from a table. Typically done after an update to
+        refetch the new value of a field.
+
+            builder (masoniteorm.builder.QueryBuilder): The query builder class
+            column (string): The column to refetch the value for.
+            results (dict): The result from an update query from the query builder.
+            This is usually a dictionary.
+            id_key (string): The key to fetch the primary key for. This is usually the primary key of the table.
+            id_value (string): The value of the primary key to fetch
+        """
+
+        new_builder = builder.select(column)
+        if id_key and id_value:
+            new_builder.where(id_key, id_value)
+            return new_builder.first()[column]
+
+        return {}

masoniteorm/query/processors/PostgresPostProcessor.py

@@ -0,0 +1,49 @@
+class PostgresPostProcessor:
+    """Post processor classes are responsable for modifying the result after a query.
+
+    Post Processors are called after the connection calls the database in the
+    Query Builder but before the result is returned in that builder method.
+
+    We can use this oppurtunity to get things like the inserted ID.
+
+    For the Postgres Post Processor we have a RETURNING * string in the insert so the result
+    will already have the full inserted record in the results. Therefore, we can just return
+    the results
+    """
+
+    def process_insert_get_id(self, builder, results, id_key):
+        """Process the results from the query to the database.
+
+        Args:
+            builder (masoniteorm.builder.QueryBuilder): The query builder class
+            results (dict): The result from an insert query or the creates from the query builder.
+            This is usually a dictionary.
+            id_key (string): The key to set the primary key to. This is usually the primary key of the table.
+
+        Returns:
+            dictionary: Should return the modified dictionary.
+        """
+
+        return results
+
+    def get_column_value(self, builder, column, results, id_key, id_value):
+        """Gets the specific column value from a table. Typically done after an update to
+        refetch the new value of a field.
+
+            builder (masoniteorm.builder.QueryBuilder): The query builder class
+            column (string): The column to refetch the value for.
+            results (dict): The result from an update query from the query builder.
+            This is usually a dictionary.
+            id_key (string): The key to fetch the primary key for. This is usually the primary key of the table.
+            id_value (string): The value of the primary key to fetch
+        """
+
+        if column in results:
+            return results[column]
+
+        new_builder = builder.select(column)
+        if id_key and id_value:
+            new_builder.where(id_key, id_value)
+            return new_builder.first()[column]
+
+        return {}

masoniteorm/query/processors/SQLitePostProcessor.py

@@ -0,0 +1,49 @@
+class SQLitePostProcessor:
+    """Post processor classes are responsable for modifying the result after a query.
+
+    Post Processors are called after the connection calls the database in the
+    Query Builder but before the result is returned in that builder method.
+
+    We can use this oppurtunity to get things like the inserted ID.
+
+    For the SQLite Post Processor we have an attribute on the connection class we can use to fetch the ID.
+    """
+
+    def process_insert_get_id(self, builder, results, id_key="id"):
+        """Process the results from the query to the database.
+
+        Args:
+            builder (masoniteorm.builder.QueryBuilder): The query builder class
+            results (dict): The result from an insert query or the creates from the query builder.
+            This is usually a dictionary.
+            id_key (string): The key to set the primary key to. This is usually the primary key of the table.
+
+        Returns:
+            dictionary: Should return the modified dictionary.
+        """
+
+        if id_key not in results:
+            results.update(
+                {id_key: builder.get_connection().get_cursor().lastrowid}
+            )
+
+        return results
+
+    def get_column_value(self, builder, column, results, id_key, id_value):
+        """Gets the specific column value from a table. Typically done after an update to
+        refetch the new value of a field.
+
+            builder (masoniteorm.builder.QueryBuilder): The query builder class
+            column (string): The column to refetch the value for.
+            results (dict): The result from an update query from the query builder.
+            This is usually a dictionary.
+            id_key (string): The key to fetch the primary key for. This is usually the primary key of the table.
+            id_value (string): The value of the primary key to fetch
+        """
+
+        new_builder = builder.select(column)
+        if id_key and id_value:
+            new_builder.where(id_key, id_value)
+            return new_builder.first()[column]
+
+        return {}

masoniteorm/query/processors/__init__.py

@@ -0,0 +1,4 @@
+from .MSSQLPostProcessor import MSSQLPostProcessor
+from .MySQLPostProcessor import MySQLPostProcessor
+from .PostgresPostProcessor import PostgresPostProcessor
+from .SQLitePostProcessor import SQLitePostProcessor

masoniteorm/relationships/BaseRelationship.py

@@ -0,0 +1,161 @@
+class BaseRelationship:
+    def __init__(self, fn, local_key=None, foreign_key=None):
+        if isinstance(fn, str):
+            self.fn = None
+            self.local_key = fn
+            self.foreign_key = local_key
+        else:
+            self.fn = fn
+            self.local_key = local_key
+            self.foreign_key = foreign_key
+
+    def __set_name__(self, cls, name):
+        """This method is called right after the decorator is registered.
+
+        At this point we finally have access to the model cls
+
+        Arguments:
+            name {object} -- The model class.
+        """
+        pass
+
+    def __call__(self, fn=None, *args, **kwargs):
+        """This method is called when the decorator contains arguments.
+
+        When you do something like this:
+
+        @belongs_to('id', 'user_id').
+
+        In this case, the {fn} argument will be the callable.
+        """
+        if callable(fn):
+            self.fn = fn
+
+        return self
+
+    def get_builder(self):
+        return self._related_builder
+
+    def __get__(self, instance, owner):
+        """
+        This method is called when the decorated method is accessed.
+
+        Arguments:
+            instance {object|None} -- The instance we called.
+                If we didn't call the attribute and only accessed it then this will be None.
+
+            owner {object} -- The current model that the property was accessed on.
+
+        Returns:
+            object -- Either returns a builder or a hydrated model.
+        """
+        attribute = self.fn.__name__
+        relationship = self.fn(instance)()
+        self.set_keys(instance, attribute)
+        self._related_builder = relationship.builder
+
+        if not instance.is_loaded():
+            return self
+
+        if attribute in instance._relationships:
+            return instance._relationships[attribute]
+
+        return self.apply_query(self._related_builder, instance)
+
+    def __getattr__(self, attribute):
+        relationship = self.fn(self)()
+        return getattr(relationship.builder, attribute)
+
+    def apply_query(self, foreign, owner):
+        """Return a dictionary to hydrate the model with
+
+        Arguments:
+            foreign {oject} -- The relationship object
+            owner {object} -- The current model oject.
+
+        Returns:
+            dict -- A dictionary of data which will be hydrated.
+        """
+        klass = self.__class__.__name__
+        raise NotImplementedError(
+            f"{klass} relationship does not implement the 'apply_query' method"
+        )
+
+    def query_where_exists(self, builder, callback, method="where_exists"):
+        """Adds a criteria clause to the query filter for existing related records"""
+        klass = self.__class__.__name__
+        raise NotImplementedError(
+            f"{klass} relationship does not implement the 'query_where_exists' method"
+        )
+
+    def joins(self, builder, clause=None):
+        """Helper method for adding join clauses to a relationship"""
+        other_table = self.get_builder().get_table_name()
+        local_table = builder.get_table_name()
+        return builder.join(
+            other_table,
+            f"{local_table}.{self.local_key}",
+            "=",
+            f"{other_table}.{self.foreign_key}",
+            clause=clause,
+        )
+
+    def get_with_count_query(self, builder, callback):
+        """Adds a clause to the query to get the record count of the relationship"""
+        klass = self.__class__.__name__
+        raise NotImplementedError(
+            f"{klass} relationship does not implement the 'get_with_count_query' method"
+        )
+
+    def attach(self, current_model, related_record):
+        """Link a related model to the current model"""
+        klass = self.__class__.__name__
+        raise NotImplementedError(
+            f"{klass} relationship does not implement the 'attach' method"
+        )
+
+    def get_related(self, query, relation, eagers=None, callback=None):
+        klass = self.__class__.__name__
+        raise NotImplementedError(
+            f"{klass} relationship does not implement the 'get_related' method"
+        )
+
+    def relate(self, related_record):
+        klass = self.__class__.__name__
+        raise NotImplementedError(
+            f"{klass} relationship does not implement the 'relate' method"
+        )
+
+    def detach(self, current_model, related_record):
+        """Unlink a related model from the current model"""
+        klass = self.__class__.__name__
+        raise NotImplementedError(
+            f"{klass} relationship does not implement the 'detach' method"
+        )
+
+    def attach_related(self, current_model, related_record):
+        """Unlink a related model from the current model"""
+        klass = self.__class__.__name__
+        raise NotImplementedError(
+            f"{klass} relationship does not implement the 'attach_related' method"
+        )
+
+    def detach_related(self, current_model, related_record):
+        """Unlink a related model from the current model"""
+        klass = self.__class__.__name__
+        raise NotImplementedError(
+            f"{klass} relationship does not implement the 'detach_related' method"
+        )
+
+    def query_has(self, current_query_builder, method="where_exists"):
+        """Adds a clause to the query to chek if a rwlarion exists"""
+        klass = self.__class__.__name__
+        raise NotImplementedError(
+            f"{klass} relationship does not implement the 'query_has' method"
+        )
+
+    def map_related(self, related_result):
+        klass = self.__class__.__name__
+        raise NotImplementedError(
+            f"{klass} relationship does not implement the 'related_result' method"
+        )