fix: managed-db issues

qykr · qykr · commit 4112a367a659 · 2026-03-10T17:57:48.000-07:00
diff --git a/internal/compiler/find_params.go b/internal/compiler/find_params.go
@@ -144,6 +144,11 @@ func (p paramSearch) Visit(node ast.Node) astutils.Visitor {
 		p.parent = node
 
 	case *ast.SelectStmt:
+		if n.FromClause != nil && len(n.FromClause.Items) > 0 {
+			if rv, ok := n.FromClause.Items[0].(*ast.RangeVar); ok {
+				p.rangeVar = rv
+			}
+		}
 		if n.LimitCount != nil {
 			p.limitCount = n.LimitCount
 		}
diff --git a/internal/compiler/find_params_test.go b/internal/compiler/find_params_test.go
@@ -0,0 +1,32 @@
+package compiler
+
+import (
+	"testing"
+
+	"github.com/sqlc-dev/sqlc/internal/sql/ast"
+)
+
+func TestFindParametersSelectStmtUsesFromRangeVarForWhereParams(t *testing.T) {
+	t.Parallel()
+
+	tableName := "solar_commcard_mapping"
+	refs, errs := findParameters(&ast.SelectStmt{
+		FromClause: &ast.List{Items: []ast.Node{&ast.RangeVar{Relname: &tableName}}},
+		WhereClause: &ast.A_Expr{
+			Lexpr: &ast.ColumnRef{Fields: &ast.List{Items: []ast.Node{&ast.String{Str: "deviceId"}}}},
+			Rexpr: &ast.ParamRef{Number: 1, Location: 1},
+		},
+	})
+	if len(errs) > 0 {
+		t.Fatalf("findParameters returned errors: %v", errs)
+	}
+	if len(refs) != 1 {
+		t.Fatalf("expected 1 ref, got %d", len(refs))
+	}
+	if refs[0].rv == nil || refs[0].rv.Relname == nil {
+		t.Fatal("expected ref to carry range var")
+	}
+	if got := *refs[0].rv.Relname; got != tableName {
+		t.Fatalf("expected ref range var %q, got %q", tableName, got)
+	}
+}
diff --git a/internal/compiler/resolve.go b/internal/compiler/resolve.go
@@ -344,6 +344,58 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 		})
 	}
 
