add asEpochMs to date and timestamp vectors

js/src/Arrow.ts

@@ -139,14 +139,19 @@ export namespace view {
     export import NullView = view_.NullView;
     export import BoolView = view_.BoolView;
     export import ValidityView = view_.ValidityView;
+    export import PrimitiveView = view_.PrimitiveView;
     export import FixedSizeView = view_.FixedSizeView;
     export import Float16View = view_.Float16View;
     export import DateDayView = view_.DateDayView;
     export import DateMillisecondView = view_.DateMillisecondView;
+    export import TimestampDayView = view_.TimestampDayView;
+    export import TimestampSecondView = view_.TimestampSecondView;
+    export import TimestampMillisecondView = view_.TimestampMillisecondView;
+    export import TimestampMicrosecondView = view_.TimestampMicrosecondView;
+    export import TimestampNanosecondView = view_.TimestampNanosecondView;
     export import IntervalYearMonthView = view_.IntervalYearMonthView;
     export import IntervalYearView = view_.IntervalYearView;
     export import IntervalMonthView = view_.IntervalMonthView;
-    export import PrimitiveView = view_.PrimitiveView;
 }
 
 /* These exports are needed for the closure and uglify umd targets */

js/src/vector.ts

@@ -17,7 +17,7 @@
 
 import { Data, ChunkedData, FlatData, BoolData, FlatListData, NestedData } from './data';
 import { VisitorNode, TypeVisitor, VectorVisitor } from './visitor';
-import { DataType, ListType, FlatType, NestedType, FlatListType } from './type';
+import { DataType, ListType, FlatType, NestedType, FlatListType, TimeUnit } from './type';
 import { IterableArrayLike, Precision, DateUnit, IntervalUnit, UnionMode } from './type';
 
 export interface VectorLike { length: number; nullCount: number; }
@@ -157,7 +157,9 @@ import { ChunkedView } from './vector/chunked';
 import { DictionaryView } from './vector/dictionary';
 import { ListView, FixedSizeListView, BinaryView, Utf8View } from './vector/list';
 import { UnionView, DenseUnionView, NestedView, StructView, MapView } from './vector/nested';
