Пример #1
0
def setup_logging( log_sa, log2stream =None):
    import logging
    #plz no timestamps!
    format ='* SA: %(levelname)s %(message)s'
    logging.basicConfig( format= format, stream= log2stream or logging.sys.stdout)  #level= logging.DEBUG,
    if log_sa == 'all':
        logging.getLogger( 'sqlalchemy').setLevel( logging.DEBUG) #debug EVERYTHING!
    else:
        from svd_util.attr import find_valid_fullname_import
        salog = find_valid_fullname_import( '''
            sqlalchemy.log
            sqlalchemy.logging
            ''', 0)
        salog.default_enabled= True    #else, default_logging() will setFormatter...

        if 'mapper' in log_sa:
            from sqlalchemy.orm import mapperlib
            mapperlib.Mapper.logger.setLevel( logging.DEBUG)
        if 'orm' in log_sa:
            logging.getLogger( 'sqlalchemy.orm').setLevel( logging.DEBUG)
Пример #2
0
def setup_logging(log_sa, log2stream=None):
    import logging
    #plz no timestamps!
    format = '* SA: %(levelname)s %(message)s'
    logging.basicConfig(format=format, stream=log2stream
                        or logging.sys.stdout)  #level= logging.DEBUG,
    if log_sa == 'all':
        logging.getLogger('sqlalchemy').setLevel(
            logging.DEBUG)  #debug EVERYTHING!
    else:
        from svd_util.attr import find_valid_fullname_import
        salog = find_valid_fullname_import(
            '''
            sqlalchemy.log
            sqlalchemy.logging
            ''', 0)
        salog.default_enabled = True  #else, default_logging() will setFormatter...

        if 'mapper' in log_sa:
            from sqlalchemy.orm import mapperlib
            mapperlib.Mapper.logger.setLevel(logging.DEBUG)
        if 'orm' in log_sa:
            logging.getLogger('sqlalchemy.orm').setLevel(logging.DEBUG)
Пример #3
0
    def visit_binary(me, b):
        r = me.stack.pop()
        l = me.stack.pop()
        try:
            op = me.ops[ b.operator]
        except KeyError:
            print 'XXXXXXXX', type(l), b.operator, type(r)
            op = b.operator
        t = ' '.join( [l, op, r ])
        me.stack.append( t)

class _state:
    do_columns = False

_BinaryThing = find_valid_fullname_import( '''
    sqlalchemy.sql.expression._BinaryExpression
''')

from sqlalchemy.orm.properties import PropertyLoader
if 0:
    def props_iter( mapr, klas =sqlalchemy.orm.PropertyLoader ):
        try: i = mapr.properties
        except:     # about r3740
            for p in mapr.iterate_properties:
                if isinstance( p, klas):
                    yield p.key, p
        else:
            for k,p in i.iteritems():
                yield k,p

    def props_get( mapr, key):
Пример #4
0
# $Id$

from svd_util.hacksrc import hacksrc
import sqlalchemy

from svd_util.attr import find_valid_fullname_import

compiler = find_valid_fullname_import(
    """
    sqlalchemy.sql.compiler.DefaultCompiler
"""
)

