def slices(self):
     return relationship(
         'Slice',
         primaryjoin=lambda: and_(
             foreign(Slice.datasource_id) == self.id,
             foreign(Slice.datasource_type) == self.type,
         ),
     )

 def redirect(cls):
     pk = getattr(cls, cls.get_pk_name())
     return relationship(
         cls, foreign_keys=[cls.redirect_page],
         remote_side='{}.{}'.format(cls.__name__, cls.get_pk_name()),
         primaryjoin=lambda: foreign(cls.redirect_page) == pk,
     )

    def test_dont_send_neverset_to_get_w_relationship(self):
        # test issue #3647
        CompositePk, composite_pk_table = (self.classes.CompositePk, self.tables.composite_pk_table)
        User, users = (self.classes.User, self.tables.users)
        mapper(
            User,
            users,
            properties={
                "elements": relationship(CompositePk, primaryjoin=users.c.id == foreign(composite_pk_table.c.i))
            },
        )
        mapper(CompositePk, composite_pk_table)

        u1 = User(id=5, name="some user")
        cp1 = CompositePk(j=1, k=1)
        u1.elements.append(cp1)
        sess = Session()

        rec = []

        def go():
            rec.append(sess.merge(u1))

        self.assert_sql_count(testing.db, go, 1)
        u2 = rec[0]
        sess.commit()
        eq_(u2.elements[0].i, 5)
        eq_(u2.id, 5)

 def __init__(self, to, ct_field='model', to_field='object_id', lazy='dynamic', primary_join=None, *args, **kwargs):
     if primary_join is None:
         primary_join = lambda model, fk_model: and_(
             model._meta.pk.column == foreign(fk_model._meta.fields[to_field].column),
             fk_model._meta.fields_dict[ct_field].column == model._meta.name
         )
     super(GenericOneToManyField, self).__init__(to, to_field, lazy=lazy, primary_join=primary_join, *args, **kwargs)

 def __declare_last__(cls):
     from .invoice import Job
     cls.jobs = relation('Job',
                         primaryjoin=cls.guid == foreign(Job.owner_guid),
                         cascade='all, delete-orphan',
                         collection_class=CallableList,
                         )

def setup_listener(mapper, class_):
    name = class_.__name__
    discriminator = name.lower()
    class_.addresses = relationship(Address,
                        primaryjoin=and_(
                                        class_.id == foreign(remote(Address.parent_id)),
                                        Address.discriminator == discriminator
                                    ),
                        backref=backref(
                                "parent_%s" % discriminator,
                                primaryjoin=remote(class_.id) == foreign(Address.parent_id)
                                )
                        )
    @event.listens_for(class_.addresses, "append")
    def append_address(target, value, initiator):
        value.discriminator = discriminator

    def slots(cls):
        rel = relation('Slot',
                       primaryjoin=foreign(Slot.obj_guid) == cls.guid,
                       cascade='all, delete-orphan',
                       collection_class=CallableList,
                       )

        return rel

