django-migrate-sql-deux 0.2.0__tar.gz

Users/brunoalla/.virtualenvs/fes-django-migrate-sql/lib/python3.6/site-packages/django_migrate_sql_deux-0.2.0-py3.6.egg-info/PKG-INFO

@@ -0,0 +1,294 @@
+Metadata-Version: 1.1
+Name: django-migrate-sql-deux
+Version: 0.2.0
+Summary: Migration support for raw SQL in Django
+Home-page: https://github.com/festicket/django-migrate-sql
+Author: Festicket
+Author-email: dev@festicket.com
+License: BSD
+Description: django-migrate-sql-deux
+        =======================
+        
+        .. note::
+        
+            This package is a fork of the ``django-migrate-sql`` package, originally published
+            by Bogdan Klichuk. This package appears unmaintained, so we decided to start a fork
+            as we depended on it. Most of the code is from him.
+        
+        |Build Status| |codecov.io|
+        
+        Django Migrations support for raw SQL.
+        
+        About
+        -----
+        
+        This tool implements mechanism for managing changes to custom SQL
+        entities (functions, types, indices, triggers) using built-in migration
+        mechanism. Technically creates a sophistication layer on top of the
+        ``RunSQL`` Django operation.
+        
+        What it does
+        ------------
+        
+        -  Makes maintaining your SQL functions, custom composite types, indices
+           and triggers easier.
+        -  Structures SQL into configuration of **SQL items**, that are
+           identified by names and divided among apps, just like models.
+        -  Automatically gathers and persists changes of your custom SQL into
+           migrations using ``makemigrations``.
+        -  Properly executes backwards/forwards keeping integrity of database.
+        -  Create -> Drop -> Recreate approach for changes to items that do not
+           support altering and require dropping and recreating.
+        -  Dependencies system for SQL items, which solves the problem of
+           updating items, that rely on others (for example custom
+           types/functions that use other custom types), and require dropping
+           all dependency tree previously with further recreation.
+        
+        What it does not
+        ----------------
+        
+        -  Does not parse SQL nor validate queries during ``makemigrations`` or
+           ``migrate`` because is database-agnostic. For this same reason
+           setting up proper dependencies is user's responsibility.
+        -  Does not create ``ALTER`` queries for items that support this, for
+           example ``ALTER TYPE`` in Postgre SQL, because is database-agnostic.
+           In case your tools allow rolling all the changes through ``ALTER``
+           queries, you can consider not using this app **or** restructure
+           migrations manually after creation by nesting generated operations
+           into ```state_operations`` of
+           ``RunSQL`` <https://docs.djangoproject.com/en/1.8/ref/migration-operations/#runsql>`__
+           that does ``ALTER``.
+        -  (**TODO**)During ``migrate`` does not restore full state of items for
+           analysis, thus does not notify about existing changes to schema that
+           are not migrated **nor** does not recognize circular dependencies
+           during migration execution.
+        
+        Installation
+        ------------
+        
+        Install from PyPi:
+        
+        ::
+        
+            $ pip install django-migrate-sql-deux
+        
+        Add ``migrate_sql`` to ``INSTALLED_APPS``:
+        
+        .. code:: python
+        
+            INSTALLED_APPS = [
+                # ...
+                'migrate_sql',
+            ]
+        
+        App defines a custom ``makemigrations`` command, that inherits from
+        Django's core one, so in order ``migrate_sql`` app to kick in put it
+        after any other apps that redefine ``makemigrations`` command too.
+        
+        Usage
+        -----
+        
+        1) Create ``sql_config.py`` module to root of a target app you want to
+           manage custom SQL for.
+        
+        2) Define SQL items in it (``sql_items``), for example:
+        
+        .. code:: python
+        
+            # PostgreSQL example.
+            # Let's define a simple function and let `migrate_sql` manage it's changes.
+        
+            from migrate_sql.config import SQLItem
+        
+            sql_items = [
+                SQLItem(
+                    'make_sum',   # name of the item
+                    'create or replace function make_sum(a int, b int) returns int as $$ '
+                    'begin return a + b; end; ' 
+                    '$$ language plpgsql;',  # forward sql
+                    reverse_sql='drop function make_sum(int, int);',  # sql for removal
+                ),
+            ]
+        
+        3) Create migration ``./manage.py makemigrations``:
+        
+           ::
+        
+               Migrations for 'app_name':
+                 0002_auto_xxxx.py:
+               - Create SQL "make_sum"
+        
+        You can take a look at content this generated:
+        
+        .. code:: python
+        
+            # -*- coding: utf-8 -*-
+            from __future__ import unicode_literals
+            from django.db import migrations, models
+            import migrate_sql.operations
+        
+        
+            class Migration(migrations.Migration):
+                dependencies = [
+                    ('app_name', '0001_initial'),
+                ]
+                operations = [
+                    migrate_sql.operations.CreateSQL(
+                        name='make_sum',
+                        sql='create or replace function make_sum(a int, b int) returns int as $$ begin return a + b; end; $$ language plpgsql;',
+                        reverse_sql='drop function make_sum(int, int);',
+                    ),
+                ]
+        
+        4) Execute migration ``./manage.py migrate``:
+        
+           ::
+        
+               Operations to perform:
+                 Apply all migrations: app_name
+               Running migrations:
+                 Rendering model states... DONE
+                 Applying app_name.0002_xxxx... OK
+        
+        Check result in ``./manage.py dbshell``:
+        
+        ::
+        
+            db_name=# select make_sum(12, 15);
+             make_sum 
+            ----------
+                   27
+            (1 row)
+        
+        Now, say, you want to change the function implementation so that it
+        takes a custom type as argument:
+        
+        5) Edit your ``sql_config.py``:
+        
+        .. code:: python
+        
+            # PostgreSQL example #2.
+            # Function and custom type.
+        
+            from migrate_sql.config import SQLItem
+        
+            sql_items = [
+                SQLItem(
+                    'make_sum',  # name of the item
+                    'create or replace function make_sum(a mynum, b mynum) returns mynum as $$ '
+                    'begin return (a.num + b.num, 'result')::mynum; end; '
+                    '$$ language plpgsql;',  # forward sql
+                    reverse_sql='drop function make_sum(mynum, mynum);',  # sql for removal
+                    # depends on `mynum` since takes it as argument. we won't be able to drop function
+                    # without dropping `mynum` first.
+                    dependencies=[('app_name', 'mynum')],
+                ),
+                SQLItem(
+                    'mynum'   # name of the item
+                    'create type mynum as (num int, name varchar(20));',  # forward sql
+                    reverse_sql='drop type mynum;',  # sql for removal
+                ),
+            ]
+        
+        6) Generate migration ``./manage.py makemigrations``:
+        
+        ::
+        
+            Migrations for 'app_name':
+              0003_xxxx:
+                - Reverse alter SQL "make_sum"
+                - Create SQL "mynum"
+                - Alter SQL "make_sum"
+                - Alter SQL state "make_sum"
+        
+        You can take a look at the content this generated:
+        
+        .. code:: python
+        
+            # -*- coding: utf-8 -*-
+            from __future__ import unicode_literals
+            from django.db import migrations, models
+            import migrate_sql.operations
+        
+        
+            class Migration(migrations.Migration):
+                dependencies = [
+                    ('app_name', '0002_xxxx'),
+                ]
+                operations = [
+                    migrate_sql.operations.ReverseAlterSQL(
+                        name='make_sum',
+                        sql='drop function make_sum(int, int);',
+                        reverse_sql='create or replace function make_sum(a int, b int) returns int as $$ begin return a + b; end; $$ language plpgsql;',
+                    ),
+                    migrate_sql.operations.CreateSQL(
+                        name='mynum',
+                        sql='create type mynum as (num int, name varchar(20));',
+                        reverse_sql='drop type mynum;',
+                    ),
+                    migrate_sql.operations.AlterSQL(
+                        name='make_sum',
+                        sql='create or replace function make_sum(a mynum, b mynum) returns mynum as $$ begin return (a.num + b.num, \'result\')::mynum; end; $$ language plpgsql;',
+                        reverse_sql='drop function make_sum(mynum, mynum);',
+                    ),
+                    migrate_sql.operations.AlterSQLState(
+                        name='make_sum',
+                        add_dependencies=(('app_name', 'mynum'),),
+                    ),
+                ]
+        
+        ***NOTE:** Previous function is completely dropped before creation
+        because definition of it changed. ``CREATE OR REPLACE`` would create
+        another version of it, so ``DROP`` makes it clean.*
+        
+        ***If you put ``replace=True`` as kwarg to an ``SQLItem`` definition, it
+        will NOT drop + create it, but just rerun forward SQL, which is
+        ``CREATE OR REPLACE`` in this example.***
+        
+        7) Execute migration ``./manage.py migrate``:
+        
+        ::
+        
+            Operations to perform:
+              Apply all migrations: app_name
+            Running migrations:
+              Rendering model states... DONE
+              Applying brands.0003_xxxx... OK
+        
+        Check results:
+        
+        ::
+        
+            db_name=# select make_sum((5, 'a')::mynum, (3, 'b')::mynum);
+              make_sum  
+            ------------
+             (8,result)
+            (1 row)
+        
+            db_name=# select make_sum(12, 15);
+            ERROR:  function make_sum(integer, integer) does not exist
+            LINE 1: select make_sum(12, 15);
+                           ^
+            HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
+        
+        For more examples see ``tests``.
+        
+        Feel free to `open new
+        issues <https://github.com/klichukb/django-migrate-sql/issues>`__.
+        
+        .. |Build Status| image:: https://travis-ci.org/klichukb/django-migrate-sql.svg?branch=master
+           :target: https://travis-ci.org/klichukb/django-migrate-sql
+        .. |codecov.io| image:: https://img.shields.io/codecov/c/github/klichukb/django-migrate-sql/master.svg
+           :target: https://codecov.io/github/klichukb/django-migrate-sql?branch=master
+        
+Platform: UNKNOWN
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6

