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

"""

    rhodecode.lib.dbmigrate.__init__

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Database migration modules

    :created_on: Dec 11, 2010

    :author: marcink

    :copyright: (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>    

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

from rhodecode.lib.utils import BasePasterCommand

from rhodecode.lib.utils import BasePasterCommand, Command, add_cache

from sqlalchemy import engine_from_config

class UpgradeDb(BasePasterCommand):

    """Command used for paster to upgrade our database to newer version

    """

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    summary = "Upgrades current db to newer version given configuration file"

    group_name = "RhodeCode"

    parser = Command.standard_parser(verbose=True)

    def command(self):

        from pylons import config

        add_cache(config)

        engine = engine_from_config(config, 'sqlalchemy.db1.')

        print engine

        raise NotImplementedError('Not implemented yet')

    def update_parser(self):

        self.parser.add_option('--sql',

                      action='store_true',

                      dest='just_sql',

                      help="Prints upgrade sql for further investigation",

                      default=False)

"""

   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 migrate.versioning import *

from migrate.changeset import *

"""

   This module extends SQLAlchemy and provides additional DDL [#]_

   support.

   .. [#] SQL Data Definition Language

"""

import re

import warnings

import sqlalchemy

from sqlalchemy import __version__ as _sa_version

warnings.simplefilter('always', DeprecationWarning)

_sa_version = tuple(int(re.match("\d+", x).group(0)) for x in _sa_version.split("."))

SQLA_06 = _sa_version >= (0, 6)

del re

del _sa_version

from migrate.changeset.schema import *

from migrate.changeset.constraint import *

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

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

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

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

"""

   Extensions to SQLAlchemy for altering existing tables.

   At the moment, this isn't so much based off of ANSI as much as

   things that just happen to work with multiple databases.

"""

import StringIO

import sqlalchemy as sa

from sqlalchemy.schema import SchemaVisitor

from sqlalchemy.engine.default import DefaultDialect

from sqlalchemy.sql import ClauseElement

from sqlalchemy.schema import (ForeignKeyConstraint,

                               PrimaryKeyConstraint,

                               CheckConstraint,

                               UniqueConstraint,

                               Index)

from migrate import exceptions

from migrate.changeset import constraint, SQLA_06

if not SQLA_06:

    from sqlalchemy.sql.compiler import SchemaGenerator, SchemaDropper

else:

    from sqlalchemy.schema import AddConstraint, DropConstraint

    from sqlalchemy.sql.compiler import DDLCompiler

    SchemaGenerator = SchemaDropper = DDLCompiler

class AlterTableVisitor(SchemaVisitor):

    """Common operations for ``ALTER TABLE`` statements."""

    if SQLA_06:

        # engine.Compiler looks for .statement

        # when it spawns off a new compiler

        statement = ClauseElement()

    def append(self, s):

        """Append content to the SchemaIterator's query buffer."""

        self.buffer.write(s)

    def execute(self):

        """Execute the contents of the SchemaIterator's buffer."""

        try:

            return self.connection.execute(self.buffer.getvalue())

        finally:

            self.buffer.truncate(0)

    def __init__(self, dialect, connection, **kw):

        self.connection = connection

        self.buffer = StringIO.StringIO()

        self.preparer = dialect.identifier_preparer

        self.dialect = dialect

    def traverse_single(self, elem):

        ret = super(AlterTableVisitor, self).traverse_single(elem)

        if ret:

            # adapt to 0.6 which uses a string-returning

            # object

            self.append(" %s" % ret)

    def _to_table(self, param):

        """Returns the table object for the given param object."""

        if isinstance(param, (sa.Column, sa.Index, sa.schema.Constraint)):

            ret = param.table

        else:

            ret = param

        return ret

    def start_alter_table(self, param):

        """Returns the start of an ``ALTER TABLE`` SQL-Statement.

        Use the param object to determine the table name and use it

        for building the SQL statement.

        :param param: object to determine the table from

        :type param: :class:`sqlalchemy.Column`, :class:`sqlalchemy.Index`,

          :class:`sqlalchemy.schema.Constraint`, :class:`sqlalchemy.Table`,

          or string (table name)

        """

        table = self._to_table(param)

        self.append('\nALTER TABLE %s ' % self.preparer.format_table(table))

        return table

