Merge pull request #52 from PostHog/fix/information-schema-ducklake-views

Fix information_schema views for DuckLake mode

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",
 		},
 	}