"""

   SQLAlchemy migrate provides two APIs :mod:`migrate.versioning` for

   database schema version and repository management and

   :mod:`migrate.changeset` that allows to define database schema changes

   using Python.

"""

from rhodecode.lib.dbmigrate.migrate.versioning import *

from rhodecode.lib.dbmigrate.migrate.changeset import *

   support.

   .. [#] SQL Data Definition Language

"""

import re

import warnings

import sqlalchemy

from sqlalchemy import __version__ as _sa_version

warnings.simplefilter('always', DeprecationWarning)

                    for x in _sa_version.split("."))

SQLA_06 = _sa_version >= (0, 6)

del re

del _sa_version

from rhodecode.lib.dbmigrate.migrate.changeset.schema import *

from rhodecode.lib.dbmigrate.migrate.changeset.constraint import *

sqlalchemy.schema.Table.__bases__ += (ChangesetTable,)

sqlalchemy.schema.Column.__bases__ += (ChangesetColumn,)

sqlalchemy.schema.Index.__bases__ += (ChangesetIndex,)

sqlalchemy.schema.DefaultClause.__bases__ += (ChangesetDefaultClause,)

   Schema module providing common schema operations.

"""

import warnings

from UserDict import DictMixin

import sqlalchemy

from sqlalchemy.schema import ForeignKeyConstraint

from sqlalchemy.schema import UniqueConstraint

from rhodecode.lib.dbmigrate.migrate.exceptions import *

from rhodecode.lib.dbmigrate.migrate.changeset.databases.visitor import (get_engine_visitor,

__all__ = [

    'create_column',

    'drop_column',

    'alter_column',

    'rename_table',

    'rename_index',

    'ChangesetTable',

    'ChangesetColumn',

    'ChangesetIndex',

    'ChangesetDefaultClause',

        """

        if table is not None:

            self.table = table

        engine = self.table.bind

        visitorcallable = get_engine_visitor(engine, 'columndropper')

        engine._run_visitor(visitorcallable, self, connection, **kwargs)

        self.remove_from_table(self.table, unset_table=False)

        self.table = None

        return self

    def add_to_table(self, table):

        if table is not None  and self.table is None:

    def _col_name_in_constraint(self,cons,name):

        return False

    def remove_from_table(self, table, unset_table=True):

        # TODO: remove primary keys, constraints, etc

        if unset_table:

            self.table = None

        to_drop = set()

        for index in table.indexes:

            columns = []

        for cons in table.constraints:

            # TODO: deal with other types of constraint

            if isinstance(cons,(ForeignKeyConstraint,

                                UniqueConstraint)):

                for col_name in cons.columns:

                    if not isinstance(col_name,basestring):

                        col_name = col_name.name

                    if self.name==col_name:

                        to_drop.add(cons)

        table.constraints = table.constraints - to_drop

        if table.c.contains_column(self):

    # TODO: this is fixed in 0.6

    def copy_fixed(self, **kw):

        """Create a copy of this ``Column``, with all attributes."""

        return sqlalchemy.Column(self.name, self.type, self.default,

            key=self.key,

            primary_key=self.primary_key,

            nullable=self.nullable,

            quote=self.quote,

            index=self.index,

            unique=self.unique,

            onupdate=self.onupdate,

class InvalidRepositoryError(RepositoryError):

    """Invalid repository error."""

class ScriptError(Error):

    """Base class for script errors."""

class InvalidScriptError(ScriptError):

    """Invalid script error."""

class NotSupportedError(Error):

    """Not supported error"""

class InvalidConstraintError(Error):

    """Invalid constraint error"""

class MigrateDeprecationWarning(DeprecationWarning):

    """Warning for deprecated features in Migrate"""

    Create an empty change script using the next unused version number

    appended with the given description.

    For instance, manage.py script "Add initial tables" creates:

    repository/versions/001_Add_initial_tables.py

    """

    repo = Repository(repository)

    repo.create_script(description, **opts)

@catch_known_errors

    Create empty change SQL scripts for given DATABASE, where DATABASE

    or generic ('default').

    """

    repo = Repository(repository)

def version(repository, **opts):

    """%prog version REPOSITORY_PATH

    Display the latest version available in a repository.

    """

    repo = Repository(repository)

    return repo.latest

@with_engine

"""

"""

import sys

import logging

import sqlalchemy

from rhodecode.lib.dbmigrate import migrate

from rhodecode.lib.dbmigrate.migrate import changeset

log = logging.getLogger(__name__)

HEADER = """

## File autogenerated by genmodel.py

from sqlalchemy import *

meta = MetaData()

"""

DECLARATIVE_HEADER = """

## File autogenerated by genmodel.py

from sqlalchemy import *

from sqlalchemy.ext import declarative

Base = declarative.declarative_base()

"""

class ModelGenerator(object):

    def __init__(self, diff, engine, declarative=False):

        self.diff = diff

        self.engine = engine

        self.declarative = declarative

    def column_repr(self, col):

        kwarg = []

        if col.key != col.name:

            kwarg.append('key')

        if col.primary_key:

            col.primary_key = True  # otherwise it dumps it as 1

        if not col.nullable:

            kwarg.append('nullable')

        if col.onupdate:

            kwarg.append('onupdate')

        if col.default:

            if col.primary_key:

                # I found that PostgreSQL automatically creates a

                # default value for the sequence, but let's not show

                # that.

                pass

            else:

                kwarg.append('default')

        # crs: not sure if this is good idea, but it gets rid of extra

        # u''

        name = col.name.encode('utf8')

        type_ = col.type

        for cls in col.type.__class__.__mro__:

            if cls.__module__ == 'sqlalchemy.types' and \

                not cls.__name__.isupper():

                if cls is not type_.__class__:

                    type_ = cls()

                break

        data = {

            'name': name,

        else:

        out = []

        tableName = table.name

        if self.declarative:

            out.append("class %(table)s(Base):" % {'table': tableName})

            for col in table.columns:

        else:

            for col in table.columns:

        return out

    def _get_tables(self,missingA=False,missingB=False,modified=False):

        to_process = []

        for bool_,names,metadata in (

            (missingA,self.diff.tables_missing_from_A,self.diff.metadataB),

            (missingB,self.diff.tables_missing_from_B,self.diff.metadataA),

            (modified,self.diff.tables_different,self.diff.metadataA),

                ):

            if bool_:

                for name in names:

                    yield metadata.tables.get(name)

        out = []

        if self.declarative:

            out.append(DECLARATIVE_HEADER)

        else:

            out.append(HEADER)

        out.append("")

        for table in self._get_tables(missingA=True):

        return '\n'.join(out)

                upgradeCommands.append(

                    'assert False, "Can\'t alter columns: %s:%s=>%s"' % (

                downgradeCommands.append(

                    'assert False, "Can\'t alter columns: %s:%s=>%s"' % (

        return (

            '\n'.join(decls),

    def _db_can_handle_this_change(self,td):

        if (td.columns_missing_from_B

            and not td.columns_missing_from_A

            and not td.columns_different):

            return True

        else:

            return not self.engine.url.drivername.startswith('sqlite')

        meta = sqlalchemy.MetaData(self.engine)

        for table in self._get_tables(missingA=True):

            table = table.tometadata(meta)

            table.drop()

        for table in self._get_tables(missingB=True):

            table = table.tometadata(meta)

            table.create()

        for modelTable in self._get_tables(modified=True):

            tableName = modelTable.name

            modelTable = modelTable.tometadata(meta)

                        'CREATE TEMPORARY TABLE %s as SELECT * from %s' % \

                            (tempName, modelTable.name))

                    # make sure the drop takes place inside our

                    # transaction with the bind parameter

                    modelTable.drop(bind=connection)

                    modelTable.create(bind=connection)

                    connection.execute(getCopyStatement())

                    connection.execute('DROP TABLE %s' % tempName)

                    trans.commit()

                except:

                    trans.rollback()

                    raise

        :param config_file: Name of the config file in Repository template

        :param name: Repository name

        :type tmpl_dir: string

        :type config_file: string

        :type name: string

        :returns: Populated config file

        """

        if options is None:

            options = {}

        options.setdefault('version_table', 'migrate_version')

        options.setdefault('repository_id', name)

        options.setdefault('required_dbs', [])

        tmpl = open(os.path.join(tmpl_dir, cls._config)).read()

        ret = TempitaTemplate(tmpl).substitute(options)

        # cleanup

        del options['__template_name__']

        return ret

    @classmethod

    def create(cls, path, name, **opts):

        """Create a repository at a specified path"""

        opts['repository_name'] = name

        # Create a management script

        manager = os.path.join(path, 'manage.py')

        Repository.create_manage_file(manager, templates_theme=theme,

            templates_path=t_path, **opts)

        return cls(path)

    def create_script(self, description, **k):

        """API to :meth:`migrate.versioning.version.Collection.create_new_python_version`"""

        self.versions.create_new_python_version(description, **k)

        """API to :meth:`migrate.versioning.version.Collection.create_new_sql_version`"""

    @property

    def latest(self):

        """API to :attr:`migrate.versioning.version.Collection.latest`"""

        return self.versions.latest

    @property

    def version_table(self):

        """Returns version_table name specified in config"""

        return self.config.get('db_settings', 'version_table')

    @property

    def id(self):

        """Returns repository id specified in config"""

        return self.config.get('db_settings', 'repository_id')

    def version(self, *p, **k):

        """API to :attr:`migrate.versioning.version.Collection.version`"""

        return self.versions.version(*p, **k)

    @classmethod

    def clear(cls):

        # TODO: deletes repo

        super(Repository, cls).clear()

        version.Collection.clear()

    def changeset(self, database, start, end=None):

        """Create a changeset to migrate this database from ver. start to end/latest.

   Database schema version management.

"""

import sys

import logging

from sqlalchemy import (Table, Column, MetaData, String, Text, Integer,

    create_engine)

from sqlalchemy.sql import and_

from sqlalchemy import exceptions as sa_exceptions

from sqlalchemy.sql import bindparam

from rhodecode.lib.dbmigrate.migrate import exceptions

from rhodecode.lib.dbmigrate.migrate.versioning import genmodel, schemadiff

from rhodecode.lib.dbmigrate.migrate.versioning.repository import Repository

from rhodecode.lib.dbmigrate.migrate.versioning.util import load_model

from rhodecode.lib.dbmigrate.migrate.versioning.version import VerNum

log = logging.getLogger(__name__)

class ControlledSchema(object):

    """A database under version control"""

    def __init__(self, engine, repository):

            data = list(result)[0]

        except:

            cls, exc, tb = sys.exc_info()

            raise exceptions.DatabaseNotControlledError, exc.__str__(), tb

        self.version = data['version']

        return data

    def drop(self):

        """

        Remove version control from a database.

        """

    def changeset(self, version=None):

        """API to Changeset creation.

        Uses self.version for start version and engine.name

        to get database name.

        """

        database = self.engine.name

        start_ver = self.version

        changeset = self.repository.changeset(database, start_ver, version)

        return changeset

        for ver, change in changeset:

            self.runchange(ver, change, changeset.step)

    def update_db_from_model(self, model):

        """

        Modify the database to match the structure of the current Python model.

        """

        model = load_model(model)

        diff = schemadiff.getDiffOfModelAgainstDatabase(

            model, self.engine, excludeTables=[self.repository.version_table]

            )

        self.update_repository_table(self.version, int(self.repository.latest))

        self.load()

    @classmethod

    def create(cls, engine, repository, version=None):

        """

        Declare a database to be under a repository's version control.

        :raises: :exc:`DatabaseAlreadyControlledError`

        :returns: :class:`ControlledSchema`

    @classmethod

    def create_model(cls, engine, repository, declarative=False):

        """

        Dump the current database as a Python model.

        """

        if isinstance(repository, basestring):

            repository = Repository(repository)

        diff = schemadiff.getDiffOfModelAgainstDatabase(

            MetaData(), engine, excludeTables=[repository.version_table]

            )

        """

        if isinstance(repository, basestring):

            # oh dear, an import cycle!

            from rhodecode.lib.dbmigrate.migrate.versioning.repository import Repository

            repository = Repository(repository)

        oldmodel = load_model(oldmodel)

        model = load_model(model)

        # Compute differences.

        diff = schemadiff.getDiffOfModelAgainstModel(

            oldmodel,

            excludeTables=[repository.version_table])

        # TODO: diff can be False (there is no difference?)

        decls, upgradeCommands, downgradeCommands = \

        # Store differences into file.

        src = Template(opts.pop('templates_path', None)).get_script(opts.pop('templates_theme', None))

        f = open(src)

        contents = f.read()

        f.close()

        # generate source

        search = 'def upgrade(migrate_engine):'

        contents = contents.replace(search, '\n\n'.join((decls, search)), 1)

        if upgradeCommands:

            contents = contents.replace('    pass', upgradeCommands, 1)

# change the table name in each database too. 

version_table={{ locals().pop('version_table') }}

# When committing a change script, Migrate will attempt to generate the 

# sql for all supported databases; normally, if one of them fails - probably

# because you don't have that database installed - it is ignored and the 

# commit continues, perhaps ending successfully. 

# Databases in this list MUST compile successfully during a commit, or the 

# entire commit will fail. List the databases your application will actually 

# be using to ensure your updates to that database work properly.

# This must be a list; example: ['postgres','sqlite']

required_dbs={{ locals().pop('required_dbs') }}

#!/usr/bin/env python

# -*- coding: utf-8 -*-

import os

import re

import shutil

import logging

from rhodecode.lib.dbmigrate.migrate import exceptions

from rhodecode.lib.dbmigrate.migrate.versioning import pathed, script

log = logging.getLogger(__name__)

class VerNum(object):

    """A version number that behaves like a string and int at the same time"""

    _instances = dict()

    def __new__(cls, value):

        val = str(value)

        if val not in cls._instances:

class Collection(pathed.Pathed):

    """A collection of versioning scripts in a repository"""

    FILENAME_WITH_VERSION = re.compile(r'^(\d{3,}).*')

    def __init__(self, path):

        """Collect current version scripts in repository

        and store them in self.versions

        """

        super(Collection, self).__init__(path)

        # Create temporary list of files, allowing skipped version numbers.

        files = os.listdir(path)

        if '1' in files:

            # deprecation

            raise Exception('It looks like you have a repository in the old '

                'format (with directories for each version). '

                'Please convert repository before proceeding.')

        tempVersions = dict()

        for filename in files:

            match = self.FILENAME_WITH_VERSION.match(filename)

            if match:

        # Create the versions member where the keys

        # are VerNum's and the values are Version's.

        self.versions = dict()

        for num, files in tempVersions.items():

            self.versions[VerNum(num)] = Version(num, path, files)

    @property

    def latest(self):

        """:returns: Latest version in Collection"""

        return max([VerNum(0)] + self.versions.keys())