:param region: the cache region.  Should be a

        region configured in the Beaker CacheManager.

        :param namespace: the cache namespace.  Should

        be a name uniquely describing the target Query's

        lexical structure.

        :param cache_key: optional.  A string cache key

        that will serve as the key to the query.   Use this

        if your query has a huge amount of parameters (such

        as when using in_()) which correspond more simply to

        some other identifier.

        """

        self.region = region

        self.namespace = namespace

        self.cache_key = cache_key

    def process_query(self, query):

        """Process a Query during normal loading operation."""

        _set_cache_parameters(query, self.region, self.namespace,

                              self.cache_key)

class RelationshipCache(MapperOption):

    """Specifies that a Query as called within a "lazy load"

       should load results from a cache."""

    propagate_to_loaders = True

    def __init__(self, region, namespace, attribute):

        """Construct a new RelationshipCache.

        :param region: the cache region.  Should be a

        region configured in the Beaker CacheManager.

        :param namespace: the cache namespace.  Should

        be a name uniquely describing the target Query's

        lexical structure.

        :param attribute: A Class.attribute which

        indicates a particular class relationship() whose

        lazy loader should be pulled from the cache.

        """

        self.region = region

        self.namespace = namespace

        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