def create_association(cls, assoc_table, relationship_name):
    """
    Creates a relationship as relationship_name to the assoc_table for each parent
    """
    name = cls.__name__
    discriminator = name.lower()
    association_name = assoc_table.__tablename__

    assoc_cls = type(  # creates dynamic class
        "{cls_name}{assoc_name}".format(
            cls_name=name, assoc_name=assoc_table.__name__
        ),  # name, i.e. EmployeeAddressMap
        (assoc_table,),  # base
        dict(__tablename__=None, __mapper_args__={"polymorphic_identity": discriminator}),  # attributes
    )

    setattr(
        cls,
        relationship_name,
        association_proxy(
            association_name, relationship_name, creator=lambda obj: assoc_cls(**{relationship_name: obj})
        ),
    )

    return relationship(assoc_cls, backref=backref("parent", uselist=False))

	def InitMapper( cls, metadata, Parameter, ParameterType, DesignQuantity ):
		mapper( cls, inherits = Parameter, polymorphic_identity = ParameterType, properties = {
			'_quantity' : relation( DesignQuantity,
				collection_class = attribute_mapped_collection('design'))
			})

		cls.quantity = association_proxy('_quantity', 'quantity', creator = lambda k, v: DesignQuantity( design = k, quantity = v ) )

 def _set_association_proxy(cls, edge_cls, attr_name, edge_name, direction):
     rel = association_proxy(
         edge_name,
         direction,
         creator=lambda node: edge_cls(**{direction: node})
     )
     setattr(cls, attr_name, rel)

  def declare_categorizable(cls, category_type, single, plural, ation):
    setattr(
        cls, plural,
        association_proxy(
            ation, 'category',
            creator=lambda category: Categorization(
                category_id=category.id,
                category_type=category.__class__.__name__,
                categorizable_type=cls.__name__
            )
        )
    )

    joinstr = (
        'and_('
        'foreign(Categorization.categorizable_id) == {type}.id, '
        'foreign(Categorization.categorizable_type) == "{type}", '
        'foreign(Categorization.category_type) == "{category_type}"'
        ')'
    )
    joinstr = joinstr.format(type=cls.__name__, category_type=category_type)
    backref = '{type}_categorizable_{category_type}'.format(
        type=cls.__name__,
        category_type=category_type,
    )
    return db.relationship(
        'Categorization',
        primaryjoin=joinstr,
        backref=backref,
        cascade='all, delete-orphan',
    )

 def tag_association(cls):
     discriminator = cls.__name__.lower()
     creator = TagAssociation.creator(discriminator)
     kwargs = {"creator": creator, "getset_factory": _default_list_getset}
     cls.tags = associationproxy.association_proxy("tag_association", "tags", **kwargs)
     backref = orm.backref("%s_parent" % discriminator, uselist=False)
     return orm.relationship("TagAssociation", backref=backref)

	def InitMapper( cls, metadata, Parameter, ParameterType, ResourceQuantity ):
		mapper( cls, inherits = Parameter, polymorphic_identity = ParameterType, properties = {
			'_quantity' : relation( ResourceQuantity,
				collection_class = attribute_mapped_collection('resource'))
			})

		cls.quantity = association_proxy('_quantity', 'quantity', creator = lambda k, v: ResourceQuantity( resource = k, **v ) )

    def transaction_meta_factory(self):
        """
        Creates TransactionMeta class.
        """
        class TransactionMeta(
            self.declarative_base,
            TransactionMetaBase
        ):
            __tablename__ = 'transaction_meta'

        TransactionMeta.transaction_log = sa.orm.relationship(
            self.transaction_log_cls,
            backref=sa.orm.backref(
                'meta_relation',
                collection_class=attribute_mapped_collection('key')
            ),
            primaryjoin=(
                '%s.id == TransactionMeta.transaction_id' %
                self.transaction_log_cls.__name__
            ),
            foreign_keys=[TransactionMeta.transaction_id]
        )

        self.transaction_log_cls.meta = association_proxy(
            'meta_relation',
            'value',
            creator=lambda key, value: TransactionMeta(key=key, value=value)
        )

        return TransactionMeta

  def _categorizations(cls, rel_name, proxy_name, scope):
    setattr(cls, proxy_name, association_proxy(
        rel_name, 'category',
        creator=lambda category: Categorization(
            category=category,
            #FIXME add from http session!
            modified_by_id=1,
            categorizable_type=cls.__name__,
            ),
        ))
    joinstr = 'and_(foreign(Categorization.categorizable_id) == {type}.id, '\
                   'foreign(Categorization.categorizable_type) == "{type}", '\
                   'Categorization.category_id == Category.id, '\
                   'Category.scope_id == {scope})'
    joinstr = joinstr.format(type=cls.__name__, scope=scope)
    return db.relationship(
        'Categorization',
        primaryjoin=joinstr,
        backref=BACKREF_NAME_FORMAT.format(type=cls.__name__, scope=scope),
        )

  # FIXME: make eager-loading work for categorizations/assertations
  #@classmethod
  #def eager_query(cls):
  #  from sqlalchemy import orm

  #  query = super(Categorizable, cls).eager_query()
  #  return query.options(
  #      orm.subqueryload_all('categorizations.category'),
  #      orm.subqueryload_all('assertations.category'))

