| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,68 @@ |
| +# `fmt` - Formatting queries |
| + |
| +`sqlc fmt` rewrites the query files referenced by your configuration file in a |
| +canonical format. Each query is parsed with the engine's parser and printed |
| +back from the syntax tree, so formatting never depends on how the query was |
| +written — only on what it means. |
| + |
| +Like `gofmt`, the formatter does not impose a maximum line width. A statement |
| +written on a single line stays on a single line, and a statement the author |
| +broke across lines keeps its breaks: the printer notices which clause |
| +boundaries (`FROM`, `WHERE`, `ORDER BY`, ...) and list boundaries the author |
| +broke at and preserves them, normalizing indentation and spacing around them. |
| + |
| +Comments inside a statement are formatted along with it: each comment is |
| +anchored to the code around it by source position and printed back there — |
| +a comment trailing a select-list item stays with that item, a comment above |
| +a clause stays above its keyword — and a comment that runs to the end of its |
| +line breaks the statement open around it. Any statement that cannot be |
| +proven to survive formatting unchanged is left exactly as written. |
| + |
| +## Usage |
| + |
| +```sh |
| +sqlc fmt [--diff] |
| +``` |
| + |
| +Without flags, the query files are rewritten in place. With `--diff`, the |
| +changes are printed to standard output instead and no files are modified. |
| + |
| +## Examples |
| + |
| +Given this query file: |
| + |
| +```sql |
| +-- name: GetAuthor :one |
| +select id,name , bio |
| +from authors |
| +where id = ? limit 1; |
| + |
| +-- name: SearchAuthors :many |
| +SELECT id, -- the primary key |
| + name, bio, created_at FROM authors WHERE name LIKE ? AND bio IS NOT NULL AND id > ? AND created_at > ? AND name <> ? ORDER BY name; |
| +``` |
| + |
| +running `sqlc fmt` rewrites it to: |
| + |
| +```sql |
| +-- name: GetAuthor :one |
| +SELECT id, name, bio |
| +FROM authors |
| +WHERE id = ? |
| +LIMIT 1; |
| + |
| +-- name: SearchAuthors :many |
| +SELECT |
| + id, -- the primary key |
| + name, |
| + bio, |
| + created_at |
| +FROM authors |
| +WHERE name LIKE ? AND bio IS NOT NULL AND id > ? AND created_at > ? AND name <> ? |
| +ORDER BY name; |
| +``` |
| + |
| +`GetAuthor` keeps the line breaks its author wrote; had it been written on |
| +one line, it would stay on one line. In `SearchAuthors`, the line comment |
| +cannot share a line with the code after it, so the statement breaks open |
| +around it, while the `WHERE` chain — written on one line — stays on one. |
| |
| |
| |
| |
| @@ -10,6 +10,7 @@ Available Commands: |
| completion Generate the autocompletion script for the specified shell |
| createdb Create an ephemeral database |
| diff Compare the generated files to the existing files |
| + fmt Format SQL queries |
| generate Generate source code from SQL |
| help Help about any command |
| init Create an empty sqlc.yaml settings file |
| |
| |
| |
| |
| @@ -20,6 +20,7 @@ sections: |
| - title: Commands |
| pages: |
| - howto/analyze.md |
| + - howto/fmt.md |
| - howto/generate.md |
| - howto/parse.md |
| - howto/push.md |
| |
| |
| |
| |
| @@ -20,7 +20,7 @@ require ( |
| github.com/spf13/pflag v1.0.10 |
| github.com/sqlc-dev/doubleclick v1.0.0 |
| github.com/sqlc-dev/marino v0.3.0 |
| - github.com/sqlc-dev/meyer v0.1.1 |
| + github.com/sqlc-dev/meyer v0.1.2 |
| github.com/sqlc-dev/oliphant v0.1.0 |
| github.com/sqlc-dev/teesql v1.1.0 |
| github.com/sqlc-dev/zetajones v0.1.0 |
| |
| |
| |
| |
| @@ -69,8 +69,8 @@ github.com/sqlc-dev/doubleclick v1.0.0 h1:2/OApfQ2eLgcfa/Fqs8WSMA6atH0G8j9hHbQIg |
| github.com/sqlc-dev/doubleclick v1.0.0/go.mod h1:ODHRroSrk/rr5neRHlWMSRijqOak8YmNaO3VAZCNl5Y= |
| github.com/sqlc-dev/marino v0.3.0 h1:e9cinBXJFFa3yRpokYNNinWvkewgd6XVDgnlG0bOmTw= |
| github.com/sqlc-dev/marino v0.3.0/go.mod h1:mQxC2dgDE0DWHMb2B5jZNk7KToJuS6wnxnffBfYnq08= |
| -github.com/sqlc-dev/meyer v0.1.1 h1:BAeZcfgLyTnk9f90DyGEKXPrHxtgvVD/DTM6awq2kUY= |
| -github.com/sqlc-dev/meyer v0.1.1/go.mod h1:pS4USCRf/SLjWtaMcnTo4YrEEFKBj8CyyqlxcVUJQH8= |
| +github.com/sqlc-dev/meyer v0.1.2 h1:40Ng9Glnx7CTf3yOYV7jfvDIN7voIFjrStkIULS+uws= |
| +github.com/sqlc-dev/meyer v0.1.2/go.mod h1:pS4USCRf/SLjWtaMcnTo4YrEEFKBj8CyyqlxcVUJQH8= |
| github.com/sqlc-dev/oliphant v0.1.0 h1:RAsO6BMitIzB2+swx/qzUR5nf6w4cQ1abgHIu+Fgppo= |
| github.com/sqlc-dev/oliphant v0.1.0/go.mod h1:fRM/t4FutRddTIq2YCuS4O9o+2rRwSwELRvLMqtPloo= |
| github.com/sqlc-dev/teesql v1.1.0 h1:3sVYQ9FGxQVcqrqQOQ27bk0aF4c4yN1H1zLL79uaSxQ= |
| |
| |
| |
| |
| @@ -43,6 +43,7 @@ func Do(args []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) int |
| rootCmd.AddCommand(createDBCmd) |
| rootCmd.AddCommand(diffCmd) |
| rootCmd.AddCommand(genCmd) |
| + rootCmd.AddCommand(newFmtCmd()) |
| rootCmd.AddCommand(initCmd) |
| rootCmd.AddCommand(newParseCmd()) |
| rootCmd.AddCommand(newAnalyzeCmd()) |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,446 @@ |
| +package cmd |
| + |
| +import ( |
| + "context" |
| + "fmt" |
| + "io" |
| + "os" |
| + "path/filepath" |
| + "runtime/trace" |
| + "sort" |
| + "strings" |
| + |
| + "github.com/cubicdaiya/gonp" |
| + "github.com/spf13/cobra" |
| + |
| + "github.com/sqlc-dev/sqlc/internal/config" |
| + "github.com/sqlc-dev/sqlc/internal/engine/sqlite" |
| + "github.com/sqlc-dev/sqlc/internal/sql/ast" |
| + "github.com/sqlc-dev/sqlc/internal/sql/format" |
| + "github.com/sqlc-dev/sqlc/internal/sql/sqlpath" |
| +) |
| + |
| +// noLineLimit renders without a maximum line width: like gofmt, fmt never |
| +// rewraps a line on its own. Breaks come from the author's own line breaks |
| +// at the boundaries the printer models, and from comments, which cannot |
| +// share a line with the code after them. |
| +const noLineLimit = 1 << 30 |
| + |
| +// queryFormatter is what the fmt command needs from an engine: a parser |
| +// that surfaces the comments its lexer already scans (so statements and |
| +// comments come from one pass, and interior comments format along with |
| +// their statements) plus dialect-aware formatting. Comments cannot be |
| +// reprinted without parser support, so ParseFile is the price of admission. |
| +type queryFormatter interface { |
| + ParseFile(io.Reader) (*ast.File, error) |
| + format.Dialect |
| +} |
| + |
| +// newQueryFormatter returns the formatter for engines fmt supports — |
| +// SQLite today. An engine joins by teaching its parser to surface comments |
| +// (meyer's ParseFile is the template) and adding its case here. |
| +func newQueryFormatter(engine config.Engine) queryFormatter { |
| + switch engine { |
| + case config.EngineSQLite: |
| + return sqlite.NewParser() |
| + default: |
| + return nil |
| + } |
| +} |
| + |
| +func newFmtCmd() *cobra.Command { |
| + cmd := &cobra.Command{ |
| + Use: "fmt", |
| + Short: "Format SQL queries", |
| + Long: `Format the SQL query files referenced by the configuration file. |
| + |
| +Each query is parsed with the engine's parser and printed back in a canonical |
| +form, with its comments kept where they were written. A statement that cannot |
| +be proven to survive formatting unchanged is left exactly as written. Files |
| +are rewritten in place; pass --diff to print the changes to stdout instead.`, |
| + RunE: func(cmd *cobra.Command, args []string) error { |
| + defer trace.StartRegion(cmd.Context(), "fmt").End() |
| + stderr := cmd.ErrOrStderr() |
| + stdout := cmd.OutOrStdout() |
| + showDiff, err := cmd.Flags().GetBool("diff") |
| + if err != nil { |
| + return err |
| + } |
| + dir, name := getConfigPath(stderr, cmd.Flag("file")) |
| + output, err := Format(cmd.Context(), dir, name, &Options{ |
| + Env: ParseEnv(cmd), |
| + Stderr: stderr, |
| + }) |
| + if err != nil { |
| + os.Exit(1) |
| + } |
| + |
| + filenames := make([]string, 0, len(output)) |
| + for filename := range output { |
| + filenames = append(filenames, filename) |
| + } |
| + sort.Strings(filenames) |
| + |
| + for _, filename := range filenames { |
| + existing, err := os.ReadFile(filename) |
| + if err != nil { |
| + fmt.Fprintf(stderr, "%s: %s\n", filename, err) |
| + return err |
| + } |
| + source := output[filename] |
| + if string(existing) == source { |
| + continue |
| + } |
| + if showDiff { |
| + diff := gonp.New(getLines(existing), getLines([]byte(source))) |
| + diff.Compose() |
| + uniHunks := filterHunks(diff.UnifiedHunks()) |
| + if len(uniHunks) == 0 { |
| + continue |
| + } |
| + rel := filepath.ToSlash(strings.TrimPrefix(filename, dir)) |
| + fmt.Fprintf(stdout, "--- a%s\n", rel) |
| + fmt.Fprintf(stdout, "+++ b%s\n", rel) |
| + diff.FprintUniHunks(stdout, uniHunks) |
| + continue |
| + } |
| + if err := os.WriteFile(filename, []byte(source), 0644); err != nil { |
| + fmt.Fprintf(stderr, "%s: %s\n", filename, err) |
| + return err |
| + } |
| + } |
| + return nil |
| + }, |
| + } |
| + cmd.Flags().Bool("diff", false, "display diffs instead of rewriting files") |
| + return cmd |
| +} |
| + |
| +// Format formats every query file referenced by the configuration with its |
| +// engine's SQL formatter. It returns the formatted contents of each file, |
| +// keyed by absolute path. Query files for engines without a formatter are |
| +// skipped. |
| +func Format(ctx context.Context, dir, filename string, o *Options) (map[string]string, error) { |
| + defer trace.StartRegion(ctx, "format").End() |
| + stderr := o.Stderr |
| + |
| + configPath, conf, err := o.ReadConfig(dir, filename) |
| + if err != nil { |
| + return nil, err |
| + } |
| + base := filepath.Base(configPath) |
| + if err := config.Validate(conf); err != nil { |
| + fmt.Fprintf(stderr, "error validating %s: %s\n", base, err) |
| + return nil, err |
| + } |
| + |
| + engines := map[string]config.Engine{} |
| + var files []string |
| + for _, sql := range conf.SQL { |
| + joined := make([]string, 0, len(sql.Queries)) |
| + for _, q := range sql.Queries { |
| + joined = append(joined, filepath.Join(dir, q)) |
| + } |
| + list, err := sqlpath.Glob(joined) |
| + if err != nil { |
| + fmt.Fprintf(stderr, "error listing queries: %s\n", err) |
| + return nil, err |
| + } |
| + for _, file := range list { |
| + if _, ok := engines[file]; ok { |
| + continue |
| + } |
| + engines[file] = sql.Engine |
| + files = append(files, file) |
| + } |
| + } |
| + |
| + output := map[string]string{} |
| + unsupported := map[config.Engine]bool{} |
| + for _, file := range files { |
| + f := newQueryFormatter(engines[file]) |
| + if f == nil { |
| + if !unsupported[engines[file]] { |
| + unsupported[engines[file]] = true |
| + fmt.Fprintf(stderr, "sqlc fmt does not yet support the %s engine; query files left unchanged\n", engines[file]) |
| + } |
| + continue |
| + } |
| + rel, err := filepath.Rel(dir, file) |
| + if err != nil { |
| + rel = file |
| + } |
| + contents, err := os.ReadFile(file) |
| + if err != nil { |
| + fmt.Fprintf(stderr, "%s: skipped: %s\n", rel, err) |
| + continue |
| + } |
| + formatted, err := formatQueries(f, string(contents)) |
| + if err != nil { |
| + // Not every query file parses without the compiler's help — for |
| + // example, some engines only accept sqlc.slice() after |
| + // preprocessing. Leave those files as they are. |
| + fmt.Fprintf(stderr, "%s: skipped: %s\n", rel, err) |
| + continue |
| + } |
| + // File-level belt for the reprinter path: no formatting result may |
| + // change the file's comments. A violation is a formatter bug; keep |
| + // the file as written and say so. |
| + before, err1 := f.ParseFile(strings.NewReader(string(contents))) |
| + after, err2 := f.ParseFile(strings.NewReader(formatted)) |
| + if err1 == nil && (err2 != nil || !sameComments(before.Comments, after.Comments)) { |
| + fmt.Fprintf(stderr, "%s: skipped: formatting would alter comments (this is a bug in sqlc fmt)\n", rel) |
| + continue |
| + } |
| + output[file] = formatted |
| + } |
| + return output, nil |
| +} |
| + |
| +// formatQueries formats each statement in a query file. The comments above |
| +// every statement (that's where the "-- name:" annotation lives) are kept |
| +// as written; comments inside a statement are threaded through the printer |
| +// by position. |
| +func formatQueries(f queryFormatter, src string) (string, error) { |
| + // The parser hands over statements and comments from one lexer pass; |
| + // statement bodies slice the comment list by span. |
| + file, err := f.ParseFile(strings.NewReader(src)) |
| + if err != nil { |
| + return "", err |
| + } |
| + stmts, fileComments := file.Stmts, file.Comments |
| + var blocks []string |
| + prevEnd := 0 |
| + for _, stmt := range stmts { |
| + if stmt.Raw == nil { |
| + continue |
| + } |
| + start := stmt.Raw.StmtLocation |
| + length := stmt.Raw.StmtLen |
| + if length == 0 { |
| + // An unterminated final statement is reported with a zero length. |
| + length = len(src) - start |
| + } |
| + if start < 0 || start+length > len(src) { |
| + return "", fmt.Errorf("statement location out of bounds") |
| + } |
| + // Engines differ on whether a statement's span covers the comments |
| + // above it, so start each segment where the previous one ended: the |
| + // gap holds nothing but the previous terminator, whitespace and |
| + // comments. |
| + segStart := prevEnd |
| + if start < segStart { |
| + segStart = start |
| + } |
| + if start+length <= prevEnd { |
| + continue |
| + } |
| + prevEnd = start + length |
| + seg := src[segStart : start+length] |
| + segOff := segStart |
| + // A comment on the same line as the previous statement's terminator |
| + // belongs to that statement, not to this one's header. |
| + if len(blocks) > 0 { |
| + if trailing, remainder := splitTrailingComment(seg); trailing != "" { |
| + blocks[len(blocks)-1] += " " + trailing |
| + segOff += len(seg) - len(remainder) |
| + seg = remainder |
| + } |
| + } |
| + orig := strings.TrimSpace(strings.TrimLeft(seg, "; \t\r\n")) |
| + if orig == "" { |
| + continue |
| + } |
| + header, rest := splitLeadingComments(orig) |
| + // The statement body's own file offset, so its interior comments |
| + // can be sliced out of the file's comment list in the same |
| + // coordinates the parser stamped on the nodes. |
| + restOff := segOff + strings.Index(seg, orig) + len(orig) - len(rest) |
| + var interior []ast.Comment |
| + for _, c := range fileComments { |
| + if c.Start >= restOff && c.End <= start+length { |
| + interior = append(interior, c) |
| + } |
| + } |
| + block := append([]string{}, header...) |
| + block = append(block, formatStmt(f, stmt.Raw, rest, interior, src)) |
| + blocks = append(blocks, strings.Join(block, "\n")) |
| + } |
| + // Everything after the last statement is its terminator, whitespace and |
| + // trailing comments; keep the comments. |
| + tailSeg := src[prevEnd:] |
| + if len(blocks) > 0 { |
| + if trailing, remainder := splitTrailingComment(tailSeg); trailing != "" { |
| + blocks[len(blocks)-1] += " " + trailing |
| + tailSeg = remainder |
| + } |
| + } |
| + if tail := strings.TrimSpace(strings.TrimLeft(tailSeg, "; \t\r\n")); tail != "" { |
| + blocks = append(blocks, tail) |
| + } |
| + if len(blocks) == 0 { |
| + return src, nil |
| + } |
| + return strings.Join(blocks, "\n\n") + "\n", nil |
| +} |
| + |
| +// splitTrailingComment splits a comment sitting on the same line as the |
| +// previous statement's terminator off the front of the text between two |
| +// statements, returning the comment (or "") and the remaining text. |
| +func splitTrailingComment(seg string) (string, string) { |
| + k := 0 |
| + for k < len(seg) && (seg[k] == ';' || seg[k] == ' ' || seg[k] == '\t' || seg[k] == '\r') { |
| + k++ |
| + } |
| + rest := seg[k:] |
| + line, _, _ := strings.Cut(rest, "\n") |
| + trimmed := strings.TrimSpace(line) |
| + switch { |
| + case strings.HasPrefix(trimmed, "--"): |
| + return trimmed, seg[k+len(line):] |
| + case strings.HasPrefix(trimmed, "/*") && |
| + strings.HasSuffix(trimmed, "*/") && strings.Count(trimmed, "*/") == 1: |
| + // A block comment contained on the terminator's line. |
| + return trimmed, seg[k+len(line):] |
| + } |
| + return "", seg |
| +} |
| + |
| +// splitLeadingComments splits a statement's text into the comment lines above |
| +// it and the statement itself. Comment lines are returned with surrounding |
| +// whitespace trimmed (block comment continuation lines keep their leading |
| +// whitespace); blank lines between comments are kept. |
| +func splitLeadingComments(text string) ([]string, string) { |
| + var header []string |
| + rest := text |
| + for rest != "" { |
| + line, remainder, found := strings.Cut(rest, "\n") |
| + trimmed := strings.TrimSpace(line) |
| + if strings.HasPrefix(trimmed, "/*") && !strings.Contains(trimmed, "*/") { |
| + // A block comment spanning several lines: commit it to the |
| + // header only when its closing line arrives with nothing after |
| + // it. Otherwise leave the whole block with the statement. |
| + block := []string{trimmed} |
| + blockRest := remainder |
| + for closed := false; !closed; { |
| + if !found || blockRest == "" { |
| + return header, rest |
| + } |
| + var blockLine string |
| + blockLine, blockRest, found = strings.Cut(blockRest, "\n") |
| + if end := strings.TrimSpace(blockLine); strings.Contains(end, "*/") { |
| + if !strings.HasSuffix(end, "*/") || strings.Count(end, "*/") != 1 { |
| + return header, rest |
| + } |
| + closed = true |
| + } |
| + block = append(block, strings.TrimRight(blockLine, " \t\r")) |
| + } |
| + header = append(header, block...) |
| + rest = blockRest |
| + continue |
| + } |
| + if !isCommentLine(trimmed) { |
| + break |
| + } |
| + header = append(header, trimmed) |
| + if !found { |
| + rest = "" |
| + break |
| + } |
| + rest = remainder |
| + } |
| + // A statement never ends with a comment-only line here (the parser found a |
| + // statement in this segment), but drop any blank lines left at the end of |
| + // the header so comments sit directly above their query. |
| + for len(header) > 0 && header[len(header)-1] == "" { |
| + header = header[:len(header)-1] |
| + } |
| + return header, rest |
| +} |
| + |
| +func isCommentLine(line string) bool { |
| + switch { |
| + case line == "": |
| + // A blank line between comments. |
| + return true |
| + case strings.HasPrefix(line, "--"): |
| + return true |
| + case strings.HasPrefix(line, "/*") && strings.HasSuffix(line, "*/") && strings.Count(line, "*/") == 1: |
| + // A block comment contained on a single line. |
| + return true |
| + default: |
| + return false |
| + } |
| +} |
| + |
| +// formatStmt returns the canonical form of a single statement, or the |
| +// original text when formatting cannot be proven to preserve the query. |
| +func formatStmt(f queryFormatter, raw *ast.RawStmt, orig string, interior []ast.Comment, src string) string { |
| + fallback := strings.TrimSuffix(strings.TrimSpace(orig), ";") + ";" |
| + if out, ok := formatWithComments(f, raw, interior, src); ok { |
| + return out |
| + } |
| + return fallback |
| +} |
| + |
| +// formatWithComments pretty-prints a statement with its interior comments |
| +// and proves the result faithful three ways before accepting it: every |
| +// comment survives (multiset equality after reparsing the output), the SQL |
| +// still parses as one statement, and the output is a fixed point (printing |
| +// the reparsed statement with its reparsed comments reproduces it). |
| +func formatWithComments(f queryFormatter, raw *ast.RawStmt, interior []ast.Comment, src string) (string, bool) { |
| + out := prettyCommented(raw, f, interior, src) |
| + if strings.TrimSpace(strings.TrimSuffix(out, ";")) == "" { |
| + return "", false |
| + } |
| + file, err := f.ParseFile(strings.NewReader(out)) |
| + if err != nil || len(file.Stmts) != 1 || file.Stmts[0].Raw == nil { |
| + return "", false |
| + } |
| + if !sameComments(interior, file.Comments) { |
| + return "", false |
| + } |
| + again := prettyCommented(file.Stmts[0].Raw, f, file.Comments, out) |
| + if !strings.EqualFold(again, out) { |
| + return "", false |
| + } |
| + return out, true |
| +} |
| + |
| +// prettyCommented attaches a statement's comments to its nodes and renders |
| +// it, returning "" when the printer panics or fails to place every comment. |
| +func prettyCommented(raw *ast.RawStmt, f queryFormatter, comments []ast.Comment, src string) (out string) { |
| + defer func() { |
| + if r := recover(); r != nil { |
| + out = "" |
| + } |
| + }() |
| + ct := ast.AttachComments(raw, f, comments, src) |
| + out = ast.PrettyWithComments(raw, f, noLineLimit, ct) |
| + if !ct.Exhausted() { |
| + return "" |
| + } |
| + return out |
| +} |
| + |
| +// sameComments reports whether two comment lists carry the same comment |
| +// texts, as multisets, ignoring surrounding whitespace. |
| +func sameComments(a, b []ast.Comment) bool { |
| + if len(a) != len(b) { |
| + return false |
| + } |
| + counts := make(map[string]int, len(a)) |
| + for _, c := range a { |
| + counts[strings.TrimSpace(c.Text)]++ |
| + } |
| + for _, c := range b { |
| + counts[strings.TrimSpace(c.Text)]-- |
| + } |
| + for _, n := range counts { |
| + if n != 0 { |
| + return false |
| + } |
| + } |
| + return true |
| +} |
| |
| |
| |
| |
| @@ -316,11 +316,12 @@ func TestReplay(t *testing.T) { |
| } |
| case "vet": |
| err = cmd.Vet(ctx, path, "", &opts) |
| - case "parse", "analyze": |
| - // These commands are config-less and flag-driven. Run them |
| - // through the real CLI entry point from inside the test |
| - // directory so file arguments resolve and the output stays |
| - // independent of the absolute path. |
| + case "parse", "analyze", "fmt": |
| + // These commands are flag-driven (fmt cases pass --diff so |
| + // nothing is rewritten). Run them through the real CLI |
| + // entry point from inside the test directory so file |
| + // arguments resolve and the output stays independent of |
| + // the absolute path. |
| var stdout bytes.Buffer |
| wd, werr := os.Getwd() |
| if werr != nil { |
| |
| |
| |
| |
| @@ -169,6 +169,12 @@ func TestFormat(t *testing.T) { |
| } |
| |
| out := ast.Format(stmt.Raw, formatter) |
| + // An empty rendering is the formatter's signal that |
| + // the statement carries syntax the AST does not |
| + // model; sqlc fmt keeps such statements as written. |
| + if strings.TrimSpace(strings.TrimSuffix(strings.TrimSpace(out), ";")) == "" { |
| + t.Skip("statement has no faithful rendering") |
| + } |
| actual, err := fingerprint(out) |
| if err != nil { |
| t.Error(err) |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,5 @@ |
| +{ |
| + "command": "fmt", |
| + "args": ["--diff"], |
| + "contexts": ["base"] |
| +} |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,15 @@ |
| +-- name: GetAuthor :one |
| +select id,name , bio from authors |
| +where id = ? limit 1; |
| + |
| +# hash comment |
| +-- name: ListAuthors :many |
| +SELECT id, name, bio FROM authors |
| +ORDER BY name DESC; |
| + |
| +-- name: CreateAuthor :execresult |
| +insert into authors ( |
| + name, bio |
| +) values ( |
| + ?, ? |
| +); |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,5 @@ |
| +CREATE TABLE authors ( |
| + id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY, |
| + name varchar(255) NOT NULL, |
| + bio text |
| +); |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,9 @@ |
| +version: "2" |
| +sql: |
| + - engine: "mysql" |
| + schema: "schema.sql" |
| + queries: "query.sql" |
| + gen: |
| + go: |
| + package: "querytest" |
| + out: "go" |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1 @@ |
| +sqlc fmt does not yet support the mysql engine; query files left unchanged |
| |
| new file mode 100644 |
| |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,5 @@ |
| +{ |
| + "command": "fmt", |
| + "args": ["--diff"], |
| + "contexts": ["base"] |
| +} |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,30 @@ |
| +-- name: GetAuthor :one |
| +select id,name , bio |
| +from authors |
| +where id = $1 limit 1; -- the primary lookup |
| + |
| +/* This listing powers the admin page. |
| + Keep it ordered by name so the UI stays stable. */ |
| +-- name: ListAuthors :many |
| +SELECT id, name, bio FROM authors |
| +ORDER BY name; |
| + |
| +-- name: CreateAuthor :one |
| +INSERT INTO authors ( |
| + name, bio |
| +) VALUES ( |
| + $1, $2 |
| +) |
| +RETURNING *; |
| + |
| +-- name: PickyQuery :many |
| +SELECT id, -- the primary key |
| + name |
| +FROM authors |
| +WHERE id > $1; |
| + |
| +-- name: SearchAuthors :many |
| +SELECT id, name, bio, created_at FROM authors WHERE name LIKE $1 AND bio IS NOT NULL AND id > $2 AND name <> $3 ORDER BY name, id LIMIT $4; |
| + |
| +-- name: DeleteAuthor :exec |
| +DELETE FROM authors WHERE id = @id |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,6 @@ |
| +CREATE TABLE authors ( |
| + id BIGSERIAL PRIMARY KEY, |
| + name text NOT NULL, |
| + bio text, |
| + created_at timestamptz NOT NULL DEFAULT now() |
| +); |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,9 @@ |
| +version: "2" |
| +sql: |
| + - engine: "postgresql" |
| + schema: "schema.sql" |
| + queries: "query.sql" |
| + gen: |
| + go: |
| + package: "querytest" |
| + out: "go" |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1 @@ |
| +sqlc fmt does not yet support the postgresql engine; query files left unchanged |
| |
| new file mode 100644 |
| |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,5 @@ |
| +{ |
| + "command": "fmt", |
| + "args": ["--diff"], |
| + "contexts": ["base"] |
| +} |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,67 @@ |
| +-- name: GetAuthor :one |
| +select id,name , bio from authors |
| +where id = ? limit 1; |
| + |
| +-- name: PickyQuery :many |
| +SELECT id, -- the primary key |
| + name, |
| + -- computed downstream |
| + bio |
| +FROM authors |
| +-- soft-deleted rows are filtered |
| +WHERE bio IS NOT NULL |
| + AND id > ?; |
| + |
| +-- name: InlineBlock :many |
| +SELECT /* inline note */ id, name FROM authors ORDER BY name; |
| + |
| +-- name: ListAuthors :many |
| +SELECT id, name, bio FROM authors |
| +ORDER BY name; |
| + |
| +-- name: GetEvent :one |
| +SELECT "EventName", "order" |
| +FROM "Events" WHERE id = ? LIMIT 1; |
| + |
| +-- name: CountSigils :one |
| +SELECT count(*) FROM authors |
| +WHERE id <> @at_param AND id <> :colon_param AND id <> $dollar_param; |
| + |
| +-- name: TopAuthors :many |
| +WITH ranked AS ( |
| + SELECT id, name FROM authors |
| +) |
| +SELECT * FROM ranked; |
| + |
| +-- name: AddAuthor :exec |
| +INSERT INTO authors (name, bio) |
| +VALUES (?, ?); |
| + |
| +-- name: MakeScratch :exec |
| +CREATE TABLE scratch ( |
| + id INTEGER NOT NULL, |
| + label TEXT |
| +); |
| + |
| +-- name: MakeMeasurements :exec |
| +CREATE TABLE IF NOT EXISTS measurements ( |
| + id INTEGER PRIMARY KEY, |
| + label VARYING CHARACTER(120), |
| + ratio DECIMAL(10,5), |
| + note |
| +); |
| + |
| +-- name: KeepAutoinc :exec |
| +CREATE TABLE counters (id INTEGER PRIMARY KEY AUTOINCREMENT, hits INTEGER DEFAULT 0); |
| + |
| +-- name: CastLabel :one |
| +SELECT CAST(bio AS VARYING CHARACTER(120)) FROM authors LIMIT 1; |
| + |
| +-- name: MakeSearchIndex :exec |
| +CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(body, tag UNINDEXED, tokenize = 'porter'); |
| + |
| +-- name: MakeRecipeIndex :exec |
| +CREATE VIRTUAL TABLE recipes_fts USING fts5( |
| + name, |
| + ingredients |
| +); |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,11 @@ |
| +CREATE TABLE authors ( |
| + id integer PRIMARY KEY, |
| + name text NOT NULL, |
| + bio text |
| +); |
| + |
| +CREATE TABLE "Events" ( |
| + id integer PRIMARY KEY, |
| + "EventName" text NOT NULL, |
| + "order" integer NOT NULL |
| +); |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,9 @@ |
| +version: "2" |
| +sql: |
| + - engine: "sqlite" |
| + schema: "schema.sql" |
| + queries: "query.sql" |
| + gen: |
| + go: |
| + package: "querytest" |
| + out: "go" |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,66 @@ |
| +--- a/query.sql |
| |
| +@@ -1,12 +1,15 @@ |
| + -- name: GetAuthor :one |
| ++SELECT id, name, bio |
| ++FROM authors |
| ++WHERE id = ? |
| ++LIMIT 1; |
| +-select id,name , bio from authors |
| +-where id = ? limit 1; |
| + |
| + -- name: PickyQuery :many |
| ++SELECT |
| ++ id, -- the primary key |
| ++ name, |
| ++ -- computed downstream |
| ++ bio |
| +-SELECT id, -- the primary key |
| +- name, |
| +- -- computed downstream |
| +- bio |
| + FROM authors |
| + -- soft-deleted rows are filtered |
| + WHERE bio IS NOT NULL |
| +@@ -16,7 +19,8 @@ |
| + SELECT /* inline note */ id, name FROM authors ORDER BY name; |
| + |
| + -- name: ListAuthors :many |
| ++SELECT id, name, bio |
| ++FROM authors |
| +-SELECT id, name, bio FROM authors |
| + ORDER BY name; |
| + |
| + -- name: GetEvent :one |
| +@@ -23,8 +27,11 @@ |
| + SELECT "EventName", "order" |
| ++FROM "Events" |
| ++WHERE id = ? |
| ++LIMIT 1; |
| +-FROM "Events" WHERE id = ? LIMIT 1; |
| + |
| + -- name: CountSigils :one |
| ++SELECT count(*) |
| ++FROM authors |
| +-SELECT count(*) FROM authors |
| + WHERE id <> @at_param AND id <> :colon_param AND id <> $dollar_param; |
| + |
| + -- name: TopAuthors :many |
| +@@ -46,7 +53,7 @@ |
| + -- name: MakeMeasurements :exec |
| + CREATE TABLE IF NOT EXISTS measurements ( |
| + id INTEGER PRIMARY KEY, |
| ++ label VARYING CHARACTER(120), |
| +- label VARYING CHARACTER(120), |
| + ratio DECIMAL(10,5), |
| + note |
| + ); |
| +@@ -58,7 +65,7 @@ |
| + SELECT CAST(bio AS VARYING CHARACTER(120)) FROM authors LIMIT 1; |
| + |
| + -- name: MakeSearchIndex :exec |
| ++CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(body, tag UNINDEXED, tokenize = 'porter'); |
| +-CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(body, tag UNINDEXED, tokenize = 'porter'); |
| + |
| + -- name: MakeRecipeIndex :exec |
| + CREATE VIRTUAL TABLE recipes_fts USING fts5( |
| |
| |
| |
| |
| @@ -22,12 +22,6 @@ func (p *Parser) Param(n int) string { |
| return "?" |
| } |
| |
| -// NamedParam returns the named parameter placeholder for the given name. |
| -// ClickHouse uses {name:Type} syntax for named parameters. |
| -func (p *Parser) NamedParam(name string) string { |
| - return "{" + name + ":String}" |
| -} |
| - |
| // Cast returns a type cast expression. |
| // ClickHouse uses CAST(expr AS type) syntax, same as MySQL. |
| func (p *Parser) Cast(arg, typeName string) string { |
| |
| |
| |
| |
| @@ -560,9 +560,28 @@ func (c *cc) convertSelectField(n *pcast.SelectField) *ast.ResTarget { |
| } |
| |
| func (c *cc) convertSelectStmt(n *pcast.SelectStmt) *ast.SelectStmt { |
| + // The ORDER BY expressions are recorded twice: bare in WindowClause, |
| + // where the compiler's strict_order_by validation expects them, and |
| + // wrapped in SortBy nodes in SortClause, which carries the sort |
| + // direction and is what formatting prints. Both share the same |
| + // converted nodes so parameter numbering stays intact. |
| windowClause := &ast.List{Items: make([]ast.Node, 0)} |
| - orderByClause := c.convertOrderByClause(n.OrderBy) |
| - if orderByClause != nil { |
| + var sortClause *ast.List |
| + if n.OrderBy != nil { |
| + sortClause = &ast.List{Items: make([]ast.Node, 0)} |
| + orderByClause := &ast.List{Items: []ast.Node{}} |
| + for _, item := range n.OrderBy.Items { |
| + expr := c.convert(item.Expr) |
| + orderByClause.Items = append(orderByClause.Items, expr) |
| + dir := ast.SortByDirDefault |
| + if item.Desc { |
| + dir = ast.SortByDirDesc |
| + } |
| + sortClause.Items = append(sortClause.Items, &ast.SortBy{ |
| + Node: expr, |
| + SortbyDir: dir, |
| + }) |
| + } |
| windowClause.Items = append(windowClause.Items, orderByClause) |
| } |
| |
| @@ -575,6 +594,7 @@ func (c *cc) convertSelectStmt(n *pcast.SelectStmt) *ast.SelectStmt { |
| WhereClause: c.convert(n.Where), |
| WithClause: c.convertWithClause(n.With), |
| WindowClause: windowClause, |
| + SortClause: sortClause, |
| Op: op, |
| All: all, |
| } |
| @@ -1242,11 +1262,20 @@ func (c *cc) convertPatternInExpr(n *pcast.PatternInExpr) ast.Node { |
| } |
| |
| func (c *cc) convertPatternLikeExpr(n *pcast.PatternLikeOrIlikeExpr) ast.Node { |
| + kind := ast.A_Expr_Kind_ILIKE |
| + op := "~~*" |
| + if n.IsLike { |
| + kind = ast.A_Expr_Kind_LIKE |
| + op = "~~" |
| + } |
| + if n.Not { |
| + op = "!" + op |
| + } |
| return &ast.A_Expr{ |
| - Kind: ast.A_Expr_Kind(9), |
| + Kind: kind, |
| Name: &ast.List{ |
| Items: []ast.Node{ |
| - &ast.String{Str: "~~"}, |
| + &ast.String{Str: op}, |
| }, |
| }, |
| Lexpr: c.convert(n.Expr), |
| |
| |
| |
| |
| @@ -29,13 +29,6 @@ func (p *Parser) Param(n int) string { |
| return "?" |
| } |
| |
| -// NamedParam returns the named parameter placeholder for the given name. |
| -// MySQL doesn't have native named parameters, so we use ? (positional). |
| -// The actual parameter names are handled by sqlc's rewrite phase. |
| -func (p *Parser) NamedParam(name string) string { |
| - return "?" |
| -} |
| - |
| // Cast returns a type cast expression. |
| // MySQL uses CAST(expr AS type) syntax. |
| func (p *Parser) Cast(arg, typeName string) string { |
| |
| |
| |
| |
| @@ -64,12 +64,6 @@ func (p *Parser) Param(n int) string { |
| return fmt.Sprintf("$%d", n) |
| } |
| |
| -// NamedParam returns the named parameter placeholder for the given name. |
| -// PostgreSQL/sqlc uses @name syntax. |
| -func (p *Parser) NamedParam(name string) string { |
| - return "@" + name |
| -} |
| - |
| // Cast returns a type cast expression. |
| // PostgreSQL uses expr::type syntax. |
| func (p *Parser) Cast(arg, typeName string) string { |
| |
| |
| |
| |
| @@ -14,9 +14,10 @@ import ( |
| |
| // cc converts a meyer syntax tree into sqlc's engine-independent AST. One |
| // converter is used per statement; paramCount numbers the anonymous "?" |
| -// markers within it. |
| +// markers within it, and src is the source the statement was parsed from. |
| type cc struct { |
| paramCount int |
| + src string |
| } |
| |
| func todo(funcname string, n meyer.Node) *ast.TODO { |
| @@ -214,15 +215,21 @@ func (c *cc) convertAlterTableStmt(n *meyer.AlterTableStmt) ast.Node { |
| } |
| name := identifier(def.Name) |
| return &ast.AlterTableStmt{ |
| - Table: parseTableName(n.Table), |
| + Table: parseTableName(n.Table), |
| + Incomplete: !representableColumn(def), |
| Cmds: &ast.List{Items: []ast.Node{ |
| &ast.AlterTableCmd{ |
| Name: &name, |
| Subtype: ast.AT_AddColumn, |
| Def: &ast.ColumnDef{ |
| - Colname: name, |
| - TypeName: &ast.TypeName{Name: columnTypeName(def.Type)}, |
| - IsNotNull: hasNotNullConstraint(def.Constraints), |
| + Colname: name, |
| + TypeName: &ast.TypeName{ |
| + Name: columnTypeName(def.Type), |
| + Spelling: typeSpelling(def.Type), |
| + }, |
| + Typeless: def.Type == nil, |
| + IsNotNull: hasNotNullConstraint(def.Constraints), |
| + PrimaryKey: hasPrimaryKeyConstraint(def.Constraints), |
| }, |
| }, |
| }}, |
| @@ -278,12 +285,24 @@ func (c *cc) convertCreateTableStmt(n *meyer.CreateTableStmt) ast.Node { |
| stmt := &ast.CreateTableStmt{ |
| Name: parseTableName(n.Name), |
| IfNotExists: n.IfNotExists, |
| + // The node models none of these, so a statement carrying them has |
| + // no faithful rendering and the formatter keeps it as written. |
| + Incomplete: n.Temp || n.Select != nil || len(n.Constraints) > 0 || len(n.Options) > 0, |
| } |
| for _, def := range n.Columns { |
| + if !representableColumn(def) { |
| + stmt.Incomplete = true |
| + } |
| stmt.Cols = append(stmt.Cols, &ast.ColumnDef{ |
| - Colname: identifier(def.Name), |
| - IsNotNull: hasNotNullConstraint(def.Constraints), |
| - TypeName: &ast.TypeName{Name: columnTypeName(def.Type)}, |
| + Colname: identifier(def.Name), |
| + IsNotNull: hasNotNullConstraint(def.Constraints), |
| + PrimaryKey: hasPrimaryKeyConstraint(def.Constraints), |
| + TypeName: &ast.TypeName{ |
| + Name: columnTypeName(def.Type), |
| + Spelling: typeSpelling(def.Type), |
| + }, |
| + Typeless: def.Type == nil, |
| + Location: def.Pos(), |
| }) |
| } |
| return stmt |
| @@ -306,6 +325,19 @@ func (c *cc) convertCreateVirtualTableFTS5(n *meyer.CreateVirtualTableStmt) ast. |
| stmt := &ast.CreateTableStmt{ |
| Name: parseTableName(n.Name), |
| IfNotExists: n.IfNotExists, |
| + Using: identifier(n.Module), |
| + } |
| + if n.HasArgs { |
| + stmt.ModuleArgs = n.Args |
| + if stmt.ModuleArgs == nil { |
| + stmt.ModuleArgs = []string{} |
| + } |
| + // The arguments carry no spans of their own, so the author's exact |
| + // breaks cannot be kept; a declaration written across lines keeps |
| + // the canonical broken form instead. |
| + if n.Pos() >= 0 && n.End() <= len(c.src) { |
| + stmt.ModuleArgsMultiline = strings.Contains(c.src[n.Pos():n.End()], "\n") |
| + } |
| } |
| |
| // The module arguments of a virtual table are an arbitrary token |
| @@ -462,7 +494,8 @@ func (c *cc) convertColumnNames(cols []*meyer.Ident) *ast.List { |
| for _, col := range cols { |
| name := identifier(col) |
| list.Items = append(list.Items, &ast.ResTarget{ |
| - Name: &name, |
| + Name: &name, |
| + Location: col.Pos(), |
| }) |
| } |
| return list |
| @@ -891,9 +924,20 @@ func (c *cc) convertBindParam(n *meyer.BindParam) ast.Node { |
| } |
| default: |
| // A named parameter. sqlc carries the name through as the operand of |
| - // a pseudo-operator and resolves it later. |
| + // a pseudo-operator and resolves it later. The operator is the |
| + // parameter's own sigil, so the formatter can print the spelling the |
| + // author chose — SQLite accepts :name, @name and $name, but sqlc |
| + // gives them different meanings, so they must never be rewritten |
| + // into one another. |
| + sigil := "@" |
| + switch n.Kind { |
| + case meyer.ParamColon: |
| + sigil = ":" |
| + case meyer.ParamDollar: |
| + sigil = "$" |
| + } |
| return &ast.A_Expr{ |
| - Name: &ast.List{Items: []ast.Node{&ast.String{Str: "@"}}}, |
| + Name: &ast.List{Items: []ast.Node{&ast.String{Str: sigil}}}, |
| Rexpr: &ast.String{Str: n.Name}, |
| Location: n.Pos(), |
| } |
| @@ -1046,6 +1090,7 @@ func (c *cc) convertCastExpr(n *meyer.CastExpr) ast.Node { |
| Arg: c.convert(n.X), |
| TypeName: &ast.TypeName{ |
| Name: name, |
| + Spelling: typeSpelling(n.Type), |
| Names: &ast.List{Items: []ast.Node{&ast.String{Str: strings.ToLower(name)}}}, |
| ArrayBounds: &ast.List{}, |
| }, |
| |
| |
| |
| |
| @@ -1,13 +1,35 @@ |
| package sqlite |
| |
| -// QuoteIdent returns a quoted identifier if it needs quoting. |
| -// SQLite uses double quotes for quoting identifiers (SQL standard), |
| -// though backticks are also supported for MySQL compatibility. |
| +import "strings" |
| + |
| +// QuoteIdent quotes an identifier when printing it bare would change what it |
| +// names: the parser folds unquoted identifiers to lower case, so any name |
| +// that is not already a plain lower-case identifier — or that collides with |
| +// a keyword — only survives a parse round-trip inside double quotes. |
| func (p *Parser) QuoteIdent(s string) string { |
| - // For now, don't quote - return as-is |
| + if s == "" || p.IsReservedKeyword(s) || !plainIdent(s) { |
| + return `"` + strings.ReplaceAll(s, `"`, `""`) + `"` |
| + } |
| return s |
| } |
| |
| +// plainIdent reports whether s parses back as itself unquoted: ASCII |
| +// lower-case letters, digits and underscores, not starting with a digit. |
| +func plainIdent(s string) bool { |
| + for i, r := range s { |
| + switch { |
| + case r >= 'a' && r <= 'z', r == '_': |
| + case r >= '0' && r <= '9': |
| + if i == 0 { |
| + return false |
| + } |
| + default: |
| + return false |
| + } |
| + } |
| + return true |
| +} |
| + |
| // TypeName returns the SQL type name for the given namespace and name. |
| func (p *Parser) TypeName(ns, name string) string { |
| if ns != "" { |
| @@ -22,12 +44,6 @@ func (p *Parser) Param(n int) string { |
| return "?" |
| } |
| |
| -// NamedParam returns the named parameter placeholder for the given name. |
| -// SQLite uses :name syntax for named parameters. |
| -func (p *Parser) NamedParam(name string) string { |
| - return ":" + name |
| -} |
| - |
| // Cast returns a type cast expression. |
| // SQLite uses CAST(expr AS type) syntax. |
| func (p *Parser) Cast(arg, typeName string) string { |
| |
| |
| |
| |
| @@ -3,9 +3,11 @@ package sqlite |
| import ( |
| "errors" |
| "io" |
| + "strings" |
| |
| meyer "github.com/sqlc-dev/meyer/ast" |
| "github.com/sqlc-dev/meyer/parser" |
| + mtoken "github.com/sqlc-dev/meyer/token" |
| |
| "github.com/sqlc-dev/sqlc/internal/source" |
| "github.com/sqlc-dev/sqlc/internal/sql/ast" |
| @@ -26,12 +28,22 @@ type Parser struct { |
| var parseOptions = parser.Options{UpdateDeleteLimit: true} |
| |
| func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { |
| + f, err := p.ParseFile(r) |
| + if err != nil { |
| + return nil, err |
| + } |
| + return f.Stmts, nil |
| +} |
| + |
| +// ParseFile parses like Parse and also carries the file's comments, taken |
| +// from the trivia meyer's single lexer pass produces alongside the tokens. |
| +func (p *Parser) ParseFile(r io.Reader) (*ast.File, error) { |
| blob, err := io.ReadAll(r) |
| if err != nil { |
| return nil, err |
| } |
| src := string(blob) |
| - parsed, err := parseOptions.ParseString(src) |
| + parsed, err := parseOptions.ParseFile(src) |
| if err != nil { |
| return nil, normalizeErr(err) |
| } |
| @@ -41,8 +53,8 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { |
| // that a statement's extent covers the comments written above it. sqlc |
| // reads the "-- name:" annotation out of that range. |
| loc := 0 |
| - for _, raw := range parsed { |
| - converter := &cc{} |
| + for _, raw := range parsed.Stmts { |
| + converter := &cc{src: src} |
| out := converter.convert(raw) |
| if _, ok := out.(*ast.TODO); !ok { |
| stmts = append(stmts, ast.Statement{ |
| @@ -55,7 +67,36 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { |
| } |
| loc = raw.End() |
| } |
| - return stmts, nil |
| + |
| + var comments []ast.Comment |
| + for _, tr := range parsed.Trivia { |
| + if tr.Kind != mtoken.COMMENT { |
| + continue |
| + } |
| + comments = append(comments, ast.Comment{ |
| + Text: strings.TrimRight(tr.Text(src), " \t\r\n"), |
| + Start: tr.Pos, |
| + End: tr.End, |
| + OwnLine: ownLine(src, tr.Pos), |
| + }) |
| + } |
| + return &ast.File{Stmts: stmts, Comments: comments}, nil |
| +} |
| + |
| +// ownLine reports that only blank space sits between the preceding line |
| +// break and pos. |
| +func ownLine(src string, pos int) bool { |
| + for j := pos - 1; j >= 0; j-- { |
| + switch src[j] { |
| + case '\n': |
| + return true |
| + case ' ', '\t', '\r': |
| + continue |
| + default: |
| + return false |
| + } |
| + } |
| + return true |
| } |
| |
| // trimTerminator returns the end of stmt with its terminating semicolon, and |
| |
| |
| |
| |
| @@ -76,6 +76,60 @@ func typeName(n *meyer.TypeName) string { |
| return sb.String() |
| } |
| |
| +// typeSpelling returns the type as the author wrote it — identifier tokens |
| +// space-joined, arguments as written — for the formatter to print back. |
| +// typeName folds the spaces out for catalog matching. |
| +func typeSpelling(n *meyer.TypeName) string { |
| + if n == nil { |
| + return "" |
| + } |
| + var sb strings.Builder |
| + sb.WriteString(n.Name) |
| + if len(n.Args) > 0 { |
| + sb.WriteString("(") |
| + sb.WriteString(strings.Join(n.Args, ",")) |
| + sb.WriteString(")") |
| + } |
| + return sb.String() |
| +} |
| + |
| +// representableColumn reports whether a column definition round-trips |
| +// through the fields ast.ColumnDef models: a plain NOT NULL, a plain |
| +// PRIMARY KEY, or nothing. Anything else — a named constraint, a conflict |
| +// clause, ASC/DESC or AUTOINCREMENT, DEFAULT, UNIQUE, CHECK, COLLATE, |
| +// REFERENCES, GENERATED — is parsed away, so a statement printing such a |
| +// column would lose it. NOT NULL next to PRIMARY KEY is also beyond the |
| +// node: SQLite's PRIMARY KEY does not imply NOT NULL, and the printed form |
| +// carries only one of the pair. |
| +func representableColumn(def *meyer.ColumnDef) bool { |
| + var notNull, primary bool |
| + for _, con := range def.Constraints { |
| + switch { |
| + case con.Name != nil: |
| + return false |
| + case con.Kind == meyer.ColumnNotNull && con.OnConflict == meyer.ConflictDefault: |
| + notNull = true |
| + case con.Kind == meyer.ColumnPrimaryKey && con.OnConflict == meyer.ConflictDefault && |
| + con.Order == meyer.SortDefault && !con.AutoIncrement: |
| + primary = true |
| + default: |
| + return false |
| + } |
| + } |
| + return !(notNull && primary) |
| +} |
| + |
| +// hasPrimaryKeyConstraint reports whether a column definition carries a |
| +// PRIMARY KEY constraint. |
| +func hasPrimaryKeyConstraint(constraints []*meyer.ColumnConstraint) bool { |
| + for _, constraint := range constraints { |
| + if constraint.Kind == meyer.ColumnPrimaryKey { |
| + return true |
| + } |
| + } |
| + return false |
| +} |
| + |
| // hasNotNullConstraint reports whether a column definition guarantees a |
| // value. A PRIMARY KEY implies NOT NULL for the purposes of code |
| // generation, matching the behavior of the previous parser. |
| |
| |
| |
| |
| @@ -7,16 +7,67 @@ This package defines the Abstract Syntax Tree (AST) nodes used by sqlc to repres |
| ### Node Interface |
| All AST nodes implement the `Node` interface with: |
| - `Pos() int` - returns the source position |
| -- `Format(buf *TrackedBuffer)` - formats the node back to SQL |
| +- `Format(buf *TrackedBuffer, d format.Dialect)` - formats the node back to SQL |
| |
| ### TrackedBuffer |
| -The `TrackedBuffer` type (`pg_query.go`) handles SQL formatting with dialect-specific behavior: |
| +The `TrackedBuffer` type (`print.go`) handles SQL formatting with dialect-specific behavior: |
| - `astFormat(node Node)` - formats any AST node |
| - `join(list *List, sep string)` - joins list items with separator |
| - `WriteString(s string)` - writes raw SQL |
| - `QuoteIdent(name string)` - quotes identifiers (dialect-specific) |
| - `TypeName(ns, name string)` - formats type names (dialect-specific) |
| |
| +### Pretty printing |
| +The doc renderer lives in `ast/printer` (`printer.Buffer`), which knows |
| +nothing about AST nodes; `TrackedBuffer` embeds it and adds the |
| +AST-facing layer (`astFormat`, comment emission, anchors). |
| +`TrackedBuffer` records a Wadler-style document (the model behind Prettier |
| +and ruff): Format methods emit text plus layout tokens, and the renderer |
| +decides which break opportunities become newlines. |
| + |
| +- `Line()` - a space when the group fits on one line, a newline otherwise |
| +- `Softline()` - nothing when the group fits, a newline otherwise |
| +- `Group()` / `EndGroup()` - a region laid out flat when its width fits |
| +- `Indent()` / `EndIndent()` - one level deeper (2 spaces) after breaks |
| +- `Breaker()` - forces every enclosing group to break (measures as |
| + infinitely wide) |
| +- `joinComma(list)` - joins items with `,` + `Line()` |
| +- `condition(node)` - clause-level AND/OR chain without outer parentheses, |
| + one branch per line when broken |
| + |
| +`ast.Format(n, d)` renders on a single line (all breaks collapse); |
| +`ast.Pretty(n, d, width)` breaks lines to fit `width` columns. Statement |
| +Format methods open a group and put `Line()` before each clause keyword |
| +(`FROM`, `WHERE`, ...), so a statement that fits stays on one line and a |
| +long one breaks at clause boundaries. When adding a Format method, write |
| +tokens so the flat rendering is correct SQL; layout tokens are optional. |
| + |
| +The fmt command does not pass a real width: like gofmt it never rewraps |
| +on its own, so it prints with an effectively infinite width and defers |
| +to the author's line breaks instead. `AttachComments` records, for each |
| +emission-point marker, whether its neighbouring printed nodes sat on |
| +different source lines; when they did, `boundary()` emits a `Breaker()` |
| +there on the real print, so the group the author broke stays broken and |
| +everything else stays flat. |
| + |
| +### Comments |
| +`ast.File{Stmts, Comments}` is what a comment-surfacing parser returns |
| +(SQLite via meyer's ParseFile). `AttachComments(raw, d, comments, src)` |
| +classifies each comment once, against a dry-run of the printer: source |
| +positions and line numbers decide trailing (same line as the code |
| +before) vs leading, and each comment is attached to the emission point |
| +— node or clause/list boundary — where the printer will reach it. From |
| +then on positions are never consulted: `PrettyWithComments(n, d, width, |
| +table)` emits by node identity, which is what lets edited or synthetic |
| +trees print their comments correctly (the dave/dst model; each record |
| +also keeps the node the comment followed, for future rewriting tools). |
| +A line comment forces every enclosing group to break — `hardline` and |
| +`breaker` tokens measure as infinitely wide — so commented statements |
| +format instead of collapsing. Emission points (`beforeClause`, |
| +`boundary` in joinComma/condition) double as classification markers on |
| +the dry run, guaranteeing attach-time decisions and print-time emission |
| +agree. |
| + |
| ### Dialect Interface |
| Dialect-specific formatting is handled via the `Dialect` interface: |
| ```go |
| |
| |
| |
| |
| @@ -1,6 +1,10 @@ |
| package ast |
| |
| -import "github.com/sqlc-dev/sqlc/internal/sql/format" |
| +import ( |
| + "strings" |
| + |
| + "github.com/sqlc-dev/sqlc/internal/sql/format" |
| +) |
| |
| type A_Expr struct { |
| Kind A_Expr_Kind |
| @@ -14,23 +18,43 @@ func (n *A_Expr) Pos() int { |
| return n.Location |
| } |
| |
| -// isNamedParam returns true if this A_Expr represents a named parameter (@name) |
| -// and extracts the parameter name if so. |
| -func (n *A_Expr) isNamedParam() (string, bool) { |
| +// isNamedParam reports whether this A_Expr represents a named parameter, |
| +// returning its sigil and name. Engines encode a named parameter as a |
| +// prefix pseudo-operator carrying the sigil the author wrote (@name for |
| +// most engines; SQLite also spells :name and $name). The spellings mean |
| +// different things to sqlc, so the printer emits the one it was given. |
| +func (n *A_Expr) isNamedParam() (sigil, name string, ok bool) { |
| if n.Name == nil || len(n.Name.Items) != 1 { |
| - return "", false |
| + return "", "", false |
| } |
| - s, ok := n.Name.Items[0].(*String) |
| - if !ok || s.Str != "@" { |
| - return "", false |
| + s, sok := n.Name.Items[0].(*String) |
| + if !sok || (s.Str != "@" && s.Str != ":" && s.Str != "$") { |
| + return "", "", false |
| } |
| if set(n.Lexpr) || !set(n.Rexpr) { |
| - return "", false |
| + return "", "", false |
| + } |
| + if nameStr, sok := n.Rexpr.(*String); sok { |
| + return s.Str, nameStr.Str, true |
| } |
| - if nameStr, ok := n.Rexpr.(*String); ok { |
| - return nameStr.Str, true |
| + // Before the compiler rewrites named parameters, @name parses as the @ |
| + // operator applied to a bare column reference. |
| + if col, sok := n.Rexpr.(*ColumnRef); sok && col.Fields != nil && len(col.Fields.Items) == 1 { |
| + if f, sok := col.Fields.Items[0].(*String); sok { |
| + return s.Str, f.Str, true |
| + } |
| } |
| - return "", false |
| + return "", "", false |
| +} |
| + |
| +// negated returns true when the expression's operator carries the negated |
| +// spelling of a pattern-match operator (e.g. "!~~" for NOT LIKE). |
| +func (n *A_Expr) negated() bool { |
| + if n.Name == nil || len(n.Name.Items) != 1 { |
| + return false |
| + } |
| + s, ok := n.Name.Items[0].(*String) |
| + return ok && strings.HasPrefix(s.Str, "!") |
| } |
| |
| func (n *A_Expr) Format(buf *TrackedBuffer, d format.Dialect) { |
| @@ -39,8 +63,9 @@ func (n *A_Expr) Format(buf *TrackedBuffer, d format.Dialect) { |
| } |
| |
| // Check for named parameter first (works regardless of Kind) |
| - if name, ok := n.isNamedParam(); ok { |
| - buf.WriteString(d.NamedParam(name)) |
| + if sigil, name, ok := n.isNamedParam(); ok { |
| + buf.WriteString(sigil) |
| + buf.WriteString(name) |
| return |
| } |
| |
| @@ -52,11 +77,19 @@ func (n *A_Expr) Format(buf *TrackedBuffer, d format.Dialect) { |
| buf.WriteString(")") |
| case A_Expr_Kind_LIKE: |
| buf.astFormat(n.Lexpr, d) |
| - buf.WriteString(" LIKE ") |
| + if n.negated() { |
| + buf.WriteString(" NOT LIKE ") |
| + } else { |
| + buf.WriteString(" LIKE ") |
| + } |
| buf.astFormat(n.Rexpr, d) |
| case A_Expr_Kind_ILIKE: |
| buf.astFormat(n.Lexpr, d) |
| - buf.WriteString(" ILIKE ") |
| + if n.negated() { |
| + buf.WriteString(" NOT ILIKE ") |
| + } else { |
| + buf.WriteString(" ILIKE ") |
| + } |
| buf.astFormat(n.Rexpr, d) |
| case A_Expr_Kind_SIMILAR: |
| buf.astFormat(n.Lexpr, d) |
| |
| |
| |
| |
| @@ -9,6 +9,10 @@ type AlterTableStmt struct { |
| Cmds *List |
| MissingOk bool |
| Relkind ObjectType |
| + // Incomplete marks a statement whose source carried syntax this node |
| + // does not model, such as column constraints beyond plain NOT NULL and |
| + // PRIMARY KEY on an added column. No faithful rendering exists for it. |
| + Incomplete bool |
| } |
| |
| func (n *AlterTableStmt) Pos() int { |
| @@ -19,6 +23,12 @@ func (n *AlterTableStmt) Format(buf *TrackedBuffer, d format.Dialect) { |
| if n == nil { |
| return |
| } |
| + // An incomplete statement cannot be printed back: part of its source |
| + // was parsed away. Render nothing, which no verification accepts, so |
| + // the formatter keeps the statement as written. |
| + if n.Incomplete { |
| + return |
| + } |
| buf.WriteString("ALTER TABLE ") |
| buf.astFormat(n.Relation, d) |
| buf.astFormat(n.Table, d) |
| |
| |
| |
| |
| @@ -35,15 +35,34 @@ func (n *BoolExpr) Format(buf *TrackedBuffer, d format.Dialect) { |
| buf.astFormat(n.Args.Items[0], d) |
| } |
| default: |
| + var op string |
| + switch n.Boolop { |
| + case BoolExprTypeAnd: |
| + op = "AND " |
| + case BoolExprTypeOr: |
| + op = "OR " |
| + } |
| buf.WriteString("(") |
| - if items(n.Args) { |
| - switch n.Boolop { |
| - case BoolExprTypeAnd: |
| - buf.join(n.Args, d, " AND ") |
| - case BoolExprTypeOr: |
| - buf.join(n.Args, d, " OR ") |
| + buf.Group() |
| + buf.Indent() |
| + buf.Softline() |
| + if items(n.Args) && op != "" { |
| + first := true |
| + for _, item := range n.Args.Items { |
| + if _, ok := item.(*TODO); ok { |
| + continue |
| + } |
| + if !first { |
| + buf.Line() |
| + buf.WriteString(op) |
| + } |
| + first = false |
| + buf.astFormat(item, d) |
| } |
| } |
| + buf.EndIndent() |
| + buf.Softline() |
| + buf.EndGroup() |
| buf.WriteString(")") |
| } |
| } |
| |
| |
| |
| |
| @@ -3,8 +3,12 @@ package ast |
| import "github.com/sqlc-dev/sqlc/internal/sql/format" |
| |
| type ColumnDef struct { |
| - Colname string |
| + Colname string |
| + // TypeName is the column's type for the catalog. When Typeless is set |
| + // the author wrote no type at all — SQLite allows it — and the column |
| + // prints without one, whatever TypeName carries. |
| TypeName *TypeName |
| + Typeless bool |
| IsNotNull bool |
| IsUnsigned bool |
| IsArray bool |
| @@ -44,8 +48,10 @@ func (n *ColumnDef) Format(buf *TrackedBuffer, d format.Dialect) { |
| return |
| } |
| buf.WriteString(n.Colname) |
| - buf.WriteString(" ") |
| - buf.astFormat(n.TypeName, d) |
| + if !n.Typeless { |
| + buf.WriteString(" ") |
| + buf.astFormat(n.TypeName, d) |
| + } |
| // Use IsArray from ColumnDef since TypeName.ArrayBounds may not be set |
| // (for type resolution compatibility) |
| if n.IsArray && !items(n.TypeName.ArrayBounds) { |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,235 @@ |
| +package ast |
| + |
| +import ( |
| + "sort" |
| + |
| + "github.com/sqlc-dev/sqlc/internal/sql/format" |
| +) |
| + |
| +// File is a parsed query file: its statements together with the comments |
| +// the parser's lexer saw. Engines whose parsers surface their trivia — the |
| +// lexical channel of whitespace and comments the grammar never sees, in |
| +// Roslyn's terminology — return it from ParseFile, so the formatter gets |
| +// statements and comments from one lexer pass. |
| +type File struct { |
| + Stmts []Statement |
| + Comments []Comment |
| +} |
| + |
| +// Comment is a single SQL comment, positioned by byte offsets into the |
| +// source the statement was parsed from — the same coordinates the engine |
| +// parsers stamp on nodes. |
| +type Comment struct { |
| + // Text is the comment as written, marker included ("-- x", "/* x */"). |
| + Text string |
| + Start int |
| + End int |
| + // OwnLine reports that only blank space preceded the comment on its |
| + // line, so it leads the code after it rather than trailing the code |
| + // before it. |
| + OwnLine bool |
| +} |
| + |
| +// Line reports whether the comment runs to the end of its line (-- or #), |
| +// so nothing may be printed after it on the same line. |
| +func (c Comment) Line() bool { |
| + return len(c.Text) < 2 || c.Text[0] != '/' || c.Text[1] != '*' |
| +} |
| + |
| +// commentRec is one attached comment: the anchor nodes on either side of it |
| +// in print order, and whether it trails the code before it (same source |
| +// line) or leads the code after it (its own line). |
| +// |
| +// The next anchor is where the printer emits the comment; the prev anchor |
| +// is the node the comment belongs to when the tree is edited — a trailing |
| +// comment travels with the node it annotates, the way dave/dst attaches |
| +// decorations in the Go ecosystem. |
| +type commentRec struct { |
| + c Comment |
| + prev, next Node |
| + trailing bool |
| +} |
| + |
| +// CommentTable holds a statement's comments attached to its nodes. It is |
| +// built once by AttachComments, before any printing (or, later, editing): |
| +// each comment is classified against the statement's anchor nodes by source |
| +// position and line, and from then on positions are never consulted again — |
| +// the printer emits comments by node identity, which is what lets an edited |
| +// or synthetic tree print its comments correctly. |
| +type CommentTable struct { |
| + recs []commentRec |
| + // byNext indexes recs by their next anchor, in source order; end holds |
| + // the comments with no anchor after them, which trail the statement. |
| + byNext map[Node][]int |
| + end []int |
| + taken []bool |
| + nTaken int |
| + // breaks marks the emission points where the author broke the line: |
| + // the printer keeps those breaks, gofmt-style, instead of imposing a |
| + // line width. |
| + breaks map[Node]bool |
| +} |
| + |
| +// breakAt reports whether the author broke the line at this emission point. |
| +func (t *CommentTable) breakAt(n Node) bool { |
| + return t != nil && t.breaks[n] |
| +} |
| + |
| +// Exhausted reports whether every attached comment was printed. |
| +func (t *CommentTable) Exhausted() bool { |
| + return t == nil || t.nTaken == len(t.recs) |
| +} |
| + |
| +// take returns and consumes the comments anchored to n, in order. |
| +func (t *CommentTable) take(n Node) []commentRec { |
| + if t == nil || n == nil { |
| + return nil |
| + } |
| + idxs := t.byNext[n] |
| + if len(idxs) == 0 { |
| + return nil |
| + } |
| + out := make([]commentRec, 0, len(idxs)) |
| + for _, i := range idxs { |
| + if t.taken[i] { |
| + continue |
| + } |
| + t.taken[i] = true |
| + t.nTaken++ |
| + out = append(out, t.recs[i]) |
| + } |
| + return out |
| +} |
| + |
| +// takeRemaining returns and consumes every comment not yet printed; the |
| +// statement is over, so everything left trails it. |
| +func (t *CommentTable) takeRemaining() []commentRec { |
| + if t == nil { |
| + return nil |
| + } |
| + var out []commentRec |
| + for i := range t.recs { |
| + if t.taken[i] { |
| + continue |
| + } |
| + t.taken[i] = true |
| + t.nTaken++ |
| + out = append(out, t.recs[i]) |
| + } |
| + return out |
| +} |
| + |
| +// AttachComments classifies a statement's interior comments against its |
| +// nodes, producing the table the printer (and any future rewriting tool) |
| +// works from. Placement follows gofmt's rules, decided here once from |
| +// source positions and lines: a comment on the same line as the code before |
| +// it trails that code; any other comment leads the first node printed after |
| +// it; a comment after the last node trails the statement. |
| +func AttachComments(raw *RawStmt, d format.Dialect, comments []Comment, src string) *CommentTable { |
| + anchors := collectAnchors(raw, d) |
| + lines := []int{0} |
| + for i := 0; i < len(src); i++ { |
| + if src[i] == '\n' { |
| + lines = append(lines, i+1) |
| + } |
| + } |
| + lineOf := func(pos int) int { |
| + return sort.SearchInts(lines, pos+1) - 1 |
| + } |
| + |
| + table := &CommentTable{byNext: make(map[Node][]int, len(anchors))} |
| + for _, c := range comments { |
| + // prev: the printed node with the greatest position before the |
| + // comment (for the trailing/leading call). next: the emission point |
| + // for the first printed node after the comment — the node itself, |
| + // or, when boundary markers immediately precede it in print order, |
| + // the earliest of those markers, which is where the printer will |
| + // look for this comment first. |
| + var prev, next Node |
| + prevPos := -1 |
| + for _, a := range anchors { |
| + if !a.marker && a.pos < c.Start && a.pos > prevPos { |
| + prev, prevPos = a.node, a.pos |
| + } |
| + } |
| + for i, a := range anchors { |
| + if a.marker || a.pos <= c.Start { |
| + continue |
| + } |
| + j := i |
| + for j > 0 && anchors[j-1].marker { |
| + j-- |
| + } |
| + next = anchors[j].node |
| + break |
| + } |
| + rec := commentRec{ |
| + c: c, |
| + prev: prev, |
| + next: next, |
| + trailing: !c.OwnLine && prev != nil && lineOf(prevPos) == lineOf(c.Start), |
| + } |
| + table.recs = append(table.recs, rec) |
| + i := len(table.recs) - 1 |
| + if next == nil { |
| + table.end = append(table.end, i) |
| + } else { |
| + table.byNext[next] = append(table.byNext[next], i) |
| + } |
| + } |
| + table.taken = make([]bool, len(table.recs)) |
| + |
| + // Record where the author broke the line: an emission point whose |
| + // neighbouring printed nodes sit on different source lines. The printer |
| + // keeps these breaks (and only imposes new ones for comments), so the |
| + // statement's shape stays the author's. |
| + table.breaks = make(map[Node]bool) |
| + for i, a := range anchors { |
| + if !a.marker { |
| + continue |
| + } |
| + prevPos, nextPos := -1, -1 |
| + for j := i - 1; j >= 0; j-- { |
| + if !anchors[j].marker { |
| + prevPos = anchors[j].pos |
| + break |
| + } |
| + } |
| + for j := i + 1; j < len(anchors); j++ { |
| + if !anchors[j].marker { |
| + nextPos = anchors[j].pos |
| + break |
| + } |
| + } |
| + if prevPos >= 0 && nextPos >= 0 && lineOf(prevPos) != lineOf(nextPos) { |
| + table.breaks[a.node] = true |
| + } |
| + } |
| + return table |
| +} |
| + |
| +type anchor struct { |
| + node Node |
| + pos int |
| + // marker anchors are emission points (beforeClause, list boundaries) |
| + // rather than printed nodes; they carry no position of their own. |
| + marker bool |
| +} |
| + |
| +// collectAnchors renders the statement once, flat, recording every |
| +// positioned node in the order the printer visits them. Print order is what |
| +// comment emission is defined against, so classifying against it keeps the |
| +// attach-time decision and the print-time emission point identical. |
| +func collectAnchors(n Node, d format.Dialect) (out []anchor) { |
| + defer func() { |
| + // A formatter panic here surfaces later, on the real print; anchors |
| + // collected so far still place most comments. |
| + recover() |
| + }() |
| + tb := NewTrackedBuffer() |
| + tb.anchors = &out |
| + if ft, ok := n.(nodeFormatter); ok { |
| + ft.Format(tb, d) |
| + } |
| + return out |
| +} |
| |
| |
| |
| |
| @@ -32,6 +32,16 @@ func (n *CommonTableExpr) Format(buf *TrackedBuffer, d format.Dialect) { |
| buf.WriteString(")") |
| } |
| buf.WriteString(" AS (") |
| + buf.Group() |
| + buf.Indent() |
| + // The body's boundary: a comment at the top of the CTE prints here, and |
| + // an author who broke the line after the parenthesis keeps the CTE — and |
| + // therefore the statement around it — broken open. |
| + buf.boundary(n.Ctequery) |
| + buf.Softline() |
| buf.astFormat(n.Ctequery, d) |
| + buf.EndIndent() |
| + buf.Softline() |
| + buf.EndGroup() |
| buf.WriteString(")") |
| } |
| |
| |
| |
| |
| @@ -9,6 +9,25 @@ type CreateTableStmt struct { |
| ReferTable *TableName |
| Comment string |
| Inherits []*TableName |
| + // Using names the module of a virtual table (SQLite's CREATE VIRTUAL |
| + // TABLE ... USING module(...)), and ModuleArgs carries the module's |
| + // argument list as written — its grammar belongs to the module, so the |
| + // arguments pass through verbatim; nil means the declaration had no |
| + // argument list at all. Cols still holds the columns sqlc derives from |
| + // the arguments for the catalog; the statement prints as its |
| + // declaration, not as those columns. |
| + Using string |
| + ModuleArgs []string |
| + // ModuleArgsMultiline records that the declaration was written across |
| + // lines. The arguments carry no positions, so the printer cannot keep |
| + // the author's exact breaks and prints the canonical broken form — one |
| + // argument per line — instead. |
| + ModuleArgsMultiline bool |
| + // Incomplete marks a statement whose source carried syntax this node |
| + // does not model — column or table constraints beyond plain NOT NULL |
| + // and PRIMARY KEY, table options, TEMP, or an AS SELECT body. No |
| + // faithful rendering exists for it. |
| + Incomplete bool |
| } |
| |
| func (n *CreateTableStmt) Pos() int { |
| @@ -19,15 +38,67 @@ func (n *CreateTableStmt) Format(buf *TrackedBuffer, d format.Dialect) { |
| if n == nil { |
| return |
| } |
| + // A virtual table prints as its declaration: the module name and the |
| + // argument list as written. |
| + if n.Using != "" { |
| + buf.WriteString("CREATE VIRTUAL TABLE ") |
| + if n.IfNotExists { |
| + buf.WriteString("IF NOT EXISTS ") |
| + } |
| + buf.astFormat(n.Name, d) |
| + buf.WriteString(" USING ") |
| + buf.WriteString(n.Using) |
| + if n.ModuleArgs != nil { |
| + buf.WriteString("(") |
| + buf.Group() |
| + buf.Indent() |
| + if n.ModuleArgsMultiline { |
| + buf.Breaker() |
| + } |
| + buf.Softline() |
| + for i, arg := range n.ModuleArgs { |
| + if i > 0 { |
| + buf.WriteString(",") |
| + buf.Line() |
| + } |
| + buf.WriteString(arg) |
| + } |
| + buf.EndIndent() |
| + buf.Softline() |
| + buf.EndGroup() |
| + buf.WriteString(")") |
| + } |
| + return |
| + } |
| + // An incomplete statement cannot be printed back: part of its source |
| + // was parsed away. Render nothing, which no verification accepts, so |
| + // the formatter keeps the statement as written. |
| + if n.Incomplete { |
| + return |
| + } |
| buf.WriteString("CREATE TABLE ") |
| + if n.IfNotExists { |
| + buf.WriteString("IF NOT EXISTS ") |
| + } |
| buf.astFormat(n.Name, d) |
| |
| - buf.WriteString("(") |
| + buf.WriteString(" (") |
| + buf.Group() |
| + buf.Indent() |
| + if len(n.Cols) > 0 { |
| + buf.boundary(n.Cols[0]) |
| + } |
| + buf.Softline() |
| for i, col := range n.Cols { |
| if i > 0 { |
| - buf.WriteString(", ") |
| + buf.WriteString(",") |
| + buf.boundary(col) |
| + buf.Line() |
| } |
| buf.astFormat(col, d) |
| } |
| + buf.EndIndent() |
| + buf.Softline() |
| + buf.EndGroup() |
| buf.WriteString(")") |
| } |
| |
| |
| |
| |
| @@ -26,9 +26,18 @@ func (n *DeleteStmt) Format(buf *TrackedBuffer, d format.Dialect) { |
| return |
| } |
| |
| + buf.Group() |
| + defer buf.EndGroup() |
| + |
| if n.WithClause != nil { |
| buf.astFormat(n.WithClause, d) |
| - buf.WriteString(" ") |
| + // The boundary between the WITH clause and the statement's own |
| + // first keyword; the group keeps a break inside the WITH clause |
| + // from forcing the statement body apart clause by clause. |
| + buf.boundary(n.Relations) |
| + buf.Line() |
| + buf.Group() |
| + defer buf.EndGroup() |
| } |
| |
| buf.WriteString("DELETE ") |
| @@ -50,22 +59,30 @@ func (n *DeleteStmt) Format(buf *TrackedBuffer, d format.Dialect) { |
| } |
| |
| if items(n.UsingClause) { |
| - buf.WriteString(" USING ") |
| + buf.beforeClause(n.UsingClause, d) |
| + buf.Line() |
| + buf.WriteString("USING ") |
| buf.join(n.UsingClause, d, ", ") |
| } |
| |
| if set(n.WhereClause) { |
| - buf.WriteString(" WHERE ") |
| - buf.astFormat(n.WhereClause, d) |
| + buf.beforeClause(n.WhereClause, d) |
| + buf.Line() |
| + buf.WriteString("WHERE ") |
| + buf.condition(n.WhereClause, d) |
| } |
| |
| if set(n.LimitCount) { |
| - buf.WriteString(" LIMIT ") |
| + buf.beforeClause(n.LimitCount, d) |
| + buf.Line() |
| + buf.WriteString("LIMIT ") |
| buf.astFormat(n.LimitCount, d) |
| } |
| |
| if items(n.ReturningList) { |
| - buf.WriteString(" RETURNING ") |
| + buf.beforeClause(n.ReturningList, d) |
| + buf.Line() |
| + buf.WriteString("RETURNING ") |
| formatReturningOptions(buf, d, n.ReturningOldAlias, n.ReturningNewAlias) |
| buf.astFormat(n.ReturningList, d) |
| } |
| |
| |
| |
| |
| @@ -26,9 +26,18 @@ func (n *InsertStmt) Format(buf *TrackedBuffer, d format.Dialect) { |
| return |
| } |
| |
| + buf.Group() |
| + defer buf.EndGroup() |
| + |
| if n.WithClause != nil { |
| buf.astFormat(n.WithClause, d) |
| - buf.WriteString(" ") |
| + // The boundary between the WITH clause and the statement's own |
| + // first keyword; the group keeps a break inside the WITH clause |
| + // from forcing the statement body apart clause by clause. |
| + buf.boundary(n.Relation) |
| + buf.Line() |
| + buf.Group() |
| + defer buf.EndGroup() |
| } |
| |
| buf.WriteString("INSERT INTO ") |
| @@ -37,29 +46,38 @@ func (n *InsertStmt) Format(buf *TrackedBuffer, d format.Dialect) { |
| } |
| if items(n.Cols) { |
| buf.WriteString(" (") |
| - buf.astFormat(n.Cols, d) |
| + buf.Group() |
| + buf.Indent() |
| + buf.Softline() |
| + buf.joinComma(n.Cols, d) |
| + buf.EndIndent() |
| + buf.Softline() |
| + buf.EndGroup() |
| buf.WriteString(")") |
| } |
| |
| if n.DefaultValues { |
| buf.WriteString(" DEFAULT VALUES") |
| } else if set(n.SelectStmt) { |
| - buf.WriteString(" ") |
| + buf.beforeClause(n.SelectStmt, d) |
| + buf.Line() |
| buf.astFormat(n.SelectStmt, d) |
| } |
| |
| if n.OnConflictClause != nil { |
| - buf.WriteString(" ") |
| + buf.Line() |
| buf.astFormat(n.OnConflictClause, d) |
| } |
| |
| if n.OnDuplicateKeyUpdate != nil { |
| - buf.WriteString(" ") |
| + buf.Line() |
| buf.astFormat(n.OnDuplicateKeyUpdate, d) |
| } |
| |
| if items(n.ReturningList) { |
| - buf.WriteString(" RETURNING ") |
| + buf.beforeClause(n.ReturningList, d) |
| + buf.Line() |
| + buf.WriteString("RETURNING ") |
| formatReturningOptions(buf, d, n.ReturningOldAlias, n.ReturningNewAlias) |
| buf.astFormat(n.ReturningList, d) |
| } |
| |
| |
| |
| |
| @@ -22,25 +22,27 @@ func (n *JoinExpr) Format(buf *TrackedBuffer, d format.Dialect) { |
| return |
| } |
| buf.astFormat(n.Larg, d) |
| + buf.beforeClause(n.Rarg, d) |
| + buf.Line() |
| if n.IsNatural { |
| - buf.WriteString(" NATURAL") |
| + buf.WriteString("NATURAL ") |
| } |
| switch n.Jointype { |
| case JoinTypeLeft: |
| - buf.WriteString(" LEFT JOIN ") |
| + buf.WriteString("LEFT JOIN ") |
| case JoinTypeRight: |
| - buf.WriteString(" RIGHT JOIN ") |
| + buf.WriteString("RIGHT JOIN ") |
| case JoinTypeFull: |
| - buf.WriteString(" FULL JOIN ") |
| + buf.WriteString("FULL JOIN ") |
| case JoinTypeInner: |
| // CROSS JOIN has no ON or USING clause |
| if !items(n.UsingClause) && !set(n.Quals) { |
| - buf.WriteString(" CROSS JOIN ") |
| + buf.WriteString("CROSS JOIN ") |
| } else { |
| - buf.WriteString(" JOIN ") |
| + buf.WriteString("JOIN ") |
| } |
| default: |
| - buf.WriteString(" JOIN ") |
| + buf.WriteString("JOIN ") |
| } |
| buf.astFormat(n.Rarg, d) |
| if items(n.UsingClause) { |
| @@ -49,6 +51,6 @@ func (n *JoinExpr) Format(buf *TrackedBuffer, d format.Dialect) { |
| buf.WriteString(")") |
| } else if set(n.Quals) { |
| buf.WriteString(" ON ") |
| - buf.astFormat(n.Quals, d) |
| + buf.condition(n.Quals, d) |
| } |
| } |
| |
| |
| |
| |
| @@ -1,9 +1,8 @@ |
| package ast |
| |
| import ( |
| - "strings" |
| - |
| "github.com/sqlc-dev/sqlc/internal/debug" |
| + "github.com/sqlc-dev/sqlc/internal/sql/ast/printer" |
| "github.com/sqlc-dev/sqlc/internal/sql/format" |
| ) |
| |
| @@ -11,18 +10,37 @@ type nodeFormatter interface { |
| Format(*TrackedBuffer, format.Dialect) |
| } |
| |
| +// TrackedBuffer layers AST formatting over the document renderer in |
| +// ast/printer: node dispatch, list joins, and comment emission. The |
| +// renderer itself — tokens, groups, width fitting — lives in the printer |
| +// package; TrackedBuffer stays here because every node's Format method |
| +// names it, which an ast → printer → ast import cycle would forbid. |
| type TrackedBuffer struct { |
| - *strings.Builder |
| + *printer.Buffer |
| + // ct, when set, carries the statement's interior comments attached to |
| + // their anchor nodes; the buffer emits each comment when it reaches the |
| + // comment's anchor. Positions were consulted once, in AttachComments — |
| + // never here — so edited and synthetic trees print comments correctly. |
| + ct *CommentTable |
| + // anchors, when set, records every positioned node and emission point |
| + // in print order instead of producing output; AttachComments uses this |
| + // dry run to classify comments against the same order printing will |
| + // use. |
| + anchors *[]anchor |
| } |
| |
| // NewTrackedBuffer creates a new TrackedBuffer. |
| func NewTrackedBuffer() *TrackedBuffer { |
| - return &TrackedBuffer{ |
| - Builder: new(strings.Builder), |
| - } |
| + return &TrackedBuffer{Buffer: &printer.Buffer{}} |
| } |
| |
| func (t *TrackedBuffer) astFormat(n Node, d format.Dialect) { |
| + if t.anchors != nil && n != nil && n.Pos() > 0 { |
| + *t.anchors = append(*t.anchors, anchor{node: n, pos: n.Pos()}) |
| + } |
| + if t.ct != nil && n != nil { |
| + t.emitComments(t.ct.take(n)) |
| + } |
| if ft, ok := n.(nodeFormatter); ok { |
| ft.Format(t, d) |
| } else { |
| @@ -30,27 +48,200 @@ func (t *TrackedBuffer) astFormat(n Node, d format.Dialect) { |
| } |
| } |
| |
| +// emitComments prints attached comments at the boundary before their anchor |
| +// node. A trailing comment continues the line before it (a line comment |
| +// then forces the enclosing groups to break); an own-line or line comment |
| +// goes on its own line; an inline block comment stays in the flow. |
| +func (t *TrackedBuffer) emitComments(recs []commentRec) { |
| + for _, rec := range recs { |
| + switch { |
| + case rec.trailing: |
| + t.WriteString(" ") |
| + t.WriteString(rec.c.Text) |
| + if rec.c.Line() { |
| + t.Breaker() |
| + } |
| + case rec.c.OwnLine || rec.c.Line(): |
| + t.Hardline() |
| + t.WriteString(rec.c.Text) |
| + t.Hardline() |
| + default: |
| + t.WriteString(rec.c.Text) |
| + t.WriteString(" ") |
| + } |
| + } |
| +} |
| + |
| +// beforeClause is the emission point for comments that sit between the |
| +// previous clause and the one about to be printed, so they land before the |
| +// clause keyword. Call it before the clause's line break. During the |
| +// AttachComments dry run it records itself as a boundary marker, which is |
| +// how classification and emission are guaranteed to pick the same spot — |
| +// and how the author's own line break before the clause is observed and |
| +// kept. |
| +func (t *TrackedBuffer) beforeClause(n Node, d format.Dialect) { |
| + t.boundary(n) |
| +} |
| + |
| +// boundary is a separator-adjacent emission point (before a clause, after a |
| +// comma, before an AND/OR): comments classified to the upcoming node print |
| +// here, before the separator's line break, and a line break the author |
| +// wrote at this boundary forces the break to stay. On the dry run it |
| +// records a marker instead, so classification and emission agree by |
| +// construction. |
| +func (t *TrackedBuffer) boundary(next Node) { |
| + if next == nil { |
| + return |
| + } |
| + if t.anchors != nil { |
| + *t.anchors = append(*t.anchors, anchor{node: next, marker: true}) |
| + return |
| + } |
| + if t.ct != nil { |
| + t.emitComments(t.ct.take(next)) |
| + if t.ct.breakAt(next) { |
| + t.Breaker() |
| + } |
| + } |
| +} |
| + |
| +// flushRemaining prints every comment not yet printed; the statement is |
| +// over, so everything left trails it. |
| +func (t *TrackedBuffer) flushRemaining() { |
| + if t.ct == nil { |
| + return |
| + } |
| + for _, rec := range t.ct.takeRemaining() { |
| + if rec.trailing { |
| + t.WriteString(" ") |
| + t.WriteString(rec.c.Text) |
| + if rec.c.Line() { |
| + t.Breaker() |
| + } |
| + } else { |
| + t.Hardline() |
| + t.WriteString(rec.c.Text) |
| + } |
| + } |
| +} |
| + |
| func (t *TrackedBuffer) join(n *List, d format.Dialect, sep string) { |
| if n == nil { |
| return |
| } |
| - for i, item := range n.Items { |
| + first := true |
| + for _, item := range n.Items { |
| if _, ok := item.(*TODO); ok { |
| continue |
| } |
| - if i > 0 { |
| + if !first { |
| t.WriteString(sep) |
| } |
| + first = false |
| + t.astFormat(item, d) |
| + } |
| +} |
| + |
| +// joinComma writes the list items separated by a comma and a break |
| +// opportunity, so a list that fits stays on one line and a list that does |
| +// not puts every item on its own line. An item's trailing comment prints |
| +// after the comma, gofmt-style: `total, -- computed`. |
| +func (t *TrackedBuffer) joinComma(n *List, d format.Dialect) { |
| + if n == nil { |
| + return |
| + } |
| + items := make([]Node, 0, len(n.Items)) |
| + for _, item := range n.Items { |
| + if _, ok := item.(*TODO); ok { |
| + continue |
| + } |
| + items = append(items, item) |
| + } |
| + for i, item := range items { |
| + if i > 0 { |
| + t.WriteString(",") |
| + t.boundary(item) |
| + t.Line() |
| + } |
| + t.astFormat(item, d) |
| + } |
| +} |
| + |
| +// condition formats a clause-level boolean condition (WHERE, HAVING, ON). |
| +// A top-level AND/OR chain is printed without the enclosing parentheses a |
| +// nested BoolExpr gets — the clause keyword already delimits it — and each |
| +// branch goes on its own line when the chain does not fit: |
| +// |
| +// WHERE name LIKE $1 |
| +// AND id > $2 |
| +func (t *TrackedBuffer) condition(n Node, d format.Dialect) { |
| + be, ok := n.(*BoolExpr) |
| + if !ok || (be.Boolop != BoolExprTypeAnd && be.Boolop != BoolExprTypeOr) { |
| + t.astFormat(n, d) |
| + return |
| + } |
| + op := "AND " |
| + if be.Boolop == BoolExprTypeOr { |
| + op = "OR " |
| + } |
| + t.Group() |
| + t.Indent() |
| + first := true |
| + t.conditionArgs(be, d, op, &first) |
| + t.EndIndent() |
| + t.EndGroup() |
| +} |
| + |
| +// conditionArgs writes the branches of an AND/OR chain, flattening nested |
| +// chains of the same operator (some parsers produce `a AND b AND c` as a |
| +// left-nested tree) so no redundant parentheses appear. |
| +func (t *TrackedBuffer) conditionArgs(be *BoolExpr, d format.Dialect, op string, first *bool) { |
| + if be.Args == nil { |
| + return |
| + } |
| + for _, item := range be.Args.Items { |
| + if _, ok := item.(*TODO); ok { |
| + continue |
| + } |
| + if nested, ok := item.(*BoolExpr); ok && nested.Boolop == be.Boolop { |
| + t.conditionArgs(nested, d, op, first) |
| + continue |
| + } |
| + if !*first { |
| + t.boundary(item) |
| + t.Line() |
| + t.WriteString(op) |
| + } |
| + *first = false |
| t.astFormat(item, d) |
| } |
| } |
| |
| +// Format renders the node as SQL on a single line. |
| func Format(n Node, d format.Dialect) string { |
| + return Pretty(n, d, -1) |
| +} |
| + |
| +// Pretty renders the node as SQL, breaking lines so the output fits within |
| +// width columns where the statement's structure allows it. A negative width |
| +// renders everything on a single line. |
| +func Pretty(n Node, d format.Dialect, width int) string { |
| + return PrettyWithComments(n, d, width, nil) |
| +} |
| + |
| +// PrettyWithComments renders the node as SQL like Pretty, emitting the |
| +// comments a prior AttachComments call anchored to its nodes and keeping |
| +// the line breaks the author wrote at the boundaries the printer models. |
| +// Each comment prints at the boundary before its anchor, a trailing comment |
| +// continues the line of the code it followed, and every comment in the |
| +// table is printed — anything left when the statement ends trails it. |
| +func PrettyWithComments(n Node, d format.Dialect, width int, ct *CommentTable) string { |
| tb := NewTrackedBuffer() |
| + tb.ct = ct |
| if ft, ok := n.(nodeFormatter); ok { |
| ft.Format(tb, d) |
| } |
| - return tb.String() |
| + return tb.Print(width) |
| } |
| |
| func set(n Node) bool { |
| @@ -58,10 +249,7 @@ func set(n Node) bool { |
| return false |
| } |
| _, ok := n.(*TODO) |
| - if ok { |
| - return false |
| - } |
| - return true |
| + return !ok |
| } |
| |
| func items(n *List) bool { |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,250 @@ |
| +// Package printer implements the document renderer the SQL formatter |
| +// prints through: a small Wadler-style engine, the model behind Prettier |
| +// and ruff (via Biome's printer). Callers emit a stream of tokens — literal |
| +// text, break opportunities, and markers that open and close groups and |
| +// indented regions — and Print lays each group out on a single line when |
| +// its flat width fits, breaking it otherwise. The package knows nothing |
| +// about SQL or the AST; the ast package's TrackedBuffer embeds a Buffer and |
| +// layers node formatting and comment emission on top. |
| +package printer |
| + |
| +import ( |
| + "strings" |
| + "unicode/utf8" |
| +) |
| + |
| +type tokenKind uint8 |
| + |
| +const ( |
| + tokenText tokenKind = iota |
| + // tokenLine renders as a single space when its group fits on one line |
| + // and as a line break when the group is broken. |
| + tokenLine |
| + // tokenSoftline renders as nothing when its group fits on one line and |
| + // as a line break when the group is broken. |
| + tokenSoftline |
| + // tokenHardline always renders a line break and forces every group |
| + // containing it to break (it measures as infinitely wide). Emitted |
| + // around comments, which pin the author's layout open. |
| + tokenHardline |
| + // tokenBreaker renders nothing but forces every group containing it to |
| + // break. Emitted after a trailing line comment, whose text swallows the |
| + // rest of the line, and at boundaries where the author broke the line. |
| + tokenBreaker |
| + tokenOpenGroup |
| + tokenCloseGroup |
| + tokenOpenIndent |
| + tokenCloseIndent |
| +) |
| + |
| +// breakWidth is the measured width of tokens that force a break: wider than |
| +// any real line, so no group containing one ever fits. |
| +const breakWidth = 1 << 24 |
| + |
| +// indentWidth is the number of spaces per indentation level in broken |
| +// (multi-line) output. |
| +const indentWidth = 2 |
| + |
| +type token struct { |
| + kind tokenKind |
| + text string |
| +} |
| + |
| +// Buffer accumulates the document token stream. |
| +type Buffer struct { |
| + tokens []token |
| +} |
| + |
| +func (t *Buffer) WriteString(s string) (int, error) { |
| + if s == "" { |
| + return 0, nil |
| + } |
| + t.tokens = append(t.tokens, token{kind: tokenText, text: s}) |
| + return len(s), nil |
| +} |
| + |
| +// Write implements io.Writer so callers can use fmt.Fprintf. |
| +func (t *Buffer) Write(p []byte) (int, error) { |
| + return t.WriteString(string(p)) |
| +} |
| + |
| +func (t *Buffer) WriteRune(r rune) (int, error) { |
| + return t.WriteString(string(r)) |
| +} |
| + |
| +// String renders the buffer on a single line. |
| +func (t *Buffer) String() string { |
| + return t.Print(-1) |
| +} |
| + |
| +// Line marks a break opportunity between two tokens: a space when the |
| +// surrounding group fits on one line, a line break when it does not. |
| +func (t *Buffer) Line() { |
| + t.tokens = append(t.tokens, token{kind: tokenLine}) |
| +} |
| + |
| +// Softline marks a break opportunity that disappears entirely when the |
| +// surrounding group fits on one line. |
| +func (t *Buffer) Softline() { |
| + t.tokens = append(t.tokens, token{kind: tokenSoftline}) |
| +} |
| + |
| +// Hardline always renders a line break and forces every enclosing group to |
| +// break. |
| +func (t *Buffer) Hardline() { |
| + t.tokens = append(t.tokens, token{kind: tokenHardline}) |
| +} |
| + |
| +// Breaker renders nothing but forces every enclosing group to break, so the |
| +// next break opportunity becomes a real line break. |
| +func (t *Buffer) Breaker() { |
| + t.tokens = append(t.tokens, token{kind: tokenBreaker}) |
| +} |
| + |
| +// Group opens a region the renderer tries to lay out on a single line, |
| +// breaking it only when its flat form does not fit. Must be paired with |
| +// EndGroup. |
| +func (t *Buffer) Group() { |
| + t.tokens = append(t.tokens, token{kind: tokenOpenGroup}) |
| +} |
| + |
| +func (t *Buffer) EndGroup() { |
| + t.tokens = append(t.tokens, token{kind: tokenCloseGroup}) |
| +} |
| + |
| +// Indent opens a region printed one indentation level deeper when line |
| +// breaks occur inside it. Must be paired with EndIndent. |
| +func (t *Buffer) Indent() { |
| + t.tokens = append(t.tokens, token{kind: tokenOpenIndent}) |
| +} |
| + |
| +func (t *Buffer) EndIndent() { |
| + t.tokens = append(t.tokens, token{kind: tokenCloseIndent}) |
| +} |
| + |
| +// docNode is the tree form of the token stream: text and break tokens are |
| +// leaves, groups and indented regions are interior nodes. |
| +type docNode struct { |
| + kind tokenKind |
| + text string |
| + kids []*docNode |
| + width int // flat width in runes, filled in by measure |
| +} |
| + |
| +// tree assembles the flat token stream into a document tree. Stray close |
| +// markers are ignored and unclosed regions end at the end of the stream. |
| +func (t *Buffer) tree() *docNode { |
| + root := &docNode{kind: tokenOpenGroup} |
| + stack := []*docNode{root} |
| + for _, tok := range t.tokens { |
| + top := stack[len(stack)-1] |
| + switch tok.kind { |
| + case tokenText, tokenLine, tokenSoftline, tokenHardline, tokenBreaker: |
| + top.kids = append(top.kids, &docNode{kind: tok.kind, text: tok.text}) |
| + case tokenOpenGroup, tokenOpenIndent: |
| + n := &docNode{kind: tok.kind} |
| + top.kids = append(top.kids, n) |
| + stack = append(stack, n) |
| + case tokenCloseGroup, tokenCloseIndent: |
| + if len(stack) > 1 { |
| + stack = stack[:len(stack)-1] |
| + } |
| + } |
| + } |
| + return root |
| +} |
| + |
| +// measure computes the width of every node when rendered flat. Hardlines |
| +// and breakers measure wider than any real line, so no group containing one |
| +// ever fits — Prettier's breakParent, by arithmetic. |
| +func measure(d *docNode) int { |
| + switch d.kind { |
| + case tokenText: |
| + d.width = utf8.RuneCountInString(d.text) |
| + case tokenLine: |
| + d.width = 1 |
| + case tokenSoftline: |
| + d.width = 0 |
| + case tokenHardline, tokenBreaker: |
| + d.width = breakWidth |
| + default: |
| + for _, kid := range d.kids { |
| + d.width += measure(kid) |
| + if d.width > breakWidth { |
| + d.width = breakWidth |
| + } |
| + } |
| + } |
| + return d.width |
| +} |
| + |
| +// Print renders the token stream. A negative width renders everything on |
| +// one line; otherwise each group is rendered flat only when it fits in the |
| +// space remaining on its line — and a group holding a hardline or breaker |
| +// never fits, whatever the width, so forced breaks survive even an |
| +// unlimited line length. |
| +func (t *Buffer) Print(width int) string { |
| + root := t.tree() |
| + measure(root) |
| + |
| + type frame struct { |
| + d *docNode |
| + indent int |
| + flat bool |
| + } |
| + var sb strings.Builder |
| + col := 0 |
| + // atLineStart dedupes consecutive breaks: a break that fires when the |
| + // output is already at the start of a fresh line writes nothing, so a |
| + // comment's surrounding hardlines collapse against clause breaks |
| + // instead of leaving blank lines. |
| + atLineStart := true |
| + newline := func(indent int) { |
| + if atLineStart { |
| + return |
| + } |
| + sb.WriteByte('\n') |
| + for i := 0; i < indent; i++ { |
| + sb.WriteByte(' ') |
| + } |
| + col = indent |
| + atLineStart = true |
| + } |
| + stack := []frame{{d: root, flat: width < 0}} |
| + for len(stack) > 0 { |
| + f := stack[len(stack)-1] |
| + stack = stack[:len(stack)-1] |
| + switch f.d.kind { |
| + case tokenText: |
| + sb.WriteString(f.d.text) |
| + col += f.d.width |
| + atLineStart = false |
| + case tokenLine: |
| + if f.flat { |
| + sb.WriteByte(' ') |
| + col++ |
| + atLineStart = false |
| + } else { |
| + newline(f.indent) |
| + } |
| + case tokenSoftline: |
| + if !f.flat { |
| + newline(f.indent) |
| + } |
| + case tokenHardline: |
| + newline(f.indent) |
| + case tokenBreaker: |
| + // forces enclosing groups broken; renders nothing |
| + case tokenOpenGroup: |
| + flat := f.flat || (f.d.width < breakWidth && f.d.width <= width-col) |
| + for i := len(f.d.kids) - 1; i >= 0; i-- { |
| + stack = append(stack, frame{d: f.d.kids[i], indent: f.indent, flat: flat}) |
| + } |
| + case tokenOpenIndent: |
| + for i := len(f.d.kids) - 1; i >= 0; i-- { |
| + stack = append(stack, frame{d: f.d.kids[i], indent: f.indent + indentWidth, flat: f.flat}) |
| + } |
| + } |
| + } |
| + return sb.String() |
| +} |
| |
| |
| |
| |
| @@ -16,5 +16,7 @@ func (n *RawStmt) Format(buf *TrackedBuffer, d format.Dialect) { |
| if n.Stmt != nil { |
| buf.astFormat(n.Stmt, d) |
| } |
| + // The terminator goes first: a trailing line comment would swallow it. |
| buf.WriteString(";") |
| + buf.flushRemaining() |
| } |
| |
| |
| |
| |
| @@ -1,8 +1,6 @@ |
| package ast |
| |
| import ( |
| - "fmt" |
| - |
| "github.com/sqlc-dev/sqlc/internal/sql/format" |
| ) |
| |
| @@ -44,82 +42,125 @@ func (n *SelectStmt) Format(buf *TrackedBuffer, d format.Dialect) { |
| buf.WriteString(", ") |
| } |
| buf.WriteString("(") |
| - buf.astFormat(row, d) |
| + buf.Group() |
| + buf.Indent() |
| + buf.Softline() |
| + if r, ok := row.(*List); ok { |
| + buf.joinComma(r, d) |
| + } else { |
| + buf.astFormat(row, d) |
| + } |
| + buf.EndIndent() |
| + buf.Softline() |
| + buf.EndGroup() |
| buf.WriteString(")") |
| } |
| return |
| } |
| |
| + buf.Group() |
| + defer buf.EndGroup() |
| + |
| if n.WithClause != nil { |
| buf.astFormat(n.WithClause, d) |
| - buf.WriteString(" ") |
| + // The boundary between the WITH clause and the statement's own |
| + // first keyword; the group keeps a break inside the WITH clause |
| + // from forcing the statement body apart clause by clause. |
| + if n.Larg != nil { |
| + buf.boundary(n.Larg) |
| + } else { |
| + buf.boundary(n.TargetList) |
| + } |
| + buf.Line() |
| + buf.Group() |
| + defer buf.EndGroup() |
| } |
| |
| if n.Larg != nil && n.Rarg != nil { |
| buf.astFormat(n.Larg, d) |
| + buf.Line() |
| switch n.Op { |
| case Union: |
| - buf.WriteString(" UNION ") |
| + buf.WriteString("UNION") |
| case Except: |
| - buf.WriteString(" EXCEPT ") |
| + buf.WriteString("EXCEPT") |
| case Intersect: |
| - buf.WriteString(" INTERSECT ") |
| + buf.WriteString("INTERSECT") |
| } |
| if n.All { |
| - buf.WriteString("ALL ") |
| + buf.WriteString(" ALL") |
| } |
| + buf.Line() |
| buf.astFormat(n.Rarg, d) |
| } else { |
| - buf.WriteString("SELECT ") |
| - } |
| - |
| - if items(n.DistinctClause) { |
| - buf.WriteString("DISTINCT ") |
| - if !todo(n.DistinctClause) { |
| - fmt.Fprintf(buf, "ON (") |
| - buf.astFormat(n.DistinctClause, d) |
| - fmt.Fprintf(buf, ")") |
| + buf.WriteString("SELECT") |
| + if items(n.DistinctClause) { |
| + buf.WriteString(" DISTINCT") |
| + if !todo(n.DistinctClause) { |
| + buf.WriteString(" ON (") |
| + buf.astFormat(n.DistinctClause, d) |
| + buf.WriteString(")") |
| + } |
| } |
| + buf.Group() |
| + buf.Indent() |
| + buf.Line() |
| + buf.joinComma(n.TargetList, d) |
| + buf.EndIndent() |
| + buf.EndGroup() |
| } |
| - buf.astFormat(n.TargetList, d) |
| |
| if items(n.FromClause) { |
| - buf.WriteString(" FROM ") |
| + buf.beforeClause(n.FromClause, d) |
| + buf.Line() |
| + buf.WriteString("FROM ") |
| buf.astFormat(n.FromClause, d) |
| } |
| |
| if set(n.WhereClause) { |
| - buf.WriteString(" WHERE ") |
| - buf.astFormat(n.WhereClause, d) |
| + buf.beforeClause(n.WhereClause, d) |
| + buf.Line() |
| + buf.WriteString("WHERE ") |
| + buf.condition(n.WhereClause, d) |
| } |
| |
| if items(n.GroupClause) { |
| - buf.WriteString(" GROUP BY ") |
| + buf.beforeClause(n.GroupClause, d) |
| + buf.Line() |
| + buf.WriteString("GROUP BY ") |
| buf.astFormat(n.GroupClause, d) |
| } |
| |
| if set(n.HavingClause) { |
| - buf.WriteString(" HAVING ") |
| - buf.astFormat(n.HavingClause, d) |
| + buf.beforeClause(n.HavingClause, d) |
| + buf.Line() |
| + buf.WriteString("HAVING ") |
| + buf.condition(n.HavingClause, d) |
| } |
| |
| if items(n.SortClause) { |
| - buf.WriteString(" ORDER BY ") |
| + buf.beforeClause(n.SortClause, d) |
| + buf.Line() |
| + buf.WriteString("ORDER BY ") |
| buf.astFormat(n.SortClause, d) |
| } |
| |
| if set(n.LimitCount) { |
| - buf.WriteString(" LIMIT ") |
| + buf.beforeClause(n.LimitCount, d) |
| + buf.Line() |
| + buf.WriteString("LIMIT ") |
| buf.astFormat(n.LimitCount, d) |
| } |
| |
| if set(n.LimitOffset) { |
| - buf.WriteString(" OFFSET ") |
| + buf.beforeClause(n.LimitOffset, d) |
| + buf.Line() |
| + buf.WriteString("OFFSET ") |
| buf.astFormat(n.LimitOffset, d) |
| } |
| |
| if items(n.LockingClause) { |
| - buf.WriteString(" ") |
| + buf.Line() |
| buf.astFormat(n.LockingClause, d) |
| } |
| |
| |
| |
| |
| |
| @@ -54,6 +54,12 @@ func (n *SubLink) Format(buf *TrackedBuffer, d format.Dialect) { |
| buf.WriteString("(") |
| } |
| } |
| + buf.Group() |
| + buf.Indent() |
| + buf.Softline() |
| buf.astFormat(n.Subselect, d) |
| + buf.EndIndent() |
| + buf.Softline() |
| + buf.EndGroup() |
| buf.WriteString(")") |
| } |
| |
| |
| |
| |
| @@ -6,6 +6,11 @@ type TypeName struct { |
| Catalog string |
| Schema string |
| Name string |
| + // Spelling is the type as the author wrote it, when that differs from |
| + // Name: SQLite folds the spaces out of multi-word type names ("VARYING |
| + // CHARACTER" resolves as "VARYINGCHARACTER" in the catalog), so the |
| + // formatter prints this back instead of the folded form. |
| + Spelling string |
| |
| // From pg.TypeName |
| Names *List |
| @@ -26,6 +31,10 @@ func (n *TypeName) Format(buf *TrackedBuffer, d format.Dialect) { |
| if n == nil { |
| return |
| } |
| + if n.Spelling != "" { |
| + buf.WriteString(n.Spelling) |
| + goto addMods |
| + } |
| if items(n.Names) { |
| // Check if this is a qualified type (e.g., pg_catalog.int4) |
| if len(n.Names.Items) == 2 { |
| |
| |
| |
| |
| @@ -27,9 +27,18 @@ func (n *UpdateStmt) Format(buf *TrackedBuffer, d format.Dialect) { |
| if n == nil { |
| return |
| } |
| + buf.Group() |
| + defer buf.EndGroup() |
| + |
| if n.WithClause != nil { |
| buf.astFormat(n.WithClause, d) |
| - buf.WriteString(" ") |
| + // The boundary between the WITH clause and the statement's own |
| + // first keyword; the group keeps a break inside the WITH clause |
| + // from forcing the statement body apart clause by clause. |
| + buf.boundary(n.Relations) |
| + buf.Line() |
| + buf.Group() |
| + defer buf.EndGroup() |
| } |
| |
| buf.WriteString("UPDATE ") |
| @@ -38,7 +47,9 @@ func (n *UpdateStmt) Format(buf *TrackedBuffer, d format.Dialect) { |
| } |
| |
| if items(n.TargetList) { |
| - buf.WriteString(" SET ") |
| + buf.beforeClause(n.TargetList, d) |
| + buf.Line() |
| + buf.WriteString("SET ") |
| |
| multi := false |
| for _, item := range n.TargetList.Items { |
| @@ -79,9 +90,13 @@ func (n *UpdateStmt) Format(buf *TrackedBuffer, d format.Dialect) { |
| buf.join(vals, d, ",") |
| buf.WriteString(")") |
| } else { |
| + buf.Group() |
| + buf.Indent() |
| for i, item := range n.TargetList.Items { |
| if i > 0 { |
| - buf.WriteString(", ") |
| + buf.WriteString(",") |
| + buf.boundary(item) |
| + buf.Line() |
| } |
| switch nn := item.(type) { |
| case *ResTarget: |
| @@ -100,26 +115,36 @@ func (n *UpdateStmt) Format(buf *TrackedBuffer, d format.Dialect) { |
| buf.astFormat(item, d) |
| } |
| } |
| + buf.EndIndent() |
| + buf.EndGroup() |
| } |
| } |
| |
| if items(n.FromClause) { |
| - buf.WriteString(" FROM ") |
| + buf.beforeClause(n.FromClause, d) |
| + buf.Line() |
| + buf.WriteString("FROM ") |
| buf.astFormat(n.FromClause, d) |
| } |
| |
| if set(n.WhereClause) { |
| - buf.WriteString(" WHERE ") |
| - buf.astFormat(n.WhereClause, d) |
| + buf.beforeClause(n.WhereClause, d) |
| + buf.Line() |
| + buf.WriteString("WHERE ") |
| + buf.condition(n.WhereClause, d) |
| } |
| |
| if set(n.LimitCount) { |
| - buf.WriteString(" LIMIT ") |
| + buf.beforeClause(n.LimitCount, d) |
| + buf.Line() |
| + buf.WriteString("LIMIT ") |
| buf.astFormat(n.LimitCount, d) |
| } |
| |
| if items(n.ReturningList) { |
| - buf.WriteString(" RETURNING ") |
| + buf.beforeClause(n.ReturningList, d) |
| + buf.Line() |
| + buf.WriteString("RETURNING ") |
| formatReturningOptions(buf, d, n.ReturningOldAlias, n.ReturningNewAlias) |
| buf.astFormat(n.ReturningList, d) |
| } |
| |
| |
| |
| |
| @@ -20,5 +20,5 @@ func (n *WithClause) Format(buf *TrackedBuffer, d format.Dialect) { |
| if n.Recursive { |
| buf.WriteString("RECURSIVE ") |
| } |
| - buf.join(n.Ctes, d, ", ") |
| + buf.joinComma(n.Ctes, d) |
| } |
| |
| |
| |
| |
| @@ -14,10 +14,6 @@ type Dialect interface { |
| // PostgreSQL uses $1, $2, etc. MySQL uses ? |
| Param(n int) string |
| |
| - // NamedParam returns the named parameter placeholder for the given name. |
| - // PostgreSQL uses @name, SQLite uses :name |
| - NamedParam(name string) string |
| - |
| // Cast formats a type cast expression. |
| // PostgreSQL uses expr::type, MySQL uses CAST(expr AS type) |
| Cast(arg, typeName string) string |
|
|
