cache, cache_key = _get_cache_parameters(self)

        cache.remove(cache_key)

    def get_value(self, merge=True, createfunc=None):

        """Return the value from the cache for this query.

        Raise KeyError if no value present and no

        createfunc specified.

        """

        cache, cache_key = _get_cache_parameters(self)

        ret = cache.get_value(cache_key, createfunc=createfunc)

        if merge:

            ret = self.merge_result(ret, load=False)

        return ret

    def set_value(self, value):

        """Set the value in the cache for this query."""

        cache, cache_key = _get_cache_parameters(self)

        cache.put(cache_key, value)

def query_callable(manager, query_cls=CachingQuery):

    def query(*arg, **kw):

        return query_cls(manager, *arg, **kw)

    return query

def get_cache_region(name, region):

    if region not in beaker.cache.cache_regions:

        raise BeakerException('Cache region `%s` not configured '

            'Check if proper cache settings are in the .ini files' % region)

    kw = beaker.cache.cache_regions[region]

    return beaker.cache.Cache._get_cache(name, kw)

def _get_cache_parameters(query):

    """For a query with cache_region and cache_namespace configured,

    return the correspoinding Cache instance and cache key, based

    on this query's current criterion and parameter values.

    """

    if not hasattr(query, '_cache_parameters'):

        raise ValueError("This Query does not have caching "

                         "parameters configured.")

    region, namespace, cache_key = query._cache_parameters

    namespace = _namespace_from_query(namespace, query)

    if cache_key is None:

        # cache key - the value arguments from this query's parameters.

        args = _params_from_query(query)

        cache_key = " ".join([str(x) for x in args])

    # get cache

    #cache = query.cache_manager.get_cache_region(namespace, region)

    cache = get_cache_region(namespace, region)

    # optional - hash the cache_key too for consistent length

    # import uuid

    # cache_key= str(uuid.uuid5(uuid.NAMESPACE_DNS, cache_key))

    return cache, cache_key

def _namespace_from_query(namespace, query):

    # cache namespace - the token handed in by the

    # option + class we're querying against

    namespace = " ".join([namespace] + [str(x) for x in query._entities])

    # memcached wants this

    namespace = namespace.replace(' ', '_')

    return namespace

def _set_cache_parameters(query, region, namespace, cache_key):

    if hasattr(query, '_cache_parameters'):

        region, namespace, cache_key = query._cache_parameters

        raise ValueError("This query is already configured "

                        "for region %r namespace %r" %

                        (region, namespace)

                    )

    query._cache_parameters = region, namespace, cache_key

class FromCache(MapperOption):

    """Specifies that a Query should load results from a cache."""

    propagate_to_loaders = False

    def __init__(self, region, namespace, cache_key=None):

        """Construct a new FromCache.

        :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