def setup_listener(mapper, class_):
    name = class_.__name__
    content_type = name.lower()
    # Reverse relationship (ie. Segment.entities)
    class_.entities = relationship(Entity,
        primaryjoin = and_(
            class_.id == foreign(remote(Entity.object_id)),
            Entity.content_type == content_type
        ),
        backref = backref(
            'parent_{0}'.format(content_type),
            primaryjoin=remote(class_.id) == foreign(Entity.object_id)
        )
    )
    @event.listens_for(class_.entities, 'append')
    def append_entity(target, value, initiator):
        value.content_type = content_type

    def _unhashable_fixture(self, metadata, load_on_pending=False):
        class MyHashType(sa.TypeDecorator):
            impl = sa.String(100)

            def process_bind_param(self, value, dialect):
                return ";".join(
                    "%s=%s" % (k, v)
                    for k, v in sorted(value.items(), key=lambda key: key[0])
                )

            def process_result_value(self, value, dialect):
                return dict(elem.split("=", 1) for elem in value.split(";"))

        category = Table(
            "category",
            metadata,
            Column("id", Integer, primary_key=True),
            Column("data", MyHashType()),
        )
        article = Table(
            "article",
            metadata,
            Column("id", Integer, primary_key=True),
            Column("data", MyHashType()),
        )

        class Category(fixtures.ComparableEntity):
            pass

        class Article(fixtures.ComparableEntity):
            pass

        mapper(Category, category)
        mapper(
            Article,
            article,
            properties={
                "category": relationship(
                    Category,
                    primaryjoin=orm.foreign(article.c.data) == category.c.data,
                    load_on_pending=load_on_pending,
                )
            },
        )

        metadata.create_all()
        sess = Session(autoflush=False)
        data = {"im": "unhashable"}
        a1 = Article(id=1, data=data)
        c1 = Category(id=1, data=data)
        if load_on_pending:
            sess.add(c1)
        else:
            sess.add_all([c1, a1])
        sess.flush()
        if load_on_pending:
            sess.add(a1)
        return Category, Article, sess, a1, c1

    def rel_acl(self):
        """
Relation to AclEntry

:return: (object) SQLAlchemy relationship description
:since:  v0.2.00
        """

        return relationship(AclEntry, primaryjoin = (foreign(self.id) == remote(AclEntry.owned_id)), uselist = True)

    def rel_text_entry(self):
        """
Relation to TextEntry

:return: (object) SQLAlchemy relationship description
:since:  v0.2.00
        """

        return relationship(TextEntry, primaryjoin = (foreign(self.id) == remote(TextEntry.id)), uselist = False)

 def _join_fixture_o2m_to_annotated_func(self, **kw):
     return relationships.JoinCondition(
         self.left,
         self.right,
         self.left,
         self.right,
         primaryjoin=self.left.c.id == foreign(func.foo(self.right.c.lid)),
         **kw
     )

 def _join_fixture_purely_single_m2o(self, **kw):
     return relationships.JoinCondition(
         self.purely_single_col,
         self.purely_single_col,
         self.purely_single_col,
         self.purely_single_col,
         support_sync=False,
         primaryjoin=remote(self.purely_single_col.c.path).like(
             foreign(self.purely_single_col.c.path.concat("%"))
         ),
     )

 def _join_fixture_remote_local_multiple_ref(self, **kw):
     fn = lambda a, b: ((a == b) | (b == a))
     return relationships.JoinCondition(
         self.selfref, self.selfref,
         self.selfref, self.selfref,
         support_sync=False,
         primaryjoin=fn(
             # we're putting a do-nothing annotation on
             # "a" so that the left/right is preserved;
             # annotation vs. non seems to affect __eq__ behavior
             self.selfref.c.sid._annotate({"foo": "bar"}),
             foreign(remote(self.selfref.c.sid)))
     )

 def related(cls):
     id_column = getattr(cls, id_label)
     related_id_column = getattr(related_model, related_id_label)
     filters = [foreign(id_column) == related_id_column]
     if cycle_label:
         cycle_column = getattr(cls, cycle_label)
         if use_modulus:
             cycle_column = cycle_column + cycle_column % 2
         related_cycle_column = getattr(related_model, related_cycle_label)
         filters.append(cycle_column == related_cycle_column)
     return db.relationship(
         related_model,
         primaryjoin=sa.and_(*filters),
     )

    def setup_mappers(cls):
        mapper(cls.classes.Person, cls.tables.person, properties=dict(
            pets=relationship(
                cls.classes.Pet, primaryjoin=(
                    orm.foreign(cls.tables.pets.c.person_id) ==
                    sa.cast(
                        sa.type_coerce(cls.tables.person.c.id, Integer),
                        Integer
                    )
                )
            )
        ))

        mapper(cls.classes.Pet, cls.tables.pets)

