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

package/lib/conversion/bytesFromString.d.ts

@@ -0,0 +1 @@
+export declare function bytesFromString(str: string): Uint8Array;

package/lib/conversion/bytesFromString.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesFromString = bytesFromString;
+const textEncoder = new TextEncoder();
+function bytesFromString(str) {
+    return textEncoder.encode(str);
+}

package/lib/createValue.d.ts

@@ -0,0 +1,4 @@
+import { Value } from '@duckdb/node-bindings';
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValue } from './values';
+export declare function createValue(type: DuckDBType, input: DuckDBValue): Value;

package/lib/createValue.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValue = createValue;
+const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
+const DuckDBTypeId_1 = require("./DuckDBTypeId");
+const values_1 = require("./values");
+function createValue(type, input) {
+    switch (type.typeId) {
+        case DuckDBTypeId_1.DuckDBTypeId.BOOLEAN:
+            if (typeof input === 'boolean') {
+                return node_bindings_1.default.create_bool(input);
+            }
+            throw new Error(`input is not a boolean`);
+        case DuckDBTypeId_1.DuckDBTypeId.TINYINT:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_int8(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.SMALLINT:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_int16(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.INTEGER:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_int32(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.BIGINT:
+            if (typeof input === 'bigint') {
+                return node_bindings_1.default.create_int64(input);
+            }
+            throw new Error(`input is not a bigint`);
+        case DuckDBTypeId_1.DuckDBTypeId.UTINYINT:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_uint8(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.USMALLINT:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_uint16(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.UINTEGER:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_uint32(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.UBIGINT:
+            if (typeof input === 'bigint') {
+                return node_bindings_1.default.create_uint64(input);
+            }
+            throw new Error(`input is not a bigint`);
+        case DuckDBTypeId_1.DuckDBTypeId.FLOAT:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_float(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.DOUBLE:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_double(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP:
+            if (input instanceof values_1.DuckDBTimestampValue) {
+                return node_bindings_1.default.create_timestamp(input);
+            }
+            throw new Error(`input is not a DuckDBTimestampValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.DATE:
+            if (input instanceof values_1.DuckDBDateValue) {
+                return node_bindings_1.default.create_date(input);
+            }
+            throw new Error(`input is not a DuckDBDateValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.TIME:
+            if (input instanceof values_1.DuckDBTimeValue) {
+                return node_bindings_1.default.create_time(input);
+            }
+            throw new Error(`input is not a DuckDBTimeValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.INTERVAL:
+            if (input instanceof values_1.DuckDBIntervalValue) {
+                return node_bindings_1.default.create_interval(input);
+            }
+            throw new Error(`input is not a DuckDBIntervalValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.HUGEINT:
+            if (typeof input === 'bigint') {
+                return node_bindings_1.default.create_hugeint(input);
+            }
+            throw new Error(`input is not a bigint`);
+        case DuckDBTypeId_1.DuckDBTypeId.UHUGEINT:
+            if (typeof input === 'bigint') {
+                return node_bindings_1.default.create_uhugeint(input);
+            }
+            throw new Error(`input is not a bigint`);
+        case DuckDBTypeId_1.DuckDBTypeId.VARCHAR:
+            if (typeof input === 'string') {
+                return node_bindings_1.default.create_varchar(input);
+            }
+            throw new Error(`input is not a string`);
+        case DuckDBTypeId_1.DuckDBTypeId.BLOB:
+            if (input instanceof values_1.DuckDBBlobValue) {
+                return node_bindings_1.default.create_blob(input.bytes);
+            }
+            throw new Error(`input is not a DuckDBBlobValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.DECIMAL:
+            throw new Error(`not yet implemented for DECIMAL`); // TODO: implement when available in 1.2.0
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_S:
+            throw new Error(`not yet implemented for TIMESTAMP_S`); // TODO: implement when available in 1.2.0
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_MS:
+            throw new Error(`not yet implemented for TIMESTAMP_MS`); // TODO: implement when available in 1.2.0
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_NS:
+            throw new Error(`not yet implemented for TIMESTAMP_NS`); // TODO: implement when available in 1.2.0
+        case DuckDBTypeId_1.DuckDBTypeId.ENUM:
+            throw new Error(`not yet implemented for ENUM`); // TODO: implement when available in 1.2.0
+        case DuckDBTypeId_1.DuckDBTypeId.LIST:
+            if (input instanceof values_1.DuckDBListValue) {
+                return node_bindings_1.default.create_list_value(type.valueType.toLogicalType().logical_type, input.items.map((item) => createValue(type.valueType, item)));
+            }
+            throw new Error(`input is not a DuckDBListValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.STRUCT:
+            if (input instanceof values_1.DuckDBStructValue) {
+                return node_bindings_1.default.create_struct_value(type.toLogicalType().logical_type, Object.values(input.entries).map((value, i) => createValue(type.entryTypes[i], value)));
+            }
+            throw new Error(`input is not a DuckDBStructValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.MAP:
+            throw new Error(`not yet implemented for MAP`); // TODO: implement when available, hopefully in 1.2.0
+        case DuckDBTypeId_1.DuckDBTypeId.ARRAY:
+            if (input instanceof values_1.DuckDBArrayValue) {
+                return node_bindings_1.default.create_array_value(type.valueType.toLogicalType().logical_type, input.items.map((item) => createValue(type.valueType, item)));
+            }
+            throw new Error(`input is not a DuckDBArrayValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.UUID:
+            throw new Error(`not yet implemented for UUID`); // TODO: implement when available in 1.2.0
+        case DuckDBTypeId_1.DuckDBTypeId.UNION:
+            throw new Error(`not yet implemented for UNION`); // TODO: implement when available, hopefully in 1.2.0
+        case DuckDBTypeId_1.DuckDBTypeId.UNION:
+            throw new Error(`not yet implemented for BIT`); // TODO: implement when available in 1.2.0
+        case DuckDBTypeId_1.DuckDBTypeId.TIME_TZ:
+            if (input instanceof values_1.DuckDBTimeTZValue) {
+                return node_bindings_1.default.create_time_tz_value(input);
+            }
+            throw new Error(`input is not a DuckDBTimeTZValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ:
+            if (input instanceof values_1.DuckDBTimestampTZValue) {
+                return node_bindings_1.default.create_timestamp(input); // TODO: change to create_timestamp_tz when available in 1.2.0
+            }
+            throw new Error(`input is not a DuckDBTimestampTZValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.ANY:
+            throw new Error(`cannot create values of type ANY`);
+        case DuckDBTypeId_1.DuckDBTypeId.VARINT:
+            throw new Error(`not yet implemented for VARINT`); // TODO: implement when available in 1.2.0
+        case DuckDBTypeId_1.DuckDBTypeId.SQLNULL:
+            throw new Error(`not yet implemented for SQLNUll`); // TODO: implement when available in 1.2.0
+        default:
+            throw new Error(`unrecognized type id ${type.typeId}`);
+    }
+}

package/lib/typeForValue.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValue } from './values';
+export declare function typeForValue(value: DuckDBValue): DuckDBType;

package/lib/typeForValue.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeForValue = typeForValue;
+const DuckDBType_1 = require("./DuckDBType");
+const values_1 = require("./values");
+function typeForValue(value) {
+    if (value === null) {
+        return DuckDBType_1.SQLNULL;
+    }
+    else {
+        switch (typeof value) {
+            case 'boolean':
+                return DuckDBType_1.BOOLEAN;
+            case 'number':
+                return DuckDBType_1.DOUBLE;
+            case 'bigint':
+                return DuckDBType_1.HUGEINT;
+            case 'string':
+                return DuckDBType_1.VARCHAR;
+            case 'object':
+                if (value instanceof values_1.DuckDBArrayValue) {
+                    return (0, DuckDBType_1.ARRAY)(typeForValue(value.items[0]), value.items.length);
+                }
+                else if (value instanceof values_1.DuckDBBitValue) {
+                    return DuckDBType_1.BIT;
+                }
+                else if (value instanceof values_1.DuckDBBlobValue) {
+                    return DuckDBType_1.BLOB;
+                }
+                else if (value instanceof values_1.DuckDBDateValue) {
+                    return DuckDBType_1.DATE;
+                }
+                else if (value instanceof values_1.DuckDBDecimalValue) {
+                    return (0, DuckDBType_1.DECIMAL)(value.width, value.scale);
+                }
+                else if (value instanceof values_1.DuckDBIntervalValue) {
+                    return DuckDBType_1.INTERVAL;
+                }
+                else if (value instanceof values_1.DuckDBListValue) {
+                    return (0, DuckDBType_1.LIST)(typeForValue(value.items[0]));
+                }
+                else if (value instanceof values_1.DuckDBMapValue) {
+                    return (0, DuckDBType_1.MAP)(typeForValue(value.entries[0].key), typeForValue(value.entries[0].value));
+                }
+                else if (value instanceof values_1.DuckDBStructValue) {
+                    const entryTypes = {};
+                    for (const key in value.entries) {
+                        entryTypes[key] = typeForValue(value.entries[key]);
+                    }
+                    return (0, DuckDBType_1.STRUCT)(entryTypes);
+                }
+                else if (value instanceof values_1.DuckDBTimestampMillisecondsValue) {
+                    return DuckDBType_1.TIMESTAMP_MS;
+                }
+                else if (value instanceof values_1.DuckDBTimestampNanosecondsValue) {
+                    return DuckDBType_1.TIMESTAMP_NS;
+                }
+                else if (value instanceof values_1.DuckDBTimestampSecondsValue) {
+                    return DuckDBType_1.TIMESTAMP_S;
+                }
+                else if (value instanceof values_1.DuckDBTimestampTZValue) {
+                    return DuckDBType_1.TIMESTAMPTZ;
+                }
+                else if (value instanceof values_1.DuckDBTimestampValue) {
+                    return DuckDBType_1.TIMESTAMP;
+                }
+                else if (value instanceof values_1.DuckDBTimeTZValue) {
+                    return DuckDBType_1.TIMETZ;
+                }
+                else if (value instanceof values_1.DuckDBTimeValue) {
+                    return DuckDBType_1.TIME;
+                }
+                else if (value instanceof values_1.DuckDBUnionValue) {
+                    return (0, DuckDBType_1.UNION)({ [value.tag]: typeForValue(value.value) });
+                }
+                else if (value instanceof values_1.DuckDBUUIDValue) {
+                    return DuckDBType_1.UUID;
+                }
+                break;
+        }
+    }
+    return DuckDBType_1.ANY;
+}

package/lib/values/DuckDBBlobValue.d.ts

@@ -5,4 +5,4 @@ export declare class DuckDBBlobValue {
     toString(): string;
     static fromString(str: string): DuckDBBlobValue;
 }
-export declare function blobValue(bytes: Uint8Array): DuckDBBlobValue;
+export declare function blobValue(input: Uint8Array | string): DuckDBBlobValue;

package/lib/values/DuckDBBlobValue.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuckDBBlobValue = void 0;
 exports.blobValue = blobValue;
+const bytesFromString_1 = require("../conversion/bytesFromString");
 const stringFromBlob_1 = require("../conversion/stringFromBlob");
-const textEncoder = new TextEncoder();
 class DuckDBBlobValue {
     bytes;
     constructor(bytes) {
@@ -14,10 +14,13 @@ class DuckDBBlobValue {
         return (0, stringFromBlob_1.stringFromBlob)(this.bytes);
     }
     static fromString(str) {
-        return new DuckDBBlobValue(Buffer.from(textEncoder.encode(str)));
+        return new DuckDBBlobValue(Buffer.from((0, bytesFromString_1.bytesFromString)(str)));
     }
 }
 exports.DuckDBBlobValue = DuckDBBlobValue;
-function blobValue(bytes) {
-    return new DuckDBBlobValue(bytes);
+function blobValue(input) {
+    if (typeof input === 'string') {
+        return DuckDBBlobValue.fromString(input);
+    }
+    return new DuckDBBlobValue(input);
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@duckdb/node-api",
-  "version": "1.1.3-alpha.8",
+  "version": "1.1.3-alpha.9",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "dependencies": {
-    "@duckdb/node-bindings": "1.1.3-alpha.8"
+    "@duckdb/node-bindings": "1.1.3-alpha.9"
   },
   "repository": {
     "type": "git",