ARROW-676: move from MinorType to FieldType in ValueVectors to carry all the relevant type bits

java/tools/src/test/java/org/apache/arrow/tools/EchoServerTest.java

@@ -18,7 +18,19 @@
 
 package org.apache.arrow.tools;
 
-import com.google.common.collect.ImmutableList;
+import static java.util.Arrays.asList;
+import static org.apache.arrow.vector.types.Types.MinorType.TINYINT;
+import static org.apache.arrow.vector.types.Types.MinorType.VARCHAR;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
@@ -39,24 +51,15 @@
 import org.apache.arrow.vector.types.pojo.ArrowType.Int;
 import org.apache.arrow.vector.types.pojo.DictionaryEncoding;
 import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.types.pojo.FieldType;
 import org.apache.arrow.vector.types.pojo.Schema;
 import org.apache.arrow.vector.util.Text;
 import org.junit.AfterClass;
 import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
-import java.io.IOException;
-import java.net.Socket;
-import java.net.UnknownHostException;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import static java.util.Arrays.asList;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import com.google.common.collect.ImmutableList;
 
 public class EchoServerTest {
 
@@ -133,9 +136,12 @@ private void testEchoServer(int serverPort,
   public void basicTest() throws InterruptedException, IOException {
     BufferAllocator alloc = new RootAllocator(Long.MAX_VALUE);
 
-    Field field = new Field("testField", true, new ArrowType.Int(8, true), Collections
-        .<Field>emptyList());
-    NullableTinyIntVector vector = new NullableTinyIntVector("testField", alloc, null);
+    Field field = new Field(
+        "testField", true,
+        new ArrowType.Int(8, true),
+        Collections.<Field>emptyList());
+    NullableTinyIntVector vector =
+        new NullableTinyIntVector("testField", FieldType.nullable(TINYINT.getType()), alloc);
     Schema schema = new Schema(asList(field));
 
     // Try an empty stream, just the header.
@@ -152,9 +158,16 @@ public void basicTest() throws InterruptedException, IOException {
   public void testFlatDictionary() throws IOException {
     DictionaryEncoding writeEncoding = new DictionaryEncoding(1L, false, null);
     try (BufferAllocator allocator = new RootAllocator(Long.MAX_VALUE);
-         NullableIntVector writeVector = new NullableIntVector("varchar", allocator, writeEncoding);
-         NullableVarCharVector writeDictionaryVector = new NullableVarCharVector("dict",
-             allocator, null)) {
+        NullableIntVector writeVector =
+            new NullableIntVector(
+                "varchar",
+                new FieldType(true, MinorType.INT.getType(), writeEncoding),
+                allocator);
+        NullableVarCharVector writeDictionaryVector =
+            new NullableVarCharVector(
+                "dict",
+                FieldType.nullable(VARCHAR.getType()),
+                allocator)) {
       writeVector.allocateNewSafe();
       NullableIntVector.Mutator mutator = writeVector.getMutator();
       mutator.set(0, 0);
@@ -222,8 +235,8 @@ public void testFlatDictionary() throws IOException {
   public void testNestedDictionary() throws IOException {
     DictionaryEncoding writeEncoding = new DictionaryEncoding(2L, false, null);
     try (BufferAllocator allocator = new RootAllocator(Long.MAX_VALUE);
-         NullableVarCharVector writeDictionaryVector = new NullableVarCharVector("dictionary",
-             allocator, null);
+         NullableVarCharVector writeDictionaryVector =
+             new NullableVarCharVector("dictionary", FieldType.nullable(VARCHAR.getType()), allocator);
          ListVector writeVector = new ListVector("list", allocator, null, null)) {
 
       // data being written:
@@ -234,7 +247,7 @@ public void testNestedDictionary() throws IOException {
       writeDictionaryVector.getMutator().set(1, "bar".getBytes(StandardCharsets.UTF_8));
       writeDictionaryVector.getMutator().setValueCount(2);
 
-      writeVector.addOrGetVector(MinorType.INT, writeEncoding);
+      writeVector.addOrGetVector(new FieldType(true, MinorType.INT.getType(), writeEncoding));
       writeVector.allocateNew();
       UnionListWriter listWriter = new UnionListWriter(writeVector);
       listWriter.startList();

java/vector/src/main/codegen/data/ArrowTypes.tdd

@@ -14,59 +14,73 @@
   types: [
     {
       name: "Null",
-      fields: []
+      fields: [],
+      complex: false
     },
     {
       name: "Struct_",
-      fields: []
+      fields: [],
+      complex: true
     },
     {
       name: "List",
-      fields: []
+      fields: [],
+      complex: true
     },
     {
       name: "Union",
-      fields: [{name: "mode", type: short, valueType: UnionMode}, {name: "typeIds", type: "int[]"}]
+      fields: [{name: "mode", type: short, valueType: UnionMode}, {name: "typeIds", type: "int[]"}],
+      complex: true
     },
     {
       name: "Int",
-      fields: [{name: "bitWidth", type: int}, {name: "isSigned", type: boolean}]
+      fields: [{name: "bitWidth", type: int}, {name: "isSigned", type: boolean}],
+      complex: false
     },
     {
       name: "FloatingPoint",
-      fields: [{name: precision, type: short, valueType: FloatingPointPrecision}]
+      fields: [{name: precision, type: short, valueType: FloatingPointPrecision}],
+      complex: false
     },
     {
       name: "Utf8",
-      fields: []
+      fields: [],
+      complex: false
     },
     {
       name: "Binary",
-      fields: []
+      fields: [],
+      complex: false
     },
     {
       name: "Bool",
-      fields: []
+      fields: [],
+      complex: false
     },
     {
       name: "Decimal",
-      fields: [{name: "precision", type: int}, {name: "scale", type: int}]
+      fields: [{name: "precision", type: int}, {name: "scale", type: int}],
+      complex: false
     },
     {
       name: "Date",
       fields: [{name: "unit", type: short, valueType: DateUnit}]
+      complex: false
     },
     {
       name: "Time",
-      fields: [{name: "unit", type: short, valueType: TimeUnit}, {name: "bitWidth", type: int}]
+      fields: [{name: "unit", type: short, valueType: TimeUnit}, {name: "bitWidth", type: int}],
+      complex: false
     },
     {
       name: "Timestamp",
       fields: [{name: "unit", type: short, valueType: TimeUnit}, {name: "timezone", type: String}]
+      complex: false
     },
     {
       name: "Interval",
-      fields: [{name: "unit", type: short, valueType: IntervalUnit}]
+      fields: [{name: "unit", type: short, valueType: IntervalUnit}],
+      complex: false
     }
   ]
 }

java/vector/src/main/codegen/templates/ArrowType.java

@@ -50,13 +50,35 @@
 })
 public abstract class ArrowType {
 
+  public static abstract class PrimitiveType extends ArrowType {
+
+    private PrimitiveType() {
+    }
+
+    @Override
+    public boolean isComplex() {
+      return false;
+    }
+  }
+
+  public static abstract class ComplexType extends ArrowType {
+
+    private ComplexType() {
+    }
+
+    @Override
+    public boolean isComplex() {
+      return true;
+    }
+  }
+
   public static enum ArrowTypeID {
     <#list arrowTypes.types as type>
     <#assign name = type.name>
     ${name?remove_ending("_")}(Type.${name}),
     </#list>
     NONE(Type.NONE);
-  
+
     private final byte flatbufType;
 
     public byte getFlatbufID() {
@@ -70,6 +92,8 @@ private ArrowTypeID(byte flatbufType) {
 
   @JsonIgnore
   public abstract ArrowTypeID getTypeID();
+  @JsonIgnore
+  public abstract boolean isComplex();
   public abstract int getType(FlatBufferBuilder builder);
   public abstract <T> T accept(ArrowTypeVisitor<T> visitor);
 
@@ -87,21 +111,56 @@ public static interface ArrowTypeVisitor<T> {
   </#list>
   }
 
+  /**
+   * to visit the Complex ArrowTypes and bundle Primitive ones in one case
+   */
+  public static abstract class ComplexTypeVisitor<T> implements ArrowTypeVisitor<T> {
+
+    public T visit(PrimitiveType type) {
+      throw new UnsupportedOperationException("Unexpected Primitive type: " + type);
+    }
+
+  <#list arrowTypes.types as type>
+    <#if !type.complex>
+    public final T visit(${type.name?remove_ending("_")} type) {
+      return visit((PrimitiveType) type);
+    }
+    </#if>
+  </#list>
+  }
+
+  /**
+   * to visit the Primitive ArrowTypes and bundle Complex ones under one case
+   */
+  public static abstract class PrimitiveTypeVisitor<T> implements ArrowTypeVisitor<T> {
+
+    public T visit(ComplexType type) {
+      throw new UnsupportedOperationException("Unexpected Complex type: " + type);
+    }
+
+  <#list arrowTypes.types as type>
+    <#if type.complex>
+    public final T visit(${type.name?remove_ending("_")} type) {
+      return visit((ComplexType) type);
+    }
+    </#if>
+  </#list>
+  }
+
   <#list arrowTypes.types as type>
   <#assign name = type.name?remove_ending("_")>
   <#assign fields = type.fields>
-  public static class ${name} extends ArrowType {
+  public static class ${name} extends <#if type.complex>ComplexType<#else>PrimitiveType</#if> {
     public static final ArrowTypeID TYPE_TYPE = ArrowTypeID.${name};
     <#if type.fields?size == 0>
     public static final ${name} INSTANCE = new ${name}();
-    </#if>
+    <#else>
 
     <#list fields as field>
     <#assign fieldType = field.valueType!field.type>
     ${fieldType} ${field.name};
     </#list>
 
-    <#if type.fields?size != 0>
     @JsonCreator
     public ${type.name}(
     <#list type.fields as field>
@@ -113,6 +172,13 @@ public static class ${name} extends ArrowType {
       this.${field.name} = ${field.name};
       </#list>
     }
+
+    <#list fields as field>
+    <#assign fieldType = field.valueType!field.type>
+    public ${fieldType} get${field.name?cap_first}() {
+      return ${field.name};
+    }
+    </#list>
     </#if>
 
     @Override
@@ -143,13 +209,6 @@ public int getType(FlatBufferBuilder builder) {
       return org.apache.arrow.flatbuf.${type.name}.end${type.name}(builder);
     }
 
-    <#list fields as field>
-    <#assign fieldType = field.valueType!field.type>
-    public ${fieldType} get${field.name?cap_first}() {
-      return ${field.name};
-    }
-    </#list>
-
     public String toString() {
       return "${name}"
       <#if fields?size != 0>

java/vector/src/main/codegen/templates/MapWriters.java

@@ -64,7 +64,7 @@ public class ${mode}MapWriter extends AbstractFieldWriter {
         list(child.getName());
         break;
       case UNION:
-        UnionWriter writer = new UnionWriter(container.addOrGet(child.getName(), MinorType.UNION, UnionVector.class, null), getNullableMapWriterFactory());
+        UnionWriter writer = new UnionWriter(container.addOrGet(child.getName(), FieldType.nullable(MinorType.UNION.getType()), UnionVector.class), getNullableMapWriterFactory());
         fields.put(handleCase(child.getName()), writer);
         break;
 <#list vv.types as type><#list type.minor as minor>
@@ -113,7 +113,7 @@ public MapWriter map(String name) {
     FieldWriter writer = fields.get(finalName);
     if(writer == null){
       int vectorCount=container.size();
-      NullableMapVector vector = container.addOrGet(name, MinorType.MAP, NullableMapVector.class, null);
+      NullableMapVector vector = container.addOrGet(name, FieldType.nullable(MinorType.MAP.getType()), NullableMapVector.class);
       writer = new PromotableWriter(vector, container, getNullableMapWriterFactory());
       if(vectorCount != container.size()) {
         writer.allocate();
@@ -157,7 +157,7 @@ public ListWriter list(String name) {
     FieldWriter writer = fields.get(finalName);
     int vectorCount = container.size();
     if(writer == null) {
-      writer = new PromotableWriter(container.addOrGet(name, MinorType.LIST, ListVector.class, null), container, getNullableMapWriterFactory());
+      writer = new PromotableWriter(container.addOrGet(name, FieldType.nullable(MinorType.LIST.getType()), ListVector.class), container, getNullableMapWriterFactory());
       if (container.size() > vectorCount) {
         writer.allocate();
       }
@@ -222,7 +222,9 @@ public void end() {
     if(writer == null) {
       ValueVector vector;
       ValueVector currentVector = container.getChild(name);
-      ${vectName}Vector v = container.addOrGet(name, MinorType.${upperName}, ${vectName}Vector.class, null<#if minor.class == "Decimal"> , new int[] {precision, scale}</#if>);
+      ${vectName}Vector v = container.addOrGet(name, 
+          FieldType.nullable(<#if minor.class == "Decimal">new Decimal(precision, scale)<#else>MinorType.${upperName}.getType()</#if>),
+          ${vectName}Vector.class);
       writer = new PromotableWriter(v, container, getNullableMapWriterFactory());
       vector = v;
       if (currentVector == null || currentVector != vector) {