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

package/lib/vectors/DuckDBBigIntVector.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBBigIntVector = 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 DuckDBBigIntVector 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 DuckDBBigIntVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBBigIntType.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 (BigInt.asIntN(64, value) !== value) {
+                throw new Error(`bigint out of int64 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 DuckDBBigIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBBigIntVector = DuckDBBigIntVector;

package/lib/vectors/DuckDBBigNumVector.d.ts

@@ -0,0 +1,21 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBBigNumType } from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBBigNumVector extends DuckDBVector<bigint> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly vector;
+    private readonly itemOffset;
+    private readonly _itemCount;
+    private readonly itemCache;
+    private readonly itemCacheDirty;
+    constructor(dataView: DataView, validity: DuckDBValidity, vector: duckdb.Vector, itemOffset: number, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBBigNumVector;
+    get type(): DuckDBBigNumType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    setItem(itemIndex: number, value: bigint | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBBigNumVector;
+}

package/lib/vectors/DuckDBBigNumVector.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBBigNumVector = 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 DuckDBBigNumVector extends DuckDBVector_1.DuckDBVector {
+    dataView;
+    validity;
+    vector;
+    itemOffset;
+    _itemCount;
+    itemCache;
+    itemCacheDirty;
+    constructor(dataView, validity, vector, itemOffset, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this.vector = vector;
+        this.itemOffset = itemOffset;
+        this._itemCount = itemCount;
+        this.itemCache = [];
+        this.itemCacheDirty = [];
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBBigNumVector(dataView, validity, vector, 0, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBBigNumType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        const bytes = (0, dataAccessors_1.getStringBytes)(this.dataView, itemIndex * 16);
+        return bytes ? (0, dataAccessors_1.getBigNumFromBytes)(bytes) : null;
+    }
+    setItem(itemIndex, value) {
+        this.itemCache[itemIndex] = value;
+        this.validity.setItemValid(itemIndex, value != null);
+        this.itemCacheDirty[itemIndex] = true;
+    }
+    flush() {
+        for (let itemIndex = 0; itemIndex < this._itemCount; itemIndex++) {
+            if (this.itemCacheDirty[itemIndex]) {
+                const cachedItem = this.itemCache[itemIndex];
+                if (cachedItem !== undefined && cachedItem !== null) {
+                    node_bindings_1.default.vector_assign_string_element_len(this.vector, this.itemOffset + itemIndex, (0, dataAccessors_1.getBytesFromBigNum)(cachedItem));
+                }
+                this.itemCacheDirty[itemIndex] = false;
+            }
+        }
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBBigNumVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, offset, length);
+    }
+}
+exports.DuckDBBigNumVector = DuckDBBigNumVector;

package/lib/vectors/DuckDBBitVector.d.ts

@@ -0,0 +1,22 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBBitType } from '../DuckDBType';
+import { DuckDBBitValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBBitVector extends DuckDBVector<DuckDBBitValue> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly vector;
+    private readonly itemOffset;
+    private readonly _itemCount;
+    private readonly itemCache;
+    private readonly itemCacheDirty;
+    constructor(dataView: DataView, validity: DuckDBValidity, vector: duckdb.Vector, itemOffset: number, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBBitVector;
+    get type(): DuckDBBitType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBBitValue | null;
+    setItem(itemIndex: number, value: DuckDBBitValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBBitVector;
+}

package/lib/vectors/DuckDBBitVector.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBBitVector = 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 DuckDBBitVector extends DuckDBVector_1.DuckDBVector {
+    dataView;
+    validity;
+    vector;
+    itemOffset;
+    _itemCount;
+    itemCache;
+    itemCacheDirty;
+    constructor(dataView, validity, vector, itemOffset, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this.vector = vector;
+        this.itemOffset = itemOffset;
+        this._itemCount = itemCount;
+        this.itemCache = [];
+        this.itemCacheDirty = [];
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBBitVector(dataView, validity, vector, 0, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBBitType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        // getBuffer rather than getStringBytes: the latter returns a view into the
+        // vector's memory for payloads of twelve bytes or fewer, and the value it is
+        // handed to keeps that reference, so it would dangle once the vector goes.
+        const bytes = (0, dataAccessors_1.getBuffer)(this.dataView, itemIndex * 16);
+        return bytes ? new values_1.DuckDBBitValue(bytes) : null;
+    }
+    setItem(itemIndex, value) {
+        this.itemCache[itemIndex] = value;
+        this.validity.setItemValid(itemIndex, value != null);
+        this.itemCacheDirty[itemIndex] = true;
+    }
+    flush() {
+        for (let itemIndex = 0; itemIndex < this._itemCount; itemIndex++) {
+            if (this.itemCacheDirty[itemIndex]) {
+                const cachedItem = this.itemCache[itemIndex];
+                if (cachedItem !== undefined && cachedItem !== null) {
+                    node_bindings_1.default.vector_assign_string_element_len(this.vector, this.itemOffset + itemIndex, cachedItem.data);
+                }
+                this.itemCacheDirty[itemIndex] = false;
+            }
+        }
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBBitVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, offset, length);
+    }
+}
+exports.DuckDBBitVector = DuckDBBitVector;

package/lib/vectors/DuckDBBlobVector.d.ts

@@ -0,0 +1,32 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBBlobType } from '../DuckDBType';
+import { DuckDBBlobValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBBlobVector extends DuckDBVector<DuckDBBlobValue> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly vector;
+    private readonly itemOffset;
+    private readonly _itemCount;
+    private readonly itemCache;
+    private readonly itemCacheDirty;
+    constructor(dataView: DataView, validity: DuckDBValidity, vector: duckdb.Vector, itemOffset: number, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBBlobVector;
+    get type(): DuckDBBlobType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBBlobValue | null;
+    /**
+     * Returns the raw bytes for the item at `itemIndex`, or null if the item
+     * is SQL NULL. Avoids the `Buffer.from(...)` copy that `getItem` does.
+     *
+     * The returned `Uint8Array` is a view over the underlying string_t
+     * backing buffer for inline payloads (≤12 bytes); for larger payloads
+     * it's a fresh allocation returned by the native bindings. Treat the
+     * result as read-only either way.
+     */
+    getItemBytes(itemIndex: number): Uint8Array | null;
+    setItem(itemIndex: number, value: DuckDBBlobValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBBlobVector;
+}

package/lib/vectors/DuckDBBlobVector.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBBlobVector = 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 DuckDBBlobVector extends DuckDBVector_1.DuckDBVector {
+    dataView;
+    validity;
+    vector;
+    itemOffset;
+    _itemCount;
+    itemCache;
+    itemCacheDirty;
+    constructor(dataView, validity, vector, itemOffset, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this.vector = vector;
+        this.itemOffset = itemOffset;
+        this._itemCount = itemCount;
+        this.itemCache = [];
+        this.itemCacheDirty = [];
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBBlobVector(dataView, validity, vector, 0, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBBlobType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBBlobValue((0, dataAccessors_1.getBuffer)(this.dataView, itemIndex * 16))
+            : null;
+    }
+    /**
+     * Returns the raw bytes for the item at `itemIndex`, or null if the item
+     * is SQL NULL. Avoids the `Buffer.from(...)` copy that `getItem` does.
+     *
+     * The returned `Uint8Array` is a view over the underlying string_t
+     * backing buffer for inline payloads (≤12 bytes); for larger payloads
+     * it's a fresh allocation returned by the native bindings. Treat the
+     * result as read-only either way.
+     */
+    getItemBytes(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? (0, dataAccessors_1.getStringBytes)(this.dataView, itemIndex * 16)
+            : null;
+    }
+    setItem(itemIndex, value) {
+        this.itemCache[itemIndex] = value;
+        this.validity.setItemValid(itemIndex, value != null);
+        this.itemCacheDirty[itemIndex] = true;
+    }
+    flush() {
+        for (let itemIndex = 0; itemIndex < this._itemCount; itemIndex++) {
+            if (this.itemCacheDirty[itemIndex]) {
+                const cachedItem = this.itemCache[itemIndex];
+                if (cachedItem !== undefined && cachedItem !== null) {
+                    node_bindings_1.default.vector_assign_string_element_len(this.vector, this.itemOffset + itemIndex, cachedItem.bytes);
+                }
+                this.itemCacheDirty[itemIndex] = false;
+            }
+        }
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBBlobVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, offset, length);
+    }
+}
+exports.DuckDBBlobVector = DuckDBBlobVector;

package/lib/vectors/DuckDBBooleanVector.d.ts

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

package/lib/vectors/DuckDBBooleanVector.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBBooleanVector = 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 DuckDBBooleanVector extends DuckDBVector_1.DuckDBVector {
+    dataView;
+    validity;
+    vector;
+    _itemCount;
+    constructor(dataView, validity, vector, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this.vector = vector;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * node_bindings_1.default.sizeof_bool);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBBooleanVector(dataView, validity, vector, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBBooleanType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? (0, dataAccessors_1.getBoolean)(this.dataView, itemIndex * node_bindings_1.default.sizeof_bool)
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            (0, dataAccessors_1.setBoolean)(this.dataView, itemIndex * node_bindings_1.default.sizeof_bool, 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.dataView.buffer, this.dataView.byteOffset, this.dataView.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBBooleanVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * node_bindings_1.default.sizeof_bool, length * node_bindings_1.default.sizeof_bool), this.validity.slice(offset, length), this.vector, length);
+    }
+}
+exports.DuckDBBooleanVector = DuckDBBooleanVector;

package/lib/vectors/DuckDBDateVector.d.ts

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

package/lib/vectors/DuckDBDateVector.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBDateVector = 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 DuckDBDateVector 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 * Int32Array.BYTES_PER_ELEMENT);
+        const items = new Int32Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBDateVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBDateType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBDateValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (!Number.isInteger(value.days)) {
+                throw new Error(`number is not an integer`);
+            }
+            if (value.days < -2147483648 || value.days > 2147483647) {
+                throw new Error(`number out of int32 range`);
+            }
+            this.items[itemIndex] = value.days;
+            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 DuckDBDateVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBDateVector = DuckDBDateVector;

package/lib/vectors/DuckDBDecimal128Vector.d.ts

@@ -0,0 +1,21 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBDecimalType } from '../DuckDBType';
+import { DuckDBDecimalValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBDecimal128Vector extends DuckDBVector<DuckDBDecimalValue> {
+    private readonly decimalType;
+    private readonly dataView;
+    private readonly validity;
+    private readonly vector;
+    private readonly _itemCount;
+    constructor(decimalType: DuckDBDecimalType, dataView: DataView, validity: DuckDBValidity, vector: duckdb.Vector, itemCount: number);
+    static fromRawVector(decimalType: DuckDBDecimalType, vector: duckdb.Vector, itemCount: number): DuckDBDecimal128Vector;
+    get type(): DuckDBDecimalType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBDecimalValue | null;
+    getScaledValue(itemIndex: number): bigint | null;
+    setItem(itemIndex: number, value: DuckDBDecimalValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBDecimal128Vector;
+}

package/lib/vectors/DuckDBDecimal128Vector.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBDecimal128Vector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBDecimal128Vector extends DuckDBVector_1.DuckDBVector {
+    decimalType;
+    dataView;
+    validity;
+    vector;
+    _itemCount;
+    constructor(decimalType, dataView, validity, vector, itemCount) {
+        super();
+        this.decimalType = decimalType;
+        this.dataView = dataView;
+        this.validity = validity;
+        this.vector = vector;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(decimalType, vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBDecimal128Vector(decimalType, dataView, validity, vector, itemCount);
+    }
+    get type() {
+        return this.decimalType;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? (0, dataAccessors_1.getDecimal128)(this.dataView, itemIndex * 16, this.decimalType)
+            : null;
+    }
+    getScaledValue(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? (0, dataAccessors_1.getInt128)(this.dataView, itemIndex * 16)
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            (0, dataAccessors_1.setInt128)(this.dataView, itemIndex * 16, value.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.dataView.buffer, this.dataView.byteOffset, this.dataView.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBDecimal128Vector(this.decimalType, new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, length);
+    }
+}
+exports.DuckDBDecimal128Vector = DuckDBDecimal128Vector;

package/lib/vectors/DuckDBDecimal16Vector.d.ts

@@ -0,0 +1,21 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBDecimalType } from '../DuckDBType';
+import { DuckDBDecimalValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBDecimal16Vector extends DuckDBVector<DuckDBDecimalValue> {
+    private readonly decimalType;
+    private readonly dataView;
+    private readonly validity;
+    private readonly vector;
+    private readonly _itemCount;
+    constructor(decimalType: DuckDBDecimalType, dataView: DataView, validity: DuckDBValidity, vector: duckdb.Vector, itemCount: number);
+    static fromRawVector(decimalType: DuckDBDecimalType, vector: duckdb.Vector, itemCount: number): DuckDBDecimal16Vector;
+    get type(): DuckDBDecimalType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBDecimalValue | null;
+    getScaledValue(itemIndex: number): number | null;
+    setItem(itemIndex: number, value: DuckDBDecimalValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBDecimal16Vector;
+}