class ANSIColumnGenerator(AlterTableVisitor, SchemaGenerator):

    """Extends ansisql generator for column creation (alter table add col)"""

    def visit_column(self, column):

        """Create a column (table already exists).

        :param column: column object

        :type column: :class:`sqlalchemy.Column` instance

        """

        if column.default is not None:

            self.traverse_single(column.default)

        table = self.start_alter_table(column)

        self.append("ADD ")

        self.append(self.get_column_specification(column))

        for cons in column.constraints:

            self.traverse_single(cons)

        self.execute()

        # ALTER TABLE STATEMENTS

        # add indexes and unique constraints

        if column.index_name:

            Index(column.index_name,column).create()

        elif column.unique_name:

            constraint.UniqueConstraint(column,

                                        name=column.unique_name).create()

        # SA bounds FK constraints to table, add manually

        for fk in column.foreign_keys:

            self.add_foreignkey(fk.constraint)

        # add primary key constraint if needed

        if column.primary_key_name:

            cons = constraint.PrimaryKeyConstraint(column,

                                                   name=column.primary_key_name)

            cons.create()

    if SQLA_06:

        def add_foreignkey(self, fk):

            self.connection.execute(AddConstraint(fk))

class ANSIColumnDropper(AlterTableVisitor, SchemaDropper):

    """Extends ANSI SQL dropper for column dropping (``ALTER TABLE

    DROP COLUMN``).

    """

    def visit_column(self, column):

        """Drop a column from its table.

        :param column: the column object

        :type column: :class:`sqlalchemy.Column`

        """

        table = self.start_alter_table(column)

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

        self.execute()

class ANSISchemaChanger(AlterTableVisitor, SchemaGenerator):

    """Manages changes to existing schema elements.

    Note that columns are schema elements; ``ALTER TABLE ADD COLUMN``

    is in SchemaGenerator.

    All items may be renamed. Columns can also have many of their properties -

    type, for example - changed.

    Each function is passed a tuple, containing (object, name); where

    object is a type of object you'd expect for that function

    (ie. table for visit_table) and name is the object's new

    name. NONE means the name is unchanged.

    """

    def visit_table(self, table):

        """Rename a table. Other ops aren't supported."""

        self.start_alter_table(table)

        self.append("RENAME TO %s" % self.preparer.quote(table.new_name,

                                                         table.quote))

        self.execute()

    def visit_index(self, index):

        """Rename an index"""

        if hasattr(self, '_validate_identifier'):

            # SA <= 0.6.3

            self.append("ALTER INDEX %s RENAME TO %s" % (

                    self.preparer.quote(

                        self._validate_identifier(

                            index.name, True), index.quote),

                    self.preparer.quote(

                        self._validate_identifier(

                            index.new_name, True), index.quote)))

        else:

            # SA >= 0.6.5

            self.append("ALTER INDEX %s RENAME TO %s" % (

                    self.preparer.quote(

                        self._index_identifier(

                            index.name), index.quote),

                    self.preparer.quote(

                        self._index_identifier(

                            index.new_name), index.quote)))

        self.execute()

    def visit_column(self, delta):

        """Rename/change a column."""

        # ALTER COLUMN is implemented as several ALTER statements

        keys = delta.keys()

        if 'type' in keys:

            self._run_subvisit(delta, self._visit_column_type)

        if 'nullable' in keys:

            self._run_subvisit(delta, self._visit_column_nullable)

        if 'server_default' in keys:

            # Skip 'default': only handle server-side defaults, others

            # are managed by the app, not the db.

            self._run_subvisit(delta, self._visit_column_default)

        if 'name' in keys:

            self._run_subvisit(delta, self._visit_column_name, start_alter=False)

    def _run_subvisit(self, delta, func, start_alter=True):

        """Runs visit method based on what needs to be changed on column"""

        table = self._to_table(delta.table)

        col_name = delta.current_name

        if start_alter:

            self.start_alter_column(table, col_name)

        ret = func(table, delta.result_column, delta)

        self.execute()

    def start_alter_column(self, table, col_name):

        """Starts ALTER COLUMN"""

        self.start_alter_table(table)

        self.append("ALTER COLUMN %s " % self.preparer.quote(col_name, table.quote))

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

        nullable = delta['nullable']

        if nullable:

            self.append("DROP NOT NULL")

        else:

            self.append("SET NOT NULL")

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

        default_text = self.get_column_default_string(column)

        if default_text is not None:

            self.append("SET DEFAULT %s" % default_text)

        else:

            self.append("DROP DEFAULT")

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

        type_ = delta['type']

        if SQLA_06:

            type_text = str(type_.compile(dialect=self.dialect))

        else:

            type_text = type_.dialect_impl(self.dialect).get_col_spec()

        self.append("TYPE %s" % type_text)

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

        self.start_alter_table(table)

        col_name = self.preparer.quote(delta.current_name, table.quote)

        new_name = self.preparer.format_column(delta.result_column)

        self.append('RENAME COLUMN %s TO %s' % (col_name, new_name))