def _gen_array_simple(cls, props, k, child_cust, p):
    table_name = cls.Attributes.table_name
    metadata = cls.Attributes.sqla_metadata

    # get left (fk) column info
    _gen_col = _get_col_o2m(cls, p.left)
    col_info = next(_gen_col) # gets the column name
    p.left, child_left_col_type = col_info[0] # FIXME: Add support for multi-column primary keys.
    child_left_col_name = p.left

    # get right(data) column info
    child_right_col_type = get_sqlalchemy_type(child_cust)
    child_right_col_name = p.right # this is the data column
    if child_right_col_name is None:
        child_right_col_name = k

    # get table name
    child_table_name = child_cust.Attributes.table_name
    if child_table_name is None:
        child_table_name = '_'.join([table_name, k])

    if child_table_name in metadata.tables:
        child_t = metadata.tables[child_table_name]
        assert child_right_col_type is \
               child_t.c[child_right_col_name].type.__class__
        assert child_left_col_type is \
               child_t.c[child_left_col_name].type.__class__

    else:
        # table does not exist, generate table
        child_right_col = Column(child_right_col_name,
                                        child_right_col_type)
        _sp_attrs_to_sqla_constraints(cls, child_cust,
                                            col=child_right_col)

        child_left_col = next(_gen_col)
        _sp_attrs_to_sqla_constraints(cls, child_cust,
                                            col=child_left_col)

        child_t = Table(child_table_name , metadata,
            Column('id', sqlalchemy.Integer, primary_key=True),
                                child_left_col, child_right_col)

    # generate temporary class for association proxy
    cls_name = ''.join(x.capitalize() or '_' for x in
                                    child_table_name.split('_'))
                            # generates camelcase class name.

    def _i(self, *args):
        setattr(self, child_right_col_name, args[0])

    cls_ = type("_" + cls_name, (object,), {'__init__': _i})
    own_mapper(cls_)(cls_, child_t)
    props["_" + k] = relationship(cls_)

    # generate association proxy
    setattr(cls, k, association_proxy("_" + k, child_right_col_name))

 def fit_association(cls):
     discriminator = cls.__name__.lower()
     cls.fits= association_proxy(
                 "fit_association", "fits",
                 creator=Fit_Association.creator(discriminator)
             )
     return relationship(Fit_Association, 
                 cascade="all, delete-orphan", backref=backref("%s_analysis" % discriminator, 
                                     uselist=False))

