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

            for cons in column.table.constraints:

                    # TODO: recreate unique constraint if it refenrences 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():

            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

            self.name = name

            self.deregister()

            self._set_parent(self.metadata)

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

            self.add_to_table(table)

        engine = self.table.bind

        visitorcallable = get_engine_visitor(engine, 'columngenerator')

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

            self.table = None

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

            self.name = name

                        modelTable, col.name))

            for modelCol, databaseCol, modelDecl, databaseDecl in diffDecl:

                upgradeCommands.append(

                downgradeCommands.append(

        pre_command = '    meta.bind = migrate_engine'

        return (

import shutil

import warnings

import logging

from StringIO import StringIO

from rhodecode.lib.dbmigrate import migrate

        funcname = base.operations[op]

        script_func = self._func(funcname)

            script_func(engine)

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