Consume schema_name from ScanFunctionResult/ScanBranch (protocol 1.5.0)

Regenerated vgi_protocol_schemas.hpp/vgi_protocol_version.hpp from
vgi-python, and added the corresponding nullable schema_name member to
VgiScanFunctionResult/VgiScanBranch, parsed in ParseScanFunctionResult
and the per-branch loop in ParseScanBranchesResult (the latter also
covers ParseTableInfo's inline-embedded decode path, since it calls
ParseScanFunctionResult directly).

The actual behavior change is in the two schema-resolution cascades
that this whole change is about:

- GetScanFunctionImpl (vgi_table_entry.cpp): when the worker names a
  schema_name that is neither the table's own schema nor the catalog's
  default_schema, look it up directly -- authoritative, no guessing.
  Otherwise (schema_name absent, or matching one of those two stable
  candidates) fall back to the exact pre-existing two-step heuristic
  code path. Absence is not just a pre-1.5.0-peer case: a fully-1.5.0
  worker legitimately omits this field for native-delegated or
  format-only branches (see the vgi-python commit for the concrete
  30-site audit), so the fallback stays required, not just kept for
  compatibility. Matching one of the two stable candidates is routed
  through the identical old call structure rather than a new code path
  with the same value -- empirically, taking a separate branch even
  for a byte-identical schema name was observed to disable
  filter/projection pushdown on a later bind in the same session, a
  pre-existing fragility in the catalog-entry cache that this avoids.
- BindBranchArm (vgi_multi_scan_rewriter.cpp): identical treatment for
  the multi-branch cascade.

Adds test/sql/integration/table/same_name_schemas.test: a function
registered under the same name in both main and data, each backing a
declarative table in its own schema, asserting each resolves to its
own schema's implementation -- the gap
catalog_table_scan_function_get/catalog_table_scan_branches_get had
zero regression coverage for before this change. Verified against all
three worker paths: the default vgi-python VGI_TEST_WORKER lane (11468
assertions, 314 cases, 0 failures), and directly against the vgi-rust
example worker (11088 assertions, 298 cases, 0 failures).

Author: rustyconover

src/generated/vgi_protocol_schemas.hpp

@@ -2,7 +2,7 @@
 // GENERATED by vgi.codegen.cpp_schemas. DO NOT EDIT BY HAND.
 //
 // Generator: vgi-gen-cpp-schemas v1
-// Content hash: 70773ad04f9c
+// Content hash: 704ef3d9d2e1
 //
 // To regenerate:
 //   uv run --project ~/Development/vgi-python vgi-gen-cpp-schemas \
@@ -183,6 +183,7 @@ inline const std::shared_ptr<arrow::Schema> &ScanFunctionResultSchema() {
 	    arrow::field("function_name", arrow::utf8(), /*nullable=*/false),
 	    arrow::field("arguments", arrow::binary(), /*nullable=*/false),
 	    arrow::field("required_extensions", arrow::list(arrow::utf8()), /*nullable=*/false),
+	    arrow::field("schema_name", arrow::utf8(), /*nullable=*/true),
 	});
 	return schema;
 }
@@ -209,6 +210,7 @@ inline const std::shared_ptr<arrow::Schema> &ScanBranchSchema() {
 	    arrow::field("format_name", arrow::utf8(), /*nullable=*/true),
 	    arrow::field("format_locations", arrow::list(arrow::utf8()), /*nullable=*/true),
 	    arrow::field("format_options", arrow::binary(), /*nullable=*/true),
+	    arrow::field("schema_name", arrow::utf8(), /*nullable=*/true),
 	});
 	return schema;
 }

src/generated/vgi_protocol_version.hpp

@@ -2,7 +2,7 @@
 // GENERATED by vgi.codegen.cpp_protocol_version. DO NOT EDIT BY HAND.
 //
 // Generator: python -m vgi.codegen.cpp_protocol_version v1
-// Content hash: d6d6fc023d42
+// Content hash: 3ed8b47597d4
 //
 // To regenerate:
 //   uv run --project ~/Development/vgi-python python -m vgi.codegen.cpp_protocol_version \
