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

# 

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

        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)

# 

# 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

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

   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.

"""

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

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

"""

   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

                    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.

"""

   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

   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

"""

   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

"""

   `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

"""

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

"""

   Module for visitor class mapping.

"""

import sqlalchemy as sa

                                         postgres,

                                         mysql,

                                         oracle,

                                         firebird)

import sqlalchemy

from sqlalchemy.schema import ForeignKeyConstraint

from sqlalchemy.schema import UniqueConstraint

                                                 run_single_visitor)

__all__ = [

    'create_column',

    'drop_column',

# 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',

"""

   Configuration parser module.

"""

from ConfigParser import ConfigParser

class Parser(ConfigParser):

    """A project configuration file."""

    def to_dict(self, sections=None):

import sys

import logging

import sqlalchemy

log = logging.getLogger(__name__)

HEADER = """

## File autogenerated by genmodel.py

from sqlalchemy import *

            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(

            missingA=True,missingB=True,modified=True

            ):

            decls.extend(self.getTableDefn(table))

"""

import os

import shutil

import logging

log = logging.getLogger(__name__)

class Pathed(KeyedInstance):

    """

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.

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

   Schema differencing support.

"""

import logging

import sqlalchemy

from sqlalchemy.types import Float

log = logging.getLogger(__name__)

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

    """

#!/usr/bin/env python

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

#!/usr/bin/env python

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

import logging

log = logging.getLogger(__name__)

class BaseScript(pathed.Pathed):

    """Base class for other types of scripts.

import shutil

import warnings

import logging

from StringIO import StringIO

log = logging.getLogger(__name__)

__all__ = ['PythonScript']

class PythonScript(base.BaseScript):

        :returns: Upgrade / Downgrade script

        :rtype: string

        """

        if isinstance(repository, basestring):

            # oh dear, an import cycle!

            repository = Repository(repository)

        oldmodel = load_model(oldmodel)

        model = load_model(model)

        # Compute differences.

#!/usr/bin/env python

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

import logging

import shutil

log = logging.getLogger(__name__)

class SqlScript(base.BaseScript):

    """A file containing plain SQL statements."""

import sys

import inspect

import logging

from optparse import OptionParser, BadOptionError

alias = dict(

    s=api.script,

    vc=api.version_control,

    dbv=api.db_version,

import os

import shutil

import sys

from pkg_resources import resource_filename

class Collection(pathed.Pathed):

    """A collection of templates of a specific type"""

    _mask = None

class SQLScriptCollection(Collection):

    _mask = '%s.py_tmpl'

class Template(pathed.Pathed):

    """Finds the paths/packages of various Migrate templates.

    if `path` is not provided.

    """

    pkg = 'migrate.versioning.templates'

    _manage = 'manage.py_tmpl'

    def __new__(cls, path=None):

from pkg_resources import EntryPoint

from sqlalchemy import create_engine

from sqlalchemy.engine import Engine

from sqlalchemy.pool import StaticPool

log = logging.getLogger(__name__)

def load_model(dotted_name):

    """Import module and use module-level variable".

import os

import re

import shutil

import logging

log = logging.getLogger(__name__)

class VerNum(object):

    """A version number that behaves like a string and int at the same time"""