Users/brunoalla/.virtualenvs/fes-django-migrate-sql/lib/python3.6/site-packages/django_migrate_sql_deux-0.2.0-py3.6.egg-info/SOURCES.txt

@@ -0,0 +1,57 @@
+README.rst
+setup.cfg
+setup.py
+django_migrate_sql_deux.egg-info/PKG-INFO
+django_migrate_sql_deux.egg-info/SOURCES.txt
+django_migrate_sql_deux.egg-info/dependency_links.txt
+django_migrate_sql_deux.egg-info/not-zip-safe
+django_migrate_sql_deux.egg-info/top_level.txt
+migrate_sql/__init__.py
+migrate_sql/autodetector.py
+migrate_sql/config.py
+migrate_sql/graph.py
+migrate_sql/operations.py
+migrate_sql/management/__init__.py
+migrate_sql/management/commands/__init__.py
+migrate_sql/management/commands/makemigrations.py
+tests/__init__.py
+tests/manage.py
+tests/test_app/__init__.py
+tests/test_app/apps.py
+tests/test_app/models.py
+tests/test_app/sql_config.py
+tests/test_app/test_migrations.py
+tests/test_app/test_utils.py
+tests/test_app/urls.py
+tests/test_app/migrations/0001_initial.py
+tests/test_app/migrations/__init__.py
+tests/test_app/migrations_change/0001_initial.py
+tests/test_app/migrations_change/0002_auto_20151224_1827.py
+tests/test_app/migrations_change/__init__.py
+tests/test_app/migrations_deps_delete/0001_initial.py
+tests/test_app/migrations_deps_delete/0002_auto_20160106_0947.py
+tests/test_app/migrations_deps_delete/0003_auto_20160108_0048.py
+tests/test_app/migrations_deps_delete/0004_auto_20160108_0048.py
+tests/test_app/migrations_deps_delete/__init__.py
+tests/test_app/migrations_deps_update/0001_initial.py
+tests/test_app/migrations_deps_update/0002_auto_20160106_0947.py
+tests/test_app/migrations_deps_update/__init__.py
+tests/test_app/migrations_recreate/0001_initial.py
+tests/test_app/migrations_recreate/0002_auto_20151224_1827.py
+tests/test_app/migrations_recreate/0003_auto_20160106_1038.py
+tests/test_app/migrations_recreate/__init__.py
+tests/test_app2/__init__.py
+tests/test_app2/apps.py
+tests/test_app2/models.py
+tests/test_app2/sql_config.py
+tests/test_app2/urls.py
+tests/test_app2/migrations/__init__.py
+tests/test_app2/migrations_deps_delete/0001_initial.py
+tests/test_app2/migrations_deps_delete/0002_auto_20160108_0041.py
+tests/test_app2/migrations_deps_delete/__init__.py
+tests/test_app2/migrations_deps_update/0001_initial.py
+tests/test_app2/migrations_deps_update/__init__.py
+tests/test_project/__init__.py
+tests/test_project/settings.py
+tests/test_project/urls.py
+tests/test_project/wsgi.py

