ceph/src/arrow/java/vector/src/main/java/org/apache/arrow/vector/types/Types.java

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one or more
   3  * contributor license agreements.  See the NOTICE file distributed with
   4  * this work for additional information regarding copyright ownership.
   5  * The ASF licenses this file to You under the Apache License, Version 2.0
   6  * (the "License"); you may not use this file except in compliance with
   7  * the License.  You may obtain a copy of the License at
   8  *
   9  *    http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package org.apache.arrow.vector.types;
  19
  20 import static org.apache.arrow.vector.types.FloatingPointPrecision.DOUBLE;
  21 import static org.apache.arrow.vector.types.FloatingPointPrecision.SINGLE;
  22 import static org.apache.arrow.vector.types.UnionMode.Dense;
  23 import static org.apache.arrow.vector.types.UnionMode.Sparse;
  24
  25 import org.apache.arrow.memory.BufferAllocator;
  26 import org.apache.arrow.vector.BigIntVector;
  27 import org.apache.arrow.vector.BitVector;
  28 import org.apache.arrow.vector.DateDayVector;
  29 import org.apache.arrow.vector.DateMilliVector;
  30 import org.apache.arrow.vector.Decimal256Vector;
  31 import org.apache.arrow.vector.DecimalVector;
  32 import org.apache.arrow.vector.DurationVector;
  33 import org.apache.arrow.vector.ExtensionTypeVector;
  34 import org.apache.arrow.vector.FieldVector;
  35 import org.apache.arrow.vector.FixedSizeBinaryVector;
  36 import org.apache.arrow.vector.Float4Vector;
  37 import org.apache.arrow.vector.Float8Vector;
  38 import org.apache.arrow.vector.IntVector;
  39 import org.apache.arrow.vector.IntervalDayVector;
  40 import org.apache.arrow.vector.IntervalMonthDayNanoVector;
  41 import org.apache.arrow.vector.IntervalYearVector;
  42 import org.apache.arrow.vector.LargeVarBinaryVector;
  43 import org.apache.arrow.vector.LargeVarCharVector;
  44 import org.apache.arrow.vector.NullVector;
  45 import org.apache.arrow.vector.SmallIntVector;
  46 import org.apache.arrow.vector.TimeMicroVector;
  47 import org.apache.arrow.vector.TimeMilliVector;
  48 import org.apache.arrow.vector.TimeNanoVector;
  49 import org.apache.arrow.vector.TimeSecVector;
  50 import org.apache.arrow.vector.TimeStampMicroTZVector;
  51 import org.apache.arrow.vector.TimeStampMicroVector;
  52 import org.apache.arrow.vector.TimeStampMilliTZVector;
  53 import org.apache.arrow.vector.TimeStampMilliVector;
  54 import org.apache.arrow.vector.TimeStampNanoTZVector;
  55 import org.apache.arrow.vector.TimeStampNanoVector;
  56 import org.apache.arrow.vector.TimeStampSecTZVector;
  57 import org.apache.arrow.vector.TimeStampSecVector;
  58 import org.apache.arrow.vector.TinyIntVector;
  59 import org.apache.arrow.vector.UInt1Vector;
  60 import org.apache.arrow.vector.UInt2Vector;
  61 import org.apache.arrow.vector.UInt4Vector;
  62 import org.apache.arrow.vector.UInt8Vector;
  63 import org.apache.arrow.vector.ValueVector;
  64 import org.apache.arrow.vector.VarBinaryVector;
  65 import org.apache.arrow.vector.VarCharVector;
  66 import org.apache.arrow.vector.complex.DenseUnionVector;
  67 import org.apache.arrow.vector.complex.FixedSizeListVector;
  68 import org.apache.arrow.vector.complex.LargeListVector;
  69 import org.apache.arrow.vector.complex.ListVector;
  70 import org.apache.arrow.vector.complex.MapVector;
  71 import org.apache.arrow.vector.complex.StructVector;
  72 import org.apache.arrow.vector.complex.UnionVector;
  73 import org.apache.arrow.vector.complex.impl.BigIntWriterImpl;
  74 import org.apache.arrow.vector.complex.impl.BitWriterImpl;
  75 import org.apache.arrow.vector.complex.impl.DateDayWriterImpl;
  76 import org.apache.arrow.vector.complex.impl.DateMilliWriterImpl;
  77 import org.apache.arrow.vector.complex.impl.Decimal256WriterImpl;
  78 import org.apache.arrow.vector.complex.impl.DecimalWriterImpl;
  79 import org.apache.arrow.vector.complex.impl.DenseUnionWriter;
  80 import org.apache.arrow.vector.complex.impl.DurationWriterImpl;
  81 import org.apache.arrow.vector.complex.impl.FixedSizeBinaryWriterImpl;
  82 import org.apache.arrow.vector.complex.impl.Float4WriterImpl;
  83 import org.apache.arrow.vector.complex.impl.Float8WriterImpl;
  84 import org.apache.arrow.vector.complex.impl.IntWriterImpl;
  85 import org.apache.arrow.vector.complex.impl.IntervalDayWriterImpl;
  86 import org.apache.arrow.vector.complex.impl.IntervalMonthDayNanoWriterImpl;
  87 import org.apache.arrow.vector.complex.impl.IntervalYearWriterImpl;
  88 import org.apache.arrow.vector.complex.impl.LargeVarBinaryWriterImpl;
  89 import org.apache.arrow.vector.complex.impl.LargeVarCharWriterImpl;
  90 import org.apache.arrow.vector.complex.impl.NullableStructWriter;
  91 import org.apache.arrow.vector.complex.impl.SmallIntWriterImpl;
  92 import org.apache.arrow.vector.complex.impl.TimeMicroWriterImpl;
  93 import org.apache.arrow.vector.complex.impl.TimeMilliWriterImpl;
  94 import org.apache.arrow.vector.complex.impl.TimeNanoWriterImpl;
  95 import org.apache.arrow.vector.complex.impl.TimeSecWriterImpl;
  96 import org.apache.arrow.vector.complex.impl.TimeStampMicroTZWriterImpl;
  97 import org.apache.arrow.vector.complex.impl.TimeStampMicroWriterImpl;
  98 import org.apache.arrow.vector.complex.impl.TimeStampMilliTZWriterImpl;
  99 import org.apache.arrow.vector.complex.impl.TimeStampMilliWriterImpl;
 100 import org.apache.arrow.vector.complex.impl.TimeStampNanoTZWriterImpl;
 101 import org.apache.arrow.vector.complex.impl.TimeStampNanoWriterImpl;
 102 import org.apache.arrow.vector.complex.impl.TimeStampSecTZWriterImpl;
 103 import org.apache.arrow.vector.complex.impl.TimeStampSecWriterImpl;
 104 import org.apache.arrow.vector.complex.impl.TinyIntWriterImpl;
 105 import org.apache.arrow.vector.complex.impl.UInt1WriterImpl;
 106 import org.apache.arrow.vector.complex.impl.UInt2WriterImpl;
 107 import org.apache.arrow.vector.complex.impl.UInt4WriterImpl;
 108 import org.apache.arrow.vector.complex.impl.UInt8WriterImpl;
 109 import org.apache.arrow.vector.complex.impl.UnionLargeListWriter;
 110 import org.apache.arrow.vector.complex.impl.UnionListWriter;
 111 import org.apache.arrow.vector.complex.impl.UnionWriter;
 112 import org.apache.arrow.vector.complex.impl.VarBinaryWriterImpl;
 113 import org.apache.arrow.vector.complex.impl.VarCharWriterImpl;
 114 import org.apache.arrow.vector.complex.writer.FieldWriter;
 115 import org.apache.arrow.vector.types.pojo.ArrowType;
 116 import org.apache.arrow.vector.types.pojo.ArrowType.ArrowTypeVisitor;
 117 import org.apache.arrow.vector.types.pojo.ArrowType.Binary;
 118 import org.apache.arrow.vector.types.pojo.ArrowType.Bool;
 119 import org.apache.arrow.vector.types.pojo.ArrowType.Date;
 120 import org.apache.arrow.vector.types.pojo.ArrowType.Decimal;
 121 import org.apache.arrow.vector.types.pojo.ArrowType.Duration;
 122 import org.apache.arrow.vector.types.pojo.ArrowType.ExtensionType;
 123 import org.apache.arrow.vector.types.pojo.ArrowType.FixedSizeBinary;
 124 import org.apache.arrow.vector.types.pojo.ArrowType.FixedSizeList;
 125 import org.apache.arrow.vector.types.pojo.ArrowType.FloatingPoint;
 126 import org.apache.arrow.vector.types.pojo.ArrowType.Int;
 127 import org.apache.arrow.vector.types.pojo.ArrowType.Interval;
 128 import org.apache.arrow.vector.types.pojo.ArrowType.LargeBinary;
 129 import org.apache.arrow.vector.types.pojo.ArrowType.LargeUtf8;
 130 import org.apache.arrow.vector.types.pojo.ArrowType.List;
 131 import org.apache.arrow.vector.types.pojo.ArrowType.Map;
 132 import org.apache.arrow.vector.types.pojo.ArrowType.Null;
 133 import org.apache.arrow.vector.types.pojo.ArrowType.Struct;
 134 import org.apache.arrow.vector.types.pojo.ArrowType.Time;
 135 import org.apache.arrow.vector.types.pojo.ArrowType.Timestamp;
 136 import org.apache.arrow.vector.types.pojo.ArrowType.Union;
 137 import org.apache.arrow.vector.types.pojo.ArrowType.Utf8;
 138 import org.apache.arrow.vector.types.pojo.Field;
 139 import org.apache.arrow.vector.types.pojo.FieldType;
 140 import org.apache.arrow.vector.util.CallBack;
 141
 142 /** An enumeration of all logical types supported by this library. */
 143 public class Types {
 144
 145   /**
 146    * The actual enumeration of types.
 147    */
 148   public enum MinorType {
 149     NULL(Null.INSTANCE) {
 150       @Override
 151       public FieldVector getNewVector(
 152           Field field,
 153           BufferAllocator allocator,
 154           CallBack schemaChangeCallback) {
 155         return new NullVector(field.getName());
 156       }
 157
 158       @Override
 159       public FieldWriter getNewFieldWriter(ValueVector vector) {
 160         return null;
 161       }
 162     },
 163     STRUCT(Struct.INSTANCE) {
 164       @Override
 165       public FieldVector getNewVector(
 166           Field field,
 167           BufferAllocator allocator,
 168           CallBack schemaChangeCallback) {
 169         return new StructVector(field.getName(), allocator, field.getFieldType(), schemaChangeCallback);
 170       }
 171
 172       @Override
 173       public FieldWriter getNewFieldWriter(ValueVector vector) {
 174         return new NullableStructWriter((StructVector) vector);
 175       }
 176     },
 177     TINYINT(new Int(8, true)) {
 178       @Override
 179       public FieldVector getNewVector(
 180           Field field,
 181           BufferAllocator allocator,
 182           CallBack schemaChangeCallback) {
 183         return new TinyIntVector(field, allocator);
 184       }
 185
 186       @Override
 187       public FieldWriter getNewFieldWriter(ValueVector vector) {
 188         return new TinyIntWriterImpl((TinyIntVector) vector);
 189       }
 190     },
 191     SMALLINT(new Int(16, true)) {
 192       @Override
 193       public FieldVector getNewVector(
 194           Field field,
 195           BufferAllocator allocator,
 196           CallBack schemaChangeCallback) {
 197         return new SmallIntVector(field, allocator);
 198       }
 199
 200       @Override
 201       public FieldWriter getNewFieldWriter(ValueVector vector) {
 202         return new SmallIntWriterImpl((SmallIntVector) vector);
 203       }
 204     },
 205     INT(new Int(32, true)) {
 206       @Override
 207       public FieldVector getNewVector(
 208           Field field,
 209           BufferAllocator allocator,
 210           CallBack schemaChangeCallback) {
 211         return new IntVector(field, allocator);
 212       }
 213
 214       @Override
 215       public FieldWriter getNewFieldWriter(ValueVector vector) {
 216         return new IntWriterImpl((IntVector) vector);
 217       }
 218     },
 219     BIGINT(new Int(64, true)) {
 220       @Override
 221       public FieldVector getNewVector(
 222           Field field,
 223           BufferAllocator allocator,
 224           CallBack schemaChangeCallback) {
 225         return new BigIntVector(field, allocator);
 226       }
 227
 228       @Override
 229       public FieldWriter getNewFieldWriter(ValueVector vector) {
 230         return new BigIntWriterImpl((BigIntVector) vector);
 231       }
 232     },
 233     DATEDAY(new Date(DateUnit.DAY)) {
 234       @Override
 235       public FieldVector getNewVector(
 236           Field field,
 237           BufferAllocator allocator,
 238           CallBack schemaChangeCallback) {
 239         return new DateDayVector(field, allocator);
 240       }
 241
 242       @Override
 243       public FieldWriter getNewFieldWriter(ValueVector vector) {
 244         return new DateDayWriterImpl((DateDayVector) vector);
 245       }
 246     },
 247     DATEMILLI(new Date(DateUnit.MILLISECOND)) {
 248       @Override
 249       public FieldVector getNewVector(
 250           Field field,
 251           BufferAllocator allocator,
 252           CallBack schemaChangeCallback) {
 253         return new DateMilliVector(field, allocator);
 254       }
 255
 256       @Override
 257       public FieldWriter getNewFieldWriter(ValueVector vector) {
 258         return new DateMilliWriterImpl((DateMilliVector) vector);
 259       }
 260     },
 261     TIMESEC(new Time(TimeUnit.SECOND, 32)) {
 262       @Override
 263       public FieldVector getNewVector(
 264           Field field,
 265           BufferAllocator allocator,
 266           CallBack schemaChangeCallback) {
 267         return new TimeSecVector(field, allocator);
 268       }
 269
 270       @Override
 271       public FieldWriter getNewFieldWriter(ValueVector vector) {
 272         return new TimeSecWriterImpl((TimeSecVector) vector);
 273       }
 274     },
 275     TIMEMILLI(new Time(TimeUnit.MILLISECOND, 32)) {
 276       @Override
 277       public FieldVector getNewVector(
 278           Field field,
 279           BufferAllocator allocator,
 280           CallBack schemaChangeCallback) {
 281         return new TimeMilliVector(field, allocator);
 282       }
 283
 284       @Override
 285       public FieldWriter getNewFieldWriter(ValueVector vector) {
 286         return new TimeMilliWriterImpl((TimeMilliVector) vector);
 287       }
 288     },
 289     TIMEMICRO(new Time(TimeUnit.MICROSECOND, 64)) {
 290       @Override
 291       public FieldVector getNewVector(
 292           Field field,
 293           BufferAllocator allocator,
 294           CallBack schemaChangeCallback) {
 295         return new TimeMicroVector(field, allocator);
 296       }
 297
 298       @Override
 299       public FieldWriter getNewFieldWriter(ValueVector vector) {
 300         return new TimeMicroWriterImpl((TimeMicroVector) vector);
 301       }
 302     },
 303     TIMENANO(new Time(TimeUnit.NANOSECOND, 64)) {
 304       @Override
 305       public FieldVector getNewVector(
 306           Field field,
 307           BufferAllocator allocator,
 308           CallBack schemaChangeCallback) {
 309         return new TimeNanoVector(field, allocator);
 310       }
 311
 312       @Override
 313       public FieldWriter getNewFieldWriter(ValueVector vector) {
 314         return new TimeNanoWriterImpl((TimeNanoVector) vector);
 315       }
 316     },
 317     // time in second from the Unix epoch, 00:00:00.000000 on 1 January 1970, UTC.
 318     TIMESTAMPSEC(new Timestamp(org.apache.arrow.vector.types.TimeUnit.SECOND, null)) {
 319       @Override
 320       public FieldVector getNewVector(
 321           Field field,
 322           BufferAllocator allocator,
 323           CallBack schemaChangeCallback) {
 324         return new TimeStampSecVector(field, allocator);
 325       }
 326
 327       @Override
 328       public FieldWriter getNewFieldWriter(ValueVector vector) {
 329         return new TimeStampSecWriterImpl((TimeStampSecVector) vector);
 330       }
 331     },
 332     // time in millis from the Unix epoch, 00:00:00.000 on 1 January 1970, UTC.
 333     TIMESTAMPMILLI(new Timestamp(org.apache.arrow.vector.types.TimeUnit.MILLISECOND, null)) {
 334       @Override
 335       public FieldVector getNewVector(
 336           Field field,
 337           BufferAllocator allocator,
 338           CallBack schemaChangeCallback) {
 339         return new TimeStampMilliVector(field, allocator);
 340       }
 341
 342       @Override
 343       public FieldWriter getNewFieldWriter(ValueVector vector) {
 344         return new TimeStampMilliWriterImpl((TimeStampMilliVector) vector);
 345       }
 346     },
 347     // time in microsecond from the Unix epoch, 00:00:00.000000 on 1 January 1970, UTC.
 348     TIMESTAMPMICRO(new Timestamp(org.apache.arrow.vector.types.TimeUnit.MICROSECOND, null)) {
 349       @Override
 350       public FieldVector getNewVector(
 351           Field field,
 352           BufferAllocator allocator,
 353           CallBack schemaChangeCallback) {
 354         return new TimeStampMicroVector(field, allocator);
 355       }
 356
 357       @Override
 358       public FieldWriter getNewFieldWriter(ValueVector vector) {
 359         return new TimeStampMicroWriterImpl((TimeStampMicroVector) vector);
 360       }
 361     },
 362     // time in nanosecond from the Unix epoch, 00:00:00.000000000 on 1 January 1970, UTC.
 363     TIMESTAMPNANO(new Timestamp(org.apache.arrow.vector.types.TimeUnit.NANOSECOND, null)) {
 364       @Override
 365       public FieldVector getNewVector(
 366           Field field,
 367           BufferAllocator allocator,
 368           CallBack schemaChangeCallback) {
 369         return new TimeStampNanoVector(field, allocator);
 370       }
 371
 372       @Override
 373       public FieldWriter getNewFieldWriter(ValueVector vector) {
 374         return new TimeStampNanoWriterImpl((TimeStampNanoVector) vector);
 375       }
 376     },
 377     INTERVALDAY(new Interval(IntervalUnit.DAY_TIME)) {
 378       @Override
 379       public FieldVector getNewVector(
 380           Field field,
 381           BufferAllocator allocator,
 382           CallBack schemaChangeCallback) {
 383         return new IntervalDayVector(field, allocator);
 384       }
 385
 386       @Override
 387       public FieldWriter getNewFieldWriter(ValueVector vector) {
 388         return new IntervalDayWriterImpl((IntervalDayVector) vector);
 389       }
 390     },
 391     INTERVALMONTHDAYNANO(new Interval(IntervalUnit.MONTH_DAY_NANO)) {
 392       @Override
 393       public FieldVector getNewVector(
 394           Field field,
 395           BufferAllocator allocator,
 396           CallBack schemaChangeCallback) {
 397         return new IntervalMonthDayNanoVector(field, allocator);
 398       }
 399
 400       @Override
 401       public FieldWriter getNewFieldWriter(ValueVector vector) {
 402         return new IntervalMonthDayNanoWriterImpl((IntervalMonthDayNanoVector) vector);
 403       }
 404     },
 405     DURATION(null) {
 406       @Override
 407       public FieldVector getNewVector(
 408           Field field,
 409           BufferAllocator allocator,
 410           CallBack schemaChangeCallback) {
 411         return new DurationVector(field, allocator);
 412       }
 413
 414       @Override
 415       public FieldWriter getNewFieldWriter(ValueVector vector) {
 416         return new DurationWriterImpl((DurationVector) vector);
 417       }
 418     },
 419
 420
 421     INTERVALYEAR(new Interval(IntervalUnit.YEAR_MONTH)) {
 422       @Override
 423       public FieldVector getNewVector(
 424           Field field,
 425           BufferAllocator allocator,
 426           CallBack schemaChangeCallback) {
 427         return new IntervalYearVector(field, allocator);
 428       }
 429
 430       @Override
 431       public FieldWriter getNewFieldWriter(ValueVector vector) {
 432         return new IntervalYearWriterImpl((IntervalYearVector) vector);
 433       }
 434     },
 435     //  4 byte ieee 754
 436     FLOAT4(new FloatingPoint(SINGLE)) {
 437       @Override
 438       public FieldVector getNewVector(
 439           Field field,
 440           BufferAllocator allocator,
 441           CallBack schemaChangeCallback) {
 442         return new Float4Vector(field, allocator);
 443       }
 444
 445       @Override
 446       public FieldWriter getNewFieldWriter(ValueVector vector) {
 447         return new Float4WriterImpl((Float4Vector) vector);
 448       }
 449     },
 450     //  8 byte ieee 754
 451     FLOAT8(new FloatingPoint(DOUBLE)) {
 452       @Override
 453       public FieldVector getNewVector(
 454           Field field,
 455           BufferAllocator allocator,
 456           CallBack schemaChangeCallback) {
 457         return new Float8Vector(field, allocator);
 458       }
 459
 460       @Override
 461       public FieldWriter getNewFieldWriter(ValueVector vector) {
 462         return new Float8WriterImpl((Float8Vector) vector);
 463       }
 464     },
 465     BIT(Bool.INSTANCE) {
 466       @Override
 467       public FieldVector getNewVector(
 468           Field field,
 469           BufferAllocator allocator,
 470           CallBack schemaChangeCallback) {
 471         return new BitVector(field, allocator);
 472       }
 473
 474       @Override
 475       public FieldWriter getNewFieldWriter(ValueVector vector) {
 476         return new BitWriterImpl((BitVector) vector);
 477       }
 478     },
 479     VARCHAR(Utf8.INSTANCE) {
 480       @Override
 481       public FieldVector getNewVector(
 482           Field field,
 483           BufferAllocator allocator,
 484           CallBack schemaChangeCallback) {
 485         return new VarCharVector(field, allocator);
 486       }
 487
 488       @Override
 489       public FieldWriter getNewFieldWriter(ValueVector vector) {
 490         return new VarCharWriterImpl((VarCharVector) vector);
 491       }
 492     },
 493     LARGEVARCHAR(LargeUtf8.INSTANCE) {
 494       @Override
 495       public FieldVector getNewVector(
 496           Field field,
 497           BufferAllocator allocator,
 498           CallBack schemaChangeCallback) {
 499         return new LargeVarCharVector(field, allocator);
 500       }
 501
 502       @Override
 503       public FieldWriter getNewFieldWriter(ValueVector vector) {
 504         return new LargeVarCharWriterImpl((LargeVarCharVector) vector);
 505       }
 506     },
 507     LARGEVARBINARY(LargeBinary.INSTANCE) {
 508       @Override
 509       public FieldVector getNewVector(
 510           Field field,
 511           BufferAllocator allocator,
 512           CallBack schemaChangeCallback) {
 513         return new LargeVarBinaryVector(field, allocator);
 514       }
 515
 516       @Override
 517       public FieldWriter getNewFieldWriter(ValueVector vector) {
 518         return new LargeVarBinaryWriterImpl((LargeVarBinaryVector) vector);
 519       }
 520     },
 521     VARBINARY(Binary.INSTANCE) {
 522       @Override
 523       public FieldVector getNewVector(
 524           Field field,
 525           BufferAllocator allocator,
 526           CallBack schemaChangeCallback) {
 527         return new VarBinaryVector(field, allocator);
 528       }
 529
 530       @Override
 531       public FieldWriter getNewFieldWriter(ValueVector vector) {
 532         return new VarBinaryWriterImpl((VarBinaryVector) vector);
 533       }
 534     },
 535     DECIMAL(null) {
 536       @Override
 537       public FieldVector getNewVector(
 538           Field field,
 539           BufferAllocator allocator,
 540           CallBack schemaChangeCallback) {
 541         return new DecimalVector(field, allocator);
 542       }
 543
 544       @Override
 545       public FieldWriter getNewFieldWriter(ValueVector vector) {
 546         return new DecimalWriterImpl((DecimalVector) vector);
 547       }
 548     },
 549     DECIMAL256(null) {
 550       @Override
 551       public FieldVector getNewVector(
 552           Field field,
 553           BufferAllocator allocator,
 554           CallBack schemaChangeCallback) {
 555         return new Decimal256Vector(field, allocator);
 556       }
 557
 558       @Override
 559       public FieldWriter getNewFieldWriter(ValueVector vector) {
 560         return new Decimal256WriterImpl((Decimal256Vector) vector);
 561       }
 562     },
 563     FIXEDSIZEBINARY(null) {
 564       @Override
 565       public FieldVector getNewVector(
 566           Field field,
 567           BufferAllocator allocator,
 568           CallBack schemaChangeCallback) {
 569         return new FixedSizeBinaryVector(field, allocator);
 570       }
 571
 572       @Override
 573       public FieldWriter getNewFieldWriter(ValueVector vector) {
 574         return new FixedSizeBinaryWriterImpl((FixedSizeBinaryVector) vector);
 575       }
 576     },
 577     UINT1(new Int(8, false)) {
 578       @Override
 579       public FieldVector getNewVector(
 580           Field field,
 581           BufferAllocator allocator,
 582           CallBack schemaChangeCallback) {
 583         return new UInt1Vector(field, allocator);
 584       }
 585
 586       @Override
 587       public FieldWriter getNewFieldWriter(ValueVector vector) {
 588         return new UInt1WriterImpl((UInt1Vector) vector);
 589       }
 590     },
 591     UINT2(new Int(16, false)) {
 592       @Override
 593       public FieldVector getNewVector(
 594           Field field,
 595           BufferAllocator allocator,
 596           CallBack schemaChangeCallback) {
 597         return new UInt2Vector(field, allocator);
 598       }
 599
 600       @Override
 601       public FieldWriter getNewFieldWriter(ValueVector vector) {
 602         return new UInt2WriterImpl((UInt2Vector) vector);
 603       }
 604     },
 605     UINT4(new Int(32, false)) {
 606       @Override
 607       public FieldVector getNewVector(
 608           Field field,
 609           BufferAllocator allocator,
 610           CallBack schemaChangeCallback) {
 611         return new UInt4Vector(field, allocator);
 612       }
 613
 614       @Override
 615       public FieldWriter getNewFieldWriter(ValueVector vector) {
 616         return new UInt4WriterImpl((UInt4Vector) vector);
 617       }
 618     },
 619     UINT8(new Int(64, false)) {
 620       @Override
 621       public FieldVector getNewVector(
 622           Field field,
 623           BufferAllocator allocator,
 624           CallBack schemaChangeCallback) {
 625         return new UInt8Vector(field, allocator);
 626       }
 627
 628       @Override
 629       public FieldWriter getNewFieldWriter(ValueVector vector) {
 630         return new UInt8WriterImpl((UInt8Vector) vector);
 631       }
 632     },
 633     LIST(List.INSTANCE) {
 634       @Override
 635       public FieldVector getNewVector(
 636           Field field,
 637           BufferAllocator allocator,
 638           CallBack schemaChangeCallback) {
 639         return new ListVector(field.getName(), allocator, field.getFieldType(), schemaChangeCallback);
 640       }
 641
 642       @Override
 643       public FieldWriter getNewFieldWriter(ValueVector vector) {
 644         return new UnionListWriter((ListVector) vector);
 645       }
 646     },
 647     LARGELIST(ArrowType.LargeList.INSTANCE) {
 648       @Override
 649       public FieldVector getNewVector(Field field, BufferAllocator allocator, CallBack schemaChangeCallback) {
 650         return new LargeListVector(field.getName(), allocator, field.getFieldType(), schemaChangeCallback);
 651       }
 652
 653       @Override
 654       public FieldWriter getNewFieldWriter(ValueVector vector) {
 655         return new UnionLargeListWriter((LargeListVector) vector);
 656       }
 657     },
 658     FIXED_SIZE_LIST(null) {
 659       @Override
 660       public FieldVector getNewVector(
 661           Field field,
 662           BufferAllocator allocator,
 663           CallBack schemaChangeCallback) {
 664         return new FixedSizeListVector(field.getName(), allocator, field.getFieldType(), schemaChangeCallback);
 665       }
 666
 667       @Override
 668       public FieldWriter getNewFieldWriter(ValueVector vector) {
 669         throw new UnsupportedOperationException("FieldWriter not implemented for FixedSizeList " +
 670           "type");
 671       }
 672     },
 673     UNION(new Union(Sparse, null)) {
 674       @Override
 675       public FieldVector getNewVector(
 676           Field field,
 677           BufferAllocator allocator,
 678           CallBack schemaChangeCallback) {
 679         if (field.getFieldType().getDictionary() != null) {
 680           throw new UnsupportedOperationException("Dictionary encoding not supported for complex " +
 681               "types");
 682         }
 683         return new UnionVector(field.getName(), allocator, field.getFieldType(), schemaChangeCallback);
 684       }
 685
 686       @Override
 687       public FieldWriter getNewFieldWriter(ValueVector vector) {
 688         return new UnionWriter((UnionVector) vector);
 689       }
 690     },
 691     DENSEUNION(new Union(Dense, null)) {
 692       @Override
 693       public FieldVector getNewVector(
 694           Field field,
 695           BufferAllocator allocator,
 696           CallBack schemaChangeCallback) {
 697         if (field.getFieldType().getDictionary() != null) {
 698           throw new UnsupportedOperationException("Dictionary encoding not supported for complex " +
 699               "types");
 700         }
 701         return new DenseUnionVector(field.getName(), allocator, field.getFieldType(), schemaChangeCallback);
 702       }
 703
 704       @Override
 705       public FieldWriter getNewFieldWriter(ValueVector vector) {
 706         return new DenseUnionWriter((DenseUnionVector) vector);
 707       }
 708     },
 709     MAP(null) {
 710       @Override
 711       public FieldVector getNewVector(
 712           Field field,
 713           BufferAllocator allocator,
 714           CallBack schemaChangeCallback) {
 715         return new MapVector(field.getName(), allocator, field.getFieldType(), schemaChangeCallback);
 716       }
 717
 718       @Override
 719       public FieldWriter getNewFieldWriter(ValueVector vector) {
 720         return new UnionListWriter((MapVector) vector);
 721       }
 722     },
 723     TIMESTAMPSECTZ(null) {
 724       @Override
 725       public FieldVector getNewVector(
 726           Field field,
 727           BufferAllocator allocator,
 728           CallBack schemaChangeCallback) {
 729         return new TimeStampSecTZVector(field, allocator);
 730       }
 731
 732       @Override
 733       public FieldWriter getNewFieldWriter(ValueVector vector) {
 734         return new TimeStampSecTZWriterImpl((TimeStampSecTZVector) vector);
 735       }
 736     },
 737     TIMESTAMPMILLITZ(null) {
 738       @Override
 739       public FieldVector getNewVector(
 740           Field field,
 741           BufferAllocator allocator,
 742           CallBack schemaChangeCallback) {
 743         return new TimeStampMilliTZVector(field, allocator);
 744       }
 745
 746       @Override
 747       public FieldWriter getNewFieldWriter(ValueVector vector) {
 748         return new TimeStampMilliTZWriterImpl((TimeStampMilliTZVector) vector);
 749       }
 750     },
 751     TIMESTAMPMICROTZ(null) {
 752       @Override
 753       public FieldVector getNewVector(
 754           Field field,
 755           BufferAllocator allocator,
 756           CallBack schemaChangeCallback) {
 757         return new TimeStampMicroTZVector(field, allocator);
 758       }
 759
 760       @Override
 761       public FieldWriter getNewFieldWriter(ValueVector vector) {
 762         return new TimeStampMicroTZWriterImpl((TimeStampMicroTZVector) vector);
 763       }
 764     },
 765     TIMESTAMPNANOTZ(null) {
 766       @Override
 767       public FieldVector getNewVector(
 768           Field field,
 769           BufferAllocator allocator,
 770           CallBack schemaChangeCallback) {
 771         return new TimeStampNanoTZVector(field, allocator);
 772       }
 773
 774       @Override
 775       public FieldWriter getNewFieldWriter(ValueVector vector) {
 776         return new TimeStampNanoTZWriterImpl((TimeStampNanoTZVector) vector);
 777       }
 778     },
 779     EXTENSIONTYPE(null) {
 780       @Override
 781       public FieldVector getNewVector(
 782           Field field,
 783           BufferAllocator allocator,
 784           CallBack schemaChangeCallback) {
 785         return ((ExtensionType) field.getFieldType().getType()).getNewVector(field.getName(),
 786             field.getFieldType(), allocator);
 787       }
 788
 789       @Override
 790       public FieldWriter getNewFieldWriter(ValueVector vector) {
 791         return ((ExtensionTypeVector) vector).getUnderlyingVector().getMinorType().getNewFieldWriter(vector);
 792       }
 793     },
 794     ;
 795
 796     private final ArrowType type;
 797
 798     MinorType(ArrowType type) {
 799       this.type = type;
 800     }
 801
 802     /**
 803      * Returns the {@link ArrowType} equivalent of this type.
 804      */
 805     public final ArrowType getType() {
 806       if (type == null) {
 807         throw new UnsupportedOperationException("Cannot get simple type for type " + name());
 808       }
 809       return type;
 810     }
 811
 812     /** Constructs a new vector for the given type. */
 813     public final FieldVector getNewVector(
 814         String name,
 815         FieldType fieldType,
 816         BufferAllocator allocator,
 817         CallBack schemaChangeCallback) {
 818       return getNewVector(new Field(name, fieldType, null), allocator, schemaChangeCallback);
 819     }
 820
 821     /** Constructs a new vector for the given type. */
 822     public abstract FieldVector getNewVector(
 823         Field field,
 824         BufferAllocator allocator,
 825         CallBack schemaChangeCallback);
 826
 827     public abstract FieldWriter getNewFieldWriter(ValueVector vector);
 828   }
 829
 830   /**
 831    * Maps the ArrowType to the java implementations MinorType.
 832    */
 833   public static MinorType getMinorTypeForArrowType(ArrowType arrowType) {
 834     return arrowType.accept(new ArrowTypeVisitor<MinorType>() {
 835       @Override
 836       public MinorType visit(Null type) {
 837         return MinorType.NULL;
 838       }
 839
 840       @Override
 841       public MinorType visit(Struct type) {
 842         return MinorType.STRUCT;
 843       }
 844
 845       @Override
 846       public MinorType visit(List type) {
 847         return MinorType.LIST;
 848       }
 849
 850       @Override
 851       public MinorType visit(FixedSizeList type) {
 852         return MinorType.FIXED_SIZE_LIST;
 853       }
 854
 855       @Override
 856       public MinorType visit(Union type) {
 857         switch (type.getMode()) {
 858           case Sparse:
 859             return MinorType.UNION;
 860           case Dense:
 861             return MinorType.DENSEUNION;
 862           default:
 863             throw new IllegalArgumentException("only Dense or Sparse unions supported: " + type);
 864         }
 865       }
 866
 867       @Override
 868       public MinorType visit(Map type) {
 869         return MinorType.MAP;
 870       }
 871
 872       @Override
 873       public MinorType visit(ArrowType.LargeList type) {
 874         return MinorType.LARGELIST;
 875       }
 876
 877       @Override
 878       public MinorType visit(Int type) {
 879         switch (type.getBitWidth()) {
 880           case 8:
 881             return type.getIsSigned() ? MinorType.TINYINT : MinorType.UINT1;
 882           case 16:
 883             return type.getIsSigned() ? MinorType.SMALLINT : MinorType.UINT2;
 884           case 32:
 885             return type.getIsSigned() ? MinorType.INT : MinorType.UINT4;
 886           case 64:
 887             return type.getIsSigned() ? MinorType.BIGINT : MinorType.UINT8;
 888           default:
 889             throw new IllegalArgumentException("only 8, 16, 32, 64 supported: " + type);
 890         }
 891       }
 892
 893       @Override
 894       public MinorType visit(FloatingPoint type) {
 895         switch (type.getPrecision()) {
 896           case HALF:
 897             throw new UnsupportedOperationException("NYI: " + type);
 898           case SINGLE:
 899             return MinorType.FLOAT4;
 900           case DOUBLE:
 901             return MinorType.FLOAT8;
 902           default:
 903             throw new IllegalArgumentException("unknown precision: " + type);
 904         }
 905       }
 906
 907       @Override
 908       public MinorType visit(Utf8 type) {
 909         return MinorType.VARCHAR;
 910       }
 911
 912       @Override
 913       public Types.MinorType visit(LargeUtf8 type) {
 914         return MinorType.LARGEVARCHAR;
 915       }
 916
 917       @Override
 918       public MinorType visit(Binary type) {
 919         return MinorType.VARBINARY;
 920       }
 921
 922       @Override
 923       public MinorType visit(LargeBinary type) {
 924         return MinorType.LARGEVARBINARY;
 925       }
 926
 927       @Override
 928       public MinorType visit(Bool type) {
 929         return MinorType.BIT;
 930       }
 931
 932       @Override
 933       public MinorType visit(Decimal type) {
 934         if (type.getBitWidth() == 256) {
 935           return MinorType.DECIMAL256;
 936         }
 937         return MinorType.DECIMAL;
 938       }
 939
 940       @Override
 941       public MinorType visit(FixedSizeBinary type) {
 942         return MinorType.FIXEDSIZEBINARY;
 943       }
 944
 945       @Override
 946       public MinorType visit(Date type) {
 947         switch (type.getUnit()) {
 948           case DAY:
 949             return MinorType.DATEDAY;
 950           case MILLISECOND:
 951             return MinorType.DATEMILLI;
 952           default:
 953             throw new IllegalArgumentException("unknown unit: " + type);
 954         }
 955       }
 956
 957       @Override
 958       public MinorType visit(Time type) {
 959         switch (type.getUnit()) {
 960           case SECOND:
 961             return MinorType.TIMESEC;
 962           case MILLISECOND:
 963             return MinorType.TIMEMILLI;
 964           case MICROSECOND:
 965             return MinorType.TIMEMICRO;
 966           case NANOSECOND:
 967             return MinorType.TIMENANO;
 968           default:
 969             throw new IllegalArgumentException("unknown unit: " + type);
 970         }
 971       }
 972
 973       @Override
 974       public MinorType visit(Timestamp type) {
 975         String tz = type.getTimezone();
 976         switch (type.getUnit()) {
 977           case SECOND:
 978             return tz == null ? MinorType.TIMESTAMPSEC : MinorType.TIMESTAMPSECTZ;
 979           case MILLISECOND:
 980             return tz == null ? MinorType.TIMESTAMPMILLI : MinorType.TIMESTAMPMILLITZ;
 981           case MICROSECOND:
 982             return tz == null ? MinorType.TIMESTAMPMICRO : MinorType.TIMESTAMPMICROTZ;
 983           case NANOSECOND:
 984             return tz == null ? MinorType.TIMESTAMPNANO : MinorType.TIMESTAMPNANOTZ;
 985           default:
 986             throw new IllegalArgumentException("unknown unit: " + type);
 987         }
 988       }
 989
 990       @Override
 991       public MinorType visit(Interval type) {
 992         switch (type.getUnit()) {
 993           case DAY_TIME:
 994             return MinorType.INTERVALDAY;
 995           case YEAR_MONTH:
 996             return MinorType.INTERVALYEAR;
 997           case MONTH_DAY_NANO:
 998             return MinorType.INTERVALMONTHDAYNANO;
 999           default:
1000             throw new IllegalArgumentException("unknown unit: " + type);
1001         }
1002       }
1003
1004       @Override
1005       public MinorType visit(Duration type) {
1006         return MinorType.DURATION;
1007       }
1008
1009       @Override
1010       public MinorType visit(ExtensionType type) {
1011         return MinorType.EXTENSIONTYPE;
1012       }
1013     });
1014   }
1015
1016 }