Mapper: Add byte type (8bit signed), closes elastic#620.

Author: kimchy

modules/elasticsearch/src/main/java/org/elasticsearch/common/Numbers.java

@@ -37,7 +37,7 @@ private Numbers() {
      * @return The int converted
      */
     public static short bytesToShort(byte[] arr) {
-        return (short) (((arr[2] & 0xff) << 8) | (arr[3] & 0xff));
+        return (short) (((arr[0] & 0xff) << 8) | (arr[1] & 0xff));
     }
 
     /**
@@ -105,8 +105,8 @@ public static byte[] intToBytes(int val) {
      */
     public static byte[] shortToBytes(int val) {
         byte[] arr = new byte[2];
-        arr[2] = (byte) (val >>> 8);
-        arr[3] = (byte) (val);
+        arr[0] = (byte) (val >>> 8);
+        arr[1] = (byte) (val);
         return arr;
     }
 

modules/elasticsearch/src/main/java/org/elasticsearch/common/xcontent/support/XContentMapValues.java

@@ -80,6 +80,13 @@ public static short nodeShortValue(Object node) {
         return Short.parseShort(node.toString());
     }
 
+    public static byte nodeByteValue(Object node) {
+        if (node instanceof Number) {
+            return ((Number) node).byteValue();
+        }
+        return Byte.parseByte(node.toString());
+    }
+
     public static long nodeLongValue(Object node) {
         if (node instanceof Number) {
             return ((Number) node).longValue();

modules/elasticsearch/src/main/java/org/elasticsearch/index/field/data/FieldDataType.java

@@ -22,6 +22,7 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.search.FieldComparatorSource;
 import org.elasticsearch.index.cache.field.data.FieldDataCache;
+import org.elasticsearch.index.field.data.bytes.ByteFieldDataType;
 import org.elasticsearch.index.field.data.doubles.DoubleFieldDataType;
 import org.elasticsearch.index.field.data.floats.FloatFieldDataType;
 import org.elasticsearch.index.field.data.ints.IntFieldDataType;
@@ -38,6 +39,7 @@ public interface FieldDataType<T extends FieldData> {
 
     public static final class DefaultTypes {
         public static final StringFieldDataType STRING = new StringFieldDataType();
+        public static final ByteFieldDataType BYTE = new ByteFieldDataType();
         public static final ShortFieldDataType SHORT = new ShortFieldDataType();
         public static final IntFieldDataType INT = new IntFieldDataType();
         public static final LongFieldDataType LONG = new LongFieldDataType();

modules/elasticsearch/src/main/java/org/elasticsearch/index/field/data/bytes/ByteDocFieldData.java

@@ -0,0 +1,40 @@
+/*
+ * Licensed to Elastic Search and Shay Banon under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. Elastic Search 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.elasticsearch.index.field.data.bytes;
+
+import org.elasticsearch.index.field.data.NumericDocFieldData;
+
+/**
+ * @author kimchy (shay.banon)
+ */
+public class ByteDocFieldData extends NumericDocFieldData<ByteFieldData> {
+
+    public ByteDocFieldData(ByteFieldData fieldData) {
+        super(fieldData);
+    }
+
+    public byte getValue() {
+        return fieldData.value(docId);
+    }
+
+    public byte[] getValues() {
+        return fieldData.values(docId);
+    }
+}

modules/elasticsearch/src/main/java/org/elasticsearch/index/field/data/bytes/ByteFieldData.java

@@ -0,0 +1,142 @@
+/*
+ * Licensed to Elastic Search and Shay Banon under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. Elastic Search 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.elasticsearch.index.field.data.bytes;
+
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.search.FieldCache;
+import org.elasticsearch.common.RamUsage;
+import org.elasticsearch.common.trove.TByteArrayList;
+import org.elasticsearch.index.field.data.FieldDataType;
+import org.elasticsearch.index.field.data.NumericFieldData;
+import org.elasticsearch.index.field.data.support.FieldDataLoader;
+
+import java.io.IOException;
+
+/**
+ * @author kimchy (shay.banon)
+ */
+public abstract class ByteFieldData extends NumericFieldData<ByteDocFieldData> {
+
+    static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
+
+    protected final byte[] values;
+
+    protected ByteFieldData(String fieldName, byte[] values) {
+        super(fieldName);
+        this.values = values;
+    }
+
+    @Override protected long computeSizeInBytes() {
+        return 1 * values.length + RamUsage.NUM_BYTES_ARRAY_HEADER;
+    }
+
+    abstract public byte value(int docId);
+
+    abstract public byte[] values(int docId);
+
+    @Override public ByteDocFieldData docFieldData(int docId) {
+        return super.docFieldData(docId);
+    }
+
+    @Override protected ByteDocFieldData createFieldData() {
+        return new ByteDocFieldData(this);
+    }
+
+    @Override public void forEachValue(StringValueProc proc) {
+        for (int i = 1; i < values.length; i++) {
+            proc.onValue(Byte.toString(values[i]));
+        }
+    }
+
+    @Override public String stringValue(int docId) {
+        return Byte.toString(value(docId));
+    }
+
+    @Override public byte byteValue(int docId) {
+        return value(docId);
+    }
+
+    @Override public short shortValue(int docId) {
+        return value(docId);
+    }
+
+    @Override public int intValue(int docId) {
+        return (int) value(docId);
+    }
+
+    @Override public long longValue(int docId) {
+        return (long) value(docId);
+    }
+
+    @Override public float floatValue(int docId) {
+        return (float) value(docId);
+    }
+
+    @Override public double doubleValue(int docId) {
+        return (double) value(docId);
+    }
+
+    @Override public FieldDataType type() {
+        return FieldDataType.DefaultTypes.BYTE;
+    }
+
+    public void forEachValue(ValueProc proc) {
+        for (int i = 1; i < values.length; i++) {
+            proc.onValue(values[i]);
+        }
+    }
+
+    public static interface ValueProc {
+        void onValue(byte value);
+    }
+
+    public abstract void forEachValueInDoc(int docId, ValueInDocProc proc);
+
+    public static interface ValueInDocProc {
+        void onValue(int docId, byte value);
+    }
+
+    public static ByteFieldData load(IndexReader reader, String field) throws IOException {
+        return FieldDataLoader.load(reader, field, new ByteTypeLoader());
+    }
+
+    static class ByteTypeLoader extends FieldDataLoader.FreqsTypeLoader<ByteFieldData> {
+
+        private final TByteArrayList terms = new TByteArrayList();
+
+        ByteTypeLoader() {
+            super();
+            // the first one indicates null value
+            terms.add((byte) 0);
+        }
+
+        @Override public void collectTerm(String term) {
+            terms.add((byte) FieldCache.NUMERIC_UTILS_INT_PARSER.parseInt(term));
+        }
+
+        @Override public ByteFieldData buildSingleValue(String field, int[] ordinals) {
+            return new SingleValueByteFieldData(field, ordinals, terms.toNativeArray());
+        }
+
+        @Override public ByteFieldData buildMultiValue(String field, int[][] ordinals) {
+            return new MultiValueByteFieldData(field, ordinals, terms.toNativeArray());
+        }
+    }
+}

modules/elasticsearch/src/main/java/org/elasticsearch/index/field/data/bytes/ByteFieldDataComparator.java

@@ -0,0 +1,63 @@
+/*
+ * Licensed to Elastic Search and Shay Banon under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. Elastic Search 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.elasticsearch.index.field.data.bytes;
+
+import org.elasticsearch.index.cache.field.data.FieldDataCache;
+import org.elasticsearch.index.field.data.FieldDataType;
+import org.elasticsearch.index.field.data.support.NumericFieldDataComparator;
+
+/**
+ * @author kimchy (shay.banon)
+ */
+// LUCENE MONITOR: Monitor against FieldComparator.Short
+public class ByteFieldDataComparator extends NumericFieldDataComparator {
+
+    private final byte[] values;
+    private short bottom;
+
+    public ByteFieldDataComparator(int numHits, String fieldName, FieldDataCache fieldDataCache) {
+        super(fieldName, fieldDataCache);
+        values = new byte[numHits];
+    }
+
+    @Override public FieldDataType fieldDataType() {
+        return FieldDataType.DefaultTypes.BYTE;
+    }
+
+    @Override public int compare(int slot1, int slot2) {
+        return values[slot1] - values[slot2];
+    }
+
+    @Override public int compareBottom(int doc) {
+        return bottom - currentFieldData.shortValue(doc);
+    }
+
+    @Override public void copy(int slot, int doc) {
+        values[slot] = currentFieldData.byteValue(doc);
+    }
+
+    @Override public void setBottom(final int bottom) {
+        this.bottom = values[bottom];
+    }
+
+    @Override public Comparable value(int slot) {
+        return Byte.valueOf(values[slot]);
+    }
+}

modules/elasticsearch/src/main/java/org/elasticsearch/index/field/data/bytes/ByteFieldDataType.java

@@ -0,0 +1,47 @@
+/*
+ * Licensed to Elastic Search and Shay Banon under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. Elastic Search 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.elasticsearch.index.field.data.bytes;
+
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.search.FieldComparator;
+import org.apache.lucene.search.FieldComparatorSource;
+import org.elasticsearch.index.cache.field.data.FieldDataCache;
+import org.elasticsearch.index.field.data.FieldDataType;
+import org.elasticsearch.index.field.data.shorts.ShortFieldDataComparator;
+
+import java.io.IOException;
+
+/**
+ * @author kimchy (shay.banon)
+ */
+public class ByteFieldDataType implements FieldDataType<ByteFieldData> {
+
+    @Override public FieldComparatorSource newFieldComparatorSource(final FieldDataCache cache) {
+        return new FieldComparatorSource() {
+            @Override public FieldComparator newComparator(String fieldname, int numHits, int sortPos, boolean reversed) throws IOException {
+                return new ShortFieldDataComparator(numHits, fieldname, cache);
+            }
+        };
+    }
+
+    @Override public ByteFieldData load(IndexReader reader, String fieldName) throws IOException {
+        return ByteFieldData.load(reader, fieldName);
+    }
+}