@duckdb/node-api 1.1.3-alpha.8 → 1.1.3-alpha.9

package/lib/DuckDBVector.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DuckDBVarIntVector = exports.DuckDBTimestampTZVector = exports.DuckDBTimeTZVector = exports.DuckDBBitVector = exports.DuckDBUnionVector = exports.DuckDBUUIDVector = exports.DuckDBArrayVector = exports.DuckDBMapVector = exports.DuckDBStructVector = exports.DuckDBListVector = exports.DuckDBEnum4Vector = exports.DuckDBEnum2Vector = exports.DuckDBEnum1Vector = exports.DuckDBTimestampNanosecondsVector = exports.DuckDBTimestampMillisecondsVector = exports.DuckDBTimestampSecondsVector = exports.DuckDBDecimal16Vector = exports.DuckDBDecimal8Vector = exports.DuckDBDecimal4Vector = exports.DuckDBDecimal2Vector = exports.DuckDBBlobVector = exports.DuckDBVarCharVector = exports.DuckDBUHugeIntVector = exports.DuckDBHugeIntVector = exports.DuckDBIntervalVector = exports.DuckDBTimeVector = exports.DuckDBDateVector = exports.DuckDBTimestampVector = exports.DuckDBDoubleVector = exports.DuckDBFloatVector = exports.DuckDBUBigIntVector = exports.DuckDBUIntegerVector = exports.DuckDBUSmallIntVector = exports.DuckDBUTinyIntVector = exports.DuckDBBigIntVector = exports.DuckDBIntegerVector = exports.DuckDBSmallIntVector = exports.DuckDBTinyIntVector = exports.DuckDBBooleanVector = exports.DuckDBVector = void 0;
+exports.DuckDBVarIntVector = exports.DuckDBTimestampTZVector = exports.DuckDBTimeTZVector = exports.DuckDBBitVector = exports.DuckDBUnionVector = exports.DuckDBUUIDVector = exports.DuckDBArrayVector = exports.DuckDBMapVector = exports.DuckDBStructVector = exports.DuckDBListVector = exports.DuckDBEnum32Vector = exports.DuckDBEnum16Vector = exports.DuckDBEnum8Vector = exports.DuckDBTimestampNanosecondsVector = exports.DuckDBTimestampMillisecondsVector = exports.DuckDBTimestampSecondsVector = exports.DuckDBDecimal128Vector = exports.DuckDBDecimal64Vector = exports.DuckDBDecimal32Vector = exports.DuckDBDecimal16Vector = exports.DuckDBBlobVector = exports.DuckDBVarCharVector = exports.DuckDBUHugeIntVector = exports.DuckDBHugeIntVector = exports.DuckDBIntervalVector = exports.DuckDBTimeVector = exports.DuckDBDateVector = exports.DuckDBTimestampVector = exports.DuckDBDoubleVector = exports.DuckDBFloatVector = exports.DuckDBUBigIntVector = exports.DuckDBUIntegerVector = exports.DuckDBUSmallIntVector = exports.DuckDBUTinyIntVector = exports.DuckDBBigIntVector = exports.DuckDBIntegerVector = exports.DuckDBSmallIntVector = exports.DuckDBTinyIntVector = exports.DuckDBBooleanVector = exports.DuckDBVector = void 0;
 const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
 const os_1 = __importDefault(require("os"));
 const DuckDBLogicalType_1 = require("./DuckDBLogicalType");
@@ -49,7 +49,7 @@ function getInt128(dataView, offset) {
 function getUInt128(dataView, offset) {
     const lower = getUInt64(dataView, offset);
     const upper = getUInt64(dataView, offset + 8);
-    return BigInt.asUintN(64, upper) << BigInt(64) | BigInt.asUintN(64, lower);
+    return (BigInt.asUintN(64, upper) << BigInt(64)) | BigInt.asUintN(64, lower);
 }
 function getStringBytes(dataView, offset) {
     const lengthInBytes = dataView.getUint32(offset, true);
@@ -88,6 +88,30 @@ function getVarIntFromBytes(bytes) {
     }
     return positive ? result : -result;
 }
+function getBytesFromVarInt(varint) {
+    const numberBytes = [];
+    if (varint === 0n) {
+        numberBytes.push(0);
+    }
+    else {
+        while (varint !== 0n) {
+            numberBytes.push(Number(BigInt.asUintN(8, varint)));
+            varint >>= 8n;
+        }
+    }
+    const varIntBytes = new Uint8Array(3 + numberBytes.length);
+    let header = 0x800000 | numberBytes.length;
+    if (varint < 0) {
+        header = ~header;
+    }
+    varIntBytes[0] = 0xff & (header >> 16);
+    varIntBytes[1] = 0xff & (header >> 8);
+    varIntBytes[2] = 0xff & header;
+    for (let i = 0; i < numberBytes.length; i++) {
+        varIntBytes[3 + i] = numberBytes[i];
+    }
+    return varIntBytes;
+}
 function getBoolean1(dataView, offset) {
     return getUInt8(dataView, offset) !== 0;
 }
@@ -115,19 +139,82 @@ function makeGetBoolean() {
     }
 }
 const getBoolean = makeGetBoolean();
