self._relationship_options = {

            (attribute.property.parent.class_, attribute.property.key): self

        }

    def process_query_conditionally(self, query):

        """Process a Query that is used within a lazy loader.

        (the process_query_conditionally() method is a SQLAlchemy

        hook invoked only within lazyload.)

        """

        if query._current_path:

            mapper, key = query._current_path[-2:]

            for cls in mapper.class_.__mro__:

                if (cls, key) in self._relationship_options:

                    relationship_option = \

                        self._relationship_options[(cls, key)]

                    _set_cache_parameters(

                            query,

                            relationship_option.region,

                            relationship_option.namespace,

                            None)

    def and_(self, option):

        """Chain another RelationshipCache option to this one.

        While many RelationshipCache objects can be specified on a single

        Query separately, chaining them together allows for a more efficient

        lookup during load.

        """

        self._relationship_options.update(option._relationship_options)

        return self

def _params_from_query(query):

    """Pull the bind parameter values from a query.

    This takes into account any scalar attribute bindparam set up.

    E.g. params_from_query(query.filter(Cls.foo==5).filter(Cls.bar==7)))

    would return [5, 7].

    """

    v = []

    def visit_bindparam(bind):

        value = query._params.get(bind.key, bind.value)

        # lazyloader may dig a callable in here, intended

        # to late-evaluate params after autoflush is called.

        # convert to a scalar value.

        if callable(value):

            value = value()

        v.append(value)

    if query._criterion is not None:

        visitors.traverse(query._criterion, {}, {'bindparam':visit_bindparam})

    return v