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

masoniteorm/schema/Column.py

@@ -0,0 +1,144 @@
+class Column:
+    """Used for creating or modifying columns."""
+
+    def __init__(
+        self,
+        name,
+        column_type,
+        length=None,
+        values=None,
+        nullable=False,
+        default=None,
+        signed=None,
+        default_is_raw=False,
+        column_python_type=str,
+    ):
+        self.column_type = column_type
+        self.column_python_type = column_python_type
+        self.name = name
+        self.length = length
+        self.values = values or []
+        self.is_null = nullable
+        self._after = None
+        self.old_column = ""
+        self.default = default
+        self._signed = signed
+        self.default_is_raw = default_is_raw
+        self.primary = False
+        self.comment = None
+
+    def nullable(self):
+        """Sets this column to be nullable
+
+        Returns:
+            self
+        """
+        self.is_null = True
+        return self
+
+    def signed(self):
+        """Sets this column to be nullable
+
+        Returns:
+            self
+        """
+        self._signed = "signed"
+        return self
+
+    def unsigned(self):
+        """Sets this column to be nullable
+
+        Returns:
+            self
+        """
+        self._signed = "unsigned"
+        return self
+
+    def not_nullable(self):
+        """Sets this column to be not nullable
+
+        Returns:
+            self
+        """
+        self.is_null = False
+        return self
+
+    def set_as_primary(self):
+        self.primary = True
+
+    def rename(self, column):
+        """Renames this column to a new name
+
+        Arguments:
+            column {string} -- The old column name
+
+        Returns:
+            self
+        """
+        self.old_column = column
+        return self
+
+    def after(self, after):
+        """Sets the column that this new column should be created after.
+
+        This is useful for setting the location of the new column in the table schema.
+
+        Arguments:
+            after {string} -- The column that this new column should be created after
+
+        Returns:
+            self
+        """
+        self._after = after
+        return self
+
+    def get_after_column(self):
+        """Sets the column that this new column should be created after.
+
+        This is useful for setting the location of the new column in the table schema.
+
+        Arguments:
+            after {string} -- The column that this new column should be created after
+
+        Returns:
+            self
+        """
+        return self._after
+
+    def default(self, value, raw=False):
+        """Sets a default value for this column
+
+        Arguments:
+            value {string} -- A default value.
+            raw {bool} -- should the value be quoted
+
+        Returns:
+            self
+        """
+        self.default = value
+        self.default_is_raw = raw
+        return self
+
+    def change(self):
+        """Sets the schema to create a modify sql statement.
+
+        Returns:
+            self
+        """
+        self._action = "modify"
+        return self
+
+    def use_current(self):
+        """Sets the column to use a current timestamp.
+
+        Used for timestamp columns.
+
+        Returns:
+            self
+        """
+        self.default = "current"
+        return self
+
+    def add_comment(self, comment):
+        self.comment = comment
+        return self

masoniteorm/schema/Constraint.py

@@ -0,0 +1,5 @@
+class Constraint:
+    def __init__(self, name, constraint_type, columns=None):
+        self.name = name
+        self.constraint_type = constraint_type
+        self.columns = columns or []

masoniteorm/schema/ForeignKeyConstraint.py

@@ -0,0 +1,28 @@
+class ForeignKeyConstraint:
+    def __init__(self, column, foreign_table, foreign_column, name=None):
+        self.column = column
+        self.foreign_table = foreign_table
+        self.foreign_column = foreign_column
+        self.delete_action = None
+        self.update_action = None
+        self.constraint_name = name
+
+    def references(self, foreign_column):
+        self.foreign_column = foreign_column
+        return self
+
+    def on(self, foreign_table):
+        self.foreign_table = foreign_table
+        return self
+
+    def on_delete(self, action):
+        self.delete_action = action
+        return self
+
+    def on_update(self, action):
+        self.update_action = action
+        return self
+
+    def name(self, name):
+        self.constraint_name = name
+        return self

masoniteorm/schema/Index.py

@@ -0,0 +1,5 @@
+class Index:
+    def __init__(self, column, name, index_type):
+        self.column = column
+        self.name = name
+        self.index_type = index_type