def has_field_handler(entity, name, *args, **kwargs):
    if 'through' in kwargs:
        setattr(entity, name,
                association_proxy(kwargs.pop('through'),
                                  kwargs.pop('attribute', name),
                                  **kwargs))
        return
    field = Field(*args, **kwargs)
    field.attach(entity, name)

 def address_association(cls):
     discriminator = cls.__name__.lower()
     cls.addresses= association_proxy(
                 "address_association", "addresses",
                 creator=AddressAssociation.creator(discriminator)
             )
     return relationship("AddressAssociation", 
                 backref=backref("%s_parent" % discriminator, 
                                     uselist=False))

 def meta_association(cls):
     discriminator = cls.__name__.lower()
     cls.metas = association_proxy(
                 "meta_association", "metas",
                 creator=MetaAssociation.creator(discriminator)
             )
     return relationship("MetaAssociation",
                 backref=backref("%s_parent" % discriminator,
                                     uselist=False))

    def variable_association(cls):
        name = cls.__name__
        discriminator = name.lower()

        # Defines a polymorphic class to distinguish variables stored
        # for regions, cells, etc.
        cls.variable_assoc_cls = assoc_cls = type(
            "%sVariableAssociation" % name,
            (VariableAssociation,),
            {
                '__tablename__': None,  # because mapping into a shared table
                '__mapper_args__': {
                    'polymorphic_identity': discriminator
                }
            })

        def _assoc_creator(kv):
            assoc = assoc_cls()
            for key, value in kv.items():
                assoc.variables[key] = Variable(key=key, value=value)
            return assoc

        cls._variables = association_proxy(
            'variable_association', 'variables', creator=_assoc_creator)

        # Using a composite associative proxy here enables returning the
        # underlying values for a given key, as opposed to the
        # Variable object; we need both.
        cls.variables = association_proxy(
            'variable_association', 'values', creator=_assoc_creator)

        def with_characteristic(self, key, value):
            return self._variables.any(key=key, value=value)

        cls.with_characteristic = classmethod(with_characteristic)

        rel = relationship(
            assoc_cls,
            collection_class=attribute_mapped_collection('key'),
            cascade='all, delete-orphan', lazy='joined',
            single_parent=True,
            backref=backref('parent', uselist=False))

        return rel

 def handler(entity, name, *args, **kwargs):
     if 'through' in kwargs and 'via' in kwargs:
         setattr(entity, name,
                 association_proxy(kwargs.pop('through'),
                                   kwargs.pop('via'),
                                   **kwargs))
         return
     elif 'through' in kwargs or 'via' in kwargs:
         raise Exception("'through' and 'via' relationship keyword "
                         "arguments should be used in combination.")
     rel = target(kwargs.pop('of_kind'), *args, **kwargs)
     rel.attach(entity, name)

 def address_association(cls):
     discriminator = cls.__name__.lower()
     cls.addresses = association_proxy(
         'attachment_association', 'attachments',
         creator=AddressAssociation.creator(discriminator)
     )
     return relationship(
         'AttachmentAssociation',
         backref=sa.orm.backref(
             "%s_parent" % discriminator,
             uselist=False
         )
     )

    def address_association(cls):
        name = cls.__name__
        discriminator = name.lower()

        assoc_cls = type(
            "%sAddressAssociation" % name,
            (AddressAssociation,),
            dict(__mapper_args__={"polymorphic_identity": discriminator}),
        )

        cls.addresses = association_proxy(
            "address_association", "addresses", creator=lambda addresses: assoc_cls(addresses=addresses)
        )
        return relationship(assoc_cls, backref=backref("parent", uselist=False))

 def object_people(cls):
   cls.people = association_proxy(
       'object_people', 'person',
       creator=lambda person: ObjectPerson(
           person=person,
           modified_by_id=1,
           personable_type=cls.__name__,
           )
       )
   joinstr = 'and_(foreign(ObjectPerson.personable_id) == {type}.id, '\
                  'foreign(ObjectPerson.personable_type) == "{type}")'
   joinstr = joinstr.format(type=cls.__name__)
   return db.relationship(
       'ObjectPerson',
       primaryjoin=joinstr,
       backref='{0}_personable'.format(cls.__name__),
       )

 def object_sections(cls):
   cls.sections = association_proxy(
       'object_sections', 'section',
       creator=lambda section: ObjectSection(
           section=section,
           sectionable_type=cls.__name__,
           )
       )
   joinstr = 'and_(foreign(ObjectSection.sectionable_id) == {type}.id, '\
                  'foreign(ObjectSection.sectionable_type) == "{type}")'
   joinstr = joinstr.format(type=cls.__name__)
   return db.relationship(
       'ObjectSection',
       primaryjoin=joinstr,
       backref='{0}_sectionable'.format(cls.__name__),
       cascade='all, delete-orphan',
       )

 def object_controls(cls):
   cls.controls = association_proxy(
       'object_controls', 'control',
       creator=lambda control: ObjectControl(
           control=control,
           controllable_type=cls.__name__,
           )
       )
   joinstr = 'and_(foreign(ObjectControl.controllable_id) == {type}.id, '\
                  'foreign(ObjectControl.controllable_type) == "{type}")'
   joinstr = joinstr.format(type=cls.__name__)
   return db.relationship(
       'ObjectControl',
       primaryjoin=joinstr,
       backref='{0}_controllable'.format(cls.__name__),
       cascade='all, delete-orphan',
       )