@query-farm/vgi 0.29.0 → 0.30.0

package/src/http/fetch.ts

@@ -18,6 +18,9 @@ import {
   type DispatchHook,
   type DispatchInfo,
   type HookToken,
+  type PeerAuthenticationPolicy,
+  type PeerIdentityProvider,
+  type PeerResolutionOptions,
   type Protocol,
 } from "@query-farm/vgi-rpc";
 import { arrowStateSerializer } from "../protocol/state-serializer.js";
@@ -76,6 +79,12 @@ export interface VgiFetchOptions {
    *  and the identity it returns is the one the worker seals `attach_opaque_data`
    *  and split tokens under. */
   authenticate?: AuthenticateFn;
+  /** Off-wire transport identities, including a trusted Iroh HTTP bridge. */
+  peerIdentityProviders?: readonly PeerIdentityProvider[];
+  /** Policy composing peer evidence with application authentication. */
+  peerAuthenticationPolicy?: PeerAuthenticationPolicy;
+  /** Host adapter supplying the physical peer and multiplicity-preserving headers. */
+  peerResolutionContext?: (request: Request) => PeerResolutionOptions | Promise<PeerResolutionOptions>;
 }
 
 // ---------------------------------------------------------------------------
@@ -207,6 +216,9 @@ export function createVgiFetch(opts: VgiFetchOptions): (req: Request) => Promise
     // can still open the identity-bound attach and split envelopes.
     dispatchHook: REQUEST_AUTH_DISPATCH_HOOK,
     authenticate: opts.authenticate,
+    peerIdentityProviders: opts.peerIdentityProviders,
+    peerAuthenticationPolicy: opts.peerAuthenticationPolicy,
+    peerResolutionContext: opts.peerResolutionContext,
     // `null` is the explicit opt-out; `undefined` (omitted) means "*".
     corsOrigins: opts.corsOrigins === null ? undefined : (opts.corsOrigins ?? "*"),
     repositoryUrl: opts.repositoryUrl,

package/src/index.core.ts

