Fix information_schema views for DuckLake mode

The previous implementation tried to create views in ducklake.main after
USE ducklake was set, but this caused the views to persist in the shared
DuckLake catalog. When the transpiler referenced these views, they couldn't
be found because:

1. Views in ducklake.main were stale from previous runs
2. Per-connection views in memory.main weren't accessible via memory.main.
   prefix after USE ducklake

This fix:

1. Splits attachDuckLake into two phases:
   - attachDuckLake: just attaches the catalog (no USE)
   - setDuckLakeDefault: runs USE ducklake

2. Creates views BEFORE USE ducklake so they go into memory.main

3. Views query from unqualified "information_schema" which resolves to
   the default catalog's information_schema at query time

4. Transpiler rewrites to memory.main.information_schema_*_compat which
   finds the per-connection views created during connection setup

The views now work as temporary per-connection views that query from
the DuckLake information_schema after USE ducklake is set.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: EDsCODE

server/catalog.go

@@ -318,19 +318,16 @@ func initPgCatalog(db *sql.DB) error {
 
 // initInformationSchema creates the column metadata table and information_schema wrapper views.
 // This enables accurate type information (VARCHAR lengths, NUMERIC precision) in information_schema.
-// When duckLakeMode is true, the views query from ducklake.information_schema instead of the
-// local information_schema, since DuckLake is set as the default catalog.
+// Views are created in memory.main (before USE ducklake) and query from unqualified information_schema,
+// which resolves to the default catalog's information_schema at query time.
 func initInformationSchema(db *sql.DB, duckLakeMode bool) error {
-	// Determine the source information_schema based on mode
-	// In DuckLake mode, we need to query ducklake.information_schema to see DuckLake tables
-	// In non-DuckLake mode, we query the local information_schema
+	// Use just "information_schema" without catalog prefix
+	// Views are created in memory.main (before USE ducklake) and query from information_schema
+	// which resolves to the current default catalog's information_schema at query time
 	infoSchemaPrefix := "information_schema"
-	if duckLakeMode {
-		infoSchemaPrefix = "ducklake.information_schema"
-	}
 
 	// Create metadata table to store column type information that DuckDB doesn't preserve
-	// Table is created in main schema of current database
+	// Table is created in main schema (which is memory.main before USE ducklake)
 	metadataTableSQL := `
 		CREATE TABLE IF NOT EXISTS main.__duckgres_column_metadata (
 			table_schema VARCHAR NOT NULL,
@@ -351,7 +348,7 @@ func initInformationSchema(db *sql.DB, duckLakeMode bool) error {
 	// Transforms DuckDB type names to PostgreSQL-compatible names
 	// Maps: VARCHAR->text, BOOLEAN->boolean, INTEGER->integer, BIGINT->bigint,
 	//       TIMESTAMP->timestamp without time zone, DECIMAL->numeric, etc.
-	// Views are created in main schema of current database
+	// Views are created in main schema (which is memory.main before USE ducklake)
 	columnsViewSQL := `
 		CREATE OR REPLACE VIEW main.information_schema_columns_compat AS
 		SELECT

server/server.go

@@ -280,7 +280,7 @@ func (s *Server) createDBConnection(username string) (*sql.DB, error) {
 		// Continue anyway - basic queries will still work
 	}
 
-	// Attach DuckLake catalog if configured
+	// Attach DuckLake catalog if configured (but don't set as default yet)
 	duckLakeMode := false
 	if err := s.attachDuckLake(db); err != nil {
 		// If DuckLake was explicitly configured, fail the connection.
@@ -295,13 +295,22 @@ func (s *Server) createDBConnection(username string) (*sql.DB, error) {
 		duckLakeMode = true
 	}
 
-	// Initialize information_schema compatibility views
-	// Must be done AFTER attaching DuckLake so views can reference ducklake.information_schema
+	// Initialize information_schema compatibility views in memory.main
+	// Must be done AFTER attaching DuckLake (so views can reference ducklake.information_schema)
+	// but BEFORE setting DuckLake as default (so views are created in memory.main, not ducklake.main)
 	if err := initInformationSchema(db, duckLakeMode); err != nil {
 		log.Printf("Warning: failed to initialize information_schema for user %q: %v", username, err)
 		// Continue anyway - basic queries will still work
 	}
 
+	// Now set DuckLake as the default catalog so all user queries use it
+	if duckLakeMode {
+		if err := setDuckLakeDefault(db); err != nil {
+			db.Close()
+			return nil, fmt.Errorf("failed to set DuckLake as default: %w", err)
+		}
+	}
+
 	return db, nil
 }
 
@@ -333,7 +342,8 @@ func (s *Server) loadExtensions(db *sql.DB) error {
 	return lastErr
 }
 
-// attachDuckLake attaches a DuckLake catalog if configured
+// attachDuckLake attaches a DuckLake catalog if configured (but does NOT set it as default).
+// Call setDuckLakeDefault after creating per-connection views in memory.main.
 func (s *Server) attachDuckLake(db *sql.DB) error {
 	if s.cfg.DuckLake.MetadataStore == "" {
 		return nil // DuckLake not configured
@@ -355,10 +365,7 @@ func (s *Server) attachDuckLake(db *sql.DB) error {
 	var count int
 	err := db.QueryRow("SELECT COUNT(*) FROM duckdb_databases() WHERE database_name = 'ducklake'").Scan(&count)
 	if err == nil && count > 0 {
-		// Already attached, just set as default
-		if _, err := db.Exec("USE ducklake"); err != nil {
-			return fmt.Errorf("failed to set DuckLake as default catalog: %w", err)
-		}
+		// Already attached
 		return nil
 	}
 
@@ -398,13 +405,17 @@ func (s *Server) attachDuckLake(db *sql.DB) error {
 		return fmt.Errorf("failed to attach DuckLake: %w", err)
 	}
 
-	// Set DuckLake as the default catalog so all queries use it
-	// See: https://duckdb.org/docs/stable/core_extensions/ducklake#usage
+	log.Printf("Attached DuckLake catalog successfully")
+	return nil
+}
+
+// setDuckLakeDefault sets the DuckLake catalog as the default so all queries use it.
+// This should be called AFTER creating per-connection views in memory.main.
+func setDuckLakeDefault(db *sql.DB) error {
 	if _, err := db.Exec("USE ducklake"); err != nil {
 		return fmt.Errorf("failed to set DuckLake as default catalog: %w", err)
 	}
-
-	log.Printf("Attached DuckLake catalog successfully and set as default")
+	log.Printf("Set DuckLake as default catalog")
 	return nil
 }
 

transpiler/transform/information_schema.go

@@ -60,17 +60,17 @@ func (t *InformationSchemaTransform) walkAndTransform(node *pg_query.Node, chang
 
 	switch n := node.Node.(type) {
 	case *pg_query.Node_RangeVar:
-		// Table references: information_schema.columns -> information_schema_columns_compat
-		// Views are created in the main schema of the current database
+		// Table references: information_schema.columns -> memory.main.information_schema_columns_compat
+		// Views are created in the memory.main schema so they're always accessible regardless of default catalog
 		// Skip transformation if catalog is explicitly "ducklake" - those are queries from
 		// within the compat views that need to access the actual DuckLake information_schema
 		if n.RangeVar != nil && strings.EqualFold(n.RangeVar.Schemaname, "information_schema") &&
 			!strings.EqualFold(n.RangeVar.Catalogname, "ducklake") {
 			relname := strings.ToLower(n.RangeVar.Relname)
 			if newName, ok := t.ViewMappings[relname]; ok {
 				n.RangeVar.Relname = newName
-				// Views are in main schema (no catalog prefix needed)
-				n.RangeVar.Catalogname = ""
+				// Views are in memory.main schema - always use explicit catalog for DuckLake compatibility
+				n.RangeVar.Catalogname = "memory"
 				n.RangeVar.Schemaname = "main"
 				*changed = true
 			}

transpiler/transpiler_test.go

@@ -105,31 +105,31 @@ func TestTranspile_InformationSchema(t *testing.T) {
 		{
 			name:     "information_schema.columns -> compat view",
 			input:    "SELECT * FROM information_schema.columns",
-			contains: "information_schema_columns_compat",
+			contains: "memory.main.information_schema_columns_compat",
 			excludes: "information_schema.columns",
 		},
 		{
 			name:     "information_schema.tables -> compat view",
 			input:    "SELECT * FROM information_schema.tables",
-			contains: "information_schema_tables_compat",
+			contains: "memory.main.information_schema_tables_compat",
 			excludes: "information_schema.tables",
 		},
 		{
 			name:     "information_schema.schemata -> compat view",
 			input:    "SELECT * FROM information_schema.schemata",
-			contains: "information_schema_schemata_compat",
+			contains: "memory.main.information_schema_schemata_compat",
 			excludes: "information_schema.schemata",
 		},
 		{
 			name:     "INFORMATION_SCHEMA.COLUMNS uppercase -> compat view",
 			input:    "SELECT * FROM INFORMATION_SCHEMA.COLUMNS",
-			contains: "information_schema_columns_compat",
+			contains: "memory.main.information_schema_columns_compat",
 			excludes: "information_schema.columns",
 		},
 		{
 			name:     "aliased information_schema query",
 			input:    "SELECT c.column_name FROM information_schema.columns c WHERE c.table_name = 'test'",
-			contains: "information_schema_columns_compat",
+			contains: "memory.main.information_schema_columns_compat",
 			excludes: "information_schema.columns",
 		},
 		{
@@ -169,14 +169,14 @@ func TestTranspile_InformationSchema_DuckLakeMode(t *testing.T) {
 		contains string
 	}{
 		{
-			name:     "information_schema.columns with DuckLake -> main qualified",
+			name:     "information_schema.columns with DuckLake -> memory.main qualified",
 			input:    "SELECT * FROM information_schema.columns",
-			contains: "main.information_schema_columns_compat",
+			contains: "memory.main.information_schema_columns_compat",
 		},
 		{
-			name:     "information_schema.tables with DuckLake -> main qualified",
+			name:     "information_schema.tables with DuckLake -> memory.main qualified",
 			input:    "SELECT * FROM information_schema.tables",
-			contains: "main.information_schema_tables_compat",
+			contains: "memory.main.information_schema_tables_compat",
 		},
 	}