WIP First draft version field

Author: Christoph Büscher

server/src/internalClusterTest/java/org/elasticsearch/search/simple/SimpleSearchIT.java

@@ -44,6 +44,7 @@
 import static org.elasticsearch.index.query.QueryBuilders.matchAllQuery;
 import static org.elasticsearch.index.query.QueryBuilders.queryStringQuery;
 import static org.elasticsearch.index.query.QueryBuilders.rangeQuery;
+import static org.elasticsearch.index.query.QueryBuilders.termQuery;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertFailures;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertHitCount;
@@ -106,6 +107,95 @@ public void testSimpleIp() throws Exception {
         assertHitCount(search, 1L);
     }
 
+    public void testSimpleVersionRange() throws Exception {
+        prepareCreate("test").setSettings(Settings.builder().put(SETTING_NUMBER_OF_SHARDS, 1).put(SETTING_NUMBER_OF_REPLICAS, 0)).get();
+        ensureGreen();
+
+        client().admin().indices().preparePutMapping("test")
+
+                .setSource(XContentFactory.jsonBuilder().startObject().startObject("_doc").startObject("properties")
+                        .startObject("versionrange").field("type", "version_range").endObject()
+                        .endObject().endObject().endObject())
+                .get();
+
+        client().prepareIndex("test")
+            .setId("1")
+            .setSource("{\"versionrange\":{\"gte\":\"1.1.0.0.0.0.0.0.0.0.1\",\"lte\":\"2.2.3\"}}", XContentType.JSON)
+            .setRefreshPolicy(IMMEDIATE)
+                .get();
+
+        client().prepareIndex("test")
+        .setId("2")
+        .setSource("{\"versionrange\":{\"gte\":\"4.0.0-beta.2\",\"lte\":\"4.0.0-rc5\"}}", XContentType.JSON)
+        .setRefreshPolicy(IMMEDIATE)
+            .get();
+
+        client().prepareIndex("test")
+        .setId("3")
+        .setSource("{\"versionrange\":{\"gte\":\"8.0.0-alpha.1\",\"lte\":\"8.0.0-alpha.9\"}}", XContentType.JSON)
+        .setRefreshPolicy(IMMEDIATE)
+            .get();
+
+        client().prepareIndex("test")
+        .setId("4")
+        .setSource("{\"versionrange\":{\"gte\":\"8.0.0-alpha.0\",\"lte\":\"8.0.0-alpha.0.1\"}}", XContentType.JSON)
+        .setRefreshPolicy(IMMEDIATE)
+            .get();
+
+        SearchResponse search = client().prepareSearch()
+                .setQuery(rangeQuery("versionrange").gte("0.1.6").lte("2.7.0").relation("within"))
+                .get();
+
+        assertHitCount(search, 1L);
+
+        search = client().prepareSearch()
+            .setQuery(rangeQuery("versionrange").gte("1.1.6").lte("1.7.0").relation("contains"))
+            .get();
+
+        assertHitCount(search, 1L);
+
+        search = client().prepareSearch()
+            .setQuery(rangeQuery("versionrange").gte("1.1.6").lte("3.7.0").relation("contains"))
+            .get();
+
+        assertHitCount(search, 0L);
+
+
+        search = client().prepareSearch()
+            .setQuery(rangeQuery("versionrange").gte("1.8.6").lte("3.7.0").relation("intersects"))
+            .get();
+
+        assertHitCount(search, 1L);
+
+        search = client().prepareSearch()
+            .setQuery(rangeQuery("versionrange").gte("3.0.0").lte("4.0.0").relation("within"))
+            .get();
+
+        assertHitCount(search, 1L);
+
+        search = client().prepareSearch()
+            .setQuery(rangeQuery("versionrange").gte("3.0.0").lte("4.0.0-rc3").relation("within"))
+            .get();
+
+        assertHitCount(search, 0L);
+
+        search = client().prepareSearch()
+            .setQuery(termQuery("versionrange", "4.0.0-rc3"))
+            .get();
+
+        assertHitCount(search, 1L);
+
+        search = client().prepareSearch()
+            .setQuery(rangeQuery("versionrange").gte("8.0.0-alpha.2").lte("8.0.0-alpha.4").relation("contains"))
+            .get();
+
+        assertHitCount(search, 1L);
+    }
+
+
+
+
+
     public void testIpCidr() throws Exception {
         createIndex("test");
 

server/src/main/java/org/apache/lucene/document/VersionRangeField.java

@@ -0,0 +1,128 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch 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.lucene.document;
+
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanClause.Occur;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.FutureArrays;
+import org.elasticsearch.index.mapper.VersionEncoder;
+import org.elasticsearch.index.mapper.VersionEncoder.SortMode;
+
+public class VersionRangeField extends Field {
+
+    public static final int BYTES = 16;
+
+    private static final FieldType TYPE;
+    static {
+        TYPE = new FieldType();
+        TYPE.setDimensions(2, BYTES);
+        TYPE.freeze();
+    }
+
+    public VersionRangeField(String name, final BytesRef min, final BytesRef max) {
+        super(name, TYPE);
+        setRangeValues(min, max);
+    }
+
+    /**
+     * Change (or set) the min/max values of the field.
+     * @param min range min value
+     * @param max range max value
+     */
+    public void setRangeValues(BytesRef min, BytesRef max) {
+        final byte[] bytes;
+        if (fieldsData == null) {
+            bytes = new byte[BYTES * 2];
+            fieldsData = new BytesRef(bytes);
+        } else {
+            bytes = ((BytesRef) fieldsData).bytes;
+        }
+        encode(min, max, bytes);
+    }
+
+    /** encode the min/max range into the provided byte array */
+    private static void encode(final BytesRef min, final BytesRef max, final byte[] bytes) {
+        if (FutureArrays.compareUnsigned(min.bytes, 0, BYTES, max.bytes, 0, BYTES) > 0) {
+            throw new IllegalArgumentException("min value cannot be greater than max value for version field");
+        }
+        System.arraycopy(min.bytes, 0, bytes, 0, BYTES);
+        System.arraycopy(max.bytes, 0, bytes, BYTES, BYTES);
+    }
+
+    /** encode the min/max range and return the byte array */
+    private static byte[] encode(BytesRef min, BytesRef max) {
+      byte[] b = new byte[BYTES*2];
+      encode(min, max, b);
+      return b;
+    }
+
+    public static Query newIntersectsQuery(String field, BytesRef from, BytesRef to, Query dvQuery) {
+        return newRelationQuery(field, from, to, RangeFieldQuery.QueryType.INTERSECTS, dvQuery);
+    }
+
+    public static Query newWithinQuery(String field, BytesRef from, BytesRef to, Query dvQuery) {
+        return newRelationQuery(field, from, to, RangeFieldQuery.QueryType.WITHIN, dvQuery);
+    }
+
+    public static Query newContainsQuery(String field, BytesRef from, BytesRef to, Query dvQuery) {
+        return newRelationQuery(field, from, to, RangeFieldQuery.QueryType.CONTAINS, dvQuery);
+    }
+
+    /** helper method for creating the desired relational query */
+    private static Query newRelationQuery(
+        String field,
+        final BytesRef min,
+        final BytesRef max,
+        RangeFieldQuery.QueryType relation,
+        Query dvQuery
+    ) {
+        RangeFieldQuery rangeFieldQuery = new RangeFieldQuery(field, encode(min, max), 1, relation) {
+            @Override
+            protected String toString(byte[] ranges, int dimension) {
+                return VersionRangeField.toString(ranges, dimension);
+            }
+        };
+        BooleanQuery conjunctionQuery = new BooleanQuery.Builder().add(new BooleanClause(rangeFieldQuery, Occur.MUST))
+            .add(new BooleanClause(dvQuery, Occur.MUST)).build();
+        return conjunctionQuery;
+    }
+
+    /**
+     * Returns the String representation for the range at the given dimension
+     * @param ranges the encoded ranges, never null
+     * @param dimension the dimension of interest (not used for this field)
+     * @return The string representation for the range at the provided dimension
+     */
+    private static String toString(byte[] ranges, int dimension) {
+      byte[] min = new byte[BYTES];
+      System.arraycopy(ranges, 0, min, 0, BYTES);
+      byte[] max = new byte[BYTES];
+      System.arraycopy(ranges, BYTES, max, 0, BYTES);
+      return "["
+          + VersionEncoder.decodeVersion(new BytesRef(min), SortMode.SEMVER)
+          + " : "
+          + VersionEncoder.decodeVersion(new BytesRef(max), SortMode.SEMVER)
+          + "]";
+    }
+
+}

server/src/main/java/org/apache/lucene/queries/BinaryDocValuesRangeQuery.java

@@ -87,11 +87,13 @@ public boolean matches() throws IOException {
                         int offset = in.getPosition();
                         for (int i = 0; i < numRanges; i++) {
                             int length = lengthType.readLength(bytes, offset);
+                            offset += lengthType.advanceBy();
                             otherFrom.offset = offset;
                             otherFrom.length = length;
                             offset += length;
 
                             length = lengthType.readLength(bytes, offset);
+                            offset += lengthType.advanceBy();
                             otherTo.offset = offset;
                             otherTo.length = length;
                             offset += length;

server/src/main/java/org/elasticsearch/index/mapper/BinaryRangeUtil.java

@@ -130,11 +130,11 @@ static List<RangeFieldMapper.Range> decodeRanges(BytesRef encodedRanges, RangeTy
         for (int i = 0; i < numRanges; i++) {
             int length = lengthType.readLength(bytes, offset);
             Object from = decodeBytes.apply(bytes, offset, length);
-            offset += length;
+            offset += length + lengthType.advanceBy();
 
             length = lengthType.readLength(bytes, offset);
             Object to = decodeBytes.apply(bytes, offset, length);
-            offset += length;
+            offset += length + lengthType.advanceBy();
             // TODO: Support for exclusive ranges, pending resolution of #40601
             RangeFieldMapper.Range decodedRange = new RangeFieldMapper.Range(rangeType, from, to, true, true);
             ranges.add(decodedRange);

server/src/main/java/org/elasticsearch/index/mapper/RangeFieldMapper.java

@@ -489,6 +489,7 @@ public String toString() {
             sb.append(includeFrom ? '[' : '(');
             Object f = includeFrom || from.equals(type.minValue()) ? from : type.nextDown(from);
             Object t = includeTo || to.equals(type.maxValue()) ? to : type.nextUp(to);
+            // TODO also handle new VERSION range type, maybe move "toString" to RangeType?
             sb.append(type == RangeType.IP ? InetAddresses.toAddrString((InetAddress)f) : f.toString());
             sb.append(" : ");
             sb.append(type == RangeType.IP ? InetAddresses.toAddrString((InetAddress)t) : t.toString());