diff --git a/README.md b/README.md index 00efb944..a4895163 100644 --- a/README.md +++ b/README.md @@ -117,7 +117,7 @@ node test.mjs Expected output for above example: ``` -v1.0.0 +v1.1.1 [col 0] bool::BOOLEAN [row 0] false [row 1] true diff --git a/api/src/DuckDBLogicalType.ts b/api/src/DuckDBLogicalType.ts index da365a1e..896a7d7e 100644 --- a/api/src/DuckDBLogicalType.ts +++ b/api/src/DuckDBLogicalType.ts @@ -1,5 +1,6 @@ import duckdb from '@duckdb/node-bindings'; import { + DuckDBAnyType, DuckDBArrayType, DuckDBBigIntType, DuckDBBitType, @@ -15,6 +16,7 @@ import { DuckDBIntervalType, DuckDBListType, DuckDBMapType, + DuckDBSQLNullType, DuckDBSmallIntType, DuckDBStructType, DuckDBTimeTZType, @@ -34,6 +36,7 @@ import { DuckDBUUIDType, DuckDBUnionType, DuckDBVarCharType, + DuckDBVarIntType, } from './DuckDBType'; import { DuckDBTypeId } from './DuckDBTypeId'; @@ -204,6 +207,12 @@ export class DuckDBLogicalType { return DuckDBTimeTZType.instance; case DuckDBTypeId.TIMESTAMP_TZ: return DuckDBTimestampTZType.instance; + case DuckDBTypeId.ANY: + return DuckDBAnyType.instance; + case DuckDBTypeId.VARINT: + return DuckDBVarIntType.instance; + case DuckDBTypeId.SQLNULL: + return DuckDBSQLNullType.instance; default: throw new Error(`Unexpected type id: ${this.typeId}`); } diff --git a/api/src/DuckDBType.ts b/api/src/DuckDBType.ts index a4864ede..773bcadc 100644 --- a/api/src/DuckDBType.ts +++ b/api/src/DuckDBType.ts @@ -266,6 +266,27 @@ export class DuckDBTimestampTZType extends BaseDuckDBType { public static readonly instance = new DuckDBTimestampTZType(); } +export class DuckDBAnyType extends BaseDuckDBType { + private constructor() { + super(DuckDBTypeId.ANY); + } + public static readonly instance = new DuckDBAnyType(); +} + +export class DuckDBVarIntType extends BaseDuckDBType { + private constructor() { + super(DuckDBTypeId.VARINT); + } + public static readonly instance = new DuckDBVarIntType(); +} + +export class DuckDBSQLNullType extends BaseDuckDBType { + private constructor() { + super(DuckDBTypeId.SQLNULL); + } + public static readonly instance = new DuckDBSQLNullType(); +} + export type DuckDBType = | DuckDBBooleanType | DuckDBTinyIntType @@ -300,4 +321,7 @@ export type DuckDBType = | DuckDBBitType | DuckDBTimeTZType | DuckDBTimestampTZType + | DuckDBAnyType + | DuckDBVarIntType + | DuckDBSQLNullType ; diff --git a/api/src/DuckDBTypeId.ts b/api/src/DuckDBTypeId.ts index 03e6dff1..0f440616 100644 --- a/api/src/DuckDBTypeId.ts +++ b/api/src/DuckDBTypeId.ts @@ -34,4 +34,7 @@ export enum DuckDBTypeId { BIT = 29, TIME_TZ = 30, TIMESTAMP_TZ = 31, + ANY = 34, + VARINT = 35, + SQLNULL = 36, } diff --git a/api/src/DuckDBVector.ts b/api/src/DuckDBVector.ts index 1349e414..26a3dd09 100644 --- a/api/src/DuckDBVector.ts +++ b/api/src/DuckDBVector.ts @@ -361,6 +361,12 @@ export abstract class DuckDBVector { return DuckDBTimeTZVector.fromRawVector(vector, itemCount); case DuckDBTypeId.TIMESTAMP_TZ: return DuckDBTimestampVector.fromRawVector(vector, itemCount); + case DuckDBTypeId.ANY: + throw new Error(`Vector not implemented for ANY type`); + case DuckDBTypeId.VARINT: + return DuckDBBlobVector.fromRawVector(vector, itemCount); // TODO: VARINT + case DuckDBTypeId.SQLNULL: + throw new Error(`Vector not implemented for SQLNULL type`); default: throw new Error(`Invalid type id: ${vectorType.typeId}`); } diff --git a/api/test/api.test.ts b/api/test/api.test.ts index 0934f262..f5fa6ab3 100644 --- a/api/test/api.test.ts +++ b/api/test/api.test.ts @@ -84,6 +84,7 @@ import { DuckDBUnionVector, DuckDBVarCharType, DuckDBVarCharVector, + DuckDBVarIntType, DuckDBVector, configurationOptionDescriptions, version @@ -150,7 +151,7 @@ const MaxTS_MS = (MaxInt64 - BI_1) / BI_1000; const MinTS_US = MinTS_MS * BI_1000; const MaxTS_US = MaxInt64 - BI_1; const TS_US_Inf = MaxInt64; -const MinTS_NS = MinInt64; +const MinTS_NS = -9223286400000000000n; const MaxTS_NS = MaxInt64 - BI_1; const MinFloat32 = Math.fround(-3.4028235e+38); const MaxFloat32 = Math.fround(3.4028235e+38); @@ -158,6 +159,26 @@ const MinFloat64 = -Number.MAX_VALUE; const MaxFloat64 = Number.MAX_VALUE; const MinUUID = MinInt128; const MaxUUID = MaxInt128; +const MinVarInt = new Uint8Array([0x7F, 0xFF, 0x7F, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +]); +const MaxVarInt = new Uint8Array([0x80, 0x00, 0x80, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +]); async function sleep(ms: number): Promise { return new Promise((resolve) => { @@ -444,6 +465,7 @@ describe('api', () => { { name: 'usmallint', type: DuckDBUSmallIntType.instance }, { name: 'uint', type: DuckDBUIntegerType.instance }, { name: 'ubigint', type: DuckDBUBigIntType.instance }, + { name: 'varint', type: DuckDBVarIntType.instance }, { name: 'date', type: DuckDBDateType.instance }, { name: 'time', type: DuckDBTimeType.instance }, { name: 'timestamp', type: DuckDBTimestampType.instance }, @@ -508,7 +530,7 @@ describe('api', () => { const chunk = await result.fetchChunk(); try { - assert.strictEqual(chunk.columnCount, 53); + assert.strictEqual(chunk.columnCount, 54); assert.strictEqual(chunk.rowCount, 3); assertValues(chunk, 0, DuckDBBooleanVector, [false, true, null]); @@ -522,95 +544,96 @@ describe('api', () => { assertValues(chunk, 8, DuckDBUSmallIntVector, [MinUInt16, MaxUInt16, null]); assertValues(chunk, 9, DuckDBUIntegerVector, [MinUInt32, MaxUInt32, null]); assertValues(chunk, 10, DuckDBUBigIntVector, [MinUInt64, MaxUInt64, null]); - assertValues(chunk, 11, DuckDBDateVector, [MinDate, MaxDate, null]); - assertValues(chunk, 12, DuckDBTimeVector, [MinTime, MaxTime, null]); - assertValues(chunk, 13, DuckDBTimestampVector, [MinTS_US, MaxTS_US, null]); - assertValues(chunk, 14, DuckDBTimestampSecondsVector, [MinTS_S, MaxTS_S, null]); - assertValues(chunk, 15, DuckDBTimestampMillisecondsVector, [MinTS_MS, MaxTS_MS, null]); - assertValues(chunk, 16, DuckDBTimestampNanosecondsVector, [MinTS_NS, MaxTS_NS, null]); - assertValues(chunk, 17, DuckDBTimeTZVector, [MinTimeTZ, MaxTimeTZ, null]); - assertValues(chunk, 18, DuckDBTimestampVector, [MinTS_US, MaxTS_US, null]); - assertValues(chunk, 19, DuckDBFloatVector, [MinFloat32, MaxFloat32, null]); - assertValues(chunk, 20, DuckDBDoubleVector, [MinFloat64, MaxFloat64, null]); - assertValues(chunk, 21, DuckDBDecimal2Vector, [ + assertValues(chunk, 11, DuckDBBlobVector, [MinVarInt, MaxVarInt, null]); + assertValues(chunk, 12, DuckDBDateVector, [MinDate, MaxDate, null]); + assertValues(chunk, 13, DuckDBTimeVector, [MinTime, MaxTime, null]); + assertValues(chunk, 14, DuckDBTimestampVector, [MinTS_US, MaxTS_US, null]); + assertValues(chunk, 15, DuckDBTimestampSecondsVector, [MinTS_S, MaxTS_S, null]); + assertValues(chunk, 16, DuckDBTimestampMillisecondsVector, [MinTS_MS, MaxTS_MS, null]); + assertValues(chunk, 17, DuckDBTimestampNanosecondsVector, [MinTS_NS, MaxTS_NS, null]); + assertValues(chunk, 18, DuckDBTimeTZVector, [MinTimeTZ, MaxTimeTZ, null]); + assertValues(chunk, 19, DuckDBTimestampVector, [MinTS_US, MaxTS_US, null]); + assertValues(chunk, 20, DuckDBFloatVector, [MinFloat32, MaxFloat32, null]); + assertValues(chunk, 21, DuckDBDoubleVector, [MinFloat64, MaxFloat64, null]); + assertValues(chunk, 22, DuckDBDecimal2Vector, [ new DuckDBSmallDecimal(-9999, new DuckDBDecimalType(4, 1)), new DuckDBSmallDecimal(9999, new DuckDBDecimalType(4, 1)), null, ]); - assertValues(chunk, 22, DuckDBDecimal4Vector, [ + assertValues(chunk, 23, DuckDBDecimal4Vector, [ new DuckDBSmallDecimal(-999999999, new DuckDBDecimalType(9, 4)), new DuckDBSmallDecimal(999999999, new DuckDBDecimalType(9, 4)), null, ]); - assertValues(chunk, 23, DuckDBDecimal8Vector, [ + assertValues(chunk, 24, DuckDBDecimal8Vector, [ new DuckDBLargeDecimal(-BI_18_9s, new DuckDBDecimalType(18, 6)), new DuckDBLargeDecimal(BI_18_9s, new DuckDBDecimalType(18, 6)), null, ]); - assertValues(chunk, 24, DuckDBDecimal16Vector, [ + assertValues(chunk, 25, DuckDBDecimal16Vector, [ new DuckDBLargeDecimal(-BI_38_9s, new DuckDBDecimalType(38, 10)), new DuckDBLargeDecimal(BI_38_9s, new DuckDBDecimalType(38, 10)), null, ]); - assertValues(chunk, 25, DuckDBUUIDVector, [MinUUID, MaxUUID, null]); - assertValues(chunk, 26, DuckDBIntervalVector, [ + assertValues(chunk, 26, DuckDBUUIDVector, [MinUUID, MaxUUID, null]); + assertValues(chunk, 27, DuckDBIntervalVector, [ new DuckDBInterval(0, 0, BigInt(0)), new DuckDBInterval(999, 999, BigInt(999999999)), null, ]); - assertValues(chunk, 27, DuckDBVarCharVector, ['🦆🦆🦆🦆🦆🦆', 'goo\0se', null]); - assertValues(chunk, 28, DuckDBBlobVector, [ + assertValues(chunk, 28, DuckDBVarCharVector, ['🦆🦆🦆🦆🦆🦆', 'goo\0se', null]); + assertValues(chunk, 29, DuckDBBlobVector, [ blobFromString('thisisalongblob\x00withnullbytes'), blobFromString('\x00\x00\x00a'), null, ]); - assertValues(chunk, 29, DuckDBBitVector, [ + assertValues(chunk, 30, DuckDBBitVector, [ DuckDBBitValue.fromString('0010001001011100010101011010111'), DuckDBBitValue.fromString('10101'), null, ]); - assertValues(chunk, 30, DuckDBEnum1Vector, [ + assertValues(chunk, 31, DuckDBEnum1Vector, [ smallEnumValues[0], smallEnumValues[smallEnumValues.length - 1], null, ]); - assertValues(chunk, 31, DuckDBEnum2Vector, [ + assertValues(chunk, 32, DuckDBEnum2Vector, [ mediumEnumValues[0], mediumEnumValues[mediumEnumValues.length - 1], null, ]); - assertValues(chunk, 32, DuckDBEnum4Vector, [ + assertValues(chunk, 33, DuckDBEnum4Vector, [ largeEnumValues[0], largeEnumValues[largeEnumValues.length - 1], null, ]); // int_array - assertNestedValues, DuckDBListVector>(chunk, 33, DuckDBListVector, [ + assertNestedValues, DuckDBListVector>(chunk, 34, DuckDBListVector, [ (v, n) => assertVectorValues(v, [], n), (v, n) => assertVectorValues(v, [42, 999, null, null, -42], n), (v, n) => assert.strictEqual(v, null, n), ]); // double_array - assertNestedValues, DuckDBListVector>(chunk, 34, DuckDBListVector, [ + assertNestedValues, DuckDBListVector>(chunk, 35, DuckDBListVector, [ (v, n) => assertVectorValues(v, [], n), (v, n) => assertVectorValues(v, [42.0, NaN, Infinity, -Infinity, null, -42.0], n), (v, n) => assert.strictEqual(v, null, n), ]); // date_array - assertNestedValues, DuckDBListVector>(chunk, 35, DuckDBListVector, [ + assertNestedValues, DuckDBListVector>(chunk, 36, DuckDBListVector, [ (v, n) => assertVectorValues(v, [], n), (v, n) => assertVectorValues(v, [0, DateInf, -DateInf, null, 19124], n), (v, n) => assert.strictEqual(v, null, n), ]); // timestamp_array - assertNestedValues, DuckDBListVector>(chunk, 36, DuckDBListVector, [ + assertNestedValues, DuckDBListVector>(chunk, 37, DuckDBListVector, [ (v, n) => assertVectorValues(v, [], n), // 1652372625 is 2022-05-12 16:23:45 (v, n) => assertVectorValues(v, [BI_0, TS_US_Inf, -TS_US_Inf, null, BigInt(1652372625)*BI_1000*BI_1000], n), (v, n) => assert.strictEqual(v, null, n), ]); // timestamptz_array - assertNestedValues, DuckDBListVector>(chunk, 37, DuckDBListVector, [ + assertNestedValues, DuckDBListVector>(chunk, 38, DuckDBListVector, [ (v, n) => assertVectorValues(v, [], n), // 1652397825 = 1652372625 + 25200, 25200 = 7 * 60 * 60 = 7 hours in seconds // This 7 hour difference is hard coded into test_all_types (value is 2022-05-12 16:23:45-07) @@ -618,14 +641,14 @@ describe('api', () => { (v, n) => assert.strictEqual(v, null, n), ]); // varchar_array - assertNestedValues, DuckDBListVector>(chunk, 38, DuckDBListVector, [ + assertNestedValues, DuckDBListVector>(chunk, 39, DuckDBListVector, [ (v, n) => assertVectorValues(v, [], n), // Note that the string 'goose' in varchar_array does NOT have an embedded null character. (v, n) => assertVectorValues(v, ['🦆🦆🦆🦆🦆🦆', 'goose', null, ''], n), (v, n) => assert.strictEqual(v, null, n), ]); // nested_int_array - assertNestedValues>, DuckDBListVector>>(chunk, 39, DuckDBListVector, [ + assertNestedValues>, DuckDBListVector>>(chunk, 40, DuckDBListVector, [ (v, n) => { assert.ok(v, `${n} unexpectedly null`); if (!v) return; @@ -640,13 +663,13 @@ describe('api', () => { ], n), (v, n) => assert.strictEqual(v, null, n), ]); - assertValues(chunk, 40, DuckDBStructVector, [ + assertValues(chunk, 41, DuckDBStructVector, [ [{ name: 'a', value: null }, { name: 'b', value: null }], [{ name: 'a', value: 42 }, { name: 'b', value: '🦆🦆🦆🦆🦆🦆' }], null, ] as (readonly DuckDBStructEntry[])[]); // struct_of_arrays - assertNestedValues(chunk, 41, DuckDBStructVector, [ + assertNestedValues(chunk, 42, DuckDBStructVector, [ (entries, n) => assert.deepStrictEqual(entries, [{ name: 'a', value: null }, { name: 'b', value: null }], n), (entries, n) => { assert.ok(entries, `${n} unexpectedly null`); @@ -662,7 +685,7 @@ describe('api', () => { (entries, n) => assert.strictEqual(entries, null, n), ]); // array_of_structs - assertNestedValues, DuckDBListVector>(chunk, 42, DuckDBListVector, [ + assertNestedValues, DuckDBListVector>(chunk, 43, DuckDBListVector, [ (v, n) => assertVectorValues(v, [], n), (v, n) => assertVectorValues(v, [ [{ name: 'a', value: null }, { name: 'b', value: null }], @@ -671,30 +694,30 @@ describe('api', () => { ], n), (v, n) => assert.strictEqual(v, null, n), ]); - assertValues(chunk, 43, DuckDBMapVector, [ + assertValues(chunk, 44, DuckDBMapVector, [ [], [{ key: 'key1', value: '🦆🦆🦆🦆🦆🦆' }, { key: 'key2', value: 'goose' }], null, ] as (readonly DuckDBMapEntry[])[]); - assertValues(chunk, 44, DuckDBUnionVector, [ + assertValues(chunk, 45, DuckDBUnionVector, [ { tag: 'name', value: 'Frank' }, { tag: 'age', value: 5 }, null, ]); // fixed_int_array - assertNestedValues, DuckDBArrayVector>(chunk, 45, DuckDBArrayVector, [ + assertNestedValues, DuckDBArrayVector>(chunk, 46, DuckDBArrayVector, [ (v, n) => assertVectorValues(v, [null, 2, 3], n), (v, n) => assertVectorValues(v, [4, 5, 6], n), (v, n) => assert.strictEqual(v, null, n), ]); // fixed_varchar_array - assertNestedValues, DuckDBArrayVector>(chunk, 46, DuckDBArrayVector, [ + assertNestedValues, DuckDBArrayVector>(chunk, 47, DuckDBArrayVector, [ (v, n) => assertVectorValues(v, ['a', null, 'c'], n), (v, n) => assertVectorValues(v, ['d', 'e', 'f'], n), (v, n) => assert.strictEqual(v, null, n), ]); // fixed_nested_int_array - assertNestedValues>, DuckDBArrayVector>(chunk, 47, DuckDBArrayVector, [ + assertNestedValues>, DuckDBArrayVector>(chunk, 48, DuckDBArrayVector, [ (v, n) => assertNestedVectorValues(v, [ (vv, nn) => assertVectorValues(vv, [null, 2, 3], nn), (vv, nn) => assert.strictEqual(vv, null, nn), @@ -708,7 +731,7 @@ describe('api', () => { (v, n) => assert.strictEqual(v, null, n), ]); // fixed_nested_varchar_array - assertNestedValues>, DuckDBArrayVector>(chunk, 48, DuckDBArrayVector, [ + assertNestedValues>, DuckDBArrayVector>(chunk, 49, DuckDBArrayVector, [ (v, n) => assertNestedVectorValues(v, [ (vv, nn) => assertVectorValues(vv, ['a', null, 'c'], nn), (vv, nn) => assert.strictEqual(vv, null, nn), @@ -722,7 +745,7 @@ describe('api', () => { (v, n) => assert.strictEqual(v, null, n), ]); // fixed_struct_array - assertNestedValues, DuckDBArrayVector>(chunk, 49, DuckDBArrayVector, [ + assertNestedValues, DuckDBArrayVector>(chunk, 50, DuckDBArrayVector, [ (v, n) => assertVectorValues(v, [ [{ name: 'a', value: null }, { name: 'b', value: null }], [{ name: 'a', value: 42 }, { name: 'b', value: '🦆🦆🦆🦆🦆🦆' }], @@ -736,7 +759,7 @@ describe('api', () => { (v, n) => assert.strictEqual(v, null, n), ]); // struct_of_fixed_array - assertNestedValues(chunk, 50, DuckDBStructVector, [ + assertNestedValues(chunk, 51, DuckDBStructVector, [ (entries, n) => { assert.ok(entries, `${n} unexpectedly null`); if (!entries) return; @@ -762,7 +785,7 @@ describe('api', () => { (entries, n) => assert.strictEqual(entries, null, n), ]); // fixed_array_of_int_list - assertNestedValues>, DuckDBArrayVector>(chunk, 51, DuckDBArrayVector, [ + assertNestedValues>, DuckDBArrayVector>(chunk, 52, DuckDBArrayVector, [ (v, n) => assertNestedVectorValues(v, [ (vv, nn) => assertVectorValues(vv, [], nn), (vv, nn) => assertVectorValues(vv, [42, 999, null, null, -42], nn), @@ -776,7 +799,7 @@ describe('api', () => { (v, n) => assert.strictEqual(v, null, n), ]); // list_of_fixed_int_array - assertNestedValues>, DuckDBListVector>(chunk, 52, DuckDBListVector, [ + assertNestedValues>, DuckDBListVector>(chunk, 53, DuckDBListVector, [ (v, n) => assertNestedVectorValues(v, [ (vv, nn) => assertVectorValues(vv, [null, 2, 3], nn), (vv, nn) => assertVectorValues(vv, [4, 5, 6], nn), diff --git a/bindings/pkgs/@duckdb/node-bindings/duckdb.d.ts b/bindings/pkgs/@duckdb/node-bindings/duckdb.d.ts index d99c159a..b792e159 100644 --- a/bindings/pkgs/@duckdb/node-bindings/duckdb.d.ts +++ b/bindings/pkgs/@duckdb/node-bindings/duckdb.d.ts @@ -82,6 +82,9 @@ export enum Type { BIT = 29, TIME_TZ = 30, TIMESTAMP_TZ = 31, + ANY = 34, + VARINT = 35, + SQLNULL = 36, } diff --git a/bindings/scripts/fetch_libduckdb_linux.py b/bindings/scripts/fetch_libduckdb_linux.py index 8eaf4f4b..6cf342b0 100644 --- a/bindings/scripts/fetch_libduckdb_linux.py +++ b/bindings/scripts/fetch_libduckdb_linux.py @@ -1,7 +1,7 @@ import os from fetch_libduckdb import fetch_libduckdb -zip_url = "https://github.com/duckdb/duckdb/releases/download/v1.0.0/libduckdb-linux-amd64.zip" +zip_url = "https://github.com/duckdb/duckdb/releases/download/v1.1.1/libduckdb-linux-amd64.zip" output_dir = os.path.join(os.path.dirname(__file__), "..", "libduckdb") files = [ "duckdb.h", diff --git a/bindings/scripts/fetch_libduckdb_mac.py b/bindings/scripts/fetch_libduckdb_mac.py index f88eab10..f6a255e7 100644 --- a/bindings/scripts/fetch_libduckdb_mac.py +++ b/bindings/scripts/fetch_libduckdb_mac.py @@ -1,7 +1,7 @@ import os from fetch_libduckdb import fetch_libduckdb -zip_url = "https://github.com/duckdb/duckdb/releases/download/v1.0.0/libduckdb-osx-universal.zip" +zip_url = "https://github.com/duckdb/duckdb/releases/download/v1.1.1/libduckdb-osx-universal.zip" output_dir = os.path.join(os.path.dirname(__file__), "..", "libduckdb") files = [ "duckdb.h", diff --git a/bindings/scripts/fetch_libduckdb_win.py b/bindings/scripts/fetch_libduckdb_win.py index 7274fc71..8e3a6652 100644 --- a/bindings/scripts/fetch_libduckdb_win.py +++ b/bindings/scripts/fetch_libduckdb_win.py @@ -1,7 +1,7 @@ import os from fetch_libduckdb import fetch_libduckdb -zip_url = "https://github.com/duckdb/duckdb/releases/download/v1.0.0/libduckdb-windows-amd64.zip" +zip_url = "https://github.com/duckdb/duckdb/releases/download/v1.1.1/libduckdb-windows-amd64.zip" output_dir = os.path.join(os.path.dirname(__file__), "..", "libduckdb") files = [ "duckdb.h", diff --git a/bindings/src/duckdb_node_bindings.cpp b/bindings/src/duckdb_node_bindings.cpp index 717c357c..d889c009 100644 --- a/bindings/src/duckdb_node_bindings.cpp +++ b/bindings/src/duckdb_node_bindings.cpp @@ -802,6 +802,9 @@ Napi::Object CreateTypeEnum(Napi::Env env) { DefineEnumMember(typeEnum, "BIT", 29); DefineEnumMember(typeEnum, "TIME_TZ", 30); DefineEnumMember(typeEnum, "TIMESTAMP_TZ", 31); + DefineEnumMember(typeEnum, "ANY", 34); + DefineEnumMember(typeEnum, "VARINT", 35); + DefineEnumMember(typeEnum, "SQLNULL", 36); return typeEnum; } @@ -1095,6 +1098,7 @@ class DuckDBNodeAddon : public Napi::Addon { auto env = info.Env(); duckdb_config config; if (duckdb_create_config(&config)) { + duckdb_destroy_config(&config); throw Napi::Error::New(env, "Failed to create config"); } return CreateExternalForConfig(env, config); diff --git a/bindings/test/config.test.ts b/bindings/test/config.test.ts index 6aa1274a..e0d2d257 100644 --- a/bindings/test/config.test.ts +++ b/bindings/test/config.test.ts @@ -3,11 +3,11 @@ import { expect, suite, test } from 'vitest'; suite('config', () => { test('config_count', () => { - expect(duckdb.config_count()).toBe(78); + expect(duckdb.config_count()).toBe(100); }); test('get_config_flag', () => { expect(duckdb.get_config_flag(0).name).toBe('access_mode'); - expect(duckdb.get_config_flag(77).name).toBe('http_logging_output'); + expect(duckdb.get_config_flag(99).name).toBe('http_logging_output'); }); test('get_config_flag out of bounds', () => { expect(() => duckdb.get_config_flag(-1)).toThrowError(/^Config option not found$/); diff --git a/bindings/test/constants.test.ts b/bindings/test/constants.test.ts index 6feb08a4..e7bcaf31 100644 --- a/bindings/test/constants.test.ts +++ b/bindings/test/constants.test.ts @@ -6,7 +6,7 @@ suite('constants', () => { expect(duckdb.sizeof_bool).toBe(1); }); test('library_version', () => { - expect(duckdb.library_version()).toBe('v1.0.0'); + expect(duckdb.library_version()).toBe('v1.1.1'); }); test('vector_size', () => { expect(duckdb.vector_size()).toBe(2048); diff --git a/bindings/test/prepared_statements.test.ts b/bindings/test/prepared_statements.test.ts index 55cdc38e..96850695 100644 --- a/bindings/test/prepared_statements.test.ts +++ b/bindings/test/prepared_statements.test.ts @@ -290,7 +290,7 @@ suite('prepared statements', () => { expect(duckdb.param_type(prepared, 20)).toBe(duckdb.Type.BLOB); duckdb.bind_null(prepared, 21); - expect(duckdb.param_type(prepared, 21)).toBe(duckdb.Type.INVALID); + expect(duckdb.param_type(prepared, 21)).toBe(duckdb.Type.SQLNULL); const result = await duckdb.execute_prepared(prepared); try { diff --git a/bindings/test/query.test.ts b/bindings/test/query.test.ts index 708982c7..2e7ae749 100644 --- a/bindings/test/query.test.ts +++ b/bindings/test/query.test.ts @@ -36,6 +36,7 @@ import { UTINYINT, UUID, VARCHAR, + VARINT, } from './utils/expectedLogicalTypes'; import { array, data, list, map, struct, union } from './utils/expectedVectors'; import { expectResult } from './utils/expectResult'; @@ -84,6 +85,7 @@ suite('query', () => { { name: 'usmallint', logicalType: USMALLINT }, { name: 'uint', logicalType: UINTEGER }, { name: 'ubigint', logicalType: UBIGINT }, + { name: 'varint', logicalType: VARINT }, { name: 'date', logicalType: DATE }, { name: 'time', logicalType: TIME }, { name: 'timestamp', logicalType: TIMESTAMP }, @@ -145,93 +147,116 @@ suite('query', () => { data(2, validity, [0, 65535, null]), // 8: usmallint data(4, validity, [0, 4294967295, null]), // 9: uint data(8, validity, [0n, 18446744073709551615n, null]), // 10: ubigint - data(4, validity, [-2147483646, 2147483646, null]), // 11: date - data(8, validity, [0n, 86400000000n, null]), // 12: time - data(8, validity, [-9223372022400000000n, 9223372036854775806n, null]), // 13: timestamp - data(8, validity, [-9223372022400n, 9223372036854n, null]), // 14: timestamp_s - data(8, validity, [-9223372022400000n, 9223372036854775n, null]), // 15: timestamp_ms - data(8, validity, [-9223372036854775808n, 9223372036854775806n, null]), // 16: timestamp_ns - data(8, validity, [0n, 1449551462400115198n, null]), // 17: time_tz - data(8, validity, [-9223372022400000000n, 9223372036854775806n, null]), // 18: timestamp_tz - data(4, validity, [-3.4028234663852886e+38, 3.4028234663852886e+38, null]), // 19: float - data(8, validity, [-1.7976931348623157e+308, 1.7976931348623157e+308, null]), // 20: double - data(2, validity, [-9999, 9999, null]), // 21: dec_4_1 - data(4, validity, [-999999999, 999999999, null]), // 22: dec_9_4 - data(8, validity, [-999999999999999999n, 999999999999999999n, null]), // 23: dec_18_6 - data(16, validity, [-99999999999999999999999999999999999999n, 99999999999999999999999999999999999999n, null]), // 24: dec38_10 - data(16, validity, [-170141183460469231731687303715884105728n, 170141183460469231731687303715884105727n, null]), // 25: uuid - data(16, validity, [{ months: 0, days: 0, micros: 0n }, { months: 999, days: 999, micros: 999999999n }, null]), // 26: interval - data(16, validity, ['🦆🦆🦆🦆🦆🦆', 'goo\0se', null]), // 27: varchar - data(16, validity, [Buffer.from('thisisalongblob\x00withnullbytes'), Buffer.from('\x00\x00\x00a'), null]), // 28: blob - data(16, validity, [Buffer.from([1, 0b10010001, 0b00101110, 0b00101010, 0b11010111]), Buffer.from([3, 0b11110101]), null]), // 29: bit (x0010001 00101110 00101010 11010111, xxx10101) - data(1, validity, [0, 1, null]), // 30: small_enum - data(2, validity, [0, 299, null]), // 31: medium_enum - data(4, validity, [0, useLargeEnum ? 69999 : 1, null]), // 32: large_enum - list(validity, [[0n, 0n], [0n, 5n], null], 5, data(4, [true, true, false, false, true], [42, 999, null, null, -42])), // 33: int_array - list(validity, [[0n, 0n], [0n, 6n], null], 6, data(8, [true, true, true, true, false, true], [42.0, NaN, Infinity, -Infinity, null, -42.0])), // 34: double_array - list(validity, [[0n, 0n], [0n, 5n], null], 5, data(4, [true, true, true, false, true], [0, 2147483647, -2147483647, null, 19124])), // 35: date_array - list(validity, [[0n, 0n], [0n, 5n], null], 5, data(8, [true, true, true, false, true], [0n, 9223372036854775807n, -9223372036854775807n, null, 1652372625000000n])), // 36: timestamp_array - list(validity, [[0n, 0n], [0n, 5n], null], 5, data(8, [true, true, true, false, true], [0n, 9223372036854775807n, -9223372036854775807n, null, 1652397825000000n])), // 37: timestamptz_array - list(validity, [[0n, 0n], [0n, 4n], null], 4, data(16, [true, true, false, true], ['🦆🦆🦆🦆🦆🦆', 'goose', null, ''])), // 38: varchar_array + data(16, validity, [ + Buffer.from(new Uint8Array([0x7F, 0xFF, 0x7F, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + ])), + Buffer.from(new Uint8Array([0x80, 0x00, 0x80, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + ])), + null] + ), // 11: varint + data(4, validity, [-2147483646, 2147483646, null]), // 12: date + data(8, validity, [0n, 86400000000n, null]), // 13: time + data(8, validity, [-9223372022400000000n, 9223372036854775806n, null]), // 14: timestamp + data(8, validity, [-9223372022400n, 9223372036854n, null]), // 15: timestamp_s + data(8, validity, [-9223372022400000n, 9223372036854775n, null]), // 16: timestamp_ms + data(8, validity, [-9223286400000000000n, 9223372036854775806n, null]), // 17: timestamp_ns + data(8, validity, [0n, 1449551462400115198n, null]), // 18: time_tz + data(8, validity, [-9223372022400000000n, 9223372036854775806n, null]), // 19: timestamp_tz + data(4, validity, [-3.4028234663852886e+38, 3.4028234663852886e+38, null]), // 20: float + data(8, validity, [-1.7976931348623157e+308, 1.7976931348623157e+308, null]), // 21: double + data(2, validity, [-9999, 9999, null]), // 22: dec_4_1 + data(4, validity, [-999999999, 999999999, null]), // 23: dec_9_4 + data(8, validity, [-999999999999999999n, 999999999999999999n, null]), // 24: dec_18_6 + data(16, validity, [-99999999999999999999999999999999999999n, 99999999999999999999999999999999999999n, null]), // 25: dec38_10 + data(16, validity, [-170141183460469231731687303715884105728n, 170141183460469231731687303715884105727n, null]), // 26: uuid + data(16, validity, [{ months: 0, days: 0, micros: 0n }, { months: 999, days: 999, micros: 999999999n }, null]), // 27: interval + data(16, validity, ['🦆🦆🦆🦆🦆🦆', 'goo\0se', null]), // 28: varchar + data(16, validity, [Buffer.from('thisisalongblob\x00withnullbytes'), Buffer.from('\x00\x00\x00a'), null]), // 29: blob + data(16, validity, [Buffer.from([1, 0b10010001, 0b00101110, 0b00101010, 0b11010111]), Buffer.from([3, 0b11110101]), null]), // 30: bit (x0010001 00101110 00101010 11010111, xxx10101) + data(1, validity, [0, 1, null]), // 31: small_enum + data(2, validity, [0, 299, null]), // 32: medium_enum + data(4, validity, [0, useLargeEnum ? 69999 : 1, null]), // 33: large_enum + list(validity, [[0n, 0n], [0n, 5n], null], 5, data(4, [true, true, false, false, true], [42, 999, null, null, -42])), // 34: int_array + list(validity, [[0n, 0n], [0n, 6n], null], 6, data(8, [true, true, true, true, false, true], [42.0, NaN, Infinity, -Infinity, null, -42.0])), // 35: double_array + list(validity, [[0n, 0n], [0n, 5n], null], 5, data(4, [true, true, true, false, true], [0, 2147483647, -2147483647, null, 19124])), // 36: date_array + list(validity, [[0n, 0n], [0n, 5n], null], 5, data(8, [true, true, true, false, true], [0n, 9223372036854775807n, -9223372036854775807n, null, 1652372625000000n])), // 37: timestamp_array + list(validity, [[0n, 0n], [0n, 5n], null], 5, data(8, [true, true, true, false, true], [0n, 9223372036854775807n, -9223372036854775807n, null, 1652397825000000n])), // 38: timestamptz_array + list(validity, [[0n, 0n], [0n, 4n], null], 4, data(16, [true, true, false, true], ['🦆🦆🦆🦆🦆🦆', 'goose', null, ''])), // 39: varchar_array list(validity, [[0n, 0n], [0n, 5n], null], 5, list([true, true, false, true, true], [[0n, 0n], [0n, 5n], null, [5n, 0n], [5n, 5n]], 10, - data(10, [true, true, false, false, true, true, true, false, false, true], [42, 999, null, null, -42, 42, 999, null, null, -42]))), // 39: nested_int_array - struct(3, validity, [data(4, [false, true, false], [null, 42, null]), data(16, [false, true, false], [null, '🦆🦆🦆🦆🦆🦆', null])]), // 40: struct + data(10, [true, true, false, false, true, true, true, false, false, true], [42, 999, null, null, -42, 42, 999, null, null, -42]))), // 40: nested_int_array + struct(3, validity, [data(4, [false, true, false], [null, 42, null]), data(16, [false, true, false], [null, '🦆🦆🦆🦆🦆🦆', null])]), // 41: struct struct(3, validity, [ list([false, true, false], [null, [0n, 5n], null], 5, data(4, [true, true, false, false, true], [42, 999, null, null, -42])), list([false, true, false], [null, [0n, 4n], null], 4, data(16, [true, true, false, true], ['🦆🦆🦆🦆🦆🦆', 'goose', null, ''])), - ]), // 41: struct_of_arrays + ]), // 42: struct_of_arrays list(validity, [[0n, 0n], [0n, 3n], null], 3, struct(3, [true, true, false], [ data(4, [false, true], [null, 42]), data(16, [false, true], [null, '🦆🦆🦆🦆🦆🦆']), ]) - ), // 42: array_of_structs + ), // 43: array_of_structs map(validity, [[0n, 0n], [0n, 2n], null], data(16, [true, true], ['key1', 'key2']), data(16, [true, true], ['🦆🦆🦆🦆🦆🦆', 'goose']), - ), // 43: map + ), // 44: map union([ data(1, validity, [0, 1, null]), // tags data(16, [true, false, false], ['Frank', null, null]), data(2, [false, true, false], [null, 5, null]), - ]), // 44: union - array(3, validity, data(4, [false, true, true, true, true, true], [null, 2, 3, 4, 5, 6])), // 45: fixed_int_array - array(3, validity, data(16, [true, false, true, true, true, true], ['a', null, 'c', 'd', 'e', 'f'])), // 46: fixed_varchar_array + ]), // 45: union + array(3, validity, data(4, [false, true, true, true, true, true], [null, 2, 3, 4, 5, 6])), // 46: fixed_int_array + array(3, validity, data(16, [true, false, true, true, true, true], ['a', null, 'c', 'd', 'e', 'f'])), // 47: fixed_varchar_array array(3, validity, array(3, [true, false, true, true, true, true, false, false, false], data(4, [false, true, true, false, false, false, false, true, true, true, true, true, false, true, true, true, true, true], [null, 2, 3, null, null, null, null, 2, 3, 4, 5, 6, null, 2, 3, 4, 5, 6]) ) - ), // 47: fixed_nested_int_array + ), // 48: fixed_nested_int_array array(3, validity, array(3, [true, false, true, true, true, true, false, false, false], data(16, [true, false, true, false, false, false, true, false, true, true, true, true, true, false, true, true, true, true], ['a', null, 'c', null, null, null, 'a', null, 'c', 'd', 'e', 'f', 'a', null, 'c', 'd', 'e', 'f']) ) - ), // 48: fixed_nested_varchar_array + ), // 49: fixed_nested_varchar_array array(3, validity, struct(9, [true, true, true, true, true, true, false, false, false], [ data(4, [false, true, false, true, false, true, false, false, false], [null, 42, null, 42, null, 42, null, null, null]), data(16, [false, true, false, true, false, true, false, false, false], [null, '🦆🦆🦆🦆🦆🦆', null, '🦆🦆🦆🦆🦆🦆', null, '🦆🦆🦆🦆🦆🦆', null, null, null]), ]) - ), // 49: fixed_struct_array + ), // 50: fixed_struct_array struct(3, validity, [ array(2, [true, true], data(4, [false, true, true, true, true, true], [null, 2, 3, 4, 5, 6])), array(2, [true, true], data(16, [true, false, true, true, true, true], ['a', null, 'c', 'd', 'e', 'f'])), - ]), // 50: struct_of_fixed_array + ]), // 51: struct_of_fixed_array array(3, validity, list([true, true, true, true, true, true, false, false, false], [[0n, 0n], [0n, 5n], [5n, 0n], [5n, 5n], [10n, 0n], [10n, 5n], null, null, null], 15, data(4, [true, true, false, false, true, true, true, false, false, true, true, true, false, false, true], [42, 999, null, null, -42, 42, 999, null, null, -42, 42, 999, null, null, -42]) ) - ), // 51: fixed_array_of_int_list + ), // 52: fixed_array_of_int_list list(validity, [[0n, 3n], [3n, 3n]], 6, array(6, [true, true, true, true, true, true], data(4, [false, true, true, true, true, true, false, true, true, true, true, true, false, true, true, true, true, true], [null, 2, 3, 4, 5, 6, null, 2, 3, 4, 5, 6, null, 2, 3, 4, 5, 6]) ) - ), // 52: list_of_fixed_int_array + ), // 53: list_of_fixed_int_array ], }, ], diff --git a/bindings/test/utils/expectResult.ts b/bindings/test/utils/expectResult.ts index 377cd970..4da19cd8 100644 --- a/bindings/test/utils/expectResult.ts +++ b/bindings/test/utils/expectResult.ts @@ -12,8 +12,8 @@ export async function expectResult(result: duckdb.Result, expectedResult: Expect expect(duckdb.column_count(result)).toBe(expectedResult.columns.length); for (let col = 0; col < expectedResult.columns.length; col++) { const expectedColumn = expectedResult.columns[col]; - expect(duckdb.column_name(result, col)).toBe(expectedColumn.name); - expect(duckdb.column_type(result, col)).toBe(expectedColumn.logicalType.typeId); + expect(duckdb.column_name(result, col), `${col}`).toBe(expectedColumn.name); + expect(duckdb.column_type(result, col), `${col}`).toBe(expectedColumn.logicalType.typeId); withLogicalType(duckdb.column_logical_type(result, col), (logical_type) => expectLogicalType(logical_type, expectedColumn.logicalType, `col ${col}`) ); diff --git a/bindings/test/utils/expectedLogicalTypes.ts b/bindings/test/utils/expectedLogicalTypes.ts index 0d3f9deb..2f5e2b30 100644 --- a/bindings/test/utils/expectedLogicalTypes.ts +++ b/bindings/test/utils/expectedLogicalTypes.ts @@ -102,6 +102,16 @@ export const TIMESTAMP_TZ: ExpectedSimpleLogicalType = { typeId: duckdb.Type.TIMESTAMP_TZ, }; +export const ANY: ExpectedSimpleLogicalType = { + typeId: duckdb.Type.ANY, +}; +export const VARINT: ExpectedSimpleLogicalType = { + typeId: duckdb.Type.VARINT, +}; +export const SQLNULL: ExpectedSimpleLogicalType = { + typeId: duckdb.Type.SQLNULL, +}; + export function ARRAY( valueType: ExpectedLogicalType, size: number diff --git a/bindings/test/utils/getValue.ts b/bindings/test/utils/getValue.ts index aaeb7c3e..0a555692 100644 --- a/bindings/test/utils/getValue.ts +++ b/bindings/test/utils/getValue.ts @@ -188,6 +188,13 @@ export function getValue(logicalType: ExpectedLogicalType, validity: BigUint64Ar return getInt64(dv, index * 8); case duckdb.Type.TIMESTAMP_TZ: return getInt64(dv, index * 8); + + case duckdb.Type.VARINT: + return getBuffer(dv, index * 16); + + case duckdb.Type.SQLNULL: + return null; + default: throw new Error(`getValue not implemented for type: ${duckdb.Type[logicalType.typeId]}`); }