-import { FlatView, NullView, BoolView, ValidityView, FixedSizeView, Float16View, DateDayView, DateMillisecondView, IntervalYearMonthView, PrimitiveView } from './vector/flat';
+import { FlatView, NullView, BoolView, ValidityView, PrimitiveView, FixedSizeView, Float16View } from './vector/flat';
+import { DateDayView, DateMillisecondView, IntervalYearMonthView } from './vector/flat';
+import { TimestampDayView, TimestampSecondView, TimestampMillisecondView, TimestampMicrosecondView, TimestampNanosecondView } from './vector/flat';
 import { packBools } from './util/bit';
 
 export class NullVector extends Vector<Null> {
@@ -242,6 +244,14 @@ export class DateVector extends FlatVector<Date_> {
     public highs(): IntVector<Int32> {
         return this.type.unit === DateUnit.DAY ? this.asInt32(0, 1) : this.asInt32(1, 2);
     }
+    public asEpochMilliseconds(): IntVector<Int32> {
+        let data = (this.data as FlatData<any>).clone(new Int32());
+        switch (this.type.unit) {
+            case DateUnit.DAY: return new IntVector(data, new TimestampDayView(data as any, 1) as any);
+            case DateUnit.MILLISECOND: return new IntVector(data, new TimestampMillisecondView(data as any, 2) as any);
+        }
+        throw new TypeError(`Unrecognized date unit "${DateUnit[this.type.unit]}"`);
+    }
 }
 
 export class DecimalVector extends FlatVector<Decimal> {
@@ -269,6 +279,16 @@ export class TimestampVector extends FlatVector<Timestamp> {
     constructor(data: Data<Timestamp>, view: View<Timestamp> = new FixedSizeView(data, 2)) {
         super(data, view);
     }
+    public asEpochMilliseconds(): IntVector<Int32> {
+        let data = (this.data as FlatData<any>).clone(new Int32());
+        switch (this.type.unit) {
+            case TimeUnit.SECOND: return new IntVector(data, new TimestampSecondView(data as any, 1) as any);
+            case TimeUnit.MILLISECOND: return new IntVector(data, new TimestampMillisecondView(data as any, 2) as any);
+            case TimeUnit.MICROSECOND: return new IntVector(data, new TimestampMicrosecondView(data as any, 2) as any);
+            case TimeUnit.NANOSECOND: return new IntVector(data, new TimestampNanosecondView(data as any, 2) as any);
+        }
+        throw new TypeError(`Unrecognized time unit "${TimeUnit[this.type.unit]}"`);
+    }
 }
 
 export class IntervalVector extends FlatVector<Interval> {

js/src/vector/chunked.ts

@@ -22,10 +22,6 @@ import { DataType, TypedArray, IterableArrayLike } from '../type';
 export class ChunkedView<T extends DataType> implements View<T> {
     public chunks: Vector<T>[];
     public offsets: Uint32Array;
-    // @ts-ignore
-    protected _length: number;
-    // @ts-ignore
-    protected _nullCount: number;
     constructor(data: ChunkedData<T>) {
         this.chunks = data.childVectors;
         this.offsets = data.childOffsets;

js/src/vector/flat.ts

@@ -18,13 +18,11 @@
 import { Data } from '../data';
 import { View } from '../vector';
 import { getBool, setBool, iterateBits } from '../util/bit';
-import { Bool, Float16, Date_, Interval, Null, Int32 } from '../type';
+import { Bool, Float16, Date_, Interval, Null, Int32, Timestamp } from '../type';
 import { DataType, FlatType, PrimitiveType, IterableArrayLike } from '../type';
 
 export class FlatView<T extends FlatType> implements View<T> {
-    // @ts-ignore
     public length: number;
-    // @ts-ignore
     public values: T['TArray'];
     constructor(data: Data<T>) {
         this.length = data.length;
@@ -51,7 +49,6 @@ export class FlatView<T extends FlatType> implements View<T> {
 }
 
 export class NullView implements View<Null> {
-    // @ts-ignore
     public length: number;
     constructor(data: Data<Null>) {
         this.length = data.length;
@@ -75,7 +72,6 @@ export class NullView implements View<Null> {
 }
 
 export class BoolView extends FlatView<Bool> {
-    // @ts-ignore
     protected offset: number;
     constructor(data: Data<Bool>) {
         super(data);
@@ -96,11 +92,8 @@ export class BoolView extends FlatView<Bool> {
 
 export class ValidityView<T extends DataType> implements View<T> {
     protected view: View<T>;
-    // @ts-ignore
     protected length: number;
-    // @ts-ignore
     protected offset: number;
-    // @ts-ignore
     protected nullBitmap: Uint8Array;
     constructor(data: Data<T>, view: View<T>) {
         this.view = view;
@@ -136,9 +129,7 @@ export class ValidityView<T extends DataType> implements View<T> {
 }
 
 export class PrimitiveView<T extends PrimitiveType> extends FlatView<T> {
-    // @ts-ignore
     public size: number;
-    // @ts-ignore
     public ArrayType: T['ArrayType'];
     constructor(data: Data<T>, size?: number) {
         super(data);
@@ -216,6 +207,59 @@ export class DateMillisecondView extends FixedSizeView<Date_> {
     }
 }
 
+export class TimestampDayView extends PrimitiveView<Timestamp> {
+    public toArray() { return [...this]; }
+    protected getValue(values: Int32Array, index: number, size: number): number {
+        return epochDaysToMs(values, index * size);
+    }
+    protected setValue(values: Int32Array, index: number, size: number, epochMs: number): void {
+        values[index * size] = (epochMs / 86400000) | 0;
+    }
+}
+
+export class TimestampSecondView extends PrimitiveView<Timestamp> {
+    public toArray() { return [...this]; }
+    protected getValue(values: Int32Array, index: number, size: number): number {
+        return epochSecondsToMs(values, index * size);
+    }
+    protected setValue(values: Int32Array, index: number, size: number, epochMs: number): void {
+        values[index * size] = (epochMs / 1000) | 0;
+    }
+}
+
+export class TimestampMillisecondView extends PrimitiveView<Timestamp> {
+    public toArray() { return [...this]; }
+    protected getValue(values: Int32Array, index: number, size: number): number {
+        return epochMillisecondsLongToMs(values, index * size);
+    }
+    protected setValue(values: Int32Array, index: number, size: number, epochMs: number): void {
+        values[index * size] = (epochMs % 4294967296) | 0;
+        values[index * size + size] = (epochMs / 4294967296) | 0;
+    }
+}
+
+export class TimestampMicrosecondView extends PrimitiveView<Timestamp> {
+    public toArray() { return [...this]; }
+    protected getValue(values: Int32Array, index: number, size: number): number {
+        return epochMicrosecondsLongToMs(values, index * size);
+    }
+    protected setValue(values: Int32Array, index: number, size: number, epochMs: number): void {
+        values[index * size] = ((epochMs / 1000) % 4294967296) | 0;
+        values[index * size + size] = ((epochMs / 1000) / 4294967296) | 0;
+    }
+}
+
+export class TimestampNanosecondView extends PrimitiveView<Timestamp> {
+    public toArray() { return [...this]; }
+    protected getValue(values: Int32Array, index: number, size: number): number {
+        return epochNanosecondsLongToMs(values, index * size);
+    }
+    protected setValue(values: Int32Array, index: number, size: number, epochMs: number): void {
+        values[index * size] = ((epochMs / 1000000) % 4294967296) | 0;
+        values[index * size + size] = ((epochMs / 1000000) / 4294967296) | 0;
+    }
+}
+
 export class IntervalYearMonthView extends PrimitiveView<Interval> {
     public toArray() { return [...this]; }
     protected getValue(values: Int32Array, index: number, size: number): Int32Array {

js/src/vector/list.ts

@@ -30,12 +30,9 @@ export const decodeUtf8 = ((decoder) =>
 )(new TextDecoder('utf-8'));
 
 export abstract class ListViewBase<T extends (ListType | FlatListType)> implements View<T> {
-    // @ts-ignore
-    protected length: number;
-    // @ts-ignore
-    protected values: T['TArray'];
-    // @ts-ignore
-    protected valueOffsets?: Int32Array;
+    public length: number;
+    public values: T['TArray'];
+    public valueOffsets?: Int32Array;
     constructor(data: Data<T>) {
         this.length = data.length;
         this.values = data.values;
@@ -86,7 +83,6 @@ export class ListView<T extends DataType> extends ListViewBase<List<T>> {
 }
 
 export class FixedSizeListView<T extends DataType> extends ListViewBase<FixedSizeList<T>> {
-    // @ts-ignore
     public size: number;
     constructor(data: Data<FixedSizeList<T>>) {
         super(data);

js/src/vector/nested.ts

@@ -21,13 +21,9 @@ import { View, Vector, createVector } from '../vector';
 import { DataType, NestedType, DenseUnion, SparseUnion, Struct, Map_ } from '../type';
 
 export abstract class NestedView<T extends NestedType> implements View<T> {
-    // @ts-ignore
     public length: number;
-    // @ts-ignore
     public numChildren: number;
-    // @ts-ignore
     public childData: Data<any>[];
-    // @ts-ignore
     protected children: Vector<any>[];
     constructor(data: Data<T>, children?: Vector<any>[]) {
         this.length = data.length;

js/src/vector/view.ts

@@ -2,4 +2,7 @@ export { ChunkedView } from './chunked';
 export { DictionaryView } from './dictionary';
 export { ListView, FixedSizeListView, BinaryView, Utf8View } from './list';
 export { UnionView, DenseUnionView, NestedView, StructView, MapView } from './nested';
-export { FlatView, NullView, BoolView, ValidityView, FixedSizeView, Float16View, DateDayView, DateMillisecondView, IntervalYearMonthView, IntervalYearView, IntervalMonthView, PrimitiveView } from './flat';
+export { FlatView, NullView, BoolView, ValidityView, PrimitiveView, FixedSizeView, Float16View } from './flat';
+export { DateDayView, DateMillisecondView } from './flat';
+export { IntervalYearMonthView, IntervalYearView, IntervalMonthView } from './flat';
+export { TimestampDayView, TimestampSecondView, TimestampMillisecondView, TimestampMicrosecondView, TimestampNanosecondView } from './flat';