@query-farm/vgi 0.7.0 → 0.8.0

package/dist/catalog/descriptors.d.ts

@@ -1,4 +1,5 @@
 import type { VgiSchema, VgiDataType } from "../arrow/index.js";
+import type { AttachCatalogInfo } from "./interface.js";
 import type { VgiFunction } from "../functions/types.js";
 import type { Arguments } from "../arguments/arguments.js";
 import type { ColumnStatistics } from "../util/statistics.js";
@@ -142,6 +143,11 @@ export interface CatalogDescriptor {
     schemas: SchemaDescriptor[];
     settings?: SettingDescriptor[];
     secretTypes?: SecretTypeDescriptor[];
+    /**
+     * Companion catalogs (lakehouse federation) the client should ATTACH when this
+     * VGI catalog attaches. Surfaced via `catalog_attach.attach_catalogs`.
+     */
+    attachCatalogs?: AttachCatalogInfo[];
     comment?: string;
     tags?: Record<string, string>;
     /**

package/dist/catalog/interface.d.ts

@@ -56,6 +56,31 @@ export interface CopyFromFormatInfo {
 }
 /** Encode a CopyFromFormatInfo to Arrow IPC bytes (single-row batch). */
 export declare const encodeCopyFromFormatInfo: (v: CopyFromFormatInfo) => Uint8Array;
+/**
+ * A companion catalog the client should ATTACH when this VGI catalog attaches
+ * (lakehouse federation). Serialized into `CatalogAttachResult.attach_catalogs`;
+ * the C++ VGI extension attaches each at VGI-attach time so multi-branch
+ * catalog-table branches can resolve tables in a companion DuckLake / Iceberg /
+ * Postgres / DuckDB.
+ */
+export interface AttachCatalogInfo {
+    /** ATTACH alias; also a catalog-table ScanBranch's `sourceCatalog`. */
+    alias: string;
+    /** ATTACH target — a path or DSN (e.g. `ducklake:sqlite:/data/meta.sqlite`). */
+    target: string;
+    /** DuckDB db type; empty => inferred from the target scheme prefix. */
+    db_type?: string;
+    /** Extra ATTACH options forwarded verbatim (e.g. DuckLake DATA_PATH). */
+    options?: Record<string, string>;
+    /** Attach hidden (excluded from duckdb_databases()); still resolvable. */
+    hidden?: boolean;
+    /** When true, attach failure fails the whole VGI ATTACH. */
+    required?: boolean;
+    /** Optional named secret to inject into the companion's ATTACH options. */
+    secret_ref?: string;
+}
+/** Encode an AttachCatalogInfo to Arrow IPC bytes (single-row batch). */
+export declare const encodeAttachCatalogInfo: (v: AttachCatalogInfo) => Uint8Array;
 import { type VgiDataType } from "../arrow/index.js";
 /**
  * Result from `tableScanFunctionGet` — tells the VGI DuckDB extension which
@@ -124,6 +149,15 @@ export interface ScanBranchInput {
     branchFilter?: string | null;
     /** Declares this branch as the INSERT target (at most one per table). */
     writable?: boolean;
+    /**
+     * Catalog-table branch (lakehouse federation): leave `functionName` empty and
+     * set these to scan the base table
+     * `sourceCatalog.sourceSchema.sourceTable` in a companion catalog instead of
+     * calling a table function.
+     */
+    sourceCatalog?: string | null;
+    sourceSchema?: string | null;
+    sourceTable?: string | null;
 }
 /**
  * Build a multi-branch `ScanBranchesResult` wire dict from explicit branch

package/dist/generated/vgi-client.d.ts

@@ -304,6 +304,7 @@ export interface CatalogAttachResult {
     default_schema: string;
     settings: Uint8Array[];
     secret_types: Uint8Array[];
+    attach_catalogs: Uint8Array[];
     comment?: string | null;
     tags: Record<string, string>;
     supports_column_statistics: boolean;

package/dist/generated/vgi-protocol-schemas.d.ts

@@ -9,6 +9,7 @@ export declare const CopyFromFormatInfoSchema: import("../index.core.js").VgiSch
 export declare const ScanFunctionResultSchema: import("../index.core.js").VgiSchema;
 export declare const ScanBranchesResultSchema: import("../index.core.js").VgiSchema;
 export declare const ScanBranchSchema: import("../index.core.js").VgiSchema;
+export declare const AttachCatalogInfoSchema: import("../index.core.js").VgiSchema;
 export declare const AggregateBindResultSchema: import("../index.core.js").VgiSchema;
 export declare const AggregateCombineResultSchema: import("../index.core.js").VgiSchema;
 export declare const AggregateDestructorResultSchema: import("../index.core.js").VgiSchema;

package/dist/index.js

@@ -5584,7 +5584,19 @@ var ScanBranchSchema = schema2([
   field2("function_name", utf82(), false),
   field2("arguments", binary2(), false),
   field2("branch_filter", utf82(), true),
-  field2("writable", bool2(), false)
+  field2("writable", bool2(), false),
+  field2("source_catalog", utf82(), true),
+  field2("source_schema", utf82(), true),
+  field2("source_table", utf82(), true)
+]);
+var AttachCatalogInfoSchema = schema2([
+  field2("alias", utf82(), false),
+  field2("target", utf82(), false),
+  field2("db_type", utf82(), false),
+  field2("options", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
+  field2("hidden", bool2(), false),
+  field2("required", bool2(), false),
+  field2("secret_ref", utf82(), false)
 ]);
 var AggregateBindResultSchema = schema2([
   field2("output_schema", binary2(), false),
@@ -5628,6 +5640,7 @@ var CatalogAttachResultSchema = schema2([
   field2("default_schema", utf82(), false),
   field2("settings", list2(field2("item", binary2(), true)), false),
   field2("secret_types", list2(field2("item", binary2(), true)), false),
+  field2("attach_catalogs", list2(field2("item", binary2(), true)), false),
   field2("comment", utf82(), true),
   field2("tags", map2(field2("key", utf82(), false), field2("value", utf82(), true), false), false),
   field2("supports_column_statistics", bool2(), false),
@@ -6090,6 +6103,15 @@ var encodeCopyFromFormatInfo = (v) => encodeASD(CopyFromFormatInfoSchema, {
   description: v.description ?? "",
   ordered: v.ordered ?? false
 });
+var encodeAttachCatalogInfo = (v) => encodeASD(AttachCatalogInfoSchema, {
+  alias: v.alias,
+  target: v.target,
+  db_type: v.db_type ?? "",
+  options: v.options ?? {},
+  hidden: v.hidden ?? false,
+  required: v.required ?? false,
+  secret_ref: v.secret_ref ?? ""
+});
 function decodeScanFunctionResult(inner) {
   const argsBytes = inner.arguments;
   const positionalArguments = [];
@@ -6123,7 +6145,10 @@ function singleBranchResult(legacy) {
     function_name: [legacy.function_name],
     arguments: [toUint8Array(legacy.arguments)],
     branch_filter: [null],
-    writable: [false]
+    writable: [false],
+    source_catalog: [null],
+    source_schema: [null],
+    source_table: [null]
   }, ScanBranchSchema);
   return {
     branches: [serializeBatch(branchBatch)],
@@ -6152,7 +6177,10 @@ function buildScanBranchesResult(branches, requiredExtensions = []) {
       function_name: [branch.functionName],
       arguments: [serializeBranchArguments(branch)],
       branch_filter: [branch.branchFilter ?? null],
-      writable: [branch.writable ?? false]
+      writable: [branch.writable ?? false],
+      source_catalog: [branch.sourceCatalog ?? null],
+      source_schema: [branch.sourceSchema ?? null],
+      source_table: [branch.sourceTable ?? null]
     }, ScanBranchSchema);
     return serializeBatch(branchBatch);
   });
@@ -6525,6 +6553,7 @@ class ReadOnlyCatalogInterface extends CatalogInterface {
     this._attachments.set(name, attachOpaqueData);
     const settings = (this._descriptor.settings ?? []).map((s) => serializeSetting(s));
     const secretTypes = (this._descriptor.secretTypes ?? []).map((s) => serializeSecretType(s));
+    const attachCatalogs = (this._descriptor.attachCatalogs ?? []).map((c) => encodeAttachCatalogInfo(c));
     const hasTimeTravel = this._descriptor.schemas.some((s) => s.tables?.some((t) => t.supportsTimeTravel) ?? false);
     return {
       attach_opaque_data: attachOpaqueData,
@@ -6536,6 +6565,7 @@ class ReadOnlyCatalogInterface extends CatalogInterface {
       default_schema: this._descriptor.defaultSchema ?? "main",
       settings,
       secret_types: secretTypes,
+      attach_catalogs: attachCatalogs,
       comment: this._descriptor.comment ?? null,
       tags: this._descriptor.tags ?? {},
       supports_column_statistics: true,
@@ -9166,6 +9196,7 @@ function registerCatalogAdminMethods(protocol, getCatalog, signingKey) {
         default_schema: result.default_schema ?? "main",
         settings: result.settings ?? [],
         secret_types: result.secret_types ?? [],
+        attach_catalogs: result.attach_catalogs ?? [],
         comment: result.comment ?? null,
         tags: result.tags ?? {},
         supports_column_statistics: result.supports_column_statistics ?? true,
@@ -10256,6 +10287,7 @@ class VgiClient {
       default_schema: inner.default_schema ?? "main",
       settings: inner.settings ? (Array.isArray(inner.settings) ? inner.settings : [...inner.settings]).map(toUint8Array) : [],
       secret_types: inner.secret_types ? (Array.isArray(inner.secret_types) ? inner.secret_types : [...inner.secret_types]).map(toUint8Array) : [],
+      attach_catalogs: inner.attach_catalogs ? (Array.isArray(inner.attach_catalogs) ? inner.attach_catalogs : [...inner.attach_catalogs]).map(toUint8Array) : [],
       comment: inner.comment ?? null,
       tags: deserializeTags(inner.tags),
       supports_column_statistics: inner.supports_column_statistics ?? false,
@@ -10885,4 +10917,4 @@ export {
   ArgumentValidationError
 };
 
-//# debugId=19A9033B1335C3EC64756E2164756E21
+//# debugId=2E19C6BFB109AD5C64756E2164756E21