masoniteorm/schema/Schema.py

@@ -0,0 +1,359 @@
+from ..config import load_config
+from ..exceptions import ConnectionNotRegistered
+from .Blueprint import Blueprint
+from .Table import Table
+from .TableDiff import TableDiff
+
+
+class Schema:
+    _default_string_length = "255"
+    _type_hints_map = {
+        "string": str,
+        "char": str,
+        "big_increments": int,
+        "integer": int,
+        "big_integer": int,
+        "tiny_integer": int,
+        "small_integer": int,
+        "medium_integer": int,
+        "integer_unsigned": int,
+        "big_integer_unsigned": int,
+        "tiny_integer_unsigned": int,
+        "small_integer_unsigned": int,
+        "medium_integer_unsigned": int,
+        "increments": int,
+        "uuid": str,
+        "binary": bytes,
+        "boolean": bool,
+        "decimal": float,
+        "double": float,
+        "enum": str,
+        "text": str,
+        "float": float,
+        "geometry": str,  # ?
+        "json": dict,
+        "jsonb": bytes,
+        "inet": str,
+        "cidr": str,
+        "macaddr": str,
+        "long_text": str,
+        "point": str,  # ?
+        "time": str,  # or pendulum.DateTime
+        "timestamp": str,  # or pendulum.DateTime
+        "date": str,  # or pendulum.DateTime
+        "year": str,
+        "datetime": str,  # or pendulum.DateTime
+        "tiny_increments": int,
+        "unsigned": int,
+        "unsigned_integer": int,
+    }
+
+    def __init__(
+        self,
+        dry=False,
+        connection="default",
+        connection_class=None,
+        platform=None,
+        grammar=None,
+        connection_details=None,
+        schema=None,
+        config_path=None,
+    ):
+        self._dry = dry
+        self.connection = connection
+        self.connection_class = connection_class
+        self._connection = None
+        self.grammar = grammar
+        self.platform = platform
+        self.connection_details = connection_details or {}
+        self._blueprint = None
+        self._sql = None
+        self.schema = schema
+        self.config_path = config_path
+
+        if not self.connection_class:
+            self.on(self.connection)
+
+        if not self.platform:
+            self.platform = self.connection_class.get_default_platform()
+
+    def on(self, connection_key):
+        """Change the connection from the default connection
+
+        Arguments:
+            connection {string} -- A connection string like 'mysql' or 'mssql'.
+                It will be made with the connection factory.
+
+        Returns:
+            cls
+        """
+        resolver = load_config(config_path=self.config_path).DB
+        self.connection_details = resolver.get_connection_details()
+        if connection_key == "default":
+            self.connection = self.connection_details.get("default")
+        else:
+            self.connection = connection_key
+
+        connection_detail = self.connection_details.get(self.connection)
+        if connection_detail:
+            self._connection_driver = connection_detail.get("driver")
+        else:
+            raise ConnectionNotRegistered(
+                f"Could not find the '{connection_key}' connection details"
+            )
+
+        self.connection_class = resolver.connection_factory.make(
+            self._connection_driver
+        )
+
+        return self
+
+    def dry(self):
+        """Whether the query should be executed. (default: {False})
+
+        Returns:
+            self
+        """
+        self._dry = True
+        return self
+
+    def create(self, table):
+        """Sets the table and returns the blueprint.
+
+        This should be used as a context manager.
+
+        Arguments:
+            table {string} -- The name of a table like 'users'
+
+        Returns:
+            masoniteorm.blueprint.Blueprint -- The Masonite ORM blueprint object.
+        """
+        self._table = table
+
+        self._blueprint = Blueprint(
+            self.grammar,
+            connection=self.new_connection(),
+            table=Table(table),
+            action="create",
+            platform=self.platform,
+            schema=self.schema,
+            default_string_length=self._default_string_length,
+            dry=self._dry,
+        )
+
+        return self._blueprint
+
+    def create_table_if_not_exists(self, table):
+        self._table = table
+
+        self._blueprint = Blueprint(
+            self.grammar,
+            connection=self.new_connection(),
+            table=Table(table),
+            action="create_table_if_not_exists",
+            platform=self.platform,
+            schema=self.schema,
+            default_string_length=self._default_string_length,
+            dry=self._dry,
+        )
+
+        return self._blueprint
+
+    def table(self, table):
+        """Sets the table and returns the blueprint.
+
+        This should be used as a context manager.
+
+        Arguments:
+            table {string} -- The name of a table like 'users'
+
+        Returns:
+            masoniteorm.blueprint.Blueprint -- The Masonite ORM blueprint object.
+        """
+        self._table = table
+
+        self._blueprint = Blueprint(
+            self.grammar,
+            connection=self.new_connection(),
+            table=TableDiff(table),
+            action="alter",
+            platform=self.platform,
+            schema=self.schema,
+            default_string_length=self._default_string_length,
+            dry=self._dry,
+        )
+
+        return self._blueprint
+
+    def get_connection_information(self):
+        return {
+            "host": self.connection_details.get(self.connection, {}).get(
+                "host"
+            ),
+            "database": self.connection_details.get(self.connection, {}).get(
+                "database"
+            ),
+            "user": self.connection_details.get(self.connection, {}).get(
+                "user"
+            ),
+            "port": self.connection_details.get(self.connection, {}).get(
+                "port"
+            ),
+            "password": self.connection_details.get(self.connection, {}).get(
+                "password"
+            ),
+            "prefix": self.connection_details.get(self.connection, {}).get(
+                "prefix"
+            ),
+            "options": self.connection_details.get(self.connection, {}).get(
+                "options", {}
+            ),
+            "full_details": self.connection_details.get(self.connection),
+        }
+
+    def new_connection(self):
+        if self._dry:
+            return
+
+        self._connection = (
+            self.connection_class(**self.get_connection_information())
+            .set_schema(self.schema)
+            .make_connection()
+        )
+
+        return self._connection
+
+    def has_column(self, table, column, query_only=False):
+        """Checks if the a table has a specific column
+
+        Arguments:
+            table {string} -- The name of a table like 'users'
+
+        Returns:
+            masoniteorm.blueprint.Blueprint -- The Masonite ORM blueprint object.
+        """
+        sql = self.platform().compile_column_exists(table, column)
+
+        if self._dry:
+            self._sql = sql
+            return sql
+
+        return bool(self.new_connection().query(sql, ()))
+
+    def get_columns(self, table, dict=True):
+        table = self.platform().get_current_schema(
+            self.new_connection(), table, schema=self.get_schema()
+        )
+        result = {}
+        if dict:
+            for column in table.get_added_columns().items():
+                result.update({column[0]: column[1]})
+            return result
+        else:
+            return table.get_added_columns().items()
+
+    @classmethod
+    def set_default_string_length(cls, length):
+        cls._default_string_length = length
+        return cls
+
+    def drop_table(self, table, query_only=False):
+        sql = self.platform().compile_drop_table(table)
+
+        if self._dry:
+            self._sql = sql
+            return sql
+
+        return bool(self.new_connection().query(sql, ()))
+
+    def drop(self, *args, **kwargs):
+        return self.drop_table(*args, **kwargs)
+
+    def drop_table_if_exists(self, table, exists=False, query_only=False):
+        sql = self.platform().compile_drop_table_if_exists(table)
+
+        if self._dry:
+            self._sql = sql
+            return sql
+
+        return bool(self.new_connection().query(sql, ()))
+
+    def rename(self, table, new_name):
+        sql = self.platform().compile_rename_table(table, new_name)
+
+        if self._dry:
+            self._sql = sql
+            return sql
+
+        return bool(self.new_connection().query(sql, ()))
+
+    def truncate(self, table, foreign_keys=False):
+        sql = self.platform().compile_truncate(
+            table, foreign_keys=foreign_keys
+        )
+
+        if self._dry:
+            self._sql = sql
+            return sql
+
+        return bool(self.new_connection().query(sql, ()))
+
+    def get_schema(self):
+        """Gets the schema set on the migration class"""
+        return self.schema or self.get_connection_information().get(
+            "full_details"
+        ).get("schema")
+
+    def get_all_tables(self):
+        """Gets all tables in the database"""
+        sql = self.platform().compile_get_all_tables(
+            database=self.get_connection_information().get("database"),
+            schema=self.get_schema(),
+        )
+
+        if self._dry:
+            self._sql = sql
+            return sql
+
+        result = self.new_connection().query(sql, ())
+
+        return (
+            list(map(lambda t: list(t.values())[0], result)) if result else []
+        )
+
+    def has_table(self, table, query_only=False):
+        """Checks if the a database has a specific table
+        Arguments:
+            table {string} -- The name of a table like 'users'
+        Returns:
+            masoniteorm.blueprint.Blueprint -- The Masonite ORM blueprint object.
+        """
+        sql = self.platform().compile_table_exists(
+            table,
+            database=self.get_connection_information().get("database"),
+            schema=self.get_schema(),
+        )
+
+        if self._dry:
+            self._sql = sql
+            return sql
+
+        return bool(self.new_connection().query(sql, ()))
+
+    def enable_foreign_key_constraints(self):
+        sql = self.platform().enable_foreign_key_constraints()
+
+        if self._dry:
+            self._sql = sql
+            return sql
+
+        return bool(self.new_connection().query(sql, ()))
+
+    def disable_foreign_key_constraints(self):
+        sql = self.platform().disable_foreign_key_constraints()
+
+        if self._dry:
+            self._sql = sql
+            return sql
+
+        return bool(self.new_connection().query(sql, ()))