@@ -88,6 +88,7 @@ export {
   FunctionType,
   FunctionStability,
   NullHandling,
+  ArgumentMonotonicity,
   OrderPreservation,
   OrderDependence,
   DistinctDependence,
@@ -307,3 +308,4 @@ export type {
 export { str, bytes, int, int32, float, float32, bool, toSchema, OutputCollector, AuthContext } from "@query-farm/vgi-rpc";
 export { subprocessConnect, httpConnect, tcpConnect } from "@query-farm/vgi-rpc";
 export type { RpcClient, StreamSession, LogMessage } from "@query-farm/vgi-rpc";
+export { normalizeSchemaPath, schemaPathDisplay, schemaPathKey, schemaPathsEqual, type SchemaPath } from "./schema-path.js";

package/src/metadata/resolve.ts

@@ -4,6 +4,7 @@
 import {
   FunctionStability,
   NullHandling,
+  ArgumentMonotonicity,
   OrderPreservation,
   OrderDependence,
   DistinctDependence,
@@ -11,6 +12,7 @@ import {
 } from "../types.js";
 import type { VgiFunction } from "../functions/types.js";
 import type { ArgumentSpec } from "../arguments/argument-spec.js";
+import { supportsExtensionFilterFunction } from "../filter-pushdown/capabilities.js";
 import {
   CatalogFunctionType,
   type ResolvedMetadata,
@@ -55,6 +57,19 @@ function specToParameterInfo(spec: ArgumentSpec): ParameterInfo {
 export function resolveMetadata(func: VgiFunction): ResolvedMetadata {
   const meta = func.meta;
 
+  if (meta.runtimeFilterAlgorithms?.length) {
+    throw new Error("TypeScript SDK has no registered runtime-filter artifact evaluator to advertise");
+  }
+  if (meta.filterEvaluationContexts?.length) {
+    throw new Error("TypeScript SDK has no isolated DuckDB session-context evaluator to advertise");
+  }
+  if (meta.filterSemanticProfiles?.some((value) => value !== "vgi.duckdb.standard.v1")) {
+    throw new Error("TypeScript SDK supports only vgi.duckdb.standard.v1 filter semantics");
+  }
+  if (meta.additionalFilterFunctions?.some((value) => !supportsExtensionFilterFunction(value))) {
+    throw new Error("TypeScript SDK cannot advertise an extension-filter function without an evaluator");
+  }
+
   let functionType: CatalogFunctionType;
   switch (func.kind) {
     case "scalar":
@@ -74,8 +89,28 @@ export function resolveMetadata(func: VgiFunction): ResolvedMetadata {
       functionType = CatalogFunctionType.TABLE;
   }
 
+  const argumentMonotonicity = meta.argumentMonotonicity ?? null;
+  if (argumentMonotonicity !== null && functionType !== CatalogFunctionType.SCALAR) {
+    throw new Error("argumentMonotonicity is only valid for scalar functions");
+  }
+
   const parameters: ParameterInfo[] = func.argumentSpecs.map(specToParameterInfo);
 
+  if (argumentMonotonicity !== null) {
+    if (argumentMonotonicity.length !== parameters.length) {
+      throw new Error(
+        `argumentMonotonicity has ${argumentMonotonicity.length} entries, ` +
+        `expected ${parameters.length} declaration slots`,
+      );
+    }
+    const allowed = new Set<string>(Object.values(ArgumentMonotonicity));
+    for (const [index, value] of argumentMonotonicity.entries()) {
+      if (!allowed.has(value)) {
+        throw new Error(`argumentMonotonicity[${index}] has unknown value ${String(value)}`);
+      }
+    }
+  }
+
   const examples: FunctionExample[] = (meta.examples ?? []).map((e) => ({
     sql: e.sql,
     description: e.description,
@@ -95,12 +130,19 @@ export function resolveMetadata(func: VgiFunction): ResolvedMetadata {
     parameters,
     stability: meta.stability ?? FunctionStability.CONSISTENT,
     nullHandling: meta.nullHandling ?? NullHandling.DEFAULT,
+    argumentMonotonicity,
     requiredSettings: meta.requiredSettings ?? [],
     requiredSecrets: meta.requiredSecrets ?? [],
     projectionPushdown: meta.projectionPushdown ?? false,
     filterPushdown: meta.filterPushdown ?? false,
     samplingPushdown: meta.samplingPushdown ?? false,
-    supportedExpressionFilters: meta.supportedExpressionFilters ?? [],
+    filterSemanticProfiles: meta.filterSemanticProfiles ?? (meta.filterPushdown ? ["vgi.duckdb.standard.v1"] : []),
+    additionalFilterFunctions: meta.additionalFilterFunctions ?? [],
+    runtimeFilterAlgorithms: meta.runtimeFilterAlgorithms ?? [],
+    filterEvaluationContexts: (meta.filterEvaluationContexts ?? []).map((value) => ({
+      profile: value.profile,
+      providerFingerprint: value.providerFingerprint ?? null,
+    })),
     preservesOrder: meta.preservesOrder ?? OrderPreservation.NO_ORDER_GUARANTEE,
     maxWorkers: maxWorkers === DEFAULT_MAX_WORKERS ? null : maxWorkers,
     orderDependent: meta.orderDependent ?? OrderDependence.NOT_ORDER_DEPENDENT,

package/src/metadata/serialize.ts

@@ -8,6 +8,7 @@ import {
   field,
   utf8,
   int32,
+  uint64,
   bool,
   list,
   struct as makeStruct,
@@ -16,6 +17,7 @@ import {
   emptyBatch,
 } from "../arrow/index.js";
 import type { ResolvedMetadata, ParameterInfo, FunctionExample } from "./types.js";
+import type { ArgumentMonotonicity } from "../types.js";
 
 // ============================================================================
 // Schema definitions matching Python's _METADATA_SCHEMA exactly
@@ -41,6 +43,17 @@ const PARAMETER_STRUCT = makeStruct([
   field("is_const", bool(), false),
 ]);
 
+const FILTER_IDENTITY_STRUCT = makeStruct([
+  field("namespace", utf8(), false),
+  field("name", utf8(), false),
+  field("version", uint64(), false),
+]);
+
+const FILTER_CONTEXT_STRUCT = makeStruct([
+  field("profile", utf8(), false),
+  field("provider_fingerprint", utf8(), true),
+]);
+
 const METADATA_SCHEMA = makeSchema([
   field("name", utf8(), false),
   field("class_name", utf8(), false),
@@ -52,10 +65,15 @@ const METADATA_SCHEMA = makeSchema([
   field("parameters", list(field("item", PARAMETER_STRUCT, true)), false),
   field("stability", utf8(), false),
   field("null_handling", utf8(), false),
+  field("argument_monotonicity", list(field("item", utf8(), true)), true),
   field("required_settings", list(field("item", utf8(), true)), false),
   field("required_secrets", list(field("item", utf8(), true)), false),
   field("projection_pushdown", bool(), false),
   field("filter_pushdown", bool(), false),
+  field("filter_semantic_profiles", list(field("item", utf8(), true)), false),
+  field("additional_filter_functions", list(field("item", FILTER_IDENTITY_STRUCT, true)), false),
+  field("runtime_filter_algorithms", list(field("item", FILTER_IDENTITY_STRUCT, true)), false),
+  field("filter_evaluation_contexts", list(field("item", FILTER_CONTEXT_STRUCT, true)), false),
   field("preserves_order", utf8(), false),
   field("max_workers", int32(), true),
   field("order_dependent", utf8(), false),
@@ -96,12 +114,23 @@ function metadataToRow(m: ResolvedMetadata): Record<string, any> {
     })),
     stability: m.stability,
     null_handling: m.nullHandling,
+    argument_monotonicity: m.argumentMonotonicity,
     required_settings: m.requiredSettings,
     required_secrets: m.requiredSecrets,
     projection_pushdown: m.projectionPushdown,
     filter_pushdown: m.filterPushdown,
     sampling_pushdown: m.samplingPushdown,
-    supported_expression_filters: m.supportedExpressionFilters,
+    filter_semantic_profiles: m.filterSemanticProfiles,
+    additional_filter_functions: m.additionalFilterFunctions.map((value) => ({
+      ...value, version: BigInt(value.version),
+    })),
+    runtime_filter_algorithms: m.runtimeFilterAlgorithms.map((value) => ({
+      ...value, version: BigInt(value.version),
+    })),
+    filter_evaluation_contexts: m.filterEvaluationContexts.map((value) => ({
+      profile: value.profile,
+      provider_fingerprint: value.providerFingerprint,
+    })),
     preserves_order: m.preservesOrder,
     max_workers: m.maxWorkers,
     order_dependent: m.orderDependent,
@@ -222,15 +251,24 @@ export function arrowToMetadatas(batch: VgiBatch): ResolvedMetadata[] {
       parameters,
       stability: (get("stability") as any) ?? "CONSISTENT",
       nullHandling: (get("null_handling") as any) ?? "DEFAULT",
+      argumentMonotonicity: get("argument_monotonicity") == null
+        ? null
+        : [...(get("argument_monotonicity") as any)].map(String) as ArgumentMonotonicity[],
       requiredSettings,
       requiredSecrets,
       projectionPushdown: (get("projection_pushdown") as boolean) ?? false,
       filterPushdown: (get("filter_pushdown") as boolean) ?? false,
       samplingPushdown: (get("sampling_pushdown") as boolean) ?? false,
-      supportedExpressionFilters: (() => {
-        const raw = get("supported_expression_filters") as any ?? [];
-        return raw ? [...raw].filter((s: any) => s != null).map(String) : [];
-      })(),
+      filterSemanticProfiles: [...((get("filter_semantic_profiles") as any) ?? [])].filter((s: any) => s != null).map(String),
+      additionalFilterFunctions: [...((get("additional_filter_functions") as any) ?? [])].filter((v: any) => v != null).map((v: any) => ({
+        namespace: String(v.namespace), name: String(v.name), version: Number(v.version),
+      })),
+      runtimeFilterAlgorithms: [...((get("runtime_filter_algorithms") as any) ?? [])].filter((v: any) => v != null).map((v: any) => ({
+        namespace: String(v.namespace), name: String(v.name), version: Number(v.version),
+      })),
+      filterEvaluationContexts: [...((get("filter_evaluation_contexts") as any) ?? [])].filter((v: any) => v != null).map((v: any) => ({
+        profile: String(v.profile), providerFingerprint: v.provider_fingerprint == null ? null : String(v.provider_fingerprint),
+      })),
       preservesOrder: (get("preserves_order") as any) ?? "NO_ORDER_GUARANTEE",
       maxWorkers: (get("max_workers") as number | null) ?? null,
       orderDependent: (get("order_dependent") as any) ?? "NOT_ORDER_DEPENDENT",

package/src/metadata/types.ts

@@ -4,6 +4,7 @@
 import {
   FunctionStability,
   NullHandling,
+  ArgumentMonotonicity,
   OrderPreservation,
   OrderDependence,
   DistinctDependence,
@@ -36,6 +37,17 @@ export interface FunctionExample {
   expectedOutput: string | null;
 }
 
+export interface FilterFunctionCapability {
+  namespace: string;
+  name: string;
+  version: number;
+}
+
+export interface EvaluationContextCapability {
+  profile: string;
+  providerFingerprint: string | null;
+}
+
 export interface ResolvedMetadata {
   name: string;
   className: string;
@@ -47,12 +59,16 @@ export interface ResolvedMetadata {
   parameters: ParameterInfo[];
   stability: FunctionStability;
   nullHandling: NullHandling;
+  argumentMonotonicity: ArgumentMonotonicity[] | null;
   requiredSettings: string[];
   requiredSecrets: string[];
   projectionPushdown: boolean;
   filterPushdown: boolean;
   samplingPushdown: boolean;
-  supportedExpressionFilters: string[];
+  filterSemanticProfiles: string[];
+  additionalFilterFunctions: FilterFunctionCapability[];
+  runtimeFilterAlgorithms: FilterFunctionCapability[];
+  filterEvaluationContexts: EvaluationContextCapability[];
   preservesOrder: OrderPreservation;
   maxWorkers: number | null;
   orderDependent: OrderDependence;

package/src/protocol/dispatch.ts

@@ -37,7 +37,7 @@ export interface ProtocolConfig {
 }
 
 export function buildVgiProtocol(config: ProtocolConfig): Protocol {
-  const protocol = new Protocol("vgi");
+  const protocol = new Protocol("vgi", { protocolVersion: "2.0.0" });
 
   registerFunctionMethods(protocol, {
     registry: config.registry,

package/src/protocol/handlers/aggregate.ts

@@ -46,19 +46,19 @@ import {
 } from "./shared.js";
 
 export function registerAggregateMethods(protocol: Protocol, registry: FunctionRegistry): void {
-  // `schemaName` scopes resolution to the schema the caller named. Every
+  // `schemaPath` 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,
+    schemaPath?: string[] | null,
   ): AggregateFunctionConfig<any, any> {
     const func = registry.get(name, {
       arguments: new Arguments(),
       inputSchema: null,
       isScalar: false,
-      schemaName: schemaName ?? null,
+      schemaPath: schemaPath ?? null,
     }) as any;
     if (!func || func.kind !== "aggregate") {
       throw new Error(`Function '${name}' is not an aggregate function`);
@@ -75,7 +75,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, innerParams.schema_name ?? null);
+      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
       const argBytes = toUint8Array(innerParams.arguments);
       const args = deserializeArguments(argBytes);
       const inputSchema = innerParams.input_schema
@@ -95,6 +95,12 @@ export function registerAggregateMethods(protocol: Protocol, registry: FunctionR
         inputSchema,
         settings: {},
         secrets,
+        argumentNames: innerParams.argument_names
+          ? (Array.isArray(innerParams.argument_names)
+            ? innerParams.argument_names
+            : [...innerParams.argument_names])
+            .map((value: unknown) => value == null ? null : String(value))
+          : null,
       };
       const executionId = new Uint8Array(16);
       crypto.getRandomValues(executionId);
@@ -126,7 +132,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, innerParams.schema_name ?? null);
+      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
       const batch = readSingleBatch(toUint8Array(innerParams.input_batch));
       if (!batch || batch.numRows === 0) return wrapResult({}, makeSchema([]));
 
@@ -193,7 +199,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, innerParams.schema_name ?? null);
+      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
       const batch = readSingleBatch(toUint8Array(innerParams.merge_batch));
       if (!batch || batch.numRows === 0) return wrapResult({}, makeSchema([]));
 
@@ -242,7 +248,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, innerParams.schema_name ?? null);
+      const cfg = resolveAggregate(functionName, innerParams.schema_path ?? null);
       const outputSchema = deserializeSchema(toUint8Array(innerParams.output_schema));
       const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
       const groupIds: bigint[] = [];

package/src/protocol/handlers/catalog/admin.ts

@@ -271,7 +271,7 @@ export function registerCatalogAdminMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       const info = await cat.schemaGet(
         toUint8Array(params.attach_opaque_data),
-        params.name,
+        params.path,
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined
       );
       return wrapResult({
@@ -288,7 +288,7 @@ export function registerCatalogAdminMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.schemaCreate(
         toUint8Array(params.attach_opaque_data),
-        params.name,
+        params.path,
         params.comment,
         null, // tags
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined
@@ -305,7 +305,7 @@ export function registerCatalogAdminMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.schemaDrop(
         toUint8Array(params.attach_opaque_data),
-        params.name,
+        params.path,
         params.ignore_not_found,
         params.cascade,
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined
@@ -322,7 +322,7 @@ export function registerCatalogAdminMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       const tables = await cat.schemaContentsTables(
         toUint8Array(params.attach_opaque_data),
-        params.name,
+        params.path,
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined
       );
       return wrapResult({
@@ -339,7 +339,7 @@ export function registerCatalogAdminMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       const views = await cat.schemaContentsViews(
         toUint8Array(params.attach_opaque_data),
-        params.name,
+        params.path,
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined
       );
       return wrapResult({
@@ -356,7 +356,7 @@ export function registerCatalogAdminMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       const funcs = await cat.schemaContentsFunctions(
         toUint8Array(params.attach_opaque_data),
-        params.name,
+        params.path,
         decodeDictValue(params.type),
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined
       );

package/src/protocol/handlers/catalog/index_methods.ts

@@ -29,7 +29,7 @@ export function registerCatalogIndexMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       const indexes = await cat.schemaContentsIndexes(
         toUint8Array(params.attach_opaque_data),
-        params.name,
+        params.path,
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined,
       );
       return wrapResult({
@@ -46,7 +46,7 @@ export function registerCatalogIndexMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       const info = await cat.indexGet(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined,
       );

package/src/protocol/handlers/catalog/macro.ts

@@ -36,7 +36,7 @@ export function registerCatalogMacroMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       const info = await cat.macroGet(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined
       );
@@ -55,7 +55,7 @@ export function registerCatalogMacroMethods(protocol: Protocol, getCatalog: GetC
       const innerParams = unwrapRequest(params.request);
       await cat.macroCreate(
         toUint8Array(innerParams.attach_opaque_data),
-        innerParams.schema_name,
+        innerParams.schema_path,
         innerParams.name,
         innerParams.macro_type as MacroType,
         innerParams.parameters ? (Array.isArray(innerParams.parameters) ? innerParams.parameters : [...innerParams.parameters]) : [],
@@ -77,7 +77,7 @@ export function registerCatalogMacroMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.macroDrop(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.ignore_not_found,
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined
@@ -94,7 +94,7 @@ export function registerCatalogMacroMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       const macros = await cat.schemaContentsMacros(
         toUint8Array(params.attach_opaque_data),
-        params.name,
+        params.path,
         decodeDictValue(params.type),
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined
       );

package/src/protocol/handlers/catalog/shared.ts

@@ -7,6 +7,7 @@ import type { CatalogInterface } from "../../../catalog/interface.js";
 import { NoCatalogError } from "../../../errors.js";
 import { deserializeBatch } from "../../../util/arrow/index.js";
 import { toUint8Array } from "../../../util/bytes.js";
+import { normalizeRequestSchemaPaths } from "../shared.js";
 import {
   sealBytes,
   openBytes,
@@ -194,6 +195,7 @@ export function catalogUnary(
     result: config.result as any,
     doc: config.doc,
     handler: async (params: Record<string, any>, ctx: any) => {
+      normalizeRequestSchemaPaths(params);
       await unwrapParamsOpaque(params, ctx, signingKey);
       return config.handler(params, ctx);
     },

package/src/protocol/handlers/catalog/table.ts

@@ -47,7 +47,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       const info = await cat.tableGet(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.at_unit,
         params.at_value,
@@ -67,7 +67,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.tableCreate(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         toUint8Array(params.columns),
         params.on_conflict,
@@ -88,7 +88,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.tableDrop(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.ignore_not_found,
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined
@@ -105,7 +105,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       const stats = await cat.tableColumnStatisticsGet(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined,
       );
@@ -121,7 +121,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       const scanResult = await cat.tableScanFunctionGet(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.at_unit,
         params.at_value,
@@ -141,7 +141,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       const branchesResult = await cat.tableScanBranchesGet(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.at_unit,
         params.at_value,
@@ -159,7 +159,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.tableCommentSet(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.comment,
         params.ignore_not_found,
@@ -177,7 +177,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.tableRename(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.new_name,
         params.ignore_not_found,
@@ -195,7 +195,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.tableColumnAdd(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.column_name,
         params.column_type,
@@ -215,7 +215,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.tableColumnDrop(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.column_name,
         params.ignore_not_found,
@@ -233,7 +233,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.tableColumnRename(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.column_name,
         params.new_name,
@@ -252,7 +252,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.tableColumnDefaultSet(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.column_name,
         params.default_value,
@@ -271,7 +271,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.tableColumnDefaultDrop(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.column_name,
         params.ignore_not_found,
@@ -289,7 +289,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.tableColumnTypeChange(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.column_name,
         params.new_type,
@@ -308,7 +308,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.tableNotNullSet(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.column_name,
         params.ignore_not_found,
@@ -326,7 +326,7 @@ export function registerCatalogTableMethods(protocol: Protocol, getCatalog: GetC
       const cat = getCatalog();
       await cat.tableNotNullDrop(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.column_name,
         params.ignore_not_found,

package/src/protocol/handlers/catalog/view.ts

@@ -32,7 +32,7 @@ export function registerCatalogViewMethods(protocol: Protocol, getCatalog: GetCa
       const cat = getCatalog();
       const info = await cat.viewGet(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined
       );
@@ -50,7 +50,7 @@ export function registerCatalogViewMethods(protocol: Protocol, getCatalog: GetCa
       const cat = getCatalog();
       await cat.viewCreate(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.definition,
         params.on_conflict,
@@ -68,7 +68,7 @@ export function registerCatalogViewMethods(protocol: Protocol, getCatalog: GetCa
       const cat = getCatalog();
       await cat.viewDrop(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.ignore_not_found,
         params.transaction_opaque_data ? toUint8Array(params.transaction_opaque_data) : undefined
@@ -85,7 +85,7 @@ export function registerCatalogViewMethods(protocol: Protocol, getCatalog: GetCa
       const cat = getCatalog();
       await cat.viewRename(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.new_name,
         params.ignore_not_found,
@@ -103,7 +103,7 @@ export function registerCatalogViewMethods(protocol: Protocol, getCatalog: GetCa
       const cat = getCatalog();
       await cat.viewCommentSet(
         toUint8Array(params.attach_opaque_data),
-        params.schema_name,
+        params.schema_path,
         params.name,
         params.comment,
         params.ignore_not_found,