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)

   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 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()

    """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"""

    'ColumnDelta',

]

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

    """Create a column, given the table.

      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:

            MigrateDeprecationWarning

            )

    engine = k['engine']

    delta = ColumnDelta(*p, **k)

    visitorcallable = get_engine_visitor(engine, 'schemachanger')

        :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

    __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)

        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):

                                            for_update=True))

        if toinit:

            column._init_items(*toinit)

        if not SQLA_06:

            column.args = []

            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)

        :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)

`~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 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)

        ``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)

        :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):

            out.append(")")

        return out

        to_process = []

                ):

            if bool_:

                for name in names:

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

                 'meta = MetaData()']

        for table in self._get_tables(

            ):

            decls.extend(self.getTableDefn(table))

                        modelTable, col.name))

            for modelCol, databaseCol, modelDecl, databaseDecl in diffDecl:

                upgradeCommands.append(

                downgradeCommands.append(

        pre_command = '    meta.bind = migrate_engine'

        return (

            '\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):

            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:

import shutil

import warnings

import logging

from StringIO import StringIO

from rhodecode.lib.dbmigrate import migrate

        :returns: Upgrade / Downgrade script

        :rtype: string

        """

        if isinstance(repository, basestring):

            # oh dear, an import cycle!

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

            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))

        funcname = base.operations[op]

        script_func = self._func(funcname)

    @property

    def module(self):

        :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)

        %s

    Enter "%%prog help COMMAND" for information on a particular command.

    parser = PassiveOptionParser(usage=usage)

    parser.add_option("-d", "--debug",

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

        """Calls self._get_item('repository', *a, **kw)"""

        return self._get_item('repository', *a, **kw)

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

        """Calls self._get_item('script', *a, **kw)"""

        return self._get_item('script', *a, **kw)