class ANSIConstraintCommon(AlterTableVisitor):

    """

    Migrate's constraints require a separate creation function from

    SA's: Migrate's constraints are created independently of a table;

    SA's are created at the same time as the table.

    """

    def get_constraint_name(self, cons):

        """Gets a name for the given constraint.

        If the name is already set it will be used otherwise the

        constraint's :meth:`autoname <migrate.changeset.constraint.ConstraintChangeset.autoname>`

        method is used.

        :param cons: constraint object

        """

        if cons.name is not None:

            ret = cons.name

        else:

            ret = cons.name = cons.autoname()

        return self.preparer.quote(ret, cons.quote)

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

        self._visit_constraint(*p, **k)

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

        self._visit_constraint(*p, **k)

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

        self._visit_constraint(*p, **k)

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

        self._visit_constraint(*p, **k)

if SQLA_06:

    class ANSIConstraintGenerator(ANSIConstraintCommon, SchemaGenerator):

        def _visit_constraint(self, constraint):

            constraint.name = self.get_constraint_name(constraint)

            self.append(self.process(AddConstraint(constraint)))

            self.execute()

    class ANSIConstraintDropper(ANSIConstraintCommon, SchemaDropper):

        def _visit_constraint(self, constraint):

            constraint.name = self.get_constraint_name(constraint)

            self.append(self.process(DropConstraint(constraint, cascade=constraint.cascade)))

            self.execute()

else:

    class ANSIConstraintGenerator(ANSIConstraintCommon, SchemaGenerator):

        def get_constraint_specification(self, cons, **kwargs):

            """Constaint SQL generators.

            We cannot use SA visitors because they append comma.

            """

            if isinstance(cons, PrimaryKeyConstraint):

                if cons.name is not None:

                    self.append("CONSTRAINT %s " % self.preparer.format_constraint(cons))

                self.append("PRIMARY KEY ")

                self.append("(%s)" % ', '.join(self.preparer.quote(c.name, c.quote)

                                               for c in cons))

                self.define_constraint_deferrability(cons)

            elif isinstance(cons, ForeignKeyConstraint):

                self.define_foreign_key(cons)

            elif isinstance(cons, CheckConstraint):

                if cons.name is not None:

                    self.append("CONSTRAINT %s " %

                                self.preparer.format_constraint(cons))

                self.append("CHECK (%s)" % cons.sqltext)

                self.define_constraint_deferrability(cons)

            elif isinstance(cons, UniqueConstraint):

                if cons.name is not None:

                    self.append("CONSTRAINT %s " %

                                self.preparer.format_constraint(cons))

                self.append("UNIQUE (%s)" % \

                    (', '.join(self.preparer.quote(c.name, c.quote) for c in cons)))

                self.define_constraint_deferrability(cons)

            else:

                raise exceptions.InvalidConstraintError(cons)

        def _visit_constraint(self, constraint):

            table = self.start_alter_table(constraint)

            constraint.name = self.get_constraint_name(constraint)

            self.append("ADD ")

            self.get_constraint_specification(constraint)

            self.execute()

    class ANSIConstraintDropper(ANSIConstraintCommon, SchemaDropper):

        def _visit_constraint(self, constraint):

            self.start_alter_table(constraint)

            self.append("DROP CONSTRAINT ")

            constraint.name = self.get_constraint_name(constraint)

            self.append(self.preparer.format_constraint(constraint))

            if constraint.cascade:

                self.cascade_constraint(constraint)

            self.execute()

        def cascade_constraint(self, constraint):

            self.append(" CASCADE")

class ANSIDialect(DefaultDialect):

    columngenerator = ANSIColumnGenerator

    columndropper = ANSIColumnDropper

    schemachanger = ANSISchemaChanger

    constraintgenerator = ANSIConstraintGenerator

    constraintdropper = ANSIConstraintDropper

"""

   This module defines standalone schema constraint classes.

"""

from sqlalchemy import schema

