ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject [02/17] incubator-ignite git commit: ignite-qry - merged
Date Wed, 10 Dec 2014 15:59:11 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheReduceQueryMultithreadedSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheReduceQueryMultithreadedSelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheReduceQueryMultithreadedSelfTest.java
index b2355ee..430c4cb 100644
--- a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheReduceQueryMultithreadedSelfTest.java
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheReduceQueryMultithreadedSelfTest.java
@@ -14,7 +14,6 @@ import org.apache.ignite.lang.*;
 import org.apache.ignite.marshaller.optimized.*;
 import org.gridgain.grid.cache.*;
 import org.gridgain.grid.cache.query.*;
-import org.gridgain.grid.spi.indexing.h2.*;
 import org.gridgain.grid.util.typedef.*;
 
 import java.util.*;
@@ -48,12 +47,6 @@ public class GridCacheReduceQueryMultithreadedSelfTest extends GridCacheAbstract
     @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
         IgniteConfiguration c = super.getConfiguration(gridName);
 
-        GridH2IndexingSpi indexing = new GridH2IndexingSpi();
-
-        indexing.setDefaultIndexPrimitiveKey(true);
-
-        c.setIndexingSpi(indexing);
-
         c.setMarshaller(new IgniteOptimizedMarshaller(false));
 
         return c;
@@ -67,6 +60,12 @@ public class GridCacheReduceQueryMultithreadedSelfTest extends GridCacheAbstract
         cfg.setBackups(1);
         cfg.setWriteSynchronizationMode(FULL_SYNC);
 
+        GridCacheQueryConfiguration qcfg = new GridCacheQueryConfiguration();
+
+        qcfg.setIndexPrimitiveKey(true);
+
+        cfg.setQueryConfiguration(qcfg);
+
         return cfg;
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheSqlQueryMultiThreadedSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheSqlQueryMultiThreadedSelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheSqlQueryMultiThreadedSelfTest.java
index 11ddf84..3a03ea8 100644
--- a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheSqlQueryMultiThreadedSelfTest.java
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheSqlQueryMultiThreadedSelfTest.java
@@ -10,12 +10,11 @@
 package org.gridgain.grid.kernal.processors.cache;
 
 import org.apache.ignite.configuration.*;
-import org.gridgain.grid.cache.*;
-import org.gridgain.grid.cache.query.*;
 import org.apache.ignite.spi.discovery.tcp.*;
 import org.apache.ignite.spi.discovery.tcp.ipfinder.*;
 import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.*;
-import org.gridgain.grid.spi.indexing.h2.*;
+import org.gridgain.grid.cache.*;
+import org.gridgain.grid.cache.query.*;
 import org.gridgain.testframework.*;
 import org.gridgain.testframework.junits.common.*;
 
@@ -44,10 +43,6 @@ public class GridCacheSqlQueryMultiThreadedSelfTest extends GridCommonAbstractTe
 
         c.setDiscoverySpi(disco);
 
-        GridH2IndexingSpi indexing = new GridH2IndexingSpi();
-
-        c.setIndexingSpi(indexing);
-
         GridCacheConfiguration ccfg = new GridCacheConfiguration();
 
         ccfg.setCacheMode(PARTITIONED);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheSwapSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheSwapSelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheSwapSelfTest.java
index 1df68e9..c8adf83 100644
--- a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheSwapSelfTest.java
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheSwapSelfTest.java
@@ -14,13 +14,13 @@ import org.apache.ignite.configuration.*;
 import org.apache.ignite.events.*;
 import org.apache.ignite.lang.*;
 import org.apache.ignite.marshaller.optimized.*;
-import org.gridgain.grid.cache.*;
-import org.gridgain.grid.cache.query.*;
 import org.apache.ignite.spi.discovery.tcp.*;
 import org.apache.ignite.spi.discovery.tcp.ipfinder.*;
 import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.*;
 import org.apache.ignite.spi.swapspace.*;
 import org.apache.ignite.spi.swapspace.noop.*;
+import org.gridgain.grid.cache.*;
+import org.gridgain.grid.cache.query.*;
 import org.gridgain.grid.util.typedef.*;
 import org.gridgain.testframework.junits.common.*;
 
@@ -29,11 +29,11 @@ import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 
 import static java.util.concurrent.TimeUnit.*;
+import static org.apache.ignite.events.IgniteEventType.*;
 import static org.apache.ignite.configuration.IgniteDeploymentMode.*;
 import static org.gridgain.grid.cache.GridCacheMode.*;
 import static org.gridgain.grid.cache.GridCachePeekMode.*;
 import static org.gridgain.grid.cache.GridCacheWriteSynchronizationMode.*;
