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

                    table = col.table

                if table_name:

                    col = '.'.join((col.table.name, col.name))

                else:

                    col = col.name

            colnames.append(col)

        return colnames, table

    def __do_imports(self, visitor_name, *a, **kw):

        engine = kw.pop('engine', self.table.bind)

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

        visitorcallable = get_engine_visitor(engine, visitor_name)

        run_single_visitor(engine, visitorcallable, self, *a, **kw)

    def create(self, *a, **kw):

        """Create the constraint in the database.

        :param engine: the database engine to use. If this is \

        :keyword:`None` the instance's engine will be used

        :type engine: :class:`sqlalchemy.engine.base.Engine`

        :param connection: reuse connection istead of creating new one.

        :type connection: :class:`sqlalchemy.engine.base.Connection` instance

        """

"""

   Firebird database specific implementations of changeset classes.

"""

from sqlalchemy.databases import firebird as sa_base

from rhodecode.lib.dbmigrate.migrate import exceptions

from rhodecode.lib.dbmigrate.migrate.changeset import ansisql, SQLA_06

if SQLA_06:

    FBSchemaGenerator = sa_base.FBDDLCompiler

else:

    FBSchemaGenerator = sa_base.FBSchemaGenerator

class FBColumnGenerator(FBSchemaGenerator, ansisql.ANSIColumnGenerator):

    """Firebird column generator implementation."""

class FBColumnDropper(ansisql.ANSIColumnDropper):

    """Firebird column dropper implementation."""

    def visit_column(self, column):

        """Firebird supports 'DROP col' instead of 'DROP COLUMN col' syntax

        Drop primary key and unique constraints if dropped column is referencing it."""

        if column.primary_key:

            if column.table.primary_key.columns.contains_column(column):

                column.table.primary_key.drop()

                # TODO: recreate primary key if it references more than this column

        self.append('DROP %s' % self.preparer.format_column(column))

        self.execute()

class FBSchemaChanger(ansisql.ANSISchemaChanger):

    """Firebird schema changer implementation."""

    def visit_table(self, table):

        """Rename table not supported"""

        raise exceptions.NotSupportedError(

            "Firebird does not support renaming tables.")

                'SELECT %(cols)s from migration_tmp')%{'cols':columns}

    def visit_column(self,column):

        if column.foreign_keys:

            SQLiteHelper.visit_column(self,column)

        else:

            super(SQLiteColumnGenerator,self).visit_column(column)

class SQLiteColumnDropper(SQLiteHelper, ansisql.ANSIColumnDropper):

    """SQLite ColumnDropper"""

    def _modify_table(self, table, column, delta):

        columns = ' ,'.join(map(self.preparer.format_column, table.columns))

        return 'INSERT INTO %(table_name)s SELECT ' + columns + \

            ' from migration_tmp'

class SQLiteSchemaChanger(SQLiteHelper, ansisql.ANSISchemaChanger):

    """SQLite SchemaChanger"""

    def _modify_table(self, table, column, delta):

        return 'INSERT INTO %(table_name)s SELECT * from migration_tmp'

    def visit_index(self, index):

        """Does not support ALTER INDEX"""

        self._not_supported('ALTER INDEX')

    'create_column',

    'drop_column',

    'alter_column',

    'rename_table',

    'rename_index',

    'ChangesetTable',

    'ChangesetColumn',

    'ChangesetIndex',

    'ChangesetDefaultClause',

    'ColumnDelta',

]

def create_column(column, table=None, *p, **kw):

    """Create a column, given the table.

    API to :meth:`ChangesetColumn.create`.

    """

    if table is not None:

        return table.create_column(column, *p, **kw)

    return column.create(*p, **kw)

def drop_column(column, table=None, *p, **kw):

    """Drop a column, given the table.

    :argument column:

      The name of the column to be altered or a

      :class:`ChangesetColumn` column representing it.

    :param table:

      A :class:`~sqlalchemy.schema.Table` or table name to

      for the table where the column will be changed.

    :param engine:

      The :class:`~sqlalchemy.engine.base.Engine` to use for table

      reflection and schema alterations.

    :returns: A :class:`ColumnDelta` instance representing the change.

    """

    if 'table' not in k and isinstance(p[0], sqlalchemy.Column):

        k['table'] = p[0].table

    if 'engine' not in k:

        k['engine'] = k['table'].bind

    # deprecation

    if len(p) >= 2 and isinstance(p[1], sqlalchemy.Column):

        warnings.warn(

            "Passing a Column object to alter_column is deprecated."

            " Just pass in keyword parameters instead.",

            MigrateDeprecationWarning

            )

    engine = k['engine']

    delta = ColumnDelta(*p, **k)

    visitorcallable = get_engine_visitor(engine, 'schemachanger')

    engine._run_visitor(visitorcallable, delta)

    return delta

