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} */