for func in compiler.visit_select, compiler.visit_compound_select:
    hacksrc(
        func,
        1
        * [
            (
                "):\n",
                """):
        tabbing = len(self.stack)*4*" "
""",
                1,
            )
        ]
        + 0
        * [
            (
                "self.stack.append(stack_entry)",
                """self.stack.append(stack_entry)
Пример #5
0
#$Id$


from sqlalchemy import schema
from svd_util.attr import find_valid_fullname_import
sql_util = find_valid_fullname_import( '''
    sqlalchemy.sql.util
''')

def fix_table_circular_deps( tablelist, dbg =0, **kargs):
    if dbg: print 'fix_table_circular_dependencies...'

    def traverse( visitor, obj):
        try: f = visitor.traverse
        except: return obj.accept_schema_visitor( visitor)
        else: return f( obj)

    alltbl = tablelist#sql_util.TableCollection( tablelist)
    tuples = []
    fkeys = {}
    inheritances = set()
    class TVisitor( schema.SchemaVisitor):
        def visit_foreign_key( _self, fkey):
            if fkey.use_alter:
                return
            #the fk is in the child; child points/references to parent;
            parent_table = fkey.column.table
            if parent_table in alltbl:
                child_table = fkey.parent.table
                #pointed, pointing
                tt = ( parent_table, child_table )
Пример #6
0
#else:
#    def equivs( parent): return getattr( parent, '_Mapper__get_equivalent_columns')()

def joincopy( c): return c._clone()

class _NOTFOUND: pass
def foreign_keys( prop):
    r = getattr( prop, 'foreign_keys',
        getattr( prop, '_foreign_keys', _NOTFOUND))
    assert r is not _NOTFOUND
    return r

from svd_util.attr import find_valid_fullname_import, import_fullname

ClauseAdapter = find_valid_fullname_import( '''
    sqlalchemy.sql.util.ClauseAdapter
''',1 )

ClauseList = find_valid_fullname_import( '''
    sqlalchemy.sql.expression.ClauseList
''',1 )

_BinaryExpression = find_valid_fullname_import( '''
    sqlalchemy.sql.expression._BinaryExpression
''',1 )

def corresponding_column( tbl, col): return tbl.corresponding_column( col)
import_fullname( 'sqlalchemy.sql.expression._corresponding_column_or_error', last_non_modules=1)    #assert for above

def prop_get_join( self, parent, primary=True, secondary=True):
    ''' from PropertyLoader.get_join(), no cache, no polymorphic joins '''
Пример #7
0
def hack4repeat():
    import sqlalchemy
    _v03 = hasattr(sqlalchemy, 'mapper')
    if not _v03:
        print 'v04 - cant hack4repeat'
        return
    # HACKALL
    import sqlalchemy.util
    sqlalchemy.util.Set = sqlalchemy.util.OrderedSet
    DICT = sqlalchemy.util.OrderedDict
    SET = sqlalchemy.util.OrderedSet

    import sqlalchemy.topological

    def init2old(x, newfunc):  #, name ='__init__', oldname = 'oldinit'):
        x.oldinit = x.__init__
        x.__init__ = newfunc

    if 0:

        class SortedList(list):
            def __iter__(me):
                try:
                    sorted = me._sorted
                except AttributeError:
                    sorted = me._sorted = me._do_sort()
                assert len(me) == len(sorted)
                return iter(sorted)

            def _do_sort(me):
                #if not me: me = r
                r = me[:]  #copy
                r.sort(key=lambda t: t.item.name)
                #                print 'sorted-', ','.join( t.item.name for t in r)
                return r

        def init(me, *a, **k):
            me.oldinit(*a, **k)
            me.children = SortedList()
            #print 'hacked', type(me)

        init2old(sqlalchemy.topological._Node, init)

    #see also:
    # unitofwork.UnitOfWork.identity_map ??
    # unitofwork.UOWTask.objects
    # sql_util.Aliasizer.tables

    if 1:

        def init(me, *a, **k):
            me.oldinit(*a, **k)
            me.tables = DICT()
            #print 'hacked', type(me)

        init2old(sqlalchemy.schema.MetaData, init)

    if 10:

        def init(me, *a, **k):
            me.oldinit(*a, **k)
            if isinstance(me.dependencies, sqlalchemy.util.Set):
                me.dependencies = SET()
            else:
                me.dependencies = DICT()
            #me.tasks = DICT()
            #print 'hacked', type(me)

        init2old(sqlalchemy.orm.unitofwork.UOWTransaction, init)

    if 10:

        def init(me, *a, **k):
            me.oldinit(*a, **k)
            me.objects = DICT()
            #print 'hacked', type(me)

        init2old(sqlalchemy.orm.unitofwork.UOWTask, init)

    if 0:
        import weakref

        def init(me, dict=None):
            me.oldinit(None)
            me.data = DICT(dict)
            print 'hacked', type(me)

        init2old(weakref.WeakKeyDictionary, init)

    from sqlalchemy.orm import mapperlib
    _mapper_registry = find_valid_fullname_import(
        '''
        sqlalchemy.orm.mapperlib._mapper_registry
    ''', 2)
    assert not _mapper_registry.data
    _mapper_registry.data = DICT()

    if 10:
        #these must be done via source:
        #orm/mapper.py: Mapper.save_obj(): line 848
        #   table_to_mapper = util.OrderedDict() #{}
        #topological.py: QueueDependencySorter.sort(): line 138
        #   nodes = util.OrderedDict()  #{}

        #ver 0.3.3
        hacksrc(mapperlib.Mapper.save_obj, 'table_to_mapper = {}',
                'table_to_mapper = util.OrderedDict()')
        hacksrc(mapperlib.Mapper._compile_properties, 'self.__props = {}',
                'self.__props = util.OrderedDict()')
        hacksrc(sqlalchemy.topological.QueueDependencySorter.sort,
                'nodes = {}', 'nodes = util.OrderedDict()')

    if 0:  #partial

        def _set_constraints(me, v):
            from sqlalchemy.util import OrderedSet, Set
            assert not v
            assert isinstance(v, Set)
            me._constraints = OrderedSet()

        sqlalchemy.Table.constraints = property(lambda me: me._constraints,
                                                _set_constraints)
        sqlalchemy.Column.constraints = property(lambda me: me._constraints,
                                                 _set_constraints)
Пример #8
0
#$Id$

from sqlalchemy import schema
from svd_util.attr import find_valid_fullname_import
sql_util = find_valid_fullname_import('''
    sqlalchemy.sql.util
''')


def fix_table_circular_deps(tablelist, dbg=0, **kargs):
    if dbg: print 'fix_table_circular_dependencies...'

    def traverse(visitor, obj):
        try:
            f = visitor.traverse
        except:
            return obj.accept_schema_visitor(visitor)
        else:
            return f(obj)

    alltbl = tablelist  #sql_util.TableCollection( tablelist)
    tuples = []
    fkeys = {}
    inheritances = set()

    class TVisitor(schema.SchemaVisitor):
        def visit_foreign_key(_self, fkey):
            if fkey.use_alter:
                return
            #the fk is in the child; child points/references to parent;
            parent_table = fkey.column.table
Пример #9
0
        l = me.stack.pop()
        try:
            op = me.ops[b.operator]
        except KeyError:
            print 'XXXXXXXX', type(l), b.operator, type(r)
            op = b.operator
        t = ' '.join([l, op, r])
        me.stack.append(t)


class _state:
    do_columns = False


_BinaryThing = find_valid_fullname_import('''
    sqlalchemy.sql.expression._BinaryExpression
''')

from sqlalchemy.orm.properties import PropertyLoader
if 0:

    def props_iter(mapr, klas=sqlalchemy.orm.PropertyLoader):
        try:
            i = mapr.properties
        except:  # about r3740
            for p in mapr.iterate_properties:
                if isinstance(p, klas):
                    yield p.key, p
        else:
            for k, p in i.iteritems():
                yield k, p
Пример #10
0
#$Id$

from svd_util.hacksrc import hacksrc
import sqlalchemy

from svd_util.attr import find_valid_fullname_import
compiler = find_valid_fullname_import('''
    sqlalchemy.sql.compiler.DefaultCompiler
''')

for func in compiler.visit_select, compiler.visit_compound_select:
    hacksrc(
        func,
        1 * [('):\n', '''):
        tabbing = len(self.stack)*4*" "
''', 1)] + 0 *
        [('self.stack.append(stack_entry)', '''self.stack.append(stack_entry)
        tabbing = len(self.stack)*4*" "
''', 1)] + [
            ('\\n' + word, word) for word in
            'SELECT FROM WHERE ORDER GROUP HAVING'.split()  #kill pre-newlines
        ] + [
            (' ' + word, word) for word in
            'SELECT FROM WHERE ORDER GROUP HAVING'.split()  #kill pre-spaces
        ] + [('"' + word, '"\\n"+tabbing+"' + word)
             for word in 'FROM WHERE ORDER GROUP HAVING'.split()] +
        [('"' + word, 'tabbing+"' + word) for word in 'SELECT'.split()] + [
            ('"("', '"(\\n"',
             5),  # w/o it nested select appears on the same row
            ('")"', '"\\n"+tabbing[:-4]+")"', 5),
            ('cs.keyword + " "',
Пример #11
0
def hack4repeat():
    import sqlalchemy

    _v03 = hasattr(sqlalchemy, "mapper")
    if not _v03:
        print "v04 - cant hack4repeat"
        return
    # HACKALL
    import sqlalchemy.util

    sqlalchemy.util.Set = sqlalchemy.util.OrderedSet
    DICT = sqlalchemy.util.OrderedDict
    SET = sqlalchemy.util.OrderedSet

    import sqlalchemy.topological

    def init2old(x, newfunc):  # , name ='__init__', oldname = 'oldinit'):
        x.oldinit = x.__init__
        x.__init__ = newfunc

    if 0:

        class SortedList(list):
            def __iter__(me):
                try:
                    sorted = me._sorted
                except AttributeError:
                    sorted = me._sorted = me._do_sort()
                assert len(me) == len(sorted)
                return iter(sorted)

            def _do_sort(me):
                # if not me: me = r
                r = me[:]  # copy
                r.sort(key=lambda t: t.item.name)
                #                print 'sorted-', ','.join( t.item.name for t in r)
                return r

        def init(me, *a, **k):
            me.oldinit(*a, **k)
            me.children = SortedList()
            # print 'hacked', type(me)

        init2old(sqlalchemy.topological._Node, init)

    # see also:
    # unitofwork.UnitOfWork.identity_map ??
    # unitofwork.UOWTask.objects
    # sql_util.Aliasizer.tables

    if 1:

        def init(me, *a, **k):
            me.oldinit(*a, **k)
            me.tables = DICT()
            # print 'hacked', type(me)

        init2old(sqlalchemy.schema.MetaData, init)

    if 10:

        def init(me, *a, **k):
            me.oldinit(*a, **k)
            if isinstance(me.dependencies, sqlalchemy.util.Set):
                me.dependencies = SET()
            else:
                me.dependencies = DICT()
            # me.tasks = DICT()
            # print 'hacked', type(me)

        init2old(sqlalchemy.orm.unitofwork.UOWTransaction, init)

    if 10:

        def init(me, *a, **k):
            me.oldinit(*a, **k)
            me.objects = DICT()
            # print 'hacked', type(me)

        init2old(sqlalchemy.orm.unitofwork.UOWTask, init)

    if 0:
        import weakref

        def init(me, dict=None):
            me.oldinit(None)
            me.data = DICT(dict)
            print "hacked", type(me)

        init2old(weakref.WeakKeyDictionary, init)

    from sqlalchemy.orm import mapperlib

    _mapper_registry = find_valid_fullname_import(
        """
        sqlalchemy.orm.mapperlib._mapper_registry
    """,
        2,
    )
    assert not _mapper_registry.data
    _mapper_registry.data = DICT()

    if 10:
        # these must be done via source:
        # orm/mapper.py: Mapper.save_obj(): line 848
        #   table_to_mapper = util.OrderedDict() #{}
        # topological.py: QueueDependencySorter.sort(): line 138
        #   nodes = util.OrderedDict()  #{}

        # ver 0.3.3
        hacksrc(mapperlib.Mapper.save_obj, "table_to_mapper = {}", "table_to_mapper = util.OrderedDict()")
        hacksrc(mapperlib.Mapper._compile_properties, "self.__props = {}", "self.__props = util.OrderedDict()")
        hacksrc(sqlalchemy.topological.QueueDependencySorter.sort, "nodes = {}", "nodes = util.OrderedDict()")

    if 0:  # partial

        def _set_constraints(me, v):
            from sqlalchemy.util import OrderedSet, Set

            assert not v
            assert isinstance(v, Set)
            me._constraints = OrderedSet()

        sqlalchemy.Table.constraints = property(lambda me: me._constraints, _set_constraints)
        sqlalchemy.Column.constraints = property(lambda me: me._constraints, _set_constraints)