def _to_table(table, engine=None):

    """Return if instance of Table, else construct new with metadata"""

    if isinstance(table, sqlalchemy.Table):

        return table

        * **current_column, \*p, \*\*kw**

            Additional parameters alter current_column. Table name is extracted

            from current_column object.

            Name is changed to current_column.name from current_name,

            if current_name is specified.

        * **current_col_name, \*p, \*\*kw**

            Table kw must specified.

        :param table: Table at which current Column should be bound to.\

        If table name is given, reflection will be used.

        :type table: string or Table instance

        :param engine: When reflecting tables, either engine or metadata must \

        be specified to acquire engine object.

        :type engine: :class:`Engine` instance

        :returns: :class:`ColumnDelta` instance provides interface for altered attributes to \

        `result_column` through :func:`dict` alike object.

        * :class:`ColumnDelta`.result_column is altered column with new attributes

        * :class:`ColumnDelta`.current_name is current name of column in db

    """

    # Column attributes that can be altered

    diff_keys = ('name', 'type', 'primary_key', 'nullable',

        'server_onupdate', 'server_default', 'autoincrement')

    diffs = dict()

    __visit_name__ = 'column'

    def __init__(self, *p, **kw):

        self.alter_metadata = kw.pop("alter_metadata", False)

        self.meta = kw.pop("metadata", None)

        self.engine = kw.pop("engine", None)

        # Things are initialized differently depending on how many column

        # parameters are given. Figure out how many and call the appropriate

        # method.

        if len(p) >= 1 and isinstance(p[0], sqlalchemy.Column):

            # At least one column specified

            if len(p) >= 2 and isinstance(p[1], sqlalchemy.Column):

                # Two columns specified

                diffs = self.compare_2_columns(*p, **kw)

            else:

                # Exactly one column specified

                diffs = self.compare_1_column(*p, **kw)

        else:

            # Zero columns specified

            if not len(p) or not isinstance(p[0], basestring):

                raise ValueError("First argument must be column name")

            diffs = self.compare_parameters(*p, **kw)

        self.apply_diffs(diffs)

    def __repr__(self):

    def __getitem__(self, key):

        if key not in self.keys():

        return getattr(self.result_column, key)

    def __setitem__(self, key, value):

        if key not in self.keys():

        setattr(self.result_column, key, value)

    def __delitem__(self, key):

        raise NotImplementedError

    def keys(self):

        return self.diffs.keys()

    def compare_parameters(self, current_name, *p, **k):

        """Compares Column objects with reflection"""

        self.table = k.pop('table')

        self.result_column = self._table.c.get(current_name)

            if isinstance(column.server_default, sqlalchemy.FetchedValue):

                toinit.append(column.server_default)

            else:

                toinit.append(sqlalchemy.DefaultClause(column.server_default))

        if column.server_onupdate is not None:

            if isinstance(column.server_onupdate, FetchedValue):

                toinit.append(column.server_default)

            else:

                toinit.append(sqlalchemy.DefaultClause(column.server_onupdate,

                                            for_update=True))

        if toinit:

            column._init_items(*toinit)

        if not SQLA_06:

            column.args = []

    def _get_table(self):

        return getattr(self, '_table', None)

    def _set_table(self, table):

        if isinstance(table, basestring):

            if self.alter_metadata:

                if not self.meta:

                    raise ValueError("metadata must be specified for table"

                        " reflection when using alter_metadata")

            else:

                if not self.engine and not self.meta:

                    raise ValueError("engine or metadata must be specified"

                        " to reflect tables")

                if not self.engine:

                    self.engine = self.meta.bind

                meta = sqlalchemy.MetaData(bind=self.engine)

            self._table = sqlalchemy.Table(table, meta, autoload=True)

        elif isinstance(table, sqlalchemy.Table):

            self._table = table

            if not self.alter_metadata:

                self._table.meta = sqlalchemy.MetaData(bind=self._table.bind)

    def _get_result_column(self):

        return getattr(self, '_result_column', None)

    def _set_result_column(self, column):

        """Set Column to Table based on alter_metadata evaluation."""

        self.process_column(column)

        if not hasattr(self, 'current_name'):

            self.current_name = column.name

        if self.alter_metadata:

            self._result_column = column

        else:

            self._result_column = column.copy_fixed()

            except AttributeError:

                # That column isn't part of the table. We don't need

                # its entire definition to drop the column, just its

                # name, so create a dummy column with the same name.

                column = sqlalchemy.Column(str(column), sqlalchemy.Integer())

        column.drop(table=self, *p, **kw)

    def rename(self, name, connection=None, **kwargs):

        """Rename this table.

        :param name: New name of the table.

        :type name: string

        :param connection: reuse connection istead of creating new one.

        :type connection: :class:`sqlalchemy.engine.base.Connection` instance

        """

        engine = self.bind

        self.new_name = name

        visitorcallable = get_engine_visitor(engine, 'schemachanger')

        run_single_visitor(engine, visitorcallable, self, connection, **kwargs)

        # Fix metadata registration

    def _meta_key(self):

        return sqlalchemy.schema._get_table_key(self.name, self.schema)

    def deregister(self):

        """Remove this table from its metadata"""

        key = self._meta_key()

        meta = self.metadata

        if key in meta.tables:

            del meta.tables[key]

               primary_key_name=None, populate_default=True, connection=None, **kwargs):

        """Create this column in the database.

        Assumes the given table exists. ``ALTER TABLE ADD COLUMN``,

        for most databases.

        :param table: Table instance to create on.

        :param index_name: Creates :class:`ChangesetIndex` on this column.

        :param unique_name: Creates :class:\

