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

package/lib/vectors/DuckDBGeometryVector.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBGeometryVector = 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 DuckDBGeometryVector 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 DuckDBGeometryVector(dataView, validity, vector, 0, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBGeometryType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBGeometryValue((0, dataAccessors_1.getBuffer)(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 DuckDBGeometryVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, offset, length);
+    }
+}
+exports.DuckDBGeometryVector = DuckDBGeometryVector;

package/lib/vectors/DuckDBHugeIntVector.d.ts

@@ -0,0 +1,19 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBHugeIntType } from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBHugeIntVector extends DuckDBVector<bigint> {
+    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): DuckDBHugeIntVector;
+    get type(): DuckDBHugeIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    getDouble(itemIndex: number): number | null;
+    setItem(itemIndex: number, value: bigint | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBHugeIntVector;
+}

package/lib/vectors/DuckDBHugeIntVector.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBHugeIntVector = 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 DuckDBHugeIntVector 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 * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBHugeIntVector(dataView, validity, vector, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBHugeIntType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? (0, dataAccessors_1.getInt128)(this.dataView, itemIndex * 16)
+            : null;
+    }
+    getDouble(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? node_bindings_1.default.hugeint_to_double((0, dataAccessors_1.getInt128)(this.dataView, itemIndex * 16))
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            (0, dataAccessors_1.setInt128)(this.dataView, itemIndex * 16, 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 DuckDBHugeIntVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, length);
+    }
+}
+exports.DuckDBHugeIntVector = DuckDBHugeIntVector;

package/lib/vectors/DuckDBIntegerVector.d.ts

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