from migrate.exceptions import *

from migrate.changeset import SQLA_06

class ConstraintChangeset(object):

    """Base class for Constraint classes."""

    def _normalize_columns(self, cols, table_name=False):

        """Given: column objects or names; return col names and

        (maybe) a table"""

        colnames = []

        table = None

        for col in cols:

            if isinstance(col, schema.Column):

                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 migrate.changeset.databases.visitor import (get_engine_visitor,

                                                         run_single_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

        """

        # TODO: set the parent here instead of in __init__

        self.__do_imports('constraintgenerator', *a, **kw)

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

        """Drop the constraint from the database.

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

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

        :param cascade: Issue CASCADE drop if database supports it

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

        :type cascade: bool

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

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

        :returns: Instance with cleared columns

        """

        self.cascade = kw.pop('cascade', False)

        self.__do_imports('constraintdropper', *a, **kw)

        # the spirit of Constraint objects is that they

        # are immutable (just like in a DB.  they're only ADDed

        # or DROPped).

        #self.columns.clear()

        return self

class PrimaryKeyConstraint(ConstraintChangeset, schema.PrimaryKeyConstraint):

    """Construct PrimaryKeyConstraint

    Migrate's additional parameters:

    :param cols: Columns in constraint.

    :param table: If columns are passed as strings, this kw is required

    :type table: Table instance

    :type cols: strings or Column instances

    """

    __migrate_visit_name__ = 'migrate_primary_key_constraint'

    def __init__(self, *cols, **kwargs):

        colnames, table = self._normalize_columns(cols)

        table = kwargs.pop('table', table)

        super(PrimaryKeyConstraint, self).__init__(*colnames, **kwargs)

        if table is not None:

            self._set_parent(table)

    def autoname(self):

        """Mimic the database's automatic constraint names"""

        return "%s_pkey" % self.table.name

class ForeignKeyConstraint(ConstraintChangeset, schema.ForeignKeyConstraint):

    """Construct ForeignKeyConstraint

    Migrate's additional parameters:

    :param columns: Columns in constraint

    :param refcolumns: Columns that this FK reffers to in another table.

    :param table: If columns are passed as strings, this kw is required

    :type table: Table instance

    :type columns: list of strings or Column instances

    :type refcolumns: list of strings or Column instances

    """

    __migrate_visit_name__ = 'migrate_foreign_key_constraint'

    def __init__(self, columns, refcolumns, *args, **kwargs):

        colnames, table = self._normalize_columns(columns)

        table = kwargs.pop('table', table)

        refcolnames, reftable = self._normalize_columns(refcolumns,

                                                        table_name=True)

        super(ForeignKeyConstraint, self).__init__(colnames, refcolnames, *args,

                                                   **kwargs)

        if table is not None:

            self._set_parent(table)

    @property

    def referenced(self):

        return [e.column for e in self.elements]

    @property

    def reftable(self):

        return self.referenced[0].table

    def autoname(self):

        """Mimic the database's automatic constraint names"""

        if hasattr(self.columns, 'keys'):

            # SA <= 0.5

            firstcol = self.columns[self.columns.keys()[0]]

            ret = "%(table)s_%(firstcolumn)s_fkey" % dict(

                table=firstcol.table.name,

                firstcolumn=firstcol.name,)

        else:

            # SA >= 0.6

            ret = "%(table)s_%(firstcolumn)s_fkey" % dict(

                table=self.table.name,

                firstcolumn=self.columns[0],)

        return ret

class CheckConstraint(ConstraintChangeset, schema.CheckConstraint):

    """Construct CheckConstraint

    Migrate's additional parameters:

    :param sqltext: Plain SQL text to check condition

    :param columns: If not name is applied, you must supply this kw\

    to autoname constraint

    :param table: If columns are passed as strings, this kw is required

    :type table: Table instance

    :type columns: list of Columns instances

    :type sqltext: string

    """

    __migrate_visit_name__ = 'migrate_check_constraint'

    def __init__(self, sqltext, *args, **kwargs):

        cols = kwargs.pop('columns', [])

        if not cols and not kwargs.get('name', False):

            raise InvalidConstraintError('You must either set "name"'

                'parameter or "columns" to autogenarate it.')

        colnames, table = self._normalize_columns(cols)

        table = kwargs.pop('table', table)

        schema.CheckConstraint.__init__(self, sqltext, *args, **kwargs)

        if table is not None:

            if not SQLA_06:

                self.table = table

            self._set_parent(table)

        self.colnames = colnames

    def autoname(self):

        return "%(table)s_%(cols)s_check" % \

            dict(table=self.table.name, cols="_".join(self.colnames))

class UniqueConstraint(ConstraintChangeset, schema.UniqueConstraint):

    """Construct UniqueConstraint

    Migrate's additional parameters:

    :param cols: Columns in constraint.

    :param table: If columns are passed as strings, this kw is required

    :type table: Table instance

    :type cols: strings or Column instances

    .. versionadded:: 0.6.0

    """

    __migrate_visit_name__ = 'migrate_unique_constraint'

    def __init__(self, *cols, **kwargs):

        self.colnames, table = self._normalize_columns(cols)

        table = kwargs.pop('table', table)

        super(UniqueConstraint, self).__init__(*self.colnames, **kwargs)

        if table is not None:

            self._set_parent(table)

    def autoname(self):

        """Mimic the database's automatic constraint names"""

        return "%s_%s_key" % (self.table.name, self.colnames[0])

"""

   This module contains database dialect specific changeset

   implementations.

"""

__all__ = [

    'postgres',

    'sqlite',

    'mysql',

    'oracle',

]

"""

   Firebird database specific implementations of changeset classes.

"""

from sqlalchemy.databases import firebird as sa_base

from migrate import exceptions

from 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

        if column.unique or getattr(column, 'unique_name', None):

            for cons in column.table.constraints:

                if cons.contains_column(column):

                    cons.drop()

                    # TODO: recreate unique constraint if it refenrences more than this column

        table = self.start_alter_table(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.")

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

        self.start_alter_table(table)

        col_name = self.preparer.quote(delta.current_name, table.quote)

        new_name = self.preparer.format_column(delta.result_column)

        self.append('ALTER COLUMN %s TO %s' % (col_name, new_name))

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

        """Changing NULL is not supported"""

        # TODO: http://www.firebirdfaq.org/faq103/

        raise exceptions.NotSupportedError(

            "Firebird does not support altering NULL bevahior.")

class FBConstraintGenerator(ansisql.ANSIConstraintGenerator):

    """Firebird constraint generator implementation."""

class FBConstraintDropper(ansisql.ANSIConstraintDropper):

    """Firebird constaint dropper implementation."""

    def cascade_constraint(self, constraint):

        """Cascading constraints is not supported"""

        raise exceptions.NotSupportedError(

            "Firebird does not support cascading constraints")

class FBDialect(ansisql.ANSIDialect):

    columngenerator = FBColumnGenerator

    columndropper = FBColumnDropper

    schemachanger = FBSchemaChanger

    constraintgenerator = FBConstraintGenerator

    constraintdropper = FBConstraintDropper

"""

   MySQL database specific implementations of changeset classes.

"""

from sqlalchemy.databases import mysql as sa_base

from sqlalchemy import types as sqltypes

from migrate import exceptions

from migrate.changeset import ansisql, SQLA_06

if not SQLA_06:

    MySQLSchemaGenerator = sa_base.MySQLSchemaGenerator

else:

    MySQLSchemaGenerator = sa_base.MySQLDDLCompiler

class MySQLColumnGenerator(MySQLSchemaGenerator, ansisql.ANSIColumnGenerator):

    pass

class MySQLColumnDropper(ansisql.ANSIColumnDropper):

    pass

class MySQLSchemaChanger(MySQLSchemaGenerator, ansisql.ANSISchemaChanger):

    def visit_column(self, delta):

        table = delta.table

        colspec = self.get_column_specification(delta.result_column)

        if delta.result_column.autoincrement:

            primary_keys = [c for c in table.primary_key.columns

                       if (c.autoincrement and

                            isinstance(c.type, sqltypes.Integer) and

                            not c.foreign_keys)]

            if primary_keys:

                first = primary_keys.pop(0)

                if first.name == delta.current_name:

                    colspec += " AUTO_INCREMENT"

        old_col_name = self.preparer.quote(delta.current_name, table.quote)

        self.start_alter_table(table)

        self.append("CHANGE COLUMN %s " % old_col_name)

        self.append(colspec)

        self.execute()

    def visit_index(self, param):

        # If MySQL can do this, I can't find how

        raise exceptions.NotSupportedError("MySQL cannot rename indexes")

class MySQLConstraintGenerator(ansisql.ANSIConstraintGenerator):

    pass