-function getDecimal2(dataView, offset, type) {
+// function setInt8(dataView: DataView, offset: number, value: number) {
+//   dataView.setInt8(offset, value);
+// }
+function setUInt8(dataView, offset, value) {
+    dataView.setUint8(offset, value);
+}
+function setInt16(dataView, offset, value) {
+    dataView.setInt16(offset, value, littleEndian);
+}
+function setUInt16(dataView, offset, value) {
+    dataView.setUint16(offset, value, littleEndian);
+}
+function setInt32(dataView, offset, value) {
+    dataView.setInt32(offset, value, littleEndian);
+}
+function setUInt32(dataView, offset, value) {
+    dataView.setUint32(offset, value, littleEndian);
+}
+function setInt64(dataView, offset, value) {
+    dataView.setBigInt64(offset, value, littleEndian);
+}
+function setUInt64(dataView, offset, value) {
+    dataView.setBigUint64(offset, value, littleEndian);
+}
+function setInt128(dataView, offset, value) {
+    const lower = BigInt.asUintN(64, value);
+    const upper = BigInt.asIntN(64, value >> BigInt(64));
+    dataView.setBigUint64(offset, lower, littleEndian);
+    dataView.setBigInt64(offset + 8, upper, littleEndian);
+}
+function setUInt128(dataView, offset, value) {
+    const lower = BigInt.asUintN(64, value);
+    const upper = BigInt.asUintN(64, value >> BigInt(64));
+    dataView.setBigUint64(offset, lower, littleEndian);
+    dataView.setBigUint64(offset + 8, upper, littleEndian);
+}
+function setBoolean1(dataView, offset, value) {
+    setUInt8(dataView, offset, value ? 1 : 0);
+}
+function setBoolean2(dataView, offset, value) {
+    setUInt16(dataView, offset, value ? 1 : 0);
+}
+function setBoolean4(dataView, offset, value) {
+    setUInt32(dataView, offset, value ? 1 : 0);
+}
+function setBoolean8(dataView, offset, value) {
+    setUInt64(dataView, offset, value ? BigInt(1) : BigInt(0));
+}
+function makeSetBoolean() {
+    switch (node_bindings_1.default.sizeof_bool) {
+        case 1:
+            return setBoolean1;
+        case 2:
+            return setBoolean2;
+        case 4:
+            return setBoolean4;
+        case 8:
+            return setBoolean8;
+        default:
+            throw new Error(`Unsupported boolean size: ${node_bindings_1.default.sizeof_bool}`);
+    }
+}
+const setBoolean = makeSetBoolean();
+function getDecimal16(dataView, offset, type) {
     const value = getInt16(dataView, offset);
     return new values_1.DuckDBDecimalValue(BigInt(value), type.width, type.scale);
 }
-function getDecimal4(dataView, offset, type) {
+function getDecimal32(dataView, offset, type) {
     const value = getInt32(dataView, offset);
     return new values_1.DuckDBDecimalValue(BigInt(value), type.width, type.scale);
 }
-function getDecimal8(dataView, offset, type) {
+function getDecimal64(dataView, offset, type) {
     const value = getInt64(dataView, offset);
     return new values_1.DuckDBDecimalValue(value, type.width, type.scale);
 }
-function getDecimal16(dataView, offset, type) {
+function getDecimal128(dataView, offset, type) {
     const value = getInt128(dataView, offset);
     return new values_1.DuckDBDecimalValue(value, type.width, type.scale);
 }
@@ -156,28 +243,65 @@ function vectorData(vector, byteCount) {
 class DuckDBValidity {
     data;
     offset;
-    constructor(data, offset) {
+    itemCount;
+    constructor(data, offset, itemCount) {
         this.data = data;
         this.offset = offset;
+        this.itemCount = itemCount;
     }
     static fromVector(vector, itemCount) {
-        const bigintCount = Math.ceil(itemCount / 64);
-        const bytes = node_bindings_1.default.vector_get_validity(vector, bigintCount * 8);
+        const uint64Count = Math.ceil(itemCount / 64);
+        const bytes = node_bindings_1.default.vector_get_validity(vector, uint64Count * 8);
         if (!bytes) {
-            return new DuckDBValidity(null, 0);
+            return new DuckDBValidity(null, 0, itemCount);
         }
-        const bigints = new BigUint64Array(bytes.buffer, bytes.byteOffset, bigintCount);
-        return new DuckDBValidity(bigints, 0);
+        const bigints = new BigUint64Array(bytes.buffer, bytes.byteOffset, uint64Count);
+        return new DuckDBValidity(bigints, 0, itemCount);
     }
     itemValid(itemIndex) {
         if (!this.data) {
             return true;
         }
         const bit = this.offset + itemIndex;
-        return (this.data[Math.floor(bit / 64)] & (BigInt(1) << BigInt(bit % 64))) !== BigInt(0);
+        return ((this.data[Math.floor(bit / 64)] & (BigInt(1) << BigInt(bit % 64))) !==
+            BigInt(0));
+    }
+    setItemValid(itemIndex, valid) {
+        if (!this.data && !valid) {
+            // An item is being set to invalid and we don't have a data buffer, so create it. If an item is being set to valid
+            // and we don't have a data buffer, then there's nothing to do; a null data buffer indicates all items are valid.
+            const uint64Count = Math.ceil(this.itemCount / 64);
+            const buffer = new ArrayBuffer(uint64Count * 8);
+            this.data = new BigUint64Array(buffer, 0, uint64Count);
+            // Initialize to all items to valid.
+            for (let i = 0; i < this.data.length; i++) {
+                this.data[i] = 0xffffffffffffffffn;
+            }
+        }
+        if (this.data) {
+            const bit = this.offset + itemIndex;
+            const uint64Index = Math.floor(bit / 64);
+            const uint64WithBitSet = BigInt(1) << BigInt(bit % 64);
+            if (valid) {
+                if ((this.data[uint64Index] & uint64WithBitSet) === 0n) {
+                    this.data[uint64Index] |= uint64WithBitSet;
+                }
+            }
+            else {
+                if ((this.data[uint64Index] & uint64WithBitSet) !== 0n) {
+                    this.data[uint64Index] &= ~uint64WithBitSet;
+                }
+            }
+        }
     }
-    slice(offset) {
-        return new DuckDBValidity(this.data, this.offset + offset);
+    flush(vector) {
+        if (this.data) {
+            node_bindings_1.default.vector_ensure_validity_writable(vector);
+            node_bindings_1.default.copy_data_to_vector_validity(vector, 0, this.data.buffer, this.data.byteOffset, this.data.byteLength);
+        }
+    }
+    slice(offset, itemCount) {
+        return new DuckDBValidity(this.data, this.offset + offset, itemCount);
     }
 }
 class DuckDBVector {
@@ -185,7 +309,9 @@ class DuckDBVector {
         return node_bindings_1.default.vector_size();
     }
     static create(vector, itemCount, knownType) {
-        const vectorType = knownType ? knownType : DuckDBLogicalType_1.DuckDBLogicalType.create(node_bindings_1.default.vector_get_column_type(vector)).asType();
+        const vectorType = knownType
+            ? knownType
+            : DuckDBLogicalType_1.DuckDBLogicalType.create(node_bindings_1.default.vector_get_column_type(vector)).asType();
         switch (vectorType.typeId) {
             case DuckDBTypeId_1.DuckDBTypeId.BOOLEAN:
                 return DuckDBBooleanVector.fromRawVector(vector, itemCount);
@@ -232,16 +358,16 @@ class DuckDBVector {
                         throw new Error(`DECIMAL width not positive: ${width}`);
                     }
                     else if (width <= 4) {
-                        return DuckDBDecimal2Vector.fromRawVector(vectorType, vector, itemCount);
+                        return DuckDBDecimal16Vector.fromRawVector(vectorType, vector, itemCount);
                     }
                     else if (width <= 9) {
-                        return DuckDBDecimal4Vector.fromRawVector(vectorType, vector, itemCount);
+                        return DuckDBDecimal32Vector.fromRawVector(vectorType, vector, itemCount);
                     }
                     else if (width <= 18) {
-                        return DuckDBDecimal8Vector.fromRawVector(vectorType, vector, itemCount);
+                        return DuckDBDecimal64Vector.fromRawVector(vectorType, vector, itemCount);
                     }
                     else if (width <= 38) {
-                        return DuckDBDecimal16Vector.fromRawVector(vectorType, vector, itemCount);
+                        return DuckDBDecimal128Vector.fromRawVector(vectorType, vector, itemCount);
                     }
                     else {
                         throw new Error(`DECIMAL width too large: ${width}`);
@@ -259,11 +385,11 @@ class DuckDBVector {
                     const { internalTypeId } = vectorType;
                     switch (internalTypeId) {
                         case DuckDBTypeId_1.DuckDBTypeId.UTINYINT:
-                            return DuckDBEnum1Vector.fromRawVector(vectorType, vector, itemCount);
+                            return DuckDBEnum8Vector.fromRawVector(vectorType, vector, itemCount);
                         case DuckDBTypeId_1.DuckDBTypeId.USMALLINT:
-                            return DuckDBEnum2Vector.fromRawVector(vectorType, vector, itemCount);
+                            return DuckDBEnum16Vector.fromRawVector(vectorType, vector, itemCount);
                         case DuckDBTypeId_1.DuckDBTypeId.UINTEGER:
-                            return DuckDBEnum4Vector.fromRawVector(vectorType, vector, itemCount);
+                            return DuckDBEnum32Vector.fromRawVector(vectorType, vector, itemCount);
                         default:
                             throw new Error(`unsupported ENUM internal type: ${internalTypeId}`);
                     }
@@ -324,18 +450,20 @@ exports.DuckDBVector = DuckDBVector;
 class DuckDBBooleanVector extends DuckDBVector {
     dataView;
     validity;
+    vector;
     _itemCount;
-    constructor(dataView, validity, 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 = vectorData(vector, itemCount * node_bindings_1.default.sizeof_bool);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBBooleanVector(dataView, validity, itemCount);
+        return new DuckDBBooleanVector(dataView, validity, vector, itemCount);
     }
     get type() {
         return DuckDBType_1.DuckDBBooleanType.instance;
@@ -344,26 +472,43 @@ class DuckDBBooleanVector extends DuckDBVector {
         return this._itemCount;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? getBoolean(this.dataView, itemIndex * node_bindings_1.default.sizeof_bool) : null;
+        return this.validity.itemValid(itemIndex)
+            ? getBoolean(this.dataView, itemIndex * node_bindings_1.default.sizeof_bool)
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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);
+        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;
 class DuckDBTinyIntVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * Int8Array.BYTES_PER_ELEMENT);
         const items = new Int8Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBTinyIntVector(items, validity);
+        return new DuckDBTinyIntVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBTinyIntType.instance;
@@ -374,24 +519,39 @@ class DuckDBTinyIntVector extends DuckDBVector {
     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 DuckDBTinyIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBTinyIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBTinyIntVector = DuckDBTinyIntVector;
 class DuckDBSmallIntVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * Int16Array.BYTES_PER_ELEMENT);
         const items = new Int16Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBSmallIntVector(items, validity);
+        return new DuckDBSmallIntVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBSmallIntType.instance;
@@ -402,24 +562,39 @@ class DuckDBSmallIntVector extends DuckDBVector {
     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 DuckDBSmallIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBSmallIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBSmallIntVector = DuckDBSmallIntVector;
 class DuckDBIntegerVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * Int32Array.BYTES_PER_ELEMENT);
         const items = new Int32Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBIntegerVector(items, validity);
+        return new DuckDBIntegerVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBIntegerType.instance;
@@ -430,24 +605,39 @@ class DuckDBIntegerVector extends DuckDBVector {
     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 DuckDBIntegerVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBIntegerVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBIntegerVector = DuckDBIntegerVector;
 class DuckDBBigIntVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
         const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBBigIntVector(items, validity);
+        return new DuckDBBigIntVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBBigIntType.instance;
@@ -458,24 +648,39 @@ class DuckDBBigIntVector extends DuckDBVector {
     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 DuckDBBigIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBBigIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBBigIntVector = DuckDBBigIntVector;
 class DuckDBUTinyIntVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * Uint8Array.BYTES_PER_ELEMENT);
         const items = new Uint8Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBUTinyIntVector(items, validity);
+        return new DuckDBUTinyIntVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBUTinyIntType.instance;
@@ -486,24 +691,39 @@ class DuckDBUTinyIntVector extends DuckDBVector {
     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 DuckDBUTinyIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBUTinyIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBUTinyIntVector = DuckDBUTinyIntVector;
 class DuckDBUSmallIntVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * Uint16Array.BYTES_PER_ELEMENT);
         const items = new Uint16Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBUSmallIntVector(items, validity);
+        return new DuckDBUSmallIntVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBUSmallIntType.instance;
@@ -514,24 +734,39 @@ class DuckDBUSmallIntVector extends DuckDBVector {
     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 DuckDBUSmallIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBUSmallIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBUSmallIntVector = DuckDBUSmallIntVector;
 class DuckDBUIntegerVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * Uint32Array.BYTES_PER_ELEMENT);
         const items = new Uint32Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBUIntegerVector(items, validity);
+        return new DuckDBUIntegerVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBUIntegerType.instance;
@@ -542,24 +777,39 @@ class DuckDBUIntegerVector extends DuckDBVector {
     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 DuckDBUIntegerVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBUIntegerVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBUIntegerVector = DuckDBUIntegerVector;
 class DuckDBUBigIntVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * BigUint64Array.BYTES_PER_ELEMENT);
         const items = new BigUint64Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBUBigIntVector(items, validity);
+        return new DuckDBUBigIntVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBUBigIntType.instance;
@@ -570,24 +820,39 @@ class DuckDBUBigIntVector extends DuckDBVector {
     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 DuckDBUBigIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBUBigIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBUBigIntVector = DuckDBUBigIntVector;
 class DuckDBFloatVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * Float32Array.BYTES_PER_ELEMENT);
         const items = new Float32Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBFloatVector(items, validity);
+        return new DuckDBFloatVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBFloatType.instance;
@@ -598,24 +863,39 @@ class DuckDBFloatVector extends DuckDBVector {
     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));
+        return new DuckDBFloatVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBFloatVector = DuckDBFloatVector;
 class DuckDBDoubleVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * Float64Array.BYTES_PER_ELEMENT);
         const items = new Float64Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBDoubleVector(items, validity);
+        return new DuckDBDoubleVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBDoubleType.instance;
@@ -626,24 +906,39 @@ class DuckDBDoubleVector extends DuckDBVector {
     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));
+        return new DuckDBDoubleVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBDoubleVector = DuckDBDoubleVector;
 class DuckDBTimestampVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
         const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBTimestampVector(items, validity);
+        return new DuckDBTimestampVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBTimestampType.instance;
@@ -652,26 +947,43 @@ class DuckDBTimestampVector extends DuckDBVector {
         return this.items.length;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? new values_1.DuckDBTimestampValue(this.items[itemIndex]) : null;
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimestampValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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 DuckDBTimestampVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBTimestampVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBTimestampVector = DuckDBTimestampVector;
 class DuckDBDateVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * Int32Array.BYTES_PER_ELEMENT);
         const items = new Int32Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBDateVector(items, validity);
+        return new DuckDBDateVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBDateType.instance;
@@ -680,26 +992,43 @@ class DuckDBDateVector extends DuckDBVector {
         return this.items.length;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? new values_1.DuckDBDateValue(this.items[itemIndex]) : null;
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBDateValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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));
+        return new DuckDBDateVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBDateVector = DuckDBDateVector;
 class DuckDBTimeVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
         const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBTimeVector(items, validity);
+        return new DuckDBTimeVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBTimeType.instance;
@@ -708,28 +1037,45 @@ class DuckDBTimeVector extends DuckDBVector {
         return this.items.length;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? new values_1.DuckDBTimeValue(this.items[itemIndex]) : null;
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimeValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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));
+        return new DuckDBTimeVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBTimeVector = DuckDBTimeVector;
 class DuckDBIntervalVector extends DuckDBVector {
     dataView;
     validity;
+    vector;
     _itemCount;
-    constructor(dataView, validity, 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 = vectorData(vector, itemCount * 16);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBIntervalVector(dataView, validity, itemCount);
+        return new DuckDBIntervalVector(dataView, validity, vector, itemCount);
     }
     get type() {
         return DuckDBType_1.DuckDBIntervalType.instance;
@@ -747,26 +1093,44 @@ class DuckDBIntervalVector extends DuckDBVector {
         const micros = getInt64(this.dataView, itemStart + 8);
         return new values_1.DuckDBIntervalValue(months, days, micros);
     }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            const itemStart = itemIndex * 16;
+            setInt32(this.dataView, itemStart, value.months);
+            setInt32(this.dataView, itemStart + 4, value.days);
+            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);
+        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;
 class DuckDBHugeIntVector extends DuckDBVector {
     dataView;
     validity;
+    vector;
     _itemCount;
-    constructor(dataView, validity, 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 = vectorData(vector, itemCount * 16);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBHugeIntVector(dataView, validity, itemCount);
+        return new DuckDBHugeIntVector(dataView, validity, vector, itemCount);
     }
     get type() {
         return DuckDBType_1.DuckDBHugeIntType.instance;
@@ -775,33 +1139,50 @@ class DuckDBHugeIntVector extends DuckDBVector {
         return this._itemCount;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? getInt128(this.dataView, itemIndex * 16) : null;
+        return this.validity.itemValid(itemIndex)
+            ? getInt128(this.dataView, itemIndex * 16)
+            : null;
     }
     getDouble(itemIndex) {
         return this.validity.itemValid(itemIndex)
             ? node_bindings_1.default.hugeint_to_double(getInt128(this.dataView, itemIndex * 16))
             : null;
     }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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);
+        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;
 class DuckDBUHugeIntVector extends DuckDBVector {
     dataView;
     validity;
+    vector;
     _itemCount;
-    constructor(dataView, validity, 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 = vectorData(vector, itemCount * 16);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBUHugeIntVector(dataView, validity, itemCount);
+        return new DuckDBUHugeIntVector(dataView, validity, vector, itemCount);
     }
     get type() {
         return DuckDBType_1.DuckDBUHugeIntType.instance;
@@ -810,33 +1191,56 @@ class DuckDBUHugeIntVector extends DuckDBVector {
         return this._itemCount;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? getUInt128(this.dataView, itemIndex * 16) : null;
+        return this.validity.itemValid(itemIndex)
+            ? getUInt128(this.dataView, itemIndex * 16)
+            : null;
     }
     getDouble(itemIndex) {
         return this.validity.itemValid(itemIndex)
             ? node_bindings_1.default.uhugeint_to_double(getUInt128(this.dataView, itemIndex * 16))
             : null;
     }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            setUInt128(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 DuckDBUHugeIntVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+        return new DuckDBUHugeIntVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, length);
     }
 }
 exports.DuckDBUHugeIntVector = DuckDBUHugeIntVector;
 class DuckDBVarCharVector extends DuckDBVector {
     dataView;
     validity;
+    vector;
+    itemOffset;
     _itemCount;
-    constructor(dataView, validity, 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 = vectorData(vector, itemCount * 16);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBVarCharVector(dataView, validity, itemCount);
+        return new DuckDBVarCharVector(dataView, validity, vector, 0, itemCount);
     }
     get type() {
         return DuckDBType_1.DuckDBVarCharType.instance;
@@ -845,28 +1249,61 @@ class DuckDBVarCharVector extends DuckDBVector {
         return this._itemCount;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? getString(this.dataView, itemIndex * 16) : null;
+        const cachedItem = this.itemCache[itemIndex];
+        if (cachedItem !== undefined) {
+            return cachedItem;
+        }
+        const item = this.validity.itemValid(itemIndex)
+            ? getString(this.dataView, itemIndex * 16)
+            : null;
+        this.itemCache[itemIndex] = item;
+        return item;
+    }
+    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(this.vector, this.itemOffset + itemIndex, cachedItem);
+                }
+                this.itemCacheDirty[itemIndex] = false;
+            }
+        }
+        this.validity.flush(this.vector);
     }
     slice(offset, length) {
-        return new DuckDBVarCharVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+        return new DuckDBVarCharVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, offset, length);
     }
 }
 exports.DuckDBVarCharVector = DuckDBVarCharVector;
 class DuckDBBlobVector extends DuckDBVector {
     dataView;
     validity;
+    vector;
+    itemOffset;
     _itemCount;
-    constructor(dataView, validity, 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 = vectorData(vector, itemCount * 16);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBBlobVector(dataView, validity, itemCount);
+        return new DuckDBBlobVector(dataView, validity, vector, 0, itemCount);
     }
     get type() {
         return DuckDBType_1.DuckDBBlobType.instance;
@@ -875,30 +1312,51 @@ class DuckDBBlobVector extends DuckDBVector {
         return this._itemCount;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? new values_1.DuckDBBlobValue(getBuffer(this.dataView, itemIndex * 16)) : null;
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBBlobValue(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 DuckDBBlobVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.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;
-class DuckDBDecimal2Vector extends DuckDBVector {
+class DuckDBDecimal16Vector extends DuckDBVector {
     decimalType;
     dataView;
     validity;
+    vector;
     _itemCount;
-    constructor(decimalType, dataView, validity, 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 = vectorData(vector, itemCount * 2);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBDecimal2Vector(decimalType, dataView, validity, itemCount);
+        return new DuckDBDecimal16Vector(decimalType, dataView, validity, vector, itemCount);
     }
     get type() {
         return this.decimalType;
@@ -907,33 +1365,52 @@ class DuckDBDecimal2Vector extends DuckDBVector {
         return this._itemCount;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? getDecimal2(this.dataView, itemIndex * 2, this.decimalType) : null;
+        return this.validity.itemValid(itemIndex)
+            ? getDecimal16(this.dataView, itemIndex * 2, this.decimalType)
+            : null;
     }
     getScaledValue(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? getInt16(this.dataView, itemIndex * 2) : null;
+        return this.validity.itemValid(itemIndex)
+            ? getInt16(this.dataView, itemIndex * 2)
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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 DuckDBDecimal2Vector(this.decimalType, new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 2, length * 2), this.validity.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.DuckDBDecimal2Vector = DuckDBDecimal2Vector;
-class DuckDBDecimal4Vector extends DuckDBVector {
+exports.DuckDBDecimal16Vector = DuckDBDecimal16Vector;
+class DuckDBDecimal32Vector extends DuckDBVector {
     decimalType;
     dataView;
     validity;
+    vector;
     _itemCount;
-    constructor(decimalType, dataView, validity, 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 = vectorData(vector, itemCount * 4);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBDecimal4Vector(decimalType, dataView, validity, itemCount);
+        return new DuckDBDecimal32Vector(decimalType, dataView, validity, vector, itemCount);
     }
     get type() {
         return this.decimalType;
@@ -942,33 +1419,52 @@ class DuckDBDecimal4Vector extends DuckDBVector {
         return this._itemCount;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? getDecimal4(this.dataView, itemIndex * 4, this.decimalType) : null;
+        return this.validity.itemValid(itemIndex)
+            ? getDecimal32(this.dataView, itemIndex * 4, this.decimalType)
+            : null;
     }
     getScaledValue(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? getInt32(this.dataView, itemIndex * 4) : null;
+        return this.validity.itemValid(itemIndex)
+            ? getInt32(this.dataView, itemIndex * 4)
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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 DuckDBDecimal4Vector(this.decimalType, new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 4, length * 4), this.validity.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.DuckDBDecimal4Vector = DuckDBDecimal4Vector;
-class DuckDBDecimal8Vector extends DuckDBVector {
+exports.DuckDBDecimal32Vector = DuckDBDecimal32Vector;
+class DuckDBDecimal64Vector extends DuckDBVector {
     decimalType;
     dataView;
     validity;
+    vector;
     _itemCount;
-    constructor(decimalType, dataView, validity, 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 = vectorData(vector, itemCount * 8);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBDecimal8Vector(decimalType, dataView, validity, itemCount);
+        return new DuckDBDecimal64Vector(decimalType, dataView, validity, vector, itemCount);
     }
     get type() {
         return this.decimalType;
@@ -977,33 +1473,52 @@ class DuckDBDecimal8Vector extends DuckDBVector {
         return this._itemCount;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? getDecimal8(this.dataView, itemIndex * 8, this.decimalType) : null;
+        return this.validity.itemValid(itemIndex)
+            ? getDecimal64(this.dataView, itemIndex * 8, this.decimalType)
+            : null;
     }
     getScaledValue(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? getInt64(this.dataView, itemIndex * 8) : null;
+        return this.validity.itemValid(itemIndex)
+            ? getInt64(this.dataView, itemIndex * 8)
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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 DuckDBDecimal8Vector(this.decimalType, new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 8, length * 8), this.validity.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.DuckDBDecimal8Vector = DuckDBDecimal8Vector;
-class DuckDBDecimal16Vector extends DuckDBVector {
+exports.DuckDBDecimal64Vector = DuckDBDecimal64Vector;
+class DuckDBDecimal128Vector extends DuckDBVector {
     decimalType;
     dataView;
     validity;
+    vector;
     _itemCount;
-    constructor(decimalType, dataView, validity, 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 = vectorData(vector, itemCount * 16);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBDecimal16Vector(decimalType, dataView, validity, itemCount);
+        return new DuckDBDecimal128Vector(decimalType, dataView, validity, vector, itemCount);
     }
     get type() {
         return this.decimalType;
@@ -1012,29 +1527,48 @@ class DuckDBDecimal16Vector extends DuckDBVector {
         return this._itemCount;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? getDecimal16(this.dataView, itemIndex * 16, this.decimalType) : null;
+        return this.validity.itemValid(itemIndex)
+            ? getDecimal128(this.dataView, itemIndex * 16, this.decimalType)
+            : null;
     }
     getScaledValue(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? getInt128(this.dataView, itemIndex * 16) : null;
+        return this.validity.itemValid(itemIndex)
+            ? getInt128(this.dataView, itemIndex * 16)
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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 DuckDBDecimal16Vector(this.decimalType, new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.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.DuckDBDecimal16Vector = DuckDBDecimal16Vector;
+exports.DuckDBDecimal128Vector = DuckDBDecimal128Vector;
 class DuckDBTimestampSecondsVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
         const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBTimestampSecondsVector(items, validity);
+        return new DuckDBTimestampSecondsVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBTimestampSecondsType.instance;
@@ -1043,26 +1577,43 @@ class DuckDBTimestampSecondsVector extends DuckDBVector {
         return this.items.length;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? new values_1.DuckDBTimestampSecondsValue(this.items[itemIndex]) : null;
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimestampSecondsValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            this.items[itemIndex] = value.seconds;
+            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 DuckDBTimestampSecondsVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBTimestampSecondsVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBTimestampSecondsVector = DuckDBTimestampSecondsVector;
 class DuckDBTimestampMillisecondsVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
         const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBTimestampMillisecondsVector(items, validity);
+        return new DuckDBTimestampMillisecondsVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBTimestampMillisecondsType.instance;
@@ -1071,26 +1622,43 @@ class DuckDBTimestampMillisecondsVector extends DuckDBVector {
         return this.items.length;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? new values_1.DuckDBTimestampMillisecondsValue(this.items[itemIndex]) : null;
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimestampMillisecondsValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            this.items[itemIndex] = value.milliseconds;
+            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));
+        return new DuckDBTimestampMillisecondsVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBTimestampMillisecondsVector = DuckDBTimestampMillisecondsVector;
 class DuckDBTimestampNanosecondsVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
         const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBTimestampNanosecondsVector(items, validity);
+        return new DuckDBTimestampNanosecondsVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBTimestampNanosecondsType.instance;
@@ -1099,28 +1667,45 @@ class DuckDBTimestampNanosecondsVector extends DuckDBVector {
         return this.items.length;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? new values_1.DuckDBTimestampNanosecondsValue(this.items[itemIndex]) : null;
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimestampNanosecondsValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            this.items[itemIndex] = value.nanoseconds;
+            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));
+        return new DuckDBTimestampNanosecondsVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBTimestampNanosecondsVector = DuckDBTimestampNanosecondsVector;
-class DuckDBEnum1Vector extends DuckDBVector {
+class DuckDBEnum8Vector extends DuckDBVector {
     enumType;
     items;
     validity;
-    constructor(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 = vectorData(vector, itemCount);
         const items = new Uint8Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBEnum1Vector(enumType, items, validity);
+        return new DuckDBEnum8Vector(enumType, items, validity, vector);
     }
     get type() {
         return this.enumType;
@@ -1129,28 +1714,45 @@ class DuckDBEnum1Vector extends DuckDBVector {
         return this.items.length;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? this.enumType.values[this.items[itemIndex]] : null;
+        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 DuckDBEnum1Vector(this.enumType, this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBEnum8Vector(this.enumType, this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
-exports.DuckDBEnum1Vector = DuckDBEnum1Vector;
-class DuckDBEnum2Vector extends DuckDBVector {
+exports.DuckDBEnum8Vector = DuckDBEnum8Vector;
+class DuckDBEnum16Vector extends DuckDBVector {
     enumType;
     items;
     validity;
-    constructor(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 = vectorData(vector, itemCount * 2);
         const items = new Uint16Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBEnum2Vector(enumType, items, validity);
+        return new DuckDBEnum16Vector(enumType, items, validity, vector);
     }
     get type() {
         return this.enumType;
@@ -1159,28 +1761,45 @@ class DuckDBEnum2Vector extends DuckDBVector {
         return this.items.length;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? this.enumType.values[this.items[itemIndex]] : null;
+        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 DuckDBEnum2Vector(this.enumType, this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBEnum16Vector(this.enumType, this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
-exports.DuckDBEnum2Vector = DuckDBEnum2Vector;
-class DuckDBEnum4Vector extends DuckDBVector {
+exports.DuckDBEnum16Vector = DuckDBEnum16Vector;
+class DuckDBEnum32Vector extends DuckDBVector {
     enumType;
     items;
     validity;
-    constructor(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 = vectorData(vector, itemCount * 4);
         const items = new Uint32Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBEnum4Vector(enumType, items, validity);
+        return new DuckDBEnum32Vector(enumType, items, validity, vector);
     }
     get type() {
         return this.enumType;
@@ -1189,26 +1808,49 @@ class DuckDBEnum4Vector extends DuckDBVector {
         return this.items.length;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? this.enumType.values[this.items[itemIndex]] : null;
+        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 DuckDBEnum4Vector(this.enumType, this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBEnum32Vector(this.enumType, this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
-exports.DuckDBEnum4Vector = DuckDBEnum4Vector;
+exports.DuckDBEnum32Vector = DuckDBEnum32Vector;
 class DuckDBListVector extends DuckDBVector {
+    parentList;
     listType;
     entryData;
     validity;
+    vector;
     childData;
+    itemOffset;
     _itemCount;
-    constructor(listType, entryData, validity, childData, 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._itemCount = itemCount;
+        this.itemOffset = itemOffset,
+            this._itemCount = itemCount;
+        this.itemCache = [];
     }
     static fromRawVector(listType, vector, itemCount) {
         const data = vectorData(vector, itemCount * BigUint64Array.BYTES_PER_ELEMENT * 2);
@@ -1217,7 +1859,7 @@ class DuckDBListVector extends DuckDBVector {
         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.create(child_vector, child_vector_size, listType.valueType);
-        return new DuckDBListVector(listType, entryData, validity, childData, itemCount);
+        return new DuckDBListVector(null, listType, entryData, validity, vector, childData, 0, itemCount);
     }
     get type() {
         return this.listType;
@@ -1235,15 +1877,78 @@ class DuckDBListVector extends DuckDBVector {
         return this.childData.slice(offset, length);
     }
     getItem(itemIndex) {
+        const cachedItem = this.itemCache[itemIndex];
+        if (cachedItem !== undefined) {
+            return cachedItem;
+        }
         const vector = this.getItemVector(itemIndex);
         if (!vector) {
             return null;
         }
-        return new values_1.DuckDBListValue(vector.toArray());
+        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;
+                }
+            }
+            // 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.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.listType, this.entryData.slice(entryDataStartIndex, entryDataStartIndex + length * 2), this.validity.slice(offset), this.childData, length);
+        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;
@@ -1252,12 +1957,14 @@ class DuckDBStructVector extends DuckDBVector {
     _itemCount;
     entryVectors;
     validity;
-    constructor(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;
@@ -1267,7 +1974,7 @@ class DuckDBStructVector extends DuckDBVector {
             entryVectors.push(DuckDBVector.create(child_vector, itemCount, structType.entryTypes[i]));
         }
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBStructVector(structType, itemCount, entryVectors, validity);
+        return new DuckDBStructVector(structType, itemCount, entryVectors, validity, vector);
     }
     get type() {
         return this.structType;
@@ -1282,7 +1989,8 @@ class DuckDBStructVector extends DuckDBVector {
         const entries = {};
         const entryCount = this.structType.entryCount;
         for (let i = 0; i < entryCount; i++) {
-            entries[this.structType.entryNames[i]] = this.entryVectors[i].getItem(itemIndex);
+            entries[this.structType.entryNames[i]] =
+                this.entryVectors[i].getItem(itemIndex);
         }
         return new values_1.DuckDBStructValue(entries);
     }
@@ -1292,8 +2000,33 @@ class DuckDBStructVector extends DuckDBVector {
         }
         return this.entryVectors[entryIndex].getItem(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));
+        return new DuckDBStructVector(this.structType, length, this.entryVectors.map((entryVector) => entryVector.slice(offset, length)), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBStructVector = DuckDBStructVector;
@@ -1333,6 +2066,17 @@ class DuckDBMapVector extends DuckDBVector {
         }
         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));
     }
@@ -1341,12 +2085,14 @@ exports.DuckDBMapVector = DuckDBMapVector;
 class DuckDBArrayVector extends DuckDBVector {
     arrayType;
     validity;
+    vector;
     childData;
     _itemCount;
-    constructor(arrayType, validity, childData, itemCount) {
+    constructor(arrayType, validity, vector, childData, itemCount) {
         super();
         this.arrayType = arrayType;
         this.validity = validity;
+        this.vector = vector;
         this.childData = childData;
         this._itemCount = itemCount;
     }
@@ -1355,7 +2101,7 @@ class DuckDBArrayVector extends DuckDBVector {
         const child_vector = node_bindings_1.default.array_vector_get_child(vector);
         const childItemsPerArray = DuckDBArrayVector.itemSize(arrayType) * arrayType.length;
         const childData = DuckDBVector.create(child_vector, itemCount * childItemsPerArray, arrayType.valueType);
-        return new DuckDBArrayVector(arrayType, validity, childData, itemCount);
+        return new DuckDBArrayVector(arrayType, validity, vector, childData, itemCount);
     }
     static itemSize(arrayType) {
         if (arrayType.valueType instanceof DuckDBType_1.DuckDBArrayType) {
@@ -1375,28 +2121,52 @@ class DuckDBArrayVector extends DuckDBVector {
         if (!this.validity.itemValid(itemIndex)) {
             return null;
         }
-        return new values_1.DuckDBArrayValue(this.childData.slice(itemIndex * this.arrayType.length, this.arrayType.length).toArray());
+        return new values_1.DuckDBArrayValue(this.childData
+            .slice(itemIndex * this.arrayType.length, this.arrayType.length)
+            .toArray());
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            const startIndex = itemIndex * this.arrayType.length;
+            for (let i = 0; i < this.arrayType.length; i++) {
+                this.childData.setItem(startIndex + i, value.items[i]);
+            }
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            const startIndex = itemIndex * this.arrayType.length;
+            for (let i = 0; i < this.arrayType.length; i++) {
+                this.childData.setItem(startIndex + i, null);
+            }
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    flush() {
+        this.childData.flush();
+        this.validity.flush(this.vector);
     }
     slice(offset, length) {
-        return new DuckDBArrayVector(this.arrayType, this.validity.slice(offset), this.childData.slice(offset * this.arrayType.length, length * this.arrayType.length), length);
+        return new DuckDBArrayVector(this.arrayType, this.validity.slice(offset, length), this.vector, this.childData.slice(offset * this.arrayType.length, length * this.arrayType.length), length);
     }
 }
 exports.DuckDBArrayVector = DuckDBArrayVector;
 class DuckDBUUIDVector extends DuckDBVector {
     dataView;
     validity;
+    vector;
     _itemCount;
-    constructor(dataView, validity, 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 = vectorData(vector, itemCount * 16);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBUUIDVector(dataView, validity, itemCount);
+        return new DuckDBUUIDVector(dataView, validity, vector, itemCount);
     }
     get type() {
         return DuckDBType_1.DuckDBUUIDType.instance;
@@ -1405,10 +2175,25 @@ class DuckDBUUIDVector extends DuckDBVector {
         return this._itemCount;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? new values_1.DuckDBUUIDValue(getInt128(this.dataView, itemIndex * 16)) : null;
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBUUIDValue(getInt128(this.dataView, itemIndex * 16))
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            setInt128(this.dataView, itemIndex * 16, value.hugeint);
+            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 DuckDBUUIDVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+        return new DuckDBUUIDVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, length);
     }
 }
 exports.DuckDBUUIDVector = DuckDBUUIDVector;
@@ -1449,6 +2234,27 @@ class DuckDBUnionVector extends DuckDBVector {
         const value = this.structVector.getItemValue(itemIndex, entryIndex);
         return new values_1.DuckDBUnionValue(tag, value);
     }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            const memberIndex = this.unionType.memberIndexForTag(value.tag);
+            this.structVector.setItemValue(itemIndex, 0, memberIndex);
+            const entryIndex = memberIndex + 1;
+            this.structVector.setItemValue(itemIndex, entryIndex, value.value);
+            for (let i = 1; i <= this.unionType.memberCount; i++) {
+                if (i !== entryIndex) {
+                    this.structVector.setItemValue(itemIndex, i, null);
+                }
+            }
+        }
+        else {
+            for (let i = 0; i <= this.unionType.memberCount; i++) {
+                this.structVector.setItemValue(itemIndex, i, null);
+            }
+        }
+    }
+    flush() {
+        this.structVector.flush();
+    }
     slice(offset, length) {
         return new DuckDBUnionVector(this.unionType, this.structVector.slice(offset, length));
     }
@@ -1457,18 +2263,26 @@ exports.DuckDBUnionVector = DuckDBUnionVector;
 class DuckDBBitVector extends DuckDBVector {
     dataView;
     validity;
+    vector;
+    itemOffset;
     _itemCount;
-    constructor(dataView, validity, 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 = vectorData(vector, itemCount * 16);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBBitVector(dataView, validity, itemCount);
+        return new DuckDBBitVector(dataView, validity, vector, 0, itemCount);
     }
     get type() {
         return DuckDBType_1.DuckDBBitType.instance;
@@ -1483,24 +2297,43 @@ class DuckDBBitVector extends DuckDBVector {
         const bytes = getStringBytes(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);
+        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;
 class DuckDBTimeTZVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * BigUint64Array.BYTES_PER_ELEMENT);
         const items = new BigUint64Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBTimeTZVector(items, validity);
+        return new DuckDBTimeTZVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBTimeTZType.instance;
@@ -1509,26 +2342,43 @@ class DuckDBTimeTZVector extends DuckDBVector {
         return this.items.length;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? values_1.DuckDBTimeTZValue.fromBits(this.items[itemIndex]) : null;
+        return this.validity.itemValid(itemIndex)
+            ? values_1.DuckDBTimeTZValue.fromBits(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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));
+        return new DuckDBTimeTZVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBTimeTZVector = DuckDBTimeTZVector;
 class DuckDBTimestampTZVector extends DuckDBVector {
     items;
     validity;
-    constructor(items, validity) {
+    vector;
+    constructor(items, validity, vector) {
         super();
         this.items = items;
         this.validity = validity;
+        this.vector = vector;
     }
     static fromRawVector(vector, itemCount) {
         const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
         const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBTimestampTZVector(items, validity);
+        return new DuckDBTimestampTZVector(items, validity, vector);
     }
     get type() {
         return DuckDBType_1.DuckDBTimestampTZType.instance;
@@ -1537,28 +2387,51 @@ class DuckDBTimestampTZVector extends DuckDBVector {
         return this.items.length;
     }
     getItem(itemIndex) {
-        return this.validity.itemValid(itemIndex) ? new values_1.DuckDBTimestampTZValue(this.items[itemIndex]) : null;
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimestampTZValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            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 DuckDBTimestampTZVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+        return new DuckDBTimestampTZVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
     }
 }
 exports.DuckDBTimestampTZVector = DuckDBTimestampTZVector;
 class DuckDBVarIntVector extends DuckDBVector {
     dataView;
     validity;
+    vector;
+    itemOffset;
     _itemCount;
-    constructor(dataView, validity, 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 = vectorData(vector, itemCount * 16);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const validity = DuckDBValidity.fromVector(vector, itemCount);
-        return new DuckDBVarIntVector(dataView, validity, itemCount);
+        return new DuckDBVarIntVector(dataView, validity, vector, 0, itemCount);
     }
     get type() {
         return DuckDBType_1.DuckDBVarIntType.instance;
@@ -1573,8 +2446,25 @@ class DuckDBVarIntVector extends DuckDBVector {
         const bytes = getStringBytes(this.dataView, itemIndex * 16);
         return bytes ? getVarIntFromBytes(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, getBytesFromVarInt(cachedItem));
+                }
+                this.itemCacheDirty[itemIndex] = false;
+            }
+        }
+        this.validity.flush(this.vector);
+    }
     slice(offset, length) {
-        return new DuckDBVarIntVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+        return new DuckDBVarIntVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, offset, length);
     }
 }
 exports.DuckDBVarIntVector = DuckDBVarIntVector;