+	addColumnParam := func(ref paramRef, key string, location int) error {
+		var schema, rel string
+		// TODO: Deprecate defaultTable
+		if defaultTable != nil {
+			schema = defaultTable.Schema
+			rel = defaultTable.Name
+		}
+		if ref.rv != nil {
+			fqn, err := ParseTableName(ref.rv)
+			if err != nil {
+				return err
+			}
+			schema = fqn.Schema
+			rel = fqn.Name
+		}
+		if schema == "" {
+			schema = c.DefaultSchema
+		}
+
+		tableMap, ok := typeMap[schema][rel]
+		if !ok {
+			return sqlerr.RelationNotFound(rel)
+		}
+
+		if c, ok := tableMap[key]; ok {
+			defaultP := named.NewInferredParam(key, c.IsNotNull)
+			p, isNamed := params.FetchMerge(ref.ref.Number, defaultP)
+			return addParam(ref, Parameter{
+				Number: ref.ref.Number,
+				Column: &Column{
+					Name:         p.Name(),
+					OriginalName: c.Name,
+					DataType:     dataType(&c.Type),
+					NotNull:      p.NotNull(),
+					Unsigned:     c.IsUnsigned,
+					IsArray:      c.IsArray,
+					ArrayDims:    c.ArrayDims,
+					Table:        &ast.TableName{Schema: schema, Name: rel},
+					Length:       c.Length,
+					IsNamedParam: isNamed,
+					IsSqlcSlice:  p.IsSqlcSlice(),
+				},
+			})
+		}
+
+		return &sqlerr.Error{
+			Code:     "42703",
+			Message:  fmt.Sprintf("column %q does not exist", key),
+			Location: location,
+		}
+	}
+
 	for _, ref := range args {
 		switch n := ref.parent.(type) {
 
@@ -434,7 +486,13 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 				}
 
 				search := tables
-				if alias != "" {
+				if alias == "" && ref.rv != nil {
+					fqn, err := ParseTableName(ref.rv)
+					if err != nil {
+						return nil, err
+					}
+					search = []*ast.TableName{fqn}
+				} else if alias != "" {
 					if original, ok := aliasMap[alias]; ok {
 						search = []*ast.TableName{original}
 					} else {
@@ -704,58 +762,13 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 			if n.Name == nil {
 				return nil, fmt.Errorf("*ast.ResTarget has nil name")
 			}
-			key := *n.Name
-
-			var schema, rel string
-			// TODO: Deprecate defaultTable
-			if defaultTable != nil {
-				schema = defaultTable.Schema
-				rel = defaultTable.Name
-			}
-			if ref.rv != nil {
-				fqn, err := ParseTableName(ref.rv)
-				if err != nil {
-					return nil, err
-				}
-				schema = fqn.Schema
-				rel = fqn.Name
-			}
-			if schema == "" {
-				schema = c.DefaultSchema
-			}
-
-			tableMap, ok := typeMap[schema][rel]
-			if !ok {
-				return nil, sqlerr.RelationNotFound(rel)
+			if err := addColumnParam(ref, *n.Name, n.Location); err != nil {
+				return nil, err
 			}
 
-			if c, ok := tableMap[key]; ok {
-				defaultP := named.NewInferredParam(key, c.IsNotNull)
-				p, isNamed := params.FetchMerge(ref.ref.Number, defaultP)
-				if err := addParam(ref, Parameter{
-					Number: ref.ref.Number,
-					Column: &Column{
-						Name:         p.Name(),
-						OriginalName: c.Name,
-						DataType:     dataType(&c.Type),
-						NotNull:      p.NotNull(),
-						Unsigned:     c.IsUnsigned,
-						IsArray:      c.IsArray,
-						ArrayDims:    c.ArrayDims,
-						Table:        &ast.TableName{Schema: schema, Name: rel},
-						Length:       c.Length,
-						IsNamedParam: isNamed,
-						IsSqlcSlice:  p.IsSqlcSlice(),
-					},
-				}); err != nil {
-					return nil, err
-				}
-			} else {
-				return nil, &sqlerr.Error{
-					Code:     "42703",
-					Message:  fmt.Sprintf("column %q does not exist", key),
-					Location: n.Location,
-				}
+		case *ast.String:
+			if err := addColumnParam(ref, n.Str, n.Pos()); err != nil {
+				return nil, err
 			}
 
 		case *ast.TypeCast:
diff --git a/internal/compiler/resolve_test.go b/internal/compiler/resolve_test.go
@@ -7,6 +7,7 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/engine/sqlite"
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
 	"github.com/sqlc-dev/sqlc/internal/sql/catalog"
+	"github.com/sqlc-dev/sqlc/internal/sql/named"
 	"github.com/sqlc-dev/sqlc/internal/sql/sqlerr"
 )
 
@@ -102,3 +103,107 @@ func TestResolvedFuncCallArgType(t *testing.T) {
 		t.Fatalf("expected nil for out-of-range positional arg, got %#v", got)
 	}
 }
+
+func TestResolveCatalogRefsInsertTargetStringInfersColumnName(t *testing.T) {
+	t.Parallel()
+
+	comp := &Compiler{parser: postgresql.NewParser(), catalog: postgresql.NewCatalog()}
+
+	var schema *catalog.Schema
+	for _, s := range comp.catalog.Schemas {
+		if s.Name == comp.catalog.DefaultSchema {
+			schema = s
+			break
+		}
+	}
+	if schema == nil {
+		t.Fatal("default schema not found")
+	}
+
+	tableName := "solar_commcard_mapping"
+	schema.Tables = append(schema.Tables, &catalog.Table{
+		Rel: &ast.TableName{Schema: schema.Name, Name: tableName},
+		Columns: []*catalog.Column{&catalog.Column{
+			Name:      "deviceId",
+			Type:      ast.TypeName{Schema: "pg_catalog", Name: "int8"},
+			IsNotNull: true,
+		}},
+	})
+
+	rv := &ast.RangeVar{Relname: &tableName}
+	params, err := comp.resolveCatalogRefs(nil, []*ast.RangeVar{rv}, []paramRef{{
+		parent: &ast.String{Str: "deviceId"},
+		rv:     rv,
+		ref:    &ast.ParamRef{Number: 1},
+	}}, named.NewParamSet(nil, true), nil)
+	if err != nil {
+		t.Fatalf("resolveCatalogRefs returned error: %v", err)
+	}
+	if len(params) != 1 {
+		t.Fatalf("expected 1 param, got %d", len(params))
+	}
+	if params[0].Column == nil {
+		t.Fatal("expected resolved column metadata")
+	}
+	if params[0].Column.Name != "deviceId" {
+		t.Fatalf("expected inferred name deviceId, got %q", params[0].Column.Name)
+	}
+	if params[0].Column.OriginalName != "deviceId" {
+		t.Fatalf("expected original name deviceId, got %q", params[0].Column.OriginalName)
+	}
+	if params[0].Column.DataType != "pg_catalog.int8" {
+		t.Fatalf("expected data type pg_catalog.int8, got %q", params[0].Column.DataType)
+	}
+	if params[0].Column.Table == nil || params[0].Column.Table.Name != tableName {
+		t.Fatalf("expected table %q, got %#v", tableName, params[0].Column.Table)
+	}
+}
+
+func TestResolveCatalogRefsAExprUsesScopedRangeVar(t *testing.T) {
+	t.Parallel()
+
+	comp := &Compiler{parser: postgresql.NewParser(), catalog: postgresql.NewCatalog()}
+
+	var schema *catalog.Schema
+	for _, s := range comp.catalog.Schemas {
+		if s.Name == comp.catalog.DefaultSchema {
+			schema = s
+			break
+		}
+	}
+	if schema == nil {
+		t.Fatal("default schema not found")
+	}
+
+	tableName := "solar_commcard_mapping"
+	schema.Tables = append(schema.Tables, &catalog.Table{
+		Rel: &ast.TableName{Schema: schema.Name, Name: tableName},
+		Columns: []*catalog.Column{{
+			Name:      "deviceId",
+			Type:      ast.TypeName{Schema: "pg_catalog", Name: "int8"},
+			IsNotNull: true,
+		}},
+	})
+
+	rv := &ast.RangeVar{Relname: &tableName}
+	params, err := comp.resolveCatalogRefs(nil, []*ast.RangeVar{rv, rv}, []paramRef{{
+		parent: &ast.A_Expr{
+			Lexpr: &ast.ColumnRef{Fields: &ast.List{Items: []ast.Node{&ast.String{Str: "deviceId"}}}},
+			Rexpr: &ast.ParamRef{Number: 1},
+		},
+		rv:  rv,
+		ref: &ast.ParamRef{Number: 1},
+	}}, named.NewParamSet(nil, true), nil)
+	if err != nil {
+		t.Fatalf("resolveCatalogRefs returned error: %v", err)
+	}
+	if len(params) != 1 {
+		t.Fatalf("expected 1 param, got %d", len(params))
+	}
+	if params[0].Column == nil {
+		t.Fatal("expected resolved column metadata")
+	}
+	if params[0].Column.Name != "deviceId" {
+		t.Fatalf("expected inferred name deviceId, got %q", params[0].Column.Name)
+	}
+}
