#$Id: example.py 662 2007-01-23 23:56:51Z sdobrev $
# -*- coding: cp1251 -*-

import sqlalchemy
if 1:
    from sawrap import plainwrap as saw
    class Text( saw.Type): pass
    class Int(  saw.Type): pass
else:
    import sa2static as saw
    from static_type.types.atomary import Text
    from static_type.types.atomary import Number as Int
    saw.Base.auto_set = False


class config:
    engine = 'memory'   #memory or sqlite or postgres
    echo = False
    debug = 'graph'  #subset of 'table column mapper graph'
    generate = False

Base = saw.Base2str

def case(
            inh='concrete',  #or 'tableinh'
         ):

    inh = (inh == 'concrete' and 'concrete_table' or 'table_inheritance')
    print 'B_inh_A case context:', ', '.join( '%s=%s' % kv for kv in locals().iteritems())


    class Employee( Base):
        manager = saw.Type4SubStruct( 'Manager')    #or 'Employee'
        name = Text()
        age  = Int()
        dept = saw.Type4SubStruct( 'Department')
        DB_inheritance = inh        #for those above; this one is always concrete anyway

    class Manager( Employee):
        secretary = saw.Type4SubStruct( Employee)
#        DB_inheritance = inh
#        DB_inheritance = 'table_inheritance'
        extras = Text()

    class Engineer( Employee):
#        DB_inheritance = 'table_inheritance'
        machine = Text()
        lover   = saw.Type4SubStruct( Employee)


        #error if base=Engineer - colummn not found XXX
        #error if base=Manager  - cyclic dependency XXX
        #error if Manager.inh=Engineer.ing=tableinh, Director.inh=concrete, Director(Employee)
    class Director( 1 and Employee or Manager or Engineer):
#        DB_inheritance = 'concrete_table'
        secretary = saw.Type4SubStruct( Employee)

    class Department( Base):
        manager = saw.Type4SubStruct( Manager)
        name = Text()
        director = saw.Type4SubStruct( 'Director')
        #employees = Collection/one2many(???) TODO


    fieldtypemap = {
        Text: dict( type= sqlalchemy.String, ),
        Int : dict( type= sqlalchemy.Integer, ),
    }

    sam = saw.SAdb( config.engine,
                debug=config.echo and 'sql' or '',
                _debug=config.debug,
                printer=config.generate,
            )
    sam.open( recreate=True)

    types = locals()
    sam.bind( types, fieldtypemap, base_klas= Base )

    def populate():
        a = Employee()
        a.name = 'empo'
        a.age = 30

        m = Manager()
        m.name = 'mummy'
        m.extras= 'big'

        dept = Department()
        dept.name = 'cubics'

        dept.manager = m
        a.manager = m
        a.dept = dept

        a1 = Employee()
        a1.name = 'emp2'
        a1.manager = m
        a1.age = 24
        a1.dept = dept

        m.secretary = a1
        m.manager = m       #self-boss

        e = Engineer()
        e.name = 'engo'
        e.manager = m
        e.machine = 'fast'
        e.lover = a1
        e.dept = dept

        if 1:
            h = Director()
            h.name = 'heady'
            h.secretary = a
            h.dept = dept
        if 0:
            m.manager = h

        session = sam.session()
        sam.saveall( session, locals() )
        session.flush()

        session.clear()


    import sys
    def test():
        session = sam.session()
        q2 = sam.query_all_tables()
        for kl in [Employee, Manager, Engineer, Department]:
            print '== query_BASE', kl.__name__
            q2 = sam.query_BASE_instances(session, klas=kl)
            print  '\n'.join( '  '+str(x) for x in q2)
            sys.stdout.flush()
            print '== query_ALL', kl.__name__
            q1 = sam.query_ALL_instances( session, klas=kl)
            print  '\n'.join( '  '+str(x) for x in q1)
            sys.stdout.flush()
            print '== query_SUB', kl.__name__
            q3 = sam.query_SUB_instances( session, klas=kl)
            print  '\n'.join( '  '+str(x) for x in q3)
            sys.stdout.flush()

    populate()
    test()

import sys
if 'help' in sys.argv or '-h' in sys.argv:
    print '''arguments:
 echo       : see sql (=no)
 generate   : see generated would-be source, for testcases (+no)
 debug=value: see debug for one or more of 'table column mapper graph' (='')
 engine=value: one of memory, sqlite, postgres (=memory)
 inh=value:   the way of inheritance-decomposition: one of concrete,tableinh (=concrete)
'''
    raise SystemError,1

for k in ['echo', 'generate']:
    v = k in sys.argv
    if v: sys.argv.remove(k)
    if k.startswith('no_'):
        k = k[3:]
        v = not v
    setattr( config, k, v)

kargs = dict( kv.split('=') for kv in sys.argv[1:])
for k in ['debug', 'engine']:
    if k in kargs:
        setattr( config, k, kargs[k])
        del kargs[k]
print 'config:', ', '.join( '%s=%s' % (k,v) for k,v in config.__dict__.iteritems() if not k.startswith('__') )
case( **kargs)

# vim:ts=4:sw=4:expandtab