fix: Myriad string formatting changes (#2558)

verygoodsoftwarenotvirus · web-flow · commit e91a9abcf179 · 2023-08-01T16:50:01.000-07:00
diff --git a/internal/codegen/golang/field.go b/internal/codegen/golang/field.go
@@ -34,7 +34,7 @@ func TagsToString(tags map[string]string) string {
 	}
 	tagParts := make([]string, 0, len(tags))
 	for key, val := range tags {
-		tagParts = append(tagParts, fmt.Sprintf("%s:\"%s\"", key, val))
+		tagParts = append(tagParts, fmt.Sprintf("%s:%q", key, val))
 	}
 	sort.Strings(tagParts)
 	return strings.Join(tagParts, " ")
diff --git a/internal/codegen/golang/imports.go b/internal/codegen/golang/imports.go
@@ -21,9 +21,9 @@ type ImportSpec struct {
 
 func (s ImportSpec) String() string {
 	if s.ID != "" {
-		return fmt.Sprintf("%s \"%s\"", s.ID, s.Path)
+		return fmt.Sprintf("%s %q", s.ID, s.Path)
 	} else {
-		return fmt.Sprintf("\"%s\"", s.Path)
+		return fmt.Sprintf("%q", s.Path)
 	}
 }
 
diff --git a/internal/compiler/output_columns.go b/internal/compiler/output_columns.go
@@ -639,14 +639,14 @@ func outputColumnRefs(res *ast.ResTarget, tables []*Table, node *ast.ColumnRef)
 	if found == 0 {
 		return nil, &sqlerr.Error{
 			Code:     "42703",
-			Message:  fmt.Sprintf("column \"%s\" does not exist", name),
+			Message:  fmt.Sprintf("column %q does not exist", name),
 			Location: res.Location,
 		}
 	}
 	if found > 1 {
 		return nil, &sqlerr.Error{
 			Code:     "42703",
-			Message:  fmt.Sprintf("column reference \"%s\" is ambiguous", name),
+			Message:  fmt.Sprintf("column reference %q is ambiguous", name),
 			Location: res.Location,
 		}
 	}
@@ -702,14 +702,14 @@ func findColumnForRef(ref *ast.ColumnRef, tables []*Table, targetList *ast.List)
 	if found == 0 {
 		return &sqlerr.Error{
 			Code:     "42703",
-			Message:  fmt.Sprintf("column reference \"%s\" not found", name),
+			Message:  fmt.Sprintf("column reference %q not found", name),
 			Location: ref.Location,
 		}
 	}
 	if found > 1 {
 		return &sqlerr.Error{
 			Code:     "42703",
-			Message:  fmt.Sprintf("column reference \"%s\" is ambiguous", name),
+			Message:  fmt.Sprintf("column reference %q is ambiguous", name),
 			Location: ref.Location,
 		}
 	}
diff --git a/internal/compiler/resolve.go b/internal/compiler/resolve.go
@@ -188,7 +188,7 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 						if !located {
 							return nil, &sqlerr.Error{
 								Code:     "42703",
-								Message:  fmt.Sprintf("table alias \"%s\" does not exist", alias),
+								Message:  fmt.Sprintf("table alias %q does not exist", alias),
 								Location: node.Location,
 							}
 						}
@@ -231,14 +231,14 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 				if found == 0 {
 					return nil, &sqlerr.Error{
 						Code:     "42703",
-						Message:  fmt.Sprintf("column \"%s\" does not exist", key),
+						Message:  fmt.Sprintf("column %q does not exist", key),
 						Location: node.Location,
 					}
 				}
 				if found > 1 {
 					return nil, &sqlerr.Error{
 						Code:     "42703",
-						Message:  fmt.Sprintf("column reference \"%s\" is ambiguous", key),
+						Message:  fmt.Sprintf("column reference %q is ambiguous", key),
 						Location: node.Location,
 					}
 				}
@@ -471,7 +471,7 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 			} else {
 				return nil, &sqlerr.Error{
 					Code:     "42703",
-					Message:  fmt.Sprintf("column \"%s\" does not exist", key),
+					Message:  fmt.Sprintf("column %q does not exist", key),
 					Location: n.Location,
 				}
 			}
@@ -587,20 +587,20 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 			if found == 0 {
 				return nil, &sqlerr.Error{
 					Code:     "42703",
-					Message:  fmt.Sprintf("396: column \"%s\" does not exist", key),
+					Message:  fmt.Sprintf("396: column %q does not exist", key),
 					Location: location,
 				}
 			}
 			if found > 1 {
 				return nil, &sqlerr.Error{
 					Code:     "42703",
-					Message:  fmt.Sprintf("in same name column reference \"%s\" is ambiguous", key),
+					Message:  fmt.Sprintf("in same name column reference %q is ambiguous", key),
 					Location: location,
 				}
 			}
 
 		default:
-			fmt.Printf("unsupported reference type: %T", n)
+			fmt.Printf("unsupported reference type: %T\n", n)
 		}
 	}
 	return a, nil
