# 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.

import os

import sys

import uuid

from rhodecode.lib.auth import get_crypt_password

from rhodecode.lib.utils import ask_ok

from rhodecode.model import init_model

from rhodecode.model.db import User, Permission, RhodeCodeUi, RhodeCodeSettings, \

from sqlalchemy.engine import create_engine

log = logging.getLogger(__name__)

class DbManage(object):

    def __init__(self, log_sql, dbconf, root, tests=False):

        self.dbname = dbconf.split('/')[-1]

        self.tests = tests

        self.root = root

        self.dburi = dbconf

        engine = create_engine(self.dburi, echo=log_sql)

        init_model(engine)

        self.sa = meta.Session()

                destroy = ask_ok('Are you sure to destroy old database ? [y/n]')

            if not destroy:

                sys.exit()

            if self.db_exists and destroy:

                os.remove(jn(self.root, self.dbname))

        checkfirst = not override

        meta.Base.metadata.create_all(checkfirst=checkfirst)

        log.info('Created tables for %s', self.dbname)

    def set_db_version(self):

        try:

            ver = DbMigrateVersion()

            ver.version = __dbversion__

            ver.repository_id = 'rhodecode_db_migrations'

            ver.repository_path = 'versions'

            self.sa.add(ver)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

        log.info('db version set to: %s', __dbversion__)

# 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, Command, add_cache

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)

    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.

"""

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

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

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

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

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

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)

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."""

"""

   This module defines standalone schema constraint classes.

"""

from sqlalchemy import schema

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)

                                                         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

"""

   Firebird database specific implementations of changeset classes.

"""

from sqlalchemy.databases import firebird as sa_base

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

"""

   MySQL database specific implementations of changeset classes.

"""

from sqlalchemy.databases import mysql as sa_base

from sqlalchemy import types as sqltypes

if not SQLA_06:

    MySQLSchemaGenerator = sa_base.MySQLSchemaGenerator

else:

    MySQLSchemaGenerator = sa_base.MySQLDDLCompiler

class MySQLColumnGenerator(MySQLSchemaGenerator, ansisql.ANSIColumnGenerator):

    pass

class MySQLColumnDropper(ansisql.ANSIColumnDropper):

"""

   Oracle database specific implementations of changeset classes.

"""

import sqlalchemy as sa

from sqlalchemy.databases import oracle as sa_base

if not SQLA_06:

    OracleSchemaGenerator = sa_base.OracleSchemaGenerator

else:

    OracleSchemaGenerator = sa_base.OracleDDLCompiler

class OracleColumnGenerator(OracleSchemaGenerator, ansisql.ANSIColumnGenerator):

    pass

"""

   `PostgreSQL`_ database specific implementations of changeset classes.

   .. _`PostgreSQL`: http://www.postgresql.org/

"""

if not SQLA_06:

    from sqlalchemy.databases import postgres as sa_base

    PGSchemaGenerator = sa_base.PGSchemaGenerator

else:

    from sqlalchemy.databases import postgresql as sa_base

    PGSchemaGenerator = sa_base.PGDDLCompiler

class PGColumnGenerator(PGSchemaGenerator, ansisql.ANSIColumnGenerator):

    """PostgreSQL column generator implementation."""

    pass

"""

   `SQLite`_ database specific implementations of changeset classes.

   .. _`SQLite`: http://www.sqlite.org/

"""

from UserDict import DictMixin

from copy import copy

from sqlalchemy.databases import sqlite as sa_base

if not SQLA_06:

    SQLiteSchemaGenerator = sa_base.SQLiteSchemaGenerator

else:

    SQLiteSchemaGenerator = sa_base.SQLiteDDLCompiler

class SQLiteCommon(object):

    def _not_supported(self, op):

        raise exceptions.NotSupportedError("SQLite does not support "

            "%s; see http://www.sqlite.org/lang_altertable.html" % op)

"""

   Module for visitor class mapping.

"""

import sqlalchemy as sa

                                         postgres,

                                         mysql,

                                         oracle,

                                         firebird)

# Map SA dialects to the corresponding Migrate extensions

DIALECTS = {

    "default": ansisql.ANSIDialect,

    "sqlite": sqlite.SQLiteDialect,

    "postgres": postgres.PGDialect,

    "postgresql": postgres.PGDialect,

"""

   Schema module providing common schema operations.

"""

import warnings

from UserDict import DictMixin

import sqlalchemy

from sqlalchemy.schema import ForeignKeyConstraint

from sqlalchemy.schema import UniqueConstraint

                                                 run_single_visitor)

__all__ = [

    'create_column',

    'drop_column',

    'alter_column',

    'rename_table',

    'rename_index',

    'ChangesetTable',

    'ChangesetColumn',

    'ChangesetIndex',

#

# please do not comment this module using sphinx syntax because its

# docstrings are presented as user help and most users cannot

# interpret sphinx annotated ReStructuredText.

#

# Thanks,

# Jan Dittberner

import sys

import inspect

import logging

    script as script_) # command name conflict

log = logging.getLogger(__name__)

