ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [15/50] [abbrv] incubator-ignite git commit: # ignite-63
Date Fri, 23 Jan 2015 09:02:23 GMT
# ignite-63


Project: http://git-wip-us.apache.org/repos/asf/incubator-ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-ignite/commit/39bc4257
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ignite/tree/39bc4257
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ignite/diff/39bc4257

Branch: refs/heads/ignite-63
Commit: 39bc425723a8407f98b2955fccb0f45d209e261e
Parents: ed7736f
Author: sboikov <sboikov@gridgain.com>
Authored: Fri Jan 23 10:37:04 2015 +0300
Committer: sboikov <sboikov@gridgain.com>
Committed: Fri Jan 23 10:37:04 2015 +0300

----------------------------------------------------------------------
 .../GridCacheAbstractFieldsQuerySelfTest.java   | 1305 +++++++++++
 .../cache/GridCacheAbstractQuerySelfTest.java   | 2094 ++++++++++++++++++
 .../cache/GridCacheCrossCacheQuerySelfTest.java |  352 +++
 ...idCacheQueryEvictsMultiThreadedSelfTest.java |   28 +
 .../cache/GridCacheQueryLoadSelfTest.java       |  458 ++++
 .../cache/GridCacheQueryMetricsSelfTest.java    |  161 ++
 .../GridCacheQueryMultiThreadedSelfTest.java    |  859 +++++++
 ...QueryOffheapEvictsMultiThreadedSelfTest.java |   28 +
 ...dCacheQueryOffheapMultiThreadedSelfTest.java |   28 +
 .../cache/GridCacheQueryTestValue.java          |  173 ++
 ...idCacheReduceQueryMultithreadedSelfTest.java |  159 ++
 .../GridCacheSqlQueryMultiThreadedSelfTest.java |  140 ++
 .../processors/cache/GridCacheSwapSelfTest.java |  722 ++++++
 .../cache/GridIndexingWithNoopSwapSelfTest.java |  117 +
 ...GridCachePartitionedFieldsQuerySelfTest.java |    2 +-
 .../near/GridCachePartitionedQuerySelfTest.java |    2 +-
 .../GridCacheReplicatedFieldsQuerySelfTest.java |    2 +-
 .../GridCacheReplicatedQuerySelfTest.java       |    1 -
 .../GridCacheLocalFieldsQuerySelfTest.java      |    2 +-
 .../local/GridCacheLocalQuerySelfTest.java      |    2 +-
 .../testsuites/GridCacheQuerySelfTestSuite.java |    1 +
 .../GridCacheAbstractFieldsQuerySelfTest.java   | 1305 -----------
 .../cache/GridCacheAbstractQuerySelfTest.java   | 2094 ------------------
 .../cache/GridCacheCrossCacheQuerySelfTest.java |  352 ---
 ...idCacheQueryEvictsMultiThreadedSelfTest.java |   28 -
 .../cache/GridCacheQueryLoadSelfTest.java       |  458 ----
 .../cache/GridCacheQueryMetricsSelfTest.java    |  161 --
 .../GridCacheQueryMultiThreadedSelfTest.java    |  859 -------
 ...QueryOffheapEvictsMultiThreadedSelfTest.java |   28 -
 ...dCacheQueryOffheapMultiThreadedSelfTest.java |   28 -
 .../cache/GridCacheQueryTestValue.java          |  172 --
 ...idCacheReduceQueryMultithreadedSelfTest.java |  158 --
 .../GridCacheSqlQueryMultiThreadedSelfTest.java |  140 --
 .../processors/cache/GridCacheSwapSelfTest.java |  722 ------
 .../cache/GridIndexingWithNoopSwapSelfTest.java |  117 -
 35 files changed, 6630 insertions(+), 6628 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/39bc4257/modules/indexing/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFieldsQuerySelfTest.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFieldsQuerySelfTest.java
