@haybarn/node-api 1.5.6-rc1 → 2.0.0-rc3

package/lib/vectors/DuckDBSmallIntVector.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBSmallIntVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBType_1 = require("../DuckDBType");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBSmallIntVector extends DuckDBVector_1.DuckDBVector {
+    items;
+    validity;
+    vector;
+    constructor(items, validity, vector) {
+        super();
+        this.items = items;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * Int16Array.BYTES_PER_ELEMENT);
+        const items = new Int16Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBSmallIntVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBSmallIntType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (!Number.isInteger(value)) {
+                throw new Error(`number is not an integer`);
+            }
+            if (value < -32768 || value > 32767) {
+                throw new Error(`number out of int16 range`);
+            }
+            this.items[itemIndex] = value;
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    flush() {
+        node_bindings_1.default.copy_data_to_vector(this.vector, 0, this.items.buffer, this.items.byteOffset, this.items.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBSmallIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBSmallIntVector = DuckDBSmallIntVector;

package/lib/vectors/DuckDBStructVector.d.ts

@@ -0,0 +1,35 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBStructType } from '../DuckDBType';
+import { DuckDBStructValue, DuckDBValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBStructVector extends DuckDBVector<DuckDBStructValue> {
+    private readonly structType;
+    private readonly _itemCount;
+    private readonly entryVectors;
+    private readonly validity;
+    private readonly vector;
+    constructor(structType: DuckDBStructType, itemCount: number, entryVectors: readonly DuckDBVector[], validity: DuckDBValidity, vector: duckdb.Vector);
+    static fromRawVector(structType: DuckDBStructType, vector: duckdb.Vector, itemCount: number): DuckDBStructVector;
+    get type(): DuckDBStructType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBStructValue | null;
+    getItemValue(itemIndex: number, entryIndex: number): DuckDBValue | null;
+    /**
+     * Returns the underlying child vector for entry `index`. Useful for
+     * callers that want direct access to a child's flat backing storage
+     * (e.g. when decoding a physical-layout type that overlays a STRUCT).
+     */
+    entryVectorAt(index: number): DuckDBVector;
+    /**
+     * Returns whether the top-level row at `itemIndex` is non-NULL. Useful
+     * for callers overlaying a logical type on a STRUCT vector that need to
+     * distinguish a SQL-NULL row from a row whose children just happen to
+     * be NULL.
+     */
+    isItemValid(itemIndex: number): boolean;
+    setItem(itemIndex: number, value: DuckDBStructValue | null): void;
+    setItemValue(itemIndex: number, entryIndex: number, value: DuckDBValue): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBStructVector;
+}

package/lib/vectors/DuckDBStructVector.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBStructVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const values_1 = require("../values");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+class DuckDBStructVector extends DuckDBVector_1.DuckDBVector {
+    structType;
+    _itemCount;
+    entryVectors;
+    validity;
+    vector;
+    constructor(structType, itemCount, entryVectors, validity, vector) {
+        super();
+        this.structType = structType;
+        this._itemCount = itemCount;
+        this.entryVectors = entryVectors;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(structType, vector, itemCount) {
+        const entryCount = structType.entryCount;
+        const entryVectors = [];
+        for (let i = 0; i < entryCount; i++) {
+            const child_vector = node_bindings_1.default.struct_vector_get_child(vector, i);
+            entryVectors.push(DuckDBVector_1.DuckDBVector.create(child_vector, itemCount, structType.entryTypes[i]));
+        }
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBStructVector(structType, itemCount, entryVectors, validity, vector);
+    }
+    get type() {
+        return this.structType;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        const entries = {};
+        const entryCount = this.structType.entryCount;
+        for (let i = 0; i < entryCount; i++) {
+            entries[this.structType.entryNames[i]] =
+                this.entryVectors[i].getItem(itemIndex);
+        }
+        return new values_1.DuckDBStructValue(entries);
+    }
+    getItemValue(itemIndex, entryIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        return this.entryVectors[entryIndex].getItem(itemIndex);
+    }
+    /**
+     * Returns the underlying child vector for entry `index`. Useful for
+     * callers that want direct access to a child's flat backing storage
+     * (e.g. when decoding a physical-layout type that overlays a STRUCT).
+     */
+    entryVectorAt(index) {
+        return this.entryVectors[index];
+    }
+    /**
+     * Returns whether the top-level row at `itemIndex` is non-NULL. Useful
+     * for callers overlaying a logical type on a STRUCT vector that need to
+     * distinguish a SQL-NULL row from a row whose children just happen to
+     * be NULL.
+     */
+    isItemValid(itemIndex) {
+        return this.validity.itemValid(itemIndex);
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            const entryCount = this.structType.entryCount;
+            for (let i = 0; i < entryCount; i++) {
+                this.entryVectors[i].setItem(itemIndex, value.entries[this.structType.entryNames[i]]);
+            }
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            const entryCount = this.structType.entryCount;
+            for (let i = 0; i < entryCount; i++) {
+                this.entryVectors[i].setItem(itemIndex, null);
+            }
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    setItemValue(itemIndex, entryIndex, value) {
+        return this.entryVectors[entryIndex].setItem(itemIndex, value);
+    }
+    flush() {
+        for (const entryVector of this.entryVectors) {
+            entryVector.flush();
+        }
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBStructVector(this.structType, length, this.entryVectors.map((entryVector) => entryVector.slice(offset, length)), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBStructVector = DuckDBStructVector;

package/lib/vectors/DuckDBTimeNSVector.d.ts

@@ -0,0 +1,18 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBTimeNSType } from '../DuckDBType';
+import { DuckDBTimeNSValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBTimeNSVector extends DuckDBVector<DuckDBTimeNSValue> {
+    private readonly items;
+    private readonly validity;
+    private readonly vector;
+    constructor(items: BigInt64Array, validity: DuckDBValidity, vector: duckdb.Vector);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimeNSVector;
+    get type(): DuckDBTimeNSType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBTimeNSValue | null;
+    setItem(itemIndex: number, value: DuckDBTimeNSValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBTimeNSVector;
+}

package/lib/vectors/DuckDBTimeNSVector.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimeNSVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBType_1 = require("../DuckDBType");
+const values_1 = require("../values");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBTimeNSVector extends DuckDBVector_1.DuckDBVector {
+    items;
+    validity;
+    vector;
+    constructor(items, validity, vector) {
+        super();
+        this.items = items;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimeNSVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimeNSType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimeNSValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (BigInt.asIntN(64, value.nanos) !== value.nanos) {
+                throw new Error(`bigint out of int64 range`);
+            }
+            this.items[itemIndex] = value.nanos;
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    flush() {
+        node_bindings_1.default.copy_data_to_vector(this.vector, 0, this.items.buffer, this.items.byteOffset, this.items.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBTimeNSVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBTimeNSVector = DuckDBTimeNSVector;

package/lib/vectors/DuckDBTimeTZVector.d.ts

@@ -0,0 +1,18 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBTimeTZType } from '../DuckDBType';
+import { DuckDBTimeTZValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBTimeTZVector extends DuckDBVector<DuckDBTimeTZValue> {
+    private readonly items;
+    private readonly validity;
+    private readonly vector;
+    constructor(items: BigUint64Array, validity: DuckDBValidity, vector: duckdb.Vector);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimeTZVector;
+    get type(): DuckDBTimeTZType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBTimeTZValue | null;
+    setItem(itemIndex: number, value: DuckDBTimeTZValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBTimeTZVector;
+}

package/lib/vectors/DuckDBTimeTZVector.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimeTZVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBType_1 = require("../DuckDBType");
+const values_1 = require("../values");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBTimeTZVector extends DuckDBVector_1.DuckDBVector {
+    items;
+    validity;
+    vector;
+    constructor(items, validity, vector) {
+        super();
+        this.items = items;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * BigUint64Array.BYTES_PER_ELEMENT);
+        const items = new BigUint64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimeTZVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimeTZType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? values_1.DuckDBTimeTZValue.fromBits(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (BigInt.asUintN(64, value.bits) !== value.bits) {
+                throw new Error(`bigint out of uint64 range`);
+            }
+            this.items[itemIndex] = value.bits;
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    flush() {
+        node_bindings_1.default.copy_data_to_vector(this.vector, 0, this.items.buffer, this.items.byteOffset, this.items.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBTimeTZVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBTimeTZVector = DuckDBTimeTZVector;

package/lib/vectors/DuckDBTimeVector.d.ts

@@ -0,0 +1,18 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBTimeType } from '../DuckDBType';
+import { DuckDBTimeValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBTimeVector extends DuckDBVector<DuckDBTimeValue> {
+    private readonly items;
+    private readonly validity;
+    private readonly vector;
+    constructor(items: BigInt64Array, validity: DuckDBValidity, vector: duckdb.Vector);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimeVector;
+    get type(): DuckDBTimeType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBTimeValue | null;
+    setItem(itemIndex: number, value: DuckDBTimeValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBTimeVector;
+}

package/lib/vectors/DuckDBTimeVector.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimeVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBType_1 = require("../DuckDBType");
+const values_1 = require("../values");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBTimeVector extends DuckDBVector_1.DuckDBVector {
+    items;
+    validity;
+    vector;
+    constructor(items, validity, vector) {
+        super();
+        this.items = items;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimeVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimeType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimeValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (BigInt.asIntN(64, value.micros) !== value.micros) {
+                throw new Error(`bigint out of int64 range`);
+            }
+            this.items[itemIndex] = value.micros;
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    flush() {
+        node_bindings_1.default.copy_data_to_vector(this.vector, 0, this.items.buffer, this.items.byteOffset, this.items.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBTimeVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBTimeVector = DuckDBTimeVector;

package/lib/vectors/DuckDBTimestampMillisecondsVector.d.ts

@@ -0,0 +1,18 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBTimestampMillisecondsType } from '../DuckDBType';
+import { DuckDBTimestampMillisecondsValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBTimestampMillisecondsVector extends DuckDBVector<DuckDBTimestampMillisecondsValue> {
+    private readonly items;
+    private readonly validity;
+    private readonly vector;
+    constructor(items: BigInt64Array, validity: DuckDBValidity, vector: duckdb.Vector);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimestampMillisecondsVector;
+    get type(): DuckDBTimestampMillisecondsType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBTimestampMillisecondsValue | null;
+    setItem(itemIndex: number, value: DuckDBTimestampMillisecondsValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBTimestampMillisecondsVector;
+}

package/lib/vectors/DuckDBTimestampMillisecondsVector.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimestampMillisecondsVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBType_1 = require("../DuckDBType");
+const values_1 = require("../values");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBTimestampMillisecondsVector extends DuckDBVector_1.DuckDBVector {
+    items;
+    validity;
+    vector;
+    constructor(items, validity, vector) {
+        super();
+        this.items = items;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimestampMillisecondsVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimestampMillisecondsType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimestampMillisecondsValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (BigInt.asIntN(64, value.millis) !== value.millis) {
+                throw new Error(`bigint out of int64 range`);
+            }
+            this.items[itemIndex] = value.millis;
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    flush() {
+        node_bindings_1.default.copy_data_to_vector(this.vector, 0, this.items.buffer, this.items.byteOffset, this.items.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBTimestampMillisecondsVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBTimestampMillisecondsVector = DuckDBTimestampMillisecondsVector;

package/lib/vectors/DuckDBTimestampNanosecondsVector.d.ts

@@ -0,0 +1,18 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBTimestampNanosecondsType } from '../DuckDBType';
+import { DuckDBTimestampNanosecondsValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBTimestampNanosecondsVector extends DuckDBVector<DuckDBTimestampNanosecondsValue> {
+    private readonly items;
+    private readonly validity;
+    private readonly vector;
+    constructor(items: BigInt64Array, validity: DuckDBValidity, vector: duckdb.Vector);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimestampNanosecondsVector;
+    get type(): DuckDBTimestampNanosecondsType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBTimestampNanosecondsValue | null;
+    setItem(itemIndex: number, value: DuckDBTimestampNanosecondsValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBTimestampNanosecondsVector;
+}

package/lib/vectors/DuckDBTimestampNanosecondsVector.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimestampNanosecondsVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBType_1 = require("../DuckDBType");
+const values_1 = require("../values");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBTimestampNanosecondsVector extends DuckDBVector_1.DuckDBVector {
+    items;
+    validity;
+    vector;
+    constructor(items, validity, vector) {
+        super();
+        this.items = items;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimestampNanosecondsVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimestampNanosecondsType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimestampNanosecondsValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (BigInt.asIntN(64, value.nanos) !== value.nanos) {
+                throw new Error(`bigint out of int64 range`);
+            }
+            this.items[itemIndex] = value.nanos;
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    flush() {
+        node_bindings_1.default.copy_data_to_vector(this.vector, 0, this.items.buffer, this.items.byteOffset, this.items.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBTimestampNanosecondsVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBTimestampNanosecondsVector = DuckDBTimestampNanosecondsVector;

package/lib/vectors/DuckDBTimestampSecondsVector.d.ts

@@ -0,0 +1,18 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBTimestampSecondsType } from '../DuckDBType';
+import { DuckDBTimestampSecondsValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBTimestampSecondsVector extends DuckDBVector<DuckDBTimestampSecondsValue> {
+    private readonly items;
+    private readonly validity;
+    private readonly vector;
+    constructor(items: BigInt64Array, validity: DuckDBValidity, vector: duckdb.Vector);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBTimestampSecondsVector;
+    get type(): DuckDBTimestampSecondsType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBTimestampSecondsValue | null;
+    setItem(itemIndex: number, value: DuckDBTimestampSecondsValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBTimestampSecondsVector;
+}