command_desc = {

    'help': 'displays help on a given command',

    'create': 'create an empty repository at the specified path',

    'script': 'create an empty change Python script',

    'script_sql': 'create empty change SQL scripts for given database',

    'version': 'display the latest version available in a repository',

    'db_version': 'show the current version of the repository under version control',

    'source': 'display the Python code for a particular version in this repository',

    'version_control': 'mark a database as under this repository\'s version control',

"""

   Configuration parser module.

"""

from ConfigParser import ConfigParser

class Parser(ConfigParser):

    """A project configuration file."""

    def to_dict(self, sections=None):

        """It's easier to access config values like dictionaries"""

        return self._sections

class Config(pathed.Pathed, Parser):

    """Configuration class."""

   Code to generate a Python model from a database or differences

   between a model and database.

   Some of this is borrowed heavily from the AutoCode project at:

   http://code.google.com/p/sqlautocode/

"""

import sys

import logging

import sqlalchemy

log = logging.getLogger(__name__)

HEADER = """

## File autogenerated by genmodel.py

from sqlalchemy import *

meta = MetaData()

"""

DECLARATIVE_HEADER = """

## File autogenerated by genmodel.py

            out.append("class %(table)s(Base):" % {'table': tableName})

            out.append("  __tablename__ = '%(table)s'" % {'table': tableName})

            for col in table.columns:

                out.append("  %s" % self.column_repr(col))

        else:

            out.append("%(table)s = Table('%(table)s', meta," % \

                           {'table': tableName})

            for col in table.columns:

                out.append("  %s," % self.column_repr(col))

            out.append(")")

        return out

        to_process = []

                ):

            if bool_:

                for name in names:

                    yield metadata.tables.get(name)

    def toPython(self):

        """Assume database is current and model is empty."""

        out = []

        if self.declarative:

            out.append(DECLARATIVE_HEADER)

        else:

            out.append(HEADER)

        out.append("")

        for table in self._get_tables(missingA=True):

            out.extend(self.getTableDefn(table))

            out.append("")

        return '\n'.join(out)

    def toUpgradeDowngradePython(self, indent='    '):

        ''' Assume model is most current and database is out-of-date. '''

                 'meta = MetaData()']

        for table in self._get_tables(

            ):

            decls.extend(self.getTableDefn(table))

        upgradeCommands, downgradeCommands = [], []

        for tableName in self.diff.tables_missing_from_A:

            upgradeCommands.append("%(table)s.drop()" % {'table': tableName})

            downgradeCommands.append("%(table)s.create()" % \

                                         {'table': tableName})

        for tableName in self.diff.tables_missing_from_B:

            upgradeCommands.append("%(table)s.create()" % {'table': tableName})

            downgradeCommands.append("%(table)s.drop()" % {'table': tableName})

                    'assert False, "Can\'t alter columns: %s:%s=>%s"',

                    modelTable, modelCol.name, databaseCol.name)

                downgradeCommands.append(

                    'assert False, "Can\'t alter columns: %s:%s=>%s"',

                    modelTable, modelCol.name, databaseCol.name)

        pre_command = '    meta.bind = migrate_engine'

        return (

            '\n'.join(decls),

            '\n'.join([pre_command] + ['%s%s' % (indent, line) for line in upgradeCommands]),

            '\n'.join([pre_command] + ['%s%s' % (indent, line) for line in downgradeCommands]))

        if (td.columns_missing_from_B

            and not td.columns_missing_from_A

            and not td.columns_different):

            # Even sqlite can handle this.

            return True

        else:

            return not self.engine.url.drivername.startswith('sqlite')

    def applyModel(self):

        """Apply model to current database."""

        meta = sqlalchemy.MetaData(self.engine)

        for table in self._get_tables(missingA=True):

            table = table.tometadata(meta)

            table.drop()

        for table in self._get_tables(missingB=True):

            table = table.tometadata(meta)

            table.create()

        for modelTable in self._get_tables(modified=True):

            tableName = modelTable.name

            modelTable = modelTable.tometadata(meta)

            dbTable = self.diff.metadataB.tables[tableName]

            td = self.diff.tables_different[tableName]

            if self._db_can_handle_this_change(td):

                for col in td.columns_missing_from_B:

                    modelTable.columns[col].create()

                for col in td.columns_missing_from_A:

                    dbTable.columns[col].drop()

                # XXX handle column changes here.

            else:

                # Sqlite doesn't support drop column, so you have to

                # do more: create temp table, copy data to it, drop

                # old table, create new table, copy data back.

                #

                # I wonder if this is guaranteed to be unique?

                tempName = '_temp_%s' % modelTable.name

"""

   A path/directory class.

"""

import os

import shutil

import logging

log = logging.getLogger(__name__)

class Pathed(KeyedInstance):

    """

    A class associated with a path/directory tree.

    Only one instance of this class may exist for a particular file;

    __new__ will return an existing instance if possible

    """

    parent = None

"""

   SQLAlchemy migrate repository management.

"""

import os

import shutil

import string

import logging

from pkg_resources import resource_filename

from tempita import Template as TempitaTemplate

log = logging.getLogger(__name__)

class Changeset(dict):

    """A collection of changes to be applied to a database.

    Changesets are bound to a repository and manage a set of

    scripts from that repository.

    Behaves like a dict, for the most part. Keys are ordered based on step value.

    """

"""

   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 import exceptions as sa_exceptions

from sqlalchemy.sql import bindparam

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

"""

   Schema differencing support.

"""

import logging

import sqlalchemy

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

    """

    return SchemaDiff(metadata,

#!/usr/bin/env python

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

#!/usr/bin/env python