"""

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

"""

   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.