byte field data implementation

Author: uboness

src/main/java/org/elasticsearch/index/fielddata/IndexFieldDataService.java

@@ -47,6 +47,7 @@ public class IndexFieldDataService extends AbstractIndexComponent {
                 .put("string", new ConcreteBytesRefIndexFieldData.Builder())
                 .put("float", new FloatArrayIndexFieldData.Builder())
                 .put("double", new DoubleArrayIndexFieldData.Builder())
+                .put("byte", new ByteArrayIndexFieldData.Builder())
                 .put("short", new ShortArrayIndexFieldData.Builder())
                 .put("int", new IntArrayIndexFieldData.Builder())
                 .put("long", new LongArrayIndexFieldData.Builder())
@@ -57,6 +58,7 @@ public class IndexFieldDataService extends AbstractIndexComponent {
                 .put(Tuple.tuple("string", "concrete_bytes"), new ConcreteBytesRefIndexFieldData.Builder())
                 .put(Tuple.tuple("float", "array"), new FloatArrayIndexFieldData.Builder())
                 .put(Tuple.tuple("double", "array"), new DoubleArrayIndexFieldData.Builder())
+                .put(Tuple.tuple("byte", "array"), new ByteArrayIndexFieldData.Builder())
                 .put(Tuple.tuple("short", "array"), new ShortArrayIndexFieldData.Builder())
                 .put(Tuple.tuple("int", "array"), new IntArrayIndexFieldData.Builder())
                 .put(Tuple.tuple("long", "array"), new LongArrayIndexFieldData.Builder())

src/main/java/org/elasticsearch/index/fielddata/StringValues.java

@@ -100,6 +100,100 @@ public String next() {
         }
     }
 
+    public static class ByteBased implements StringValues {
+
+        private final ByteValues values;
+
+        private final StringArrayRef arrayScratch = new StringArrayRef(new String[1], 1);
+        private final ValuesIter valuesIter = new ValuesIter();
+        private final Proc proc = new Proc();
+
+        public ByteBased(ByteValues values) {
+            this.values = values;
+        }
+
+        @Override
+        public boolean isMultiValued() {
+            return values.isMultiValued();
+        }
+
+        @Override
+        public boolean hasValue(int docId) {
+            return values.hasValue(docId);
+        }
+
+        @Override
+        public String getValue(int docId) {
+            if (!values.hasValue(docId)) {
+                return null;
+            }
+            return Byte.toString(values.getValue(docId));
+        }
+
+        @Override
+        public StringArrayRef getValues(int docId) {
+            ByteArrayRef arrayRef = values.getValues(docId);
+            int size = arrayRef.size();
+            if (size == 0) return StringArrayRef.EMPTY;
+
+            arrayScratch.reset(size);
+            for (int i = arrayRef.start; i < arrayRef.end; i++) {
+                arrayScratch.values[arrayScratch.end++] = Byte.toString(arrayRef.values[i]);
+            }
+            return arrayScratch;
+        }
+
+        @Override
+        public Iter getIter(int docId) {
+            return valuesIter.reset(values.getIter(docId));
+        }
+
+        @Override
+        public void forEachValueInDoc(int docId, ValueInDocProc proc) {
+            values.forEachValueInDoc(docId, this.proc.reset(proc));
+        }
+
+        static class ValuesIter implements Iter {
+
+            private ByteValues.Iter iter;
+
+            private ValuesIter reset(ByteValues.Iter iter) {
+                this.iter = iter;
+                return this;
+            }
+
+            @Override
+            public boolean hasNext() {
+                return iter.hasNext();
+            }
+
+            @Override
+            public String next() {
+                return Byte.toString(iter.next());
+            }
+        }
+
+        static class Proc implements ByteValues.ValueInDocProc {
+
+            private ValueInDocProc proc;
+
+            private Proc reset(ValueInDocProc proc) {
+                this.proc = proc;
+                return this;
+            }
+
+            @Override
+            public void onValue(int docId, byte value) {
+                proc.onValue(docId, Byte.toString(value));
+            }
+
+            @Override
+            public void onMissing(int docId) {
+                proc.onMissing(docId);
+            }
+        }
+    }
+
     public static class ShortBased implements StringValues {
 
         private final ShortValues values;