modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/IgniteCachelessQueriesSelfTest.java

/*
 * 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.query;

import java.io.Serializable;
import java.util.Map;
import org.apache.ignite.Ignite;
import org.apache.ignite.IgniteCache;
import org.apache.ignite.cache.CacheAtomicityMode;
import org.apache.ignite.cache.CacheKeyConfiguration;
import org.apache.ignite.cache.CacheMode;
import org.apache.ignite.cache.query.SqlFieldsQuery;
import org.apache.ignite.cache.query.annotations.QuerySqlField;
import org.apache.ignite.configuration.CacheConfiguration;
import org.apache.ignite.configuration.IgniteConfiguration;
import org.apache.ignite.internal.processors.cache.query.GridCacheTwoStepQuery;
import org.apache.ignite.internal.processors.query.h2.QueryParserCacheEntry;
import org.apache.ignite.internal.util.typedef.internal.U;
import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
import org.junit.Test;

/**
 * Tests for behavior in various cases of local and distributed queries.
 */
public class IgniteCachelessQueriesSelfTest extends GridCommonAbstractTest {
    /** */
    private static final String SELECT =
        "select count(*) from \"pers\".Person p, \"org\".Organization o where p.orgId = o._key";

    /** */
    private static final String ORG_CACHE_NAME = "org";

    /** */
    private static final String PERSON_CAHE_NAME = "pers";

    /** {@inheritDoc} */
    @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
        IgniteConfiguration cfg = super.getConfiguration(gridName);

        CacheKeyConfiguration keyCfg = new CacheKeyConfiguration("MyCache", "affKey");

        cfg.setCacheKeyConfiguration(keyCfg);

        cfg.setPeerClassLoadingEnabled(false);