package/lib/vectors/DuckDBIntegerVector.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.DuckDBIntegerVector = 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 DuckDBIntegerVector 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 DuckDBIntegerVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBIntegerType.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 < -2147483648 || value > 2147483647) {
+                throw new Error(`number out of int32 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 DuckDBIntegerVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBIntegerVector = DuckDBIntegerVector;

package/lib/vectors/DuckDBIntervalVector.d.ts

@@ -0,0 +1,19 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBIntervalType } from '../DuckDBType';
+import { DuckDBIntervalValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBIntervalVector extends DuckDBVector<DuckDBIntervalValue> {
+    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): DuckDBIntervalVector;
+    get type(): DuckDBIntervalType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBIntervalValue | null;
+    setItem(itemIndex: number, value: DuckDBIntervalValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBIntervalVector;
+}

package/lib/vectors/DuckDBIntervalVector.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBIntervalVector = 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 DuckDBIntervalVector 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 * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBIntervalVector(dataView, validity, vector, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBIntervalType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        const itemStart = itemIndex * 16;
+        const months = (0, dataAccessors_1.getInt32)(this.dataView, itemStart);
+        const days = (0, dataAccessors_1.getInt32)(this.dataView, itemStart + 4);
+        const micros = (0, dataAccessors_1.getInt64)(this.dataView, itemStart + 8);
+        return new values_1.DuckDBIntervalValue(months, days, micros);
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            const itemStart = itemIndex * 16;
+            (0, dataAccessors_1.setInt32)(this.dataView, itemStart, value.months);
+            (0, dataAccessors_1.setInt32)(this.dataView, itemStart + 4, value.days);
+            (0, dataAccessors_1.setInt64)(this.dataView, itemStart + 8, 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.dataView.buffer, this.dataView.byteOffset, this.dataView.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBIntervalVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, length);
+    }
+}
+exports.DuckDBIntervalVector = DuckDBIntervalVector;

package/lib/vectors/DuckDBListVector.d.ts

@@ -0,0 +1,35 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBListType } from '../DuckDBType';
+import { DuckDBListValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBListVector extends DuckDBVector<DuckDBListValue> {
+    private readonly parentList;
+    private readonly listType;
+    private readonly entryData;
+    private readonly validity;
+    private readonly vector;
+    private childData;
+    private readonly itemOffset;
+    private readonly _itemCount;
+    private readonly itemCache;
+    constructor(parentList: DuckDBListVector | null, listType: DuckDBListType, entryData: BigUint64Array, validity: DuckDBValidity, vector: duckdb.Vector, childData: DuckDBVector, itemOffset: number, itemCount: number);
+    static fromRawVector(listType: DuckDBListType, vector: duckdb.Vector, itemCount: number): DuckDBListVector;
+    get type(): DuckDBListType;
+    get itemCount(): number;
+    getItemVector(itemIndex: number): DuckDBVector | null;
+    /**
+     * Returns the offset into `childVector` where this row's elements begin.
+     * Combined with `childVector`, this allows callers to index directly into
+     * the flat backing storage without allocating a per-row sliced vector.
+     */
+    getEntryOffset(itemIndex: number): number;
+    /** Returns the number of elements this row contributes to `childVector`. */
+    getEntryLength(itemIndex: number): number;
+    /** The (flat) child vector backing all rows' list elements. */
+    get childVector(): DuckDBVector;
+    getItem(itemIndex: number): DuckDBListValue | null;
+    setItem(itemIndex: number, value: DuckDBListValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBListVector;
+}

package/lib/vectors/DuckDBListVector.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBListVector = 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");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBListVector extends DuckDBVector_1.DuckDBVector {
+    parentList;
+    listType;
+    entryData;
+    validity;
+    vector;
+    childData;
+    itemOffset;
+    _itemCount;
+    itemCache;
+    constructor(parentList, listType, entryData, validity, vector, childData, itemOffset, itemCount) {
+        super();
+        this.parentList = parentList;
+        this.listType = listType;
+        this.entryData = entryData;
+        this.validity = validity;
+        this.vector = vector;
+        this.childData = childData;
+        this.itemOffset = itemOffset;
+        this._itemCount = itemCount;
+        this.itemCache = [];
+    }
+    static fromRawVector(listType, vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * BigUint64Array.BYTES_PER_ELEMENT * 2);
+        const entryData = new BigUint64Array(data.buffer, data.byteOffset, itemCount * 2);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        const child_vector = node_bindings_1.default.list_vector_get_child(vector);
+        const child_vector_size = node_bindings_1.default.list_vector_get_size(vector);
+        const childData = DuckDBVector_1.DuckDBVector.create(child_vector, child_vector_size, listType.valueType);
+        return new DuckDBListVector(null, listType, entryData, validity, vector, childData, 0, itemCount);
+    }
+    get type() {
+        return this.listType;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItemVector(itemIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        const entryDataStartIndex = itemIndex * 2;
+        const offset = Number(this.entryData[entryDataStartIndex]);
+        const length = Number(this.entryData[entryDataStartIndex + 1]);
+        return this.childData.slice(offset, length);
+    }
+    /**
+     * Returns the offset into `childVector` where this row's elements begin.
+     * Combined with `childVector`, this allows callers to index directly into
+     * the flat backing storage without allocating a per-row sliced vector.
+     */
+    getEntryOffset(itemIndex) {
+        return Number(this.entryData[itemIndex * 2]);
+    }
+    /** Returns the number of elements this row contributes to `childVector`. */
+    getEntryLength(itemIndex) {
+        return Number(this.entryData[itemIndex * 2 + 1]);
+    }
+    /** The (flat) child vector backing all rows' list elements. */
+    get childVector() {
+        return this.childData;
+    }
+    getItem(itemIndex) {
+        const cachedItem = this.itemCache[itemIndex];
+        if (cachedItem !== undefined) {
+            return cachedItem;
+        }
+        const vector = this.getItemVector(itemIndex);
+        if (!vector) {
+            return null;
+        }
+        const item = new values_1.DuckDBListValue(vector.toArray());
+        this.itemCache[itemIndex] = item;
+        return item;
+    }
+    setItem(itemIndex, value) {
+        this.itemCache[itemIndex] = value;
+        if (this.parentList) {
+            this.parentList.setItem(this.itemOffset + itemIndex, value);
+        }
+        else {
+            this.validity.setItemValid(itemIndex, value != null);
+        }
+    }
+    flush() {
+        if (this.parentList) {
+            this.parentList.flush();
+            for (let i = 0; i < this.itemCount; i++) {
+                this.itemCache[i] = undefined;
+            }
+        }
+        else {
+            // update entryData offset & lengths
+            // calculate new child vector size (sum of all item lengths)
+            let totalLength = 0;
+            for (let itemIndex = 0; itemIndex < this._itemCount; itemIndex++) {
+                const entryDataStartIndex = itemIndex * 2;
+                this.entryData[entryDataStartIndex] = BigInt(totalLength);
+                // ensure the cache is populated for all items
+                const item = this.getItem(itemIndex);
+                if (item) {
+                    this.entryData[entryDataStartIndex + 1] = BigInt(item.items.length);
+                    totalLength += item.items.length;
+                }
+                else {
+                    this.entryData[entryDataStartIndex + 1] = 0n;
+                }
+            }
+            // grow child vector capacity (set_size does not allocate)
+            node_bindings_1.default.list_vector_reserve(this.vector, totalLength);
+            // set new child vector size
+            node_bindings_1.default.list_vector_set_size(this.vector, totalLength);
+            // recreate childData after resize
+            const child_vector = node_bindings_1.default.list_vector_get_child(this.vector);
+            const child_vector_size = node_bindings_1.default.list_vector_get_size(this.vector);
+            this.childData = DuckDBVector_1.DuckDBVector.create(child_vector, child_vector_size, this.listType.valueType);
+            // set all childData items
+            let childItemAbsoluteIndex = 0;
+            for (let listIndex = 0; listIndex < this._itemCount; listIndex++) {
+                const list = this.getItem(listIndex);
+                if (list) {
+                    for (let childItemRelativeIndex = 0; childItemRelativeIndex < list.items.length; childItemRelativeIndex++) {
+                        this.childData.setItem(childItemAbsoluteIndex++, list.items[childItemRelativeIndex]);
+                    }
+                }
+            }
+            // copy childData to child vector
+            this.childData.flush();
+            // copy entryData to vector
+            node_bindings_1.default.copy_data_to_vector(this.vector, 0, this.entryData.buffer, this.entryData.byteOffset, this.entryData.byteLength);
+            // flush validity
+            this.validity.flush(this.vector);
+        }
+    }
+    slice(offset, length) {
+        const entryDataStartIndex = offset * 2;
+        return new DuckDBListVector(this, this.listType, this.entryData.slice(entryDataStartIndex, entryDataStartIndex + length * 2), this.validity.slice(offset, length), this.vector, this.childData, offset, length);
+    }
+}
+exports.DuckDBListVector = DuckDBListVector;

package/lib/vectors/DuckDBMapVector.d.ts

@@ -0,0 +1,17 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBMapType } from '../DuckDBType';
+import { DuckDBMapValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBListVector } from './DuckDBListVector';
+export declare class DuckDBMapVector extends DuckDBVector<DuckDBMapValue> {
+    private readonly mapType;
+    private readonly listVector;
+    constructor(mapType: DuckDBMapType, listVector: DuckDBListVector);
+    static fromRawVector(mapType: DuckDBMapType, vector: duckdb.Vector, itemCount: number): DuckDBMapVector;
+    get type(): DuckDBMapType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBMapValue | null;
+    setItem(itemIndex: number, value: DuckDBMapValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBMapVector;
+}

package/lib/vectors/DuckDBMapVector.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBMapVector = void 0;
+const DuckDBType_1 = require("../DuckDBType");
+const values_1 = require("../values");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBListVector_1 = require("./DuckDBListVector");
+const DuckDBStructVector_1 = require("./DuckDBStructVector");
+// MAP = LIST(STRUCT(key KEY_TYPE, value VALUE_TYPE))
+class DuckDBMapVector extends DuckDBVector_1.DuckDBVector {
+    mapType;
+    listVector;
+    constructor(mapType, listVector) {
+        super();
+        this.mapType = mapType;
+        this.listVector = listVector;
+    }
+    static fromRawVector(mapType, vector, itemCount) {
+        const listVectorType = new DuckDBType_1.DuckDBListType(new DuckDBType_1.DuckDBStructType(['key', 'value'], [mapType.keyType, mapType.valueType]));
+        return new DuckDBMapVector(mapType, DuckDBListVector_1.DuckDBListVector.fromRawVector(listVectorType, vector, itemCount));
+    }
+    get type() {
+        return this.mapType;
+    }
+    get itemCount() {
+        return this.listVector.itemCount;
+    }
+    getItem(itemIndex) {
+        const itemVector = this.listVector.getItemVector(itemIndex);
+        if (!itemVector) {
+            return null;
+        }
+        if (!(itemVector instanceof DuckDBStructVector_1.DuckDBStructVector)) {
+            throw new Error('item in map list vector is not a struct');
+        }
+        const entries = [];
+        const itemEntryCount = itemVector.itemCount;
+        for (let i = 0; i < itemEntryCount; i++) {
+            const key = itemVector.getItemValue(i, 0);
+            const value = itemVector.getItemValue(i, 1);
+            entries.push({ key, value });
+        }
+        return new values_1.DuckDBMapValue(entries);
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            this.listVector.setItem(itemIndex, (0, values_1.listValue)(value.entries.map((entry) => (0, values_1.structValue)({ 'key': entry.key, 'value': entry.value }))));
+        }
+        else {
+            this.listVector.setItem(itemIndex, null);
+        }
+    }
+    flush() {
+        this.listVector.flush();
+    }
+    slice(offset, length) {
+        return new DuckDBMapVector(this.mapType, this.listVector.slice(offset, length));
+    }
+}
+exports.DuckDBMapVector = DuckDBMapVector;

package/lib/vectors/DuckDBSQLNullVector.d.ts

@@ -0,0 +1,18 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBSQLNullType } from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+/** A vector of the SQLNULL type, whose items are all null. */
+export declare class DuckDBSQLNullVector extends DuckDBVector<null> {
+    private readonly validity;
+    private readonly vector;
+    private readonly _itemCount;
+    constructor(validity: DuckDBValidity, vector: duckdb.Vector, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBSQLNullVector;
+    get type(): DuckDBSQLNullType;
+    get itemCount(): number;
+    getItem(_itemIndex: number): null;
+    setItem(itemIndex: number, value: null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBSQLNullVector;
+}

package/lib/vectors/DuckDBSQLNullVector.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBSQLNullVector = void 0;
+const DuckDBType_1 = require("../DuckDBType");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+/** A vector of the SQLNULL type, whose items are all null. */
+class DuckDBSQLNullVector extends DuckDBVector_1.DuckDBVector {
+    validity;
+    vector;
+    _itemCount;
+    constructor(validity, vector, itemCount) {
+        super();
+        this.validity = validity;
+        this.vector = vector;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(vector, itemCount) {
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBSQLNullVector(validity, vector, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBSQLNullType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(_itemIndex) {
+        return null;
+    }
+    setItem(itemIndex, value) {
+        if (value !== null) {
+            throw new Error(`Cannot set a non-null value in a SQLNULL vector`);
+        }
+        this.validity.setItemValid(itemIndex, false);
+    }
+    flush() {
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBSQLNullVector(this.validity.slice(offset, length), this.vector, length);
+    }
+}
+exports.DuckDBSQLNullVector = DuckDBSQLNullVector;

package/lib/vectors/DuckDBSmallIntVector.d.ts

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