Users/brunoalla/.virtualenvs/fes-django-migrate-sql/lib/python3.6/site-packages/django_migrate_sql_deux-0.2.0-py3.6.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

Users/brunoalla/.virtualenvs/fes-django-migrate-sql/lib/python3.6/site-packages/django_migrate_sql_deux-0.2.0-py3.6.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

Users/brunoalla/.virtualenvs/fes-django-migrate-sql/lib/python3.6/site-packages/django_migrate_sql_deux-0.2.0-py3.6.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+migrate_sql
+tests

Users/brunoalla/.virtualenvs/fes-django-migrate-sql/lib/python3.6/site-packages/migrate_sql/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+__version__ = '0.2.0'

Users/brunoalla/.virtualenvs/fes-django-migrate-sql/lib/python3.6/site-packages/migrate_sql/autodetector.py

@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db.migrations.autodetector import MigrationAutodetector as DjangoMigrationAutodetector
+from django.db.migrations.operations import RunSQL
+
+from migrate_sql.operations import (AlterSQL, ReverseAlterSQL, CreateSQL, DeleteSQL, AlterSQLState)
+from migrate_sql.graph import SQLStateGraph
+
+
+class SQLBlob(object):
+    pass
+
+# Dummy object used to identify django dependency as the one used by this tool only.
+SQL_BLOB = SQLBlob()
+
+
+def _sql_params(sql):
+    """
+    Identify `sql` as either SQL string or 2-tuple of SQL and params.
+    Same format as supported by Django's RunSQL operation for sql/reverse_sql.
+    """
+    params = None
+    if isinstance(sql, (list, tuple)):
+        elements = len(sql)
+        if elements == 2:
+            sql, params = sql
+        else:
+            raise ValueError("Expected a 2-tuple but got %d" % elements)
+    return sql, params
+
+
+def is_sql_equal(sqls1, sqls2):
+    """
+    Find out equality of two SQL items.
+
+    See https://docs.djangoproject.com/en/1.8/ref/migration-operations/#runsql.
+    Args:
+        sqls1, sqls2: SQL items, have the same format as supported by Django's RunSQL operation.
+    Returns:
+        (bool) `True` if equal, otherwise `False`.
+    """
+    is_seq1 = isinstance(sqls1, (list, tuple))
+    is_seq2 = isinstance(sqls2, (list, tuple))
+
+    if not is_seq1:
+        sqls1 = (sqls1,)
+    if not is_seq2:
+        sqls2 = (sqls2,)
+
+    if len(sqls1) != len(sqls2):
+        return False
+
+    for sql1, sql2 in zip(sqls1, sqls2):
+        sql1, params1 = _sql_params(sql1)
+        sql2, params2 = _sql_params(sql2)
+        if sql1 != sql2 or params1 != params2:
+            return False
+    return True
+
+
+class MigrationAutodetector(DjangoMigrationAutodetector):
+    """
+    Substitutes Django's MigrationAutodetector class, injecting SQL migrations logic.
+    """
+    def __init__(self, from_state, to_state, questioner=None, to_sql_graph=None):
+        super(MigrationAutodetector, self).__init__(from_state, to_state, questioner)
+        self.to_sql_graph = to_sql_graph
+        self.from_sql_graph = getattr(self.from_state, 'sql_state', None) or SQLStateGraph()
+        self.from_sql_graph.build_graph()
+        self._sql_operations = []
+
+    def assemble_changes(self, keys, resolve_keys, sql_state):
+        """
+        Accepts keys of SQL items available, sorts them and adds additional dependencies.
+        Uses graph of `sql_state` nodes to build `keys` and `resolve_keys` into sequence that
+        starts with leaves (items that have not dependents) and ends with roots.
+
+        Changes `resolve_keys` argument as dependencies are added to the result.
+
+        Args:
+            keys (list): List of migration keys, that are one of create/delete operations, and
+                dont require respective reverse operations.
+            resolve_keys (list): List of migration keys, that are changing existing items,
+                and may require respective reverse operations.
+            sql_sate (graph.SQLStateGraph): State of SQL items.
+        Returns:
+            (list) Sorted sequence of migration keys, enriched with dependencies.
+        """
+        result_keys = []
+        all_keys = keys | resolve_keys
+        for key in all_keys:
+            node = sql_state.node_map[key]
+            sql_item = sql_state.nodes[key]
+            ancs = node.ancestors()[:-1]
+            ancs.reverse()
+            pos = next((i for i, k in enumerate(result_keys) if k in ancs), len(result_keys))
+            result_keys.insert(pos, key)
+
+            if key in resolve_keys and not sql_item.replace:
+                # ancestors() and descendants() include key itself, need to cut it out.
+                descs = reversed(node.descendants()[:-1])
+                for desc in descs:
+                    if desc not in all_keys and desc not in result_keys:
+                        result_keys.insert(pos, desc)
+                        # these items added may also need reverse operations.
+                        resolve_keys.add(desc)
+        return result_keys
+
+    def add_sql_operation(self, app_label, sql_name, operation, dependencies):
+        """
+        Add SQL operation and register it to be used as dependency for further
+        sequential operations.
+        """
+        deps = [(dp[0], SQL_BLOB, dp[1], self._sql_operations.get(dp)) for dp in dependencies]
+
+        self.add_operation(app_label, operation, dependencies=deps)
+        self._sql_operations[(app_label, sql_name)] = operation
+
+    def _generate_reversed_sql(self, keys, changed_keys):
+        """
+        Generate reversed operations for changes, that require full rollback and creation.
+        """
+        for key in keys:
+            if key not in changed_keys:
+                continue
+            app_label, sql_name = key
+            old_item = self.from_sql_graph.nodes[key]
+            new_item = self.to_sql_graph.nodes[key]
+            if not old_item.reverse_sql or old_item.reverse_sql == RunSQL.noop or new_item.replace:
+                continue
+
+            # migrate backwards
+            operation = ReverseAlterSQL(sql_name, old_item.reverse_sql, reverse_sql=old_item.sql)
+            sql_deps = [n.key for n in self.from_sql_graph.node_map[key].children]
+            sql_deps.append(key)
+            self.add_sql_operation(app_label, sql_name, operation, sql_deps)
+
+    def _generate_sql(self, keys, changed_keys):
+        """
+        Generate forward operations for changing/creating SQL items.
+        """
+        for key in reversed(keys):
+            app_label, sql_name = key
+            new_item = self.to_sql_graph.nodes[key]
+            sql_deps = [n.key for n in self.to_sql_graph.node_map[key].parents]
+            reverse_sql = new_item.reverse_sql
+
+            if key in changed_keys:
+                operation_cls = AlterSQL
+                kwargs = {}
+                # in case of replace mode, AlterSQL will hold sql, reverse_sql and
+                # state_reverse_sql, the latter one will be used for building state forward
+                # instead of reverse_sql.
+                if new_item.replace:
+                    kwargs['state_reverse_sql'] = reverse_sql
+                    reverse_sql = self.from_sql_graph.nodes[key].sql
+            else:
+                operation_cls = CreateSQL
+                kwargs = {'dependencies': list(sql_deps)}
+
+            operation = operation_cls(
+                sql_name, new_item.sql, reverse_sql=reverse_sql, **kwargs)
+            sql_deps.append(key)
+            self.add_sql_operation(app_label, sql_name, operation, sql_deps)
+
+    def _generate_altered_sql_dependencies(self, dep_changed_keys):
+        """
+        Generate forward operations for changing/creating SQL item dependencies.
+
+        Dependencies are only in-memory and should be reflecting database dependencies, so
+        changing them in SQL config does not alter database. Such actions are persisted in separate
+        type operation - `AlterSQLState`.
+
+        Args:
+            dep_changed_keys (list): Data about keys, that have their dependencies changed.
+                List of tuples (key, removed depndencies, added_dependencies).
+        """
+        for key, removed_deps, added_deps in dep_changed_keys:
+            app_label, sql_name = key
+            operation = AlterSQLState(sql_name, add_dependencies=tuple(added_deps),
+                                      remove_dependencies=tuple(removed_deps))
+            sql_deps = [key]
+            self.add_sql_operation(app_label, sql_name, operation, sql_deps)
+
+    def _generate_delete_sql(self, delete_keys):
+        """
+        Generate forward delete operations for SQL items.
+        """
+        for key in delete_keys:
+            app_label, sql_name = key
+            old_node = self.from_sql_graph.nodes[key]
+            operation = DeleteSQL(sql_name, old_node.reverse_sql, reverse_sql=old_node.sql)
+            sql_deps = [n.key for n in self.from_sql_graph.node_map[key].children]
+            sql_deps.append(key)
+            self.add_sql_operation(app_label, sql_name, operation, sql_deps)
+
+    def generate_sql_changes(self):
+        """
+        Starting point of this tool, which identifies changes and generates respective
+        operations.
+        """
+        from_keys = set(self.from_sql_graph.nodes.keys())
+        to_keys = set(self.to_sql_graph.nodes.keys())
+        new_keys = to_keys - from_keys
+        delete_keys = from_keys - to_keys
+        changed_keys = set()
+        dep_changed_keys = []
+
+        for key in from_keys & to_keys:
+            old_node = self.from_sql_graph.nodes[key]
+            new_node = self.to_sql_graph.nodes[key]
+
+            # identify SQL changes -- these will alter database.
+            if not is_sql_equal(old_node.sql, new_node.sql):
+                changed_keys.add(key)
+
+            # identify dependencies change
+            old_deps = self.from_sql_graph.dependencies[key]
+            new_deps = self.to_sql_graph.dependencies[key]
+            removed_deps = old_deps - new_deps
+            added_deps = new_deps - old_deps
+            if removed_deps or added_deps:
+                dep_changed_keys.append((key, removed_deps, added_deps))
+
+        # we do basic sort here and inject dependency keys here.
+        # operations built using these keys will properly set operation dependencies which will
+        # enforce django to build/keep a correct order of operations (stable_topological_sort).
+        keys = self.assemble_changes(new_keys, changed_keys, self.to_sql_graph)
+        delete_keys = self.assemble_changes(delete_keys, set(), self.from_sql_graph)
+
+        self._sql_operations = {}
+        self._generate_reversed_sql(keys, changed_keys)
+        self._generate_sql(keys, changed_keys)
+        self._generate_delete_sql(delete_keys)
+        self._generate_altered_sql_dependencies(dep_changed_keys)
+
+    def check_dependency(self, operation, dependency):
+        """
+        Enhances default behavior of method by checking dependency for matching operation.
+        """
+        if isinstance(dependency[1], SQLBlob):
+            # NOTE: we follow the sort order created by `assemble_changes` so we build a fixed chain
+            # of operations. thus we should match exact operation here.
+            return dependency[3] == operation
+        return super(MigrationAutodetector, self).check_dependency(operation, dependency)
+
+    def generate_altered_fields(self):
+        """
+        Injecting point. This is quite awkward, and i'm looking forward Django for having the logic
+        divided into smaller methods/functions for easier enhancement and substitution.
+        So far we're doing all the SQL magic in this method.
+        """
+        result = super(MigrationAutodetector, self).generate_altered_fields()
+        self.generate_sql_changes()
+        return result

Users/brunoalla/.virtualenvs/fes-django-migrate-sql/lib/python3.6/site-packages/migrate_sql/config.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+
+class SQLItem(object):
+    """
+    Represents any SQL entity (unit), for example function, type, index or trigger.
+    """
+    def __init__(self, name, sql, reverse_sql=None, dependencies=None, replace=False):
+        """
+        Args:
+            name (str): Name of the SQL item. Should be unique among other items in the current
+                application. It is the name that other items can refer to.
+            sql (str/tuple): Forward SQL that creates entity.
+            drop_sql (str/tuple, optional): Backward SQL that destroyes entity. (DROPs).
+            dependencies (list, optional): Collection of item keys, that the current one depends on.
+                Each element is a tuple of two: (app, item_name). Order does not matter.
+            replace (bool, optional): If `True`, further migrations will not drop previous version
+                of item before creating, assuming that a forward SQL replaces. For example Postgre's
+                `create or replace function` which does not require dropping it previously.
+                If `False` then each changed item will get two operations: dropping previous version
+                and creating new one.
+                Default = `False`.
+        """
+        self.name = name
+        self.sql = sql
+        self.reverse_sql = reverse_sql
+        self.dependencies = dependencies or []
+        self.replace = replace