`~migrate.changeset.constraint.UniqueConstraint` on this column.

        :param primary_key_name: Creates :class:\

`~migrate.changeset.constraint.PrimaryKeyConstraint` on this column.

        :param populate_default: If True, created column will be \

populated with defaults

        :param connection: reuse connection istead of creating new one.

        :type table: Table instance

        :type index_name: string

        :type unique_name: string

        :type primary_key_name: string

        :type populate_default: bool

        :type connection: :class:`sqlalchemy.engine.base.Connection` instance

        :returns: self

        """

        self.populate_default = populate_default

        self.index_name = index_name

        self.unique_name = unique_name

        self.primary_key_name = primary_key_name

        for cons in ('index_name', 'unique_name', 'primary_key_name'):

            self._check_sanity_constraints(cons)

        engine = self.table.bind

        visitorcallable = get_engine_visitor(engine, 'columngenerator')

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

        # TODO: reuse existing connection

        if self.populate_default and self.default is not None:

            stmt = table.update().values({self: engine._execute_default(self.default)})

            engine.execute(stmt)

        return self

    def drop(self, table=None, connection=None, **kwargs):

        """Drop this column from the database, leaving its table intact.

        ``ALTER TABLE DROP COLUMN``, for most databases.

        :param connection: reuse connection istead of creating new one.

        :type connection: :class:`sqlalchemy.engine.base.Connection` instance

        """

        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)

        return self

    def add_to_table(self, table):

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

            self._set_parent(table)

        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 col in index.columns:

                    columns.append(col)

            if columns:

            else:

                to_drop.add(index)

        table.indexes = table.indexes - to_drop

        to_drop = set()

        for cons in table.constraints:

            # TODO: deal with other types of constraint

                                UniqueConstraint)):

                for col_name in cons.columns:

                        col_name = col_name.name

                        to_drop.add(cons)

        table.constraints = table.constraints - to_drop

        if table.c.contains_column(self):

            table.c.remove(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,

class ChangesetIndex(object):

    """Changeset extensions to SQLAlchemy Indexes."""

    __visit_name__ = 'index'

    def rename(self, name, connection=None, **kwargs):

        """Change the name of an index.

        :param name: New name of the Index.

        :type name: string

        :param connection: reuse connection istead of creating new one.

        :type connection: :class:`sqlalchemy.engine.base.Connection` instance

        """

        engine = self.table.bind

        self.new_name = name

        visitorcallable = get_engine_visitor(engine, 'schemachanger')

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

class ChangesetDefaultClause(object):

    """Implements comparison between :class:`DefaultClause` instances"""

    def __eq__(self, other):

        if isinstance(other, self.__class__):

            if self.arg == other.arg:

                return True

    def __ne__(self, other):

        return not self.__eq__(other)

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

            out.append("  __tablename__ = '%(table)s'" % {'table': tableName})

            for col in table.columns:

                out.append("  %s" % self.column_repr(col))

        else:

            out.append("%(table)s = Table('%(table)s', meta," % \

                           {'table': tableName})

            for col in table.columns:

                out.append("  %s," % self.column_repr(col))

            out.append(")")

        return out

        to_process = []

                ):

            if bool_:

                for name in names:

                    yield metadata.tables.get(name)

    def toPython(self):

        """Assume database is current and model is empty."""

        out = []

        if self.declarative:

            out.append(DECLARATIVE_HEADER)

        else:

            out.append(HEADER)

        out.append("")

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

            out.extend(self.getTableDefn(table))

            out.append("")

        return '\n'.join(out)

    def toUpgradeDowngradePython(self, indent='    '):

        ''' Assume model is most current and database is out-of-date. '''

        decls = ['from rhodecode.lib.dbmigrate.migrate.changeset import schema',

                 'meta = MetaData()']

        for table in self._get_tables(

            ):

            decls.extend(self.getTableDefn(table))

        upgradeCommands, downgradeCommands = [], []

        for tableName in self.diff.tables_missing_from_A:

            upgradeCommands.append("%(table)s.drop()" % {'table': tableName})

            downgradeCommands.append("%(table)s.create()" % \

                                         {'table': tableName})

        for tableName in self.diff.tables_missing_from_B:

            upgradeCommands.append("%(table)s.create()" % {'table': tableName})

            downgradeCommands.append("%(table)s.drop()" % {'table': tableName})

            for col in missingInDatabase:

                upgradeCommands.append('%s.columns[%r].create()' % (

                        modelTable, col.name))

                downgradeCommands.append('%s.columns[%r].drop()' % (

                        modelTable, col.name))

            for col in missingInModel:

                upgradeCommands.append('%s.columns[%r].drop()' % (

                        modelTable, col.name))

                downgradeCommands.append('%s.columns[%r].create()' % (

                        modelTable, col.name))

            for modelCol, databaseCol, modelDecl, databaseDecl in diffDecl:

                upgradeCommands.append(

                downgradeCommands.append(

        pre_command = '    meta.bind = migrate_engine'

        return (

            '\n'.join(decls),

            '\n'.join([pre_command] + ['%s%s' % (indent, line) for line in upgradeCommands]),

            '\n'.join([pre_command] + ['%s%s' % (indent, line) for line in downgradeCommands]))

        if (td.columns_missing_from_B

            and not td.columns_missing_from_A

            and not td.columns_different):

            # Even sqlite can handle this.

            return True

        else:

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

    def applyModel(self):

        """Apply model to current database."""

        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)

            dbTable = self.diff.metadataB.tables[tableName]

            td = self.diff.tables_different[tableName]

            if self._db_can_handle_this_change(td):

                for col in td.columns_missing_from_B:

                    modelTable.columns[col].create()

                for col in td.columns_missing_from_A:

                    dbTable.columns[col].drop()

                # XXX handle column changes here.

            else:

                # Sqlite doesn't support drop column, so you have to

                # do more: create temp table, copy data to it, drop

                # old table, create new table, copy data back.

                #

                # I wonder if this is guaranteed to be unique?

                tempName = '_temp_%s' % modelTable.name

#!/usr/bin/env python

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

import shutil

import warnings

import logging

from StringIO import StringIO

from rhodecode.lib.dbmigrate import migrate

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

from rhodecode.lib.dbmigrate.migrate.versioning.config import operations

from rhodecode.lib.dbmigrate.migrate.versioning.template import Template

from rhodecode.lib.dbmigrate.migrate.versioning.script import base

from rhodecode.lib.dbmigrate.migrate.versioning.util import import_path, load_model, with_engine

from rhodecode.lib.dbmigrate.migrate.exceptions import MigrateDeprecationWarning, InvalidScriptError, ScriptError

log = logging.getLogger(__name__)

__all__ = ['PythonScript']

        :param repository: path to migrate repository

        :param oldmodel: dotted.module.name:SAClass or SAClass object

        :param model: dotted.module.name:SAClass or SAClass object

        :param engine: SQLAlchemy engine

        :type repository: string or :class:`Repository instance <migrate.versioning.repository.Repository>`

        :type oldmodel: string or Class

        :type model: string or Class

        :type engine: Engine instance

        :returns: Upgrade / Downgrade script

        :rtype: string

        """

        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,

            model,

            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)

        :type step: int

        """

        if step > 0:

            op = 'upgrade'

        elif step < 0:

            op = 'downgrade'

        else:

            raise ScriptError("%d is not a valid step" % step)

        funcname = base.operations[op]

        script_func = self._func(funcname)

    @property

    def module(self):

        """Calls :meth:`migrate.versioning.script.py.verify_module`

        and returns it.

        """

        if not hasattr(self, '_module'):

            self._module = self.verify_module(self.path)

        return self._module

    def _func(self, funcname):

        if not hasattr(self.module, funcname):

log = logging.getLogger(__name__)

class SqlScript(base.BaseScript):

    """A file containing plain SQL statements."""

    @classmethod

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

        """Create an empty migration script at specified path

        :returns: :class:`SqlScript instance <migrate.versioning.script.sql.SqlScript>`"""

        cls.require_notfound(path)

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

        shutil.copy(src, path)

        return cls(path)

    # TODO: why is step parameter even here?

    def run(self, engine, step=None, executemany=True):

        """Runs SQL script through raw dbapi execute call"""

        text = self.source()

        # Don't rely on SA's autocommit here

        # (SA uses .startswith to check if a commit is needed. What if script

        # starts with a comment?)

        conn = engine.connect()