"""

   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(

"""

   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)