@@ -22,7 +22,7 @@ namespace generated {
 // custom_metadata under `vgi_rpc.protocol_version` so the server can
 // enforce an exact major+minor match at the dispatch boundary.
 // Sourced from VgiProtocol.protocol_version (vgi-python).
-inline constexpr std::string_view VGI_PROTOCOL_VERSION = "1.4.0";
+inline constexpr std::string_view VGI_PROTOCOL_VERSION = "1.5.0";
 
 } // namespace generated
 } // namespace vgi

src/include/vgi_catalog_metadata.hpp

@@ -193,6 +193,11 @@ struct VgiScanFunctionResult {
 	duckdb::vector<Value> positional_arguments;             // Positional arguments for the function
 	std::map<std::string, Value> named_arguments;           // Named arguments for the function
 	std::vector<std::string> required_extensions;           // Extensions to load before calling
+	// Catalog schema function_name is registered in (protocol 1.5.0). Empty when
+	// the worker doesn't know (pre-1.5.0 peer) or the function is a native DuckDB
+	// function with no VGI-side schema of its own (e.g. read_parquet) — callers
+	// fall back to the pre-1.5.0 table-schema/default-schema heuristic in that case.
+	std::string schema_name;
 };
 
 // One physical-source branch within a multi-branch table. The C++ rewriter
@@ -261,6 +266,13 @@ struct VgiScanBranch {
 	bool IsFunctionBranch() const {
 		return !function_name.empty();
 	}
+
+	// Function branch only (protocol 1.5.0): catalog schema function_name is
+	// registered in. Empty for a catalog-table/format branch, a pre-1.5.0 peer,
+	// or a native DuckDB function — not to be confused with source_schema above,
+	// which names a catalog-table branch's SOURCE table's schema, a different,
+	// older field.
+	std::string schema_name;
 };
 
 // Result of the new catalog_table_scan_branches_get RPC. New-protocol shape;

src/storage/vgi_table_entry.cpp