def fetch_users_to_sync(session, required_property=None):
    # type: (...) -> List[_ResultProxyType]
    """Fetch the users who should be synced

    :param session: The SQLAlchemy session to use
    :param str required_property: the property required to export users

    :returns: An iterable of `(User, should_be_blocked)` ResultProxies
        having the property `required_property' and a unix_account.
    """
    if required_property:
        no_unix_account_q = User.q.join(User.current_properties)\
            .filter(CurrentProperty.property_name == required_property,
                    User.unix_account == None)
    else:
        no_unix_account_q = User.q.filter(User.unix_account == None)

    count_exportable_but_no_account = no_unix_account_q.count()

    if required_property:
        logger.warning("%s users have the '%s' property but not a unix_account",
                       count_exportable_but_no_account, required_property)
    else:
        logger.warning("%s users applicable to exporting don't have a unix_account",
                       count_exportable_but_no_account)

    # used for second join against CurrentProperty
    not_blocked_property = CurrentProperty.__table__.alias('ldap_login_enabled')

    return (
        # Grab all users with the required property
        User.q
        .options(joinedload(User.unix_account))
        .join(User.current_properties)
        .filter(CurrentProperty.property_name == required_property,
                User.unix_account != None)

        # additional info:
        #  absence of `ldap_login_enabled` property → should_be_blocked
        .add_column(not_blocked_property.c.property_name.is_(None)
                    .label('should_be_blocked'))
        .outerjoin(
            not_blocked_property,
            and_(User.id == foreign(not_blocked_property.c.user_id),
                 ~not_blocked_property.c.denied,
                 not_blocked_property.c.property_name == 'ldap_login_enabled')
        ).all()
    )

    def __declare_last__(cls):
        from .invoice import Job
        owner_type = PersonType.get(cls, None)
        if owner_type:
            cls.jobs = relation('Job',
                                primaryjoin=and_(
                                    cls.guid == foreign(Job.owner_guid),
                                    owner_type == Job.owner_type,
                                ),
                                cascade='all, delete-orphan',
                                collection_class=CallableList,
                                )

            @event.listens_for(cls.jobs, "append")
            def add(target, value, initiator):
                value.owner_type = owner_type
                value.owner_guid = target.guid
                value._assign_id()

Chat.request   = relationship(Request)

Message.chat = relationship(Chat, backref="messages")
Message.user = relationship(User, backref="messages")
Message.chat_user = relationship(
    ChatUser,
    primaryjoin=and_(Message.chat_id == ChatUser.chat_id, Message.user_id == ChatUser.user_id),
    foreign_keys=[Message.chat_id, Message.user_id],
)

ChatUser.chat = relationship(Chat, backref="users")
ChatUser.user = relationship(User, backref="chats")
ChatUser.export = relationship(
    ChatExport,
    primaryjoin=and_(
        ChatUser.chat_id == foreign(ChatExport.chat_id),
        ChatUser.user_id == foreign(ChatExport.user_id),
    ),
    uselist=False,
    viewonly=True,
)

ChatExport.chat = relationship(Chat)
ChatExport.user = relationship(User)

PromptReport.duplicate_of = relationship(PromptReport, backref="duplicates", remote_side=PromptReport.id)
PromptReport.reporting_user = relationship(User, backref="reports_sent", primaryjoin=PromptReport.reporting_user_id == User.id)
PromptReport.reported_user = relationship(User, backref="reports_recieved", primaryjoin=PromptReport.reported_user_id == User.id)

Request.user = relationship(User, backref="requests")
Request.tags = relationship(Tag, secondary=RequestTag.__table__, order_by=(Tag.type, Tag.name), backref="requests")

        if session:
            session.commit()


mapper(SubNode, subnode_table,
       properties=dict(_state=subnode_table.c.state))


mapper(Node, node_table,
       properties=dict(
           _state=node_table.c.state,
           subnodes=relationship(
               SubNode,
               cascade='all, delete-orphan',
               uselist=True,
               primaryjoin=foreign(subnode_table.c.node_id) == node_table.c.id,
               backref='node')))


mapper(SnapshotImage, snapshot_image_table,
       properties=dict(_state=snapshot_image_table.c.state))

mapper(DibImage, dib_image_table,
       properties=dict(_state=dib_image_table.c.state))


class NodeDatabase(object):
    def __init__(self, dburi):
        engine_kwargs = dict(echo=False, pool_recycle=3600)
        if 'sqlite:' not in dburi:
            engine_kwargs['max_overflow'] = -1