Revert "core/seed: load a dialect's relations on demand"

Relations are seeded with the rest of the dialect again, so every record in
a dialect directory is applied as it is read and the catalog has no notion
of a seed that runs later. The cost this was avoiding — about 40ms per
invocation to install PostgreSQL's system catalogs — comes back, and will
be dealt with another way.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011MnoUabwBWW9gaEn2Nj7eG

Author: claude

internal/core/catalog.go

@@ -21,36 +21,6 @@ type Catalog struct {
 	// dialectOID is the dialect this catalog was seeded with. A catalog is
 	// built for one dialect, so dialect-wide lookups need no other input.
 	dialectOID int64
-
-	// deferred holds the parts of a seed that are only worth loading if a
-	// query asks for them. They run at most once, when a namespace lookup
-	// misses.
-	deferred     []func(*Catalog) error
-	deferredDone bool
-}
-
-// SeedLater registers a part of the seed to run the first time the catalog is
-// asked for a namespace it does not have. A dialect's system catalogs run to
-// thousands of columns that most queries never reference, so loading them is
-// left until one does.
-func (c *Catalog) SeedLater(fn func(*Catalog) error) {
-	c.deferred = append(c.deferred, fn)
-}
-
-// runDeferred runs the deferred seeds, reporting whether it had any to run.
-func (c *Catalog) runDeferred() (bool, error) {
-	if c.deferredDone || len(c.deferred) == 0 {
-		return false, nil
-	}
-	// Marked done up front: a deferred seed looks namespaces up itself, and
-	// must not set itself running again.
-	c.deferredDone = true
-	for _, fn := range c.deferred {
-		if err := fn(c); err != nil {
-			return false, err
-		}
-	}
-	return true, nil
 }
 
 type Option func(*Catalog) error

internal/core/namespace.go

@@ -15,20 +15,10 @@ func (c *Catalog) CreateNamespace(name string) (int64, error) {
 
 func (c *Catalog) NamespaceOID(name string) (int64, error) {
 	oid, err := c.q.NamespaceOID(context.Background(), name)
-	if err == nil {
-		return oid, nil
-	}
-	// A namespace the catalog does not have may be one a deferred seed brings
-	// in — a dialect's system catalogs, which most queries never name and
-	// which are therefore not loaded until one does.
-	if ran, derr := c.runDeferred(); derr != nil {
-		return 0, derr
-	} else if ran {
-		if oid, err := c.q.NamespaceOID(context.Background(), name); err == nil {
-			return oid, nil
-		}
+	if err != nil {
+		return 0, fmt.Errorf("namespace %q: %w", name, err)
 	}
-	return 0, fmt.Errorf("namespace %q: %w", name, err)
+	return oid, nil
 }
 
 type NamespaceInfo struct {

internal/core/seed/seed.go

@@ -15,10 +15,6 @@
 // The lists are JSONL — one record per line — and are applied as they are
 // read, so a dialect whose function list runs to thousands of entries is never
 // held in memory as a whole. Any of the lists may be left out.
-//
-// Relations are the exception to "applied as they are read": they are loaded
-// the first time a query names a schema the catalog does not yet have, since
-// most queries never touch a system catalog.
 package seed
 
 import (
@@ -192,13 +188,7 @@ func apply(cat *core.Catalog, fsys fs.FS) error {
 	if err := stream(fsys, FunctionsFile, b.addFunction); err != nil {
 		return err
 	}
-
-	// A dialect's system catalogs are thousands of columns that a query only
-	// occasionally names, so they wait until one does.
-	cat.SeedLater(func(*core.Catalog) error {
-		return stream(fsys, RelationsFile, b.addRelation)
-	})
-	return nil
+	return stream(fsys, RelationsFile, b.addRelation)
 }
 
 func loadSettings(fsys fs.FS) (Settings, error) {