@duckdb/node-api 1.3.2-alpha.25 → 1.3.2-alpha.26

package/README.md

@@ -17,14 +17,7 @@ available separately as [@duckdb/node-bindings](https://www.npmjs.com/package/@d
 
 ### Roadmap
 
-Some features are not yet complete:
-* Appending default values row-by-row
-* User-defined types & functions
-* Profiling info
-* Table description
-* APIs for Arrow
-
-See the [issues list on GitHub](https://github.com/duckdb/duckdb-node-neo/issues)
+Some features are not yet complete. See the [issues list on GitHub](https://github.com/duckdb/duckdb-node-neo/issues)
 for the most up-to-date roadmap.
 
 ### Supported Platforms
@@ -883,6 +876,32 @@ appender.flushSync();
 
 See "Specifying Values" above for how to supply values to the appender.
 
+### Scalar Functions
+
+```ts
+connection.registerScalarFunction(
+  DuckDBScalarFunction.create({
+    name: 'my_add',
+    mainFunction: (info, input, output) => {
+      const v0 = input.getColumnVector(0);
+      const v1 = input.getColumnVector(1);
+      for (let rowIndex = 0; rowIndex < input.rowCount; rowIndex++) {
+        output.setItem(
+          rowIndex,
+          v0.getItem(rowIndex) + v1.getItem(rowIndex)
+        );
+      }
+      output.flush();
+    },
+    returnType: INTEGER,
+    parameterTypes: [INTEGER, INTEGER],
+  })
+);
+const reader = await connection.runAndReadAll('select my_add(2, 3)');
+const rows = reader.getRows();
+// [ [ 5 ] ]
+```
+
 ### Extract Statements
 
 ```ts

package/lib/DuckDBConnection.d.ts

@@ -7,6 +7,7 @@ import { DuckDBPendingResult } from './DuckDBPendingResult';
 import { DuckDBPreparedStatement } from './DuckDBPreparedStatement';
 import { DuckDBResult } from './DuckDBResult';
 import { DuckDBResultReader } from './DuckDBResultReader';
+import { DuckDBScalarFunction } from './DuckDBScalarFunction';
 import { DuckDBType } from './DuckDBType';
 import { DuckDBValue } from './values';
 export declare class DuckDBConnection {
@@ -34,4 +35,5 @@ export declare class DuckDBConnection {
     extractStatements(sql: string): Promise<DuckDBExtractedStatements>;
     private runUntilLast;
     createAppender(table: string, schema?: string | null, catalog?: string | null): Promise<DuckDBAppender>;
+    registerScalarFunction(scalarFunction: DuckDBScalarFunction): void;
 }

package/lib/DuckDBConnection.js

@@ -152,5 +152,8 @@ class DuckDBConnection {
     async createAppender(table, schema, catalog) {
         return new DuckDBAppender_1.DuckDBAppender(node_bindings_1.default.appender_create_ext(this.connection, catalog ?? null, schema ?? null, table));
     }
+    registerScalarFunction(scalarFunction) {
+        node_bindings_1.default.register_scalar_function(this.connection, scalarFunction.scalar_function);
+    }
 }
 exports.DuckDBConnection = DuckDBConnection;

package/lib/DuckDBFunctionInfo.d.ts

@@ -0,0 +1,7 @@
+import duckdb from '@duckdb/node-bindings';
+export declare class DuckDBFunctionInfo {
+    private readonly function_info;
+    constructor(function_info: duckdb.FunctionInfo);
+    getExtraInfo(): object | undefined;
+    setError(error: string): void;
+}

package/lib/DuckDBFunctionInfo.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBFunctionInfo = void 0;
+const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
+class DuckDBFunctionInfo {
+    function_info;
+    constructor(function_info) {
+        this.function_info = function_info;
+    }
+    getExtraInfo() {
+        return node_bindings_1.default.scalar_function_get_extra_info(this.function_info);
+    }
+    setError(error) {
+        node_bindings_1.default.scalar_function_set_error(this.function_info, error);
+    }
+}
+exports.DuckDBFunctionInfo = DuckDBFunctionInfo;

package/lib/DuckDBPreparedStatementWeakRefCollection.d.ts

@@ -2,6 +2,7 @@ import { DuckDBPreparedStatement } from './DuckDBPreparedStatement';
 import { DuckDBPreparedStatementCollection } from './DuckDBPreparedStatementCollection';
 export declare class DuckDBPreparedStatementWeakRefCollection implements DuckDBPreparedStatementCollection {
     preparedStatements: WeakRef<DuckDBPreparedStatement>[];
+    lastPruneTime: number;
     add(prepared: DuckDBPreparedStatement): void;
     destroySync(): void;
     private prune;

package/lib/DuckDBPreparedStatementWeakRefCollection.js

@@ -3,8 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuckDBPreparedStatementWeakRefCollection = void 0;
 class DuckDBPreparedStatementWeakRefCollection {
     preparedStatements = [];
+    lastPruneTime = 0;
     add(prepared) {
-        this.prune();
+        const now = performance.now();
+        if (now - this.lastPruneTime > 1000) {
+            this.lastPruneTime = now;
+            this.prune();
+        }
         this.preparedStatements.push(new WeakRef(prepared));
     }
     destroySync() {

package/lib/DuckDBScalarFunction.d.ts

@@ -0,0 +1,29 @@
+import duckdb from '@duckdb/node-bindings';
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBFunctionInfo } from './DuckDBFunctionInfo';
+import { DuckDBType } from './DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+export type DuckDBScalarMainFunction = (functionInfo: DuckDBFunctionInfo, inputDataChunk: DuckDBDataChunk, outputVector: DuckDBVector) => void;
+export declare class DuckDBScalarFunction {
+    readonly scalar_function: duckdb.ScalarFunction;
+    constructor();
+    static create({ name, mainFunction, returnType, parameterTypes, varArgsType, specialHandling, volatile, extraInfo, }: {
+        name: string;
+        mainFunction: DuckDBScalarMainFunction;
+        returnType: DuckDBType;
+        parameterTypes?: readonly DuckDBType[];
+        varArgsType?: DuckDBType;
+        specialHandling?: boolean;
+        volatile?: boolean;
+        extraInfo?: object;
+    }): DuckDBScalarFunction;
+    destroySync(): void;
+    setName(name: string): void;
+    setMainFunction(mainFunction: DuckDBScalarMainFunction): void;
+    setReturnType(returnType: DuckDBType): void;
+    addParameter(parameterType: DuckDBType): void;
+    setVarArgs(varArgsType: DuckDBType): void;
+    setSpecialHandling(): void;
+    setVolatile(): void;
+    setExtraInfo(extraInfo: object): void;
+}

package/lib/DuckDBScalarFunction.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBScalarFunction = void 0;
+const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
+const DuckDBDataChunk_1 = require("./DuckDBDataChunk");
+const DuckDBFunctionInfo_1 = require("./DuckDBFunctionInfo");
+const DuckDBVector_1 = require("./DuckDBVector");
+class DuckDBScalarFunction {
+    scalar_function;
+    constructor() {
+        this.scalar_function = node_bindings_1.default.create_scalar_function();
+    }
+    static create({ name, mainFunction, returnType, parameterTypes, varArgsType, specialHandling, volatile, extraInfo, }) {
+        const scalarFunction = new DuckDBScalarFunction();
+        scalarFunction.setName(name);
+        scalarFunction.setMainFunction(mainFunction);
+        scalarFunction.setReturnType(returnType);
+        if (parameterTypes) {
+            for (const parameterType of parameterTypes) {
+                scalarFunction.addParameter(parameterType);
+            }
+        }
+        if (varArgsType) {
+            scalarFunction.setVarArgs(varArgsType);
+        }
+        if (specialHandling) {
+            scalarFunction.setSpecialHandling();
+        }
+        if (volatile) {
+            scalarFunction.setVolatile();
+        }
+        if (extraInfo) {
+            scalarFunction.setExtraInfo(extraInfo);
+        }
+        return scalarFunction;
+    }
+    destroySync() {
+        node_bindings_1.default.destroy_scalar_function_sync(this.scalar_function);
+    }
+    setName(name) {
+        node_bindings_1.default.scalar_function_set_name(this.scalar_function, name);
+    }
+    setMainFunction(mainFunction) {
+        node_bindings_1.default.scalar_function_set_function(this.scalar_function, (info, input, output) => {
+            const functionInfo = new DuckDBFunctionInfo_1.DuckDBFunctionInfo(info);
+            const inputDataChunk = new DuckDBDataChunk_1.DuckDBDataChunk(input);
+            const outputVector = DuckDBVector_1.DuckDBVector.create(output, inputDataChunk.rowCount);
+            mainFunction(functionInfo, inputDataChunk, outputVector);
+        });
+    }
+    setReturnType(returnType) {
+        node_bindings_1.default.scalar_function_set_return_type(this.scalar_function, returnType.toLogicalType().logical_type);
+    }
+    addParameter(parameterType) {
+        node_bindings_1.default.scalar_function_add_parameter(this.scalar_function, parameterType.toLogicalType().logical_type);
+    }
+    setVarArgs(varArgsType) {
+        node_bindings_1.default.scalar_function_set_varargs(this.scalar_function, varArgsType.toLogicalType().logical_type);
+    }
+    setSpecialHandling() {
+        node_bindings_1.default.scalar_function_set_special_handling(this.scalar_function);
+    }
+    setVolatile() {
+        node_bindings_1.default.scalar_function_set_volatile(this.scalar_function);
+    }
+    setExtraInfo(extraInfo) {
+        node_bindings_1.default.scalar_function_set_extra_info(this.scalar_function, extraInfo);
+    }
+}
+exports.DuckDBScalarFunction = DuckDBScalarFunction;

package/lib/duckdb.d.ts

@@ -5,13 +5,17 @@ export * from './DuckDBAppender';
 export * from './DuckDBConnection';
 export * from './DuckDBDataChunk';
 export * from './DuckDBExtractedStatements';
+export * from './DuckDBFunctionInfo';
 export * from './DuckDBInstance';
+export * from './DuckDBInstanceCache';
 export * from './DuckDBLogicalType';
 export * from './DuckDBMaterializedResult';
 export * from './DuckDBPendingResult';
 export * from './DuckDBPreparedStatement';
 export * from './DuckDBPreparedStatementCollection';
 export * from './DuckDBResult';
+export * from './DuckDBResultReader';
+export * from './DuckDBScalarFunction';
 export * from './DuckDBType';
 export * from './DuckDBTypeId';
 export * from './DuckDBValueConverter';

package/lib/duckdb.js

@@ -26,13 +26,17 @@ __exportStar(require("./DuckDBAppender"), exports);
 __exportStar(require("./DuckDBConnection"), exports);
 __exportStar(require("./DuckDBDataChunk"), exports);
 __exportStar(require("./DuckDBExtractedStatements"), exports);
+__exportStar(require("./DuckDBFunctionInfo"), exports);
 __exportStar(require("./DuckDBInstance"), exports);
+__exportStar(require("./DuckDBInstanceCache"), exports);
 __exportStar(require("./DuckDBLogicalType"), exports);
 __exportStar(require("./DuckDBMaterializedResult"), exports);
 __exportStar(require("./DuckDBPendingResult"), exports);
 __exportStar(require("./DuckDBPreparedStatement"), exports);
 __exportStar(require("./DuckDBPreparedStatementCollection"), exports);
 __exportStar(require("./DuckDBResult"), exports);
+__exportStar(require("./DuckDBResultReader"), exports);
+__exportStar(require("./DuckDBScalarFunction"), exports);
 __exportStar(require("./DuckDBType"), exports);
 __exportStar(require("./DuckDBTypeId"), exports);
 __exportStar(require("./DuckDBValueConverter"), exports);

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@duckdb/node-api",
-  "version": "1.3.2-alpha.25",
+  "version": "1.3.2-alpha.26",
   "license": "MIT",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "dependencies": {
-    "@duckdb/node-bindings": "1.3.2-alpha.25"
+    "@duckdb/node-bindings": "1.3.2-alpha.26"
   },
   "repository": {
     "type": "git",