"""

   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.sql import bindparam

from rhodecode.lib.dbmigrate.migrate import exceptions

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

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

        if isinstance(repository, basestring):

            repository = Repository(repository)

        self.engine = engine

        self.repository = repository

        self.meta = MetaData(engine)

        self.load()

    def __eq__(self, other):

        """Compare two schemas by repositories and versions"""

        return (self.repository is other.repository \

            and self.version == other.version)

    def load(self):

        """Load controlled schema version info from DB"""

        tname = self.repository.version_table

        try:

            if not hasattr(self, 'table') or self.table is None:

                    self.table = Table(tname, self.meta, autoload=True)

            result = self.engine.execute(self.table.select(

                self.table.c.repository_id == str(self.repository.id)))

            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.

        """

        if SQLA_07:

            try:

                self.table.drop()

            except sa_exceptions.DatabaseError:

                raise exceptions.DatabaseNotControlledError(str(self.table))

        else:

            try:

                self.table.drop()

            except (sa_exceptions.SQLError):

                raise exceptions.DatabaseNotControlledError(str(self.table))

    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

    def runchange(self, ver, change, step):

        startver = ver

        endver = ver + step

        # Current database version must be correct! Don't run if corrupt!

        if self.version != startver:

            raise exceptions.InvalidVersionError("%s is not %s" % \

                                                     (self.version, startver))

        # Run the change

        change.run(self.engine, step)

        # Update/refresh database version

        self.update_repository_table(startver, endver)

        self.load()

    def update_repository_table(self, startver, endver):

        """Update version_table with new information"""

        update = self.table.update(and_(self.table.c.version == int(startver),

             self.table.c.repository_id == str(self.repository.id)))

        self.engine.execute(update, version=int(endver))

    def upgrade(self, version=None):

        """

        Upgrade (or downgrade) to a specified version, or latest version.

        """

        changeset = self.changeset(version)

        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]

"""

   Schema differencing support.

"""

import logging

import sqlalchemy

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

from sqlalchemy.types import Float

log = logging.getLogger(__name__)

def getDiffOfModelAgainstDatabase(metadata, engine, excludeTables=None):

    """

    Return differences of model against database.

    :return: object which will evaluate to :keyword:`True` if there \

      are differences else :keyword:`False`.

    """

    # sqlite will include a dynamically generated 'sqlite_sequence' table if

    # there are autoincrement sequences in the database; this should not be

    # compared.

    if engine.dialect.name == 'sqlite':

        if 'sqlite_sequence' in db_metadata.tables:

            db_metadata.remove(db_metadata.tables['sqlite_sequence'])

    return SchemaDiff(metadata, db_metadata,

                      labelA='model',

                      labelB='database',

                      excludeTables=excludeTables)

def getDiffOfModelAgainstModel(metadataA, metadataB, excludeTables=None):

    """

    Return differences of model against another model.

    :return: object which will evaluate to :keyword:`True` if there \

      are differences else :keyword:`False`.

    """

    return SchemaDiff(metadataA, metadataB, excludeTables=excludeTables)

class ColDiff(object):

    """

    Container for differences in one :class:`~sqlalchemy.schema.Column`

    between two :class:`~sqlalchemy.schema.Table` instances, ``A``

    and ``B``.

    .. attribute:: col_A

      The :class:`~sqlalchemy.schema.Column` object for A.

    .. attribute:: col_B

      The :class:`~sqlalchemy.schema.Column` object for B.

    .. attribute:: type_A

      The most generic type of the :class:`~sqlalchemy.schema.Column`

      object in A.

    .. attribute:: type_B

      The most generic type of the :class:`~sqlalchemy.schema.Column`

      object in A.

    """

    diff = False

    def __init__(self,col_A,col_B):

        self.col_A = col_A

        self.col_B = col_B

        self.type_A = col_A.type

        self.type_B = col_B.type

        self.affinity_A = self.type_A._type_affinity

        self.affinity_B = self.type_B._type_affinity

        if self.affinity_A is not self.affinity_B:

            self.diff = True

            return

        if isinstance(self.type_A,Float) or isinstance(self.type_B,Float):

            if not (isinstance(self.type_A,Float) and isinstance(self.type_B,Float)):

                self.diff=True

                return

        for attr in ('precision','scale','length'):

            A = getattr(self.type_A,attr,None)

            B = getattr(self.type_B,attr,None)

            if not (A is None or B is None) and A!=B:

                self.diff=True

                return

    def __nonzero__(self):

        return self.diff

class TableDiff(object):

    """

    Container for differences in one :class:`~sqlalchemy.schema.Table`

    between two :class:`~sqlalchemy.schema.MetaData` instances, ``A``

    and ``B``.

    .. attribute:: columns_missing_from_A

      A sequence of column names that were found in B but weren't in

      A.

    .. attribute:: columns_missing_from_B

      A sequence of column names that were found in A but weren't in

      B.