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

package/lib/vectors/DuckDBDecimal16Vector.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.DuckDBDecimal16Vector = 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 DuckDBDecimal16Vector 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 * 2);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBDecimal16Vector(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.getDecimal16)(this.dataView, itemIndex * 2, this.decimalType)
+            : null;
+    }
+    getScaledValue(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? (0, dataAccessors_1.getInt16)(this.dataView, itemIndex * 2)
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            (0, dataAccessors_1.setInt16)(this.dataView, itemIndex * 2, Number(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 DuckDBDecimal16Vector(this.decimalType, new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 2, length * 2), this.validity.slice(offset, length), this.vector, length);
+    }
+}
+exports.DuckDBDecimal16Vector = DuckDBDecimal16Vector;

package/lib/vectors/DuckDBDecimal32Vector.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 DuckDBDecimal32Vector 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): DuckDBDecimal32Vector;
+    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): DuckDBDecimal32Vector;
+}

package/lib/vectors/DuckDBDecimal32Vector.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.DuckDBDecimal32Vector = 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 DuckDBDecimal32Vector 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 * 4);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBDecimal32Vector(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.getDecimal32)(this.dataView, itemIndex * 4, this.decimalType)
+            : null;
+    }
+    getScaledValue(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? (0, dataAccessors_1.getInt32)(this.dataView, itemIndex * 4)
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            (0, dataAccessors_1.setInt32)(this.dataView, itemIndex * 4, Number(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 DuckDBDecimal32Vector(this.decimalType, new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 4, length * 4), this.validity.slice(offset, length), this.vector, length);
+    }
+}
+exports.DuckDBDecimal32Vector = DuckDBDecimal32Vector;

package/lib/vectors/DuckDBDecimal64Vector.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 DuckDBDecimal64Vector 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): DuckDBDecimal64Vector;
+    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): DuckDBDecimal64Vector;
+}

package/lib/vectors/DuckDBDecimal64Vector.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.DuckDBDecimal64Vector = 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 DuckDBDecimal64Vector 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 * 8);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBDecimal64Vector(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.getDecimal64)(this.dataView, itemIndex * 8, this.decimalType)
+            : null;
+    }
+    getScaledValue(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? (0, dataAccessors_1.getInt64)(this.dataView, itemIndex * 8)
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            (0, dataAccessors_1.setInt64)(this.dataView, itemIndex * 8, 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 DuckDBDecimal64Vector(this.decimalType, new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 8, length * 8), this.validity.slice(offset, length), this.vector, length);
+    }
+}
+exports.DuckDBDecimal64Vector = DuckDBDecimal64Vector;

package/lib/vectors/DuckDBDoubleVector.d.ts

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

package/lib/vectors/DuckDBDoubleVector.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBDoubleVector = 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 DuckDBDoubleVector 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 * Float64Array.BYTES_PER_ELEMENT);
+        const items = new Float64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBDoubleVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBDoubleType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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 DuckDBDoubleVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBDoubleVector = DuckDBDoubleVector;

package/lib/vectors/DuckDBEnum16Vector.d.ts

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

package/lib/vectors/DuckDBEnum16Vector.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBEnum16Vector = 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 DuckDBEnum16Vector extends DuckDBVector_1.DuckDBVector {
+    enumType;
+    items;
+    validity;
+    vector;
+    constructor(enumType, items, validity, vector) {
+        super();
+        this.enumType = enumType;
+        this.items = items;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(enumType, vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * 2);
+        const items = new Uint16Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBEnum16Vector(enumType, items, validity, vector);
+    }
+    get type() {
+        return this.enumType;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? this.enumType.values[this.items[itemIndex]]
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            this.items[itemIndex] = this.enumType.indexForValue(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 DuckDBEnum16Vector(this.enumType, this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBEnum16Vector = DuckDBEnum16Vector;

package/lib/vectors/DuckDBEnum32Vector.d.ts

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

package/lib/vectors/DuckDBEnum32Vector.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBEnum32Vector = 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 DuckDBEnum32Vector extends DuckDBVector_1.DuckDBVector {
+    enumType;
+    items;
+    validity;
+    vector;
+    constructor(enumType, items, validity, vector) {
+        super();
+        this.enumType = enumType;
+        this.items = items;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(enumType, vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * 4);
+        const items = new Uint32Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBEnum32Vector(enumType, items, validity, vector);
+    }
+    get type() {
+        return this.enumType;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? this.enumType.values[this.items[itemIndex]]
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            this.items[itemIndex] = this.enumType.indexForValue(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 DuckDBEnum32Vector(this.enumType, this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBEnum32Vector = DuckDBEnum32Vector;

package/lib/vectors/DuckDBEnum8Vector.d.ts

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

package/lib/vectors/DuckDBEnum8Vector.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBEnum8Vector = 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 DuckDBEnum8Vector extends DuckDBVector_1.DuckDBVector {
+    enumType;
+    items;
+    validity;
+    vector;
+    constructor(enumType, items, validity, vector) {
+        super();
+        this.enumType = enumType;
+        this.items = items;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(enumType, vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount);
+        const items = new Uint8Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBEnum8Vector(enumType, items, validity, vector);
+    }
+    get type() {
+        return this.enumType;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? this.enumType.values[this.items[itemIndex]]
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            this.items[itemIndex] = this.enumType.indexForValue(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 DuckDBEnum8Vector(this.enumType, this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBEnum8Vector = DuckDBEnum8Vector;

package/lib/vectors/DuckDBFloatVector.d.ts

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

package/lib/vectors/DuckDBFloatVector.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBFloatVector = 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 DuckDBFloatVector 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 * Float32Array.BYTES_PER_ELEMENT);
+        const items = new Float32Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBFloatVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBFloatType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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 DuckDBFloatVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBFloatVector = DuckDBFloatVector;

package/lib/vectors/DuckDBGeometryVector.d.ts

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