diff --git a/internal/sql/catalog/table.go b/internal/sql/catalog/table.go
@@ -267,7 +267,7 @@ func (c *Catalog) createTable(stmt *ast.CreateTableStmt) error {
 				seen[col.Name] = notNull || col.IsNotNull
 				if a, ok := coltype[col.Name]; ok {
 					if !sameType(&a, &col.Type) {
-						return fmt.Errorf("column \"%s\" has a type conflict", col.Name)
+						return fmt.Errorf("column %q has a type conflict", col.Name)
 					}
 				}
 				continue
@@ -298,7 +298,7 @@ func (c *Catalog) createTable(stmt *ast.CreateTableStmt) error {
 				seen[col.Colname] = notNull || col.IsNotNull
 				if a, ok := coltype[col.Colname]; ok {
 					if !sameType(&a, col.TypeName) {
-						return fmt.Errorf("column \"%s\" has a type conflict", col.Colname)
+						return fmt.Errorf("column %q has a type conflict", col.Colname)
 					}
 				}
 				continue
diff --git a/internal/sql/sqlerr/errors.go b/internal/sql/sqlerr/errors.go
@@ -35,77 +35,77 @@ func ColumnExists(rel, col string) *Error {
 	return &Error{
 		Err:     Exists,
 		Code:    "42701",
-		Message: fmt.Sprintf("column \"%s\" of relation \"%s\"", col, rel),
+		Message: fmt.Sprintf("column %q of relation %q", col, rel),
 	}
 }
 
 func ColumnNotFound(rel, col string) *Error {
 	return &Error{
 		Err:     NotFound,
 		Code:    "42703",
-		Message: fmt.Sprintf("column \"%s\" of relation \"%s\"", col, rel),
+		Message: fmt.Sprintf("column %q of relation %q", col, rel),
 	}
 }
 
 func RelationExists(rel string) *Error {
 	return &Error{
 		Err:     Exists,
 		Code:    "42P07",
-		Message: fmt.Sprintf("relation \"%s\"", rel),
+		Message: fmt.Sprintf("relation %q", rel),
 	}
 }
 
 func RelationNotFound(rel string) *Error {
 	return &Error{
 		Err:     NotFound,
 		Code:    "42P01",
-		Message: fmt.Sprintf("relation \"%s\"", rel),
+		Message: fmt.Sprintf("relation %q", rel),
 	}
 }
 
 func SchemaExists(name string) *Error {
 	return &Error{
 		Err:     Exists,
 		Code:    "42P06",
-		Message: fmt.Sprintf("schema \"%s\"", name),
+		Message: fmt.Sprintf("schema %q", name),
 	}
 }
 
 func SchemaNotFound(sch string) *Error {
 	return &Error{
 		Err:     NotFound,
 		Code:    "3F000",
-		Message: fmt.Sprintf("schema \"%s\"", sch),
+		Message: fmt.Sprintf("schema %q", sch),
 	}
 }
 
 func TypeExists(typ string) *Error {
 	return &Error{
 		Err:     Exists,
 		Code:    "42710",
-		Message: fmt.Sprintf("type \"%s\"", typ),
+		Message: fmt.Sprintf("type %q", typ),
 	}
 }
 
 func TypeNotFound(typ string) *Error {
 	return &Error{
 		Err:     NotFound,
 		Code:    "42704",
-		Message: fmt.Sprintf("type \"%s\"", typ),
+		Message: fmt.Sprintf("type %q", typ),
 	}
 }
 
 func FunctionNotFound(fun string) *Error {
 	return &Error{
 		Err:     NotFound,
 		Code:    "42704",
-		Message: fmt.Sprintf("function \"%s\"", fun),
+		Message: fmt.Sprintf("function %q", fun),
 	}
 }
 
 func FunctionNotUnique(fn string) *Error {
 	return &Error{
 		Err:     NotUnique,
-		Message: fmt.Sprintf("function name \"%s\"", fn),
+		Message: fmt.Sprintf("function name %q", fn),
 	}
 }
diff --git a/internal/tools/sqlc-pg-gen/main.go b/internal/tools/sqlc-pg-gen/main.go
@@ -13,7 +13,7 @@ import (
 	"strings"
 	"text/template"
 
-	pgx "github.com/jackc/pgx/v4"
+	"github.com/jackc/pgx/v4"
 )
 
 // https://dba.stackexchange.com/questions/255412/how-to-select-functions-that-belong-in-a-given-extension-in-postgresql
@@ -308,8 +308,7 @@ func run(ctx context.Context) error {
 			funcName += strings.Title(part)
 		}
 
-		_, err := conn.Exec(ctx, fmt.Sprintf("CREATE EXTENSION IF NOT EXISTS \"%s\"", extension))
-		if err != nil {
+		if _, err := conn.Exec(ctx, fmt.Sprintf("CREATE EXTENSION IF NOT EXISTS %q", extension)); err != nil {
 			return fmt.Errorf("error creating %s: %s", extension, err)
 		}
 

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ func TagsToString(tags map[string]string) string {`
`34`	`34`	`}`
`35`	`35`	`tagParts := make([]string, 0, len(tags))`
`36`	`36`	`for key, val := range tags {`
`37`		`- tagParts = append(tagParts, fmt.Sprintf("%s:\"%s\"", key, val))`
	`37`	`+ tagParts = append(tagParts, fmt.Sprintf("%s:%q", key, val))`
`38`	`38`	`}`
`39`	`39`	`sort.Strings(tagParts)`
`40`	`40`	`return strings.Join(tagParts, " ")`
Original file line number	Diff line number	Diff line change
`@@ -21,9 +21,9 @@ type ImportSpec struct {`
`21`	`21`
`22`	`22`	`func (s ImportSpec) String() string {`
`23`	`23`	`if s.ID != "" {`
`24`		`- return fmt.Sprintf("%s \"%s\"", s.ID, s.Path)`
	`24`	`+ return fmt.Sprintf("%s %q", s.ID, s.Path)`
`25`	`25`	`} else {`
`26`		`- return fmt.Sprintf("\"%s\"", s.Path)`
	`26`	`+ return fmt.Sprintf("%q", s.Path)`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
Original file line number	Diff line number	Diff line change
`@@ -639,14 +639,14 @@ func outputColumnRefs(res ast.ResTarget, tables []Table, node *ast.ColumnRef)`
`639`	`639`	`if found == 0 {`
`640`	`640`	`return nil, &sqlerr.Error{`
`641`	`641`	`Code: "42703",`
`642`		`- Message: fmt.Sprintf("column \"%s\" does not exist", name),`
	`642`	`+ Message: fmt.Sprintf("column %q does not exist", name),`
`643`	`643`	`Location: res.Location,`
`644`	`644`	`}`
`645`	`645`	`}`
`646`	`646`	`if found > 1 {`
`647`	`647`	`return nil, &sqlerr.Error{`
`648`	`648`	`Code: "42703",`
`649`		`- Message: fmt.Sprintf("column reference \"%s\" is ambiguous", name),`
	`649`	`+ Message: fmt.Sprintf("column reference %q is ambiguous", name),`
`650`	`650`	`Location: res.Location,`
`651`	`651`	`}`
`652`	`652`	`}`
`@@ -702,14 +702,14 @@ func findColumnForRef(ref ast.ColumnRef, tables []Table, targetList *ast.List)`
`702`	`702`	`if found == 0 {`
`703`	`703`	`return &sqlerr.Error{`
`704`	`704`	`Code: "42703",`
`705`		`- Message: fmt.Sprintf("column reference \"%s\" not found", name),`
	`705`	`+ Message: fmt.Sprintf("column reference %q not found", name),`
`706`	`706`	`Location: ref.Location,`
`707`	`707`	`}`
`708`	`708`	`}`
`709`	`709`	`if found > 1 {`
`710`	`710`	`return &sqlerr.Error{`
`711`	`711`	`Code: "42703",`
`712`		`- Message: fmt.Sprintf("column reference \"%s\" is ambiguous", name),`
	`712`	`+ Message: fmt.Sprintf("column reference %q is ambiguous", name),`
`713`	`713`	`Location: ref.Location,`
`714`	`714`	`}`
`715`	`715`	`}`
Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,7 @@ func (comp Compiler) resolveCatalogRefs(qc QueryCatalog, rvs []*ast.RangeVar,`
`188`	`188`	`if !located {`
`189`	`189`	`return nil, &sqlerr.Error{`
`190`	`190`	`Code: "42703",`
`191`		`- Message: fmt.Sprintf("table alias \"%s\" does not exist", alias),`
	`191`	`+ Message: fmt.Sprintf("table alias %q does not exist", alias),`
`192`	`192`	`Location: node.Location,`
`193`	`193`	`}`
`194`	`194`	`}`
`@@ -231,14 +231,14 @@ func (comp Compiler) resolveCatalogRefs(qc QueryCatalog, rvs []*ast.RangeVar,`
`231`	`231`	`if found == 0 {`
`232`	`232`	`return nil, &sqlerr.Error{`
`233`	`233`	`Code: "42703",`
`234`		`- Message: fmt.Sprintf("column \"%s\" does not exist", key),`
	`234`	`+ Message: fmt.Sprintf("column %q does not exist", key),`
`235`	`235`	`Location: node.Location,`
`236`	`236`	`}`
`237`	`237`	`}`
`238`	`238`	`if found > 1 {`
`239`	`239`	`return nil, &sqlerr.Error{`
`240`	`240`	`Code: "42703",`
`241`		`- Message: fmt.Sprintf("column reference \"%s\" is ambiguous", key),`
	`241`	`+ Message: fmt.Sprintf("column reference %q is ambiguous", key),`
`242`	`242`	`Location: node.Location,`
`243`	`243`	`}`
`244`	`244`	`}`
`@@ -471,7 +471,7 @@ func (comp Compiler) resolveCatalogRefs(qc QueryCatalog, rvs []*ast.RangeVar,`
`471`	`471`	`} else {`
`472`	`472`	`return nil, &sqlerr.Error{`
`473`	`473`	`Code: "42703",`
`474`		`- Message: fmt.Sprintf("column \"%s\" does not exist", key),`
	`474`	`+ Message: fmt.Sprintf("column %q does not exist", key),`
`475`	`475`	`Location: n.Location,`
`476`	`476`	`}`
`477`	`477`	`}`
`@@ -587,20 +587,20 @@ func (comp Compiler) resolveCatalogRefs(qc QueryCatalog, rvs []*ast.RangeVar,`
`587`	`587`	`if found == 0 {`
`588`	`588`	`return nil, &sqlerr.Error{`
`589`	`589`	`Code: "42703",`
`590`		`- Message: fmt.Sprintf("396: column \"%s\" does not exist", key),`
	`590`	`+ Message: fmt.Sprintf("396: column %q does not exist", key),`
`591`	`591`	`Location: location,`
`592`	`592`	`}`
`593`	`593`	`}`
`594`	`594`	`if found > 1 {`
`595`	`595`	`return nil, &sqlerr.Error{`
`596`	`596`	`Code: "42703",`
`597`		`- Message: fmt.Sprintf("in same name column reference \"%s\" is ambiguous", key),`
	`597`	`+ Message: fmt.Sprintf("in same name column reference %q is ambiguous", key),`
`598`	`598`	`Location: location,`
`599`	`599`	`}`
`600`	`600`	`}`
`601`	`601`
`602`	`602`	`default:`
`603`		`- fmt.Printf("unsupported reference type: %T", n)`
	`603`	`+ fmt.Printf("unsupported reference type: %T\n", n)`
`604`	`604`	`}`
`605`	`605`	`}`
`606`	`606`	`return a, nil`
Original file line number	Diff line number	Diff line change
`@@ -267,7 +267,7 @@ func (c Catalog) createTable(stmt ast.CreateTableStmt) error {`
`267`	`267`	`seen[col.Name] = notNull \|\| col.IsNotNull`
`268`	`268`	`if a, ok := coltype[col.Name]; ok {`
`269`	`269`	`if !sameType(&a, &col.Type) {`
`270`		`- return fmt.Errorf("column \"%s\" has a type conflict", col.Name)`
	`270`	`+ return fmt.Errorf("column %q has a type conflict", col.Name)`
`271`	`271`	`}`
`272`	`272`	`}`
`273`	`273`	`continue`
`@@ -298,7 +298,7 @@ func (c Catalog) createTable(stmt ast.CreateTableStmt) error {`
`298`	`298`	`seen[col.Colname] = notNull \|\| col.IsNotNull`
`299`	`299`	`if a, ok := coltype[col.Colname]; ok {`
`300`	`300`	`if !sameType(&a, col.TypeName) {`
`301`		`- return fmt.Errorf("column \"%s\" has a type conflict", col.Colname)`
	`301`	`+ return fmt.Errorf("column %q has a type conflict", col.Colname)`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`	`continue`
Original file line number	Diff line number	Diff line change
`@@ -35,77 +35,77 @@ func ColumnExists(rel, col string) *Error {`
`35`	`35`	`return &Error{`
`36`	`36`	`Err: Exists,`
`37`	`37`	`Code: "42701",`
`38`		`- Message: fmt.Sprintf("column \"%s\" of relation \"%s\"", col, rel),`
	`38`	`+ Message: fmt.Sprintf("column %q of relation %q", col, rel),`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`func ColumnNotFound(rel, col string) *Error {`
`43`	`43`	`return &Error{`
`44`	`44`	`Err: NotFound,`
`45`	`45`	`Code: "42703",`
`46`		`- Message: fmt.Sprintf("column \"%s\" of relation \"%s\"", col, rel),`
	`46`	`+ Message: fmt.Sprintf("column %q of relation %q", col, rel),`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`func RelationExists(rel string) *Error {`
`51`	`51`	`return &Error{`
`52`	`52`	`Err: Exists,`
`53`	`53`	`Code: "42P07",`
`54`		`- Message: fmt.Sprintf("relation \"%s\"", rel),`
	`54`	`+ Message: fmt.Sprintf("relation %q", rel),`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`func RelationNotFound(rel string) *Error {`
`59`	`59`	`return &Error{`
`60`	`60`	`Err: NotFound,`
`61`	`61`	`Code: "42P01",`
`62`		`- Message: fmt.Sprintf("relation \"%s\"", rel),`
	`62`	`+ Message: fmt.Sprintf("relation %q", rel),`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`func SchemaExists(name string) *Error {`
`67`	`67`	`return &Error{`
`68`	`68`	`Err: Exists,`
`69`	`69`	`Code: "42P06",`
`70`		`- Message: fmt.Sprintf("schema \"%s\"", name),`
	`70`	`+ Message: fmt.Sprintf("schema %q", name),`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`func SchemaNotFound(sch string) *Error {`
`75`	`75`	`return &Error{`
`76`	`76`	`Err: NotFound,`
`77`	`77`	`Code: "3F000",`
`78`		`- Message: fmt.Sprintf("schema \"%s\"", sch),`
	`78`	`+ Message: fmt.Sprintf("schema %q", sch),`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`func TypeExists(typ string) *Error {`
`83`	`83`	`return &Error{`
`84`	`84`	`Err: Exists,`
`85`	`85`	`Code: "42710",`
`86`		`- Message: fmt.Sprintf("type \"%s\"", typ),`
	`86`	`+ Message: fmt.Sprintf("type %q", typ),`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`func TypeNotFound(typ string) *Error {`
`91`	`91`	`return &Error{`
`92`	`92`	`Err: NotFound,`
`93`	`93`	`Code: "42704",`
`94`		`- Message: fmt.Sprintf("type \"%s\"", typ),`
	`94`	`+ Message: fmt.Sprintf("type %q", typ),`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`func FunctionNotFound(fun string) *Error {`
`99`	`99`	`return &Error{`
`100`	`100`	`Err: NotFound,`
`101`	`101`	`Code: "42704",`
`102`		`- Message: fmt.Sprintf("function \"%s\"", fun),`
	`102`	`+ Message: fmt.Sprintf("function %q", fun),`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`func FunctionNotUnique(fn string) *Error {`
`107`	`107`	`return &Error{`
`108`	`108`	`Err: NotUnique,`
`109`		`- Message: fmt.Sprintf("function name \"%s\"", fn),`
	`109`	`+ Message: fmt.Sprintf("function name %q", fn),`
`110`	`110`	`}`
`111`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ import (`
`13`	`13`	`"strings"`
`14`	`14`	`"text/template"`
`15`	`15`
`16`		`- pgx "github.com/jackc/pgx/v4"`
	`16`	`+ "github.com/jackc/pgx/v4"`
`17`	`17`	`)`
`18`	`18`
`19`	`19`	`// https://dba.stackexchange.com/questions/255412/how-to-select-functions-that-belong-in-a-given-extension-in-postgresql`
`@@ -308,8 +308,7 @@ func run(ctx context.Context) error {`
`308`	`308`	`funcName += strings.Title(part)`
`309`	`309`	`}`
`310`	`310`
`311`		`- _, err := conn.Exec(ctx, fmt.Sprintf("CREATE EXTENSION IF NOT EXISTS \"%s\"", extension))`
`312`		`- if err != nil {`
	`311`	`+ if _, err := conn.Exec(ctx, fmt.Sprintf("CREATE EXTENSION IF NOT EXISTS %q", extension)); err != nil {`
`313`	`312`	`return fmt.Errorf("error creating %s: %s", extension, err)`
`314`	`313`	`}`
`315`	`314`