http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/a6f9c9e6/modules/scalar/src/main/scala/org/gridgain/scalar/pimps/ScalarCacheProjectionPimp.scala ---------------------------------------------------------------------- diff --git a/modules/scalar/src/main/scala/org/gridgain/scalar/pimps/ScalarCacheProjectionPimp.scala b/modules/scalar/src/main/scala/org/gridgain/scalar/pimps/ScalarCacheProjectionPimp.scala deleted file mode 100644 index 1e64d73..0000000 --- a/modules/scalar/src/main/scala/org/gridgain/scalar/pimps/ScalarCacheProjectionPimp.scala +++ /dev/null @@ -1,2005 +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.gridgain.scalar.pimps - -import org.apache.ignite.cache.{GridCacheEntry, GridCacheProjection} -import org.apache.ignite.cluster.ClusterGroup -import org.apache.ignite.lang.{IgnitePredicate, IgniteReducer, IgniteClosure, IgniteBiTuple} - -import collection._ -import collection.JavaConversions._ -import org.jetbrains.annotations.Nullable -import org.apache.ignite._ -import org.gridgain.grid._ -import org.apache.ignite.internal.util.lang.{GridFunc => F} -import org.apache.ignite.internal.util.scala.impl -import org.gridgain.scalar._ -import scalar._ - -/** - * 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: GridCacheProjection[K, V]) = { - if (impl == null) - throw new NullPointerException("impl") - - val pimp = new ScalarCacheProjectionPimp[K, V] - - pimp.impl = impl - - pimp - } -} - -/** - * ==Overview== - * Defines Scalar "pimp" for `GridCacheProjection` on Java side. - * - * Essentially this class extends Java `GridCacheProjection` 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 `GridCacheProjection` 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 GridGain 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[GridCacheProjection[K, V]] - with Iterable[GridCacheEntry[K, V]] { - /** */ - lazy val value: GridCacheProjection[K, V] = impl - - /** */ - protected var impl: GridCacheProjection[K, V] = _ - - /** Type alias. */ - protected type EntryPred = (GridCacheEntry[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 GridGain predicates. - */ - private def unwrap(@Nullable p: Seq[EntryPred]): Seq[IgnitePredicate[GridCacheEntry[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 `GridCacheProjection.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 `GridCacheProjection.projection(...)` - */ - def viewByKv(@Nullable p: ((K, V) => Boolean)): GridCacheProjection[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 `GridCacheProjection.projection(...)` - */ - def viewByEntry(@Nullable p: EntryPred): GridCacheProjection[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 `GridCacheFlag#STRICT` set on it. - * - * @param k Key type. - * @param v Value type. - * @return Cache projection for given key and value types. - * @see `GridCacheProjection.projection(...)` - */ - def viewByType[A, B](k: Class[A], v: Class[B]): GridCacheProjection[A, B] = { - assert(k != null && v != null) - - value.projection(toJavaType(k), toJavaType(v)).asInstanceOf[GridCacheProjection[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: - * `GridCacheFlag#LOCAL`, `GridCacheFlag#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 `GridCacheProjection#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: - * `GridCacheFlag#LOCAL`, `GridCacheFlag#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 `GridCacheProjection#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: - * `GridCacheFlag#LOCAL`, `GridCacheFlag#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 `GridCacheProjection#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 `GridCacheProjection#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: - * `GridCacheFlag#LOCAL`, `GridCacheFlag#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 `GridCacheProjection#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: - * `GridCacheFlag#LOCAL`, `GridCacheFlag#READ`. - * - * @param kvs Key-value pairs to store in cache. If `null` this function is no-op. - * @see `GridCacheProjection#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: - * `GridCacheFlag#LOCAL`, `GridCacheFlag#READ`. - * - * @param ks Sequence of additional keys to remove. If `null` - this function is no-op. - * @see `GridCacheProjection#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 `GridCacheProjection#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 `GridCacheMode#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 `GridCacheMode#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: - * `GridCacheFlag#LOCAL`, `GridCacheFlag#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 `GridCacheProjection#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 `GridCacheMode#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 `GridCacheMode#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: - * `GridCacheFlag#LOCAL`, `GridCacheFlag#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 `GridCacheProjection#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 `GridCacheProjection#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: - * `GridCacheFlag#LOCAL`, `GridCacheFlag#READ`. - * - * @param k1 1st key to remove. - * @param k2 2nd key to remove. - * @param ks Optional sequence of additional keys to remove. - * @see `GridCacheProjection#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 `GridCacheProjection#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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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 `GridCacheQuery` 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
<TRUNCATED>
