ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [06/35] incubator-ignite git commit: # IGNITE-261 Cleanup API: WIP scalar.
Date Mon, 16 Feb 2015 14:16:43 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7007771c/modules/scalar/src/main/scala/org/apache/ignite/scalar/pimps/ScalarCacheProjectionPimp.scala
----------------------------------------------------------------------
diff --git a/modules/scalar/src/main/scala/org/apache/ignite/scalar/pimps/ScalarCacheProjectionPimp.scala b/modules/scalar/src/main/scala/org/apache/ignite/scalar/pimps/ScalarCacheProjectionPimp.scala
deleted file mode 100644
index e9308f8..0000000
--- a/modules/scalar/src/main/scala/org/apache/ignite/scalar/pimps/ScalarCacheProjectionPimp.scala
+++ /dev/null
@@ -1,2004 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.scalar.pimps
-
-import javax.cache.Cache
-
-import org.apache.ignite._
-import org.apache.ignite.cache.CacheProjection
-import org.apache.ignite.cluster.ClusterGroup
-import org.apache.ignite.internal.util.scala.impl
-import org.apache.ignite.lang.{IgniteBiTuple, IgniteClosure, IgnitePredicate, IgniteReducer}
-import org.apache.ignite.scalar.scalar._
-import org.jetbrains.annotations.Nullable
-
-import scala.collection.JavaConversions._
-import scala.collection._
-
-/**
- * Companion object.
- */
-object ScalarCacheProjectionPimp {
-    /**
-     * Creates new Scalar cache projection pimp with given Java-side implementation.
-     *
-     * @param impl Java-side implementation.
-     */
-    def apply[K, V](impl: CacheProjection[K, V]) = {
-        if (impl == null)
-            throw new NullPointerException("impl")
-
-        val pimp = new ScalarCacheProjectionPimp[K, V]
-
-        pimp.impl = impl
-
-        pimp
-    }
-}
-
-/**
- * ==Overview==
- * Defines Scalar "pimp" for `CacheProjection` on Java side.
- *
- * Essentially this class extends Java `CacheProjection` interface with Scala specific
- * API adapters using primarily implicit conversions defined in `ScalarConversions` object. What
- * it means is that you can use functions defined in this class on object
- * of Java `CacheProjection` type. Scala will automatically (implicitly) convert it into
- * Scalar's pimp and replace the original call with a call on that pimp.
- *
- * Note that Scalar provide extensive library of implicit conversion between Java and
- * Scala Ignite counterparts in `ScalarConversions` object
- *
- * ==Suffix '$' In Names==
- * Symbol `$` is used in names when they conflict with the names in the base Java class
- * that Scala pimp is shadowing or with Java package name that your Scala code is importing.
- * Instead of giving two different names to the same function we've decided to simply mark
- * Scala's side method with `$` suffix.
- */
-class ScalarCacheProjectionPimp[@specialized K, @specialized V] extends PimpedType[CacheProjection[K, V]]
-    with Iterable[Cache.Entry[K, V]] {
-    /** */
-    lazy val value: CacheProjection[K, V] = impl
-
-    /** */
-    protected var impl: CacheProjection[K, V] = _
-
-    /** Type alias. */
-    protected type EntryPred = (Cache.Entry[K, V]) => Boolean
-
-    /** Type alias. */
-    protected type KvPred = (K, V) => Boolean
-
-    /**
-     * Gets iterator for cache entries.
-     */
-    def iterator =
-        toScalaSeq(value.iterator).iterator
-
-    /**
-     * Unwraps sequence of functions to sequence of Ignite predicates.
-     */
-    private def unwrap(@Nullable p: Seq[EntryPred]): Seq[IgnitePredicate[Cache.Entry[K, V]]] =
-        if (p == null)
-            null
-        else
-            p map ((f: EntryPred) => toPredicate(f))
-
-    /**
-     * Converts reduce function to Grid Reducer that takes map entries.
-     *
-     * @param rdc Reduce function.
-     * @return Entry reducer.
-     */
-    private def toEntryReducer[R](rdc: Iterable[(K, V)] => R): IgniteReducer[java.util.Map.Entry[K, V], R] = {
-        new IgniteReducer[java.util.Map.Entry[K, V], R] {
-            private var seq = Seq.empty[(K, V)]
-
-            def collect(e: java.util.Map.Entry[K, V]): Boolean = {
-                seq +:= (e.getKey, e.getValue)
-
-                true
-            }
-
-            def reduce(): R = {
-                rdc(seq)
-            }
-        }
-    }
-
-    private def toRemoteTransformer[K, V, T](trans: V => T):
-        IgniteClosure[java.util.Map.Entry[K, V], java.util.Map.Entry[K, T]] = {
-        new IgniteClosure[java.util.Map.Entry[K, V], java.util.Map.Entry[K, T]] {
-            @impl def apply(e: java.util.Map.Entry[K, V]): java.util.Map.Entry[K, T] = {
-                new IgniteBiTuple[K, T](e.getKey, trans(e.getValue))
-            }
-        }
-    }
-
-    /**
-     * Retrieves value mapped to the specified key from cache. The return value of `null`
-     * means entry did not pass the provided filter or cache has no mapping for the key.
-     *
-     * @param k Key to retrieve the value for.
-     * @return Value for the given key.
-     */
-    def apply(k: K): V =
-        value.get(k)
-
-    /**
-     * Returns the value associated with a key, or a default value if the key is not contained in the map.
-     *
-     * @param k The key.
-     * @param default A computation that yields a default value in case key is not in cache.
-     * @return The cache value associated with `key` if it exists, otherwise the result
-     *      of the `default` computation.
-     */
-    def getOrElse(k: K, default: => V) = {
-        opt(k) match {
-            case Some(v) => v
-            case None => default
-        }
-    }
-
-    /**
-     * Retrieves value mapped to the specified key from cache as an option. The return value
-     * of `null` means entry did not pass the provided filter or cache has no mapping for the key.
-     *
-     * @param k Key to retrieve the value for.
-     * @param p Filter to check prior to getting the value. Note that filter check
-     *      together with getting the value is an atomic operation.
-     * @return Value for the given key.
-     * @see `CacheProjection.get(...)`
-     */
-    def opt(k: K, p: EntryPred = null): Option[V] =
-        Option(value.projection(p).get(k))
-
-    /**
-     * Gets cache projection based on given key-value predicate. Whenever makes sense,
-     * this predicate will be used to pre-filter cache operations. If
-     * operation passed pre-filtering, this filter will be passed through
-     * to cache operations as well.
-     *
-     * @param p Key-value predicate for this projection. If `null`, then the
-     *      same projection is returned.
-     * @return Projection for given key-value predicate.
-     * @see `CacheProjection.projection(...)`
-     */
-    def viewByKv(@Nullable p: ((K, V) => Boolean)): CacheProjection[K, V] =
-        if (p == null)
-            value
-        else
-            value.projection(p)
-
-    /**
-     * Gets cache projection based on given entry filter. This filter will be simply passed through
-     * to all cache operations on this projection. Unlike `viewByKv` function, this filter
-     * will '''not''' be used for pre-filtering.
-     *
-     * @param p Filter to be passed through to all cache operations. If `null`, then the
-     *      same projection is returned.  If cache operation receives its own filter, then filters
-     *      will be `anded`.
-     * @return Projection based on given filter.
-     * @see `CacheProjection.projection(...)`
-     */
-    def viewByEntry(@Nullable p: EntryPred): CacheProjection[K, V] =
-        if (p == null)
-            value
-        else
-            value.projection(p)
-
-    /**
-     * Gets cache projection only for given key and value type. Only `non-null` key-value
-     * pairs that have matching key and value pairs will be used in this projection.
-     *
-     * Note that this method should be used instead of `projection(...)` on Java side as
-     * it properly converts types from Scala counterparts to Java ones.
-     *
-     * ===Cache Flags===
-     * The resulting projection will have flag `CacheFlag#STRICT` set on it.
-     *
-     * @param k Key type.
-     * @param v Value type.
-     * @return Cache projection for given key and value types.
-     * @see `CacheProjection.projection(...)`
-     */
-    def viewByType[A, B](k: Class[A], v: Class[B]): CacheProjection[A, B] = {
-        assert(k != null && v != null)
-
-        value.projection(toJavaType(k), toJavaType(v)).asInstanceOf[CacheProjection[A, B]]
-    }
-
-    /**
-     * Converts given type of corresponding Java type, if Scala does
-     * auto-conversion for a given type. Only primitive types and Strings
-     * are supported.
-     *
-     * @param c Type to convert.
-     */
-    private def toJavaType(c: Class[_]) = {
-        assert(c != null)
-
-        // Hopefully if-else is faster here than a normal matching.
-        if (c == classOf[Int])
-            classOf[java.lang.Integer]
-        else if (c == classOf[Boolean])
-            classOf[java.lang.Boolean]
-        else if (c == classOf[String])
-            classOf[java.lang.String]
-        else if (c == classOf[Char])
-            classOf[java.lang.Character]
-        else if (c == classOf[Long])
-            classOf[java.lang.Long]
-        else if (c == classOf[Double])
-            classOf[java.lang.Double]
-        else if (c == classOf[Float])
-            classOf[java.lang.Float]
-        else if (c == classOf[Short])
-            classOf[java.lang.Short]
-        else if (c == classOf[Byte])
-            classOf[java.lang.Byte]
-        else if (c == classOf[Symbol])
-            throw new IgniteCheckedException("Cache type projeciton on 'scala.Symbol' are not supported.")
-        else
-            c
-    }
-
-    /**
-     * Stores given key-value pair in cache. If filters are provided, then entries will
-     * be stored in cache only if they pass the filter. Note that filter check is atomic,
-     * so value stored in cache is guaranteed to be consistent with the filters.
-     * <p>
-     * If write-through is enabled, the stored value will be persisted to `GridCacheStore`
-     * via `GridCacheStore#put(String, GridCacheTx, Object, Object)` method.
-     *
-     * ===Transactions===
-     * This method is transactional and will enlist the entry into ongoing transaction
-     * if there is one.
-     *
-     * ===Cache Flags===
-     * This method is not available if any of the following flags are set on projection:
-     * `CacheFlag#LOCAL`, `CacheFlag#READ`.
-     *
-     * @param kv Key-Value pair to store in cache.
-     * @param p Optional filter to check prior to putting value in cache. Note
-     *      that filter check is atomic with put operation.
-     * @return `True` if value was stored in cache, `false` otherwise.
-     * @see `CacheProjection#putx(...)`
-     */
-    def putx$(kv: (K, V), @Nullable p: EntryPred*): Boolean =
-        value.putx(kv._1, kv._2, unwrap(p): _*)
-
-    /**
-     * Stores given key-value pair in cache. If filters are provided, then entries will
-     * be stored in cache only if they pass the filter. Note that filter check is atomic,
-     * so value stored in cache is guaranteed to be consistent with the filters.
-     * <p>
-     * If write-through is enabled, the stored value will be persisted to `GridCacheStore`
-     * via `GridCacheStore#put(String, GridCacheTx, Object, Object)` method.
-     *
-     * ===Transactions===
-     * This method is transactional and will enlist the entry into ongoing transaction
-     * if there is one.
-     *
-     * ===Cache Flags===
-     * This method is not available if any of the following flags are set on projection:
-     * `CacheFlag#LOCAL`, `CacheFlag#READ`.
-     *
-     * @param kv Key-Value pair to store in cache.
-     * @param p Optional filter to check prior to putting value in cache. Note
-     *      that filter check is atomic with put operation.
-     * @return Previous value associated with specified key, or `null`
-     *      if entry did not pass the filter, or if there was no mapping for the key in swap
-     *      or in persistent storage.
-     * @see `CacheProjection#put(...)`
-     */
-    def put$(kv: (K, V), @Nullable p: EntryPred*): V =
-        value.put(kv._1, kv._2, unwrap(p): _*)
-
-    /**
-     * Stores given key-value pair in cache. If filters are provided, then entries will
-     * be stored in cache only if they pass the filter. Note that filter check is atomic,
-     * so value stored in cache is guaranteed to be consistent with the filters.
-     * <p>
-     * If write-through is enabled, the stored value will be persisted to `GridCacheStore`
-     * via `GridCacheStore#put(String, GridCacheTx, Object, Object)` method.
-     *
-     * ===Transactions===
-     * This method is transactional and will enlist the entry into ongoing transaction
-     * if there is one.
-     *
-     * ===Cache Flags===
-     * This method is not available if any of the following flags are set on projection:
-     * `CacheFlag#LOCAL`, `CacheFlag#READ`.
-     *
-     * @param kv Key-Value pair to store in cache.
-     * @param p Optional filter to check prior to putting value in cache. Note
-     *      that filter check is atomic with put operation.
-     * @return Previous value associated with specified key as an option.
-     * @see `CacheProjection#put(...)`
-     */
-    def putOpt$(kv: (K, V), @Nullable p: EntryPred*): Option[V] =
-        Option(value.put(kv._1, kv._2, unwrap(p): _*))
-
-    /**
-     * Operator alias for the same function `putx$`.
-     *
-     * @param kv Key-Value pair to store in cache.
-     * @param p Optional filter to check prior to putting value in cache. Note
-     *      that filter check is atomic with put operation.
-     * @return `True` if value was stored in cache, `false` otherwise.
-     * @see `CacheProjection#putx(...)`
-     */
-    def +=(kv: (K, V), @Nullable p: EntryPred*): Boolean =
-        putx$(kv, p: _*)
-
-    /**
-     * Stores given key-value pairs in cache.
-     *
-     * If write-through is enabled, the stored values will be persisted to `GridCacheStore`
-     * via `GridCacheStore#putAll(String, GridCacheTx, Map)` method.
-     *
-     * ===Transactions===
-     * This method is transactional and will enlist the entry into ongoing transaction
-     * if there is one.
-     *
-     * ===Cache Flags===
-     * This method is not available if any of the following flags are set on projection:
-     * `CacheFlag#LOCAL`, `CacheFlag#READ`.
-     *
-     * @param kv1 Key-value pair to store in cache.
-     * @param kv2 Key-value pair to store in cache.
-     * @param kvs Optional key-value pairs to store in cache.
-     * @see `CacheProjection#putAll(...)`
-     */
-    def putAll$(kv1: (K, V), kv2: (K, V), @Nullable kvs: (K, V)*) {
-        var m = mutable.Map.empty[K, V]
-
-        m += (kv1, kv2)
-
-        if (kvs != null)
-            kvs foreach (m += _)
-
-        value.putAll(m)
-    }
-
-    /**
-     * Stores given key-value pairs from the sequence in cache.
-     *
-     * If write-through is enabled, the stored values will be persisted to `GridCacheStore`
-     * via `GridCacheStore#putAll(String, GridCacheTx, Map)` method.
-     *
-     * ===Transactions===
-     * This method is transactional and will enlist the entry into ongoing transaction
-     * if there is one.
-     *
-     * ===Cache Flags===
-     * This method is not available if any of the following flags are set on projection:
-     * `CacheFlag#LOCAL`, `CacheFlag#READ`.
-     *
-     * @param kvs Key-value pairs to store in cache. If `null` this function is no-op.
-     * @see `CacheProjection#putAll(...)`
-     */
-    def putAll$(@Nullable kvs: Seq[(K, V)]) {
-        if (kvs != null)
-            value.putAll(mutable.Map(kvs: _*))
-    }
-
-    /**
-     * Removes given key mappings from cache.
-     *
-     * If write-through is enabled, the values will be removed from `GridCacheStore`
-     * via `GridCacheStore#removeAll(String, GridCacheTx, Collection)` method.
-     *
-     * ===Transactions===
-     * This method is transactional and will enlist the entry into ongoing transaction
-     * if there is one.
-     *
-     * ===Cache Flags===
-     * This method is not available if any of the following flags are set on projection:
-     * `CacheFlag#LOCAL`, `CacheFlag#READ`.
-     *
-     * @param ks Sequence of additional keys to remove. If `null` - this function is no-op.
-     * @see `CacheProjection#removeAll(...)`
-     */
-    def removeAll$(@Nullable ks: Seq[K]) {
-        if (ks != null)
-            value.removeAll(ks)
-    }
-
-    /**
-     * Operator alias for the same function `putAll$`.
-     *
-     * @param kv1 Key-value pair to store in cache.
-     * @param kv2 Key-value pair to store in cache.
-     * @param kvs Optional key-value pairs to store in cache.
-     * @see `CacheProjection#putAll(...)`
-     */
-    def +=(kv1: (K, V), kv2: (K, V), @Nullable kvs: (K, V)*) {
-        putAll$(kv1, kv2, kvs: _*)
-    }
-
-    /**
-     * Removes given key mapping from cache. If cache previously contained value for the given key,
-     * then this value is returned. Otherwise, in case of `CacheMode#REPLICATED` caches,
-     * the value will be loaded from swap and, if it's not there, and read-through is allowed,
-     * from the underlying `GridCacheStore` storage. In case of `CacheMode#PARTITIONED`
-     * caches, the value will be loaded from the primary node, which in its turn may load the value
-     * from the swap storage, and consecutively, if it's not in swap and read-through is allowed,
-     * from the underlying persistent storage. If value has to be loaded from persistent
-     * storage, `GridCacheStore#load(String, GridCacheTx, Object)` method will be used.
-     *
-     * If the returned value is not needed, method `removex$(...)` should
-     * always be used instead of this one to avoid the overhead associated with returning of the
-     * previous value.
-     *
-     * If write-through is enabled, the value will be removed from 'GridCacheStore'
-     * via `GridCacheStore#remove(String, GridCacheTx, Object)` method.
-     *
-     * ===Transactions===
-     * This method is transactional and will enlist the entry into ongoing transaction
-     * if there is one.
-     *
-     * ===Cache Flags===
-     * This method is not available if any of the following flags are set on projection:
-     * `CacheFlag#LOCAL`, `CacheFlag#READ`.
-     *
-     * @param k Key whose mapping is to be removed from cache.
-     * @param p Optional filters to check prior to removing value form cache. Note
-     *      that filter is checked atomically together with remove operation.
-     * @return Previous value associated with specified key, or `null`
-     *      if there was no value for this key.
-     * @see `CacheProjection#remove(...)`
-     */
-    def remove$(k: K, @Nullable p: EntryPred*): V =
-        value.remove(k, unwrap(p): _*)
-
-    /**
-     * Removes given key mapping from cache. If cache previously contained value for the given key,
-     * then this value is returned. Otherwise, in case of `CacheMode#REPLICATED` caches,
-     * the value will be loaded from swap and, if it's not there, and read-through is allowed,
-     * from the underlying `GridCacheStore` storage. In case of `CacheMode#PARTITIONED`
-     * caches, the value will be loaded from the primary node, which in its turn may load the value
-     * from the swap storage, and consecutively, if it's not in swap and read-through is allowed,
-     * from the underlying persistent storage. If value has to be loaded from persistent
-     * storage, `GridCacheStore#load(String, GridCacheTx, Object)` method will be used.
-     *
-     * If the returned value is not needed, method `removex$(...)` should
-     * always be used instead of this one to avoid the overhead associated with returning of the
-     * previous value.
-     *
-     * If write-through is enabled, the value will be removed from 'GridCacheStore'
-     * via `GridCacheStore#remove(String, GridCacheTx, Object)` method.
-     *
-     * ===Transactions===
-     * This method is transactional and will enlist the entry into ongoing transaction
-     * if there is one.
-     *
-     * ===Cache Flags===
-     * This method is not available if any of the following flags are set on projection:
-     * `CacheFlag#LOCAL`, `CacheFlag#READ`.
-     *
-     * @param k Key whose mapping is to be removed from cache.
-     * @param p Optional filters to check prior to removing value form cache. Note
-     *      that filter is checked atomically together with remove operation.
-     * @return Previous value associated with specified key as an option.
-     * @see `CacheProjection#remove(...)`
-     */
-    def removeOpt$(k: K, @Nullable p: EntryPred*): Option[V] =
-        Option(value.remove(k, unwrap(p): _*))
-
-    /**
-     * Operator alias for the same function `remove$`.
-     *
-     * @param k Key whose mapping is to be removed from cache.
-     * @param p Optional filters to check prior to removing value form cache. Note
-     *      that filter is checked atomically together with remove operation.
-     * @return Previous value associated with specified key, or `null`
-     *      if there was no value for this key.
-     * @see `CacheProjection#remove(...)`
-     */
-    def -=(k: K, @Nullable p: EntryPred*): V =
-        remove$(k, p: _*)
-
-    /**
-     * Removes given key mappings from cache.
-     *
-     * If write-through is enabled, the values will be removed from `GridCacheStore`
-     * via `GridCacheStore#removeAll(String, GridCacheTx, Collection)` method.
-     *
-     * ===Transactions===
-     * This method is transactional and will enlist the entry into ongoing transaction
-     * if there is one.
-     *
-     * ===Cache Flags===
-     * This method is not available if any of the following flags are set on projection:
-     * `CacheFlag#LOCAL`, `CacheFlag#READ`.
-     *
-     * @param k1 1st key to remove.
-     * @param k2 2nd key to remove.
-     * @param ks Optional sequence of additional keys to remove.
-     * @see `CacheProjection#removeAll(...)`
-     */
-    def removeAll$(k1: K, k2: K, @Nullable ks: K*) {
-        val s = new mutable.ArrayBuffer[K](2 + (if (ks == null) 0 else ks.length))
-
-        s += k1
-        s += k2
-
-        if (ks != null)
-            ks foreach (s += _)
-
-        value.removeAll(s)
-    }
-
-    /**
-     * Operator alias for the same function `remove$`.
-     *
-     * @param k1 1st key to remove.
-     * @param k2 2nd key to remove.
-     * @param ks Optional sequence of additional keys to remove.
-     * @see `CacheProjection#removeAll(...)`
-     */
-    def -=(k1: K, k2: K, @Nullable ks: K*) {
-        removeAll$(k1, k2, ks: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @return Collection of cache key-value pairs.
-     */
-    def scan(@Nullable grid: ClusterGroup = null, cls: Class[_ <: V], kvp: KvPred): Iterable[(K, V)] = {
-        assert(cls != null)
-        assert(kvp != null)
-
-        val q = value.cache[K, V]().queries().createScanQuery(kvp)
-
-        (if (grid != null) q.projection(grid) else q).execute().get.map(e => (e.getKey, e.getValue))
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @return Collection of cache key-value pairs.
-     */
-    def scan(@Nullable grid: ClusterGroup, kvp: KvPred)
-        (implicit m: Manifest[V]): Iterable[(K, V)] = {
-        assert(kvp != null)
-
-        scan(grid, m.erasure.asInstanceOf[Class[V]], kvp)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @return Collection of cache key-value pairs.
-     */
-    def scan(cls: Class[_ <: V], kvp: KvPred): Iterable[(K, V)] = {
-        assert(cls != null)
-        assert(kvp != null)
-
-        scan(null, cls, kvp)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @return Collection of cache key-value pairs.
-     */
-    def scan(kvp: KvPred)(implicit m: Manifest[V]): Iterable[(K, V)] = {
-        assert(kvp != null)
-
-        scan(m.erasure.asInstanceOf[Class[V]], kvp)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param args Optional list of query arguments.
-     * @return Collection of cache key-value pairs.
-     */
-    def sql(@Nullable grid: ClusterGroup, cls: Class[_ <: V], clause: String, args: Any*): Iterable[(K, V)] = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(args != null)
-
-        val q = value.cache().queries().createSqlQuery(cls, clause)
-
-        (if (grid != null) q.projection(grid) else q)
-            .execute(args.asInstanceOf[Seq[Object]]: _*)
-            .get.map(e => (e.getKey, e.getValue))
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @return Collection of cache key-value pairs.
-     */
-    def sql(@Nullable grid: ClusterGroup = null, cls: Class[_ <: V], clause: String): Iterable[(K, V)] = {
-        assert(cls != null)
-        assert(clause != null)
-
-        sql(grid, cls, clause, Nil: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param args Optional list of query arguments.
-     * @return Collection of cache key-value pairs.
-     */
-    def sql(@Nullable grid: ClusterGroup, clause: String, args: Any*)
-        (implicit m: Manifest[V]): Iterable[(K, V)] = {
-        assert(clause != null)
-        assert(args != null)
-
-        sql(grid, m.erasure.asInstanceOf[Class[V]], clause, args: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param args Optional list of query arguments.
-     * @return Collection of cache key-value pairs.
-     */
-    def sql(cls: Class[_ <: V], clause: String, args: Any*): Iterable[(K, V)] = {
-        assert(cls != null)
-        assert(clause != null)
-
-        sql(null.asInstanceOf[ClusterGroup], cls, clause, args: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param args Optional list of query arguments.
-     * @return Collection of cache key-value pairs.
-     */
-    def sql(clause: String, args: Any*)(implicit m: Manifest[V]): Iterable[(K, V)] = {
-        assert(clause != null)
-
-        sql(m.erasure.asInstanceOf[Class[V]], clause, args: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @return Collection of cache key-value pairs.
-     */
-    def text(@Nullable grid: ClusterGroup = null, cls: Class[_ <: V], clause: String): Iterable[(K, V)] = {
-        assert(cls != null)
-        assert(clause != null)
-
-        val q = value.cache().queries().createFullTextQuery(cls, clause)
-
-        (if (grid != null) q.projection(grid) else q).execute().get.map(e => (e.getKey, e.getValue))
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @return Collection of cache key-value pairs.
-     */
-    def text(@Nullable grid: ClusterGroup, clause: String)(implicit m: Manifest[V]): Iterable[(K, V)] = {
-        assert(clause != null)
-
-        text(grid, m.erasure.asInstanceOf[Class[V]], clause)
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @return Collection of cache key-value pairs.
-     */
-    def text(cls: Class[_ <: V], clause: String): Iterable[(K, V)] = {
-        assert(cls != null)
-        assert(clause != null)
-
-        text(null, cls, clause)
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @return Collection of cache key-value pairs.
-     */
-    def text(clause: String)(implicit m: Manifest[V]): Iterable[(K, V)] = {
-        assert(clause != null)
-
-        text(m.erasure.asInstanceOf[Class[V]], clause)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` transform query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @return Collection of cache key-value pairs.
-     */
-    def scanTransform[T](@Nullable grid: ClusterGroup = null, cls: Class[_ <: V], kvp: KvPred, trans: V => T):
-        Iterable[(K, T)] = {
-        assert(cls != null)
-        assert(kvp != null)
-        assert(trans != null)
-
-        val q = value.cache[K, V]().queries().createScanQuery(kvp)
-
-        toScalaItr[K, T]((if (grid != null) q.projection(grid) else q).execute(toRemoteTransformer[K, V, T](trans)).get)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` transform query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the global projection will be used.
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @return Collection of cache key-value pairs.
-     */
-    def scanTransform[T](@Nullable grid: ClusterGroup, kvp: KvPred, trans: V => T)(implicit m: Manifest[V]):
-        Iterable[(K, T)] = {
-        assert(kvp != null)
-        assert(trans != null)
-
-        scanTransform(grid, m.erasure.asInstanceOf[Class[V]], kvp, trans)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` transform query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @return Collection of cache key-value pairs.
-     */
-    def scanTransform[T](cls: Class[_ <: V], kvp: KvPred, trans: V => T): Iterable[(K, T)] = {
-        assert(cls != null)
-        assert(kvp != null)
-        assert(trans != null)
-
-        scanTransform(null, cls, kvp, trans)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` transform query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @return Collection of cache key-value pairs.
-     */
-    def scanTransform[T](kvp: KvPred, trans: V => T)
-        (implicit m: Manifest[V]): Iterable[(K, T)] = {
-        assert(kvp != null)
-        assert(trans != null)
-
-        scanTransform(m.erasure.asInstanceOf[Class[V]], kvp, trans)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` transform query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @param args Optional list of query arguments.
-     * @return Collection of cache key-value pairs.
-     */
-    def sqlTransform[T](@Nullable grid: ClusterGroup, cls: Class[_ <: V], clause: String,
-        trans: V => T, args: Any*): Iterable[(K, T)] = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(trans != null)
-        assert(args != null)
-
-        val q = value.cache[K, V]().queries().createSqlQuery(cls, clause)
-
-        toScalaItr((if (grid != null) q.projection(grid) else q)
-            .execute(toRemoteTransformer[K, V, T](trans), args.asInstanceOf[Seq[Object]]: _*).get)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` transform query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @return Collection of cache key-value pairs.
-     */
-    def sqlTransform[T](@Nullable grid: ClusterGroup = null, cls: Class[_ <: V], clause: String,
-        trans: V => T): Iterable[(K, T)] = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(trans != null)
-
-        sqlTransform(grid, cls, clause, trans, Nil: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` transform query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @param args Optional list of query arguments.
-     * @return Collection of cache key-value pairs.
-     */
-    def sqlTransform[T](@Nullable grid: ClusterGroup, clause: String, trans: V => T, args: Any*)
-        (implicit m: Manifest[V]): Iterable[(K, T)] = {
-        assert(clause != null)
-        assert(trans != null)
-        assert(args != null)
-
-        sqlTransform(grid, m.erasure.asInstanceOf[Class[V]], clause, trans, args: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` transform query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @param args Optional list of query arguments.
-     * @return Collection of cache key-value pairs.
-     */
-    def sqlTransform[T](cls: Class[_ <: V], clause: String, trans: V => T, args: Any*): Iterable[(K, T)] = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(trans != null)
-        assert(args != null)
-
-        sqlTransform(null, cls, clause, trans, args: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` transform query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @param args Optional list of query arguments.
-     * @return Collection of cache key-value pairs.
-     */
-    def sqlTransform[T](clause: String, trans: V => T, args: Any*)
-        (implicit m: Manifest[V]): Iterable[(K, T)] = {
-        assert(clause != null)
-        assert(trans != null)
-        assert(args != null)
-
-        sqlTransform(m.erasure.asInstanceOf[Class[V]], clause, trans, args: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` transform query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @return Collection of cache key-value pairs.
-     */
-    def textTransform[T](@Nullable grid: ClusterGroup = null, cls: Class[_ <: V], clause: String,
-        trans: V => T): Iterable[(K, T)] = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(trans != null)
-
-        val q = value.cache[K, V]().queries().createFullTextQuery(cls, clause)
-
-        toScalaItr((if (grid != null) q.projection(grid) else q).execute(toRemoteTransformer[K, V, T](trans)).get)
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` transform query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @return Collection of cache key-value pairs.
-     */
-    def textTransform[T](@Nullable grid: ClusterGroup, clause: String, trans: V => T)
-        (implicit m: Manifest[V]): Iterable[(K, T)] = {
-        assert(clause != null)
-        assert(trans != null)
-
-        textTransform(grid, m.erasure.asInstanceOf[Class[V]], clause, trans)
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` transform query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @return Collection of cache key-value pairs.
-     */
-    def textTransform[T](cls: Class[_ <: V], clause: String, trans: V => T): Iterable[(K, T)] = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(trans != null)
-
-        textTransform(null, cls, clause, trans)
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` transform query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @param trans Transform function that will be applied to each returned value.
-     * @return Collection of cache key-value pairs.
-     */
-    def textTransform[T](clause: String, trans: V => T)
-        (implicit m: Manifest[V]): Iterable[(K, T)] = {
-        assert(clause != null)
-        assert(trans != null)
-
-        textTransform(m.erasure.asInstanceOf[Class[V]], clause, trans)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @return Reduced value.
-     */
-    def scanReduce[R1, R2](@Nullable grid: ClusterGroup = null, cls: Class[_ <: V], kvp: KvPred,
-        rmtRdc: Iterable[(K, V)] => R1, locRdc: Iterable[R1] => R2): R2 = {
-        assert(cls != null)
-        assert(kvp != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-
-        val q = value.cache[K, V]().queries().createScanQuery(kvp)
-
-        locRdc((if (grid != null) q.projection(grid) else q).execute(toEntryReducer(rmtRdc)).get)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @return Reduced value.
-     */
-    def scanReduce[R1, R2](@Nullable grid: ClusterGroup, kvp: KvPred,
-        rmtRdc: Iterable[(K, V)] => R1, locRdc: Iterable[R1] => R2)(implicit m: Manifest[V]): R2 = {
-        assert(kvp != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-
-        scanReduce(grid, m.erasure.asInstanceOf[Class[V]], kvp, rmtRdc, locRdc)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` reduce query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @return Reduced value.
-     */
-    def scanReduce[R1, R2](cls: Class[_ <: V], kvp: KvPred,
-        rmtRdc: Iterable[(K, V)] => R1, locRdc: Iterable[R1] => R2): R2 = {
-        assert(cls != null)
-        assert(kvp != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-
-        scanReduce(null, cls, kvp, rmtRdc, locRdc)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` reduce query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @return Reduced value.
-     */
-    def scanReduce[R1, R2](kvp: KvPred, rmtRdc: Iterable[(K, V)] => R1,
-        locRdc: Iterable[R1] => R2)(implicit m: Manifest[V]): R2 = {
-        assert(kvp != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-
-        scanReduce(m.erasure.asInstanceOf[Class[V]], kvp, rmtRdc, locRdc)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @param args Optional list of query arguments.
-     * @return Reduced value.
-     */
-    def sqlReduce[R1, R2](@Nullable grid: ClusterGroup, cls: Class[_ <: V], clause: String,
-        rmtRdc: Iterable[(K, V)] => R1, locRdc: Iterable[R1] => R2, args: Any*): R2 = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-        assert(args != null)
-
-        val q = value.cache[K, V]().queries().createSqlQuery(cls, clause)
-
-        locRdc((if (grid != null) q.projection(grid) else q)
-            .execute(toEntryReducer(rmtRdc), args.asInstanceOf[Seq[Object]]: _*).get)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @return Reduced value.
-     */
-    def sqlReduce[R1, R2](@Nullable grid: ClusterGroup = null, cls: Class[_ <: V], clause: String,
-        rmtRdc: Iterable[(K, V)] => R1, locRdc: Iterable[R1] => R2): R2 = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-
-        sqlReduce(grid, cls, clause, rmtRdc, locRdc, Nil: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @param args Optional list of query arguments.
-     * @return Reduced value.
-     */
-    def sqlReduce[R1, R2](@Nullable grid: ClusterGroup, clause: String, rmtRdc: Iterable[(K, V)] => R1,
-        locRdc: Iterable[R1] => R2, args: Any*)(implicit m: Manifest[V]): R2 = {
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-        assert(args != null)
-
-        sqlReduce(grid, m.erasure.asInstanceOf[Class[V]], clause, rmtRdc, locRdc, args: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` reduce query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @param args Optional list of query arguments.
-     * @return Reduced value.
-     */
-    def sqlReduce[R1, R2](cls: Class[_ <: V], clause: String, rmtRdc: Iterable[(K, V)] => R1,
-        locRdc: Iterable[R1] => R2, args: Any*): R2 = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-        assert(args != null)
-
-        sqlReduce(null, cls, clause, rmtRdc, locRdc, args: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` reduce query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @param args Optional list of query arguments.
-     * @return Reduced value.
-     */
-    def sqlReduce[R1, R2](clause: String, rmtRdc: Iterable[(K, V)] => R1,
-        locRdc: Iterable[R1] => R2, args: Any*)(implicit m: Manifest[V]): R2 = {
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-        assert(args != null)
-
-        sqlReduce(m.erasure.asInstanceOf[Class[V]], clause, rmtRdc, locRdc, args: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @return Reduced value.
-     */
-    def textReduce[R1, R2](@Nullable grid: ClusterGroup = null, cls: Class[_ <: V], clause: String,
-        rmtRdc: Iterable[(K, V)] => R1, locRdc: Iterable[R1] => R2): R2 = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-
-        val q = value.cache[K, V]().queries().createFullTextQuery(cls, clause)
-
-        locRdc((if (grid != null) q.projection(grid) else q).execute(toEntryReducer(rmtRdc)).get)
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @return Reduced value.
-     */
-    def textReduce[R1, R2](@Nullable grid: ClusterGroup, clause: String, rmtRdc: Iterable[(K, V)] => R1,
-        locRdc: Iterable[R1] => R2)(implicit m: Manifest[V]): R2 = {
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-
-        textReduce(grid, m.erasure.asInstanceOf[Class[V]], clause, rmtRdc, locRdc)
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` reduce query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @return Reduced value.
-     */
-    def textReduce[R1, R2](cls: Class[_ <: V], clause: String, rmtRdc: Iterable[(K, V)] => R1,
-        locRdc: Iterable[R1] => R2): R2 = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-
-        textReduce(null, cls, clause, rmtRdc, locRdc)
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` reduce query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param locRdc Reduce function that will be called on local node.
-     * @return Reduced value.
-     */
-    def textReduce[R1, R2](clause: String, rmtRdc: Iterable[(K, V)] => R1,
-        locRdc: Iterable[R1] => R2)(implicit m: Manifest[V]): R2 = {
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(locRdc != null)
-
-        textReduce(m.erasure.asInstanceOf[Class[V]], clause, rmtRdc, locRdc)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @return Collection of reduced values.
-     */
-    def scanReduceRemote[R](@Nullable grid: ClusterGroup = null, cls: Class[_ <: V], kvp: KvPred,
-        rmtRdc: Iterable[(K, V)] => R): Iterable[R] = {
-        assert(cls != null)
-        assert(kvp != null)
-        assert(rmtRdc != null)
-
-        val q = value.cache[K, V]().queries().createScanQuery(kvp)
-
-        (if (grid != null) q.projection(grid) else q).execute(toEntryReducer(rmtRdc)).get
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the global projection will be used.
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @return Collection of reduced values.
-     */
-    def scanReduceRemote[R](@Nullable grid: ClusterGroup, kvp: KvPred,
-        rmtRdc: Iterable[(K, V)] => R)(implicit m: Manifest[V]): Iterable[R] = {
-        assert(kvp != null)
-        assert(rmtRdc != null)
-
-        scanReduceRemote(grid, m.erasure.asInstanceOf[Class[V]], kvp, rmtRdc)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` reduce query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @return Collection of reduced values.
-     */
-    def scanReduceRemote[R](cls: Class[_ <: V], kvp: KvPred, rmtRdc: Iterable[(K, V)] => R): Iterable[R] = {
-        assert(cls != null)
-        assert(kvp != null)
-        assert(rmtRdc != null)
-
-        scanReduceRemote(null, cls, kvp, rmtRdc)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SCAN` reduce query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param kvp Filter to be used prior to returning key-value pairs to user. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @return Collection of reduced values.
-     */
-    def scanReduceRemote[R](kvp: KvPred, rmtRdc: Iterable[(K, V)] => R)(implicit m: Manifest[V]): Iterable[R] = {
-        assert(kvp != null)
-        assert(rmtRdc != null)
-
-        scanReduceRemote(m.erasure.asInstanceOf[Class[V]], kvp, rmtRdc)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param args Optional list of query arguments.
-     * @return Collection of reduced values.
-     */
-    def sqlReduceRemote[R](@Nullable grid: ClusterGroup, cls: Class[_ <: V], clause: String,
-        rmtRdc: Iterable[(K, V)] => R, args: Any*): Iterable[R] = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(args != null)
-
-        val q = value.cache[K, V]().queries().createSqlQuery(cls, clause)
-
-        (if (grid != null) q.projection(grid) else q)
-            .execute(toEntryReducer(rmtRdc), args.asInstanceOf[Seq[Object]]: _*).get
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @return Collection of reduced values.
-     */
-    def sqlReduceRemote[R](@Nullable grid: ClusterGroup = null, cls: Class[_ <: V], clause: String,
-        rmtRdc: Iterable[(K, V)] => R): Iterable[R] = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(rmtRdc != null)
-
-        sqlReduceRemote(grid, cls, clause, rmtRdc, Nil: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param args Optional list of query arguments.
-     * @return Collection of reduced values.
-     */
-    def sqlReduceRemote[R](@Nullable grid: ClusterGroup, clause: String, rmtRdc: Iterable[(K, V)] => R,
-        args: Any*)(implicit m: Manifest[V]): Iterable[R] = {
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(args != null)
-
-        sqlReduceRemote(grid, m.erasure.asInstanceOf[Class[V]], clause, rmtRdc, args: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` reduce query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param args Optional list of query arguments.
-     * @return Collection of reduced values.
-     */
-    def sqlReduceRemote[R](cls: Class[_ <: V], clause: String, rmtRdc: Iterable[(K, V)] => R,
-        args: Any*): Iterable[R] = {
-        assert(cls != null)
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(args != null)
-
-        sqlReduceRemote(null, cls, clause, rmtRdc, args: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `SQL` reduce query on global projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * Note that query value class will be taken implicitly as exact type `V` of this
-     * cache projection.
-     *
-     * @param clause Query SQL clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @param args Optional list of query arguments.
-     * @return Collection of reduced values.
-     */
-    def sqlReduceRemote[R](clause: String, rmtRdc: Iterable[(K, V)] => R, args: Any*)
-        (implicit m: Manifest[V]): Iterable[R] = {
-        assert(clause != null)
-        assert(rmtRdc != null)
-        assert(args != null)
-
-        sqlReduceRemote(m.erasure.asInstanceOf[Class[V]], clause, rmtRdc, args: _*)
-    }
-
-    /**
-     * Creates and executes ad-hoc `TEXT` reduce query on given projection returning its result.
-     *
-     * Note that if query is executed more than once (potentially with different
-     * arguments) it is more performant to create query via standard mechanism
-     * and execute it multiple times with different arguments. The analogy is
-     * similar to JDBC `PreparedStatement`. Note also that this function will return
-     * all results at once without pagination and therefore memory limits should be
-     * taken into account.
-     *
-     * @param grid Grid projection on which this query will be executed. If `null` the
-     *     global projection will be used.
-     * @param cls Query values class. Since cache can, in general, contain values of any subtype of `V`
-     *     query needs to know the exact type it should operate on.
-     * @param clause Query text clause. See `CacheQuery` for more details.
-     * @param rmtRdc Reduce function that will be called on each remote node.
-     * @return Collection of reduced values.
-     */
-    def textReduceRemote[R](@Nullable grid: ClusterGroup = null, cls: Class[_ <: V], clause: String,
-     

<TRUNCATED>

Mime
View raw message