]>
Commit | Line | Data |
---|---|---|
1d09f67e TL |
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 | } |