        return cfg;
    }

    /** @return number of nodes to be prestarted. */
    private int nodesCount() {
        return 1;
    }

    /** {@inheritDoc} */
    @Override protected void beforeTest() throws Exception {
        super.beforeTest();

        startGrids(nodesCount());
    }

    /** {@inheritDoc} */
    @Override protected void afterTest() throws Exception {
        stopAllGrids();

        super.afterTest();
    }

    /**
     * @param name Cache name.
     * @param mode Cache mode.
     * @param idxTypes Indexed types.
     * @return Cache configuration.
     */
    protected <K, V> CacheConfiguration<K, V> cacheConfig(String name, TestCacheMode mode, Class<?>... idxTypes) {
        return new CacheConfiguration<K, V>()
            .setName(name)
            .setCacheMode(mode == TestCacheMode.REPLICATED ? CacheMode.REPLICATED : CacheMode.PARTITIONED)
            .setQueryParallelism(mode == TestCacheMode.SEGMENTED ? 5 : 1)
            .setAtomicityMode(CacheAtomicityMode.ATOMIC)
            .setIndexedTypes(idxTypes);
    }

    /**
     *
     */
    @Test
    public void testDistributedQueryOnPartitionedCaches() {
        createCachesAndExecuteQuery(TestCacheMode.PARTITIONED, TestCacheMode.PARTITIONED, false, false);

        assertDistributedQuery();
    }

    /**
     *
     */
    @Test
    public void testDistributedQueryOnPartitionedAndReplicatedCache() {
        createCachesAndExecuteQuery(TestCacheMode.PARTITIONED, TestCacheMode.REPLICATED, false, false);

        assertDistributedQuery();
    }

    /**
     *
     */
    @Test
    public void testDistributedQueryOnReplicatedCaches() {
        createCachesAndExecuteQuery(TestCacheMode.REPLICATED, TestCacheMode.REPLICATED, false, false);

        assertLocalQuery();
    }

    /**
     *
     */
    @Test
    public void testDistributedQueryOnSegmentedCaches() {
        createCachesAndExecuteQuery(TestCacheMode.SEGMENTED, TestCacheMode.SEGMENTED, false, false);

        assertDistributedQuery();
    }

    /**
     *
     */
    @Test
    public void testDistributedQueryOnReplicatedAndSegmentedCache() {
        createCachesAndExecuteQuery(TestCacheMode.REPLICATED, TestCacheMode.SEGMENTED, false, false);

        assertDistributedQuery();
    }

    /**
     *
     */
    @Test
    public void testDistributedQueryOnPartitionedCachesWithReplicatedFlag() {
        createCachesAndExecuteQuery(TestCacheMode.PARTITIONED, TestCacheMode.PARTITIONED, true, false);

        assertDistributedQuery();
    }

    /**
     *
     */
    @Test
    public void testDistributedQueryOnPartitionedAndReplicatedCacheWithReplicatedFlag() {
        createCachesAndExecuteQuery(TestCacheMode.PARTITIONED, TestCacheMode.REPLICATED, true, false);

        assertDistributedQuery();
    }

    /**
     *
     */
    @Test
    public void testLocalQueryOnReplicatedCachesWithReplicatedFlag() {
        createCachesAndExecuteQuery(TestCacheMode.REPLICATED, TestCacheMode.REPLICATED, true, false);

        assertLocalQuery();
    }

    /**
     *
     */
    @Test
    public void testDistributedQueryOnSegmentedCachesWithReplicatedFlag() {
        createCachesAndExecuteQuery(TestCacheMode.SEGMENTED, TestCacheMode.SEGMENTED, true, false);

        assertDistributedQuery();
    }

    /**
     *
     */
    @Test
    public void testDistributedQueryOnReplicatedAndSegmentedCacheWithReplicatedFlag() {
        createCachesAndExecuteQuery(TestCacheMode.REPLICATED, TestCacheMode.SEGMENTED, true, false);

        assertDistributedQuery();
    }

    /**
     *
     */
    @Test
    public void testLocalQueryOnPartitionedCachesWithLocalFlag() {
        createCachesAndExecuteQuery(TestCacheMode.PARTITIONED, TestCacheMode.PARTITIONED, false, true);

        assertLocalQuery();
    }

    /**
     *
     */
    @Test
    public void testLocalQueryOnPartitionedAndReplicatedCacheWithLocalFlag() {
        createCachesAndExecuteQuery(TestCacheMode.PARTITIONED, TestCacheMode.REPLICATED, false, true);

        assertLocalQuery();
    }

    /**
     *
     */
    @Test
    public void testLocalQueryOnReplicatedCachesWithLocalFlag() {
        createCachesAndExecuteQuery(TestCacheMode.REPLICATED, TestCacheMode.REPLICATED, false, true);

        assertLocalQuery();
    }

    /**
     *
     */
    @Test
    public void testLocalTwoStepQueryOnSegmentedCachesWithLocalFlag() {
        createCachesAndExecuteQuery(TestCacheMode.SEGMENTED, TestCacheMode.SEGMENTED, false, true);

        assertLocalTwoStepQuery();
    }

    /**
     *
     */
    @Test
    public void testLocalTwoStepQueryOnReplicatedAndSegmentedCacheWithLocalFlag() {
        createCachesAndExecuteQuery(TestCacheMode.REPLICATED, TestCacheMode.SEGMENTED, false, true);

        assertLocalTwoStepQuery();
    }

    /**
     *
     */
    @Test
    public void testLocalQueryOnPartitionedCachesWithReplicatedAndLocalFlag() {
        createCachesAndExecuteQuery(TestCacheMode.PARTITIONED, TestCacheMode.PARTITIONED, false, true);

        assertLocalQuery();
    }

    /**
     *
     */
    @Test
    public void testLocalQueryOnPartitionedAndReplicatedCacheWithReplicatedAndLocalFlag() {
        createCachesAndExecuteQuery(TestCacheMode.PARTITIONED, TestCacheMode.REPLICATED, true, true);

        assertLocalQuery();
    }

    /**
     *
     */
    @Test
    public void testLocalQueryOnReplicatedCachesWithReplicatedAndLocalFlag() {
        createCachesAndExecuteQuery(TestCacheMode.REPLICATED, TestCacheMode.REPLICATED, true, true);

        assertLocalQuery();
    }

    /**
     *
     */
    @Test
    public void testLocalTwoStepQueryOnSegmentedCachesWithReplicatedAndLocalFlag() {
        createCachesAndExecuteQuery(TestCacheMode.SEGMENTED, TestCacheMode.SEGMENTED, true, true);

        assertLocalTwoStepQuery();
    }

    /**
     *
     */
    @Test
    public void testLocalTwoStepQueryOnReplicatedAndSegmentedCacheWithReplicatedAndLocalFlag() {
        createCachesAndExecuteQuery(TestCacheMode.REPLICATED, TestCacheMode.SEGMENTED, true, true);

        assertLocalTwoStepQuery();
    }

    /**
     * @param firstCacheMode First cache mode.
     * @param secondCacheMode Second cache mode.
     * @param replicatedOnly Replicated only query flag.
     * @param loc Local query flag.
     */
    private void createCachesAndExecuteQuery(TestCacheMode firstCacheMode, TestCacheMode secondCacheMode,
        boolean replicatedOnly, boolean loc) {
        Ignite node = ignite(0);

        node.createCache(cacheConfig(PERSON_CAHE_NAME, firstCacheMode, Integer.class, Person.class));
        node.createCache(cacheConfig(ORG_CACHE_NAME, secondCacheMode, Integer.class, Organization.class));

        IgniteCache<Integer, Person> c = node.cache(PERSON_CAHE_NAME);

        c.query(new SqlFieldsQuery(SELECT).setReplicatedOnly(replicatedOnly).setLocal(loc)).getAll();
    }

    /**
     * @return Cached two-step query, or {@code null} if none occurred.
     */
    private GridCacheTwoStepQuery cachedTwoStepQuery() {
        GridQueryIndexing idx = grid(0).context().query().getIndexing();

        Map<?, QueryParserCacheEntry> m = U.field((Object)U.field(idx, "parser"), "cache");

        if (m.isEmpty())
            return null;

        QueryParserCacheEntry q = m.values().iterator().next();

        return q.select().twoStepQuery();
    }

    /**
     * Check that truly distributed query has happened.
     */
    private void assertDistributedQuery() {
        GridCacheTwoStepQuery q = cachedTwoStepQuery();

        assertNotNull(q);

        assertFalse(q.isLocal());
    }

    /**
     * Check that local two-step query has happened.
     */
    private void assertLocalTwoStepQuery() {
        GridCacheTwoStepQuery q = cachedTwoStepQuery();

        assertNotNull(q);

        assertTrue(q.isLocal());
    }

    /**
     * Check that no distributed query has happened.
     */
    private void assertLocalQuery() {
        GridCacheTwoStepQuery q = cachedTwoStepQuery();

        assertNull(q);
    }

    /**
     *
     */
    private static class Person implements Serializable {
        /** */
        @QuerySqlField(index = true)
        Integer orgId;

        /** */
        @QuerySqlField
        String name;

        /**
         *
         */
        public Person() {
            // No-op.
        }

        /**
         * @param orgId Organization ID.
         * @param name Name.
         */
        public Person(int orgId, String name) {
            this.orgId = orgId;
            this.name = name;
        }
    }

    /**
     *
     */
    private static class Organization implements Serializable {
        /** */
        @QuerySqlField
        String name;

        /**
         *
         */
        public Organization() {
            // No-op.
        }

        /**
         * @param name Organization name.
         */
        public Organization(String name) {
            this.name = name;
        }
    }

    /**
     * Mode for test cache.
     */
    private enum TestCacheMode {
        /** */
        SEGMENTED,

        /** */
        PARTITIONED,

        /** */
        REPLICATED
    }
}