-import static org.apache.ignite.events.IgniteEventType.*;
 
 /**
  * Test for cache swap.

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridIndexingWithNoopSwapSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridIndexingWithNoopSwapSelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridIndexingWithNoopSwapSelfTest.java
index 9cdb1c7..ee404cf 100644
--- a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridIndexingWithNoopSwapSelfTest.java
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/GridIndexingWithNoopSwapSelfTest.java
@@ -11,15 +11,14 @@ package org.gridgain.grid.kernal.processors.cache;
 
 import org.apache.ignite.*;
 import org.apache.ignite.configuration.*;
-import org.gridgain.grid.cache.*;
-import org.gridgain.grid.cache.eviction.fifo.*;
-import org.gridgain.grid.cache.query.*;
-import org.gridgain.grid.kernal.processors.cache.GridCacheAbstractQuerySelfTest.*;
 import org.apache.ignite.spi.discovery.tcp.*;
 import org.apache.ignite.spi.discovery.tcp.ipfinder.*;
 import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.*;
-import org.gridgain.grid.spi.indexing.h2.*;
 import org.apache.ignite.spi.swapspace.noop.*;
+import org.gridgain.grid.cache.*;
+import org.gridgain.grid.cache.eviction.fifo.*;
+import org.gridgain.grid.cache.query.*;
+import org.gridgain.grid.kernal.processors.cache.GridCacheAbstractQuerySelfTest.*;
 import org.gridgain.testframework.junits.common.*;
 
 import java.util.*;
@@ -48,12 +47,6 @@ public class GridIndexingWithNoopSwapSelfTest extends GridCommonAbstractTest {
 
         c.setDiscoverySpi(disco);
 
-        GridH2IndexingSpi indexing = new GridH2IndexingSpi();
-
-        indexing.setDefaultIndexPrimitiveKey(true);
-
-        c.setIndexingSpi(indexing);
-
         c.setSwapSpaceSpi(new NoopSwapSpaceSpi());
 
         GridCacheConfiguration cc = defaultCacheConfiguration();
@@ -68,6 +61,12 @@ public class GridIndexingWithNoopSwapSelfTest extends GridCommonAbstractTest {
         cc.setBackups(1);
         cc.setAtomicityMode(TRANSACTIONAL);
 
+        GridCacheQueryConfiguration qcfg = new GridCacheQueryConfiguration();
+
+        qcfg.setIndexPrimitiveKey(true);
+
+        cc.setQueryConfiguration(qcfg);
+
         c.setCacheConfiguration(cc);
 
         return c;

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedFieldsQuerySelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedFieldsQuerySelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedFieldsQuerySelfTest.java
index 6e80a55..43b0ad5 100644
--- a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedFieldsQuerySelfTest.java
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedFieldsQuerySelfTest.java
@@ -17,8 +17,8 @@ import org.jetbrains.annotations.*;
 
 import java.util.*;
 
-import static org.gridgain.grid.cache.GridCacheMode.*;
 import static org.gridgain.grid.cache.GridCacheDistributionMode.*;
+import static org.gridgain.grid.cache.GridCacheMode.*;
 
 /**
  * Tests for fields queries.

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedHitsAndMissesSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedHitsAndMissesSelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedHitsAndMissesSelfTest.java
index 022a2fd..7cd4d3b 100644
--- a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedHitsAndMissesSelfTest.java
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedHitsAndMissesSelfTest.java
@@ -12,18 +12,18 @@ import org.apache.ignite.*;
 import org.apache.ignite.configuration.*;
 import org.apache.ignite.dataload.*;
 import org.apache.ignite.lang.*;
-import org.gridgain.grid.*;
-import org.gridgain.grid.cache.*;
 import org.apache.ignite.spi.discovery.tcp.*;
 import org.apache.ignite.spi.discovery.tcp.ipfinder.*;
 import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.*;
-import org.gridgain.grid.spi.indexing.h2.*;
+import org.gridgain.grid.*;
+import org.gridgain.grid.cache.*;
+import org.gridgain.grid.cache.query.*;
 import org.gridgain.testframework.junits.common.*;
 
 import java.util.*;
 
-import static org.gridgain.grid.cache.GridCacheMode.*;
 import static org.gridgain.grid.cache.GridCacheDistributionMode.*;
+import static org.gridgain.grid.cache.GridCacheMode.*;
 import static org.gridgain.grid.cache.GridCacheWriteSynchronizationMode.*;
 
 /**
@@ -43,12 +43,6 @@ public class GridCachePartitionedHitsAndMissesSelfTest extends GridCommonAbstrac
     @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
         IgniteConfiguration cfg = super.getConfiguration(gridName);
 
-        // IndexingSpi
-        GridH2IndexingSpi spi = new GridH2IndexingSpi();
-        spi.setName("indexingSpi");
-        spi.setDefaultIndexPrimitiveKey(true);
-        cfg.setIndexingSpi(spi);
-
         // DiscoverySpi
         TcpDiscoverySpi disco = new TcpDiscoverySpi();
         disco.setIpFinder(IP_FINDER);
@@ -85,6 +79,12 @@ public class GridCachePartitionedHitsAndMissesSelfTest extends GridCommonAbstrac
         cfg.setPreloadPartitionedDelay(-1);
         cfg.setBackups(1);
 
+        GridCacheQueryConfiguration qcfg = new GridCacheQueryConfiguration();
+
+        qcfg.setIndexPrimitiveKey(true);
+
+        cfg.setQueryConfiguration(qcfg);
+
         return cfg;
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCacheQueryNodeRestartSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCacheQueryNodeRestartSelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCacheQueryNodeRestartSelfTest.java
index 890fe1d..b3e123f 100644
--- a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCacheQueryNodeRestartSelfTest.java
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCacheQueryNodeRestartSelfTest.java
@@ -12,14 +12,13 @@ package org.gridgain.grid.kernal.processors.cache.distributed.near;
 import org.apache.ignite.configuration.*;
 import org.apache.ignite.events.*;
 import org.apache.ignite.lang.*;
+import org.apache.ignite.spi.discovery.tcp.*;
+import org.apache.ignite.spi.discovery.tcp.ipfinder.*;
+import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.*;
 import org.gridgain.grid.*;
 import org.gridgain.grid.cache.*;
 import org.gridgain.grid.cache.query.*;
 import org.gridgain.grid.kernal.processors.cache.*;
-import org.apache.ignite.spi.discovery.tcp.*;
-import org.apache.ignite.spi.discovery.tcp.ipfinder.*;
-import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.*;
-import org.gridgain.grid.spi.indexing.h2.*;
 import org.gridgain.grid.util.typedef.*;
 import org.gridgain.grid.util.typedef.internal.*;
 
@@ -28,8 +27,8 @@ import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 
 import static org.gridgain.grid.cache.GridCacheAtomicityMode.*;
-import static org.gridgain.grid.cache.GridCacheMode.*;
 import static org.gridgain.grid.cache.GridCacheDistributionMode.*;
+import static org.gridgain.grid.cache.GridCacheMode.*;
 
 /**
  * Test for distributed queries with node restarts.
@@ -72,13 +71,13 @@ public class GridCacheQueryNodeRestartSelfTest extends GridCacheAbstractSelfTest
         cc.setAtomicityMode(TRANSACTIONAL);
         cc.setDistributionMode(NEAR_PARTITIONED);
 
-        c.setCacheConfiguration(cc);
+        GridCacheQueryConfiguration qcfg = new GridCacheQueryConfiguration();
 
-        GridH2IndexingSpi idxSpi = new GridH2IndexingSpi();
+        qcfg.setIndexPrimitiveKey(true);
 
-        idxSpi.setDefaultIndexPrimitiveKey(true);
+        cc.setQueryConfiguration(qcfg);
 
-        c.setIndexingSpi(idxSpi);
+        c.setCacheConfiguration(cc);
 
         return c;
     }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/replicated/GridCacheReplicatedFieldsQuerySelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/replicated/GridCacheReplicatedFieldsQuerySelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/replicated/GridCacheReplicatedFieldsQuerySelfTest.java
index 81c1c95..5c2a3ef 100644
--- a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/replicated/GridCacheReplicatedFieldsQuerySelfTest.java
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/replicated/GridCacheReplicatedFieldsQuerySelfTest.java
@@ -13,12 +13,12 @@ import org.apache.ignite.*;
 import org.apache.ignite.cluster.*;
 import org.apache.ignite.events.*;
 import org.apache.ignite.lang.*;
-import org.apache.ignite.spi.indexing.*;
 import org.gridgain.grid.*;
 import org.gridgain.grid.cache.*;
 import org.gridgain.grid.cache.query.*;
 import org.gridgain.grid.kernal.*;
 import org.gridgain.grid.kernal.processors.cache.*;
+import org.gridgain.grid.kernal.processors.query.*;
 import org.gridgain.grid.util.future.*;
 import org.gridgain.grid.util.typedef.*;
 import org.gridgain.grid.util.typedef.internal.*;
@@ -27,8 +27,8 @@ import org.gridgain.testframework.*;
 import java.util.*;
 import java.util.concurrent.*;
 
-import static org.gridgain.grid.cache.GridCacheMode.*;
 import static org.apache.ignite.events.IgniteEventType.*;
+import static org.gridgain.grid.cache.GridCacheMode.*;
 
 /**
  * Tests for fields queries.
@@ -51,7 +51,7 @@ public class GridCacheReplicatedFieldsQuerySelfTest extends GridCacheAbstractFie
         hasCache = true;
 
         try {
-            final Map<UUID, Map<Long, GridFutureAdapter<IndexingFieldsResult>>> map =
+            final Map<UUID, Map<Long, GridFutureAdapter<GridQueryFieldsResult>>> map =
                 U.field(((GridKernal)grid(0)).internalCache().context().queries(), "fieldsQryRes");
 
             // Ensure that iterators map empty.
@@ -82,7 +82,7 @@ public class GridCacheReplicatedFieldsQuerySelfTest extends GridCacheAbstractFie
                 }
             }, getTestTimeout()));
 
-            Map<Long, GridFutureAdapter<IndexingFieldsResult>> futs = map.get(g.cluster().localNode().id());
+            Map<Long, GridFutureAdapter<GridQueryFieldsResult>> futs = map.get(g.cluster().localNode().id());
 
             assertEquals(1, futs.size());
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/replicated/GridCacheReplicatedQuerySelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/replicated/GridCacheReplicatedQuerySelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/replicated/GridCacheReplicatedQuerySelfTest.java
index c3da7e0..53d3dfd 100644
--- a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/replicated/GridCacheReplicatedQuerySelfTest.java
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/replicated/GridCacheReplicatedQuerySelfTest.java
@@ -13,18 +13,16 @@ import org.apache.ignite.*;
 import org.apache.ignite.cluster.*;
 import org.apache.ignite.events.*;
 import org.apache.ignite.lang.*;
-import org.apache.ignite.spi.*;
-import org.apache.ignite.spi.indexing.*;
 import org.gridgain.grid.*;
 import org.gridgain.grid.cache.*;
 import org.gridgain.grid.cache.query.*;
 import org.gridgain.grid.kernal.*;
 import org.gridgain.grid.kernal.processors.cache.*;
 import org.gridgain.grid.kernal.processors.cache.query.*;
+import org.gridgain.grid.util.future.*;
 import org.gridgain.grid.util.lang.*;
 import org.gridgain.grid.util.typedef.*;
 import org.gridgain.grid.util.typedef.internal.*;
-import org.gridgain.grid.util.future.*;
 import org.gridgain.testframework.*;
 import org.jetbrains.annotations.*;
 import org.springframework.util.*;
@@ -239,7 +237,7 @@ public class GridCacheReplicatedQuerySelfTest extends GridCacheAbstractQuerySelf
      * @return {@code qryIters} of {@link GridCacheQueryManager}.
      */
     private ConcurrentMap<UUID,
-        Map<Long, GridFutureAdapter<GridCloseableIterator<IndexingKeyValueRow<CacheKey, CacheValue>>>>>
+        Map<Long, GridFutureAdapter<GridCloseableIterator<IgniteBiTuple<CacheKey, CacheValue>>>>>
         distributedQueryManagerQueryItersMap(Ignite g) {
         GridCacheContext ctx = ((GridKernal)g).internalCache().context();
 
@@ -248,7 +246,7 @@ public class GridCacheReplicatedQuerySelfTest extends GridCacheAbstractQuerySelf
         qryItersField.setAccessible(true);
 
         return (ConcurrentMap<UUID,
-            Map<Long, GridFutureAdapter<GridCloseableIterator<IndexingKeyValueRow<CacheKey, CacheValue>>>>>)
+            Map<Long, GridFutureAdapter<GridCloseableIterator<IgniteBiTuple<CacheKey, CacheValue>>>>>)
             ReflectionUtils.getField(qryItersField, ctx.queries());
     }
 
@@ -397,7 +395,7 @@ public class GridCacheReplicatedQuerySelfTest extends GridCacheAbstractQuerySelf
             assertEquals(0, (int)fut.next().getKey());
 
             final ConcurrentMap<UUID, Map<Long, GridFutureAdapter<GridCloseableIterator<
-                IndexingKeyValueRow<Integer, Integer>>>>> map =
+                IgniteBiTuple<Integer, Integer>>>>> map =
                 U.field(((GridKernal)grid(0)).internalCache().context().queries(), "qryIters");
 
             // fut.nextX() does not guarantee the request has completed on remote node
@@ -408,13 +406,13 @@ public class GridCacheReplicatedQuerySelfTest extends GridCacheAbstractQuerySelf
                 }
             }, getTestTimeout()));
 
-            Map<Long, GridFutureAdapter<GridCloseableIterator<IndexingKeyValueRow<Integer, Integer>>>> futs =
+            Map<Long, GridFutureAdapter<GridCloseableIterator<IgniteBiTuple<Integer, Integer>>>> futs =
                 map.get(g.cluster().localNode().id());
 
             assertEquals(1, futs.size());
 
