@query-farm/vgi 0.22.0 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@query-farm/vgi",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "TypeScript framework for extending DuckDB with user-defined functions via the Vector Gateway Interface (VGI) over Arrow IPC.",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Query Farm LLC (https://query.farm)",

package/src/protocol/handlers/aggregate.ts

@@ -41,8 +41,20 @@ import {
 } from "./shared.js";
 
 export function registerAggregateMethods(protocol: Protocol, registry: FunctionRegistry): void {
-  function resolveAggregate(name: string): AggregateFunctionConfig<any, any> {
-    const func = registry.get(name, { arguments: new Arguments(), inputSchema: null, isScalar: false }) as any;
+  // `schemaName` scopes resolution to the schema the caller named. Every
+  // aggregate RPC carries it (protocol 1.2.0), so an aggregate name declared in
+  // two schemas dispatches to the one the request names rather than colliding
+  // on the flat by-name index. `null` (no schema) keeps the cross-schema lookup.
+  function resolveAggregate(
+    name: string,
+    schemaName?: string | null,
+  ): AggregateFunctionConfig<any, any> {
+    const func = registry.get(name, {
+      arguments: new Arguments(),
+      inputSchema: null,
+      isScalar: false,
+      schemaName: schemaName ?? null,
+    }) as any;
     if (!func || func.kind !== "aggregate") {
       throw new Error(`Function '${name}' is not an aggregate function`);
     }
@@ -58,7 +70,7 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
     handler: async (params) => {
       const innerParams = unwrapRequest(params.request);
       const functionName: string = innerParams.function_name;
-      const cfg = resolveAggregate(functionName);
+      const cfg = resolveAggregate(functionName, innerParams.schema_name ?? null);
       const argBytes = toUint8Array(innerParams.arguments);
       const args = deserializeArguments(argBytes);
       const inputSchema = innerParams.input_schema
@@ -109,7 +121,7 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
       const innerParams = unwrapRequest(params.request);
       const functionName: string = innerParams.function_name;
       const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName);
+      const cfg = resolveAggregate(functionName, innerParams.schema_name ?? null);
       const batch = readSingleBatch(toUint8Array(innerParams.input_batch));
       if (!batch || batch.numRows === 0) return wrapResult({}, makeSchema([]));
 
@@ -176,7 +188,7 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
       const innerParams = unwrapRequest(params.request);
       const functionName: string = innerParams.function_name;
       const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName);
+      const cfg = resolveAggregate(functionName, innerParams.schema_name ?? null);
       const batch = readSingleBatch(toUint8Array(innerParams.merge_batch));
       if (!batch || batch.numRows === 0) return wrapResult({}, makeSchema([]));
 
@@ -225,7 +237,7 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
       const innerParams = unwrapRequest(params.request);
       const functionName: string = innerParams.function_name;
       const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName);
+      const cfg = resolveAggregate(functionName, innerParams.schema_name ?? null);
       const outputSchema = deserializeSchema(toUint8Array(innerParams.output_schema));
       const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
       const groupIds: bigint[] = [];

package/src/protocol/handlers/table-buffering.ts

@@ -43,11 +43,19 @@ export function registerTableBufferingMethods(
   registry: FunctionRegistry,
   signingKey?: Uint8Array,
 ): void {
-  function resolveBuffering(name: string): TableBufferingVgiFunction {
+  // `schemaName` scopes resolution to the schema the caller named. The
+  // buffering process/combine RPCs carry it (protocol 1.2.0), so a name
+  // declared in two schemas resolves to the one the request names rather than
+  // colliding on the flat by-name index. `null` keeps the cross-schema lookup.
+  function resolveBuffering(
+    name: string,
+    schemaName?: string | null,
+  ): TableBufferingVgiFunction {
     const func = registry.get(name, {
       arguments: new Arguments(),
       inputSchema: null,
       isScalar: false,
+      schemaName: schemaName ?? null,
     }) as any;
     if (!func || func.kind !== "table_buffering") {
       throw new Error(`Function '${name}' is not a table_buffering function`);
@@ -75,7 +83,7 @@ export function registerTableBufferingMethods(
         : rawAttach;
     const transactionId = inner.transaction_id ? toUint8Array(inner.transaction_id) : null;
 
-    const func = resolveBuffering(functionName);
+    const func = resolveBuffering(functionName, inner.schema_name ?? null);
     const bound = new BoundStorage(defaultStorage, executionId);
     const payload = await bound.stateGet(
       FrameworkNS.BUFFERING_INIT,