b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFieldsQuerySelfTest.java
new file mode 100644
index 0000000..5b37029
--- /dev/null
+++ b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFieldsQuerySelfTest.java
@@ -0,0 +1,1305 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.processors.cache;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.affinity.*;
+import org.apache.ignite.cache.query.*;
+import org.apache.ignite.configuration.*;
+import org.apache.ignite.lang.*;
+import org.apache.ignite.marshaller.optimized.*;
+import org.apache.ignite.spi.discovery.*;
+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.internal.processors.cache.query.*;
+import org.apache.ignite.internal.processors.query.*;
+import org.apache.ignite.internal.util.typedef.*;
+import org.apache.ignite.testframework.junits.common.*;
+import org.jetbrains.annotations.*;
+
+import java.io.*;
+import java.util.*;
+
+import static org.apache.ignite.cache.GridCacheAtomicityMode.*;
+import static org.apache.ignite.cache.GridCacheMode.*;
+import static org.apache.ignite.cache.GridCachePreloadMode.*;
+
+/**
+ * Tests for fields queries.
+ */
+public abstract class GridCacheAbstractFieldsQuerySelfTest extends GridCommonAbstractTest
{
+    /** IP finder. */
+    private static final TcpDiscoveryIpFinder IP_FINDER = new TcpDiscoveryVmIpFinder(true);
+
+    /** Cache name. */
+    private static final String CACHE = "cache";
+
+    /** Empty cache name. */
+    private static final String EMPTY_CACHE = "emptyCache";
+
+    /** Name of the cache that doesn't index primitives. */
+    private static final String CACHE_NO_PRIMITIVES = "cacheNoPrimitives";
+
+    /** Name of the cache that doesn't index primitives. */
+    private static final String CACHE_COMPLEX_KEYS = "cacheComplexKeys";
+
+    /** Flag indicating if starting node should have cache. */
+    protected boolean hasCache;
+
+    /** {@inheritDoc} */
+    @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception
{
+        IgniteConfiguration cfg = super.getConfiguration(gridName);
+
+        cfg.setMarshaller(new IgniteOptimizedMarshaller(false));
+
+        if (hasCache)
+            cfg.setCacheConfiguration(cache(null, null), cache(CACHE, null), cache(EMPTY_CACHE,
null));
+        else
+            cfg.setCacheConfiguration();
+
+        cfg.setDiscoverySpi(discovery());
+
+        return cfg;
+    }
+
+    /**
+     * @param name Cache name.
+     * @param spiName Indexing SPI name.
+     * @return Cache.
+     */
+    protected CacheConfiguration cache(@Nullable String name, @Nullable String spiName) {
+        CacheConfiguration cache = defaultCacheConfiguration();
+
+        cache.setName(name);
+        cache.setCacheMode(cacheMode());
+        cache.setAtomicityMode(atomicityMode());
+        cache.setWriteSynchronizationMode(GridCacheWriteSynchronizationMode.FULL_SYNC);
+        cache.setPreloadMode(SYNC);
+
+        GridCacheQueryConfiguration qcfg = new GridCacheQueryConfiguration();
+
+        qcfg.setIndexPrimitiveKey(true);
+        qcfg.setIndexPrimitiveValue(true);
+        qcfg.setIndexFixedTyping(true);
+
+        cache.setQueryConfiguration(qcfg);
+
+        if (cacheMode() == PARTITIONED)
+            cache.setBackups(1);
+
+        return cache;
+    }
+
+    /** @return Discovery SPI. */
+    private DiscoverySpi discovery() {
+        TcpDiscoverySpi spi = new TcpDiscoverySpi();
+
+        spi.setIpFinder(IP_FINDER);
+
+        return spi;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void beforeTestsStarted() throws Exception {
+        hasCache = true;
+
+        startGridsMultiThreaded(gridCount());
+
+        hasCache = false;
+
+        startGrid(gridCount());
+
+        GridCache<String, Organization> orgCache = grid(0).cache(null);
+
+        assert orgCache != null;
+
+        assert orgCache.putx("o1", new Organization(1, "A"));
+        assert orgCache.putx("o2", new Organization(2, "B"));
+
+        GridCache<GridCacheAffinityKey<String>, Person> personCache = grid(0).cache(null);
+
+        assert personCache != null;
+
+        assert personCache.putx(new GridCacheAffinityKey<>("p1", "o1"), new Person("John
White", 25, 1));
+        assert personCache.putx(new GridCacheAffinityKey<>("p2", "o1"), new Person("Joe
Black", 35, 1));
+        assert personCache.putx(new GridCacheAffinityKey<>("p3", "o2"), new Person("Mike
Green", 40, 2));
+
+        GridCache<String, String> strCache = grid(0).cache(null);
+
+        assert strCache != null;
+
+        assert strCache.putx("key", "val");
+
+        GridCache<Integer, Integer> intCache = grid(0).cache(null);
+
+        assert intCache != null;
+
+        for (int i = 0; i < 200; i++)
+            assert intCache.putx(i, i);
+
+        GridCache<Integer, Integer> namedCache = grid(0).cache(CACHE);
+
+        for (int i = 0; i < 200; i++)
+            assert namedCache.putx(i, i);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void afterTestsStopped() throws Exception {
+        stopAllGrids();
+    }
+
+    /** @return cache mode. */
+    protected abstract GridCacheMode cacheMode();
+
+    /** @return Cache atomicity mode. */
+    protected GridCacheAtomicityMode atomicityMode() {
+        return TRANSACTIONAL;
+    }
+
+    /** @return Number of grids to start. */
+    protected abstract int gridCount();
+
+    /** @throws Exception If failed. */
+    public void testCacheMetaData() throws Exception {
+        // Create data structure to test filtering of internal objects.
+        grid(0).cache(null).dataStructures().atomicLong("LONG", 0, true);
+
+        Collection<GridCacheSqlMetadata> metas =
+            ((GridCacheQueriesEx<?, ?>)grid(0).cache(null).queries()).sqlMetadata();
+
+        assert metas != null;
+        assertEquals("Invalid meta: " + metas, 3, metas.size());
+
+        boolean wasNull = false;
+        boolean wasNamed = false;
+        boolean wasEmpty = false;
+
+        for (GridCacheSqlMetadata meta : metas) {
+            if (meta.cacheName() == null) {
+                Collection<String> types = meta.types();
+
+                assert types != null;
+                assert types.size() == 4;
+                assert types.contains("Person");
+                assert types.contains("Organization");
+                assert types.contains("String");
+                assert types.contains("Integer");
+
+                assert GridCacheAffinityKey.class.getName().equals(meta.keyClass("Person"));
+                assert String.class.getName().equals(meta.keyClass("Organization"));
+                assert String.class.getName().equals(meta.keyClass("String"));
+
+                assert Person.class.getName().equals(meta.valueClass("Person"));
+                assert Organization.class.getName().equals(meta.valueClass("Organization"));
+                assert String.class.getName().equals(meta.valueClass("String"));
+
+                Map<String, String> fields = meta.fields("Person");
+
+                assert fields != null;
+                assert fields.size() == 5;
+                assert GridCacheAffinityKey.class.getName().equals(fields.get("_KEY"));
+                assert Person.class.getName().equals(fields.get("_VAL"));
+                assert String.class.getName().equals(fields.get("NAME"));
+                assert int.class.getName().equals(fields.get("AGE"));
+                assert int.class.getName().equals(fields.get("ORGID"));
+
+                fields = meta.fields("Organization");
+
+                assert fields != null;
+                assert fields.size() == 4;
+                assert String.class.getName().equals(fields.get("_KEY"));
+                assert Organization.class.getName().equals(fields.get("_VAL"));
+                assert int.class.getName().equals(fields.get("ID"));
+                assert String.class.getName().equals(fields.get("NAME"));
+
+                fields = meta.fields("String");
+
+                assert fields != null;
+                assert fields.size() == 2;
+                assert String.class.getName().equals(fields.get("_KEY"));
+                assert String.class.getName().equals(fields.get("_VAL"));
+
+                fields = meta.fields("Integer");
+
+                assert fields != null;
+                assert fields.size() == 2;
+                assert Integer.class.getName().equals(fields.get("_KEY"));
+                assert Integer.class.getName().equals(fields.get("_VAL"));
+
+                Collection<GridCacheSqlIndexMetadata> indexes = meta.indexes("Person");
+
+                assertEquals(2, indexes.size());
+
+                wasNull = true;
+            }
+            else if (CACHE.equals(meta.cacheName()))
+                wasNamed = true;
+            else if (EMPTY_CACHE.equals(meta.cacheName())) {
+                assert meta.types().isEmpty();
+
+                wasEmpty = true;
+            }
+        }
+
+        assert wasNull;
+        assert wasNamed;
+        assert wasEmpty;
+    }
+
+    /** @throws Exception If failed. */
+    public void testExecute() throws Exception {
+        GridCacheQuery<List<?>> qry = grid(0).cache(null).queries().createSqlFieldsQuery(
+            "select _KEY, name, age from Person");
+
+        GridCacheQueryFuture<List<?>> fut = qry.execute();
+
+        assert metadata(fut) == null;
+
+        List<List<?>> res = new ArrayList<>(fut.get());
+
+        assert res != null;
+
+        dedup(res);
+
+        assertEquals(res.size(), 3);
+
+        Collections.sort(res, new Comparator<List<?>>() {
+            @Override public int compare(List<?> row1, List<?> row2) {
+                return ((Integer)row1.get(2)).compareTo((Integer)row2.get(2));
+            }
+        });
+
+        int cnt = 0;
+
+        for (List<?> row : res) {
+            assert row.size() == 3;
+
+            if (cnt == 0) {
+                assert new GridCacheAffinityKey<>("p1", "o1").equals(row.get(0));
+                assert "John White".equals(row.get(1));
+                assert row.get(2).equals(25);
+            }
+            else if (cnt == 1) {
+                assert new GridCacheAffinityKey<>("p2", "o1").equals(row.get(0));
+                assert "Joe Black".equals(row.get(1));
+                assert row.get(2).equals(35);
+            }
+            if (cnt == 2) {
+                assert new GridCacheAffinityKey<>("p3", "o2").equals(row.get(0));
+                assert "Mike Green".equals(row.get(1));
+                assert row.get(2).equals(40);
+            }
+
+            cnt++;
+        }
+
+        assert cnt == 3;
+    }
+
+    /** @throws Exception If failed. */
+    public void testExecuteWithArguments() throws Exception {
+        GridCacheQuery<List<?>> qry = grid(0).cache(null).queries().createSqlFieldsQuery(
+            "select _KEY, name, age from Person where age > ?");
+
+        GridCacheQueryFuture<List<?>> fut = qry.execute(30);
+
+        assert metadata(fut) == null;
+
+        List<List<?>> res = new ArrayList<>(fut.get());
+
+        assert res != null;
+
+        dedup(res);
+
+        assert res.size() == 2;
+
+        Collections.sort(res, new Comparator<List<?>>() {
+            @Override public int compare(List<?> row1, List<?> row2) {
+                return ((Integer)row1.get(2)).compareTo((Integer)row2.get(2));
+            }
+        });
+
+        int cnt = 0;
+
+        for (List<?> row : res) {
+            assert row.size() == 3;
+
+            if (cnt == 0) {
+                assert new GridCacheAffinityKey<>("p2", "o1").equals(row.get(0));
+                assert "Joe Black".equals(row.get(1));
+                assert row.get(2).equals(35);
+            }
+            else if (cnt == 1) {
+                assert new GridCacheAffinityKey<>("p3", "o2").equals(row.get(0));
+                assert "Mike Green".equals(row.get(1));
+                assert row.get(2).equals(40);
+            }
+
+            cnt++;
+        }
+
+        assert cnt == 2;
+    }
+
+    /** @throws Exception If failed. */
+    public void testExecuteWithMetaData() throws Exception {
+        GridCacheQuery<List<?>> qry = ((GridCacheQueriesEx<?, ?>)grid(0).cache(null).queries()).createSqlFieldsQuery(
+            "select p._KEY, p.name, p.age, o.name " +
+                "from Person p, Organization o where p.orgId = o.id",
+            true);
+
+        GridCacheQueryFuture<List<?>> fut = qry.execute();
+
+        List<GridQueryFieldMetadata> meta = metadata(fut);
+
+        assert meta != null;
+        assert meta.size() == 4;
+
+        Iterator<GridQueryFieldMetadata> metaIt = meta.iterator();
+
+        assert metaIt != null;
+        assert metaIt.hasNext();
+
+        GridQueryFieldMetadata field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "PERSON".equals(field.typeName());
+        assert "_KEY".equals(field.fieldName());
+        assert Object.class.getName().equals(field.fieldTypeName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "PERSON".equals(field.typeName());
+        assert "NAME".equals(field.fieldName());
+        assert String.class.getName().equals(field.fieldTypeName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "PERSON".equals(field.typeName());
+        assert "AGE".equals(field.fieldName());
+        assert Integer.class.getName().equals(field.fieldTypeName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "ORGANIZATION".equals(field.typeName());
+        assert "NAME".equals(field.fieldName());
+        assert String.class.getName().equals(field.fieldTypeName());
+
+        assert !metaIt.hasNext();
+
+        List<List<?>> res = new ArrayList<>(fut.get());
+
+        dedup(res);
+
+        assertEquals(3, res.size());
+
+        Collections.sort(res, new Comparator<List<?>>() {
+            @Override public int compare(List<?> row1, List<?> row2) {
+                return ((Integer)row1.get(2)).compareTo((Integer)row2.get(2));
+            }
+        });
+
+        int cnt = 0;
+
+        for (List<?> row : res) {
+            assert row.size() == 4;
+
+            if (cnt == 0) {
+                assert new GridCacheAffinityKey<>("p1", "o1").equals(row.get(0));
+                assert "John White".equals(row.get(1));
+                assert row.get(2).equals(25);
+                assert "A".equals(row.get(3));
+            }
+            else if (cnt == 1) {
+                assert new GridCacheAffinityKey<>("p2", "o1").equals(row.get(0));
+                assert "Joe Black".equals(row.get(1));
+                assert row.get(2).equals(35);
+                assert "A".equals(row.get(3));
+            }
+            if (cnt == 2) {
+                assert new GridCacheAffinityKey<>("p3", "o2").equals(row.get(0));
+                assert "Mike Green".equals(row.get(1));
+                assert row.get(2).equals(40);
+                assert "B".equals(row.get(3));
+            }
+
+            cnt++;
+        }
+
+        assert cnt == 3;
+    }
+
+    /** @throws Exception If failed. */
+    public void testSelectAllJoined() throws Exception {
+        GridCacheQuery<List<?>> qry = ((GridCacheQueriesEx<?, ?>)grid(0).cache(null).queries()).createSqlFieldsQuery(
+            "select * from Person p, Organization o where p.orgId = o.id",
+            true);
+
+        GridCacheQueryFuture<List<?>> fut = qry.execute();
+
+        List<GridQueryFieldMetadata> meta = metadata(fut);
+
+        assert meta != null;
+        assert meta.size() == 9;
+
+        Iterator<GridQueryFieldMetadata> metaIt = meta.iterator();
+
+        assert metaIt != null;
+        assert metaIt.hasNext();
+
+        GridQueryFieldMetadata field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "PERSON".equals(field.typeName());
+        assert "_KEY".equals(field.fieldName());
+        assert Object.class.getName().equals(field.fieldTypeName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "PERSON".equals(field.typeName());
+        assert "_VAL".equals(field.fieldName());
+        assert Object.class.getName().equals(field.fieldTypeName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "PERSON".equals(field.typeName());
+        assert "NAME".equals(field.fieldName());
+        assert String.class.getName().equals(field.fieldTypeName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "PERSON".equals(field.typeName());
+        assert "AGE".equals(field.fieldName());
+        assert Integer.class.getName().equals(field.fieldTypeName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "PERSON".equals(field.typeName());
+        assert "ORGID".equals(field.fieldName());
+        assert Integer.class.getName().equals(field.fieldTypeName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "ORGANIZATION".equals(field.typeName());
+        assert "_KEY".equals(field.fieldName());
+        assert String.class.getName().equals(field.fieldTypeName()) : field.fieldTypeName();
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "ORGANIZATION".equals(field.typeName());
+        assert "_VAL".equals(field.fieldName());
+        assert Object.class.getName().equals(field.fieldTypeName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "ORGANIZATION".equals(field.typeName());
+        assert "ID".equals(field.fieldName());
+        assert Integer.class.getName().equals(field.fieldTypeName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "ORGANIZATION".equals(field.typeName());
+        assert "NAME".equals(field.fieldName());
+        assert String.class.getName().equals(field.fieldTypeName());
+
+        assert !metaIt.hasNext();
+
+        List<List<?>> res = new ArrayList<>(fut.get());
+
+        dedup(res);
+
+        assertEquals(3, res.size());
+
+        Collections.sort(res, new Comparator<List<?>>() {
+            @Override public int compare(List<?> row1, List<?> row2) {
+                return ((Integer)row1.get(3)).compareTo((Integer)row2.get(3));
+            }
+        });
+
+        int cnt = 0;
+
+        for (List<?> row : res) {
+            assert row.size() == 9;
+
+            if (cnt == 0) {
+                assert new GridCacheAffinityKey<>("p1", "o1").equals(row.get(0));
+                assert Person.class.getName().equals(row.get(1).getClass().getName());
+                assert "John White".equals(row.get(2));
+                assert row.get(3).equals(25);
+                assert row.get(4).equals(1);
+                assert "o1".equals(row.get(5));
+                assert Organization.class.getName().equals(row.get(6).getClass().getName());
+                assert row.get(7).equals(1);
+                assert "A".equals(row.get(8));
+            }
+            else if (cnt == 1) {
+                assert new GridCacheAffinityKey<>("p2", "o1").equals(row.get(0));
+                assert Person.class.getName().equals(row.get(1).getClass().getName());
+                assert "Joe Black".equals(row.get(2));
+                assert row.get(3).equals(35);
+                assert row.get(4).equals(1);
+                assert "o1".equals(row.get(5));
+                assert Organization.class.getName().equals(row.get(6).getClass().getName());
+                assert row.get(7).equals(1);
+                assert "A".equals(row.get(8));
+            }
+            if (cnt == 2) {
+                assert new GridCacheAffinityKey<>("p3", "o2").equals(row.get(0));
+                assert Person.class.getName().equals(row.get(1).getClass().getName());
+                assert "Mike Green".equals(row.get(2));
+                assert row.get(3).equals(40);
+                assert row.get(4).equals(2);
+                assert "o2".equals(row.get(5));
+                assert Organization.class.getName().equals(row.get(6).getClass().getName());
+                assert row.get(7).equals(2);
+                assert "B".equals(row.get(8));
+            }
+
+            cnt++;
+        }
+
+        assert cnt == 3;
+    }
+
+    /** @throws Exception If failed. */
+    public void testEmptyResult() throws Exception {
+        GridCacheQuery<List<?>> qry = ((GridCacheQueriesEx<?, ?>)grid(0).cache(null).queries()).createSqlFieldsQuery(
+            "select name from Person where age = 0", true);
+
+        GridCacheQueryFuture<List<?>> fut = qry.execute();
+
+        assert fut != null;
+
+        List<GridQueryFieldMetadata> meta = metadata(fut);
+
+        assert meta != null;
+        assert meta.size() == 1;
+
+        GridQueryFieldMetadata field = F.first(meta);
+
+        assert field != null;
+        assert "PUBLIC".equals(field.schemaName());
+        assert "PERSON".equals(field.typeName());
+        assert "NAME".equals(field.fieldName());
+        assert String.class.getName().equals(field.fieldTypeName());
+
+        Collection<List<?>> res = fut.get();
+
+        assert res != null;
+        assert res.isEmpty();
+    }
+
+    /** @throws Exception If failed. */
+    public void testQueryString() throws Exception {
+        GridCacheQuery<List<?>> qry = grid(0).cache(null).queries().createSqlFieldsQuery("select
* from String");
+
+        Collection<List<?>> res = qry.execute().get();
+
+        assert res != null;
+        assert res.size() == 1;
+
+        for (List<?> row : res) {
+            assert row != null;
+            assert row.size() == 2;
+            assert "key".equals(row.get(0));
+            assert "val".equals(row.get(1));
+        }
+    }
+
+    /** @throws Exception If failed. */
+    public void testQueryIntegersWithJoin() throws Exception {
+        GridCacheQuery<List<?>> qry = ((GridCacheQueriesEx<?, ?>)grid(0).cache(null).queries()).createSqlFieldsQuery(
+            "select i._KEY, i._VAL, j._KEY, j._VAL from Integer i join Integer j where i._VAL
>= 100", true)
+            .projection(grid(0));
+
+        GridCacheQueryFuture<List<?>> fut = qry.execute();
+
+        List<GridQueryFieldMetadata> meta = metadata(fut);
+
+        assert meta != null;
+        assert meta.size() == 4;
+
+        Iterator<GridQueryFieldMetadata> metaIt = meta.iterator();
+
+        assert metaIt.hasNext();
+
+        GridQueryFieldMetadata field = metaIt.next();
+
+        assert field != null;
+        assert "INTEGER".equals(field.typeName());
+        assert "_KEY".equals(field.fieldName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "INTEGER".equals(field.typeName());
+        assert "_VAL".equals(field.fieldName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "INTEGER".equals(field.typeName());
+        assert "_KEY".equals(field.fieldName());
+
+        assert metaIt.hasNext();
+
+        field = metaIt.next();
+
+        assert field != null;
+        assert "INTEGER".equals(field.typeName());
+        assert "_VAL".equals(field.fieldName());
+
+        assert !metaIt.hasNext();
+
+        Collection<List<?>> res = fut.get();
+
+        assert res != null;
+
+        if (cacheMode() == LOCAL)
+            assert res.size() == 20000;
+        else if (cacheMode() == REPLICATED)
+            assert res.size() == 60000;
+        else
+            assert res.size() <= 20000;
+
+        for (List<?> row : res) {
+            assert (Integer)row.get(0) >= 100;
+            assert (Integer)row.get(1) >= 100;
+            assert (Integer)row.get(2) >= 0;
+            assert (Integer)row.get(3) >= 0;
+        }
+    }
+
+    /** @throws Exception If failed. */
+    public void testPagination() throws Exception {
+        GridCacheQuery<List<?>> qry = grid(0).cache(null).queries().createSqlFieldsQuery("select
* from Integer");
+
+        qry.pageSize(20);
+
+        List<List<?>> res = new ArrayList<>(qry.execute().get());
+
+        dedup(res);
+
+        Collections.sort(res, new Comparator<List<?>>() {
+            @Override public int compare(List<?> r1, List<?> r2) {
+                return ((Integer)r1.get(0)).compareTo((Integer)r2.get(0));
+            }
+        });
+
+        assertEquals(200, res.size());
+
+       for (List<?> row : res)
+           assertEquals("Wrong row size: " + row, 2, row.size());
+    }
+
+    /** @throws Exception If failed. */
+    public void testNamedCache() throws Exception {
+        GridCache<Integer, Integer> cache = grid(0).cache(CACHE);
+
+        for (int i = 0; i < 200; i++)
+            assert cache.putx(i, i);
+
+        GridCacheQuery<List<?>> qry = cache.queries().createSqlFieldsQuery("select
* from Integer").projection(grid(0));
+
+        Collection<List<?>> res = qry.execute().get();
+
+        assert res != null;
+        assert res.size() == (cacheMode() == REPLICATED ? 200 * gridCount() : 200);
+    }
+
+    /** @throws Exception If failed. */
+    public void _testNoPrimitives() throws Exception { // TODO
+        GridCache<Object, Object> cache = grid(0).cache(CACHE_NO_PRIMITIVES);
+
+        assert cache.putx("key", "val");
+
+        Collection<GridCacheSqlMetadata> metas = ((GridCacheQueriesEx<?, ?>)cache.queries()).sqlMetadata();
+
+        assertEquals(1, metas.size());
+
+        assert F.first(metas).types().isEmpty() : "Non empty types: " + F.first(metas).types();
+
+        GridCacheQuery<List<?>> qry = cache.queries().createSqlFieldsQuery("select
* from String");
+
+        assert qry.execute().get().isEmpty();
+
+        cache.removeAll(F.<GridCacheEntry<Object, Object>>alwaysTrue());
+    }
+
+    /** @throws Exception If failed. */
+    public void _testComplexKeys() throws Exception { // TODO
+        GridCache<PersonKey, Person> cache = grid(0).cache(CACHE_COMPLEX_KEYS);
+
+        UUID id = UUID.randomUUID();
+
+        PersonKey key = new PersonKey(id);
+        Person val = new Person("John", 20, 1);
+
+        assert cache.putx(key, val);
+
+        Collection<GridCacheSqlMetadata> metas = ((GridCacheQueriesEx<?, ?>)cache.queries()).sqlMetadata();
+
+        assertEquals(1, metas.size());
+
+        GridCacheSqlMetadata meta = F.first(metas);
+
+        assertEquals(CACHE_COMPLEX_KEYS, meta.cacheName());
+
+        Collection<String> types = meta.types();
+
+        assertEquals(1, types.size());
+        assert types.contains("Person");
+
+        assertEquals(PersonKey.class.getName(), meta.keyClass("Person"));
+        assertEquals(Person.class.getName(), meta.valueClass("Person"));
+
+        Map<String, String> fields = meta.fields("Person");
+
+        assertEquals(6, fields.size());
+
+        int cnt = 0;
+
+        for (Map.Entry<String, String> e : fields.entrySet()) {
+            if (cnt == 0) {
+                assertEquals("_KEY", e.getKey());
+                assertEquals(PersonKey.class.getName(), e.getValue());
+            }
+            else if (cnt == 1) {
+                assertEquals("_VAL", e.getKey());
+                assertEquals(Person.class.getName(), e.getValue());
+            }
+            else if (cnt == 2) {
+                assertEquals("ID", e.getKey());
+                assertEquals(UUID.class.getName(), e.getValue());
+            }
+            else if (cnt == 3) {
+                assertEquals("NAME", e.getKey());
+                assertEquals(String.class.getName(), e.getValue());
+            }
+            else if (cnt == 4) {
+                assertEquals("AGE", e.getKey());
+                assertEquals(int.class.getName(), e.getValue());
+            }
+            else if (cnt == 5) {
+                assertEquals("ORGID", e.getKey());
+                assertEquals(int.class.getName(), e.getValue());
+            }
+
+            cnt++;
+        }
+
+        Collection<List<?>> res = cache.queries().createSqlFieldsQuery("select
* from Person").execute().get();
+
+        assertEquals(1, res.size());
+
+        for (Collection<?> row : res) {
+            cnt = 0;
+
+            for (Object fieldVal : row) {
+                if (cnt == 0)
+                    assertEquals(key, fieldVal);
+                else if (cnt == 1)
+                    assertEquals(val, fieldVal);
+                else if (cnt == 2)
+                    assertEquals(id, fieldVal);
+                else if (cnt == 3)
+                    assertEquals("John", fieldVal);
+                else if (cnt == 4)
+                    assertEquals(20, fieldVal);
+                else if (cnt == 5)
+                    assertEquals(1, fieldVal);
+
+                cnt++;
+            }
+        }
+
+        cache.removeAll(F.<GridCacheEntry<PersonKey, Person>>alwaysTrue());
+    }
+
+    /** @throws Exception If failed. */
+    public void testPaginationIteratorDefaultCache() throws Exception {
+        testPaginationIterator(null);
+    }
+
+    /** @throws Exception If failed. */
+    public void testPaginationIteratorNamedCache() throws Exception {
+        testPaginationIterator(CACHE);
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @throws Exception If failed.
+     */
+    private void testPaginationIterator(@Nullable String cacheName) throws Exception {
+        GridCacheQuery<List<?>> q = grid(0).cache(cacheName).queries().createSqlFieldsQuery("select
_key, _val from " +
+            "Integer")
+            .projection(grid(0));
+
+        q.pageSize(10);
+        q.keepAll(false);
+
+        GridCacheQueryFuture<List<?>> f = q.execute();
+
+        int cnt = 0;
+
+        List<?> row;
+
+        while ((row = f.next()) != null) {
+            assertEquals(2, row.size());
+            assertEquals(row.get(0), row.get(1));
+            assertTrue((Integer)row.get(0) >= 0 && (Integer)row.get(0) < 200);
+
+            cnt++;
+        }
+
+        int size = cacheMode() == REPLICATED ? 200 * gridCount() : 200;
+
+        assertEquals(size, cnt);
+
+        assertTrue(f.isDone());
+
+        if (cacheMode() != LOCAL)
+            assertTrue(f.get().size() < size);
+    }
+
+    /** @throws Exception If failed. */
+    public void testPaginationIteratorKeepAll() throws Exception {
+        GridCacheQuery<List<?>> q = grid(0).cache(null).queries().createSqlFieldsQuery(
+            "select _key, _val from Integer");
+
+        q.pageSize(10);
+        q.keepAll(true);
+
+        GridCacheQueryFuture<List<?>> f = q.execute();
+
+        int cnt = 0;
+
+        List<?> row;
+
+        while ((row = f.next()) != null) {
+            assertEquals(2, row.size());
+            assertEquals(row.get(0), row.get(1));
+            assertTrue((Integer)row.get(0) >= 0 && (Integer)row.get(0) < 200);
+
+            cnt++;
+        }
+
+        int size = 200;
+
+        assertEquals(size, cnt);
+
+        assertTrue(f.isDone());
+
+        List<List<?>> list = new ArrayList<>(f.get());
+
+        dedup(list);
+
+        Collections.sort(list, new Comparator<List<?>>() {
+            @Override public int compare(List<?> r1, List<?> r2) {
+                return ((Integer)r1.get(0)).compareTo((Integer)r2.get(0));
+            }
+        });
+
+        for (int i = 0; i < 200; i++) {
+            List<?> r = list.get(i);
+
+            assertEquals(i, r.get(0));
+            assertEquals(i, r.get(1));
+        }
+    }
+
+    /** @throws Exception If failed. */
+    public void testPaginationGetDefaultCache() throws Exception {
+        testPaginationGet(null);
+    }
+
+    /** @throws Exception If failed. */
+    public void testPaginationGetNamedCache() throws Exception {
+        testPaginationGet(CACHE);
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @throws Exception If failed.
+     */
+    private void testPaginationGet(@Nullable String cacheName) throws Exception {
+        GridCacheQuery<List<?>> q = grid(0).cache(cacheName).queries().createSqlFieldsQuery("select
_key, _val from " +
+            "Integer");
+
+        q.pageSize(10);
+        q.keepAll(true);
+
+        GridCacheQueryFuture<List<?>> f = q.execute();
+
+        List<List<?>> list = new ArrayList<>(f.get());
+
+        dedup(list);
+
+        Collections.sort(list, new Comparator<List<?>>() {
+            @Override public int compare(List<?> r1, List<?> r2) {
+                return ((Integer)r1.get(0)).compareTo((Integer)r2.get(0));
+            }
+        });
+
+        for (int i = 0; i < 200; i++) {
+            List<?> row = list.get(i);
+
+            assertEquals(i, row.get(0));
+            assertEquals(i, row.get(1));
+        }
+    }
+
+    /** @throws Exception If failed. */
+    public void testEmptyGrid() throws Exception {
+        GridCacheQuery<List<?>> qry = grid(0).cache(null).queries().createSqlFieldsQuery("select
name, " +
+            "age from Person where age = 25");
+
+        List<?> res = F.first(qry.execute().get());
+
+        assert res != null;
+        assert res.size() == 2;
+        assert "John White".equals(res.get(0));
+        assert res.get(1).equals(25);
+    }
+
+    /** @throws Exception If failed. */
+    public void testOnProjection() throws Exception {
+        P2<Integer, Integer> p = new P2<Integer, Integer>() {
+            @Override public boolean apply(Integer key, Integer val) {
+                return val < 30;
+            }
+        };
+
+        GridCacheProjection<Integer, Integer> cachePrj = grid(0).<Integer, Integer>cache(null).projection(p);
+
+        GridCacheQuery<List<?>> q = cachePrj.queries()
+            .createSqlFieldsQuery("select _key, _val from Integer where _key >= 20 and
_val < 40");
+
+        List<List<?>> list = new ArrayList<>(q.execute().get());
+
+        dedup(list);
+
+        Collections.sort(list, new Comparator<List<?>>() {
+            @Override public int compare(List<?> r1, List<?> r2) {
+                return ((Integer)r1.get(0)).compareTo((Integer)r2.get(0));
+            }
+        });
+
+        assertEquals(10, list.size());
+
+        for (int i = 20; i < 30; i++) {
+            List<?> row = list.get(i - 20);
+
+            assertEquals(i, row.get(0));
+            assertEquals(i, row.get(1));
+        }
+    }
+
+    /**
+     * Dedups result.
+     *
+     * @param res Result.
+     * @throws Exception In case of error.
+     */
+    private void dedup(Collection<List<?>> res) throws Exception {
+        assert res != null;
+
+        if (cacheMode() != REPLICATED)
+            return;
+
+        Collection<List<?>> res0 = new ArrayList<>(res.size());
+
+        Collection<Object> keys = new HashSet<>();
+
+        for (List<?> row : res) {
+            Object key = row.get(0);
+
+            if (!keys.contains(key)) {
+                res0.add(row);
+                keys.add(key);
+            }
+        }
+
+        res.clear();
+
+        res.addAll(res0);
+    }
+
+    /**
+     * @param fut Query future.
+     * @return Metadata.
+     * @throws IgniteCheckedException In case of error.
+     */
+    private List<GridQueryFieldMetadata> metadata(GridCacheQueryFuture<List<?>>
fut) throws IgniteCheckedException {
+        assert fut != null;
+
+        return ((GridCacheQueryMetadataAware)fut).metadata().get();
+    }
+
+    /**
+     */
+    private static class RemoteSumReducerFactory implements C1<Object[], IgniteReducer<List<Object>,
Integer>> {
+        /** {@inheritDoc} */
+        @Override public IgniteReducer<List<Object>, Integer> apply(Object[]
args) {
+            return new RemoteSumReducer();
+        }
+    }
+
+    /**
+     */
+    private static class RemoteSumReducer implements R1<List<Object>, Integer>
{
+        /** */
+        private int sum;
+
+        /** {@inheritDoc} */
+        @Override public boolean collect(@Nullable List<Object> row) {
+            if (row != null)
+                sum += (int)row.get(0);
+
+            return true;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Integer reduce() {
+            return sum;
+        }
+    }
+
+    /**
+     */
+    private static class LocalSumReducerFactory implements C1<Object[], IgniteReducer<Integer,
Integer>> {
+        /** {@inheritDoc} */
+        @Override public IgniteReducer<Integer, Integer> apply(Object[] args) {
+            return new LocalSumReducer();
+        }
+    }
+
+    /**
+     */
+    private static class LocalSumReducer implements R1<Integer, Integer> {
+        /** */
+        private int sum;
+
+        /** {@inheritDoc} */
+        @Override public boolean collect(@Nullable Integer val) {
+            if (val != null)
+                sum += val;
+
+            return true;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Integer reduce() {
+            return sum;
+        }
+    }
+
+    /**
+     * Person key.
+     */
+    @SuppressWarnings("UnusedDeclaration")
+    private static class PersonKey implements Serializable {
+        /** ID. */
+        @GridCacheQuerySqlField
+        private final UUID id;
+
+        /** @param id ID. */
+        private PersonKey(UUID id) {
+            assert id != null;
+
+            this.id = id;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean equals(Object o) {
+            if (this == o)
+                return true;
+
+            if (o == null || getClass() != o.getClass())
+                return false;
+
+            PersonKey key = (PersonKey)o;
+
+            return id.equals(key.id);
+
+        }
+
+        /** {@inheritDoc} */
+        @Override public int hashCode() {
+            return id.hashCode();
+        }
+    }
+
+    /**
+     * Person.
+     */
+    @SuppressWarnings("UnusedDeclaration")
+    private static class Person implements Serializable {
+        /** Name. */
+        @GridCacheQuerySqlField(index = false)
+        private final String name;
+
+        /** Age. */
+        @GridCacheQuerySqlField(index = true)
+        private final int age;
+
+        /** Organization ID. */
+        @GridCacheQuerySqlField(index = true)
+        private final int orgId;
+
+        /**
+         * @param name Name.
+         * @param age Age.
+         * @param orgId Organization ID.
+         */
+        private Person(String name, int age, int orgId) {
+            assert !F.isEmpty(name);
+            assert age > 0;
+            assert orgId > 0;
+
+            this.name = name;
+            this.age = age;
+            this.orgId = orgId;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean equals(Object o) {
+            if (this == o)
+                return true;
+
+            if (o == null || getClass() != o.getClass())
+                return false;
+
+            Person person = (Person)o;
+
+            return age == person.age && orgId == person.orgId && name.equals(person.name);
+
+        }
+
+        /** {@inheritDoc} */
+        @Override public int hashCode() {
+            int res = name.hashCode();
+
+            res = 31 * res + age;
+            res = 31 * res + orgId;
+
+            return res;
+        }
+    }
+
+    /**
+     * Organization.
+     */
+    @SuppressWarnings("UnusedDeclaration")
+    private static class Organization implements Serializable {
+        /** ID. */
+        @GridCacheQuerySqlField
+        private final int id;
+
+        /** Name. */
+        @GridCacheQuerySqlField(index = false)
+        private final String name;
+
+        /**
+         * @param id ID.
+         * @param name Name.
+         */
+        private Organization(int id, String name) {
+            assert id > 0;
+            assert !F.isEmpty(name);
+
+            this.id = id;
+            this.name = name;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean equals(Object o) {
+            if (this == o)
+                return true;
+
+            if (o == null || getClass() != o.getClass())
+                return false;
+
+            Organization that = (Organization)o;
+
+            return id == that.id && name.equals(that.name);
+
+        }
+
+        /** {@inheritDoc} */
+        @Override public int hashCode() {
+            int res = id;
+
+            res = 31 * res + name.hashCode();
+
+            return res;
+        }
+    }
+}


Mime
View raw message