Ok, I think I´ve managed a solution that works to the extent of my tests
and that is elegant (in the sense that does all its magic behind
curtains without help from the lazy and evil user, not in the sense that
it is fancy code, which is not!)
This solution involves more iterations and probably more processing
power required, but this iterations only happen once during the entire
program, so it should not be a problem. Most modifications are inside
process_relationships, plus one added function for comfort and a tweak
in ActiveMapperMeta because I´m just lazy...
You should be able to throw almost any combination of one_to_many and
foreign_keys in any order and it will (hopefully) work just fine...
activemapper.py
---
from sqlalchemy import objectstore, create_engine,
assign_mapper, relation, mapper
from sqlalchemy import and_, or_
from sqlalchemy import Table, Column, ForeignKey
from sqlalchemy.ext.proxy import ProxyEngine
import inspect
import sys
#
# the "proxy" to the database engine... this can be swapped out at runtime
#
engine = ProxyEngine()
#
# declarative column declaration - this is so that we can infer the colname
#
class column(object):
def __init__(self, coltype, colname=None, foreign_key=None,
primary_key=False, *args, **kwargs):
if isinstance( foreign_key, basestring ):
foreign_key= ForeignKey( foreign_key )
self.coltype = coltype
self.colname = colname
self.foreign_key = foreign_key
self.primary_key = primary_key
# self.unique = kwargs.pop( 'unique', None )
# self.index = kwargs.pop( 'indexed', None )
self.kwargs = kwargs
self.args = args
#
# declarative relationship declaration
#
class relationship(object):
def __init__(self, classname, colname=None, backref=None, private=False,
lazy=True, uselist=True, secondary=None):
self.classname = classname
self.colname = colname
self.backref = backref
self.private = private
self.lazy = lazy
self.uselist = uselist
self.secondary = secondary
class one_to_many(relationship):
def __init__(self, classname, colname=None, backref=None,
private=False, lazy=True):
relationship.__init__(self, classname, colname, backref,
private, lazy, uselist=True)
class one_to_one(relationship):
def __init__(self, classname, colname=None, backref=None,
private=False, lazy=True):
relationship.__init__(self, classname, colname, backref,
private, lazy, uselist=False)
class many_to_many(relationship):
def __init__(self, classname, secondary, backref=None, lazy=True):
relationship.__init__(self, classname, None, backref, False, lazy,
uselist=True, secondary=secondary)
#
# SQLAlchemy metaclass and superclass that can be used to do SQLAlchemy
# mapping in a declarative way, along with a function to process the
# relationships between dependent objects as they come in, without blowing
# up if the classes aren't specified in a proper order
#
__deferred_classes__ = []
__processed_classes__ = []
def check_relationships(klass):
#Check the class for foreign_keys recursively. If some foreign table
is not found, the processing of the table
#must be defered.
for keyname in klass.table._foreign_keys:
xtable = keyname._colspec[:keyname._colspec.find('.')]
tablefound = False
for xclass in ActiveMapperMeta.classes:
if ActiveMapperMeta.classes[xclass].table.from_name == xtable:
tablefound = True
break
if tablefound==False:
#The refered table has not yet been created.
return False
return True
def process_relationships(klass):
defer = False
for propname, reldesc in klass.relations.items():
#We require that every related table has been processed first
if not reldesc.classname in __processed_classes__:
if not klass._classname in __deferred_classes__:
__deferred_classes__.append(klass._classname)
defer = True
#Check every column item to see if it points to an existing table
#if it does not, defer...
if not defer:
if not check_relationships(klass):
if not klass._classname in __deferred_classes__:
__deferred_classes__.append(klass._classname)
defer = True
if not defer:
relations = {}
__processed_classes__.append(klass._classname)
for propname, reldesc in klass.relations.items():
relclass = ActiveMapperMeta.classes[reldesc.classname]
relations[propname] = relation(relclass.mapper,
secondary=reldesc.secondary,
backref=reldesc.backref,
private=reldesc.private,
lazy=reldesc.lazy,
uselist=reldesc.uselist)
if len(relations)>0:
assign_mapper(klass, klass.table, properties=relations)
if klass._classname in __deferred_classes__:
__deferred_classes__.remove(klass._classname)
for deferred_class in __deferred_classes__:
process_relationships(ActiveMapperMeta.classes[deferred_class])
class ActiveMapperMeta(type):
classes = {}
def __init__(cls, clsname, bases, dict):
table_name = clsname.lower()
columns = []
relations = {}
_engine = getattr( sys.modules[cls.__module__], "__engine__",
engine )
if 'mapping' in dict:
members = inspect.getmembers(dict.get('mapping'))
for name, value in members:
if name == '__table__':
table_name = value
continue
if '__engine__' == name:
_engine= value
continue
if name.startswith('__'): continue
if isinstance(value, column):
if value.foreign_key:
col = Column(value.colname or name,
value.coltype,
value.foreign_key,
primary_key=value.primary_key,
*value.args, **value.kwargs)
else:
col = Column(value.colname or name,
value.coltype,
primary_key=value.primary_key,
*value.args, **value.kwargs)
columns.append(col)
# if value.indexed:
# # create a Index object for the column
# index= Index( "%s_idx" % (value.colname or name),
# col, unique= value.unique )
continue
if isinstance(value, relationship):
relations[name] = value
assert _engine is not None, "No engine specified"
cls.table = Table(table_name, _engine, *columns)
assign_mapper(cls, cls.table)
cls.relations = relations
cls._classname = clsname
ActiveMapperMeta.classes[clsname] = cls
process_relationships(cls)
super(ActiveMapperMeta, cls).__init__(clsname, bases, dict)
class ActiveMapper(object):
__metaclass__ = ActiveMapperMeta
def set(self, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
#
# a utility function to create all tables for all ActiveMapper classes
#
def create_tables():
for klass in ActiveMapperMeta.classes.values():
klass.table.create()
---
Jonathan LaCour escribió:
Gabriel Jacobo wrote:
I have been checking on the issue of ActiveMapper, regarding its use
when classes with multiple inter-relations are involved. It quickly
became evident that if you intend to use ActiveMapper for a case
where the complexity of the classes goes a little beyond the test
case, the code fails, except you take extreme care with the ordering
of the classes...
This is true, and is a known issue. Thanks for taking a look at the
code, I really appreciate it!
Anyway...I think I´ve managed to modify ActiveMapper to lessen this
problem, maybe even solve it completely (at least to the extent of my
testing it works just fine). This modification is barely more than a
dirty hack, but it "just works". What I did was decouple the table
creation phase from the relations processing, which now must be
started "by hand", calling the function "connect_classes". Upon
calling this function, the system will check everyclass asociated
with ActiveMapperMeta, and will order them in the correct order for
everything to work fine.
This is certainly one way to do it (and was, in fact, the way that I
originally wrote ActiveMapper), but I think that there is a better way
to solve this, and allow relationship processing to happen
automatically. I don't think that the flaw is in the approach
necessarily, I think its just buggy code :)
In a recent discussion with someone else about this issue, I suggested
the following way to potentially fix the bugs *and* keep the process
automatic:
Currently the process_relationships function is called from within the
ActiveMapperMeta metaclass each time an ActiveMapper class is defined.
Currently, lines 91 and 92 in ActiveMapper.py do the following:
for deferred_class in __deferred_classes__:
process_relationships(deferred_class, was_deferred=True)
This doesn't take into account various different orderings that the
classes may be specified in. In order to combat this problem, the
logic could be improved to keep trying to process relationships until
you cannot process anymore.
last_length = len(__deferred_classes__)
while len(__deferred_classes__) > 0:
for klass in __deferred_classes__:
process_relationships(klass, True)
if len(__deferred_classes__) == last_length:
# the number of deferred classes is the same as
# the last time through the loop, meaning that we
# were not able to resolve any new relationships
break
Give this a shot, and see what happens. I really don't like the
manual solution, as its far too invasive. Even if my suggestion
doesn't work, keep at it. I think that an automatic solution *can* be
reached.
Sorry I have not been keeping up with ActiveMapper as much as I would
like to. Things have been very busy for me lately, but I will get
back into the fold eventually.
--
Jonathan LaCour
http://cleverdevil.org
-------------------------------------------------------
This SF.Net email is sponsored by xPML, a groundbreaking scripting
language
that extends applications into web and mobile media. Attend the live
webcast
and join the prime developer group breaking into this new coding
territory!
http://sel.as-us.falkag.net/sel?cmd=k&kid0944&bid$1720&dat1642
_______________________________________________
Sqlalchemy-users mailing list
Sqlalchemy-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sqlalchemy-users
-------------------------------------------------------
This SF.Net email is sponsored by xPML, a groundbreaking scripting language
that extends applications into web and mobile media. Attend the live webcast
and join the prime developer group breaking into this new coding territory!
http://sel.as-us.falkag.net/sel?cmd=lnk&kid=110944&bid=241720&dat=121642
_______________________________________________
Sqlalchemy-users mailing list
Sqlalchemy-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sqlalchemy-users