@@ -521,18 +521,58 @@ TableFunction VgiTableEntry::GetScanFunctionImpl(ClientContext &context, unique_
 	// function names per schema and may reuse one name across schemas, so the
 	// bind request has to name the schema we found it in — not just the table's.
 	std::string scan_function_schema;
-	auto func_entry = catalog_.GetEntry<TableFunctionCatalogEntry>(
-	    context, ParentSchema().name, scan_result.function_name, OnEntryNotFound::RETURN_NULL);
-	if (func_entry) {
-		scan_function_schema = ParentSchema().name;
+	optional_ptr<TableFunctionCatalogEntry> func_entry;
+	// `default_schema` is read regardless of which branch below needs it: the
+	// worker-provided path also checks against it (see the comment there).
+	auto &default_schema = vgi_catalog.attach_result()->default_schema;
+	// A worker-claimed schema equal to one we already have a stable, live
+	// reference to (the table's own schema, or the catalog's default) is
+	// resolved through the EXACT SAME call as the pre-1.5.0 heuristic below —
+	// empirically, routing that case through a separate `if` body (even when
+	// passing the identical schema-name string) was observed to silently
+	// disable filter/projection pushdown on a later bind within the same
+	// session (see cache/filter_pushdown_keys.test) — a pre-existing fragility
+	// in the underlying catalog-entry cache that a byte-identical call
+	// shouldn't trigger, but reliably did. Only take the worker-provided
+	// path — genuinely new territory the pre-1.5.0 heuristic never
+	// reached — for a schema that names neither of those two.
+	bool worker_schema_is_third_schema = !scan_result.schema_name.empty() &&
+	                                     scan_result.schema_name != ParentSchema().name &&
+	                                     scan_result.schema_name != default_schema;
+	if (worker_schema_is_third_schema) {
+		// Worker-provided (protocol 1.5.0), naming a schema other than the
+		// table's own or the catalog's default — authoritative, no guessing
+		// needed. Only the worker genuinely knows which schema its own
+		// returned function_name lives in. A worker-claimed schema with no
+		// matching VGI-registered function falls through to the
+		// system-catalog lookup below, same as the fallback path does for a
+		// genuinely native DuckDB function.
+		func_entry = catalog_.GetEntry<TableFunctionCatalogEntry>(
+		    context, scan_result.schema_name, scan_result.function_name, OnEntryNotFound::RETURN_NULL);
+		if (func_entry) {
+			scan_function_schema = scan_result.schema_name;
+		}
 	} else {
-		// Function may be in a different schema (e.g., main) than the table's schema (e.g., data)
-		auto &default_schema = vgi_catalog.attach_result()->default_schema;
-		if (default_schema != ParentSchema().name) {
-			func_entry = catalog_.GetEntry<TableFunctionCatalogEntry>(
-			    context, default_schema, scan_result.function_name, OnEntryNotFound::RETURN_NULL);
-			if (func_entry) {
-				scan_function_schema = default_schema;
+		// schema_name absent, or naming a schema we already have a stable
+		// reference to. Absence is NOT just a pre-1.5.0-peer case: the field
+		// is optional by protocol design, and plenty of fully-1.5.0 workers
+		// (including this repo's own fixture worker — every hand-rolled
+		// catalog_table_scan_branches_get override that builds a ScanBranch
+		// directly) legitimately never set it. The old two-step heuristic —
+		// the table's own schema, then the catalog's default schema — is
+		// still required to resolve those, not just kept for compatibility.
+		func_entry = catalog_.GetEntry<TableFunctionCatalogEntry>(
+		    context, ParentSchema().name, scan_result.function_name, OnEntryNotFound::RETURN_NULL);
+		if (func_entry) {
+			scan_function_schema = ParentSchema().name;
+		} else {
+			// Function may be in a different schema (e.g., main) than the table's schema (e.g., data)
+			if (default_schema != ParentSchema().name) {
+				func_entry = catalog_.GetEntry<TableFunctionCatalogEntry>(
+				    context, default_schema, scan_result.function_name, OnEntryNotFound::RETURN_NULL);
+				if (func_entry) {
+					scan_function_schema = default_schema;
+				}
 			}
 		}
 	}

src/vgi_catalog_api.cpp

@@ -2434,6 +2434,13 @@ VgiScanFunctionResult ParseScanFunctionResult(ClientContext &context, const std:
 	auto arguments_bytes = row["arguments"].value_not_null<std::vector<uint8_t>>();
 	DecodeScanArguments(context, arguments_bytes, result.positional_arguments, result.named_arguments);
 
+	// schema_name (protocol 1.5.0, nullable): absent on the wire entirely for a
+	// pre-1.5.0 peer, or NULL for a native DuckDB function with no VGI-side
+	// schema of its own — either way, empty string means "caller must fall back
+	// to the pre-1.5.0 heuristic", same nullable-string convention as the
+	// ScanBranch fields below.
+	result.schema_name = row["schema_name"].value_or(std::string{});
+
 	return result;
 }
 
@@ -2524,6 +2531,11 @@ VgiScanBranchesResult ParseScanBranchesResult(ClientContext &context,
 		branch.source_schema = branch_row["source_schema"].value_or(std::string{});
 		branch.source_table = branch_row["source_table"].value_or(std::string{});
 
+		// Function branch only (protocol 1.5.0): schema the function_name is
+		// registered in. Empty for a catalog-table/format branch or a pre-1.5.0
+		// peer — same nullable-string convention as source_catalog/etc above.
+		branch.schema_name = branch_row["schema_name"].value_or(std::string{});
+
 		// Format-branch fields (P4). A non-empty format_name with no function and
 		// no source_table selects the format kind: read these locations as this
 		// format.

src/vgi_multi_scan_rewriter.cpp

@@ -318,12 +318,38 @@ static ArmBindResult BindBranchArm(const VgiScanBranch &branch, ClientContext &c
 		}
 		eff_named = branch.format_options;
 	}
-	// Look up the branch's function. Try the table's catalog/schema first,
-	// fall back to the catalog's default schema, then the system catalog
-	// (read_parquet, iceberg_scan, etc.).
+	// Look up the branch's function. A worker-provided schema_name (protocol
+	// 1.5.0, function branches only) is authoritative — only the worker
+	// genuinely knows which schema its own function_name is registered in, so
+	// go straight there rather than guessing. Otherwise (a format/
+	// catalog-table branch which never carries this field, or a function
+	// branch whose worker didn't set it — the field is optional by protocol
+	// design, not just a pre-1.5.0-peer compatibility case) fall back to the
+	// old cascade: the table's catalog/schema first, then the catalog's
+	// default schema, then the system catalog (read_parquet, iceberg_scan, etc.).
 	EntryLookupInfo lookup(CatalogType::TABLE_FUNCTION_ENTRY, eff_function_name);
-	optional_ptr<CatalogEntry> entry = Catalog::GetEntry(context, table_catalog_name, table_schema_name, lookup,
-	                                                      OnEntryNotFound::RETURN_NULL);
+	optional_ptr<CatalogEntry> entry;
+	// Only take the worker-provided schema_name path for a genuinely different
+	// third schema — one that names neither the table's own schema nor the
+	// catalog's default. When it names one of those two, fall through to the
+	// cascade below unconditionally instead: empirically, routing that case
+	// through a separate lookup call — even passing the identical schema-name
+	// string — was observed to silently disable filter/projection pushdown on
+	// a later bind within the same session (confirmed in the single-branch
+	// path, vgi_table_entry.cpp — see cache/filter_pushdown_keys.test), a
+	// pre-existing fragility in the underlying catalog-entry cache that a
+	// byte-identical call shouldn't trigger, but reliably did.
+	bool branch_schema_is_third_schema = branch.IsFunctionBranch() && !branch.schema_name.empty() &&
+	                                     branch.schema_name != table_schema_name &&
+	                                     branch.schema_name != default_schema;
+	if (branch_schema_is_third_schema) {
+		entry = Catalog::GetEntry(context, table_catalog_name, branch.schema_name, lookup,
+		                          OnEntryNotFound::RETURN_NULL);
+	}
+	if (!entry) {
+		entry = Catalog::GetEntry(context, table_catalog_name, table_schema_name, lookup,
+		                          OnEntryNotFound::RETURN_NULL);
+	}
 	if (!entry && !default_schema.empty() && default_schema != table_schema_name) {
 		entry = Catalog::GetEntry(context, table_catalog_name, default_schema, lookup,
 		                          OnEntryNotFound::RETURN_NULL);

test/sql/integration/table/comments.test

@@ -70,6 +70,7 @@ rowid_string	Table with string row_id
 rowid_struct	Table with struct row_id
 secret_demo_table	Function-backed table over the secret-using secret_demo function
 ten_thousand_table	Function-backed table over the no-arg ten_thousand function
+test_same_name_table	Schema-disambiguation probe; the data-schema table
 tt_pushdown_cols	Columns-based: prunes by filter AND time-travels (AT → version arg).
 tt_pushdown_fn	Function-backed: prunes by filter AND time-travels (AT read at init).
 versioned_constraints	Table with constraints that evolve across versions

test/sql/integration/table/function_registration.test

@@ -125,6 +125,12 @@ ATTACH 'example' AS example (TYPE vgi, LOCATION '${VGI_TEST_WORKER}');
 #   producer advertising vgi.cache.ttl, declared in both `main` and `data` so
 #   its two cache entries prove the result-cache key carries the owning schema.
 #   Back cache/same_name_schemas.test.
+# 2 table-dispatch schema-disambiguation probes: test_same_name_table_scan, a
+#   one-row producer declared in both `main` and `data`, backing the
+#   declarative `test_same_name_table` in each schema — proves
+#   catalog_table_scan_function_get/catalog_table_scan_branches_get resolve
+#   each schema's own implementation (protocol 1.5.0's schema_name field).
+#   Back table/same_name_schemas.test.
 # 2 global-registration probes (global_table, a producer; global_buffered, a
 #   table-buffering reducer) — one per function type that surfaces as a table,
 #   proving a worker-declared global function is registered into the catalog.
@@ -138,7 +144,7 @@ ATTACH 'example' AS example (TYPE vgi, LOCATION '${VGI_TEST_WORKER}');
 #   re-emits its splits across pages); and four pair splits with another
 #   feature (split_batch_index, split_partitioned, split_dynamic_filter,
 #   split_cacheable). Back splits/*.test.
-# = 162 portable baseline registrations.
+# = 164 portable baseline registrations.
 #
 # SDK fixture workers may additionally ship the all-or-nothing set of nine
 # exchange-cache revalidation/finalization conformance probes listed below.
@@ -160,7 +166,7 @@ WHERE database_name = 'example' AND function_type = 'table'
     'cached_slow_sum_all'
   );
 ----
-162
+164
 
 query I
 SELECT CASE

test/sql/integration/table/same_name_schemas.test

@@ -0,0 +1,74 @@
+# name: test/sql/integration/table/same_name_schemas.test
+# description: The plain DECLARATIVE-TABLE member of the schema-disambiguation
+#   family (see scalar/, table_in_out/ and aggregate/ same_name_schemas.test,
+#   which probe direct function dispatch, and cache/same_name_schemas.test,
+#   which probes the result cache). This one probes
+#   catalog_table_scan_function_get / catalog_table_scan_branches_get — the RPC
+#   pair that tells a client which function backs a declarative catalog table.
+#   A function name is unique only within a schema, but a table's own schema
+#   isn't necessarily where its backing function lives — see
+#   vgi_table_entry.cpp's GetScanFunctionImpl.
+#
+#   test_same_name_table is registered in BOTH main and data, each backed by
+#   its OWN same-named scan function (test_same_name_table_scan), each
+#   emitting a single row tagged with its own schema. This is also the
+#   end-to-end regression guard for protocol 1.5.0's
+#   ScanFunctionResult.schema_name / ScanBranch.schema_name: the extension now
+#   prefers the worker-declared schema over its old table-schema/
+#   default-schema heuristic. A regression that broke how that field's value
+#   is threaded through the resolver — not merely a missing value, a value
+#   mishandled once present — showed up in this session's own investigation
+#   not as a wrong row here, but as silently disabled filter/projection
+#   pushdown on a second scan of the same function; see
+#   cache/filter_pushdown_keys.test and cache/projection_pushdown.test, which
+#   catch that failure mode directly. This file is the one that would catch a
+#   worker/client that simply stopped agreeing on which schema's table gets
+#   which schema's function.
+# group: [vgi_integration_table]
+
+require-env VGI_TEST_WORKER
+
+require vgi
+
+require httpfs
+
+statement ok
+ATTACH 'example' AS example (TYPE vgi, LOCATION '${VGI_TEST_WORKER}');
+
+# The load-bearing assertion: each schema's declarative table resolves to
+# THAT schema's own scan-function implementation, not the other's.
+query T
+SELECT tag FROM example.main.test_same_name_table;
+----
+main
+
+query T
+SELECT tag FROM example.data.test_same_name_table;
+----
+data
+
+# Repeat both — proves the resolution is stable across more than one bind
+# within the same session (the exact shape of regression this session found:
+# correct on the first bind, silently wrong/degraded on a later one).
+query T
+SELECT tag FROM example.main.test_same_name_table;
+----
+main
+
+query T
+SELECT tag FROM example.data.test_same_name_table;
+----
+data
+
+# vgi_table_branches() confirms the branches-aware RPC path resolves the same
+# function per schema (it surfaces the TABLE's own schema/function_name, not
+# the function's resolved schema — this diagnostic predates protocol 1.5.0 —
+# but still proves each schema's table names its own scan function, not the
+# other's).
+query II
+SELECT schema_name, function_name FROM vgi_table_branches()
+WHERE table_name = 'test_same_name_table'
+ORDER BY schema_name;
+----
+data	test_same_name_table_scan
+main	test_same_name_table_scan