propagate=False for relationship properties

patch attached

this feature modifies two things:

we no longer raise an error on backrefs where the name conflicts when doing a concrete mapper. This behavior was inconsistent vs. forward same-named refs created on concrete mappers. more tests will be needed in orm/test_concrete.py for this.
the propagate=False flag on backref and relationship allows you to specify different relationships per subclass even in joined and single inh. tests will be needed to check that a subclass that doesn't re-implement a relationship gets this error:
```
AttributeError: Concrete/non-propagated Mapper|Manager|manager does not implement attribute 'versions' at the instance level.  Add this property explicitly to Mapper|Manager|manager.
```
some mechanics are broken on ConcreteInheritedProp so try to test more of it.

A test script is as follows:

from sqlalchemy import *
from sqlalchemy.orm import *
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class Employee(Base):
    __tablename__ = 'employee'
    id = Column(Integer, primary_key=True)
    name = Column(String(50))
    type = Column(String(50))

    __mapper_args__ = {
        'polymorphic_identity': 'employee', 'polymorphic_on': type
    }
    def __repr__(self):
        return "Ordinary person %s" % self.name

class Engineer(Employee):
    __tablename__ = 'engineer'
    id = Column(Integer, ForeignKey('employee.id'), primary_key=True)
    status = Column(String(30))
    engineer_name = Column(String(30))
    primary_language = Column(String(30))

    __mapper_args__ = {
        'polymorphic_identity': 'engineer',
    }
    def __repr__(self):
        return "Engineer %s, status %s, engineer_name %s, "\
                "primary_language %s" % \
                    (self.name, self.status,
                        self.engineer_name, self.primary_language)

class Manager(Employee):
    __tablename__ = 'manager'
    id = Column(Integer, ForeignKey('employee.id'), primary_key=True)
    status = Column(String(30))
    manager_name = Column(String(30))

    __mapper_args__ = {
        'polymorphic_identity': 'manager',
    }
    def __repr__(self):
        return "Manager %s, status %s, manager_name %s" % \
                    (self.name, self.status, self.manager_name)


class Version(Base):
    __abstract__ = True

    version_id = Column(Integer, primary_key=True)

class EmployeeH(Version):
    __tablename__ = 'employee_h'

    id = Column(Integer, ForeignKey('employee.id'), primary_key=True)
    employee = relationship(Employee, backref=backref('versions', propagate=False))

class EngineerH(Version):
    __tablename__ = 'engineer_h'

    id = Column(Integer, ForeignKey('engineer.id'), primary_key=True)
    employee = relationship(Engineer, backref=backref('versions', propagate=False))

#class ManagerH(Version):
#    __tablename__ = 'manager_h'

#    id = Column(Integer, ForeignKey('manager.id'), primary_key=True)
#    employee = relationship(Manager, backref=backref('versions', propagate=False))


e = create_engine("sqlite://", echo=True)
Base.metadata.create_all(e)

s = Session(e)

s.add_all([
    Employee(name='e1', versions=[EmployeeH(version_id=1), EmployeeH(version_id=2)]),
    Engineer(name='e1', versions=[EngineerH(version_id=1), EngineerH(version_id=2)]),
])

s.commit()
s.close()

print s.query(Engineer).join(Engineer.versions)

e1 = s.query(Engineer).first()
print e1.versions

# assert that these all raise:
# AttributeError: Concrete/non-propagated Mapper|Manager|manager does not
# implement attribute 'versions' at the instance or class level.  Add this property
# explicitly to Mapper|Manager|manager.

try:
    print s.query(Manager).join(Manager.versions)
except:
    pass

try:
    # this should raise ideally, seems to just be ignored at the moment
    print s.query(Manager).options(eagerload(Manager.versions))
except:
    raise
    pass

try:
    # assert that this raises:
    m1 = Manager()
    m1.versions
except:
    pass

Comments (17)