You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by ti...@apache.org on 2022/08/17 11:25:45 UTC

[ignite] branch master updated: IGNITE-14914 Add IndexQuery IN criterion (#10195)

This is an automated email from the ASF dual-hosted git repository.

timoninmaxim pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ignite.git


The following commit(s) were added to refs/heads/master by this push:
     new 44d03573a78 IGNITE-14914 Add IndexQuery IN criterion (#10195)
44d03573a78 is described below

commit 44d03573a78e1507d8357d332e6c0e1d5cbb954e
Author: Maksim Timonin <ti...@gmail.com>
AuthorDate: Wed Aug 17 14:25:35 2022 +0300

    IGNITE-14914 Add IndexQuery IN criterion (#10195)
---
 .../clients/JavaThinCompatibilityTest.java         |  57 ++
 .../org/apache/ignite/cache/query/IndexQuery.java  |   7 +-
 .../cache/query/IndexQueryCriteriaBuilder.java     |  16 +
 .../cache/query/InIndexQueryCriterion.java         |  54 ++
 .../cache/query/index/IndexKeyQueryCondition.java  | 350 ++++++++++++
 .../cache/query/index/IndexMultipleRangeQuery.java |  89 +++
 .../query/index/IndexQueryCriteriaClosure.java     | 196 +++++++
 .../cache/query/index/IndexQueryProcessor.java     | 489 +++-------------
 .../cache/query/index/IndexSingleRangeQuery.java   | 139 +++++
 .../index/sorted/inline/InlineIndexKeyType.java    |  11 +
 .../inline/types/BytesInlineIndexKeyType.java      |  10 +-
 .../types/ObjectByteArrayInlineIndexKeyType.java   |   5 +
 .../inline/types/StringInlineIndexKeyType.java     |  10 +-
 .../types/StringNoCompareInlineIndexKeyType.java   |   5 +
 .../query/index/sorted/keys/BooleanIndexKey.java   |   5 +
 .../query/index/sorted/keys/ByteIndexKey.java      |   5 +
 .../query/index/sorted/keys/BytesIndexKey.java     |   6 +
 .../query/index/sorted/keys/DateIndexKey.java      |   5 +
 .../query/index/sorted/keys/DecimalIndexKey.java   |   5 +
 .../query/index/sorted/keys/DoubleIndexKey.java    |   5 +
 .../query/index/sorted/keys/FloatIndexKey.java     |   5 +
 .../query/index/sorted/keys/IntegerIndexKey.java   |  15 +
 .../index/sorted/keys/JavaObjectIndexKey.java      |  10 +
 .../query/index/sorted/keys/LongIndexKey.java      |  16 +
 .../query/index/sorted/keys/NullIndexKey.java      |  15 +
 .../query/index/sorted/keys/ShortIndexKey.java     |  16 +
 .../query/index/sorted/keys/StringIndexKey.java    |  16 +
 .../query/index/sorted/keys/TimeIndexKey.java      |  15 +
 .../query/index/sorted/keys/TimestampIndexKey.java |  16 +
 .../query/index/sorted/keys/UuidIndexKey.java      |  15 +
 .../client/thin/ProtocolBitmaskFeature.java        |   5 +-
 .../internal/client/thin/TcpClientCache.java       |  15 +
 .../platform/client/ClientBitmaskFeature.java      |   5 +-
 .../client/cache/ClientCacheIndexQueryRequest.java |  53 +-
 .../processors/query/GridQueryProcessor.java       |   9 +-
 .../ignite/cache/query/IndexQueryAllTypesTest.java | 169 +++++-
 .../query/IndexQueryCacheKeyValueFieldsTest.java   |   2 +-
 .../query/IndexQueryInCriterionDescTest.java}      |  31 +-
 .../cache/query/IndexQueryInCriterionTest.java     | 628 +++++++++++++++++++++
 .../cache/query/IndexQueryInlineSizesTest.java     |  94 ++-
 .../ignite/cache/query/IndexQueryRangeTest.java    |   8 +
 .../ignite/cache/query/IndexQueryTestSuite.java    |   5 +-
 .../cache/query/ThinClientIndexQueryTest.java      | 109 +++-
 43 files changed, 2227 insertions(+), 514 deletions(-)

diff --git a/modules/compatibility/src/test/java/org/apache/ignite/compatibility/clients/JavaThinCompatibilityTest.java b/modules/compatibility/src/test/java/org/apache/ignite/compatibility/clients/JavaThinCompatibilityTest.java
index 9e4d79d3ced..cee1d214ef3 100644
--- a/modules/compatibility/src/test/java/org/apache/ignite/compatibility/clients/JavaThinCompatibilityTest.java
+++ b/modules/compatibility/src/test/java/org/apache/ignite/compatibility/clients/JavaThinCompatibilityTest.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.compatibility.clients;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -35,9 +36,12 @@ import org.apache.ignite.binary.BinaryObject;
 import org.apache.ignite.cache.CacheAtomicityMode;
 import org.apache.ignite.cache.CacheMode;
 import org.apache.ignite.cache.QueryEntity;
+import org.apache.ignite.cache.QueryIndex;
 import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
 import org.apache.ignite.cache.query.ContinuousQuery;
+import org.apache.ignite.cache.query.IndexQuery;
 import org.apache.ignite.cache.query.ScanQuery;
+import org.apache.ignite.cache.query.SqlFieldsQuery;
 import org.apache.ignite.client.ClientCache;
 import org.apache.ignite.client.ClientCacheConfiguration;
 import org.apache.ignite.client.ClientFeatureNotSupportedByServerException;
@@ -46,6 +50,7 @@ import org.apache.ignite.client.ClientTransaction;
 import org.apache.ignite.client.IgniteClient;
 import org.apache.ignite.client.Person;
 import org.apache.ignite.cluster.ClusterNode;
+import org.apache.ignite.compatibility.testframework.junits.IgniteCompatibilityNodeRunner;
 import org.apache.ignite.compute.ComputeJob;
 import org.apache.ignite.compute.ComputeJobResult;
 import org.apache.ignite.compute.ComputeTaskAdapter;
@@ -446,6 +451,9 @@ public class JavaThinCompatibilityTest extends AbstractClientCompatibilityTest {
         if (clientVer.compareTo(VER_2_14_0) >= 0)
             testDataReplicationOperations(serverVer.compareTo(VER_2_14_0) >= 0);
 
+        if (clientVer.compareTo(VER_2_14_0) >= 0)
+            new JavaThinIndexQueryCompatibilityTest().testIndexQueries(ADDR, serverVer.compareTo(VER_2_14_0) >= 0);
+
         if (clientVer.compareTo(VER_2_14_0) >= 0) {
             // This wrapper is used to avoid serialization/deserialization issues when the `testClient` is
             // tried to be deserialized on previous Ignite releases that do not contain a newly added classes.
@@ -617,4 +625,53 @@ public class JavaThinCompatibilityTest extends AbstractClientCompatibilityTest {
     /** */
     public static class CustomAffinity extends RendezvousAffinityFunction {
     }
+
+    /**
+     * This class is a workaround to avoid serialization error in {@link IgniteCompatibilityNodeRunner#readClosureFromFileAndDelete}.
+     * {@link IndexQuery} appeared since Ignite 2.12 and prior versions doesn't know this class, and it fails while serializing
+     * {@link JavaThinCompatibilityTest} class. Then it's required to move this test case into separate class that will be loaded in
+     * runtime only for the such versions that know this class.
+     */
+    public static class JavaThinIndexQueryCompatibilityTest {
+        /** */
+        public void testIndexQueries(String addr, boolean supported) {
+            X.println(">>>> Testing index queries");
+
+            try (IgniteClient client = Ignition.startClient(new ClientConfiguration().setAddresses(addr))) {
+                ClientCache<Object, Object> cache = client.getOrCreateCache(
+                    new ClientCacheConfiguration()
+                        .setName("testIndexQueries")
+                        .setQueryEntities(
+                            new QueryEntity()
+                                .setTableName("TABLE_TEST_INDEX_QUERIES")
+                                .setKeyType(Integer.class.getName())
+                                .setFields(new LinkedHashMap<>(F.asMap(
+                                    "A", Integer.class.getName(),
+                                    "B", Integer.class.getName())))
+                                .setKeyFieldName("A")
+                                .setValueType("TEST_INDEX_QUERIES")
+                                .setIndexes(Collections.singleton(new QueryIndex()
+                                    .setName("IDX")
+                                    .setFields(new LinkedHashMap<>(F.asMap("B", true)))))
+                        )
+                );
+
+                cache.query(
+                    new SqlFieldsQuery("insert into TABLE_TEST_INDEX_QUERIES(A, B) values (?, ?)")
+                        .setArgs(0, 0)
+                        .setTimeout(0, TimeUnit.MILLISECONDS))  // Required.
+                    .getAll();
+
+                IndexQuery<Integer, Object> idxQry = new IndexQuery<>("TEST_INDEX_QUERIES", "IDX");
+
+                if (supported)
+                    assertEquals(1, cache.withKeepBinary().query(idxQry).getAll().size());
+                else {
+                    assertThrowsWithCause(
+                        () -> cache.withKeepBinary().query(idxQry).getAll(),
+                        ClientFeatureNotSupportedByServerException.class);
+                }
+            }
+        }
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/query/IndexQuery.java b/modules/core/src/main/java/org/apache/ignite/cache/query/IndexQuery.java
index 2820b8449a7..0e7f2a1abc9 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/query/IndexQuery.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/query/IndexQuery.java
@@ -206,13 +206,8 @@ public final class IndexQuery<K, V> extends Query<Cache.Entry<K, V>> {
         if (F.isEmpty(criteria))
             return;
 
-        Class<?> critCls = criteria.get(0).getClass();
-
-        for (IndexQueryCriterion c: criteria) {
+        for (IndexQueryCriterion c: criteria)
             A.notNull(c, "criteria");
-            A.ensure(c.getClass() == critCls,
-                "Expect a the same criteria class for merging criteria. Exp=" + critCls + ", act=" + c.getClass());
-        }
 
         this.criteria = Collections.unmodifiableList(criteria);
     }
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/query/IndexQueryCriteriaBuilder.java b/modules/core/src/main/java/org/apache/ignite/cache/query/IndexQueryCriteriaBuilder.java
index 64c73842bf0..783adb9d67e 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/query/IndexQueryCriteriaBuilder.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/query/IndexQueryCriteriaBuilder.java
@@ -17,6 +17,8 @@
 
 package org.apache.ignite.cache.query;
 
+import java.util.Collection;
+import org.apache.ignite.internal.cache.query.InIndexQueryCriterion;
 import org.apache.ignite.internal.cache.query.RangeIndexQueryCriterion;
 import org.apache.ignite.internal.util.typedef.internal.A;
 
@@ -124,4 +126,18 @@ public class IndexQueryCriteriaBuilder {
 
         return c;
     }
+
+    /**
+     * In.
+     *
+     * @param field Index field to apply criterion.
+     * @param vals Collection of values to find.
+     * @return Criterion.
+     */
+    public static IndexQueryCriterion in(String field, Collection<?> vals) {
+        A.notNullOrEmpty(field, "field");
+        A.notEmpty(vals, "vals");
+
+        return new InIndexQueryCriterion(field, vals);
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/InIndexQueryCriterion.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/InIndexQueryCriterion.java
new file mode 100644
index 00000000000..2927446a769
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/InIndexQueryCriterion.java
@@ -0,0 +1,54 @@
+/*
+ * 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.cache.query;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import org.apache.ignite.cache.query.IndexQueryCriterion;
+
+/**
+ * Criterion for IN operator.
+ */
+public final class InIndexQueryCriterion implements IndexQueryCriterion {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Index field name. */
+    private final String field;
+
+    /** Set of values that indexed {@link #field()} value should match. */
+    private final Set<Object> vals;
+
+    /** */
+    public InIndexQueryCriterion(String field, Collection<?> vals) {
+        this.field = field;
+        this.vals = Collections.unmodifiableSet(new HashSet<>(vals));
+    }
+
+    /** */
+    public Set<Object> values() {
+        return vals;
+    }
+
+    /** {@inheritDoc} */
+    @Override public String field() {
+        return field;
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexKeyQueryCondition.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexKeyQueryCondition.java
new file mode 100644
index 00000000000..c8b2a01521b
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexKeyQueryCondition.java
@@ -0,0 +1,350 @@
+/*
+ * 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.cache.query.index;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import org.apache.ignite.IgniteCheckedException;
+import org.apache.ignite.IgniteException;
+import org.apache.ignite.cache.query.IndexQueryCriterion;
+import org.apache.ignite.internal.cache.query.InIndexQueryCriterion;
+import org.apache.ignite.internal.cache.query.RangeIndexQueryCriterion;
+import org.apache.ignite.internal.cache.query.index.sorted.IndexKeyDefinition;
+import org.apache.ignite.internal.cache.query.index.sorted.IndexKeyType;
+import org.apache.ignite.internal.cache.query.index.sorted.IndexKeyTypeSettings;
+import org.apache.ignite.internal.cache.query.index.sorted.IndexRowComparator;
+import org.apache.ignite.internal.cache.query.index.sorted.inline.InlineIndexImpl;
+import org.apache.ignite.internal.cache.query.index.sorted.keys.IndexKey;
+import org.apache.ignite.internal.cache.query.index.sorted.keys.IndexKeyFactory;
+import org.apache.ignite.internal.processors.cache.CacheObjectContext;
+import org.jetbrains.annotations.Nullable;
+
+import static org.apache.ignite.internal.cache.query.index.IndexQueryProcessor.rangeDesc;
+import static org.apache.ignite.internal.cache.query.index.SortOrder.DESC;
+
+/**
+ * IndexQuery condition for single indexed key. It accumulates user defined criteria (with Object as parameters)
+ * for the same key to single one and transforms it to apply to {@link IndexKey} parameters.
+ */
+class IndexKeyQueryCondition {
+    /** Index field name. */
+    private final String fldName;
+
+    /** Accumulated IndexKey RANGE criterion. */
+    private RangeIndexQueryCriterion range;
+
+    /**
+     * Accumulated IndexKey IN criterion values. Values are sorted to guarantee order of IndexQuery result.
+     */
+    private SortedSet<IndexKey> inVals;
+
+    /** Index. */
+    private final InlineIndexImpl idx;
+
+    /** IndexKey comparator. */
+    private IndexRowComparator keyCmp;
+
+    /**
+     * Constructor for preparing index key condition.
+     *
+     * @param fldName Index field name for index key.
+     * @param idx Index.
+     */
+    IndexKeyQueryCondition(String fldName, InlineIndexImpl idx) {
+        this.idx = idx;
+        this.fldName = fldName;
+
+        keyCmp = idx.indexDefinition().rowComparator();
+    }
+
+    /**
+     * Constructor for already prepared index key condition.
+     *
+     * @param fldName Index field name for index key.
+     * @param range Prepared range criterion for IndexKeys.
+     * @param inVals Prepared IndexKey values for IN criterion.
+     */
+    IndexKeyQueryCondition(String fldName, InlineIndexImpl idx, RangeIndexQueryCriterion range, SortedSet<IndexKey> inVals) {
+        this.range = range;
+        this.idx = idx;
+        this.fldName = fldName;
+        this.inVals = inVals;
+    }
+
+    /**
+     * Splits IN condition to multiple RANGE conditions.
+     */
+    public List<IndexKeyQueryCondition> splitInToRanges() {
+        List<IndexKeyQueryCondition> conds = new ArrayList<>(inVals.size());
+
+        for (IndexKey k: inVals) {
+            RangeIndexQueryCriterion c = new RangeIndexQueryCriterion(fldName, k, k);
+            c.lowerIncl(true);
+            c.upperIncl(true);
+
+            conds.add(new IndexKeyQueryCondition(fldName, idx, c, null));
+        }
+
+        return conds;
+    }
+
+    /**
+     * Accumulate User's criterion for index key.
+     *
+     * @param criterion User's criterion for index key.
+     */
+    void accumulate(IndexQueryCriterion criterion) throws IgniteCheckedException {
+        if (criterion instanceof InIndexQueryCriterion)
+            addInCriterion((InIndexQueryCriterion)criterion);
+        else if (criterion instanceof RangeIndexQueryCriterion)
+            addRangeCriterion((RangeIndexQueryCriterion)criterion);
+        else
+            throw new IgniteCheckedException("Unexpected IndexQueryCriterion class: " + criterion);
+    }
+
+    /**
+     * @return Prepared IndexKey range.
+     */
+    public RangeIndexQueryCriterion range() {
+        return range;
+    }
+
+    /**
+     * @return Prepared IndexKey values for IN operation.
+     */
+    public SortedSet<IndexKey> inVals() {
+        return inVals == null ? null : Collections.unmodifiableSortedSet(inVals);
+    }
+
+    /**
+     * @param criterion User IN criterion.
+     */
+    private void addInCriterion(InIndexQueryCriterion criterion) throws IgniteCheckedException {
+        if (inVals != null)
+            throw new IgniteCheckedException("Multiple IN criteria for same field arent't supported.");
+
+        inVals = new TreeSet<>((idxKeyLeft, idxKeyRight) -> {
+            try {
+                return compare(idxKeyLeft, idxKeyRight);
+            }
+            catch (IgniteCheckedException e) {
+                // Never reach this.
+                throw new IgniteException(e);
+            }
+        });
+
+        for (Object v: criterion.values())
+            inVals.add(key(v, v == null));
+
+        narrowRangeWithIn();
+    }
+
+    /**
+     * Sets or merges (if multiple criteria for the same field) RANGE criterion.
+     *
+     * @param criterion User RANGE criterion.
+     */
+    private void addRangeCriterion(RangeIndexQueryCriterion criterion) throws IgniteCheckedException {
+        boolean desc = desc();
+
+        if (desc)
+            criterion = criterion.swap();
+
+        IndexKey l = key(criterion.lower(), criterion.lowerNull());
+        IndexKey u = key(criterion.upper(), criterion.upperNull());
+
+        if (l != null && u != null && (desc ? -1 : 1 ) * keyCmp.compareKey(l, u) > 0) {
+            throw new IgniteCheckedException("Illegal criterion: lower boundary is greater than the upper boundary: "
+                + rangeDesc(criterion, fldName, null, null));
+        }
+
+        RangeIndexQueryCriterion crit = new RangeIndexQueryCriterion(fldName, l, u);
+        crit.lowerIncl(criterion.lowerIncl());
+        crit.upperIncl(criterion.upperIncl());
+        crit.lowerNull(criterion.lowerNull());
+        crit.upperNull(criterion.upperNull());
+
+        range = range == null ? crit : mergeRanges(crit);
+
+        checkInAndRangeCriteria();
+    }
+
+    /**
+     * Merges existing {@link #range} criterion with another one for the same indexed field.
+     */
+    private RangeIndexQueryCriterion mergeRanges(RangeIndexQueryCriterion idxKeyCrit) throws IgniteCheckedException {
+        IndexKey prevLower = (IndexKey)range.lower();
+        IndexKey prevUpper = (IndexKey)range.upper();
+
+        IndexKey l = (IndexKey)idxKeyCrit.lower();
+        IndexKey u = (IndexKey)idxKeyCrit.upper();
+
+        // Validate merged criteria.
+        if (!checkBoundaries(l, prevUpper, idxKeyCrit.lowerIncl(), range.upperIncl()) ||
+            !checkBoundaries(prevLower, u, range.lowerIncl(), idxKeyCrit.upperIncl())) {
+
+            String prevDesc = rangeDesc(range, range.field(),
+                prevLower == null ? null : prevLower.key(),
+                prevUpper == null ? null : prevUpper.key());
+
+            throw new IgniteCheckedException("Failed to merge criterion "
+                + rangeDesc(idxKeyCrit, idxKeyCrit.field(), null, null)
+                + " with previous criteria range " + prevDesc);
+        }
+
+        int lowCmp = 0;
+        boolean lowIncl = idxKeyCrit.lowerIncl();
+        boolean lowNull = idxKeyCrit.lowerNull();
+
+        // Use previous lower boudary, as it's greater than the current.
+        if (l == null || (prevLower != null && (lowCmp = compare(prevLower, l)) >= 0)) {
+            l = prevLower;
+            lowIncl = lowCmp != 0 ? range.lowerIncl() : range.lowerIncl() ? lowIncl : range.lowerIncl();
+            lowNull = range.lowerNull();
+        }
+
+        int upCmp = 0;
+        boolean upIncl = idxKeyCrit.upperIncl();
+        boolean upNull = idxKeyCrit.upperNull();
+
+        // Use previous upper boudary, as it's less than the current.
+        if (u == null || (prevUpper != null && (upCmp = compare(prevUpper, u)) <= 0)) {
+            u = prevUpper;
+            upIncl = upCmp != 0 ? range.upperIncl() : range.upperIncl() ? upIncl : range.upperIncl();
+            upNull = range.upperNull();
+        }
+
+        RangeIndexQueryCriterion crit = new RangeIndexQueryCriterion(idxKeyCrit.field(), l, u);
+        crit.lowerIncl(lowIncl);
+        crit.upperIncl(upIncl);
+        crit.lowerNull(lowNull);
+        crit.upperNull(upNull);
+
+        return crit;
+    }
+
+    /**
+     * @return {@code} true if boudaries are intersected, otherwise {@code false}.
+     */
+    private boolean checkBoundaries(
+        IndexKey left,
+        IndexKey right,
+        boolean leftIncl,
+        boolean rightIncl
+    ) throws IgniteCheckedException {
+        boolean boundaryCheck = left != null && right != null;
+
+        if (boundaryCheck) {
+            int cmp = compare(left, right);
+
+            return cmp < 0 || (cmp == 0 && leftIncl && rightIncl);
+        }
+
+        return true;
+    }
+
+    /**
+     * Checks that specified {@link #range} and {@link #inVals} criterion are intersected, otherwise failes. Unbounded
+     * values are removed from {@link #inVals}.
+     */
+    private void checkInAndRangeCriteria() throws IgniteCheckedException {
+        boolean changed = false;
+
+        if (inVals != null && range != null) {
+            for (Iterator<IndexKey> it = inVals.iterator(); it.hasNext(); ) {
+                IndexKey k = it.next();
+
+                if (range.lower() != null) {
+                    int cmp = compare((IndexKey)range.lower(), k);
+
+                    if (cmp > 0 || (cmp == 0 && !range.lowerIncl())) {
+                        it.remove();
+
+                        changed = true;
+                    }
+                }
+
+                if (range.upper() != null) {
+                    int cmp = compare((IndexKey)range.upper(), k);
+
+                    if (cmp < 0 || (cmp == 0 && !range.upperIncl())) {
+                        it.remove();
+
+                        changed = true;
+                    }
+                }
+            }
+
+            if (inVals != null && inVals.isEmpty()) {
+                throw new IgniteCheckedException(
+                    "Failed to merge IN and RANGE criteria. No IN values match range criterion " + range);
+            }
+        }
+
+        if (changed)
+            narrowRangeWithIn();
+    }
+
+    /**
+     * In case IN criterion specified it's possible to narrow existing index ranges to avoid wasteful checking.
+     */
+    private void narrowRangeWithIn() throws IgniteCheckedException {
+        // Define narrow range to avoid misreading wide ranges.
+        RangeIndexQueryCriterion r = new RangeIndexQueryCriterion(fldName, inVals.first(), inVals.last());
+        r.lowerIncl(true);
+        r.upperIncl(true);
+
+        range = range == null ? r : mergeRanges(r);
+
+        // Re-check after merging criteria.
+        checkInAndRangeCriteria();
+    }
+
+    /**
+     * @param val Value to wrap to IndexKey.
+     * @param isNull {@code true} if user explicitly set {@code null} with a query argument.
+     */
+    private IndexKey key(@Nullable Object val, boolean isNull) {
+        IndexKeyTypeSettings keyTypeSettings = idx.segment(0).rowHandler().indexKeyTypeSettings();
+        CacheObjectContext coctx = idx.segment(0).cacheGroupContext().cacheObjectContext();
+
+        IndexKey key = null;
+        IndexKeyType keyType = val == null ? IndexKeyType.NULL : IndexKeyType.forClass(val.getClass());
+
+        if (val != null || isNull)
+            key = IndexKeyFactory.wrap(val, keyType, coctx, keyTypeSettings);
+
+        return key;
+    }
+
+    /** */
+    private int compare(IndexKey left, IndexKey right) throws IgniteCheckedException {
+        return (desc() ? -1 : 1) * keyCmp.compareKey(left, right);
+    }
+
+    /** */
+    boolean desc() {
+        IndexKeyDefinition keyDef = idx.indexDefinition().indexKeyDefinitions().get(fldName);
+
+        return keyDef.order().sortOrder() == DESC;
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexMultipleRangeQuery.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexMultipleRangeQuery.java
new file mode 100644
index 00000000000..8638cfaf8cd
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexMultipleRangeQuery.java
@@ -0,0 +1,89 @@
+/*
+ * 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.cache.query.index;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Represents ordered list of independent index range queries.
+ */
+class IndexMultipleRangeQuery {
+    /** Ordered list of index ranges queries. */
+    private final List<IndexSingleRangeQuery> queries = new ArrayList<>();
+
+    /** */
+    private final int critSize;
+
+    /** */
+    private final int idxRowSize;
+
+    /** */
+    IndexMultipleRangeQuery(int idxRowSize, int critSize) {
+        this.critSize = critSize;
+        this.idxRowSize = idxRowSize;
+    }
+
+    /** */
+    public List<IndexSingleRangeQuery> queries() {
+        return queries;
+    }
+
+    /** */
+    int critSize() {
+        return critSize;
+    }
+
+    /**
+     * Adds condition. In case of multiple queries it adds to every query.
+     */
+    void addIndexKeyCondition(int i, IndexKeyQueryCondition cond) {
+        if (i == 0)
+            addFirstIndexKeyCondition(cond);
+        else {
+            for (IndexSingleRangeQuery qry: queries)
+                qry.addCondition(cond, i);
+        }
+    }
+
+    /**
+     * Add first condition. If it contains IN clause then split query to multiple index ranges joint with OR:
+     *
+     * IN(A, B) and GT(C) = (EQ(A) and GT(C)) or (EQ(B) and GT(C)).
+     *
+     * It ignores RANGE criterion if IN is specified. Intersection of them was already checked on prepare query phase.
+     */
+    private void addFirstIndexKeyCondition(IndexKeyQueryCondition keyCond) {
+        if (keyCond.inVals() != null) {
+            for (IndexKeyQueryCondition cond: keyCond.splitInToRanges()) {
+                IndexSingleRangeQuery q = new IndexSingleRangeQuery(idxRowSize, critSize);
+
+                q.addCondition(cond, 0);
+
+                queries.add(q);
+            }
+        }
+        else {
+            IndexSingleRangeQuery qry = new IndexSingleRangeQuery(idxRowSize, critSize);
+
+            qry.addCondition(keyCond, 0);
+
+            queries.add(qry);
+        }
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexQueryCriteriaClosure.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexQueryCriteriaClosure.java
new file mode 100644
index 00000000000..3bd5a7ac0e4
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexQueryCriteriaClosure.java
@@ -0,0 +1,196 @@
+/*
+ * 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.cache.query.index;
+
+import java.util.List;
+import java.util.Set;
+import org.apache.ignite.IgniteCheckedException;
+import org.apache.ignite.internal.cache.query.RangeIndexQueryCriterion;
+import org.apache.ignite.internal.cache.query.index.sorted.IndexRow;
+import org.apache.ignite.internal.cache.query.index.sorted.IndexRowComparator;
+import org.apache.ignite.internal.cache.query.index.sorted.inline.InlineIndexKeyType;
+import org.apache.ignite.internal.cache.query.index.sorted.inline.InlineIndexTree;
+import org.apache.ignite.internal.cache.query.index.sorted.keys.IndexKey;
+import org.apache.ignite.internal.processors.cache.persistence.tree.BPlusTree;
+import org.apache.ignite.internal.processors.cache.persistence.tree.io.BPlusIO;
+import org.jetbrains.annotations.Nullable;
+
+import static org.apache.ignite.internal.cache.query.index.sorted.IndexKeyType.JAVA_OBJECT;
+import static org.apache.ignite.internal.cache.query.index.sorted.inline.types.NullableInlineIndexKeyType.CANT_BE_COMPARE;
+import static org.apache.ignite.internal.cache.query.index.sorted.inline.types.NullableInlineIndexKeyType.COMPARE_UNSUPPORTED;
+
+/**
+ * Checks index rows for matching to specified index criteria.
+ */
+class IndexQueryCriteriaClosure implements BPlusTree.TreeRowClosure<IndexRow, IndexRow> {
+    /** */
+    private final IndexSingleRangeQuery qry;
+
+    /** */
+    private final IndexRowComparator rowCmp;
+
+    /** */
+    IndexQueryCriteriaClosure(IndexSingleRangeQuery qry, IndexRowComparator rowCmp) {
+        this.qry = qry;
+        this.rowCmp = rowCmp;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean apply(
+        BPlusTree<IndexRow, IndexRow> tree,
+        BPlusIO<IndexRow> io,
+        long pageAddr,
+        int idx
+    ) throws IgniteCheckedException {
+        return !rowIsOutOfRange((InlineIndexTree)tree, io, pageAddr, idx, qry.lower(), qry.upper());
+    }
+
+    /**
+     * Checks that {@code row} belongs to the range specified with {@code low} and {@code high}.
+     *
+     * @return {@code true} if the row doesn't belong the range, otherwise {@code false}.
+     */
+    private boolean rowIsOutOfRange(
+        InlineIndexTree tree,
+        BPlusIO<IndexRow> io,
+        long pageAddr,
+        int idx,
+        IndexRow low,
+        IndexRow high
+    ) throws IgniteCheckedException {
+        int off = io.offset(idx);
+
+        int fieldOff = 0;
+
+        InlineIndexRow currRow = new InlineIndexRow(tree, io, pageAddr, idx);
+
+        List<InlineIndexKeyType> keyTypes = tree.rowHandler().inlineIndexKeyTypes();
+
+        for (int keyIdx = 0; keyIdx < tree.rowHandler().indexKeyDefinitions().size(); keyIdx++) {
+            IndexKeyQueryCondition keyCond = qry.keyCondition(keyIdx);
+
+            if (keyCond == null)
+                return false;
+
+            RangeIndexQueryCriterion c = keyCond.range();
+            Set<IndexKey> inVals = keyCond.inVals();
+
+            InlineIndexKeyType keyType = keyIdx < keyTypes.size() ? keyTypes.get(keyIdx) : null;
+
+            boolean descOrder = keyCond.desc();
+
+            int maxSize = tree.inlineSize() - fieldOff;
+
+            if (inVals != null) {
+                IndexKey key = null;
+
+                if (keyType != null && keyType.type() != JAVA_OBJECT && keyType.inlinedFullValue(pageAddr, off + fieldOff))
+                    key = keyType.get(pageAddr, off + fieldOff, maxSize);
+
+                if (key == null) {
+                    IndexRow row = io.getLookupRow(tree, pageAddr, idx);
+
+                    key = row.key(keyIdx);
+                }
+
+                // Range boundaries were already checked for all IN values.
+                return !inVals.contains(key);
+            }
+
+            if (low != null && low.key(keyIdx) != null) {
+                int cmp = currRow.compare(rowCmp, low, keyIdx, off + fieldOff, maxSize, keyType);
+
+                if (cmp == 0) {
+                    if (!c.lowerIncl())
+                        return true;  // Exclude if field equals boundary field and criteria is excluding.
+                }
+                else if ((cmp < 0) ^ descOrder)
+                    return true;  // Out of bound. Either below 'low' margin or column with desc order.
+            }
+
+            if (high != null && high.key(keyIdx) != null) {
+                int cmp = currRow.compare(rowCmp, high, keyIdx, off + fieldOff, maxSize, keyType);
+
+                if (cmp == 0) {
+                    if (!c.upperIncl())
+                        return true;  // Exclude if field equals boundary field and criteria is excluding.
+                }
+                else if ((cmp > 0) ^ descOrder)
+                    return true;  // Out of bound. Either above 'high' margin or column with desc order.
+            }
+
+            if (keyType != null)
+                fieldOff += keyType.inlineSize(pageAddr, off + fieldOff);
+        }
+
+        return false;
+    }
+
+    /**
+     * Wrapper class over index row. It is suitable for comparison. It tries to check inlined keys first, and fetches a
+     * cache entry only if the inlined information is not full enough for comparison.
+     */
+    private static class InlineIndexRow {
+        /** */
+        private final long pageAddr;
+
+        /** */
+        private final int idx;
+
+        /** */
+        private final InlineIndexTree tree;
+
+        /** */
+        private final BPlusIO<IndexRow> io;
+
+        /** Set it for accessing keys from underlying cache entry. */
+        private IndexRow currRow;
+
+        /** */
+        private InlineIndexRow(InlineIndexTree tree, BPlusIO<IndexRow> io, long addr, int idx) {
+            pageAddr = addr;
+            this.idx = idx;
+            this.tree = tree;
+            this.io = io;
+        }
+
+        /** Compare using inline. {@code keyType} is {@code null} for non-inlined keys. */
+        private int compare(
+            IndexRowComparator rowCmp,
+            IndexRow o,
+            int keyIdx,
+            int off,
+            int maxSize,
+            @Nullable InlineIndexKeyType keyType
+        ) throws IgniteCheckedException {
+            if (currRow == null) {
+                int cmp = COMPARE_UNSUPPORTED;
+
+                if (keyType != null)
+                    cmp = rowCmp.compareKey(pageAddr, off, maxSize, o.key(keyIdx), keyType);
+
+                if (cmp == COMPARE_UNSUPPORTED || cmp == CANT_BE_COMPARE)
+                    currRow = tree.getRow(io, pageAddr, idx);
+                else
+                    return cmp;
+            }
+
+            return rowCmp.compareRow(currRow, o, keyIdx);
+        }
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexQueryProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexQueryProcessor.java
index 6128171bf45..4048971a38a 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexQueryProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexQueryProcessor.java
@@ -20,7 +20,6 @@ package org.apache.ignite.internal.cache.query.index;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
@@ -31,26 +30,17 @@ import org.apache.ignite.cache.query.IndexQuery;
 import org.apache.ignite.cache.query.IndexQueryCriterion;
 import org.apache.ignite.internal.cache.query.RangeIndexQueryCriterion;
 import org.apache.ignite.internal.cache.query.index.sorted.IndexKeyDefinition;
-import org.apache.ignite.internal.cache.query.index.sorted.IndexKeyType;
-import org.apache.ignite.internal.cache.query.index.sorted.IndexKeyTypeSettings;
 import org.apache.ignite.internal.cache.query.index.sorted.IndexRow;
 import org.apache.ignite.internal.cache.query.index.sorted.IndexRowComparator;
-import org.apache.ignite.internal.cache.query.index.sorted.IndexSearchRowImpl;
-import org.apache.ignite.internal.cache.query.index.sorted.InlineIndexRowHandler;
 import org.apache.ignite.internal.cache.query.index.sorted.SortedIndexDefinition;
 import org.apache.ignite.internal.cache.query.index.sorted.SortedSegmentedIndex;
 import org.apache.ignite.internal.cache.query.index.sorted.inline.IndexQueryContext;
 import org.apache.ignite.internal.cache.query.index.sorted.inline.InlineIndexImpl;
-import org.apache.ignite.internal.cache.query.index.sorted.inline.InlineIndexKeyType;
-import org.apache.ignite.internal.cache.query.index.sorted.inline.InlineIndexTree;
-import org.apache.ignite.internal.cache.query.index.sorted.keys.IndexKey;
-import org.apache.ignite.internal.cache.query.index.sorted.keys.IndexKeyFactory;
 import org.apache.ignite.internal.processors.cache.CacheObject;
 import org.apache.ignite.internal.processors.cache.CacheObjectContext;
 import org.apache.ignite.internal.processors.cache.CacheObjectUtils;
 import org.apache.ignite.internal.processors.cache.GridCacheContext;
 import org.apache.ignite.internal.processors.cache.persistence.tree.BPlusTree;
-import org.apache.ignite.internal.processors.cache.persistence.tree.io.BPlusIO;
 import org.apache.ignite.internal.processors.cache.query.IndexQueryDesc;
 import org.apache.ignite.internal.processors.query.QueryUtils;
 import org.apache.ignite.internal.util.GridCloseableIteratorAdapter;
@@ -62,10 +52,6 @@ import org.apache.ignite.lang.IgniteBiTuple;
 import org.apache.ignite.spi.indexing.IndexingQueryFilter;
 import org.jetbrains.annotations.Nullable;
 
-import static org.apache.ignite.internal.cache.query.index.SortOrder.DESC;
-import static org.apache.ignite.internal.cache.query.index.sorted.inline.types.NullableInlineIndexKeyType.CANT_BE_COMPARE;
-import static org.apache.ignite.internal.cache.query.index.sorted.inline.types.NullableInlineIndexKeyType.COMPARE_UNSUPPORTED;
-
 /**
  * Processor of {@link IndexQuery}.
  */
@@ -90,15 +76,15 @@ public class IndexQueryProcessor {
         IndexingQueryFilter cacheFilter,
         boolean keepBinary
     ) throws IgniteCheckedException {
-        SortedSegmentedIndex idx = findSortedIndex(cctx, idxQryDesc);
+        InlineIndexImpl idx = (InlineIndexImpl)findSortedIndex(cctx, idxQryDesc);
 
-        IndexRangeQuery qry = prepareQuery(idx, idxQryDesc);
+        IndexMultipleRangeQuery qry = prepareQuery(idx, idxQryDesc);
 
-        GridCursor<IndexRow> cursor = querySortedIndex(idx, cacheFilter, qry);
+        GridCursor<IndexRow> cursor = queryMultipleRanges(idx, cacheFilter, qry);
 
         SortedIndexDefinition def = (SortedIndexDefinition)idxProc.indexDefinition(idx.id());
 
-        IndexQueryResultMeta meta = new IndexQueryResultMeta(def, qry.criteria.length);
+        IndexQueryResultMeta meta = new IndexQueryResultMeta(def, qry.critSize());
 
         // Map IndexRow to Cache Key-Value pair.
         return new IndexQueryResult<>(meta, new GridCloseableIteratorAdapter<IgniteBiTuple<K, V>>() {
@@ -161,7 +147,7 @@ public class IndexQueryProcessor {
         final String tableName = cctx.kernalContext().query().tableName(cctx.name(), idxQryDesc.valType());
 
         if (tableName == null)
-            throw failIndexQuery("No table found for type: " + idxQryDesc.valType(), null, idxQryDesc);
+            throw new IgniteCheckedException("No table found for type: " + idxQryDesc.valType());
 
         // Collect both fields (original and normalized).
         Map<String, String> critFlds;
@@ -183,40 +169,36 @@ public class IndexQueryProcessor {
             critFlds = Collections.emptyMap();
 
         if (idxQryDesc.idxName() == null && !critFlds.isEmpty())
-            return indexByCriteria(cctx, critFlds, tableName, idxQryDesc);
+            return indexByCriteria(cctx, critFlds, tableName);
 
         // If index name isn't specified and criteria aren't set then use the PK index.
         String name = idxQryDesc.idxName() == null ? QueryUtils.PRIMARY_KEY_INDEX : idxQryDesc.idxName();
 
         IndexName idxName = new IndexName(cctx.name(), cctx.kernalContext().query().schemaName(cctx), tableName, name);
 
-        return indexByName(idxName, idxQryDesc, critFlds);
+        return indexByName(idxName, critFlds);
     }
 
     /**
      * @return Sorted index found by name.
      * @throws IgniteCheckedException If index not found or specified index doesn't match query criteria.
      */
-    private SortedSegmentedIndex indexByName(
-        IndexName idxName,
-        IndexQueryDesc idxQryDesc,
-        final Map<String, String> criteriaFlds
-    ) throws IgniteCheckedException {
-        SortedSegmentedIndex idx = assertSortedIndex(idxProc.index(idxName), idxQryDesc);
+    private SortedSegmentedIndex indexByName(IndexName idxName, final Map<String, String> criteriaFlds) throws IgniteCheckedException {
+        SortedSegmentedIndex idx = assertSortedIndex(idxProc.index(idxName));
 
         if (idx == null && !QueryUtils.PRIMARY_KEY_INDEX.equals(idxName.idxName())) {
             String normIdxName = QueryUtils.normalizeObjectName(idxName.idxName(), false);
 
             idxName = new IndexName(idxName.cacheName(), idxName.schemaName(), idxName.tableName(), normIdxName);
 
-            idx = assertSortedIndex(idxProc.index(idxName), idxQryDesc);
+            idx = assertSortedIndex(idxProc.index(idxName));
         }
 
         if (idx == null)
-            throw failIndexQuery("No index found for name: " + idxName.idxName(), null, idxQryDesc);
+            throw new IgniteCheckedException("No index found for name: " + idxName.idxName());
 
         if (!checkIndex(idx, idxName.tableName(), criteriaFlds))
-            throw failIndexQuery("Index doesn't match criteria", null, idxQryDesc);
+            throw new IgniteCheckedException("Index doesn't match criteria. Index " + idxName.idxName());
 
         return idx;
     }
@@ -228,28 +210,27 @@ public class IndexQueryProcessor {
     private SortedSegmentedIndex indexByCriteria(
         GridCacheContext<?, ?> cctx,
         final Map<String, String> criteriaFlds,
-        String tableName,
-        IndexQueryDesc idxQryDesc
+        String tableName
     ) throws IgniteCheckedException {
         Collection<Index> idxs = idxProc.indexes(cctx.name());
 
         for (Index idx: idxs) {
-            SortedSegmentedIndex sortedIdx = assertSortedIndex(idx, idxQryDesc);
+            SortedSegmentedIndex sortedIdx = assertSortedIndex(idx);
 
             if (checkIndex(sortedIdx, tableName, criteriaFlds))
                 return sortedIdx;
         }
 
-        throw failIndexQuery("No index found for criteria", null, idxQryDesc);
+        throw new IgniteCheckedException("No index found for criteria.");
     }
 
     /** Assert if specified index is not an instance of {@link SortedSegmentedIndex}. */
-    private SortedSegmentedIndex assertSortedIndex(Index idx, IndexQueryDesc idxQryDesc) throws IgniteCheckedException {
+    private SortedSegmentedIndex assertSortedIndex(Index idx) throws IgniteCheckedException {
         if (idx == null)
             return null;
 
         if (!(idx instanceof SortedSegmentedIndex))
-            throw failIndexQuery("IndexQuery is not supported for index: " + idx.name(), null, idxQryDesc);
+            throw new IgniteCheckedException("IndexQuery is not supported for index: " + idx.name());
 
         return (SortedSegmentedIndex)idx;
     }
@@ -286,214 +267,120 @@ public class IndexQueryProcessor {
         return false;
     }
 
-    /** */
-    private IgniteCheckedException failIndexQuery(String msg, IndexDefinition idxDef, IndexQueryDesc desc) {
-        String exMsg = "Failed to parse IndexQuery. " + msg + ".";
-
-        if (idxDef != null)
-            exMsg += " Index=" + idxDef;
-
-        return new IgniteCheckedException(exMsg + " Query=" + desc);
-    }
-
     /** Merges multiple criteria for the same field into single criterion. */
-    private Map<String, RangeIndexQueryCriterion> mergeIndexQueryCriteria(
-        InlineIndexImpl idx,
-        SortedIndexDefinition idxDef,
-        IndexQueryDesc idxQryDesc
-    ) throws IgniteCheckedException {
-        Map<String, RangeIndexQueryCriterion> mergedCriteria = new HashMap<>();
-
-        Map<String, IndexKeyDefinition> idxFlds = idxDef.indexKeyDefinitions();
-        IndexKeyTypeSettings keyTypeSettings = idx.segment(0).rowHandler().indexKeyTypeSettings();
-        CacheObjectContext coctx = idx.segment(0).cacheGroupContext().cacheObjectContext();
+    private IndexMultipleRangeQuery mergeIndexQueryCriteria(InlineIndexImpl idx, IndexQueryDesc idxQryDesc) throws IgniteCheckedException {
+        Map<String, IndexKeyQueryCondition> mergedCriteria = new HashMap<>();
 
-        IndexRowComparator keyCmp = idxDef.rowComparator();
+        SortedIndexDefinition idxDef = idx.indexDefinition();
 
-        for (IndexQueryCriterion c: idxQryDesc.criteria()) {
-            RangeIndexQueryCriterion crit = (RangeIndexQueryCriterion)c;
+        Map<String, IndexKeyDefinition> idxFlds = idxDef.indexKeyDefinitions();
 
+        // Merge.
+        for (IndexQueryCriterion crit: idxQryDesc.criteria()) {
             String fldName = idxFlds.containsKey(crit.field()) ? crit.field()
                 : QueryUtils.normalizeObjectName(crit.field(), false);
 
             IndexKeyDefinition keyDef = idxFlds.get(fldName);
 
             if (keyDef == null)
-                throw failIndexQuery("Index doesn't match criteria", idxDef, idxQryDesc);
-
-            IndexKey l = key(crit.lower(), crit.lowerNull(), keyDef, keyTypeSettings, coctx);
-            IndexKey u = key(crit.upper(), crit.upperNull(), keyDef, keyTypeSettings, coctx);
-
-            if (l != null && u != null && keyCmp.compareKey(l, u) > 0) {
-                throw failIndexQuery("Illegal criterion: lower boundary is greater than the upper boundary: " +
-                    rangeDesc(crit, fldName, null, null), idxDef, idxQryDesc);
-            }
-
-            boolean lowIncl = crit.lowerIncl();
-            boolean upIncl = crit.upperIncl();
+                throw new IgniteCheckedException("Index doesn't match criteria. Index " + idxDef + ", criterion field=" + fldName);
 
-            boolean lowNull = crit.lowerNull();
-            boolean upNull = crit.upperNull();
+            mergedCriteria.putIfAbsent(fldName, new IndexKeyQueryCondition(fldName, idx));
 
-            if (mergedCriteria.containsKey(fldName)) {
-                RangeIndexQueryCriterion prev = mergedCriteria.get(fldName);
+            IndexKeyQueryCondition idxKeyCond = mergedCriteria.get(fldName);
 
-                IndexKey prevLower = (IndexKey)prev.lower();
-                IndexKey prevUpper = (IndexKey)prev.upper();
-
-                // Validate merged criteria.
-                if (!checkBoundaries(l, prevUpper, crit.lowerIncl(), prev.upperIncl(), keyCmp) ||
-                    !checkBoundaries(prevLower, u, prev.lowerIncl(), crit.upperIncl(), keyCmp)) {
-
-                    String prevDesc = rangeDesc(prev, null,
-                        prevLower == null ? null : prevLower.key(),
-                        prevUpper == null ? null : prevUpper.key());
-
-                    throw failIndexQuery("Failed to merge criterion " + rangeDesc(crit, fldName, null, null) +
-                        " with previous criteria range " + prevDesc, idxDef, idxQryDesc);
-                }
-
-                int lowCmp = 0;
+            idxKeyCond.accumulate(crit);
+        }
 
-                // Use previous lower boudary, as it's greater than the current.
-                if (l == null || (prevLower != null && (lowCmp = keyCmp.compareKey(prevLower, l)) >= 0)) {
-                    l = prevLower;
-                    lowIncl = lowCmp != 0 ? prev.lowerIncl() : prev.lowerIncl() ? lowIncl : prev.lowerIncl();
-                    lowNull = prev.lowerNull();
-                }
+        // Allign with index and check that users criteria matches a prefix subset of index fields.
+        int i = 0;
 
-                int upCmp = 0;
+        IndexMultipleRangeQuery multipleQry = new IndexMultipleRangeQuery(idxFlds.size(), mergedCriteria.size());
 
-                // Use previous upper boudary, as it's less than the current.
-                if (u == null || (prevUpper != null && (upCmp = keyCmp.compareKey(prevUpper, u)) <= 0)) {
-                    u = prevUpper;
-                    upIncl = upCmp != 0 ? prev.upperIncl() : prev.upperIncl() ? upIncl : prev.upperIncl();
-                    upNull = prev.upperNull();
-                }
-            }
+        for (Map.Entry<String, IndexKeyDefinition> keyDef: idxFlds.entrySet()) {
+            IndexKeyQueryCondition keyCond = mergedCriteria.remove(keyDef.getKey());
 
-            RangeIndexQueryCriterion idxKeyCrit = new RangeIndexQueryCriterion(fldName, l, u);
-            idxKeyCrit.lowerIncl(lowIncl);
-            idxKeyCrit.upperIncl(upIncl);
-            idxKeyCrit.lowerNull(lowNull);
-            idxKeyCrit.upperNull(upNull);
+            if (keyCond == null)
+                break;
 
-            mergedCriteria.put(fldName, idxKeyCrit);
+            multipleQry.addIndexKeyCondition(i++, keyCond);
         }
 
-        return mergedCriteria;
+        return multipleQry;
     }
 
     /**
-     * @return {@code} true if boudaries are intersected, otherwise {@code false}.
+     * Prepare index query.
+     *
+     * @return Prepared query for index range.
      */
-    private boolean checkBoundaries(
-        IndexKey left,
-        IndexKey right,
-        boolean leftIncl,
-        boolean rightIncl,
-        IndexRowComparator keyCmp
-    ) throws IgniteCheckedException {
-        boolean boundaryCheck = left != null && right != null;
+    private IndexMultipleRangeQuery prepareQuery(InlineIndexImpl idx, IndexQueryDesc idxQryDesc) throws IgniteCheckedException {
+        if (F.isEmpty(idxQryDesc.criteria())) {
+            IndexMultipleRangeQuery multQry = new IndexMultipleRangeQuery(
+                idx.indexDefinition().indexKeyDefinitions().size(), 1);
 
-        if (boundaryCheck) {
-            int cmp = keyCmp.compareKey(left, right);
+            multQry.addIndexKeyCondition(0, new IndexKeyQueryCondition(QueryUtils.KEY_FIELD_NAME, idx));
 
-            return cmp < 0 || (cmp == 0 && leftIncl && rightIncl);
+            return multQry;
         }
 
-        return true;
+        return mergeIndexQueryCriteria(idx, idxQryDesc);
     }
 
-    /** Checks that specified index matches index query criteria. */
-    private IndexRangeQuery alignCriteriaWithIndex(
+    /**
+     * Queries multiple ranges.
+     *
+     * @return Cursor over IndexRows that match user's criteria.
+     */
+    private GridCursor<IndexRow> queryMultipleRanges(
         InlineIndexImpl idx,
-        Map<String, RangeIndexQueryCriterion> criteria,
-        IndexDefinition idxDef
-    ) {
-        // Size of bounds array has to be equal to count of indexed fields.
-        IndexKey[] lowerBounds = new IndexKey[idxDef.indexKeyDefinitions().size()];
-        IndexKey[] upperBounds = new IndexKey[idxDef.indexKeyDefinitions().size()];
-
-        boolean lowerAllNulls = true;
-        boolean upperAllNulls = true;
-
-        IndexRangeQuery qry = new IndexRangeQuery(criteria.size());
-
-        // Checks that users criteria matches a prefix subset of index fields.
-        int i = 0;
-
-        for (Map.Entry<String, IndexKeyDefinition> keyDef: idxDef.indexKeyDefinitions().entrySet()) {
-            RangeIndexQueryCriterion criterion = criteria.remove(keyDef.getKey());
-
-            if (keyDef.getValue().order().sortOrder() == DESC)
-                criterion = criterion.swap();
-
-            qry.criteria[i] = criterion;
-
-            IndexKey l = (IndexKey)criterion.lower();
-            IndexKey u = (IndexKey)criterion.upper();
-
-            if (l != null)
-                lowerAllNulls = false;
-
-            if (u != null)
-                upperAllNulls = false;
-
-            lowerBounds[i] = l;
-            upperBounds[i++] = u;
-
-            if (criteria.isEmpty())
-                break;
-        }
+        IndexingQueryFilter cacheFilter,
+        IndexMultipleRangeQuery qry
+    ) throws IgniteCheckedException {
+        List<IndexSingleRangeQuery> queries = qry.queries();
 
-        InlineIndexRowHandler hnd = idx.segment(0).rowHandler();
+        if (queries.size() == 1)
+            return querySortedIndex(idx, cacheFilter, queries.get(0));
 
-        qry.lower = lowerAllNulls ? null : new IndexSearchRowImpl(lowerBounds, hnd);
-        qry.upper = upperAllNulls ? null : new IndexSearchRowImpl(upperBounds, hnd);
+        return new GridCursor<IndexRow>() {
+            private GridCursor<IndexRow> currCursor;
 
-        return qry;
-    }
+            private int qryNum;
 
-    /**
-     * Prepare index query.
-     *
-     * @return Prepared query for index range.
-     */
-    private IndexRangeQuery prepareQuery(SortedSegmentedIndex idx, IndexQueryDesc idxQryDesc) throws IgniteCheckedException {
-        SortedIndexDefinition idxDef = (SortedIndexDefinition)idxProc.indexDefinition(idx.id());
+            /** {@inheritDoc} */
+            @Override public boolean next() throws IgniteCheckedException {
+                while (currCursor == null || !currCursor.next()) {
+                    if (qryNum == queries.size())
+                        return false;
 
-        // For PK indexes will serialize _KEY column.
-        if (F.isEmpty(idxQryDesc.criteria()))
-            return new IndexRangeQuery(1);
+                    IndexSingleRangeQuery q = queries.get(qryNum++);
 
-        InlineIndexImpl sortedIdx = (InlineIndexImpl)idx;
+                    currCursor = querySortedIndex(idx, cacheFilter, q);
+                }
 
-        Map<String, RangeIndexQueryCriterion> merged = mergeIndexQueryCriteria(sortedIdx, idxDef, idxQryDesc);
+                return true;
+            }
 
-        return alignCriteriaWithIndex(sortedIdx, merged, idxDef);
+            /** {@inheritDoc} */
+            @Override public IndexRow get() throws IgniteCheckedException {
+                return currCursor.get();
+            }
+        };
     }
 
     /**
-     * Runs an index query.
+     * Runs single index query.
      *
      * @return Result cursor.
      */
     private GridCursor<IndexRow> querySortedIndex(
         SortedSegmentedIndex idx,
         IndexingQueryFilter cacheFilter,
-        IndexRangeQuery qry
+        IndexSingleRangeQuery qry
     ) throws IgniteCheckedException {
-        BPlusTree.TreeRowClosure<IndexRow, IndexRow> treeFilter = null;
-
-        // No need in the additional filter step for queries with 0 or 1 criteria.
-        // Also skips filtering if the current search is unbounded (both boundaries equal to null).
-        if (qry.criteria.length > 1 && !(qry.lower == null && qry.upper == null)) {
-            LinkedHashMap<String, IndexKeyDefinition> idxDef = idxProc.indexDefinition(idx.id()).indexKeyDefinitions();
+        IndexRowComparator rowCmp = ((SortedIndexDefinition)idxProc.indexDefinition(idx.id())).rowComparator();
 
-            treeFilter = new IndexQueryCriteriaClosure(
-                qry, idxDef, ((SortedIndexDefinition)idxProc.indexDefinition(idx.id())).rowComparator());
-        }
+        BPlusTree.TreeRowClosure<IndexRow, IndexRow> treeFilter = qry.filter(rowCmp);
 
         IndexQueryContext qryCtx = new IndexQueryContext(cacheFilter, treeFilter, null);
 
@@ -510,153 +397,19 @@ public class IndexQueryProcessor {
      * 2. To apply criteria on non-first index fields. Tree apply boundaries field by field, if first field match
      * a boundary, then second field isn't checked within traversing.
      */
-    private GridCursor<IndexRow> treeIndexRange(SortedSegmentedIndex idx, IndexRangeQuery qry, IndexQueryContext qryCtx)
+    private GridCursor<IndexRow> treeIndexRange(SortedSegmentedIndex idx, IndexSingleRangeQuery qry, IndexQueryContext qryCtx)
         throws IgniteCheckedException {
 
-        boolean lowIncl = inclBoundary(qry, true);
-        boolean upIncl = inclBoundary(qry, false);
-
-        return idx.find(qry.lower, qry.upper, lowIncl, upIncl, qryCtx);
-    }
-
-    /**
-     * Checks whether index thraversing should include boundary or not. Includes a boundary for unbounded searches, for
-     * others it checks user criteria.
-     *
-     * @param lower {@code true} for lower bound and {@code false} for upper bound.
-     * @return {@code true} for inclusive boundary, otherwise {@code false}.
-     */
-    private boolean inclBoundary(IndexRangeQuery qry, boolean lower) {
-        for (RangeIndexQueryCriterion c: qry.criteria) {
-            if (c == null || (lower ? c.lower() : c.upper()) == null)
-                break;
-
-            if (!(lower ? c.lowerIncl() : c.upperIncl()))
-                return false;
-        }
-
-        return true;
-    }
-
-    /**
-     * @param isNull {@code true} if user explicitly set {@code null} with a query argument.
-     */
-    private IndexKey key(Object val, boolean isNull, IndexKeyDefinition def, IndexKeyTypeSettings settings, CacheObjectContext coctx) {
-        IndexKey key = null;
-        IndexKeyType keyType = val == null ? IndexKeyType.NULL : IndexKeyType.forClass(val.getClass());
-
-        if (val != null || isNull)
-            key = IndexKeyFactory.wrap(val, keyType, coctx, settings);
-
-        return key;
-    }
-
-    /**
-     * Checks index rows for matching to specified index criteria.
-     */
-    private static class IndexQueryCriteriaClosure implements BPlusTree.TreeRowClosure<IndexRow, IndexRow> {
-        /** */
-        private final IndexRangeQuery qry;
-
-        /** */
-        private final IndexRowComparator rowCmp;
-
-        /** */
-        private final boolean[] descOrderCache;
-
-        /** */
-        IndexQueryCriteriaClosure(
-            IndexRangeQuery qry,
-            LinkedHashMap<String, IndexKeyDefinition> idxDef,
-            IndexRowComparator rowCmp
-        ) {
-            this.qry = qry;
-            this.rowCmp = rowCmp;
-            descOrderCache = new boolean[qry.criteria.length];
-
-            for (int i = 0; i < qry.criteria.length; i++) {
-                RangeIndexQueryCriterion c = qry.criteria[i];
-
-                descOrderCache[i] = idxDef.get(c.field()).order().sortOrder() == DESC;
-            }
-        }
-
-        /** {@inheritDoc} */
-        @Override public boolean apply(
-            BPlusTree<IndexRow, IndexRow> tree,
-            BPlusIO<IndexRow> io,
-            long pageAddr,
-            int idx
-        ) throws IgniteCheckedException {
-            return !rowIsOutOfRange((InlineIndexTree)tree, io, pageAddr, idx, qry.lower, qry.upper);
-        }
-
-        /**
-         * Checks that {@code row} belongs to the range specified with {@code low} and {@code high}.
-         *
-         * @return {@code true} if the row doesn't belong the range, otherwise {@code false}.
-         */
-        private boolean rowIsOutOfRange(
-            InlineIndexTree tree,
-            BPlusIO<IndexRow> io,
-            long pageAddr,
-            int idx,
-            IndexRow low,
-            IndexRow high
-        ) throws IgniteCheckedException {
-            int criteriaKeysCnt = qry.criteria.length;
-
-            int off = io.offset(idx);
-
-            int fieldOff = 0;
-
-            InlineIndexRow currRow = new InlineIndexRow(tree, io, pageAddr, idx);
-
-            List<InlineIndexKeyType> keyTypes = tree.rowHandler().inlineIndexKeyTypes();
-
-            for (int keyIdx = 0; keyIdx < criteriaKeysCnt; keyIdx++) {
-                RangeIndexQueryCriterion c = qry.criteria[keyIdx];
-
-                InlineIndexKeyType keyType = keyIdx < keyTypes.size() ? keyTypes.get(keyIdx) : null;
-
-                boolean descOrder = descOrderCache[keyIdx];
-
-                int maxSize = tree.inlineSize() - fieldOff;
+        boolean lowIncl = qry.inclBoundary(true);
+        boolean upIncl = qry.inclBoundary(false);
 
-                if (low != null && low.key(keyIdx) != null) {
-                    int cmp = currRow.compare(rowCmp, low, keyIdx, off + fieldOff, maxSize, keyType);
-
-                    if (cmp == 0) {
-                        if (!c.lowerIncl())
-                            return true;  // Exclude if field equals boundary field and criteria is excluding.
-                    }
-                    else if ((cmp < 0) ^ descOrder)
-                        return true;  // Out of bound. Either below 'low' margin or column with desc order.
-                }
-
-                if (high != null && high.key(keyIdx) != null) {
-                    int cmp = currRow.compare(rowCmp, high, keyIdx, off + fieldOff, maxSize, keyType);
-
-                    if (cmp == 0) {
-                        if (!c.upperIncl())
-                            return true;  // Exclude if field equals boundary field and criteria is excluding.
-                    }
-                    else if ((cmp > 0) ^ descOrder)
-                        return true;  // Out of bound. Either above 'high' margin or column with desc order.
-                }
-
-                if (keyType != null)
-                    fieldOff += keyType.inlineSize(pageAddr, off + fieldOff);
-            }
-
-            return false;
-        }
+        return idx.find(qry.lower(), qry.upper(), lowIncl, upIncl, qryCtx);
     }
 
     /**
      * @return Modified description for criterion in case of error.
      */
-    private static String rangeDesc(RangeIndexQueryCriterion c, String fldName, Object lower, Object upper) {
+    public static String rangeDesc(RangeIndexQueryCriterion c, String fldName, Object lower, Object upper) {
         String fld = fldName == null ? c.field() : fldName;
 
         Object l = lower == null ? c.lower() : lower;
@@ -669,74 +422,4 @@ public class IndexQueryProcessor {
 
         return r.toString();
     }
-
-    /** */
-    private static class IndexRangeQuery {
-        /** Ordered list of criteria. Order matches index fields order. */
-        private final RangeIndexQueryCriterion[] criteria;
-
-        /** */
-        private IndexRangeQuery(int critSize) {
-            criteria = new RangeIndexQueryCriterion[critSize];
-        }
-
-        /** */
-        private IndexRow lower;
-
-        /** */
-        private IndexRow upper;
-    }
-
-    /**
-     * Wrapper class over index row. It is suitable for comparison. It tries to check inlined keys first, and fetches a
-     * cache entry only if the inlined information is not full enough for comparison.
-     */
-    private static class InlineIndexRow {
-        /** */
-        private final long pageAddr;
-
-        /** */
-        private final int idx;
-
-        /** */
-        private final InlineIndexTree tree;
-
-        /** */
-        private final BPlusIO<IndexRow> io;
-
-        /** Set it for accessing keys from underlying cache entry. */
-        private IndexRow currRow;
-
-        /** */
-        private InlineIndexRow(InlineIndexTree tree, BPlusIO<IndexRow> io, long addr, int idx) {
-            pageAddr = addr;
-            this.idx = idx;
-            this.tree = tree;
-            this.io = io;
-        }
-
-        /** Compare using inline. {@code keyType} is {@code null} for non-inlined keys. */
-        private int compare(
-            IndexRowComparator rowCmp,
-            IndexRow o,
-            int keyIdx,
-            int off,
-            int maxSize,
-            @Nullable InlineIndexKeyType keyType
-        ) throws IgniteCheckedException {
-            if (currRow == null) {
-                int cmp = COMPARE_UNSUPPORTED;
-
-                if (keyType != null)
-                    cmp = rowCmp.compareKey(pageAddr, off, maxSize, o.key(keyIdx), keyType);
-
-                if (cmp == COMPARE_UNSUPPORTED || cmp == CANT_BE_COMPARE)
-                    currRow = tree.getRow(io, pageAddr, idx);
-                else
-                    return cmp;
-            }
-
-            return rowCmp.compareRow(currRow, o, keyIdx);
-        }
-    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexSingleRangeQuery.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexSingleRangeQuery.java
new file mode 100644
index 00000000000..448c778f399
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexSingleRangeQuery.java
@@ -0,0 +1,139 @@
+/*
+ * 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.cache.query.index;
+
+import org.apache.ignite.internal.cache.query.RangeIndexQueryCriterion;
+import org.apache.ignite.internal.cache.query.index.sorted.IndexRow;
+import org.apache.ignite.internal.cache.query.index.sorted.IndexRowComparator;
+import org.apache.ignite.internal.cache.query.index.sorted.IndexSearchRowImpl;
+import org.apache.ignite.internal.cache.query.index.sorted.keys.IndexKey;
+import org.apache.ignite.internal.processors.cache.persistence.tree.BPlusTree;
+import org.jetbrains.annotations.Nullable;
+
+/** */
+class IndexSingleRangeQuery {
+    /** Ordered list of criteria. Order matches index fields order. */
+    private final IndexKeyQueryCondition[] keyCond;
+
+    /** Array of IndexKeys to query underlying index. */
+    private final IndexKey[] lowerBounds;
+
+    /** Array of IndexKeys to query underlying index. */
+    private final IndexKey[] upperBounds;
+
+    /** {@code true} if all {@link #lowerBounds} keys are null. */
+    private boolean lowerAllNulls = true;
+
+    /** {@code true} if all {@link #upperBounds} keys are null. */
+    private boolean upperAllNulls = true;
+
+    /** Lower bound to query underlying index. */
+    private @Nullable IndexSearchRowImpl lower;
+
+    /** Upper bound to query underlying index. */
+    private @Nullable IndexSearchRowImpl upper;
+
+    /** */
+    IndexSingleRangeQuery(int idxRowSize, int critSize) {
+        keyCond = new IndexKeyQueryCondition[critSize];
+
+        // Size of bounds array has to be equal to count of indexed fields.
+        lowerBounds = new IndexKey[idxRowSize];
+        upperBounds = new IndexKey[idxRowSize];
+    }
+
+    /**
+     * @return Index tree filter for this query.
+     */
+    BPlusTree.TreeRowClosure<IndexRow, IndexRow> filter(IndexRowComparator rowCmp) {
+        // No need in the additional filter step for queries with 0 or 1 criteria.
+        // Also skips filtering if the current search is unbounded (both boundaries equal to null).
+        if (keyCond.length > 1 && !(lowerAllNulls && upperAllNulls))
+            return new IndexQueryCriteriaClosure(this, rowCmp);
+
+        return null;
+    }
+
+    /** */
+    IndexKeyQueryCondition keyCondition(int idx) {
+        if (idx < keyCond.length)
+            return keyCond[idx];
+
+        return null;
+    }
+
+    /** */
+    void addCondition(IndexKeyQueryCondition cond, int i) {
+        keyCond[i] = cond;
+
+        if (cond.range() != null) {
+            IndexKey l = (IndexKey)cond.range().lower();
+            IndexKey u = (IndexKey)cond.range().upper();
+
+            if (l != null)
+                lowerAllNulls = false;
+
+            if (u != null)
+                upperAllNulls = false;
+
+            lowerBounds[i] = l;
+            upperBounds[i] = u;
+        }
+        else {
+            lowerAllNulls = false;
+            upperAllNulls = false;
+        }
+    }
+
+    /** */
+    @Nullable IndexSearchRowImpl lower() {
+        if (lower == null && !lowerAllNulls)
+            lower = new IndexSearchRowImpl(lowerBounds, null);
+
+        return lower;
+    }
+
+    /** */
+    @Nullable IndexSearchRowImpl upper() {
+        if (upper == null && !upperAllNulls)
+            upper = new IndexSearchRowImpl(upperBounds, null);
+
+        return upper;
+    }
+
+    /**
+     * Checks whether index thraversing should include boundary or not. Includes a boundary for unbounded searches, for
+     * others it checks user criteria.
+     *
+     * @param lower {@code true} for lower bound and {@code false} for upper bound.
+     * @return {@code true} for inclusive boundary, otherwise {@code false}.
+     */
+    boolean inclBoundary(boolean lower) {
+        for (IndexKeyQueryCondition cond: keyCond) {
+            RangeIndexQueryCriterion c = cond.range();
+
+            if (c == null || (lower ? c.lower() : c.upper()) == null)
+                break;
+
+            if (!(lower ? c.lowerIncl() : c.upperIncl()))
+                return false;
+        }
+
+        return true;
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/InlineIndexKeyType.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/InlineIndexKeyType.java
index 0e54faae0d0..47b6ea2707a 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/InlineIndexKeyType.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/InlineIndexKeyType.java
@@ -102,4 +102,15 @@ public interface InlineIndexKeyType {
      * @return Size of key, in bytes. {@code -1} means variable length of key.
      */
     public short keySize();
+
+    /**
+     * Whether inline contains full index key.
+     *
+     * @param pageAddr Page address.
+     * @param off Offset.
+     * @return {@code true} if inline contains full index key. Can be {@code false} for truncated variable lenght types.
+     */
+    public default boolean inlinedFullValue(long pageAddr, int off) {
+        return true;
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/BytesInlineIndexKeyType.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/BytesInlineIndexKeyType.java
index 05b6687b1f8..5ed154b558d 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/BytesInlineIndexKeyType.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/BytesInlineIndexKeyType.java
@@ -89,7 +89,7 @@ public class BytesInlineIndexKeyType extends NullableInlineIndexKeyType<BytesInd
 
         int res = Integer.signum(len1 - len2);
 
-        if (isValueFull(pageAddr, off))
+        if (inlinedFullValue(pageAddr, off))
             return res;
 
         if (res >= 0)
@@ -144,12 +144,8 @@ public class BytesInlineIndexKeyType extends NullableInlineIndexKeyType<BytesInd
         return compareBinaryUnsigned;
     }
 
-    /**
-     * @param pageAddr Page address.
-     * @param off Offset.
-     * @return {@code True} if string is not truncated on save.
-     */
-    private boolean isValueFull(long pageAddr, int off) {
+    /** {@inheritDoc} */
+    @Override public boolean inlinedFullValue(long pageAddr, int off) {
         return (PageUtils.getShort(pageAddr, off + 1) & 0x8000) == 0;
     }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/ObjectByteArrayInlineIndexKeyType.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/ObjectByteArrayInlineIndexKeyType.java
index da657de884e..81ada03b74c 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/ObjectByteArrayInlineIndexKeyType.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/ObjectByteArrayInlineIndexKeyType.java
@@ -67,4 +67,9 @@ public class ObjectByteArrayInlineIndexKeyType extends NullableInlineIndexKeyTyp
         // Signed or unsigned doesn't matter there.
         return delegate.inlineSize0(new BytesIndexKey(b));
     }
+
+    /** {@inheritDoc} */
+    @Override public boolean inlinedFullValue(long pageAddr, int offset) {
+        return delegate.inlinedFullValue(pageAddr, offset);
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/StringInlineIndexKeyType.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/StringInlineIndexKeyType.java
index f88fef76af8..b7ffa1df680 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/StringInlineIndexKeyType.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/StringInlineIndexKeyType.java
@@ -230,7 +230,7 @@ public class StringInlineIndexKeyType extends NullableInlineIndexKeyType<StringI
 
         int res = cntr1 == len1 && cntr2 == len2 ? 0 : cntr1 == len1 ? -1 : 1;
 
-        if (isValueFull(pageAddr, off))
+        if (inlinedFullValue(pageAddr, off))
             return res;
 
         if (res >= 0)
@@ -264,12 +264,8 @@ public class StringInlineIndexKeyType extends NullableInlineIndexKeyType<StringI
         return null;
     }
 
-    /**
-     * @param pageAddr Page address.
-     * @param off Offset.
-     * @return {@code True} if string is not truncated on save.
-     */
-    private boolean isValueFull(long pageAddr, int off) {
+    /** {@inheritDoc} */
+    @Override public boolean inlinedFullValue(long pageAddr, int off) {
         return (PageUtils.getShort(pageAddr, off + 1) & 0x8000) == 0;
     }
 
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/StringNoCompareInlineIndexKeyType.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/StringNoCompareInlineIndexKeyType.java
index 1ed3583a610..bcc2ea85f7c 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/StringNoCompareInlineIndexKeyType.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/inline/types/StringNoCompareInlineIndexKeyType.java
@@ -53,4 +53,9 @@ public class StringNoCompareInlineIndexKeyType extends NullableInlineIndexKeyTyp
     @Override protected int inlineSize0(StringIndexKey key) {
         return delegate.inlineSize0(key);
     }
+
+    /** {@inheritDoc} */
+    @Override public boolean inlinedFullValue(long pageAddr, int off) {
+        return delegate.inlinedFullValue(pageAddr, off);
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/BooleanIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/BooleanIndexKey.java
index c7d5c488816..202dea0905d 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/BooleanIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/BooleanIndexKey.java
@@ -84,4 +84,9 @@ public class BooleanIndexKey extends NumericIndexKey {
     @Override public int compare(IndexKey o) {
         return o.type() == type() ? Boolean.compare(key, ((BooleanIndexKey)o).key) : -((NumericIndexKey)o).compareTo(key);
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return String.valueOf(key);
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/ByteIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/ByteIndexKey.java
index 07991fc3567..1e02ab367e5 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/ByteIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/ByteIndexKey.java
@@ -85,4 +85,9 @@ public class ByteIndexKey extends NumericIndexKey {
         return o.type() == type() ? Integer.signum(Byte.compare(key, ((ByteIndexKey)o).key))
             : -((NumericIndexKey)o).compareTo(key);
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return String.valueOf(key);
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/BytesIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/BytesIndexKey.java
index 98739d0df63..fa1effaa5d6 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/BytesIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/BytesIndexKey.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.cache.query.index.sorted.keys;
 
+import java.util.Arrays;
 import org.apache.ignite.internal.cache.query.index.sorted.IndexKeyType;
 
 /** */
@@ -61,4 +62,9 @@ public class BytesIndexKey implements IndexKey {
 
         return Integer.signum(Integer.compare(arr0.length, arr1.length));
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return Arrays.toString(key);
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/DateIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/DateIndexKey.java
index 0f31def690a..196c9b49018 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/DateIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/DateIndexKey.java
@@ -77,4 +77,9 @@ public class DateIndexKey extends DateTimeIndexKey {
         return type() == o.type() ? Long.compare(dateVal, ((DateIndexKey)o).dateVal)
             : -((DateTimeIndexKey)o).compareTo(dateVal, 0);
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return String.valueOf(dateVal);
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/DecimalIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/DecimalIndexKey.java
index 5ae1bb8597f..84e0973cd2f 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/DecimalIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/DecimalIndexKey.java
@@ -84,4 +84,9 @@ public class DecimalIndexKey extends NumericIndexKey {
     @Override public int compare(IndexKey o) {
         return o.type() == type() ? key.compareTo((BigDecimal)o.key()) : -((NumericIndexKey)o).compareTo(key);
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return String.valueOf(key);
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/DoubleIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/DoubleIndexKey.java
index 6b8ca8c7cd8..669c4e759b8 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/DoubleIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/DoubleIndexKey.java
@@ -84,4 +84,9 @@ public class DoubleIndexKey extends NumericIndexKey {
     @Override public int compare(IndexKey o) {
         return o.type() == type() ? Double.compare(key, ((DoubleIndexKey)o).key) : -((NumericIndexKey)o).compareTo(key);
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return String.valueOf(key);
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/FloatIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/FloatIndexKey.java
index 2dd4f36a2f1..c73f1edd103 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/FloatIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/FloatIndexKey.java
@@ -84,4 +84,9 @@ public class FloatIndexKey extends NumericIndexKey {
     @Override public int compare(IndexKey o) {
         return o.type() == type() ? Float.compare(key, ((FloatIndexKey)o).key) : -((NumericIndexKey)o).compareTo(key);
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return String.valueOf(key);
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/IntegerIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/IntegerIndexKey.java
index 28bd281d324..b5170566106 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/IntegerIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/IntegerIndexKey.java
@@ -84,4 +84,19 @@ public class IntegerIndexKey extends NumericIndexKey {
     @Override public int compare(IndexKey o) {
         return o.type() == type() ? Integer.compare(key, ((IntegerIndexKey)o).key) : -((NumericIndexKey)o).compareTo(key);
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return String.valueOf(key);
+    }
+//
+//    /** {@inheritDoc} */
+//    @Override public int hashCode() {
+//        return Integer.hashCode(key);
+//    }
+//
+//    /** {@inheritDoc} */
+//    @Override public boolean equals(Object o) {
+//        return o instanceof IntegerIndexKey && key == ((IntegerIndexKey)o).key;
+//    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/JavaObjectIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/JavaObjectIndexKey.java
index d6a0226b003..150401f1de7 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/JavaObjectIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/JavaObjectIndexKey.java
@@ -112,4 +112,14 @@ public abstract class JavaObjectIndexKey implements IndexKey {
             return len == 0 ? EMPTY_BYTES : Arrays.copyOf(bytes, len);
         }
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return key().toString();
+    }
+
+//    /** {@inheritDoc} */
+//    @Override public boolean equals(Object o) {
+//        return o instanceof JavaObjectIndexKey && compare((IndexKey)o) == 0;
+//    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/LongIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/LongIndexKey.java
index 1d63b31b5c8..04ce8f014b7 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/LongIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/LongIndexKey.java
@@ -84,4 +84,20 @@ public class LongIndexKey extends NumericIndexKey {
     @Override public int compare(IndexKey o) {
         return o.type() == type() ? Long.compare(key, ((LongIndexKey)o).key) : -((NumericIndexKey)o).compareTo(key);
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return String.valueOf(key);
+    }
+
+//    /** {@inheritDoc} */
+//    @Override public int hashCode() {
+//        return Long.hashCode(key);
+//    }
+//
+//    /** {@inheritDoc} */
+//    @Override public boolean equals(Object o) {
+//        return o instanceof LongIndexKey && key == ((LongIndexKey)o).key;
+//    }
+
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/NullIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/NullIndexKey.java
index fc369a8620a..1da2125390d 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/NullIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/NullIndexKey.java
@@ -43,4 +43,19 @@ public class NullIndexKey implements IndexKey {
     @Override public IndexKeyType type() {
         return IndexKeyType.NULL;
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return "null";
+    }
+
+//    /** {@inheritDoc} */
+//    @Override public int hashCode() {
+//        return 0;
+//    }
+//
+//    /** {@inheritDoc} */
+//    @Override public boolean equals(Object o) {
+//        return o instanceof NullIndexKey;
+//    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/ShortIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/ShortIndexKey.java
index 6d8b1419621..a1db4935036 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/ShortIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/ShortIndexKey.java
@@ -84,4 +84,20 @@ public class ShortIndexKey extends NumericIndexKey {
     @Override public int compare(IndexKey o) {
         return o.type() == type() ? Integer.compare(key, ((ShortIndexKey)o).key) : -((NumericIndexKey)o).compareTo(key);
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return String.valueOf(key);
+    }
+
+//    /** {@inheritDoc} */
+//    @Override public int hashCode() {
+//        return key;
+//    }
+//
+//    /** {@inheritDoc} */
+//    @Override public boolean equals(Object o) {
+//        return o instanceof ShortIndexKey && key == ((ShortIndexKey)o).key;
+//    }
+
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/StringIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/StringIndexKey.java
index e55f96f988b..c5368ba898f 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/StringIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/StringIndexKey.java
@@ -45,5 +45,21 @@ public class StringIndexKey implements IndexKey {
 
         return key.compareTo(okey);
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return key;
+    }
+
+//    /** {@inheritDoc} */
+//    @Override public int hashCode() {
+//        return key.hashCode();
+//    }
+//
+//    /** {@inheritDoc} */
+//    @Override public boolean equals(Object o) {
+//        return o instanceof StringIndexKey && compare((IndexKey)o) == 0;
+//    }
+
 }
 
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/TimeIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/TimeIndexKey.java
index 849b504e6f2..7e2c31b0bb2 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/TimeIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/TimeIndexKey.java
@@ -78,4 +78,19 @@ public class TimeIndexKey implements IndexKey {
     @Override public int compare(IndexKey o) {
         return Long.compare(nanos, ((TimeIndexKey)o).nanos);
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return String.valueOf(nanos);
+    }
+
+//    /** {@inheritDoc} */
+//    @Override public int hashCode() {
+//        return Long.hashCode(nanos);
+//    }
+//
+//    /** {@inheritDoc} */
+//    @Override public boolean equals(Object o) {
+//        return o instanceof TimeIndexKey && compare((IndexKey)o) == 0;
+//    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/TimestampIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/TimestampIndexKey.java
index 7447d1efefc..8488f02764d 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/TimestampIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/TimestampIndexKey.java
@@ -102,4 +102,20 @@ public class TimestampIndexKey extends DateTimeIndexKey {
     @Override public int compare(IndexKey o) {
         return -((DateTimeIndexKey)o).compareTo(dateVal, nanos);
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return dateVal + " " + nanos;
+    }
+//
+//    /** {@inheritDoc} */
+//    @Override public int hashCode() {
+//        return (int)(dateVal ^ dateVal >>> 32 ^ nanos ^ nanos >>> 32);
+//    }
+//
+//    /** {@inheritDoc} */
+//    @Override public boolean equals(Object o) {
+//        return o instanceof TimestampIndexKey && dateVal == ((TimestampIndexKey)o).dateVal && nanos == ((TimestampIndexKey)o).nanos;
+//    }
+
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/UuidIndexKey.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/UuidIndexKey.java
index 8cbb269916f..8f17c5a5533 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/UuidIndexKey.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/UuidIndexKey.java
@@ -50,4 +50,19 @@ public class UuidIndexKey implements IndexKey {
         else
             return key.getMostSignificantBits() > okey.getMostSignificantBits() ? 1 : -1;
     }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return String.valueOf(key);
+    }
+
+//    /** {@inheritDoc} */
+//    @Override public int hashCode() {
+//        return key.hashCode();
+//    }
+//
+//    /** {@inheritDoc} */
+//    @Override public boolean equals(Object o) {
+//        return o instanceof UuidIndexKey && compare((IndexKey)o) == 0;
+//    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/client/thin/ProtocolBitmaskFeature.java b/modules/core/src/main/java/org/apache/ignite/internal/client/thin/ProtocolBitmaskFeature.java
index c538c7e6345..d172142a1dd 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/client/thin/ProtocolBitmaskFeature.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/client/thin/ProtocolBitmaskFeature.java
@@ -65,7 +65,10 @@ public enum ProtocolBitmaskFeature {
     DATA_REPLICATION_OPERATIONS(12),
 
     /** Send all mappings to the client including non-default affinity functions. */
-    ALL_AFFINITY_MAPPINGS(13);
+    ALL_AFFINITY_MAPPINGS(13),
+
+    /** IndexQuery. */
+    INDEX_QUERY(14);
 
     /** */
     private static final EnumSet<ProtocolBitmaskFeature> ALL_FEATURES_AS_ENUM_SET =
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/client/thin/TcpClientCache.java b/modules/core/src/main/java/org/apache/ignite/internal/client/thin/TcpClientCache.java
index 69af7682ce6..fee4d55edb6 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/client/thin/TcpClientCache.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/client/thin/TcpClientCache.java
@@ -51,6 +51,7 @@ import org.apache.ignite.internal.binary.BinaryWriterExImpl;
 import org.apache.ignite.internal.binary.GridBinaryMarshaller;
 import org.apache.ignite.internal.binary.streams.BinaryInputStream;
 import org.apache.ignite.internal.binary.streams.BinaryOutputStream;
+import org.apache.ignite.internal.cache.query.InIndexQueryCriterion;
 import org.apache.ignite.internal.cache.query.RangeIndexQueryCriterion;
 import org.apache.ignite.internal.client.thin.TcpClientTransactions.TcpClientTransaction;
 import org.apache.ignite.internal.processors.cache.version.GridCacheVersion;
@@ -958,6 +959,9 @@ public class TcpClientCache<K, V> implements ClientCache<K, V> {
     /** Handle index query. */
     private QueryCursor<Cache.Entry<K, V>> indexQuery(IndexQuery<K, V> qry) {
         Consumer<PayloadOutputChannel> qryWriter = payloadCh -> {
+            if (!payloadCh.clientChannel().protocolCtx().isFeatureSupported(ProtocolBitmaskFeature.INDEX_QUERY))
+                throw new ClientFeatureNotSupportedByServerException(ProtocolBitmaskFeature.INDEX_QUERY);
+
             writeCacheInfo(payloadCh);
 
             BinaryOutputStream out = payloadCh.out();
@@ -989,6 +993,17 @@ public class TcpClientCache<K, V> implements ClientCache<K, V> {
                             serDes.writeObject(out, range.lower());
                             serDes.writeObject(out, range.upper());
                         }
+                        else if (c instanceof InIndexQueryCriterion) {
+                            out.writeByte((byte)1); // Criterion type.
+
+                            InIndexQueryCriterion in = (InIndexQueryCriterion)c;
+
+                            w.writeString(in.field());
+                            w.writeInt(in.values().size());
+
+                            for (Object v: in.values())
+                                serDes.writeObject(out, v);
+                        }
                         else {
                             throw new IllegalArgumentException(
                                 String.format("Unknown IndexQuery criterion type [%s]", c.getClass().getSimpleName())
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/client/ClientBitmaskFeature.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/client/ClientBitmaskFeature.java
index d4beaef89db..ae09009be03 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/client/ClientBitmaskFeature.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/client/ClientBitmaskFeature.java
@@ -66,7 +66,10 @@ public enum ClientBitmaskFeature implements ThinProtocolFeature {
     DATA_REPLICATION_OPERATIONS(12),
 
     /** Send all mappings to the client including non-default affinity functions. */
-    ALL_AFFINITY_MAPPINGS(13);
+    ALL_AFFINITY_MAPPINGS(13),
+
+    /** IndexQuery. */
+    INDEX_QUERY(14);
 
     /** */
     private static final EnumSet<ClientBitmaskFeature> ALL_FEATURES_AS_ENUM_SET =
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/client/cache/ClientCacheIndexQueryRequest.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/client/cache/ClientCacheIndexQueryRequest.java
index a5928cea542..69fc5973074 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/client/cache/ClientCacheIndexQueryRequest.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/client/cache/ClientCacheIndexQueryRequest.java
@@ -27,6 +27,7 @@ import org.apache.ignite.cache.query.IndexQuery;
 import org.apache.ignite.cache.query.IndexQueryCriterion;
 import org.apache.ignite.cache.query.QueryCursor;
 import org.apache.ignite.internal.binary.BinaryRawReaderEx;
+import org.apache.ignite.internal.cache.query.InIndexQueryCriterion;
 import org.apache.ignite.internal.cache.query.RangeIndexQueryCriterion;
 import org.apache.ignite.internal.processors.platform.client.ClientConnectionContext;
 import org.apache.ignite.internal.processors.platform.client.ClientResponse;
@@ -94,27 +95,47 @@ public class ClientCacheIndexQueryRequest extends ClientCacheRequest {
     private IndexQueryCriterion readCriterion(BinaryRawReaderEx reader) {
         byte type = reader.readByte();
 
-        if (type == 0) {
-            String field = reader.readString();
+        if (type == (byte)0)
+            return readRangeCriterion(reader);
+        else if (type == (byte)1)
+            return readInCriterion(reader);
 
-            boolean lowerIncl = reader.readBoolean();
-            boolean upperIncl = reader.readBoolean();
-            boolean lowerNull = reader.readBoolean();
-            boolean upperNull = reader.readBoolean();
+        throw new IgniteException("Unknown IndexQuery criterion type: " + type);
+    }
 
-            Object lower = reader.readObjectDetached();
-            Object upper = reader.readObjectDetached();
+    /** */
+    private IndexQueryCriterion readRangeCriterion(BinaryRawReaderEx reader) {
+        String field = reader.readString();
 
-            RangeIndexQueryCriterion r = new RangeIndexQueryCriterion(field, lower, upper);
-            r.lowerIncl(lowerIncl);
-            r.upperIncl(upperIncl);
-            r.lowerNull(lowerNull);
-            r.upperNull(upperNull);
+        boolean lowerIncl = reader.readBoolean();
+        boolean upperIncl = reader.readBoolean();
+        boolean lowerNull = reader.readBoolean();
+        boolean upperNull = reader.readBoolean();
 
-            return r;
-        }
+        Object lower = reader.readObjectDetached();
+        Object upper = reader.readObjectDetached();
 
-        throw new IgniteException("Unknown IndexQuery criterion type: " + type);
+        RangeIndexQueryCriterion r = new RangeIndexQueryCriterion(field, lower, upper);
+        r.lowerIncl(lowerIncl);
+        r.upperIncl(upperIncl);
+        r.lowerNull(lowerNull);
+        r.upperNull(upperNull);
+
+        return r;
+    }
+
+    /** */
+    private IndexQueryCriterion readInCriterion(BinaryRawReaderEx reader) {
+        String field = reader.readString();
+
+        int valsCnt = reader.readInt();
+
+        List<Object> vals = new ArrayList<>(valsCnt);
+
+        for (int i = 0; i < valsCnt; i++)
+            vals.add(reader.readObject());
+
+        return new InIndexQueryCriterion(field, vals);
     }
 
     /**
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryProcessor.java
index 443e12dbb2a..2c0b6aa9b4f 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryProcessor.java
@@ -3576,7 +3576,14 @@ public class GridQueryProcessor extends GridProcessorAdapter {
             return executeQuery(GridCacheQueryType.INDEX, valCls, cctx,
                 new IgniteOutClosureX<IndexQueryResult<K, V>>() {
                     @Override public IndexQueryResult<K, V> applyx() throws IgniteCheckedException {
-                        return idxQryPrc.queryLocal(cctx, idxQryDesc, entryFilter, cacheFilter, keepBinary);
+                        try {
+                            return idxQryPrc.queryLocal(cctx, idxQryDesc, entryFilter, cacheFilter, keepBinary);
+                        }
+                        catch (IgniteCheckedException e) {
+                            String msg = "Failed to execute IndexQuery: " + e.getMessage() + ". Query desc: " + idxQryDesc;
+
+                            throw new IgniteCheckedException(msg, e);
+                        }
                     }
                 }, true);
         }
diff --git a/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryAllTypesTest.java b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryAllTypesTest.java
index 779a1532043..c964a27e91d 100644
--- a/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryAllTypesTest.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryAllTypesTest.java
@@ -28,6 +28,7 @@ import java.sql.Time;
 import java.sql.Timestamp;
 import java.util.Arrays;
 import java.util.Calendar;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -55,6 +56,7 @@ import org.junit.runners.Parameterized;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.eq;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.gt;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.gte;
+import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.in;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.lt;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.lte;
 
@@ -119,7 +121,7 @@ public class IndexQueryAllTypesTest extends GridCommonAbstractTest {
 
         int pivot = CNT / 5;
 
-        String intNullIdx = idxName("intNullId");
+        String intNullIdx = idxName("intNullId", false);
 
         // Should include all.
         IndexQuery<Long, Person> qry = new IndexQuery<>(Person.class, intNullIdx);
@@ -161,6 +163,12 @@ public class IndexQueryAllTypesTest extends GridCommonAbstractTest {
             .setCriteria(gte("intNullId", null));
 
         check(cache.query(qry), 0, CNT, i -> i, persGen);
+
+        // Should return only nulls.
+        qry = new IndexQuery<Long, Person>(Person.class, intNullIdx)
+            .setCriteria(in("intNullId", Collections.singleton(null)));
+
+        check(cache.query(qry), 0, CNT / 10, i -> i, persGen);
     }
 
     /** */
@@ -169,12 +177,24 @@ public class IndexQueryAllTypesTest extends GridCommonAbstractTest {
         testRangeField(Integer::byteValue, "byteId", Byte.MAX_VALUE);
     }
 
+    /** */
+    @Test
+    public void testInByteField() {
+        testInSecondField(Integer::byteValue, "byteId", Byte.MAX_VALUE);
+    }
+
     /** */
     @Test
     public void testRangeShortField() {
         testRangeField(Integer::shortValue, "shortId");
     }
 
+    /** */
+    @Test
+    public void testInShortField() {
+        testInSecondField(Integer::shortValue, "shortId");
+    }
+
     /** */
     @Test
     public void testRangeIntField() {
@@ -187,42 +207,84 @@ public class IndexQueryAllTypesTest extends GridCommonAbstractTest {
         testRangeField(Integer::longValue, "longId");
     }
 
+    /** */
+    @Test
+    public void testInLongField() {
+        testInSecondField(Integer::longValue, "longId");
+    }
+
     /** */
     @Test
     public void testRangeDecimalField() {
         testRangeField(BigDecimal::valueOf, "decimalId");
     }
 
+    /** */
+    @Test
+    public void testInDecimalField() {
+        testInSecondField(BigDecimal::valueOf, "decimalId");
+    }
+
     /** */
     @Test
     public void testRangeDoubleField() {
         testRangeField(Integer::doubleValue, "doubleId");
     }
 
+    /** */
+    @Test
+    public void testInDoubleField() {
+        testInSecondField(Integer::doubleValue, "doubleId");
+    }
+
     /** */
     @Test
     public void testRangeFloatField() {
         testRangeField(Integer::floatValue, "floatId");
     }
 
+    /** */
+    @Test
+    public void testInFloatField() {
+        testInSecondField(Integer::floatValue, "floatId");
+    }
+
     /** */
     @Test
     public void testRangeTimeField() {
         testRangeField(i -> new Time(i.longValue()), "timeId");
     }
 
+    /** */
+    @Test
+    public void testInTimeField() {
+        testInSecondField(i -> new Time(i.longValue()), "timeId");
+    }
+
     /** */
     @Test
     public void testRangeDateField() {
         testRangeField(i -> new java.util.Date(i.longValue()), "dateId");
     }
 
+    /** */
+    @Test
+    public void testInDateField() {
+        testInSecondField(i -> new java.util.Date(i.longValue()), "dateId");
+    }
+
     /** */
     @Test
     public void testRangePojoField() {
         testRangeField(PojoField::new, "pojoId");
     }
 
+    /** */
+    @Test
+    public void testInPojoField() {
+        testInSecondField(PojoField::new, "pojoId");
+    }
+
     /** */
     @Test
     public void testRangeSqlDateField() {
@@ -237,12 +299,24 @@ public class IndexQueryAllTypesTest extends GridCommonAbstractTest {
         testRangeField(i -> new Timestamp(i.longValue()), "timestampId");
     }
 
+    /** */
+    @Test
+    public void testInTimestampField() {
+        testInSecondField(i -> new Timestamp(i.longValue()), "timestampId");
+    }
+
     /** */
     @Test
     public void testRangeBytesField() {
         testRangeField(i -> ByteBuffer.allocate(4).putInt(i).array(), "bytesId", 4);
     }
 
+    /** */
+    @Test
+    public void testInBytesField() {
+        testInSecondField(i -> ByteBuffer.allocate(4).putInt(i).array(), "bytesId", 4);
+    }
+
     /** */
     @Test
     public void testRangeUuidField() {
@@ -255,12 +329,30 @@ public class IndexQueryAllTypesTest extends GridCommonAbstractTest {
         }, "uuidId");
     }
 
+    /** */
+    @Test
+    public void testInUuidField() {
+        testInSecondField(i -> {
+            String formatted = String.format("%04d", i);
+            String uuid = "2af83a15-" + formatted + "-4c13-871d-b14f0d37fe2e";
+
+            return UUID.fromString(uuid);
+
+        }, "uuidId");
+    }
+
     /** */
     @Test
     public void testRangeStringField() {
         testRangeField(i -> String.format("%04d", i), "strId");
     }
 
+    /** */
+    @Test
+    public void testInStringField() {
+        testInSecondField(i -> String.format("%04d", i), "strId");
+    }
+
     /** Also checks duplicate indexed values. */
     @Test
     public void testBoolField() {
@@ -270,7 +362,7 @@ public class IndexQueryAllTypesTest extends GridCommonAbstractTest {
 
         insertData(valGen, persGen, CNT);
 
-        String boolIdx = idxName("boolId");
+        String boolIdx = idxName("boolId", false);
 
         IndexQuery<Long, Person> qry = new IndexQuery<>(Person.class, boolIdx);
 
@@ -288,6 +380,12 @@ public class IndexQueryAllTypesTest extends GridCommonAbstractTest {
             .setCriteria(eq("boolId", false));
 
         check(cache.query(qry), 0, CNT / 2 + 1, valGen, persGen);
+
+        // In.
+        qry = new IndexQuery<Long, Person>(Person.class, boolIdx)
+            .setCriteria(in("boolId", Collections.singleton(false)));
+
+        check(cache.query(qry), 0, CNT / 2 + 1, valGen, persGen);
     }
 
     /** */
@@ -360,12 +458,12 @@ public class IndexQueryAllTypesTest extends GridCommonAbstractTest {
                 log.info("Checking " + func.getKey() + " cache row type with " +
                     filterVal.getClass().getSimpleName() + " search row type");
 
-                IndexQuery<Long, Person> qry = new IndexQuery<Long, Person>(Person.class, idxName(fieldName))
+                IndexQuery<Long, Person> qry = new IndexQuery<Long, Person>(Person.class, idxName(fieldName, false))
                     .setCriteria(lte(fieldName, filterVal));
 
                 check(cache.query(qry), 0, cnt, func.getValue(), persGen);
 
-                qry = new IndexQuery<Long, Person>(Person.class, idxName(fieldName))
+                qry = new IndexQuery<Long, Person>(Person.class, idxName(fieldName, false))
                     .setCriteria(gt(fieldName, filterVal));
 
                 assertTrue(cache.query(qry).getAll().isEmpty());
@@ -399,26 +497,77 @@ public class IndexQueryAllTypesTest extends GridCommonAbstractTest {
         S val = searchRowGen.apply(pivot);
 
         // All.
-        IndexQuery<Long, Person> qry = new IndexQuery<>(Person.class, idxName(fieldName));
+        IndexQuery<Long, Person> qry = new IndexQuery<>(Person.class, idxName(fieldName, false));
 
         check(cache.query(qry), 0, cnt, valGen, persGen);
 
         // Lt.
-        qry = new IndexQuery<Long, Person>(Person.class, idxName(fieldName))
+        qry = new IndexQuery<Long, Person>(Person.class, idxName(fieldName, false))
             .setCriteria(lt(fieldName, val));
 
         check(cache.query(qry), 0, pivot, valGen, persGen);
 
         // Lte.
-        qry = new IndexQuery<Long, Person>(Person.class, idxName(fieldName))
+        qry = new IndexQuery<Long, Person>(Person.class, idxName(fieldName, false))
             .setCriteria(lte(fieldName, val));
 
         check(cache.query(qry), 0, pivot + 1, valGen, persGen);
+
+        // In.
+        qry = new IndexQuery<Long, Person>(Person.class, idxName(fieldName, false))
+            .setCriteria(in(fieldName, Collections.singleton(val)));
+
+        check(cache.query(qry), pivot, pivot + 1, valGen, persGen);
+    }
+
+    /** */
+    private <T, S> void testInSecondField(Function<Integer, T> valGen, String fieldName) {
+        testInSecondField(valGen, valGen, fieldName, CNT);
+    }
+
+    /** */
+    private <T, S> void testInSecondField(Function<Integer, T> valGen, String fieldName, int cnt) {
+        testInSecondField(valGen, valGen, fieldName, cnt);
+    }
+
+    /** */
+    private <T, S> void testInSecondField(
+        Function<Integer, T> valGen,
+        Function<Integer, S> searchRowGen,
+        String fieldName,
+        int cnt
+    ) {
+        Function<T, Person> persGen = i -> {
+            Person p = person(fieldName, i);
+
+            p.intId = 0;
+
+            return p;
+        };
+
+        insertData(valGen, persGen, cnt);
+
+        cache.query(new SqlFieldsQuery(
+            "create index if not exists IDX_intid_" + fieldName + " on Person(intId, " + fieldName + ");"
+        )).getAll();
+
+        int pivot = new Random().nextInt(cnt);
+
+        S val = searchRowGen.apply(pivot);
+
+        // In.
+        IndexQuery<Long, Person> qry = new IndexQuery<Long, Person>(Person.class, idxName(fieldName, true))
+            .setCriteria(eq("intId", 0), in(fieldName, Collections.singleton(val)));
+
+        check(cache.query(qry), pivot, pivot + 1, valGen, persGen);
     }
 
     /** */
-    private String idxName(String field) {
-        return useIdxName ? ("Person_" + field + "_idx").toUpperCase() : null;
+    private String idxName(String field, boolean inTest) {
+        if (!useIdxName)
+            return null;
+
+        return inTest ? "IDX_intid_" + field : ("Person_" + field + "_idx").toUpperCase();
     }
 
     /** */
@@ -575,7 +724,7 @@ public class IndexQueryAllTypesTest extends GridCommonAbstractTest {
     }
 
     /** */
-    private static class PojoField implements Serializable {
+    public static class PojoField implements Serializable {
         /** */
         private int intVal;
 
diff --git a/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryCacheKeyValueFieldsTest.java b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryCacheKeyValueFieldsTest.java
index 3630b89c716..e6b7a52d42f 100644
--- a/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryCacheKeyValueFieldsTest.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryCacheKeyValueFieldsTest.java
@@ -158,7 +158,7 @@ public class IndexQueryCacheKeyValueFieldsTest extends GridCommonAbstractTest {
             grid(0).cache(CACHE).query(
                 new IndexQuery<String, Integer>(Integer.class).setCriteria(gt(fld, key ? key(0) : 0))
             ).getAll();
-        }, IgniteException.class, "Failed to parse IndexQuery. No index found for criteria.");
+        }, IgniteException.class, "Failed to execute IndexQuery: No index found for criteria.");
     }
 
     /** */
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/StringIndexKey.java b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryInCriterionDescTest.java
similarity index 56%
copy from modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/StringIndexKey.java
copy to modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryInCriterionDescTest.java
index e55f96f988b..d1275da8c42 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/keys/StringIndexKey.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryInCriterionDescTest.java
@@ -15,35 +15,12 @@
  * limitations under the License.
  */
 
-package org.apache.ignite.internal.cache.query.index.sorted.keys;
-
-import org.apache.ignite.internal.cache.query.index.sorted.IndexKeyType;
+package org.apache.ignite.cache.query;
 
 /** */
-public class StringIndexKey implements IndexKey {
-    /** */
-    private final String key;
-
+public class IndexQueryInCriterionDescTest extends IndexQueryInCriterionTest {
     /** */
-    public StringIndexKey(String key) {
-        this.key = key;
-    }
-
-    /** {@inheritDoc} */
-    @Override public Object key() {
-        return key;
-    }
-
-    /** {@inheritDoc} */
-    @Override public IndexKeyType type() {
-        return IndexKeyType.STRING;
-    }
-
-    /** {@inheritDoc} */
-    @Override public int compare(IndexKey o) {
-        String okey = (String)o.key();
-
-        return key.compareTo(okey);
+    @Override protected boolean asc() {
+        return false;
     }
 }
-
diff --git a/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryInCriterionTest.java b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryInCriterionTest.java
new file mode 100644
index 00000000000..19692b7896a
--- /dev/null
+++ b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryInCriterionTest.java
@@ -0,0 +1,628 @@
+/*
+ * 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.cache.query;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Random;
+import org.apache.ignite.IgniteCheckedException;
+import org.apache.ignite.IgniteDataStreamer;
+import org.apache.ignite.cache.CacheAtomicityMode;
+import org.apache.ignite.cache.QueryEntity;
+import org.apache.ignite.cache.QueryIndex;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.internal.util.tostring.GridToStringInclude;
+import org.apache.ignite.internal.util.typedef.F;
+import org.apache.ignite.internal.util.typedef.internal.S;
+import org.apache.ignite.lang.IgniteBiPredicate;
+import org.apache.ignite.testframework.GridTestUtils;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+import org.junit.Test;
+
+import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.between;
+import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.eq;
+import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.gt;
+import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.gte;
+import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.in;
+import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.lt;
+import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.lte;
+
+/** */
+public class IndexQueryInCriterionTest extends GridCommonAbstractTest {
+    /** */
+    private static final String IDX = "IDX";
+
+    /** */
+    private static final Map<Integer, Person> data = new HashMap<>();
+
+    /** {@inheritDoc} */
+    @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception {
+        IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName);
+
+        QueryEntity qe = new QueryEntity()
+            .setKeyType(Integer.class.getName())
+            .setValueType(Person.class.getName())
+            .addQueryField("age", Integer.class.getName(), null)
+            .setIndexes(Collections.singleton(
+                new QueryIndex()
+                    .setName(IDX)
+                    .setFields(new LinkedHashMap<>(F.asMap("age", asc())))
+            ));
+
+        CacheConfiguration<Integer, Person> ccfg = new CacheConfiguration<Integer, Person>()
+            .setName("CACHE")
+            .setAtomicityMode(CacheAtomicityMode.TRANSACTIONAL)
+            .setQueryEntities(Collections.singleton(qe));
+
+        cfg.setCacheConfiguration(ccfg);
+
+        return cfg;
+    }
+
+    /** */
+    protected boolean asc() {
+        return true;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void beforeTestsStarted() throws Exception {
+        startGrids(3);
+
+        try (IgniteDataStreamer<Integer, Person> stream = grid(0).dataStreamer("CACHE")) {
+            Random rnd = new Random();
+
+            for (int i = 0; i < 10_000; i++) {
+                Person p = new Person(rnd.nextInt(100));
+
+                stream.addData(i, p);
+
+                data.put(i, p);
+            }
+
+            stream.addData(20_000, new Person(null));
+
+            data.put(20_000, new Person(null));
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void afterTestsStopped() {
+        stopAllGrids();
+    }
+
+    /** */
+    @Test
+    public void testSingleValueInCriterion() {
+        for (int i = -1; i <= 100; i++) {
+            IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(in("age", Collections.singleton(i)));
+
+            final int age = i;
+
+            assertExpect(qry, (k, p) -> p.age == age);
+        }
+    }
+
+    /** */
+    @Test
+    public void testTwoValuesInCriterion() {
+        for (int i = -1; i <= 100; i++) {
+            for (int j = -1; j <= 100; j++) {
+                IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+                    .setCriteria(in("age", F.asList(i, j)));
+
+                final int ageFirst = i;
+                final int ageSecond = j;
+
+                assertExpect(i + " " + j, qry, (k, p) -> p.age == ageFirst || p.age == ageSecond);
+            }
+        }
+    }
+
+    /** */
+    @Test
+    public void testMultipleInCriterion() {
+        List<Integer> arr = new ArrayList<>();
+
+        for (int i = -1; i <= 100; i++)
+            arr.add(i);
+
+        IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+            .setCriteria(in("age", arr));
+
+        assertExpect(qry, (k, p) -> true);
+    }
+
+    /** */
+    @Test
+    public void testSingleInWithSingleRangeCriterion() {
+        List<IndexQueryCriterion> criteria = F.asList(
+            lt("age", 50),
+            lte("age", 10),
+            eq("age", 10),
+            gte("age", 10),
+            gt("age", 0));
+
+        for (IndexQueryCriterion c: criteria) {
+            IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(in("age", Collections.singleton(10)), c);
+
+            assertExpect(c.toString(), qry, (k, p) -> p.age == 10);
+
+            qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(c, in("age", Collections.singleton(10)));
+
+            assertExpect(c.toString(), qry, (k, p) -> p.age == 10);
+        }
+    }
+
+    /** */
+    @Test
+    public void testSingleInWithMultipleRangeCriterion() {
+        List<IndexQueryCriterion> criteria = F.asList(
+            lt("age", 50),
+            lte("age", 10),
+            eq("age", 10),
+            gte("age", 10),
+            gt("age", 0));
+
+        List<IndexQueryCriterion[]> rangeCritPair = new ArrayList<>();
+
+        for (IndexQueryCriterion i: criteria) {
+            for (IndexQueryCriterion j: criteria) {
+                IndexQueryCriterion[] c = new IndexQueryCriterion[2];
+
+                c[0] = i;
+                c[1] = j;
+
+                rangeCritPair.add(c);
+            }
+        }
+
+        for (IndexQueryCriterion[] c: rangeCritPair) {
+            IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(in("age", Collections.singleton(10)), c[0], c[1]);
+
+            assertExpect(qry, (k, p) -> p.age == 10);
+
+            qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(c[0], in("age", Collections.singleton(10)), c[1]);
+
+            assertExpect(qry, (k, p) -> p.age == 10);
+
+            qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(c[0], in("age", Collections.singleton(10)), c[0], c[1]);
+
+            assertExpect(qry, (k, p) -> p.age == 10);
+        }
+    }
+
+    /** */
+    @Test
+    public void testMultipleInWithSingleRangeCriterion() {
+        List<IndexQueryCriterion> criteria = F.asList(
+            lt("age", 50),
+            lte("age", 20),
+            between("age", 10, 20),
+            gte("age", 10),
+            gt("age", 0));
+
+        for (IndexQueryCriterion c: criteria) {
+            IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(in("age", F.asList(10, 20)), c);
+
+            assertExpect(c.toString(), qry, (k, p) -> p.age == 10 || p.age == 20);
+
+            qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(c, in("age", F.asList(10, 20)));
+
+            assertExpect(c.toString(), qry, (k, p) -> p.age == 10 || p.age == 20);
+        }
+    }
+
+    /** */
+    @Test
+    public void testMultipleInWithSingleRangeCriterionCrossing() {
+        List<IndexQueryCriterion> firstOnlyCriteria = F.asList(
+            lte("age", 10),
+            lte("age", 15),
+            lt("age", 15),
+            lt("age", 20),
+            between("age", 5, 15),
+            between("age", 10, 15),
+            between("age", 5, 10),
+            eq("age", 10));
+
+        for (IndexQueryCriterion c: firstOnlyCriteria) {
+            IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(in("age", F.asList(10, 20)), c);
+
+            assertExpect(c.toString(), qry, (k, p) -> p.age == 10);
+
+            qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(c, in("age", F.asList(10, 20)));
+
+            assertExpect(c.toString(), qry, (k, p) -> p.age == 10);
+        }
+
+        if (true)
+            return;
+
+        List<IndexQueryCriterion> secondOnlyCriteria = F.asList(
+            gte("age", 15),
+            gte("age", 20),
+            gt("age", 10),
+            gt("age", 15),
+            between("age", 15, 25),
+            between("age", 20, 30),
+            between("age", 15, 20),
+            eq("age", 20));
+
+        for (IndexQueryCriterion c: secondOnlyCriteria) {
+            IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(in("age", F.asList(10, 20)), c);
+
+            assertExpect(c.toString(), qry, (k, p) -> p.age == 20);
+
+            qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(c, in("age", F.asList(10, 20)));
+
+            assertExpect(c.toString(), qry, (k, p) -> p.age == 20);
+        }
+    }
+
+    /** */
+    @Test
+    public void testExplcitiInCriterionWithNullVal() {
+        IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+            .setCriteria(in("age", Collections.singleton(null)));
+
+        assertExpect(qry, (k, p) -> p.age == null, true);
+
+        qry = new IndexQuery<Integer, Person>(Person.class)
+            .setCriteria(in("age", F.asList(null, 10)));
+
+        assertExpect(qry, (k, p) -> p.age == null || p.age == 10, true);
+    }
+
+    /** */
+    @Test
+    public void testDuplicatedInCriterionFailure() {
+        List<IndexQueryCriterion[]> criteria = F.asList(
+            new IndexQueryCriterion[] {
+                in("age", Collections.singleton(10)),
+                in("age", Collections.singleton(20))
+            },
+            new IndexQueryCriterion[] {
+                in("age", Collections.singleton(10)),
+                in("age", Collections.singleton(10))
+            },
+            new IndexQueryCriterion[] {
+                in("age", Collections.singleton(10)),
+                lt("age", 100),
+                in("age", Collections.singleton(20))
+            },
+            new IndexQueryCriterion[] {
+                in("age", Collections.singleton(10)),
+                lt("age", 100),
+                in("age", Collections.singleton(10))
+            },
+            new IndexQueryCriterion[] {
+                lt("age", 100),
+                in("age", Collections.singleton(10)),
+                in("age", Collections.singleton(20))
+            },
+            new IndexQueryCriterion[] {
+                lt("age", 100),
+                in("age", Collections.singleton(10)),
+                in("age", Collections.singleton(10))
+            });
+
+        for (IndexQueryCriterion[] c: criteria) {
+            IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(c);
+
+            GridTestUtils.assertThrows(
+                log,
+                () -> grid(0).cache("CACHE").query(qry).getAll(),
+                IgniteCheckedException.class,
+                "Multiple IN criteria for same field arent't supported."
+            );
+        }
+    }
+
+    /** */
+    @Test
+    public void testSingleInCriteriaAndRangeCriteriaNoCross() {
+        List<IndexQueryCriterion> criteria = F.asList(
+            lt("age", 10),
+            lt("age", 5),
+            lte("age", 5),
+            eq("age", 5),
+            eq("age", 20),
+            between("age", 0, 5),
+            between("age", 15, 20),
+            gt("age", 10),
+            gt("age", 15),
+            gte("age", 20)
+        );
+
+        for (IndexQueryCriterion c: criteria) {
+            IndexQuery<Integer, Person> qry1 = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(in("age", Collections.singleton(10)), c);
+
+            GridTestUtils.assertThrows(
+                log,
+                () -> grid(0).cache("CACHE").query(qry1).getAll(),
+                IgniteCheckedException.class,
+                "Failed to merge criterion"
+            );
+
+            IndexQuery<Integer, Person> qry2 = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(c, in("age", Collections.singleton(10)));
+
+            GridTestUtils.assertThrows(
+                log,
+                () -> grid(0).cache("CACHE").query(qry2).getAll(),
+                IgniteCheckedException.class,
+                "Failed to merge criterion"
+            );
+        }
+    }
+
+    /** */
+    @Test
+    public void testMultipleInCriteriaAndRangeCriteriaNoCross() {
+        List<IndexQueryCriterion[]> criteria = F.asList(
+            new IndexQueryCriterion[] { lt("age", 15), lt("age", 5) },
+            new IndexQueryCriterion[] { lt("age", 10), lte("age", 10) },
+            new IndexQueryCriterion[] { lt("age", 10), gt("age", 5) },
+            new IndexQueryCriterion[] { lt("age", 10), gte("age", 5) },
+            new IndexQueryCriterion[] { lt("age", 10), between("age", 5, 15) },
+            new IndexQueryCriterion[] { lt("age", 10), gte("age", 10) },
+            new IndexQueryCriterion[] { lte("age", 10), gt("age", 10) },
+            new IndexQueryCriterion[] { lt("age", 10), gt("age", 10) }
+        );
+
+        for (IndexQueryCriterion[] c: criteria) {
+            IndexQuery<Integer, Person> qry1 = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(in("age", Collections.singleton(10)), c[0], c[1]);
+
+            GridTestUtils.assertThrows(
+                log,
+                () -> grid(0).cache("CACHE").query(qry1).getAll(),
+                IgniteCheckedException.class,
+                "Failed to merge"
+            );
+
+            IndexQuery<Integer, Person> qry2 = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(c[0], in("age", Collections.singleton(10)), c[1]);
+
+            GridTestUtils.assertThrows(
+                log,
+                () -> grid(0).cache("CACHE").query(qry2).getAll(),
+                IgniteCheckedException.class,
+                "Failed to merge"
+            );
+
+            IndexQuery<Integer, Person> qry3 = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(c[0], c[1], in("age", Collections.singleton(10)));
+
+            GridTestUtils.assertThrows(
+                log,
+                () -> grid(0).cache("CACHE").query(qry3).getAll(),
+                IgniteCheckedException.class,
+                "Failed to merge"
+            );
+        }
+    }
+
+    /** */
+    @Test
+    public void testOnlySecondFieldCriterionFailed() {
+        IndexQuery<Integer, Person> idxQry = new IndexQuery<Integer, Person>(Person.class, IDX)
+            .setCriteria(in("_KEY", Collections.singleton(0)));
+
+        GridTestUtils.assertThrows(
+            log,
+            () -> grid(0).cache("CACHE").query(idxQry).getAll(),
+            IgniteCheckedException.class,
+            "Index doesn't match criteria"
+        );
+    }
+
+    /** */
+    @Test
+    public void testSingleInCriterionOnSecondField() {
+        for (int i = -1; i <= 100; i++) {
+            final int key = i;
+
+            IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(gte("age", 0), in("_KEY", Collections.singleton(i)));
+
+            assertExpect(String.valueOf(key), qry, (k, p) -> k == key);
+
+            qry = new IndexQuery<Integer, Person>(Person.class)
+                .setCriteria(in("_KEY", Collections.singleton(i)), gte("age", 0));
+
+            assertExpect(String.valueOf(key), qry, (k, p) -> k == key);
+        }
+    }
+
+    /** */
+    @Test
+    public void testMultipleInCriterionOnSecondField() {
+        for (int i = -1; i < 10; i++) {
+            for (int j = -1; j < 10; j++) {
+                final int firstKey = i;
+                final int secondKey = j;
+
+                IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+                    .setCriteria(gte("age", 0), in("_KEY", F.asList(i, j)));
+
+                assertExpect(qry, (k, p) -> k == firstKey || k == secondKey);
+
+                qry = new IndexQuery<Integer, Person>(Person.class)
+                    .setCriteria(in("_KEY", F.asList(i, j)), gte("age", 0));
+
+                assertExpect(qry, (k, p) -> k == firstKey || k == secondKey);
+            }
+        }
+    }
+
+    /** */
+    @Test
+    public void testMultipleInWithRangeCrossCriterionOnSecondField() {
+        Random rnd = new Random();
+
+        int keyFirst = 0;
+        int keySecond = 0;
+
+        int ageFirst = 0;
+        int ageSecond = 0;
+
+        while (ageFirst >= ageSecond) {
+            keyFirst = rnd.nextInt(10_000);
+            keySecond = rnd.nextInt(10_000);
+
+            ageFirst = data.get(keyFirst).age;
+            ageSecond = data.get(keySecond).age;
+        }
+
+        final int firstKey = keyFirst;
+        final int secondKey = keySecond;
+
+        IndexQuery<Integer, Person> qry = new IndexQuery<Integer, Person>(Person.class)
+            .setCriteria(lt("age", ageSecond), in("_KEY", F.asList(keyFirst, keySecond)));
+
+        assertExpect(qry, (k, p) -> k == firstKey);
+
+        qry = new IndexQuery<Integer, Person>(Person.class)
+            .setCriteria(lte("age", ageSecond), in("_KEY", F.asList(keyFirst, keySecond)));
+
+        assertExpect(qry, (k, p) -> k == firstKey || k == secondKey);
+
+        qry = new IndexQuery<Integer, Person>(Person.class)
+            .setCriteria(lte("age", ageFirst), in("_KEY", F.asList(keyFirst, keySecond)));
+
+        assertExpect(qry, (k, p) -> k == firstKey);
+
+        qry = new IndexQuery<Integer, Person>(Person.class)
+            .setCriteria(gt("age", ageFirst), in("_KEY", F.asList(keyFirst, keySecond)));
+
+        assertExpect(qry, (k, p) -> k == secondKey);
+
+        qry = new IndexQuery<Integer, Person>(Person.class)
+            .setCriteria(gte("age", ageFirst), in("_KEY", F.asList(keyFirst, keySecond)));
+
+        assertExpect(qry, (k, p) -> k == firstKey || k == secondKey);
+
+        qry = new IndexQuery<Integer, Person>(Person.class)
+            .setCriteria(gte("age", ageSecond), in("_KEY", F.asList(keyFirst, keySecond)));
+
+        assertExpect(qry, (k, p) -> k == secondKey);
+
+        qry = new IndexQuery<Integer, Person>(Person.class)
+            .setCriteria(between("age", ageFirst, ageSecond), in("_KEY", F.asList(keyFirst, keySecond)));
+
+        assertExpect(qry, (k, p) -> k == firstKey || k == secondKey);
+
+        qry = new IndexQuery<Integer, Person>(Person.class)
+            .setCriteria(between("age", ageFirst + 1, ageSecond), in("_KEY", F.asList(keyFirst, keySecond)));
+
+        assertExpect(qry, (k, p) -> k == secondKey);
+
+        qry = new IndexQuery<Integer, Person>(Person.class)
+            .setCriteria(between("age", ageFirst, ageSecond - 1), in("_KEY", F.asList(keyFirst, keySecond)));
+
+        assertExpect(qry, (k, p) -> k == firstKey);
+    }
+
+    /** */
+    private void assertExpect(IndexQuery<Integer, Person> qry, IgniteBiPredicate<Integer, Person> expectFunc) {
+        assertExpect(qry, expectFunc, false);
+    }
+
+    /** */
+    private void assertExpect(String msg, IndexQuery<Integer, Person> qry, IgniteBiPredicate<Integer, Person> expectFunc) {
+        assertExpect(msg, qry, expectFunc, false);
+    }
+
+    /** */
+    private void assertExpect(IndexQuery<Integer, Person> qry, IgniteBiPredicate<Integer, Person> expectFunc, boolean checkNull) {
+        assertExpect("", qry, expectFunc, checkNull);
+    }
+
+    /** */
+    private void assertExpect(
+        String msg,
+        IndexQuery<Integer, Person> qry,
+        IgniteBiPredicate<Integer, Person> expectFunc,
+        boolean checkNull
+    ) {
+        Map<Integer, Person> expect = new HashMap<>();
+
+        data.forEach((k, v) -> {
+            if ((checkNull || v.age != null) && expectFunc.apply(k, v))
+                expect.put(k, v);
+        });
+
+        int expSize = expect.size();
+
+        grid(0).cache("CACHE").query(qry).getAll().forEach(e ->
+            assertTrue(
+                msg + " : " + e.toString() + " expSize=" + expSize + " currSize=" + expect.size(),
+                expect.remove(e.getKey(), e.getValue()))
+        );
+
+        assertTrue(expect.toString(), expect.isEmpty());
+    }
+
+    /** */
+    private static class Person {
+        /** */
+        @GridToStringInclude
+        final Integer age;
+
+        /** */
+        Person(Integer age) {
+            this.age = age;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean equals(Object o) {
+            return Objects.equals(age, ((Person)o).age);
+        }
+
+        /** {@inheritDoc} */
+        @Override public int hashCode() {
+            return age;
+        }
+
+        /** {@inheritDoc} */
+        @Override public String toString() {
+            return S.toString(Person.class, this);
+        }
+    }
+}
diff --git a/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryInlineSizesTest.java b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryInlineSizesTest.java
index 000b30c327b..32de88d75b8 100644
--- a/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryInlineSizesTest.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryInlineSizesTest.java
@@ -18,32 +18,36 @@
 package org.apache.ignite.cache.query;
 
 import java.math.BigDecimal;
+import java.util.Collections;
 import java.util.List;
 import java.util.Random;
 import java.util.function.BiFunction;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import org.apache.ignite.Ignite;
 import org.apache.ignite.IgniteDataStreamer;
 import org.apache.ignite.binary.BinaryObject;
+import org.apache.ignite.cache.QueryEntity;
+import org.apache.ignite.configuration.CacheConfiguration;
 import org.apache.ignite.internal.IgniteEx;
 import org.apache.ignite.internal.processors.query.h2.IgniteH2Indexing;
 import org.apache.ignite.internal.processors.query.h2.database.H2TreeIndexBase;
 import org.apache.ignite.internal.processors.query.h2.opt.GridH2Table;
+import org.apache.ignite.internal.util.typedef.F;
 import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
+import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.eq;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.gt;
+import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.in;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.lt;
 
 /** */
 @RunWith(Parameterized.class)
 public class IndexQueryInlineSizesTest extends GridCommonAbstractTest {
-    /** */
-    private static final String CACHE = "TEST_CACHE";
-
     /** */
     private static final String TABLE_CACHE = "TEST_CACHE_TABLE";
 
@@ -85,6 +89,22 @@ public class IndexQueryInlineSizesTest extends GridCommonAbstractTest {
             check((low, high) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
                 .setCriteria(gt("fld1", low), lt("fld2", high)));
         }
+
+        try (Index idx = new Index(inlineSize, "fld5", inlineSize > 10 ? 10 : inlineSize)) {
+            checkEquals((val) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
+                .setCriteria(eq("fld5", pojoFieldVal(val))));
+
+            checkEquals((val) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
+                .setCriteria(in("fld5", Collections.singleton(pojoFieldVal(val)))));
+        }
+
+        try (Index idx = new Index(inlineSize, "fld1, fld5", inlineSize > 15 ? 15 : inlineSize)) {
+            checkEquals((val) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
+                .setCriteria(eq("fld1", val), in("fld5", Collections.singleton(pojoFieldVal(val)))));
+
+            checkEquals((val) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
+                .setCriteria(eq("fld1", val), eq("fld5", pojoFieldVal(val))));
+        }
     }
 
     /** */
@@ -93,6 +113,11 @@ public class IndexQueryInlineSizesTest extends GridCommonAbstractTest {
         try (Index idx = new Index(inlineSize, "fld1, fld3")) {
             check((low, high) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
                 .setCriteria(gt("fld1", low), lt("fld3", strFieldVal(high))));
+
+            checkEquals((val) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
+                .setCriteria(
+                    in("fld1", Collections.singleton(val)),
+                    in("fld3", Collections.singleton(strFieldVal(val)))));
         }
     }
 
@@ -102,6 +127,11 @@ public class IndexQueryInlineSizesTest extends GridCommonAbstractTest {
         try (Index idx = new Index(inlineSize, "fld3, fld1")) {
             check((low, high) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
                 .setCriteria(gt("fld1", low), lt("fld3", strFieldVal(high))));
+
+            checkEquals((val) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
+                .setCriteria(
+                    eq("fld1", val),
+                    in("fld3", Collections.singleton(strFieldVal(val)))));
         }
     }
 
@@ -114,6 +144,11 @@ public class IndexQueryInlineSizesTest extends GridCommonAbstractTest {
         try (Index idx = new Index(inlineSize, "fld1, fld4", inlineSize > 5 ? 5 : inlineSize)) {
             check((low, high) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
                 .setCriteria(gt("fld1", low), lt("fld4", new BigDecimal(high))));
+
+            checkEquals((val) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
+                .setCriteria(
+                    eq("fld1", val),
+                    in("fld4", Collections.singleton(new BigDecimal(val)))));
         }
     }
 
@@ -123,6 +158,11 @@ public class IndexQueryInlineSizesTest extends GridCommonAbstractTest {
         try (Index idx = new Index(inlineSize, "fld4, fld1", 0)) {
             check((low, high) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
                 .setCriteria(gt("fld1", low), lt("fld4", new BigDecimal(high))));
+
+            checkEquals((val) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
+                .setCriteria(
+                    eq("fld1", val),
+                    in("fld4", Collections.singleton(new BigDecimal(val)))));
         }
     }
 
@@ -132,6 +172,11 @@ public class IndexQueryInlineSizesTest extends GridCommonAbstractTest {
         try (Index idx = new Index(inlineSize, "fld3, fld4")) {
             check((low, high) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
                 .setCriteria(gt("fld3", strFieldVal(low)), lt("fld4", new BigDecimal(high))));
+
+            checkEquals((val) -> new IndexQuery<Integer, BinaryObject>(VALUE_TYPE, idx.idxName)
+                .setCriteria(
+                    eq("fld3", strFieldVal(val)),
+                    in("fld4", Collections.singleton(new BigDecimal(val)))));
         }
     }
 
@@ -150,12 +195,35 @@ public class IndexQueryInlineSizesTest extends GridCommonAbstractTest {
     }
 
     /** */
-    private void prepareTable(Ignite crd) {
-        SqlFieldsQuery tblQry = new SqlFieldsQuery("create table " + TABLE +
-            "(id int PRIMARY KEY, fld1 int, fld2 int, fld3 varchar, fld4 decimal)" +
-            " with \"CACHE_NAME=" + TABLE_CACHE + ",VALUE_TYPE=" + VALUE_TYPE + "\";");
+    private void checkEquals(Function<Integer, IndexQuery<Integer, BinaryObject>> qryBld) {
+        Random r = new Random();
+
+        int val = r.nextInt(CNT);
+
+        IndexQuery<Integer, BinaryObject> qry = qryBld.apply(val);
 
-        crd.getOrCreateCache(CACHE).query(tblQry);
+        List<?> result = crd.cache(TABLE_CACHE).withKeepBinary().query(qry).getAll();
+
+        assertEquals(1, result.size());
+    }
+
+    /** */
+    private void prepareTable(Ignite crd) {
+        QueryEntity qe = new QueryEntity()
+            .setTableName(TABLE)
+            .setKeyType(Integer.class.getName())
+            .setValueType(VALUE_TYPE)
+            .setKeyFieldName("id")
+            .addQueryField("id", Integer.class.getName(), null)
+            .addQueryField("fld1", Integer.class.getName(), null)
+            .addQueryField("fld2", Integer.class.getName(), null)
+            .addQueryField("fld3", String.class.getName(), null)
+            .addQueryField("fld4", BigDecimal.class.getName(), null)
+            .addQueryField("fld5", IndexQueryAllTypesTest.PojoField.class.getName(), null);
+
+        crd.createCache(new CacheConfiguration<>(TABLE_CACHE)
+            .setSqlSchema("PUBLIC")
+            .setQueryEntities(F.asList(qe)));
 
         try (IgniteDataStreamer<Integer, BinaryObject> s = crd.dataStreamer(TABLE_CACHE)) {
             IntStream.range(0, CNT).forEach((v) -> {
@@ -164,6 +232,7 @@ public class IndexQueryInlineSizesTest extends GridCommonAbstractTest {
                     .setField("fld2", v)
                     .setField("fld3", strFieldVal(v))
                     .setField("fld4", new BigDecimal(v))
+                    .setField("fld5", new IndexQueryAllTypesTest.PojoField(v))
                     .build();
 
                 s.addData(v, bo);
@@ -176,6 +245,11 @@ public class IndexQueryInlineSizesTest extends GridCommonAbstractTest {
         return String.format("%10s", val).replace(" ", "0");
     }
 
+    /** */
+    private static IndexQueryAllTypesTest.PojoField pojoFieldVal(int val) {
+        return new IndexQueryAllTypesTest.PojoField(val);
+    }
+
     /** */
     private static class Index implements AutoCloseable {
         /** */
@@ -193,7 +267,7 @@ public class IndexQueryInlineSizesTest extends GridCommonAbstractTest {
             SqlFieldsQuery idxQry = new SqlFieldsQuery(
                 "create index " + idxName + " on " + TABLE + "(" + flds + ") INLINE_SIZE " + inlineSize);
 
-            crd.cache(CACHE).query(idxQry).getAll();
+            crd.cache(TABLE_CACHE).query(idxQry).getAll();
 
             GridH2Table tbl = ((IgniteH2Indexing)crd.context().query().getIndexing()).schemaManager()
                 .dataTable("PUBLIC", TABLE);
@@ -205,7 +279,7 @@ public class IndexQueryInlineSizesTest extends GridCommonAbstractTest {
         @Override public void close() throws Exception {
             SqlFieldsQuery idxQry = new SqlFieldsQuery("drop index " + idxName);
 
-            crd.cache(CACHE).query(idxQry).getAll();
+            crd.cache(TABLE_CACHE).query(idxQry).getAll();
         }
     }
 }
diff --git a/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryRangeTest.java b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryRangeTest.java
index 02fe4b96daa..9fa143ad686 100644
--- a/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryRangeTest.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryRangeTest.java
@@ -39,6 +39,7 @@ 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.QueryCursorEx;
+import org.apache.ignite.internal.util.typedef.F;
 import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -52,6 +53,7 @@ import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.between;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.eq;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.gt;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.gte;
+import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.in;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.lt;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.lte;
 
@@ -220,6 +222,12 @@ public class IndexQueryRangeTest extends GridCommonAbstractTest {
             .setCriteria(between(fld, lower, upper));
 
         check(qry, lower, upper + 1);
+
+        // In.
+        qry = new IndexQuery<Long, Person>(Person.class, idxName)
+            .setCriteria(in(fld, F.asList(pivot, pivot + 1)));
+
+        check(qry, pivot, pivot + 2);
     }
 
     /**
diff --git a/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryTestSuite.java b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryTestSuite.java
index 0aeec5d059f..754fc2d2361 100644
--- a/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryTestSuite.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryTestSuite.java
@@ -42,7 +42,10 @@ import org.junit.runners.Suite;
     MultifieldIndexQueryTest.class,
     MultiTableIndexQuery.class,
     RepeatedFieldIndexQueryTest.class,
-    ThinClientIndexQueryTest.class
+    ThinClientIndexQueryTest.class,
+    RepeatedFieldIndexQueryTest.class,
+    IndexQueryInCriterionTest.class,
+    IndexQueryInCriterionDescTest.class
 })
 public class IndexQueryTestSuite {
 }
diff --git a/modules/indexing/src/test/java/org/apache/ignite/cache/query/ThinClientIndexQueryTest.java b/modules/indexing/src/test/java/org/apache/ignite/cache/query/ThinClientIndexQueryTest.java
index 50a43fe3b6b..4c4a8ce0951 100644
--- a/modules/indexing/src/test/java/org/apache/ignite/cache/query/ThinClientIndexQueryTest.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/cache/query/ThinClientIndexQueryTest.java
@@ -17,10 +17,11 @@
 
 package org.apache.ignite.cache.query;
 
-import java.util.Iterator;
+import java.util.Collections;
 import java.util.List;
 import java.util.Random;
 import java.util.function.Consumer;
+import java.util.function.Function;
 import javax.cache.Cache;
 import org.apache.ignite.Ignite;
 import org.apache.ignite.IgniteDataStreamer;
@@ -50,6 +51,7 @@ import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.between;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.eq;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.gt;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.gte;
+import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.in;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.lt;
 import static org.apache.ignite.cache.query.IndexQueryCriteriaBuilder.lte;
 
@@ -59,6 +61,9 @@ public class ThinClientIndexQueryTest extends GridCommonAbstractTest {
     /** */
     private static final int CNT = 10_000;
 
+    /** */
+    private static final int NULLS_CNT = -10;
+
     /** */
     private static final int NODES = 2;
 
@@ -68,6 +73,9 @@ public class ThinClientIndexQueryTest extends GridCommonAbstractTest {
     /** */
     private static final String IDX_FLD1_FLD2 = "IDX_FLD1_FLD2";
 
+    /** */
+    private static final String IDX_FLD3 = "IDX_FLD3";
+
     /** */
     @Parameterized.Parameter
     public boolean keepBinary;
@@ -100,7 +108,10 @@ public class ThinClientIndexQueryTest extends GridCommonAbstractTest {
 
         try (IgniteDataStreamer<Integer, Person> stream = grid(0).dataStreamer("CACHE")) {
             for (int i = 0; i < CNT; i++)
-                stream.addData(i, new Person(i, i));
+                stream.addData(i, new Person(i, i, new IndexQueryAllTypesTest.PojoField(i)));
+
+            for (int i = NULLS_CNT; i < 0; i++)
+                stream.addData(i, new Person(null, null, null));
         }
     }
 
@@ -115,18 +126,31 @@ public class ThinClientIndexQueryTest extends GridCommonAbstractTest {
         for (String idxName: F.asList(IDX_FLD1, IDX_FLD1_FLD2, null)) {
             withClientCache((cache) -> {
                 // No criteria.
-                assertClientQuery(cache, 0, CNT, idxName);
+                assertClientQuery(cache, NULLS_CNT, CNT, idxName);
 
                 // Single field, single criterion.
                 assertClientQuery(cache, left + 1, CNT, idxName, gt("fld1", left));
                 assertClientQuery(cache, left, CNT, idxName, gte("fld1", left));
-                assertClientQuery(cache, 0, left, idxName, lt("fld1", left));
-                assertClientQuery(cache, 0, left + 1, idxName, lte("fld1", left));
+                assertClientQuery(cache, NULLS_CNT, left, idxName, lt("fld1", left));
+                assertClientQuery(cache, NULLS_CNT, left + 1, idxName, lte("fld1", left));
                 assertClientQuery(cache, left, left + 1, idxName, eq("fld1", left));
-                assertClientQuery(cache, left, right, idxName, between("fld1", left, right));
+                assertClientQuery(cache, left, right + 1, idxName, between("fld1", left, right));
+                assertClientQuery(cache, left, left + 1, idxName, in("fld1", Collections.singleton(left)));
 
                 // Single field, multiple criteria.
                 assertClientQuery(cache, left, right + 1, idxName, gte("fld1", left), lte("fld1", right));
+                assertClientQuery(cache, left + 1, right + 1, idxName, gt("fld1", left), lte("fld1", right));
+                assertClientQuery(cache, left, right, idxName, gte("fld1", left), lt("fld1", right));
+                assertClientQuery(cache, left + 1, right, idxName, gt("fld1", left), lt("fld1", right));
+                assertClientQuery(cache, right, right + 1, idxName,
+                    gte("fld1", left), in("fld1", Collections.singleton(right)));
+
+                // Single field, with nulls.
+                assertClientQuery(cache, NULLS_CNT, CNT, idxName, gte("fld1", null));
+                assertClientQuery(cache, 0, CNT, idxName, gt("fld1", null));
+                assertClientQuery(cache, 0, 0, idxName, lt("fld1", null));
+                assertClientQuery(cache, NULLS_CNT, 0, idxName, lte("fld1", null));
+                assertClientQuery(cache, NULLS_CNT, 0, idxName, in("fld1", Collections.singleton(null)));
             });
         }
 
@@ -134,10 +158,39 @@ public class ThinClientIndexQueryTest extends GridCommonAbstractTest {
             withClientCache((cache) -> {
                 // Multiple field, multiple criteria.
                 assertClientQuery(cache, left + 1, right, idxName, gt("fld1", left), lt("fld2", right));
+                assertClientQuery(cache, right, right + 1, idxName,
+                    gt("fld1", left), in("fld2", Collections.singleton(right)));
+
             });
         }
     }
 
+    /** */
+    @Test
+    public void testPojoIndex() {
+        withClientCache((cache) -> {
+            Object pojo = new IndexQueryAllTypesTest.PojoField(100);
+
+            for (IndexQueryCriterion[] criteria: F.asList(
+                new IndexQueryCriterion[] { eq("fld3", pojo) },
+                new IndexQueryCriterion[] { in("fld3", Collections.singleton(pojo)) })
+            ) {
+                IndexQuery<Integer, Person> idxQry = new IndexQuery<Integer, Person>(Person.class, IDX_FLD3)
+                    .setCriteria(criteria);
+
+                List<Cache.Entry<Integer, Person>> result = cache.query(idxQry).getAll();
+
+                assertEquals(1, result.size());
+                assertEquals(100, result.get(0).getKey().intValue());
+
+                if (keepBinary)
+                    assertEquals(pojo, ((BinaryObject)result.get(0).getValue()).field("fld3"));
+                else
+                    assertEquals(100, result.get(0).getKey().intValue());
+            }
+        });
+    }
+
     /** */
     @Test
     public void testIndexNameMismatchCriteria() {
@@ -153,7 +206,7 @@ public class ThinClientIndexQueryTest extends GridCommonAbstractTest {
                     log,
                     () -> cache.query(idxQry).getAll(),
                     ClientException.class,
-                    "Failed to parse IndexQuery. Index doesn't match criteria");
+                    "Failed to execute IndexQuery: Index doesn't match criteria");
             }
         });
     }
@@ -169,7 +222,7 @@ public class ThinClientIndexQueryTest extends GridCommonAbstractTest {
 
                 TestRecordingCommunicationSpi.spi(grid(0)).record(GridQueryNextPageRequest.class);
 
-                assertClientQuery(cache, 0, CNT, idxQry);
+                assertClientQuery(cache, NULLS_CNT, CNT, idxQry);
 
                 List<Object> reqs = TestRecordingCommunicationSpi.spi(grid(0)).recordedMessages(true);
 
@@ -209,7 +262,7 @@ public class ThinClientIndexQueryTest extends GridCommonAbstractTest {
     @Test
     public void testFilter() {
         IndexQuery idxQry = new IndexQuery(Person.class);
-        idxQry.setFilter((k, v) -> (int)k < 1000);
+        idxQry.setFilter((k, v) -> (int)k >= 0 && (int)k < 1000);
 
         withClientCache((cache) -> assertClientQuery(cache, 0, 1000, idxQry));
     }
@@ -295,21 +348,24 @@ public class ThinClientIndexQueryTest extends GridCommonAbstractTest {
 
     /** */
     private void assertClientQuery(ClientCache<Integer, Person> cache, int left, int right, IndexQuery idxQry) {
-        Iterator<Cache.Entry<Integer, Person>> cursor = cache.query(idxQry).iterator();
+        List<Cache.Entry<Integer, Person>> result = cache.query(idxQry).getAll();
 
-        for (int i = left; i < right; i++) {
-            Cache.Entry<Integer, Person> e = cursor.next();
+        assertEquals(right - left, result.size());
 
-            assertEquals(i, e.getKey().intValue());
+        Function<Cache.Entry<Integer, Person>, Object> fldOneVal = (e) ->
+            keepBinary ? ((BinaryObject)e.getValue()).field("fld1") : e.getValue().fld1;
 
-            if (keepBinary) {
-                assertEquals(i, (int)((BinaryObject)e.getValue()).field("fld1"));
-                assertEquals(i, (int)((BinaryObject)e.getValue()).field("fld2"));
-            }
-            else {
-                assertEquals(i, e.getValue().fld1);
-                assertEquals(i, e.getValue().fld2);
+        for (int i = 0; i < result.size(); i++) {
+            Cache.Entry<Integer, Person> e = result.get(i);
+
+            int key = left + i;
+
+            if (key >= 0) {
+                assertEquals(key, e.getKey().intValue());
+                assertEquals(key, (int)fldOneVal.apply(e));
             }
+            else
+                assertEquals(null, fldOneVal.apply(e));
         }
     }
 
@@ -336,19 +392,26 @@ public class ThinClientIndexQueryTest extends GridCommonAbstractTest {
             @QuerySqlField.Group(name = IDX_FLD1, order = 0),
             @QuerySqlField.Group(name = IDX_FLD1_FLD2, order = 0)
         })
-        final int fld1;
+        final Integer fld1;
 
         /** */
         @GridToStringInclude
         @QuerySqlField(orderedGroups = {
             @QuerySqlField.Group(name = IDX_FLD1_FLD2, order = 1)
         })
-        final int fld2;
+        final Integer fld2;
+
+        /** */
+        @QuerySqlField(orderedGroups = {
+            @QuerySqlField.Group(name = IDX_FLD3, order = 0)
+        })
+        IndexQueryAllTypesTest.PojoField fld3;
 
         /** */
-        Person(int fld1, int fld2) {
+        Person(Integer fld1, Integer fld2, IndexQueryAllTypesTest.PojoField fld3) {
             this.fld1 = fld1;
             this.fld2 = fld2;
+            this.fld3 = fld3;
         }
 
         /** {@inheritDoc} */