masoniteorm/schema/Table.py

@@ -0,0 +1,94 @@
+from .Column import Column
+from .Constraint import Constraint
+from .ForeignKeyConstraint import ForeignKeyConstraint
+from .Index import Index
+
+
+class Table:
+    def __init__(self, table):
+        self.name = table
+        self.added_columns = {}
+        self.added_constraints = {}
+        self.added_indexes = {}
+        self.added_foreign_keys = {}
+        self.renamed_columns = {}
+        self.drop_indexes = {}
+        self.foreign_keys = {}
+        self.primary_key = None
+        self.comment = None
+
+    def add_column(
+        self,
+        name=None,
+        column_type=None,
+        length=None,
+        values=None,
+        nullable=False,
+        default=None,
+        signed=None,
+        default_is_raw=False,
+        primary=False,
+        column_python_type=str,
+    ):
+        column = Column(
+            name,
+            column_type,
+            length=length,
+            nullable=nullable,
+            values=values or [],
+            default=default,
+            signed=signed,
+            default_is_raw=default_is_raw,
+            column_python_type=column_python_type,
+        )
+        if primary:
+            column.set_as_primary()
+        self.added_columns.update({name: column})
+        return column
+
+    def add_constraint(self, name, constraint_type, columns=None):
+        self.added_constraints.update(
+            {name: Constraint(name, constraint_type, columns=columns or [])}
+        )
+
+    def add_foreign_key(
+        self, column, table=None, foreign_column=None, name=None
+    ):
+        foreign_key = ForeignKeyConstraint(
+            column,
+            table,
+            foreign_column,
+            name=name or f"{self.name}_{column}_foreign",
+        )
+        self.added_foreign_keys.update({column: foreign_key})
+
+        return foreign_key
+
+    def get_added_foreign_keys(self):
+        return self.added_foreign_keys
+
+    def get_constraint(self, name):
+        return self.added_constraints[name]
+
+    def get_added_constraints(self):
+        return self.added_constraints
+
+    def get_added_columns(self):
+        return self.added_columns
+
+    def get_renamed_columns(self):
+        return self.added_columns
+
+    def set_primary_key(self, columns):
+        self.primary_key = columns
+        return self
+
+    def add_index(self, column, name, index_type):
+        self.added_indexes.update({name: Index(column, name, index_type)})
+
+    def get_index(self, name):
+        return self.added_indexes[name]
+
+    def add_comment(self, comment):
+        self.comment = comment
+        return self