-            IgniteSpiCloseableIterator<IndexingKeyValueRow<Integer, Integer>> iter =
-                U.field(((IgniteFuture)F.first(futs.values()).get()).get(), "iter");
+            GridCloseableIterator<IgniteBiTuple<Integer, Integer>> iter =
+                (GridCloseableIterator<IgniteBiTuple<Integer, Integer>>)((IgniteFuture)F.first(futs.values()).get()).get();
 
             ResultSet rs = U.field(iter, "data");
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexRebuildTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexRebuildTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexRebuildTest.java
new file mode 100644
index 0000000..b288f0b
--- /dev/null
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexRebuildTest.java
@@ -0,0 +1,241 @@
+/* @java.file.header */
+
+/*  _________        _____ __________________        _____
+ *  __  ____/___________(_)______  /__  ____/______ ____(_)_______
+ *  _  / __  __  ___/__  / _  __  / _  / __  _  __ `/__  / __  __ \
+ *  / /_/ /  _  /    _  /  / /_/ /  / /_/ /  / /_/ / _  /  _  / / /
+ *  \____/   /_/     /_/   \_,__/   \____/   \__,_/  /_/   /_/ /_/
+ */
+
+package org.gridgain.grid.kernal.processors.query.h2;
+
+import org.apache.ignite.configuration.*;
+import org.apache.ignite.lang.*;
+import org.gridgain.grid.*;
+import org.gridgain.grid.cache.*;
+import org.gridgain.grid.cache.query.*;
+import org.gridgain.grid.kernal.processors.cache.*;
+import org.gridgain.grid.kernal.processors.query.*;
+import org.gridgain.grid.util.typedef.internal.*;
+import org.gridgain.testframework.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+import java.util.concurrent.*;
+
+/**
+ */
+public class GridH2IndexRebuildTest extends GridCacheAbstractSelfTest {
+    /** */
+    private static final int GRID_CNT = 1;
+
+    /** {@inheritDoc} */
+    @Override protected int gridCount() {
+        return GRID_CNT;
+    }
+
+    /**
+     * Overrides rebuildIndexes to check it can be interrupted.
+     */
+    private static class SleepingH2Indexing extends GridH2Indexing {
+        /** */
+        private volatile boolean sleepInRebuild;
+
+        /** */
+        private volatile boolean interrupted;
+
+        /**
+         * Constructor.
+         */
+        public SleepingH2Indexing() {
+            spi = this;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void rebuildIndexes(@Nullable String spaceName, GridQueryTypeDescriptor type) {
+            if (sleepInRebuild) {
+                try {
+                    U.sleep(Long.MAX_VALUE);
+                }
+                catch (GridInterruptedException ignored) {
+                    interrupted = true;
+                }
+            }
+
+            super.rebuildIndexes(spaceName, type);
+        }
+    }
+
+    /** */
+    private static SleepingH2Indexing spi;
+
+    /** {@inheritDoc} */
+    @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
+        IgniteConfiguration cfg = super.getConfiguration(gridName);
+
+        GridQueryProcessor.idxCls = SleepingH2Indexing.class;
+
+        return cfg;
+    }
+
+    /**
+     * Value class with regular and compound indexes.
+     */
+    @SuppressWarnings("UnusedDeclaration")
+    private static class TestValue1 {
+        /** */
+        @GridCacheQuerySqlField(index = true)
+        private long val1;
+
+        /** */
+        @GridCacheQuerySqlField(index = true)
+        private String val2;
+
+        /** */
+        @GridCacheQuerySqlField(groups = "group1")
+        private int val3;
+
+        /** */
+        @GridCacheQuerySqlField(groups = "group1")
+        private int val4;
+
+        /**
+         */
+        TestValue1(long val1, String val2, int val3, int val4) {
+            this.val1 = val1;
+            this.val2 = val2;
+            this.val3 = val3;
+            this.val4 = val4;
+        }
+    }
+
+    /**
+     * Value class with regular and text indexes.
+     */
+    @SuppressWarnings("UnusedDeclaration")
+    private static class TestValue2 {
+        /** */
+        @GridCacheQuerySqlField(index = true)
+        private long val1;
+
+        /** */
+        @GridCacheQueryTextField
+        private String val2;
+
+        /**
+         */
+        TestValue2(long val1, String val2) {
+            this.val1 = val1;
+            this.val2 = val2;
+        }
+    }
+
+    /** */
+    private static final int ENTRY_CNT = 10000;
+
+    /**
+     * @throws Exception if failed.
+     */
+    public void testRebuildIndexes() throws Exception {
+        cache().queries().rebuildIndexes(ArrayList.class).get();
+
+        cache().queries().rebuildAllIndexes().get();
+
+        GridCache<Integer, TestValue1> cache1 = grid(0).cache(null);
+        GridCache<Integer, TestValue2> cache2 = grid(0).cache(null);
+
+        for (int i = 0; i < ENTRY_CNT; i++) {
+            cache1.put(i, new TestValue1(i, "val2-" + i, i, i));
+            cache2.put(ENTRY_CNT * 2 + i, new TestValue2(i, "val2-" + i));
+        }
+
+        GridCacheQuery<Map.Entry<Integer, TestValue1>> qry1 =
+            cache1.queries().createSqlQuery(TestValue1.class, "val1 = 9000");
+
+        GridCacheQuery<Map.Entry<Integer, TestValue1>> qry2 =
+            cache1.queries().createSqlQuery(TestValue1.class, "val2 = 'val2-9000'");
+
+        GridCacheQuery<Map.Entry<Integer, TestValue1>> qry3 =
+            cache1.queries().createSqlQuery(TestValue1.class, "val3 = 9000 and val4 = 9000");
+
+        GridCacheQuery<Map.Entry<Integer, TestValue2>> qry4 =
+            cache2.queries().createSqlQuery(TestValue2.class, "val1 = 9000");
+
+        GridCacheQuery<Map.Entry<Integer, TestValue2>> qry5 =
+            cache2.queries().createFullTextQuery(TestValue2.class, "val2 = 'val2-9000'");
+
+        checkQueryReturnsOneEntry(qry1, qry2, qry3, qry4, qry5);
+
+        for (int i = 0; i < ENTRY_CNT / 2; i++) {
+            cache1.remove(i);
+            cache2.remove(ENTRY_CNT * 2 + i);
+        }
+
+        cache().queries().rebuildIndexes(TestValue1.class).get();
+        cache().queries().rebuildIndexes(TestValue2.class).get();
+
+        checkQueryReturnsOneEntry(qry1, qry2, qry3, qry4, qry5);
+
+        cache().queries().rebuildAllIndexes().get();
+
+        checkQueryReturnsOneEntry(qry1, qry2, qry3, qry4, qry5);
+    }
+
+    /**
+     * @throws Exception if failed.
+     */
+    public void testRebuildInterrupted() throws Exception {
+        spi.sleepInRebuild = true;
+
+        GridCache<Integer, TestValue1> cache1 = grid(0).cache(null);
+        GridCache<Integer, TestValue2> cache2 = grid(0).cache(null);
+
+        cache1.put(0, new TestValue1(0, "val0", 0 ,0));
+        cache2.put(1, new TestValue2(0, "val0"));
+
+        checkCancel(grid(0).cache(null).queries().rebuildIndexes("TestValue1"));
+
+        checkCancel(grid(0).cache(null).queries().rebuildAllIndexes());
+
+        spi.sleepInRebuild = false;
+
+        final IgniteFuture<?> fut1 = grid(0).cache(null).queries().rebuildIndexes(TestValue1.class);
+
+        assertFalse(fut1.isCancelled());
+
+        fut1.get();
+
+        final IgniteFuture<?> fut2 = grid(0).cache(null).queries().rebuildAllIndexes();
+
+        assertFalse(fut2.isCancelled());
+
+        fut2.get();
+    }
+
+    /**
+     * @throws Exception if failed.
+     */
+    private void checkCancel(final IgniteFuture<?> fut) throws Exception {
+        assertTrue(fut.cancel());
+
+        GridTestUtils.assertThrows(log, new Callable<Void>() {
+            @Override
+            public Void call() throws Exception {
+                fut.get();
+                return null;
+            }
+        }, IgniteFutureCancelledException.class, null);
+
+        assertTrue(spi.interrupted);
+
+        spi.interrupted = false;
+    }
+
+    /**
+     * @throws Exception if failed.
+     */
+    private void checkQueryReturnsOneEntry(GridCacheQuery<?>... qrys) throws Exception {
+        for (GridCacheQuery<?> qry : qrys)
+            assertEquals(1, qry.execute().get().size());
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexingGeoSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexingGeoSelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexingGeoSelfTest.java
new file mode 100644
index 0000000..1f22529
--- /dev/null
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexingGeoSelfTest.java
@@ -0,0 +1,240 @@
+/* @java.file.header */
+
+/*  _________        _____ __________________        _____
+ *  __  ____/___________(_)______  /__  ____/______ ____(_)_______
+ *  _  / __  __  ___/__  / _  __  / _  / __  _  __ `/__  / __  __ \
+ *  / /_/ /  _  /    _  /  / /_/ /  / /_/ /  / /_/ / _  /  _  / / /
+ *  \____/   /_/     /_/   \_,__/   \____/   \__,_/  /_/   /_/ /_/
+ */
+
+package org.gridgain.grid.kernal.processors.query.h2;
+
+import com.vividsolutions.jts.geom.*;
+import com.vividsolutions.jts.io.*;
+import org.apache.ignite.lang.*;
+import org.gridgain.grid.cache.*;
+import org.gridgain.grid.cache.query.*;
+import org.gridgain.grid.kernal.processors.cache.*;
+import org.gridgain.grid.util.typedef.*;
+import org.gridgain.grid.util.typedef.internal.*;
+import org.gridgain.testframework.*;
+
+import java.io.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+/**
+ *
+ */
+public class GridH2IndexingGeoSelfTest extends GridCacheAbstractSelfTest {
+    /** */
+    private static final int CNT = 100;
+
+    /** */
+    private static final long DUR = 60000L;
+
+    /** {@inheritDoc} */
+    @Override protected int gridCount() {
+        return 3;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected long getTestTimeout() {
+        return DUR * 3;
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    @SuppressWarnings("unchecked")
+    public void testGeo() throws Exception {
+        GridCache<Integer, EnemyCamp> cache = grid(0).cache(null);
+
+        WKTReader r = new WKTReader();
+
+        cache.put(0, new EnemyCamp(r.read("POINT(25 75)"), "A"));
+        cache.put(1, new EnemyCamp(r.read("POINT(70 70)"), "B"));
+        cache.put(2, new EnemyCamp(r.read("POINT(70 30)"), "C"));
+        cache.put(3, new EnemyCamp(r.read("POINT(75 25)"), "D"));
+
+        GridCacheQuery<Map.Entry<Integer, EnemyCamp>> qry = cache.queries().createSqlQuery(EnemyCamp.class,
+            "coords && ?");
+
+        Collection<Map.Entry<Integer, EnemyCamp>> res = qry.execute(r.read("POLYGON((5 70, 5 80, 30 80, 30 70, 5 70))"))
+            .get();
+
+        checkPoints(res, "A");
+
+        res = qry.execute(r.read("POLYGON((10 5, 10 35, 70 30, 75 25, 10 5))")).get();
+
+        checkPoints(res, "C", "D");
+
+        // Move B to the first polygon.
+        cache.put(1, new EnemyCamp(r.read("POINT(20 75)"), "B"));
+
+        res = qry.execute(r.read("POLYGON((5 70, 5 80, 30 80, 30 70, 5 70))")).get();
+
+        checkPoints(res, "A", "B");
+
+        // Move B to the second polygon.
+        cache.put(1, new EnemyCamp(r.read("POINT(30 30)"), "B"));
+
+        res = qry.execute(r.read("POLYGON((10 5, 10 35, 70 30, 75 25, 10 5))")).get();
+
+        checkPoints(res, "B", "C", "D");
+
+        // Remove B.
+        cache.remove(1);
+
+        res = qry.execute(r.read("POLYGON((5 70, 5 80, 30 80, 30 70, 5 70))")).get();
+
+        checkPoints(res, "A");
+
+        res = qry.execute(r.read("POLYGON((10 5, 10 35, 70 30, 75 25, 10 5))")).get();
+
+        checkPoints(res, "C", "D");
+
+        // Check explaint request.
+        assertTrue(F.first(cache.queries().createSqlFieldsQuery("explain select * from EnemyCamp " +
+            "where coords && 'POINT(25 75)'").execute().get()).get(0).toString().contains("coords_idx"));
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    @SuppressWarnings("unchecked")
+    public void testGeoMultithreaded() throws Exception {
+        final GridCache<Integer, EnemyCamp> cache1 = grid(0).cache(null);
+        final GridCache<Integer, EnemyCamp> cache2 = grid(1).cache(null);
+        final GridCache<Integer, EnemyCamp> cache3 = grid(2).cache(null);
+
+        final String[] points = new String[CNT];
+
+        WKTReader r = new WKTReader();
+
+        ThreadLocalRandom rnd = ThreadLocalRandom.current();
+
+        for (int idx = 0; idx < CNT; idx++) {
+            int x = rnd.nextInt(1, 100);
+            int y = rnd.nextInt(1, 100);
+
+            cache1.put(idx, new EnemyCamp(r.read("POINT(" + x + " " + y + ")"), Integer.toString(idx)));
+
+            points[idx] = Integer.toString(idx);
+        }
+
+        Thread.sleep(200);
+
+        final AtomicBoolean stop = new AtomicBoolean();
+        final AtomicReference<Exception> err = new AtomicReference<>();
+
+        IgniteFuture<?> putFut = GridTestUtils.runMultiThreadedAsync(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                WKTReader r = new WKTReader();
+
+                ThreadLocalRandom rnd = ThreadLocalRandom.current();
+
+                while (!stop.get()) {
+                    int cacheIdx = rnd.nextInt(0, 3);
+
+                    GridCache<Integer, EnemyCamp> cache = cacheIdx == 0 ? cache1 : cacheIdx == 1 ? cache2 : cache3;
+
+                    int idx = rnd.nextInt(CNT);
+                    int x = rnd.nextInt(1, 100);
+                    int y = rnd.nextInt(1, 100);
+
+                    cache.put(idx, new EnemyCamp(r.read("POINT(" + x + " " + y + ")"), Integer.toString(idx)));
+
+                    U.sleep(50);
+                }
+
+                return null;
+            }
+        }, Runtime.getRuntime().availableProcessors(), "put-thread");
+
+        IgniteFuture<?> qryFut = GridTestUtils.runMultiThreadedAsync(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                WKTReader r = new WKTReader();
+
+                ThreadLocalRandom rnd = ThreadLocalRandom.current();
+
+                while (!stop.get()) {
+                    try {
+                        int cacheIdx = rnd.nextInt(0, 3);
+
+                        GridCache<Integer, EnemyCamp> cache = cacheIdx == 0 ? cache1 : cacheIdx == 1 ? cache2 : cache3;
+
+                        GridCacheQuery<Map.Entry<Integer, EnemyCamp>> qry = cache.queries().createSqlQuery(
+                            EnemyCamp.class, "coords && ?");
+
+                        Collection<Map.Entry<Integer, EnemyCamp>> res = qry.execute(
+                            r.read("POLYGON((0 0, 0 100, 100 100, 100 0, 0 0))")).get();
+
+                        checkPoints(res, points);
+
+                        U.sleep(5);
+                    }
+                    catch (Exception e) {
+                        err.set(e);
+
+                        stop.set(true);
+
+                        break;
+                    }
+                }
+
+                return null;
+            }
+        }, 4, "qry-thread");
+
+        U.sleep(60000L);
+
+        stop.set(true);
+
+        putFut.get();
+        qryFut.get();
+
+        Exception err0 = err.get();
+
+        if (err0 != null)
+            throw err0;
+    }
+
+    /**
+     * Check whether result contains all required points.
+     *
+     * @param res Result.
+     * @param points Expected points.
+     */
+    private void checkPoints( Collection<Map.Entry<Integer, EnemyCamp>> res, String... points) {
+        Set<String> set = new HashSet<>(Arrays.asList(points));
+
+        assertEquals(set.size(), res.size());
+
+        for (Map.Entry<Integer, EnemyCamp> e : res)
+            assertTrue(set.remove(e.getValue().name));
+    }
+
+    /**
+     *
+     */
+    private static class EnemyCamp implements Serializable {
+        /** */
+        @GridCacheQuerySqlField(index = true)
+        private Geometry coords;
+
+        /** */
+        @GridCacheQuerySqlField
+        private String name;
+
+        /**
+         * @param coords Coordinates.
+         * @param name Name.
+         */
+        private EnemyCamp(Geometry coords, String name) {
+            this.coords = coords;
+            this.name = name;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexingInMemSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexingInMemSelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexingInMemSelfTest.java
new file mode 100644
index 0000000..ced0025
--- /dev/null
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexingInMemSelfTest.java
@@ -0,0 +1,17 @@
+/* @java.file.header */
+
+/*  _________        _____ __________________        _____
+ *  __  ____/___________(_)______  /__  ____/______ ____(_)_______
+ *  _  / __  __  ___/__  / _  __  / _  / __  _  __ `/__  / __  __ \
+ *  / /_/ /  _  /    _  /  / /_/ /  / /_/ /  / /_/ / _  /  _  / / /
+ *  \____/   /_/     /_/   \_,__/   \____/   \__,_/  /_/   /_/ /_/
+ */
+
+package org.gridgain.grid.kernal.processors.query.h2;
+
+/**
+ * Tests for H2 indexing SPI.
+ */
+public class GridH2IndexingInMemSelfTest extends GridIndexingSpiAbstractSelfTest {
+    // No-op.
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexingOffheapSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexingOffheapSelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexingOffheapSelfTest.java
new file mode 100644
index 0000000..45aee5d
--- /dev/null
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridH2IndexingOffheapSelfTest.java
@@ -0,0 +1,36 @@
+/* @java.file.header */
+
+/*  _________        _____ __________________        _____
+ *  __  ____/___________(_)______  /__  ____/______ ____(_)_______
+ *  _  / __  __  ___/__  / _  __  / _  / __  _  __ `/__  / __  __ \
+ *  / /_/ /  _  /    _  /  / /_/ /  / /_/ /  / /_/ / _  /  _  / / /
+ *  \____/   /_/     /_/   \_,__/   \____/   \__,_/  /_/   /_/ /_/
+ */
+
+package org.gridgain.grid.kernal.processors.query.h2;
+
+/**
+ * Tests for H2 indexing SPI.
+ */
+public class GridH2IndexingOffheapSelfTest extends GridIndexingSpiAbstractSelfTest {
+    /** */
+    private static final long offheap = 10000000;
+
+    private static GridH2Indexing currentSpi;
+
+    /** {@inheritDoc} */
+    @Override protected void startIndexing(GridH2Indexing spi) throws Exception {
+        spi.configuration().setMaxOffHeapMemory(offheap);
+
+        currentSpi = spi;
+
+        super.startIndexing(spi);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void afterTestsStopped() throws Exception {
+        super.afterTestsStopped();
+
+        assertEquals(0, currentSpi.getAllocatedOffHeapMemory());
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridIndexingSpiAbstractSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridIndexingSpiAbstractSelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridIndexingSpiAbstractSelfTest.java
new file mode 100644
index 0000000..135fd62
--- /dev/null
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/GridIndexingSpiAbstractSelfTest.java
@@ -0,0 +1,553 @@
+/* @java.file.header */
+
+/*  _________        _____ __________________        _____
+ *  __  ____/___________(_)______  /__  ____/______ ____(_)_______
+ *  _  / __  __  ___/__  / _  __  / _  / __  _  __ `/__  / __  __ \
+ *  / /_/ /  _  /    _  /  / /_/ /  / /_/ /  / /_/ / _  /  _  / / /
+ *  \____/   /_/     /_/   \_,__/   \____/   \__,_/  /_/   /_/ /_/
+ */
+
+package org.gridgain.grid.kernal.processors.query.h2;
+
+import org.apache.ignite.*;
+import org.apache.ignite.lang.*;
+import org.apache.ignite.spi.*;
+import org.gridgain.grid.kernal.processors.query.*;
+import org.gridgain.grid.*;
+import org.gridgain.grid.spi.*;
+import org.gridgain.grid.util.typedef.*;
+import org.gridgain.grid.util.typedef.internal.*;
+import org.gridgain.testframework.*;
+import org.gridgain.testframework.junits.common.*;
+
+import java.util.*;
+import java.util.concurrent.*;
+
+/**
+ * Tests for all SQL based indexing SPI implementations.
+ */
+public abstract class GridIndexingSpiAbstractSelfTest extends GridCommonAbstractTest {
+    /** */
+    private static final TextIndex textIdx = new TextIndex(F.asList("txt"));
+
+    /** */
+    private static final Map<String, Class<?>> fieldsAA = new HashMap<>();
+
+    /** */
+    private static final Map<String, Class<?>> fieldsAB = new HashMap<>();
+
+    /** */
+    private static final Map<String, Class<?>> fieldsBA = new HashMap<>();
+
+    /**
+     * Fields initialization.
+     */
+    static {
+        fieldsAA.put("id", Long.class);
+        fieldsAA.put("name", String.class);
+        fieldsAA.put("age", Integer.class);
+
+        fieldsAB.putAll(fieldsAA);
+        fieldsAB.put("txt", String.class);
+
+        fieldsBA.putAll(fieldsAA);
+        fieldsBA.put("sex", Boolean.class);
+    }
+
+    /** */
+    private static TypeDesc typeAA = new TypeDesc("A", "A", fieldsAA, null);
+
+    /** */
+    private static TypeDesc typeAB = new TypeDesc("A", "B", fieldsAB, textIdx);
+
+    /** */
+    private static TypeDesc typeBA = new TypeDesc("B", "A", fieldsBA, null);
+
+    /** */
+    private GridH2Indexing idx = new GridH2Indexing();
+
+    /** {@inheritDoc} */
+    @Override protected void beforeTest() throws Exception {
+        getTestResources().inject(idx);
+
+        startIndexing(idx);
+    }
+
+    /** {@inheritDoc} */
+    protected void startIndexing(GridH2Indexing spi) throws Exception {
+        spi.registerSpace("A");
+        spi.registerSpace("B");
+
+        spi.start(null);
+    }
+
+    @Override protected void afterTest() throws Exception {
+        idx.stop();
+
+        idx = null;
+    }
+
+    /**
+     * @param id Id.
+     * @param name Name.
+     * @param age Age.
+     * @return AA.
+     */
+    private Map<String, Object> aa(long id, String name, int age) {
+        Map<String, Object> map = new HashMap<>();
+
+        map.put("id", id);
+        map.put("name", name);
+        map.put("age", age);
+
+        return map;
+    }
+
+    /**
+     * @param id Id.
+     * @param name Name.
+     * @param age Age.
+     * @param txt Text.
+     * @return AB.
+     */
+    private Map<String, Object> ab(long id, String name, int age, String txt) {
+        Map<String, Object> map = aa(id, name, age);
+
+        map.put("txt", txt);
+
+        return map;
+    }
+
+    /**
+     * @param id Id.
+     * @param name Name.
+     * @param age Age.
+     * @param sex Sex.
+     * @return BA.
+     */
+    private Map<String, Object> ba(long id, String name, int age, boolean sex) {
+        Map<String, Object> map = aa(id, name, age);
+
+        map.put("sex", sex);
+
+        return map;
+    }
+
+    /**
+     * @param row Row
+     * @return Value.
+     * @throws IgniteSpiException If failed.
+     */
+    private Map<String, Object> value(IgniteBiTuple<Integer, Map<String, Object>> row) throws IgniteSpiException {
+        return row.get2();
+    }
+
+    /**
+     * @return Indexing.
+     */
+    private GridH2Indexing getIndexing() {
+        return idx;
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testSpi() throws Exception {
+        GridH2Indexing spi = getIndexing();
+
+        assertEquals(-1, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(-1, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(-1, spi.size(typeBA.space(), typeBA, null));
+
+        spi.registerType(typeAA.space(), typeAA);
+
+        assertEquals(0, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(-1, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(-1, spi.size(typeBA.space(), typeBA, null));
+
+        spi.registerType(typeAB.space(), typeAB);
+
+        assertEquals(0, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(0, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(-1, spi.size(typeBA.space(), typeBA, null));
+
+        spi.registerType(typeBA.space(), typeBA);
+
+        // Initially all is empty.
+        assertEquals(0, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(0, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(0, spi.size(typeBA.space(), typeBA, null));
+
+        assertFalse(spi.query(typeAA.space(), "select * from A.A", Collections.emptySet(), typeAA, null).hasNext());
+        assertFalse(spi.query(typeAB.space(), "select * from A.B", Collections.emptySet(), typeAB, null).hasNext());
+        assertFalse(spi.query(typeBA.space(), "select * from B.A", Collections.emptySet(), typeBA, null).hasNext());
+
+        // Nothing to remove.
+        spi.remove("A", 1);
+        spi.remove("B", 1);
+
+        spi.store(typeAA.space(), typeAA, 1, aa(1, "Vasya", 10), "v1".getBytes(), 0);
+
+        assertEquals(1, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(0, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(0, spi.size(typeBA.space(), typeBA, null));
+
+        spi.store(typeAB.space(), typeAB, 1, ab(1, "Vasya", 20, "Some text about Vasya goes here."),
+            "v2".getBytes(), 0);
+
+        // In one space all keys must be unique.
+        assertEquals(0, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(1, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(0, spi.size(typeBA.space(), typeBA, null));
+
+        spi.store(typeBA.space(), typeBA, 1, ba(2, "Petya", 25, true), "v3".getBytes(), 0);
+
+        // No replacement because of different space.
+        assertEquals(0, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(1, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(1, spi.size(typeBA.space(), typeBA, null));
+
+        spi.store(typeBA.space(), typeBA, 1, ba(2, "Kolya", 25, true), "v4".getBytes(), 0);
+
+        // Replacement in the same table.
+        assertEquals(0, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(1, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(1, spi.size(typeBA.space(), typeBA, null));
+
+        spi.store(typeAA.space(), typeAA, 2, aa(2, "Valera", 19), "v5".getBytes(), 0);
+
+        assertEquals(1, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(1, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(1, spi.size(typeBA.space(), typeBA, null));
+
+        spi.store(typeAA.space(), typeAA, 3, aa(3, "Borya", 18), "v6".getBytes(), 0);
+
+        assertEquals(2, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(1, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(1, spi.size(typeBA.space(), typeBA, null));
+
+        spi.store(typeAB.space(), typeAB, 4, ab(4, "Vitalya", 20, "Very Good guy"), "v7".getBytes(), 0);
+
+        assertEquals(2, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(2, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(1, spi.size(typeBA.space(), typeBA, null));
+
+        // Query data.
+        Iterator<IgniteBiTuple<Integer, Map<String, Object>>> res =
+            spi.query(typeAA.space(), "select * from a order by age", Collections.emptySet(), typeAA, null);
+
+        assertTrue(res.hasNext());
+        assertEquals(aa(3, "Borya", 18), value(res.next()));
+        assertTrue(res.hasNext());
+        assertEquals(aa(2, "Valera", 19), value(res.next()));
+        assertFalse(res.hasNext());
+
+        res = spi.query(typeAB.space(), "select * from b order by name", Collections.emptySet(), typeAB, null);
+
+        assertTrue(res.hasNext());
+        assertEquals(ab(1, "Vasya", 20, "Some text about Vasya goes here."), value(res.next()));
+        assertTrue(res.hasNext());
+        assertEquals(ab(4, "Vitalya", 20, "Very Good guy"), value(res.next()));
+        assertFalse(res.hasNext());
+
+        res = spi.query(typeBA.space(), "select * from a", Collections.emptySet(), typeBA, null);
+
+        assertTrue(res.hasNext());
+        assertEquals(ba(2, "Kolya", 25, true), value(res.next()));
+        assertFalse(res.hasNext());
+
+        // Text queries
+        Iterator<IgniteBiTuple<Integer, Map<String, Object>>> txtRes = spi.queryText(typeAB.space(), "good",
+            typeAB, null);
+
+        assertTrue(txtRes.hasNext());
+        assertEquals(ab(4, "Vitalya", 20, "Very Good guy"), value(txtRes.next()));
+        assertFalse(txtRes.hasNext());
+
+        // Fields query
+        GridQueryFieldsResult fieldsRes =
+            spi.queryFields(null, "select a.a.name n1, a.a.age a1, b.a.name n2, " +
+            "b.a.age a2 from a.a, b.a where a.a.id = b.a.id ", Collections.emptySet(), null);
+
+        String[] aliases = {"N1", "A1", "N2", "A2"};
+        Object[] vals = { "Valera", 19, "Kolya", 25};
+
+        assertTrue(fieldsRes.iterator().hasNext());
+
+        List<?> fields = fieldsRes.iterator().next();
+
+        assertEquals(4, fields.size());
+
+        int i = 0;
+
+        for (Object f : fields) {
+            assertEquals(aliases[i], fieldsRes.metaData().get(i).fieldName());
+            assertEquals(vals[i++], f);
+        }
+
+        assertFalse(fieldsRes.iterator().hasNext());
+
+        // Query on not existing table should not fail.
+        assertFalse(spi.queryFields(null, "select * from not_existing_table",
+            Collections.emptySet(), null).iterator().hasNext());
+
+        // Remove
+        spi.remove(typeAA.space(), 2);
+
+        assertEquals(1, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(2, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(1, spi.size(typeBA.space(), typeBA, null));
+
+        spi.remove(typeBA.space(), 1);
+
+        assertEquals(1, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(2, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(0, spi.size(typeBA.space(), typeBA, null));
+
+        boolean h2IdxOffheap = spi.configuration().getMaxOffHeapMemory() > 0;
+
+        // At the time of this writing index rebuilding is not supported for GridH2Indexing with off-heap storage.
+        if (!h2IdxOffheap) {
+            // Rebuild
+
+            spi.rebuildIndexes(typeAB.space(), typeAB);
+
+            assertEquals(1, spi.size(typeAA.space(), typeAA, null));
+            assertEquals(2, spi.size(typeAB.space(), typeAB, null));
+            assertEquals(0, spi.size(typeBA.space(), typeBA, null));
+
+            // For invalid space name/type should not fail.
+            spi.rebuildIndexes("not_existing_space", typeAA);
+            spi.rebuildIndexes(typeAA.space(), new TypeDesc("C", "C", fieldsAA, null));
+        }
+
+        // Unregister.
+        spi.unregisterType(typeAA.space(), typeAA);
+
+        assertEquals(-1, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(2, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(0, spi.size(typeBA.space(), typeBA, null));
+
+        spi.unregisterType(typeAB.space(), typeAB);
+
+        assertEquals(-1, spi.size(typeAA.space(), typeAA, null));
+        assertEquals(-1, spi.size(typeAB.space(), typeAB, null));
+        assertEquals(0, spi.size(typeBA.space(), typeBA, null));
+
+        spi.unregisterType(typeBA.space(), typeBA);
+
+        // Should not store but should not fail as well.
+        spi.store(typeAA.space(), typeAA, 10, aa(1, "Fail", 100500), "v220".getBytes(), 0);
+
+        assertEquals(-1, spi.size(typeAA.space(), typeAA, null));
+    }
+
+    /**
+     * Test long queries write explain warnings into log.
+     *
+     * @throws Exception If failed.
+     */
+    public void testLongQueries() throws Exception {
+        GridH2Indexing spi = getIndexing();
+
+        long longQryExecTime = 100;
+
+        GridStringLogger log = new GridStringLogger(false, this.log);
+
+        IgniteLogger oldLog = GridTestUtils.getFieldValue(spi, "log");
+
+        spi.configuration().setLongQueryExecutionTimeout(longQryExecTime);
+        spi.configuration().setLongQueryExplain(true);
+
+        try {
+            GridTestUtils.setFieldValue(spi, "log", log);
+
+            String sql = "select sum(x) FROM SYSTEM_RANGE(?, ?)";
+
+            long now = U.currentTimeMillis();
+            long time = now;
+
+            long range = 1000000L;
+
+            while (now - time <= longQryExecTime * 3 / 2) {
+                time = now;
+                range *= 3;
+
+                GridQueryFieldsResult res = spi.queryFields(null, sql, Arrays.<Object>asList(1, range), null);
+
+                assert res.iterator().hasNext();
+
+                now = U.currentTimeMillis();
+            }
+
+            String res = log.toString();
+
+            F.println(res);
+
+            assert res.contains("/* PUBLIC.RANGE_INDEX */");
+        }
+        finally {
+            GridTestUtils.setFieldValue(spi, "log", oldLog);
+            spi.configuration().setLongQueryExecutionTimeout(3000);
+        }
+    }
+
+    public void _testResultReuse() throws Exception {
+        final GridH2Indexing spi = getIndexing();
+
+        multithreaded(new Callable<Object>() {
+              @Override public Object call() throws Exception {
+                  return spi.queryFields(null, "SELECT sum(x) + sum(x) + sum(x) + sum(x) FROM SYSTEM_RANGE(?, ?)",
+                      F.<Object>asList(0, 7000000), null);
+              }
+          }, 5);
+    }
+
+    /**
+     * Test long queries write explain warnings into log.
+     *
+     * @throws Exception If failed.
+     */
+    public void testZeroLongQuery() throws Exception {
+        GridH2Indexing spi = getIndexing();
+
+        long longQryExecTime = -1;
+
+        GridStringLogger log = new GridStringLogger(false, this.log);
+
+        IgniteLogger oldLog = GridTestUtils.getFieldValue(spi, "log");
+        spi.configuration().setLongQueryExecutionTimeout(longQryExecTime);
+        spi.configuration().setLongQueryExplain(true);
+
+        try {
+            GridTestUtils.setFieldValue(spi, "log", log);
+
+            String sql = "SELECT * FROM MyNonExistingTable";
+
+            GridQueryFieldsResult res = spi.queryFields(null, sql, Collections.emptyList(), null);
+
+            assertFalse(res.iterator().hasNext());
+
+            String logStr = log.toString();
+
+            F.println(logStr);
+
+            assertTrue(logStr.contains("Failed to explain plan because required table does not exist"));
+        }
+        finally {
+            GridTestUtils.setFieldValue(spi, "log", oldLog);
+            spi.configuration().setLongQueryExecutionTimeout(3000);
+        }
+    }
+
+    /**
+     * Index descriptor.
+     */
+    private static class TextIndex implements GridQueryIndexDescriptor {
+        /** */
+        private final Collection<String> fields;
+
+        /**
+         * @param fields Fields.
+         */
+        private TextIndex(Collection<String> fields) {
+            this.fields = Collections.unmodifiableCollection(fields);
+        }
+
+        /** {@inheritDoc} */
+        @Override public Collection<String> fields() {
+            return fields;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean descending(String field) {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public GridQueryIndexType type() {
+            return GridQueryIndexType.FULLTEXT;
+        }
+    }
+
+    /**
+     * Type descriptor.
+     */
+    private static class TypeDesc implements GridQueryTypeDescriptor {
+        /** */
+        private final String name;
+
+        /** */
+        private final String space;
+
+        /** */
+        private final Map<String, Class<?>> valFields;
+
+        /** */
+        private final GridQueryIndexDescriptor textIdx;
+
+        /**
+         * @param space Space name.
+         * @param name Type name.
+         * @param valFields Fields.
+         * @param textIdx Fulltext index.
+         */
+        private TypeDesc(String space, String name, Map<String, Class<?>> valFields, GridQueryIndexDescriptor textIdx) {
+            this.name = name;
+            this.space = space;
+            this.valFields = Collections.unmodifiableMap(valFields);
+            this.textIdx = textIdx;
+        }
+
+        /** {@inheritDoc} */
+        @Override public String name() {
+            return name;
+        }
+
+        /**
+         * @return Space name.
+         */
+        public String space() {
+            return space;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Map<String, Class<?>> valueFields() {
+            return valFields;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Map<String, Class<?>> keyFields() {
+            return Collections.emptyMap();
+        }
+
+        /** {@inheritDoc} */
+        @Override public <T> T value(Object obj, String field) throws IgniteSpiException {
+            assert obj != null;
+            assert !F.isEmpty(field);
+
+            return (T)((Map<String, Object>) obj).get(field);
+        }
+
+        /** */
+        @Override public Map<String, GridQueryIndexDescriptor> indexes() {
+            return textIdx == null ? Collections.<String, GridQueryIndexDescriptor>emptyMap() :
+                Collections.singletonMap("index", textIdx);
+        }
+
+        /** */
+        @Override public Class<?> valueClass() {
+            return Object.class;
+        }
+
+        /** */
+        @Override public Class<?> keyClass() {
+            return Integer.class;
+        }
+
+        /** */
+        @Override public boolean valueTextIndex() {
+            return textIdx == null;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/922a2bab/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/opt/GridH2TableSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/opt/GridH2TableSelfTest.java b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/opt/GridH2TableSelfTest.java
new file mode 100644
index 0000000..6d2f75c
--- /dev/null
+++ b/modules/indexing/src/test/java/org/gridgain/grid/kernal/processors/query/h2/opt/GridH2TableSelfTest.java
@@ -0,0 +1,613 @@
+/* @java.file.header */
+
+/*  _________        _____ __________________        _____
+ *  __  ____/___________(_)______  /__  ____/______ ____(_)_______
+ *  _  / __  __  ___/__  / _  __  / _  / __  _  __ `/__  / __  __ \
+ *  / /_/ /  _  /    _  /  / /_/ /  / /_/ /  / /_/ / _  /  _  / / /
+ *  \____/   /_/     /_/   \_,__/   \____/   \__,_/  /_/   /_/ /_/
+ */
+
+package org.gridgain.grid.kernal.processors.query.h2.opt;
+
+import org.gridgain.testframework.junits.common.*;
+import org.h2.Driver;
+import org.h2.index.*;
+import org.h2.result.*;
+import org.h2.table.*;
+import org.h2.value.*;
+import org.jetbrains.annotations.*;
+import org.junit.*;
+
+import java.sql.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+/**
+ * Tests H2 Table.
+ */
+@SuppressWarnings({"TypeMayBeWeakened", "FieldAccessedSynchronizedAndUnsynchronized"})
+public class GridH2TableSelfTest extends GridCommonAbstractTest {
+    /** */
+    private static final long MAX_X = 2000;
+
+    /** */
+    private static final String DB_URL = "jdbc:h2:mem:gg_table_engine;MULTI_THREADED=1;OPTIMIZE_REUSE_RESULTS=0;" +
+        "QUERY_CACHE_SIZE=0;RECOMPILE_ALWAYS=1";
+
+    /** */
+    private static final String CREATE_TABLE_SQL = "CREATE TABLE T(ID UUID, T TIMESTAMP, STR VARCHAR, X BIGINT)";
+
+    /** */
+    private static final String PK_NAME = "__GG_PK_";
+
+    /** */
+    private static final String STR_IDX_NAME = "__GG_IDX_";
+
+    /** */
+    private static final String NON_UNIQUE_IDX_NAME = "__GG_IDX_";
+
+    /** */
+    private static final String SCAN_IDX_NAME = GridH2Table.ScanIndex.SCAN_INDEX_NAME_SUFFIX;
+
+    /** */
+    private Connection conn;
+
+    /** */
+    private GridH2Table tbl;
+
+    /** {@inheritDoc} */
+    @Override protected void beforeTest() throws Exception {
+        Driver.load();
+
+        conn = DriverManager.getConnection(DB_URL);
+
+        tbl = GridH2Table.Engine.createTable(conn, CREATE_TABLE_SQL, null, new GridH2Table.IndexesFactory() {
+            @Override public ArrayList<Index> createIndexes(GridH2Table tbl) {
+                ArrayList<Index> idxs = new ArrayList<>();
+
+                IndexColumn id = tbl.indexColumn(0, SortOrder.ASCENDING);
+                IndexColumn t = tbl.indexColumn(1, SortOrder.ASCENDING);
+                IndexColumn str = tbl.indexColumn(2, SortOrder.DESCENDING);
+                IndexColumn x = tbl.indexColumn(3, SortOrder.DESCENDING);
+
+                idxs.add(new GridH2TreeIndex(PK_NAME, tbl, true, 0, 1, id));
+                idxs.add(new GridH2TreeIndex(NON_UNIQUE_IDX_NAME, tbl, false, 0, 1, x, t));
+                idxs.add(new GridH2TreeIndex(STR_IDX_NAME, tbl, false, 0, 1, str));
+
+                return idxs;
+            }
+        }, null);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void afterTest() throws Exception {
+        conn.close();
+
+        conn = null;
+        tbl = null;
+    }
+
+    /**
+     * @param id Id.
+     * @param t Timestamp.
+     * @param str String.
+     * @param x X.
+     * @return New row.
+     */
+    private GridH2Row row(UUID id, long t, String str, long x) {
+        return new GridH2Row(ValueUuid.get(id.getMostSignificantBits(), id.getLeastSignificantBits()),
+            ValueTimestamp.get(new Timestamp(t)),
+            ValueString.get(str),
+            ValueLong.get(x));
+    }
+
+
+    /**
+     * Simple table test.
+     *
+     * @throws Exception If failed.
+     */
+    public void testTable() throws Exception {
+        // Test insert.
+        long x = MAX_X;
+
+        Random rnd = new Random();
+
+        while(x-- > 0) {
+            UUID id = UUID.randomUUID();
+
+            GridH2Row row = row(id, System.currentTimeMillis(), rnd.nextBoolean() ? id.toString() :
+                UUID.randomUUID().toString(), rnd.nextInt(100));
+
+            tbl.doUpdate(row, false);
+        }
+
+        assertEquals(MAX_X, tbl.getRowCountApproximation());
+        assertEquals(MAX_X, tbl.getRowCount(null));
+
+        for (GridH2IndexBase idx : tbl.indexes()) {
+            assertEquals(MAX_X, idx.getRowCountApproximation());
+            assertEquals(MAX_X, idx.getRowCount(null));
+        }
+
+        // Check correct rows order.
+        checkOrdered((GridH2TreeIndex)tbl.indexes().get(0), new Comparator<SearchRow>() {
+            @Override public int compare(SearchRow o1, SearchRow o2) {
+                UUID id1 = (UUID)o1.getValue(0).getObject();
+                UUID id2 = (UUID)o2.getValue(0).getObject();
+
+                return id1.compareTo(id2);
+            }
+        });
+
+        checkOrdered((GridH2TreeIndex)tbl.indexes().get(1), new Comparator<SearchRow>() {
+            @Override public int compare(SearchRow o1, SearchRow o2) {
+                Long x1 = (Long)o1.getValue(3).getObject();
+                Long x2 = (Long)o2.getValue(3).getObject();
+
+                int c = x2.compareTo(x1);
+
+                if (c != 0)
+                    return c;
+
+                Timestamp t1 = (Timestamp)o1.getValue(1).getObject();
+                Timestamp t2 = (Timestamp)o2.getValue(1).getObject();
+
+                return t1.compareTo(t2);
+            }
+        });
+
+        checkOrdered((GridH2TreeIndex)tbl.indexes().get(2), new Comparator<SearchRow>() {
+            @Override public int compare(SearchRow o1, SearchRow o2) {
+                String s1 = (String)o1.getValue(2).getObject();
+                String s2 = (String)o2.getValue(2).getObject();
+
+                return s2.compareTo(s1);
+            }
+        });
+
+        // Indexes data consistency.
+        ArrayList<? extends Index> idxs = tbl.indexes();
+
+        checkIndexesConsistent((ArrayList<Index>)idxs, null);
+
+        // Check unique index.
+        UUID id = UUID.randomUUID();
+        UUID id2 = UUID.randomUUID();
+
+        assertTrue(tbl.doUpdate(row(id, System.currentTimeMillis(), id.toString(), rnd.nextInt(100)), false));
+        assertTrue(tbl.doUpdate(row(id2, System.currentTimeMillis(), id2.toString(), rnd.nextInt(100)), false));
+
+        // Check index selection.
+        checkQueryPlan(conn, "SELECT * FROM T", SCAN_IDX_NAME);
+
+        checkQueryPlan(conn, "SELECT * FROM T WHERE ID IS NULL", PK_NAME);
+        checkQueryPlan(conn, "SELECT * FROM T WHERE ID = RANDOM_UUID()", PK_NAME);
+        checkQueryPlan(conn, "SELECT * FROM T WHERE ID > RANDOM_UUID()", PK_NAME);
+        checkQueryPlan(conn, "SELECT * FROM T ORDER BY ID", PK_NAME);
+
+        checkQueryPlan(conn, "SELECT * FROM T WHERE STR IS NULL", STR_IDX_NAME);
+        checkQueryPlan(conn, "SELECT * FROM T WHERE STR = 'aaaa'", STR_IDX_NAME);
+        checkQueryPlan(conn, "SELECT * FROM T WHERE STR > 'aaaa'", STR_IDX_NAME);
+        checkQueryPlan(conn, "SELECT * FROM T ORDER BY STR DESC", STR_IDX_NAME);
+
+        checkQueryPlan(conn, "SELECT * FROM T WHERE X IS NULL", NON_UNIQUE_IDX_NAME);
+        checkQueryPlan(conn, "SELECT * FROM T WHERE X = 10000", NON_UNIQUE_IDX_NAME);
+        checkQueryPlan(conn, "SELECT * FROM T WHERE X > 10000", NON_UNIQUE_IDX_NAME);
+        checkQueryPlan(conn, "SELECT * FROM T ORDER BY X DESC", NON_UNIQUE_IDX_NAME);
+        checkQueryPlan(conn, "SELECT * FROM T ORDER BY X DESC, T", NON_UNIQUE_IDX_NAME);
+
+        checkQueryPlan(conn, "SELECT * FROM T ORDER BY T, X DESC", SCAN_IDX_NAME);
+
+        // Simple queries.
+
+        Statement s = conn.createStatement();
+
+        ResultSet rs = s.executeQuery("select id from t where x between 0 and 100");
+
+        int i = 0;
+        while (rs.next())
+            i++;
+
+        assertEquals(MAX_X + 2, i);
+
+        // -----
+
+        rs = s.executeQuery("select id from t where t is not null");
+
+        i = 0;
+        while (rs.next())
+            i++;
+
+        assertEquals(MAX_X + 2, i);
+
+        // ----
+
+        int cnt = 10 + rnd.nextInt(25);
+
+        long t = System.currentTimeMillis();
+
+        for (i = 0; i < cnt; i++) {
+            id = UUID.randomUUID();
+
+            assertTrue(tbl.doUpdate(row(id, t, id.toString(), 51), false));
+        }
+
+        rs = s.executeQuery("select x, id from t where x = 51 limit " + cnt);
+
+        i = 0;
+
+        while (rs.next()) {
+            assertEquals(51, rs.getInt(1));
+
+            i++;
+        }
+
+        assertEquals(cnt, i);
+    }
+
+    /**
+     * Dumps all table rows for index.
+     *
+     * @param idx Index.
+     */
+    private void dumpRows(GridH2TreeIndex idx) {
+        Iterator<GridH2Row> iter = idx.rows();
+
+        while (iter.hasNext())
+            System.out.println(iter.next().toString());
+    }
+
+    /**
+     * Multithreaded indexes consistency test.
+     *
+     * @throws Exception If failed.
+     */
+    public void testIndexesMultiThreadedConsistency() throws Exception {
+        final int threads = 19;
+        final int iterations = 1500;
+
+        multithreaded(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                Random rnd = new Random();
+
+                PreparedStatement ps1 = null;
+
+                for (int i = 0; i < iterations; i++) {
+                    UUID id = UUID.randomUUID();
+
+                    int x = rnd.nextInt(50);
+
+                    long t = System.currentTimeMillis();
+
+                    GridH2Row row = row(id, t, rnd.nextBoolean() ? id.toString() : UUID.randomUUID().toString(), x);
+
+                    assertTrue(tbl.doUpdate(row, false));
+
+                    if (rnd.nextInt(100) == 0) {
+                        tbl.lock(null, false, false);
+
+                        long cnt = 0;
+
+                        try {
+                            ArrayList<Index> idxs = tbl.getIndexes();
+
+                            // Consistency check.
+                            Set<Row> rowSet = checkIndexesConsistent(idxs, null);
+
+                            // Order check.
+                            checkOrdered(idxs);
+
+                            checkIndexesConsistent(idxs, rowSet);
+
+                            cnt = idxs.get(0).getRowCount(null);
+                        }
+                        finally {
+                            tbl.unlock(null);
+                        }
+
+                        // Row count is valid.
+                        ResultSet rs = conn.createStatement().executeQuery("select count(*) from t");
+
+                        assertTrue(rs.next());
+
+                        int cnt2 = rs.getInt(1);
+
+                        rs.close();
+
+                        assertTrue(cnt2 + " must be >= " + cnt, cnt2 >= cnt);
+                        assertTrue(cnt2 <= threads * iterations);
+
+                        // Search by ID.
+                        rs = conn.createStatement().executeQuery("select * from t where id = '" + id.toString() + "'");
+
+                        assertTrue(rs.next());
+                        assertFalse(rs.next());
+
+                        rs.close();
+
+                        // Scan search.
+                        if (ps1 == null)
+                            ps1 = conn.prepareStatement("select id from t where x = ? order by t desc");
+
+                        ps1.setInt(1, x);
+
+                        rs = ps1.executeQuery();
+
+                        for (;;) {
+                            assertTrue(rs.next());
+
+                            if (rs.getObject(1).equals(id))
+                                break;
+                        }
+
+                        rs.close();
+                    }
+                }
+                return null;
+            }
+        }, threads);
+    }
+
+    /**
+     * Run test in endless loop.
+     *
+     * @param args Arguments.
+     * @throws Exception If failed.
+     */
+    @SuppressWarnings("InfiniteLoopStatement")
+    public static void main(String ... args) throws Exception {
+        for (int i = 0;;) {
+            GridH2TableSelfTest t = new GridH2TableSelfTest();
+
+            t.beforeTest();
+
+            t.testDataLoss();
+
+            t.afterTest();
+
+            System.out.println("..." + ++i);
+        }
+    }
+
+    /**
+      * @throws Exception If failed.
+     */
+    public void testRangeQuery() throws Exception {
+        int rows = 3000;
+        int xs = 37;
+
+        long t = System.currentTimeMillis();
+
+        Random rnd = new Random();
+
+        for (int i = 0 ; i < rows; i++) {
+            UUID id = UUID.randomUUID();
+
+            GridH2Row row = row(id, t++, id.toString(), rnd.nextInt(xs));
+
+            assertTrue(tbl.doUpdate(row, false));
+        }
+
+        PreparedStatement ps = conn.prepareStatement("select count(*) from t where x = ?");
+
+        int cnt = 0;
+
+        for (int x = 0; x < xs; x++) {
+            ps.setInt(1, x);
+
+            ResultSet rs = ps.executeQuery();
+
+            assertTrue(rs.next());
+
+            cnt += rs.getInt(1);
+        }
+
+        assertEquals(rows, cnt);
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testDataLoss() throws Exception {
+        final int threads = 37;
+        final int iterations = 15000;
+
+        final AtomicInteger cntr = new AtomicInteger();
+
+        final UUID[] ids = new UUID[threads * iterations];
+
+        for (int i = 0; i < ids.length; i++)
+            ids[i] = UUID.randomUUID();
+
+        final long t = System.currentTimeMillis();
+
+        final AtomicInteger deleted = new AtomicInteger();
+
+        multithreaded(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                Random rnd = new Random();
+
+                int offset = cntr.getAndIncrement() * iterations;
+
+                synchronized (ids[offset]) {
+                    for (int i = 0; i < iterations; i++) {
+                        UUID id = ids[offset + i];
+
+                        int x = rnd.nextInt(50);
+
+                        GridH2Row row = row(id, t, id.toString(), x);
+
+                        assertTrue(tbl.doUpdate(row, false));
+                    }
+                }
+
+                offset = (offset + iterations) % ids.length;
+
+                synchronized (ids[offset]) {
+                    for (int i = 0; i < iterations; i += 2) {
+                        UUID id = ids[offset + i];
+
+                        int x = rnd.nextInt(50);
+
+                        GridH2Row row = row(id, t, id.toString(), x);
+
+                        if (tbl.doUpdate(row, true))
+                            deleted.incrementAndGet();
+                    }
+                }
+
+                return null;
+            }
+        }, threads);
+
+        assertTrue(deleted.get() > 0);
+
+        PreparedStatement p = conn.prepareStatement("select count(*) from t where id = ?");
+
+        for (int i = 1; i < ids.length; i += 2) {
+            p.setObject(1, ids[i]);
+
+            ResultSet rs = p.executeQuery();
+
+            assertTrue(rs.next());
+
+            assertEquals(1, rs.getInt(1));
+        }
+
+        Statement s = conn.createStatement();
+
+        ResultSet rs = s.executeQuery("select count(*) from t");
+
+        assertTrue(rs.next());
+
+        assertEquals(ids.length - deleted.get(), rs.getInt(1));
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testRebuildIndexes() throws Exception {
+        ArrayList<GridH2IndexBase> idxsBefore = tbl.indexes();
+
+        assertEquals(3, idxsBefore.size());
+
+        Random rnd = new Random();
+
+        for (int i = 0; i < MAX_X; i++) {
+            UUID id = UUID.randomUUID();
+
+            GridH2Row row = row(id, System.currentTimeMillis(), rnd.nextBoolean() ? id.toString() :
+                    UUID.randomUUID().toString(), rnd.nextInt(100));
+
+            tbl.doUpdate(row, false);
+        }
+
+        for (GridH2IndexBase idx : idxsBefore)
+            assertEquals(MAX_X, idx.getRowCountApproximation());
+
+        tbl.rebuildIndexes();
+
+        ArrayList<GridH2IndexBase> idxsAfter = tbl.indexes();
+
+        assertEquals(3, idxsAfter.size());
+
+        for (int i = 0; i < 3; i++) {
+            GridH2IndexBase idxBefore = idxsBefore.get(i);
+            GridH2IndexBase idxAfter = idxsAfter.get(i);
+
+            assertNotSame(idxBefore, idxAfter);
+            assertEquals(idxBefore.getName(), idxAfter.getName());
+            assertSame(idxBefore.getTable(), idxAfter.getTable());
+            assertEquals(idxBefore.getRowCountApproximation(), idxAfter.getRowCountApproximation());
+            assertEquals(idxBefore.getIndexType().isUnique(), idxAfter.getIndexType().isUnique());
+            Assert.assertArrayEquals(idxBefore.getColumns(), idxAfter.getColumns());
+        }
+    }
+
+    /**
+     * Check query plan to correctly select index.
+     *
+     * @param conn Connection.
+     * @param sql Select.
+     * @param search Search token in result.
+     * @throws SQLException If failed.
+     */
+    private void checkQueryPlan(Connection conn, String sql, String search) throws SQLException {
+
+        try (Statement s = conn.createStatement()) {
+            try (ResultSet r = s.executeQuery("EXPLAIN ANALYZE " + sql)) {
+                assertTrue(r.next());
+
+                String plan = r.getString(1);
+
+                assertTrue("Execution plan for '" + sql + "' query should contain '" + search + "'",
+                        plan.contains(search));
+            }
+        }
+    }
+
+    /**
+     * @param idxs Indexes.
+     * @param rowSet Rows.
+     * @return Rows.
+     */
+    private Set<Row> checkIndexesConsistent(ArrayList<Index> idxs, @Nullable Set<Row> rowSet) {
+        for (Index idx : idxs) {
+            if (!(idx instanceof GridH2TreeIndex))
+                continue;
+
+            Set<Row> set = new HashSet<>();
+
+            Iterator<GridH2Row> iter = ((GridH2TreeIndex)idx).rows();
+
+            while(iter.hasNext())
+                assertTrue(set.add(iter.next()));
+
+            //((GridH2SnapTreeSet)((GridH2Index)idx).tree).print();
+
+            if (rowSet == null)
+                rowSet = set;
+            else
+                assertEquals(rowSet, set);
+        }
+
+        return rowSet;
+    }
+
+    /**
+     * @param idxs Indexes list.
+     */
+    private void checkOrdered(ArrayList<Index> idxs) {
+        for (Index idx : idxs) {
+            if (!(idx instanceof GridH2TreeIndex))
+                continue;
+
+            GridH2TreeIndex h2Idx = (GridH2TreeIndex)idx;
+
+            checkOrdered(h2Idx, h2Idx);
+        }
+    }
+
+    /**
+     * @param idx Index.
+     * @param cmp Comparator.
+     */
+    private void checkOrdered(GridH2TreeIndex idx, Comparator<? super GridH2Row> cmp) {
+        Iterator<GridH2Row> rows = idx.rows();
+
+        GridH2Row min = null;
+
+        while (rows.hasNext()) {
+            GridH2Row row = rows.next();
+
+            assertNotNull(row);
+
+            assertFalse("Incorrect row order in index: " + idx + "\n min: " + min + "\n row: " + row,
+                min != null && cmp.compare(min, row) > 0);
+
+            min = row;
+        }
+    }
+}


Mime
View raw message