| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,47 @@ |
| +name: difftest |
| + |
| +# The milestone-6 cron lane: differential fuzzing of darkwing against the |
| +# pinned DuckDB CLI, plus a native fuzz run of the public Parse API. The |
| +# nightly artifact only matches the pin until upstream moves it, so the |
| +# lane verifies the version first and skips (green) once it drifts — |
| +# advancing the pin is its own workflow (cmd/regenerate), not this one. |
| + |
| +on: |
| + schedule: |
| + - cron: "17 5 * * *" |
| + workflow_dispatch: |
| + |
| +permissions: |
| + contents: read |
| + |
| +jobs: |
| + difftest: |
| + runs-on: ubuntu-latest |
| + timeout-minutes: 60 |
| + steps: |
| + - uses: actions/checkout@v4 |
| + - uses: actions/setup-go@v5 |
| + with: |
| + go-version-file: go.mod |
| + - name: Download the nightly DuckDB CLI |
| + run: | |
| + curl -sSL -o duckdb.zip https://artifacts.duckdb.org/latest/duckdb-binaries-linux-amd64.zip |
| + unzip -o -q duckdb.zip duckdb_cli-linux-amd64.zip |
| + unzip -o -q duckdb_cli-linux-amd64.zip |
| + ./duckdb --version |
| + - name: Check the nightly against the pin |
| + id: pin |
| + run: | |
| + pin=$(sed -n 's/.*PinnedVersion = "\(.*\)"/\1/p' internal/duckdbsrc/duckdbsrc.go) |
| + version=$(./duckdb --version) |
| + if echo "$version" | grep -qF "$pin"; then |
| + echo "matches=true" >> "$GITHUB_OUTPUT" |
| + else |
| + echo "matches=false" >> "$GITHUB_OUTPUT" |
| + echo "nightly is $version, pin is $pin - skipping until the pin advances" |
| + fi |
| + - name: Differential fuzzing vs the pinned CLI |
| + if: steps.pin.outputs.matches == 'true' |
| + run: DARKWING_DUCKDB=$PWD/duckdb go run ./cmd/difftest -seed $(date +%s) -duration 20m |
| + - name: Native fuzzing of Parse |
| + run: go test ./parser -run '^$' -fuzz FuzzParse -fuzztime 10m |
| |
| |
| |
| |
| @@ -77,6 +77,10 @@ Two corpus gates run under `go test ./parser`: |
| pinned DuckDB binary parses it. Since milestone 3 the classification |
| runs the full Parse pipeline, so transformer-raised Parser Errors count |
| alongside the matcher's syntax errors. |
| +- **Error fidelity** (`TestCorpusErrorMessages`, since milestone 6): |
| + every rejection renders the oracle's recorded first line verbatim. |
| + Positions and messages the corpus can't pin are covered by unit tests |
| + in `parser/errors_test.go`. |
| - **Tree shape** (`TestSerializeGoldens`): `internal/serialize` output |
| must match vendored `json_serialize_sql` goldens for a corpus sample |
| (see `parser/testdata/serialize/README.md`). |
| |
| |
| |
| |
| @@ -20,28 +20,34 @@ loader, and matcher (with packrat memoization) — to Go. |
| |
| ## Status |
| |
| -Milestone 2 (corpus + accept/reject conformance) is in place: the corpus |
| -under `parser/testdata/` is extracted from DuckDB's own test suite and |
| -classified by the pinned DuckDB CLI (`cmd/regenerate`); `go test ./parser` |
| -enforces *darkwing accepts iff pinned DuckDB parses*, with remaining |
| -disagreements tracked in todo metadata (`cmd/next-test`). |
| - |
| -Milestone 1 (engine) is complete: |
| - |
| -- `token/` — token kinds and DuckDB's keyword categories |
| -- `lexer/` — port of the parsing tokenizer |
| -- `internal/grammar/` — vendored grammar (pinned upstream commit recorded in |
| - `internal/grammar/README.md`) and the grammar loader |
| -- `internal/matcher/` — matcher tree, packrat memoization, rule overrides, |
| - furthest-failure error reporting |
| -- `cmd/debug-parse` — dump tokens or the raw parse tree for SQL on the |
| - command line |
| - |
| -Next: the typed AST and transformer core (milestone 3). |
| +Milestones 1–6 are complete: the engine (tokenizer, grammar loader, |
| +matcher with packrat memoization), the corpus conformance gates, the full |
| +typed AST with a transformer for every statement, and the hardening pass. |
| +`go test ./parser` enforces, corpus-wide against the pinned DuckDB CLI: |
| + |
| +- **Accept/reject** — darkwing accepts a statement iff the pinned binary |
| + parses it (`TestCorpus`), including transformer-raised parser errors. |
| +- **Error fidelity** — every rejection renders the oracle's error message |
| + verbatim (`TestCorpusErrorMessages`), with positions pinned by unit |
| + tests. |
| +- **Tree shape** — `internal/serialize` output matches vendored |
| + `json_serialize_sql` goldens for the SELECT subset |
| + (`TestSerializeGoldens`), with AST snapshots covering the rest. |
| + |
| +Hardening: `FuzzParse` holds the public API to its invariants on |
| +arbitrary input, benchmarks pin parse throughput and upstream's |
| +pathological-backtracking case (19 unmatched parens: milliseconds, thanks |
| +to packrat), and `cmd/difftest` mutates corpus seeds and diffs darkwing's |
| +verdicts against the pinned CLI (run nightly in CI while the nightly |
| +artifact matches the pin). |
| + |
| +Next: advancing the pin to the v2.0.0 tag when it lands (milestone 7), |
| +then sqlc integration. |
| |
| ``` |
| $ go run ./cmd/debug-parse 'SELECT 1' |
| $ go run ./cmd/debug-parse -tokens 'SELECT * FROM t' |
| +$ go run ./cmd/debug-parse -ast 'FROM t SELECT x' |
| ``` |
| |
| ## License |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,355 @@ |
| +// Command difftest is the milestone-6 differential fuzzer: it mutates |
| +// corpus seed statements at token boundaries and compares darkwing's |
| +// accept/reject verdict (and, for syntax errors, the message) against the |
| +// pinned DuckDB CLI — the strongest check on the matcher's ordered-choice |
| +// fidelity, cheap to run for hours in a cron lane. |
| +// |
| +// Usage: |
| +// |
| +// difftest [-n 500] [-duration 0] [-seed 1] [-jobs N] [-corpus dir] |
| +// |
| +// Deterministic for a given -seed/-corpus pair (a fixed -n; -duration |
| +// bounds wall clock instead). Exit status 1 when any disagreement is |
| +// found. The oracle binary is located via $DARKWING_DUCKDB (see |
| +// internal/duckdbsrc). |
| +// |
| +// Verdict policy mirrors the corpus harness: darkwing must reject iff |
| +// the oracle raises a Parser Error. Two known oracle imprecisions are |
| +// filtered rather than reported: mutants that mention the nested-SQL |
| +// functions (query, query_table, json_serialize_sql, ...) whose |
| +// bind-time inner parse also raises Parser Error, and oracle rejects |
| +// whose message is not a syntax error (bind-time ParserException raised |
| +// outside the parse pipeline — the corpus todo category). Oracle |
| +// timeouts and crashes leave a mutant unverified and are skipped. |
| +package main |
| + |
| +import ( |
| + "context" |
| + "errors" |
| + "flag" |
| + "fmt" |
| + "io/fs" |
| + "math/rand" |
| + "os" |
| + "path/filepath" |
| + "runtime" |
| + "strings" |
| + "sync" |
| + "sync/atomic" |
| + "time" |
| + |
| + "github.com/sqlc-dev/darkwing/internal/duckdbsrc" |
| + "github.com/sqlc-dev/darkwing/internal/testfile" |
| + "github.com/sqlc-dev/darkwing/lexer" |
| + "github.com/sqlc-dev/darkwing/parser" |
| + "github.com/sqlc-dev/darkwing/token" |
| +) |
| + |
| +func main() { |
| + n := flag.Int("n", 500, "number of mutants to test (ignored with -duration)") |
| + duration := flag.Duration("duration", 0, "run for this long instead of a fixed -n") |
| + seed := flag.Int64("seed", 1, "mutation RNG seed") |
| + jobs := flag.Int("jobs", runtime.NumCPU(), "concurrent oracle processes") |
| + corpusDir := flag.String("corpus", filepath.Join("parser", "testdata", "corpus"), "corpus directory for seed statements") |
| + maxPrint := flag.Int("max-print", 25, "max disagreements to print in detail") |
| + verbose := flag.Bool("v", false, "print every mutant tested") |
| + flag.Parse() |
| + |
| + bin, err := duckdbsrc.Find() |
| + if err != nil { |
| + fmt.Fprintln(os.Stderr, err) |
| + os.Exit(1) |
| + } |
| + seeds, err := loadSeeds(*corpusDir) |
| + if err != nil { |
| + fmt.Fprintln(os.Stderr, err) |
| + os.Exit(1) |
| + } |
| + if len(seeds) == 0 { |
| + fmt.Fprintf(os.Stderr, "no seed statements under %s (run cmd/regenerate first)\n", *corpusDir) |
| + os.Exit(1) |
| + } |
| + fmt.Printf("difftest: %d seeds, seed=%d, jobs=%d\n", len(seeds), *seed, *jobs) |
| + |
| + // one generator goroutine keeps mutation deterministic for a given |
| + // -seed; workers race only for oracle execution |
| + mutants := make(chan string, *jobs) |
| + go func() { |
| + defer close(mutants) |
| + rng := rand.New(rand.NewSource(*seed)) |
| + deadline := time.Time{} |
| + if *duration > 0 { |
| + deadline = time.Now().Add(*duration) |
| + } |
| + for i := 0; *duration > 0 || i < *n; i++ { |
| + if !deadline.IsZero() && time.Now().After(deadline) { |
| + return |
| + } |
| + mutants <- mutate(rng, seeds) |
| + } |
| + }() |
| + |
| + var ( |
| + mu sync.Mutex |
| + disagreements int |
| + tested atomic.Int64 |
| + unverified atomic.Int64 |
| + softSkipped atomic.Int64 |
| + ) |
| + var wg sync.WaitGroup |
| + for w := 0; w < *jobs; w++ { |
| + wg.Add(1) |
| + go func() { |
| + defer wg.Done() |
| + oracle := &duckdbsrc.Oracle{Binary: bin} |
| + for sql := range mutants { |
| + if nestedParseSQL(sql) || shellArtifact(sql) { |
| + softSkipped.Add(1) |
| + continue |
| + } |
| + verdict, err := oracle.Run(sql) |
| + if err != nil { |
| + fmt.Fprintf(os.Stderr, "oracle: %v\n", err) |
| + os.Exit(1) |
| + } |
| + if verdict.TimedOut || verdict.Crashed { |
| + unverified.Add(1) |
| + continue |
| + } |
| + got := classify(sql) |
| + if !verdict.Reject && got.reject && verdict.PostParseError && multiStatement(sql) { |
| + // the batch-mode CLI stops at the first failing |
| + // statement: a post-parse error on an earlier |
| + // statement leaves the rest unparsed, so the |
| + // oracle's accept does not cover darkwing's reject |
| + unverified.Add(1) |
| + continue |
| + } |
| + tested.Add(1) |
| + if *verbose { |
| + fmt.Printf("mutant: %q oracle-reject=%v darkwing-reject=%v\n", sql, verdict.Reject, got.reject) |
| + } |
| + if diff := compare(verdict, got); diff != "" { |
| + if verdict.Reject && !got.reject && !isSyntaxError(verdict.Error) { |
| + // bind-time ParserException outside the parse |
| + // pipeline: the corpus todo category, not a bug |
| + softSkipped.Add(1) |
| + continue |
| + } |
| + mu.Lock() |
| + disagreements++ |
| + if disagreements <= *maxPrint { |
| + fmt.Printf("DISAGREEMENT (%s)\nSQL: %s\noracle: %s\ndarkwing: %s\n\n", |
| + diff, sql, describe(verdict.Reject, verdict.Error), describe(got.reject, got.detail)) |
| + } |
| + mu.Unlock() |
| + } |
| + } |
| + }() |
| + } |
| + wg.Wait() |
| + |
| + fmt.Printf("tested %d mutants: %d disagreements (%d unverified, %d skipped as bind-time/nested-parse)\n", |
| + tested.Load(), disagreements, unverified.Load(), softSkipped.Load()) |
| + if disagreements > 0 { |
| + os.Exit(1) |
| + } |
| +} |
| + |
| +// loadSeeds collects every corpus statement that is not skip-listed — |
| +// including must-rejects, whose mutants probe the error paths. |
| +func loadSeeds(root string) ([]string, error) { |
| + var seeds []string |
| + err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error { |
| + if err != nil { |
| + return err |
| + } |
| + if d.IsDir() || !strings.HasSuffix(path, ".test") { |
| + return nil |
| + } |
| + file, err := testfile.Read(path) |
| + if err != nil { |
| + return err |
| + } |
| + meta, err := testfile.ReadMetadata(path) |
| + if err != nil { |
| + return err |
| + } |
| + for i := range file.Cases { |
| + c := &file.Cases[i] |
| + if _, skip := meta.Skip[c.Key()]; skip { |
| + continue |
| + } |
| + if _, ok := lexer.Tokenize(c.SQL); ok == nil { |
| + seeds = append(seeds, c.SQL) |
| + } |
| + } |
| + return nil |
| + }) |
| + return seeds, err |
| +} |
| + |
| +// verdict mirrors the corpus harness's classification: tokenizer, |
| +// matcher and transformer parse errors are rejects. |
| +type verdict struct { |
| + reject bool |
| + detail string |
| +} |
| + |
| +func classify(sql string) (v verdict) { |
| + defer func() { |
| + if r := recover(); r != nil { |
| + v = verdict{reject: false, detail: fmt.Sprintf("transformer panic: %v", r)} |
| + } |
| + }() |
| + _, err := parser.Parse(context.Background(), strings.NewReader(sql)) |
| + if err == nil { |
| + return verdict{} |
| + } |
| + var pe *parser.Error |
| + if errors.As(err, &pe) { |
| + return verdict{reject: true, detail: pe.Error()} |
| + } |
| + return verdict{reject: false, detail: "internal error: " + err.Error()} |
| +} |
| + |
| +func isSyntaxError(msg string) bool { |
| + return strings.HasPrefix(msg, "Parser Error: syntax error at or near") |
| +} |
| + |
| +// compare returns a non-empty disagreement kind when darkwing diverges |
| +// from the oracle on the mutant. |
| +func compare(oracle duckdbsrc.Verdict, got verdict) string { |
| + if !got.reject && got.detail != "" { |
| + return "internal error" |
| + } |
| + if oracle.Reject != got.reject { |
| + if oracle.Reject { |
| + return "oracle rejects, darkwing accepts" |
| + } |
| + return "darkwing rejects, oracle accepts" |
| + } |
| + // message fidelity: pinned only for syntax errors — a bind-time |
| + // oracle reject can coincide with a darkwing reject for a different |
| + // (legitimate) reason |
| + if oracle.Reject && isSyntaxError(oracle.Error) { |
| + // the oracle records the trimmed first line of a message; a token |
| + // spelling with an embedded newline (unterminated dollar quote) |
| + // spills across lines, so darkwing's line is trimmed to match |
| + firstLine, _, _ := strings.Cut(got.detail, "\n") |
| + if strings.TrimSpace(firstLine) != oracle.Error { |
| + return "message mismatch" |
| + } |
| + } |
| + return "" |
| +} |
| + |
| +func describe(reject bool, detail string) string { |
| + if !reject { |
| + if detail != "" { |
| + return "accept (" + detail + ")" |
| + } |
| + return "accept" |
| + } |
| + return "reject (" + detail + ")" |
| +} |
| + |
| +// shellArtifact reports mutants the CLI shell intercepts before the |
| +// parser sees them: a line starting with '#' in column 0 is a shell |
| +// comment (an indented '#' reaches the parser as an operator) and a |
| +// line starting with '.' is a dot command. |
| +func shellArtifact(sql string) bool { |
| + for _, line := range strings.Split(sql, "\n") { |
| + if strings.HasPrefix(line, "#") || strings.HasPrefix(line, ".") { |
| + return true |
| + } |
| + } |
| + return false |
| +} |
| + |
| +// multiStatement reports whether sql contains a statement separator with |
| +// content after it (a ';' inside a string or comment also matches — the |
| +// check only widens the unverified skip, never a reported disagreement). |
| +func multiStatement(sql string) bool { |
| + return strings.Contains(strings.TrimRight(sql, "; \t\r\n"), ";") |
| +} |
| + |
| +// nestedParseSQL reports statements that mention the functions whose |
| +// arguments the oracle parses as SQL at bind time — their Parser Errors |
| +// come from the inner parse the grammar never sees. |
| +func nestedParseSQL(sql string) bool { |
| + l := strings.ToLower(sql) |
| + for _, fn := range []string{"query", "query_table", "json_serialize_sql", "nextval", "currval"} { |
| + if strings.Contains(l, fn) { |
| + return true |
| + } |
| + } |
| + return false |
| +} |
| + |
| +// mutate produces one mutant from the seed pool. All mutations cut and |
| +// splice the original source at token span boundaries, preserving the |
| +// seed's exact spelling (strings, comments, whitespace). |
| +func mutate(rng *rand.Rand, seeds []string) string { |
| + src := seeds[rng.Intn(len(seeds))] |
| + toks := realTokens(src) |
| + if len(toks) == 0 { |
| + return src |
| + } |
| + switch rng.Intn(6) { |
| + case 0: // delete a token |
| + t := toks[rng.Intn(len(toks))] |
| + return src[:t.Span.Start] + src[t.Span.End:] |
| + case 1: // duplicate a token |
| + t := toks[rng.Intn(len(toks))] |
| + return src[:t.Span.End] + " " + src[t.Span.Start:t.Span.End] + src[t.Span.End:] |
| + case 2: // swap two adjacent tokens |
| + if len(toks) < 2 { |
| + return src |
| + } |
| + i := rng.Intn(len(toks) - 1) |
| + a, b := toks[i], toks[i+1] |
| + return src[:a.Span.Start] + src[b.Span.Start:b.Span.End] + src[a.Span.End:b.Span.Start] + |
| + src[a.Span.Start:a.Span.End] + src[b.Span.End:] |
| + case 3: // replace a token with one drawn from another seed |
| + t := toks[rng.Intn(len(toks))] |
| + other := seeds[rng.Intn(len(seeds))] |
| + otherToks := realTokens(other) |
| + if len(otherToks) == 0 { |
| + return src |
| + } |
| + o := otherToks[rng.Intn(len(otherToks))] |
| + return src[:t.Span.Start] + other[o.Span.Start:o.Span.End] + src[t.Span.End:] |
| + case 4: // truncate at a token boundary |
| + t := toks[rng.Intn(len(toks))] |
| + return src[:t.Span.Start] |
| + default: // splice a prefix of one seed onto a suffix of another |
| + other := seeds[rng.Intn(len(seeds))] |
| + otherToks := realTokens(other) |
| + if len(otherToks) == 0 { |
| + return src |
| + } |
| + t := toks[rng.Intn(len(toks))] |
| + o := otherToks[rng.Intn(len(otherToks))] |
| + return src[:t.Span.End] + " " + other[o.Span.Start:] |
| + } |
| +} |
| + |
| +// realTokens tokenizes src, drops the end-of-input sentinel, and clamps |
| +// spans to the source (dollar-quoted string tokens record the rewritten |
| +// literal's length, which can overrun the source extent). |
| +func realTokens(src string) []token.Token { |
| + toks, err := lexer.Tokenize(src) |
| + if err != nil { |
| + return nil |
| + } |
| + for len(toks) > 0 && toks[len(toks)-1].Kind == token.EndOfInput { |
| + toks = toks[:len(toks)-1] |
| + } |
| + for i := range toks { |
| + if toks[i].Span.End > len(src) { |
| + toks[i].Span.End = len(src) |
| + } |
| + } |
| + return toks |
| +} |
| |
| |
| |
| |
| @@ -11,6 +11,7 @@ import ( |
| "fmt" |
| "os" |
| "os/exec" |
| + "regexp" |
| "strings" |
| "time" |
| ) |
| @@ -79,6 +80,12 @@ type Verdict struct { |
| // Crashed records that the CLI died before printing a verdict; like |
| // TimedOut, the statement is unverified. |
| Crashed bool |
| + // PostParseError records that the CLI reported a non-parser error |
| + // (Binder Error, Catalog Error, ...). Still must-accept — but the |
| + // batch-mode CLI stops at the first failing statement, so for |
| + // multi-statement input everything after that statement went |
| + // unparsed and the accept verdict does not cover it. |
| + PostParseError bool |
| } |
| |
| // Oracle runs statements through the pinned CLI against :memory:. |
| @@ -126,6 +133,7 @@ func (o *Oracle) Run(sql string) (Verdict, error) { |
| // execution ran long: parsing succeeded |
| return Verdict{TimedOut: true}, nil |
| } |
| + postParse := hasPostParseError(stderr.String()) |
| if err != nil { |
| var exitErr *exec.ExitError |
| if errors.As(err, &exitErr) { |
| @@ -137,11 +145,30 @@ func (o *Oracle) Run(sql string) (Verdict, error) { |
| } |
| // plain error exit with a non-parser error on stderr: |
| // post-parse failure, must-accept |
| - return Verdict{}, nil |
| + return Verdict{PostParseError: postParse}, nil |
| } |
| return Verdict{}, fmt.Errorf("running oracle: %w", err) |
| } |
| - return Verdict{}, nil |
| + return Verdict{PostParseError: postParse}, nil |
| +} |
| + |
| +// errorLine matches the CLI's non-parser error headers ("Binder Error:", |
| +// "Catalog Error: ", "Invalid Input Error: ", ...). |
| +var errorLine = regexp.MustCompile(`^[A-Za-z][A-Za-z ]*Error: `) |
| + |
| +// hasPostParseError reports whether stderr carries a non-parser error |
| +// line. |
| +func hasPostParseError(stderr string) bool { |
| + for _, line := range strings.Split(stderr, "\n") { |
| + line = strings.TrimSpace(line) |
| + if strings.HasPrefix(line, "Parser Error") { |
| + continue |
| + } |
| + if errorLine.MatchString(line) { |
| + return true |
| + } |
| + } |
| + return false |
| } |
| |
| // classify scans CLI stderr for the first error line. Only "Parser Error" |
| |
| |
| |
| |
| @@ -17,7 +17,10 @@ type SyntaxError struct { |
| } |
| |
| func (e *SyntaxError) Error() string { |
| - return fmt.Sprintf("syntax error at or near %q", e.Token.Text) |
| + // the token's raw spelling goes between plain double quotes with no |
| + // escaping, exactly as upstream renders it (embedded quotes, |
| + // backslashes and newlines stay verbatim) |
| + return `syntax error at or near "` + e.Token.Text + `"` |
| } |
| |
| // MatchError is a non-positional matching error, mirroring the |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,112 @@ |
| +// Milestone 6 benchmarks: parse throughput on representative statements |
| +// and upstream's pathological-backtracking case. Upstream's motivating |
| +// packrat example — 19 unmatched '(' going from 10.6 s to 1 ms — is both |
| +// a benchmark and a regression test here. |
| +package parser |
| + |
| +import ( |
| + "context" |
| + "strings" |
| + "testing" |
| + |
| + "github.com/sqlc-dev/darkwing/lexer" |
| +) |
| + |
| +const benchSimpleSelect = "SELECT a, b + 1 FROM t WHERE c = 'x' ORDER BY a LIMIT 10" |
| + |
| +const benchComplexSelect = ` |
| +WITH sales AS ( |
| + SELECT region, product, amount, sold_at |
| + FROM raw_sales |
| + WHERE sold_at >= DATE '2024-01-01' |
| +), ranked AS ( |
| + SELECT region, product, |
| + sum(amount) AS total, |
| + rank() OVER (PARTITION BY region ORDER BY sum(amount) DESC) AS r |
| + FROM sales |
| + GROUP BY ALL |
| +) |
| +SELECT r.region, r.product, r.total, |
| + t.name AS region_name, |
| + CASE WHEN r.total > 1000 THEN 'big' ELSE 'small' END AS bucket |
| +FROM ranked r |
| +JOIN regions t ON r.region = t.id |
| +WHERE r.r <= 3 |
| +QUALIFY row_number() OVER (ORDER BY r.total DESC) <= 100 |
| +ORDER BY ALL` |
| + |
| +// benchMixed exercises the non-SELECT transformers. |
| +var benchMixed = []string{ |
| + "INSERT INTO t (a, b) VALUES (1, 'x'), (2, 'y') ON CONFLICT (a) DO UPDATE SET b = excluded.b RETURNING a", |
| + "UPDATE t SET b = b + 1 FROM u WHERE t.a = u.a", |
| + "DELETE FROM t USING u WHERE t.a = u.a RETURNING *", |
| + "CREATE TABLE IF NOT EXISTS t (a INTEGER PRIMARY KEY, b VARCHAR DEFAULT 'x', c STRUCT(x INT, y MAP(TEXT, DOUBLE[])))", |
| + "COPY t TO 'out.parquet' (FORMAT parquet, COMPRESSION zstd)", |
| + "PIVOT sales ON month IN (jan, feb) USING sum(amount) GROUP BY region", |
| + "SELECT * EXCLUDE (a) REPLACE (b + 1 AS b) FROM t USING SAMPLE 10%", |
| + "ATTACH 'other.db' AS other (READ_ONLY)", |
| + "PREPARE q AS SELECT * FROM t WHERE a = $1 AND b = $name", |
| +} |
| + |
| +func benchmarkParse(b *testing.B, sql string) { |
| + b.Helper() |
| + // prime the engine compile outside the timed loop |
| + if _, err := Parse(context.Background(), strings.NewReader(sql)); err != nil { |
| + b.Fatalf("Parse(%q): %v", sql, err) |
| + } |
| + b.SetBytes(int64(len(sql))) |
| + b.ReportAllocs() |
| + b.ResetTimer() |
| + for i := 0; i < b.N; i++ { |
| + if _, err := parseString(context.Background(), sql); err != nil { |
| + b.Fatal(err) |
| + } |
| + } |
| +} |
| + |
| +func BenchmarkParseSimpleSelect(b *testing.B) { benchmarkParse(b, benchSimpleSelect) } |
| +func BenchmarkParseComplexSelect(b *testing.B) { benchmarkParse(b, benchComplexSelect) } |
| + |
| +func BenchmarkParseMixed(b *testing.B) { |
| + all := strings.Join(benchMixed, ";\n") + ";" |
| + benchmarkParse(b, all) |
| +} |
| + |
| +func BenchmarkTokenize(b *testing.B) { |
| + b.SetBytes(int64(len(benchComplexSelect))) |
| + b.ReportAllocs() |
| + for i := 0; i < b.N; i++ { |
| + if _, err := lexer.Tokenize(benchComplexSelect); err != nil { |
| + b.Fatal(err) |
| + } |
| + } |
| +} |
| + |
| +// unmatchedParens is upstream's pathological backtracking input: without |
| +// packrat memoization each unmatched '(' multiplies the work (10.6 s at |
| +// 19 parens in upstream's pre-memoization measurement). |
| +func unmatchedParens(n int) string { |
| + return "SELECT " + strings.Repeat("(", n) + "1" |
| +} |
| + |
| +func BenchmarkUnmatchedParens19(b *testing.B) { |
| + sql := unmatchedParens(19) |
| + b.ReportAllocs() |
| + for i := 0; i < b.N; i++ { |
| + if _, err := parseString(context.Background(), sql); err == nil { |
| + b.Fatal("expected a syntax error") |
| + } |
| + } |
| +} |
| + |
| +// TestPathologicalBacktracking is the packrat regression gate: well past |
| +// upstream's 19-paren case must still fail fast. If memoization breaks, |
| +// this does not finish. |
| +func TestPathologicalBacktracking(t *testing.T) { |
| + for _, n := range []int{19, 40} { |
| + pe := rejectError(t, unmatchedParens(n)) |
| + if !strings.Contains(pe.Msg, "syntax error") { |
| + t.Errorf("unmatchedParens(%d): unexpected message %q", n, pe.Msg) |
| + } |
| + } |
| +} |
| |
| |
| |
| |
| @@ -97,7 +97,7 @@ func TestInsertOnConflict(t *testing.T) { |
| if ins.OnConflict == nil || ins.OnConflict.Action != ast.OnConflictReplace { |
| t.Errorf("OR REPLACE on-conflict = %#v", ins.OnConflict) |
| } |
| - if msg := parseErr(t, "INSERT OR REPLACE INTO t VALUES (1) ON CONFLICT DO NOTHING"); !strings.Contains(msg, "not compatible") { |
| + if msg := parseErr(t, "INSERT OR REPLACE INTO t VALUES (1) ON CONFLICT DO NOTHING"); !strings.Contains(msg, "can not provide both OR REPLACE|IGNORE") { |
| t.Errorf("shorthand+clause error = %q", msg) |
| } |
| } |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,197 @@ |
| +// Error message and position fidelity (milestone 6): darkwing's rendered |
| +// parse errors must match the pinned DuckDB build's. The corpus records |
| +// the first line of the oracle's message for every must-reject case; |
| +// TestCorpusErrorMessages holds darkwing to it exactly. Positions are not |
| +// recorded in the corpus (the CLI renders them as a LINE/caret display |
| +// below the first line), so TestErrorPositions pins them with hand-written |
| +// cases instead. |
| +package parser |
| + |
| +import ( |
| + "context" |
| + "errors" |
| + "strings" |
| + "testing" |
| + |
| + "github.com/sqlc-dev/darkwing/internal/testfile" |
| +) |
| + |
| +// rejectError parses sql and returns the *Error it must fail with. |
| +func rejectError(t *testing.T, sql string) *Error { |
| + t.Helper() |
| + _, err := Parse(context.Background(), strings.NewReader(sql)) |
| + if err == nil { |
| + t.Fatalf("Parse(%q): expected error", sql) |
| + } |
| + var pe *Error |
| + if !errors.As(err, &pe) { |
| + t.Fatalf("Parse(%q): got %T (%v), want *parser.Error", sql, err, err) |
| + } |
| + return pe |
| +} |
| + |
| +// TestCorpusErrorMessages is the negative-corpus message gate: for every |
| +// must-reject case, darkwing's error must render the oracle's recorded |
| +// first line verbatim. |
| +func TestCorpusErrorMessages(t *testing.T) { |
| + for _, path := range corpusFiles(t) { |
| + rel := strings.TrimPrefix(path, "testdata/") |
| + t.Run(rel, func(t *testing.T) { |
| + t.Parallel() |
| + file, err := testfile.Read(path) |
| + if err != nil { |
| + t.Fatal(err) |
| + } |
| + meta, err := testfile.ReadMetadata(path) |
| + if err != nil { |
| + t.Fatal(err) |
| + } |
| + for i := range file.Cases { |
| + c := &file.Cases[i] |
| + key := c.Key() |
| + if !c.Reject { |
| + continue |
| + } |
| + if _, skip := meta.Skip[key]; skip { |
| + continue |
| + } |
| + if _, todo := meta.Todo[key]; todo { |
| + continue |
| + } |
| + got := classify(nil, c.SQL) |
| + if !got.reject { |
| + // TestCorpus reports accept/reject disagreements |
| + continue |
| + } |
| + // the oracle records only the first line; darkwing's |
| + // multi-line messages (e.g. the PIVOT hints) match beyond it |
| + firstLine, _, _ := strings.Cut(got.detail, "\n") |
| + if firstLine != c.Error { |
| + t.Errorf("case %s: error message diverges from the oracle\nSQL: %s\nwant: %s\ngot: %s", |
| + key, c.SQL, c.Error, firstLine) |
| + } |
| + } |
| + }) |
| + } |
| +} |
| + |
| +// TestErrorPositions pins Offset/Line/Column on representative failures. |
| +// Column counts bytes from 1, as the pinned CLI's caret display does. |
| +func TestErrorPositions(t *testing.T) { |
| + tests := []struct { |
| + sql string |
| + msg string // rendered first line |
| + offset int |
| + line, col int |
| + }{ |
| + { |
| + // SELCT itself parses as a bare expression statement (a |
| + // column reference), so the failure lands on the 1 |
| + sql: "SELCT 1", |
| + msg: `Parser Error: syntax error at or near "1"`, |
| + offset: 6, line: 1, col: 7, |
| + }, |
| + { |
| + sql: "SELECT 1 2", |
| + msg: `Parser Error: syntax error at or near "2"`, |
| + offset: 9, line: 1, col: 10, |
| + }, |
| + { |
| + sql: "SELECT 1;\nSELCT 2;", |
| + msg: `Parser Error: syntax error at or near "2"`, |
| + offset: 16, line: 2, col: 7, |
| + }, |
| + { |
| + sql: "SELECT 1\nFROM t\nWHERE (", |
| + msg: `Parser Error: syntax error at or near "("`, |
| + offset: 22, line: 3, col: 7, |
| + }, |
| + { |
| + // whole-query UTF-8 validation, positioned at the bad byte |
| + sql: "SELECT\n 42\nFR\xffOM t;", |
| + msg: "Parser Error: Invalid UTF-8 in query (byte sequence mismatch)", |
| + offset: 14, line: 3, col: 3, |
| + }, |
| + { |
| + // a well-formed sequence encoding a surrogate is the other |
| + // UnicodeInvalidReason |
| + sql: "SELECT '\xed\xa0\x80'", |
| + msg: "Parser Error: Invalid UTF-8 in query (invalid unicode)", |
| + offset: 8, line: 1, col: 9, |
| + }, |
| + } |
| + for _, tt := range tests { |
| + pe := rejectError(t, tt.sql) |
| + firstLine, _, _ := strings.Cut(pe.Error(), "\n") |
| + if firstLine != tt.msg { |
| + t.Errorf("Parse(%q): message = %q, want %q", tt.sql, firstLine, tt.msg) |
| + } |
| + if pe.Offset != tt.offset || pe.Line != tt.line || pe.Column != tt.col { |
| + t.Errorf("Parse(%q): position = offset %d line %d col %d, want offset %d line %d col %d", |
| + tt.sql, pe.Offset, pe.Line, pe.Column, tt.offset, tt.line, tt.col) |
| + } |
| + } |
| +} |
| + |
| +// TestErrorMessages pins messages that only fire on inputs the corpus |
| +// does not cover. |
| +func TestErrorMessages(t *testing.T) { |
| + tests := []struct{ sql, msg string }{ |
| + // escape-literal UTF-8 classification: raw invalid byte vs |
| + // well-formed surrogate sequence |
| + {`SELECT e'\xFF'`, "Parser Error: Invalid UTF-8 in escape string literal at byte offset 0: byte mismatch"}, |
| + {`SELECT e'a\xed\xa0\x80'`, "Parser Error: Invalid UTF-8 in escape string literal at byte offset 1: invalid unicode"}, |
| + // KeywordHelper::WriteOptionallyQuoted quotes keywords and |
| + // non-plain identifiers, and leaves plain ones bare |
| + {"CREATE TABLE t (foo)", "Parser Error: Column foo must have a type or be defined as a GENERATED column."}, |
| + {"CREATE TABLE t (name)", `Parser Error: Column "name" must have a type or be defined as a GENERATED column.`}, |
| + {`CREATE TABLE t ("A b")`, `Parser Error: Column "A b" must have a type or be defined as a GENERATED column.`}, |
| + // upstream names the last offending RESET option |
| + {"ALTER TABLE t RESET (a='1', b='2')", `Parser Error: Reset option "b" cannot set any value. Did you mean to use SET?`}, |
| + {"ALTER TABLE t RESET (a='1', b)", `Parser Error: Reset option "a" cannot set any value. Did you mean to use SET?`}, |
| + // a deeper operand error beats the chained-comparison ban |
| + {"SELECT 1 < 2 < [3][]", "Parser Error: Empty subscript '[]' is not allowed"}, |
| + {"SELECT 1 < 2 < 3", "Parser Error: Chained comparisons are not supported, use AND to combine comparisons"}, |
| + // the offending token's raw spelling goes between plain quotes |
| + // with no escaping (found by cmd/difftest) |
| + {`TABLE ALTER "other name" RENAME`, `Parser Error: syntax error at or near ""other name""`}, |
| + {`SELECT E'\\' = '\' '\';`, `Parser Error: syntax error at or near "'\'"`}, |
| + } |
| + for _, tt := range tests { |
| + pe := rejectError(t, tt.sql) |
| + firstLine, _, _ := strings.Cut(pe.Error(), "\n") |
| + if firstLine != tt.msg { |
| + t.Errorf("Parse(%q): message = %q, want %q", tt.sql, firstLine, tt.msg) |
| + } |
| + } |
| +} |
| + |
| +// TestAnalyzeUTF8 pins the Utf8Proc::Analyze port's classification and |
| +// positions, including the deliberate divergence from the standard |
| +// library: overlong encodings pass. |
| +func TestAnalyzeUTF8(t *testing.T) { |
| + tests := []struct { |
| + in string |
| + reason utf8Reason |
| + pos int |
| + }{ |
| + {"", utf8Valid, -1}, |
| + {"plain ascii", utf8Valid, -1}, |
| + {"caf\xc3\xa9", utf8Valid, -1}, |
| + {"\xf0\x9f\xa6\x86", utf8Valid, -1}, // U+1F986 (duck) |
| + {"\xff", utf8ByteMismatch, 0}, |
| + {"a\x80", utf8ByteMismatch, 1}, // stray continuation byte |
| + {"a\xc3", utf8ByteMismatch, 1}, // truncated 2-byte sequence |
| + {"ab\xe0\xa0", utf8ByteMismatch, 2}, // truncated 3-byte sequence |
| + {"\xc3(", utf8ByteMismatch, 0}, // bad continuation byte |
| + {"\xed\xa0\x80", utf8InvalidUnicode, 0}, // surrogate U+D800 |
| + {"a\xf4\x90\x80\x80", utf8InvalidUnicode, 1}, // > U+10FFFF |
| + {"\xc0\xaf", utf8Valid, -1}, // overlong '/', accepted like upstream |
| + } |
| + for _, tt := range tests { |
| + reason, pos := analyzeUTF8(tt.in) |
| + if reason != tt.reason || pos != tt.pos { |
| + t.Errorf("analyzeUTF8(%q) = (%v, %d), want (%v, %d)", tt.in, reason, pos, tt.reason, tt.pos) |
| + } |
| + } |
| +} |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,125 @@ |
| +// Milestone 6 hardening: native fuzzing of the public Parse entry point |
| +// and a shared-engine parallel parse test (run under -race by the dev |
| +// loop and CI). |
| +package parser |
| + |
| +import ( |
| + "context" |
| + "errors" |
| + "strings" |
| + "sync" |
| + "testing" |
| + |
| + "github.com/sqlc-dev/darkwing/ast" |
| +) |
| + |
| +// checkParseInvariants parses src and enforces what Parse promises for |
| +// any input: no panic other than the controlled internal kinds, errors |
| +// are *parser.Error with sane positions, and on success the statement |
| +// spans tile the input. |
| +func checkParseInvariants(t *testing.T, src string) { |
| + t.Helper() |
| + stmts, err := Parse(context.Background(), strings.NewReader(src)) |
| + if err != nil { |
| + var pe *Error |
| + if !errors.As(err, &pe) { |
| + t.Fatalf("Parse(%q): error is %T (%v), want *parser.Error", src, err, err) |
| + } |
| + if pe.Offset < -1 || pe.Offset > len(src) { |
| + t.Fatalf("Parse(%q): error offset %d out of range", src, pe.Offset) |
| + } |
| + if pe.Line < 1 || pe.Column < 1 { |
| + t.Fatalf("Parse(%q): error position line %d col %d", src, pe.Line, pe.Column) |
| + } |
| + return |
| + } |
| + // spans tile the input: the first statement starts at 0, each next |
| + // one starts where the previous ended, the last ends at len(src) |
| + prev := 0 |
| + for i, stmt := range stmts { |
| + if stmt == nil { |
| + t.Fatalf("Parse(%q): statement %d is nil", src, i) |
| + } |
| + sp := ast.Span{Start: stmt.Pos(), End: stmt.End()} |
| + if sp.Start != prev { |
| + t.Fatalf("Parse(%q): statement %d starts at %d, want %d", src, i, sp.Start, prev) |
| + } |
| + if sp.End < sp.Start || sp.End > len(src) { |
| + t.Fatalf("Parse(%q): statement %d span [%d,%d) out of range", src, i, sp.Start, sp.End) |
| + } |
| + prev = sp.End |
| + } |
| + if len(stmts) > 0 && prev != len(src) { |
| + t.Fatalf("Parse(%q): last statement ends at %d, want %d", src, prev, len(src)) |
| + } |
| +} |
| + |
| +var fuzzSeeds = []string{ |
| + "", |
| + ";;", |
| + "SELECT 1", |
| + "SELECT * FROM t WHERE a = $1 AND b = ? AND c = $name", |
| + "FROM t SELECT x: a + 1", |
| + "WITH RECURSIVE c AS (SELECT 1) SELECT * FROM c UNION ALL BY NAME SELECT 2", |
| + "INSERT OR REPLACE INTO t BY NAME SELECT 1 RETURNING *", |
| + "CREATE TABLE t (a INT PRIMARY KEY, b STRUCT(x INT[], y MAP(TEXT, UNION(i INT, s TEXT))))", |
| + "PIVOT sales ON month USING sum(amount)", |
| + "SELECT [x + 1 FOR x IN [1,2,3] IF x > 1], l[1:3:2], r['k'], s.*.x", |
| + "SELECT interval '2 10' years to months", |
| + "SELECT e'\\x41\\n' || $tag$body$tag$ || 'lit''eral'", |
| + "SELECT $$'''$$", // rewritten literal longer than its source extent |
| + "SELECT a -> '$.b' ->> 'c' FROM j -- comment\n/* block /* nested */ */", |
| + "ATTACH 'f.db' AS d (READ_ONLY); USE d; SET threads = 4;", |
| + "SELECT (((((((1", |
| + "SELCT 1 2 3 (", |
| + "SELECT '\xff'", |
| + "select 1 = 1 = 1", |
| + "[1,2,3][];", |
| +} |
| + |
| +func FuzzParse(f *testing.F) { |
| + for _, seed := range fuzzSeeds { |
| + f.Add(seed) |
| + } |
| + f.Fuzz(func(t *testing.T, src string) { |
| + if len(src) > 1<<14 { |
| + // long adversarial inputs stress the matcher superlinearly; |
| + // throughput is covered by the benchmarks |
| + t.Skip() |
| + } |
| + checkParseInvariants(t, src) |
| + }) |
| +} |
| + |
| +// TestParseInvariantsOnSeeds keeps the fuzz seeds honest in ordinary |
| +// test runs (go test does not execute the fuzz engine). |
| +func TestParseInvariantsOnSeeds(t *testing.T) { |
| + for _, seed := range fuzzSeeds { |
| + checkParseInvariants(t, seed) |
| + } |
| +} |
| + |
| +// TestParallelParse hammers the shared engine from many goroutines — the |
| +// race-clean gate for the immutable compiled grammar and the per-call |
| +// packrat state (meaningful under -race, as the dev loop and CI run it). |
| +func TestParallelParse(t *testing.T) { |
| + inputs := append([]string(nil), fuzzSeeds...) |
| + inputs = append(inputs, benchComplexSelect, unmatchedParens(19)) |
| + var wg sync.WaitGroup |
| + for g := 0; g < 8; g++ { |
| + wg.Add(1) |
| + go func(g int) { |
| + defer wg.Done() |
| + for i := 0; i < 20; i++ { |
| + src := inputs[(g+i)%len(inputs)] |
| + _, err := Parse(context.Background(), strings.NewReader(src)) |
| + var pe *Error |
| + if err != nil && !errors.As(err, &pe) { |
| + t.Errorf("Parse(%q): unexpected error type %T", src, err) |
| + return |
| + } |
| + } |
| + }(g) |
| + } |
| + wg.Wait() |
| +} |
| |
| |
| |
| |
| @@ -469,3 +469,42 @@ func TestSequenceOptionChecks(t *testing.T) { |
| } |
| parseOne(t, "CREATE SEQUENCE s INCREMENT 2 MINVALUE 0 MAXVALUE 100 START 4 CYCLE") |
| } |
| + |
| +// TestCollateNames pins the collationName port: identifier chains join |
| +// with '.', constants render via Value::ToString, and anything else — |
| +// where upstream throws NotImplementedException at bind time — still |
| +// parses (found by cmd/difftest). |
| +func TestCollateNames(t *testing.T) { |
| + sel := func(sql string) *ast.CollateExpression { |
| + t.Helper() |
| + stmt := parseOne(t, sql).(*ast.SelectStatement) |
| + node := stmt.Node.(*ast.SelectNode) |
| + return node.SelectList[0].(*ast.CollateExpression) |
| + } |
| + for _, tt := range []struct{ sql, collation string }{ |
| + {"SELECT 'x' COLLATE nocase", "nocase"}, |
| + {"SELECT 'x' COLLATE a.b", "a.b"}, |
| + {"SELECT 'x' COLLATE 'lit'", "lit"}, |
| + {"SELECT 'x' COLLATE NULL", "NULL"}, |
| + {"SELECT 'x' COLLATE 3.5", "3.5"}, |
| + {"SELECT 'x' COLLATE true", "true"}, |
| + } { |
| + if c := sel(tt.sql); c.Collation != tt.collation { |
| + t.Errorf("%s: collation = %q, want %q", tt.sql, c.Collation, tt.collation) |
| + } |
| + } |
| + // upstream: NotImplementedException (post-parse), so these parse |
| + parseOne(t, "SELECT strpos('HELLO WORLD' COLLATE NOCASE 'o w')") |
| + parseOne(t, "SELECT 'x' COLLATE $1") |
| +} |
| + |
| +// TestUnconvertibleNumberLiterals: a number token whose text has no |
| +// value ("2.03.0") still parses — upstream throws InvalidInputException |
| +// only while constructing the value, which is post-parse under the |
| +// oracle's classification (found by cmd/difftest). |
| +func TestUnconvertibleNumberLiterals(t *testing.T) { |
| + parseOne(t, "SELECT 2.03.0") |
| + parseOne(t, "SELECT list_position([1.0,2.03.0,]::varchar[], 'a')") |
| + parseOne(t, "SELECT 12.5.5.5") |
| + parseOne(t, "SELECT 999999999999999999999999999999999999999999.1.1") |
| +} |
| |
| |
| |
| |
| @@ -67,6 +67,9 @@ func ParseExpr(ctx context.Context, sql string) (expr ast.Expr, err error) { |
| if err != nil { |
| return nil, err |
| } |
| + if ue := validateQueryUTF8(sql); ue != nil { |
| + return nil, ue |
| + } |
| tokens, err := lexer.Tokenize(sql) |
| if err != nil { |
| return nil, newError(sql, err) |
| @@ -92,6 +95,10 @@ func parseString(ctx context.Context, src string) (stmts []ast.Stmt, err error) |
| if err != nil { |
| return nil, err |
| } |
| + // the pinned build validates the whole query's UTF-8 before parsing |
| + if ue := validateQueryUTF8(src); ue != nil { |
| + return nil, ue |
| + } |
| tokens, err := lexer.Tokenize(src) |
| if err != nil { |
| return nil, newError(src, err) |
| @@ -148,12 +155,19 @@ func parseString(ctx context.Context, src string) (stmts []ast.Stmt, err error) |
| |
| // consumedEnd returns the byte offset just past the tokens consumed by |
| // the match from pos to newPos (excluding the end-of-input sentinel). |
| +// Dollar-quoted string tokens record the rewritten literal's length |
| +// rather than the source extent (upstream behavior, pinned by the |
| +// serialize goldens' query_location_length), so the end is clamped to |
| +// keep statement spans inside the input they promise to tile. |
| func consumedEnd(tokens []token.Token, pos, newPos, srcLen int) int { |
| for i := newPos - 1; i >= pos; i-- { |
| if tokens[i].Kind == token.EndOfInput { |
| continue |
| } |
| - return tokens[i].Span.End |
| + if end := tokens[i].Span.End; end < srcLen { |
| + return end |
| + } |
| + return srcLen |
| } |
| return srcLen |
| } |
| @@ -204,6 +218,12 @@ func newError(src string, err error) error { |
| default: |
| msg = err.Error() |
| } |
| + return errorAt(src, msg, offset) |
| +} |
| + |
| +// errorAt builds an *Error at a byte offset in src, deriving line and |
| +// column (offset -1 means no position). |
| +func errorAt(src, msg string, offset int) *Error { |
| pe := &Error{Msg: msg, Offset: offset, Line: 1, Column: 1} |
| if offset >= 0 { |
| line, col := 1, 1 |
| |
| deleted file mode 100644 |
| |
| |
| |
| @@ -1,5 +0,0 @@ |
| -{ |
| - "todo": { |
| - "07e88975ac7f20a0": "oracle's Parser Error comes from outside the parse pipeline (bind-time setting/function/constraint validation or nested SQL parsing); darkwing accepts by design - revisit with milestone 6 error-fidelity work" |
| - } |
| -} |
| |
| |
| |
| |
| @@ -68,7 +68,7 @@ func (tc *transformContext) transformCreate(n tnode) ast.Stmt { |
| base.Temporary = temporary |
| if base.OnConflict == "" || onConflict == ast.CreateReplace { |
| if base.OnConflict == ast.CreateIgnore && onConflict == ast.CreateReplace { |
| - raise("cannot combine OR REPLACE with IF NOT EXISTS") |
| + raise("Cannot specify both OR REPLACE and IF NOT EXISTS within single create statement") |
| } |
| if onConflict != ast.CreateError || base.OnConflict == "" { |
| if base.OnConflict == "" { |
| @@ -114,7 +114,7 @@ func (tc *transformContext) transformCreateTable(n tnode) ast.CreateInfo { |
| stmt := tc.transformStatement(def.child(4)) |
| sel, ok := stmt.(*ast.SelectStatement) |
| if !ok { |
| - raise("CREATE TABLE AS requires a SELECT statement") |
| + raise("CREATE TABLE AS requires a SELECT clause") |
| } |
| info.Query = sel |
| case "CreateColumnList": |
| @@ -164,7 +164,7 @@ func (tc *transformContext) transformColumnDefinition(n tnode) ast.ColumnDef { |
| } |
| } |
| if col.Type == nil && col.Generated == "" { |
| - raise("Column %s must have a type or be defined as a GENERATED column.", strings.Join(col.Names, ".")) |
| + raise("Column %s must have a type or be defined as a GENERATED column.", optionallyQuoted(strings.Join(col.Names, "."))) |
| } |
| if col.Generated != "" { |
| name := col.Names[len(col.Names)-1] |
| @@ -926,17 +926,22 @@ func (tc *transformContext) transformAlterTableOption(n tnode) ast.AlterInfo { |
| info := &ast.GenericAlterInfo{Kind: "RESET_OPTIONS"} |
| info.SetSpan(alt.span()) |
| // RESET (...) options cannot carry values (a bare NULL passes, |
| - // mirroring upstream's null-constant default) |
| + // mirroring upstream's null-constant default); upstream checks |
| + // the whole list and names the last offending option |
| + offender := "" |
| for _, o := range alt.child(1).parens().listElems() { |
| // RelOption <- RelOptionName RelOptionArgumentOpt? |
| if arg, ok := o.child(1).opt(); ok { |
| // RelOptionArgumentOpt <- '=' DefArg |
| _, def := arg.child(1).sole().choice() |
| if def.name() != "DefArgNull" { |
| - raise("Reset option \"%s\" cannot set any value. Did you mean to use SET?", relOptionName(o.child(0))) |
| + offender = relOptionName(o.child(0)) |
| } |
| } |
| } |
| + if offender != "" { |
| + raise("Reset option \"%s\" cannot set any value. Did you mean to use SET?", offender) |
| + } |
| return info |
| } |
| shapeError(alt, "unknown alter table option") |
| |
| |
| |
| |
| @@ -83,7 +83,7 @@ func (tc *transformContext) transformInsert(n tnode) ast.Stmt { |
| } |
| if oc, ok := n.child(8).opt(); ok { |
| if stmt.OnConflict != nil { |
| - raise("OR REPLACE|IGNORE is not compatible with ON CONFLICT") |
| + raise("You can not provide both OR REPLACE|IGNORE and an ON CONFLICT clause, please remove the first if you want to have more granular control") |
| } |
| stmt.OnConflict = tc.transformOnConflict(oc) |
| } |
| |
| |
| |
| |
| @@ -6,6 +6,8 @@ |
| package parser |
| |
| import ( |
| + "math/big" |
| + "strconv" |
| "strings" |
| |
| "github.com/sqlc-dev/darkwing/ast" |
| @@ -229,8 +231,13 @@ func (tc *transformContext) transformComparison(n tnode) ast.Expr { |
| return expr |
| } |
| if len(tails) > 1 { |
| - // upstream bans chained comparisons in the transformer |
| - raise("Chained comparisons (e.g. a < b < c) are not supported") |
| + // upstream bans chained comparisons in the transformer, but only |
| + // after transforming the operands - a deeper operand error (e.g. |
| + // an empty subscript) takes precedence over the chain ban |
| + for _, tail := range tails { |
| + tc.transformBetweenInLike(tail.child(2)) |
| + } |
| + raise("Chained comparisons are not supported, use AND to combine comparisons") |
| } |
| tail := tails[0] |
| _, opAlt := tail.child(0).sole().choice() |
| @@ -705,7 +712,7 @@ func (tc *transformContext) transformCollate(n tnode) ast.Expr { |
| expr := tc.transformAtTimeZone(n.child(0)) |
| for _, tail := range n.child(1).repeat() { |
| rhs := tc.transformAtTimeZone(tail.child(1)) |
| - collation := collationName(rhs) |
| + collation := tc.collationName(rhs) |
| c := &ast.CollateExpression{Child: expr, Collation: collation} |
| c.SetSpan(ast.Span{Start: n.span().Start, End: tail.span().End}) |
| expr = c |
| @@ -714,13 +721,78 @@ func (tc *transformContext) transformCollate(n tnode) ast.Expr { |
| } |
| |
| // collationName extracts the collation name from the right-hand |
| -// expression of COLLATE (a bare identifier chain). |
| -func collationName(e ast.Expr) string { |
| - ref, ok := e.(*ast.ColumnRefExpression) |
| - if !ok { |
| - raise("COLLATE expects a collation name") |
| +// expression of COLLATE: an identifier chain joined with '.', or a |
| +// constant rendered with Value::ToString semantics ('x' COLLATE 'nocase' |
| +// and even COLLATE 3 parse; the name fails lookup at bind time). For any |
| +// other expression upstream throws NotImplementedException ("Unexpected |
| +// expression encountered for collate, ...") — a post-parse error under |
| +// the oracle's classification — so darkwing accepts and records the |
| +// source spelling. |
| +func (tc *transformContext) collationName(e ast.Expr) string { |
| + switch v := e.(type) { |
| + case *ast.ColumnRefExpression: |
| + return strings.Join(v.ColumnNames, ".") |
| + case *ast.ConstantExpression: |
| + return valueString(v.Value) |
| + } |
| + return tc.exprSourceText(e) |
| +} |
| + |
| +// valueString ports Value::ToString for the constants the transformer |
| +// produces. |
| +func valueString(v ast.Value) string { |
| + if v.IsNull { |
| + return "NULL" |
| } |
| - return strings.Join(ref.ColumnNames, ".") |
| + switch v.Kind { |
| + case ast.ValueBool: |
| + if v.Bool { |
| + return "true" |
| + } |
| + return "false" |
| + case ast.ValueInt64: |
| + if v.Type.ID == "DECIMAL" { |
| + return decimalValueString(strconv.FormatInt(v.Int64, 10), v.Type.Scale) |
| + } |
| + return strconv.FormatInt(v.Int64, 10) |
| + case ast.ValueHugeint: |
| + s := hugeintString(v.Hugeint) |
| + if v.Type.ID == "DECIMAL" { |
| + return decimalValueString(s, v.Type.Scale) |
| + } |
| + return s |
| + case ast.ValueDouble: |
| + return strconv.FormatFloat(v.Float64, 'g', -1, 64) |
| + case ast.ValueString: |
| + return v.Str |
| + } |
| + return "" |
| +} |
| + |
| +// hugeintString renders the 128-bit integer in decimal. |
| +func hugeintString(h ast.Hugeint) string { |
| + n := new(big.Int).SetInt64(h.Upper) |
| + n.Lsh(n, 64) |
| + n.Add(n, new(big.Int).SetUint64(h.Lower)) |
| + return n.String() |
| +} |
| + |
| +// decimalValueString inserts the decimal point into an unscaled integer |
| +// rendering, Decimal::ToString-style ("35" scale 1 -> "3.5", "5" scale 2 |
| +// -> "0.05"). |
| +func decimalValueString(digits string, scale int) string { |
| + if scale <= 0 { |
| + return digits |
| + } |
| + sign := "" |
| + if strings.HasPrefix(digits, "-") { |
| + sign, digits = "-", digits[1:] |
| + } |
| + for len(digits) <= scale { |
| + digits = "0" + digits |
| + } |
| + cut := len(digits) - scale |
| + return sign + digits[:cut] + "." + digits[cut:] |
| } |
| |
| // AtTimeZoneExpression <- PrefixExpression AtTimeZoneExpressionTail* |
| @@ -954,7 +1026,7 @@ func (tc *transformContext) transformSlice(base ast.Expr, n tnode) ast.Expr { |
| endBound, hasEnd := bound.child(1).opt() |
| if !hasEnd { |
| if start == nil { |
| - raise("empty subscript is not allowed") |
| + raise("Empty subscript '[]' is not allowed") |
| } |
| return opExpr(sp, ast.ArrayExtract, base, start) |
| } |
| |
| |
| |
| |
| @@ -433,17 +433,18 @@ func (tc *transformContext) transformFrameClause(w *ast.WindowExpression, n tnod |
| case "BetweenFrameExtent": |
| start, startExpr := tc.transformFrameBound(extent.child(1), kind, true) |
| end, endExpr := tc.transformFrameBound(extent.child(3), kind, false) |
| - if end == ast.WindowUnboundedPreceding { |
| - raise("Frame end cannot be UNBOUNDED PRECEDING") |
| - } |
| w.FrameStart, w.StartExpr = start, startExpr |
| w.FrameEnd, w.EndExpr = end, endExpr |
| default: |
| shapeError(extent, "unknown frame extent") |
| } |
| + // upstream validates the start bound before the end bound |
| if w.FrameStart == ast.WindowUnboundedFollowing { |
| raise("Frame start cannot be UNBOUNDED FOLLOWING") |
| } |
| + if w.FrameEnd == ast.WindowUnboundedPreceding { |
| + raise("Frame end cannot be UNBOUNDED PRECEDING") |
| + } |
| if excl, ok := n.child(2).opt(); ok { |
| _, e := excl.child(1).sole().choice() |
| switch e.name() { |
| @@ -1004,6 +1005,18 @@ var intervalFuncs = map[string]string{ |
| "MillenniumKeyword": "to_millennia", |
| } |
| |
| +// intervalRangeSpecifiers spells the IntervalToInterval alternatives the |
| +// way upstream's error message does. |
| +var intervalRangeSpecifiers = map[string]string{ |
| + "YearToMonth": "YEAR TO MONTH", |
| + "DayToHour": "DAY TO HOUR", |
| + "DayToMinute": "DAY TO MINUTE", |
| + "DayToSecond": "DAY TO SECOND", |
| + "HourToMinute": "HOUR TO MINUTE", |
| + "HourToSecond": "HOUR TO SECOND", |
| + "MinuteToSecond": "MINUTE TO SECOND", |
| +} |
| + |
| // IntervalLiteral <- 'INTERVAL' IntervalParameter Interval? |
| func (tc *transformContext) transformIntervalLiteral(n tnode) ast.Expr { |
| sp := n.span() |
| @@ -1031,7 +1044,12 @@ func (tc *transformContext) transformIntervalLiteral(n tnode) ast.Expr { |
| } |
| _, unit := unitNode.sole().choice() |
| if unit.name() == "IntervalToInterval" { |
| - raise("interval range specifiers (e.g. YEAR TO MONTH) are not supported in interval literals") |
| + _, r := unit.sole().choice() |
| + spec, ok := intervalRangeSpecifiers[r.name()] |
| + if !ok { |
| + shapeError(r, "unknown interval range specifier") |
| + } |
| + raise("%s is not supported", spec) |
| } |
| fname, ok := intervalFuncs[unit.name()] |
| if !ok { |
| |
| |
| |
| |
| @@ -22,6 +22,7 @@ import ( |
| "strings" |
| |
| "github.com/sqlc-dev/darkwing/ast" |
| + "github.com/sqlc-dev/darkwing/token" |
| ) |
| |
| func init() { |
| @@ -753,6 +754,28 @@ func (tc *transformContext) transformComment(n tnode) ast.Stmt { |
| return stmt |
| } |
| |
| +// optionallyQuoted renders an identifier for an error message the way |
| +// upstream's KeywordHelper::WriteOptionallyQuoted does: wrapped in double |
| +// quotes (embedded quotes doubled) when it is empty, is a keyword, or is |
| +// not a plain lowercase identifier. |
| +func optionallyQuoted(s string) string { |
| + needs := s == "" || token.IsKeyword(s) |
| + for i := 0; i < len(s) && !needs; i++ { |
| + c := s[i] |
| + switch { |
| + case c >= 'a' && c <= 'z' || c == '_': |
| + case c >= '0' && c <= '9': |
| + needs = i == 0 |
| + default: |
| + needs = true |
| + } |
| + } |
| + if !needs { |
| + return s |
| + } |
| + return `"` + strings.ReplaceAll(s, `"`, `""`) + `"` |
| +} |
| + |
| // qualifiedNameFromParts splits a dotted path into catalog/schema/name, |
| // mirroring upstream's QualifiedName::StringToQualifiedName. |
| func qualifiedNameFromParts(parts []string) (catalog, schema, name string) { |
| @@ -764,7 +787,7 @@ func qualifiedNameFromParts(parts []string) (catalog, schema, name string) { |
| case 3: |
| return parts[0], parts[1], parts[2] |
| } |
| - raise("Too many qualifications for name \"%s\"", strings.Join(parts, ".")) |
| + raise("Too many qualifications found - expected [catalog.schema.name] or [schema.name]") |
| return "", "", "" |
| } |
| |
| |
| |
| |
| |
| @@ -6,10 +6,10 @@ package parser |
| |
| import ( |
| "errors" |
| + "fmt" |
| "math" |
| "strconv" |
| "strings" |
| - "unicode/utf8" |
| |
| "github.com/sqlc-dev/darkwing/ast" |
| "github.com/sqlc-dev/darkwing/internal/matcher" |
| @@ -191,9 +191,12 @@ func (tc *transformContext) stringConstant(sp ast.Span, s string, kind matcher.S |
| if strings.IndexByte(unescaped, 0) >= 0 { |
| raise("Null character not permitted in escape string literal") |
| } |
| - if !utf8.ValidString(unescaped) { |
| - raise("Invalid UTF-8 in escape string literal at byte offset %d: invalid unicode codepoint", |
| - invalidUTF8Offset(unescaped)) |
| + if reason, off := analyzeUTF8(unescaped); reason != utf8Valid { |
| + kind := "byte mismatch" |
| + if reason == utf8InvalidUnicode { |
| + kind = "invalid unicode" |
| + } |
| + raise("Invalid UTF-8 in escape string literal at byte offset %d: %s", off, kind) |
| } |
| return constExpr(sp, varcharValue(unescaped)) |
| default: |
| @@ -250,19 +253,6 @@ func unescapeString(s string) string { |
| return sb.String() |
| } |
| |
| -// invalidUTF8Offset finds the first invalid byte offset of a non-UTF-8 |
| -// string (for the escape-literal error message). |
| -func invalidUTF8Offset(s string) int { |
| - for i := 0; i < len(s); { |
| - r, size := utf8.DecodeRuneInString(s[i:]) |
| - if r == utf8.RuneError && size == 1 { |
| - return i |
| - } |
| - i += size |
| - } |
| - return len(s) |
| -} |
| - |
| func isHexDigit(c byte) bool { |
| return c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F' |
| } |
| @@ -306,13 +296,26 @@ func integerTypeFor(v int64) string { |
| // INTEGER/BIGINT/HUGEINT (then DOUBLE), plain decimals become DECIMAL |
| // with derived width/scale (up to width 38), exponent forms become |
| // DOUBLE. |
| +// unconvertibleNumber stands in for a number literal whose text has no |
| +// value (e.g. "2.03.0", tokenized as a single number): upstream accepts |
| +// the token and throws InvalidInputException while constructing the |
| +// value ("Could not convert string ... to DECIMAL(5,1)") — post-parse |
| +// under the oracle's classification — so darkwing records the raw text |
| +// as a cast to the derived type and accepts (found by cmd/difftest). |
| +func unconvertibleNumber(sp ast.Span, text, typeID string) ast.Expr { |
| + child := constExpr(invalidSpan, varcharValue(text)) |
| + cast := &ast.CastExpression{Child: child, ResolvedType: typeID} |
| + cast.SetSpan(sp) |
| + return cast |
| +} |
| + |
| func numberConstant(sp ast.Span, text string) ast.Expr { |
| clean := strings.ReplaceAll(text, "_", "") |
| lower := strings.ToLower(clean) |
| if strings.ContainsAny(lower, "e") { |
| f, err := parseDouble(clean) |
| if err != nil { |
| - raise("invalid number literal \"%s\"", text) |
| + return unconvertibleNumber(sp, clean, "DOUBLE") |
| } |
| return constExpr(sp, ast.Value{Type: ast.LogicalType{ID: "DOUBLE"}, Kind: ast.ValueDouble, Float64: f}) |
| } |
| @@ -331,7 +334,7 @@ func numberConstant(sp ast.Span, text string) ast.Expr { |
| } |
| f, err := parseDouble(clean) |
| if err != nil { |
| - raise("invalid number literal \"%s\"", text) |
| + return unconvertibleNumber(sp, clean, "DOUBLE") |
| } |
| return constExpr(sp, ast.Value{Type: ast.LogicalType{ID: "DOUBLE"}, Kind: ast.ValueDouble, Float64: f}) |
| } |
| @@ -362,7 +365,7 @@ func decimalConstant(sp ast.Span, clean string, dot int) ast.Expr { |
| if width > 38 { |
| f, err := parseDouble(clean) |
| if err != nil { |
| - raise("invalid number literal \"%s\"", clean) |
| + return unconvertibleNumber(sp, clean, "DOUBLE") |
| } |
| return constExpr(sp, ast.Value{Type: ast.LogicalType{ID: "DOUBLE"}, Kind: ast.ValueDouble, Float64: f}) |
| } |
| @@ -376,7 +379,7 @@ func decimalConstant(sp ast.Span, clean string, dot int) ast.Expr { |
| } |
| h, ok := parseHugeint(unscaled) |
| if !ok { |
| - raise("invalid number literal \"%s\"", clean) |
| + return unconvertibleNumber(sp, clean, fmt.Sprintf("DECIMAL(%d,%d)", width, scale)) |
| } |
| return constExpr(sp, ast.Value{Type: typ, Kind: ast.ValueHugeint, Hugeint: h}) |
| } |
| |
| |
| |
| |
| @@ -511,8 +511,8 @@ func (tc *transformContext) transformNearestJoin(left ast.TableRef, n tnode) ast |
| } |
| if num, ok := alt.child(5).opt(); ok { |
| v, err := strconv.ParseInt(num.number(), 10, 64) |
| - if err != nil { |
| - raise("invalid NEAREST count") |
| + if err != nil || v <= 0 { |
| + raise("NEAREST expects a positive integer literal, got \"%s\"", num.number()) |
| } |
| join.NearestCount = v |
| } |
| @@ -795,7 +795,7 @@ func (tc *transformContext) transformPivotStatement(n tnode) ast.QueryNode { |
| raise("Cannot pivot on constant value \"%s\"", constantText(e)) |
| } |
| if hasSubquery(e) { |
| - raise("Cannot pivot on subquery \"%s\"", constantText(e)) |
| + raise("Cannot pivot on subquery \"%s\"", tc.exprSourceText(e)) |
| } |
| } |
| } |
| @@ -898,6 +898,18 @@ func constantText(e ast.Expr) string { |
| return "?" |
| } |
| |
| +// exprSourceText renders an expression for an error message by slicing |
| +// the original source at its span — a best-effort stand-in for upstream's |
| +// ToString renderer, which darkwing does not have. Falls back to |
| +// constantText when the span is invalid. |
| +func (tc *transformContext) exprSourceText(e ast.Expr) string { |
| + start, end := e.Pos(), e.End() |
| + if start >= 0 && start < end && end <= len(tc.src) { |
| + return tc.src[start:end] |
| + } |
| + return constantText(e) |
| +} |
| + |
| // PivotColumnEntry <- PivotColumnSubquery / PivotValueList / PivotColumnExpression |
| func (tc *transformContext) transformPivotColumnEntry(n tnode) ast.PivotColumn { |
| _, alt := n.sole().choice() |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,69 @@ |
| +package parser |
| + |
| +// utf8Reason classifies why a byte string is not valid UTF-8 — the port |
| +// of upstream's UnicodeInvalidReason. |
| +type utf8Reason int |
| + |
| +const ( |
| + utf8Valid utf8Reason = iota |
| + // utf8ByteMismatch is a malformed byte sequence (bad start byte or |
| + // missing/invalid continuation byte). |
| + utf8ByteMismatch |
| + // utf8InvalidUnicode is a well-formed sequence encoding an invalid |
| + // codepoint (surrogate or beyond U+10FFFF). |
| + utf8InvalidUnicode |
| +) |
| + |
| +// analyzeUTF8 walks s the way upstream's Utf8Proc::Analyze does and |
| +// returns the first invalid sequence's classification and start offset |
| +// (utf8Valid and -1 when the whole string is valid). Unlike the standard |
| +// library's utf8.ValidString it accepts overlong encodings, matching the |
| +// pinned build's effective behavior. |
| +func analyzeUTF8(s string) (utf8Reason, int) { |
| + for i := 0; i < len(s); { |
| + c := s[i] |
| + if c&0x80 == 0 { |
| + i++ |
| + continue |
| + } |
| + start := i |
| + var cont int |
| + var cp int32 |
| + switch { |
| + case c&0xE0 == 0xC0: |
| + cont, cp = 1, int32(c&0x1F) |
| + case c&0xF0 == 0xE0: |
| + cont, cp = 2, int32(c&0x0F) |
| + case c&0xF8 == 0xF0: |
| + cont, cp = 3, int32(c&0x07) |
| + default: |
| + return utf8ByteMismatch, start |
| + } |
| + i++ |
| + for j := 0; j < cont; j++ { |
| + if i >= len(s) || s[i]&0xC0 != 0x80 { |
| + return utf8ByteMismatch, start |
| + } |
| + cp = cp<<6 | int32(s[i]&0x3F) |
| + i++ |
| + } |
| + if cp > 0x10FFFF || (cp >= 0xD800 && cp <= 0xDFFF) { |
| + return utf8InvalidUnicode, start |
| + } |
| + } |
| + return utf8Valid, -1 |
| +} |
| + |
| +// validateQueryUTF8 raises the pinned build's whole-query UTF-8 error |
| +// when src is not valid UTF-8, positioned at the invalid sequence. |
| +func validateQueryUTF8(src string) *Error { |
| + reason, off := analyzeUTF8(src) |
| + if reason == utf8Valid { |
| + return nil |
| + } |
| + kind := "byte sequence mismatch" |
| + if reason == utf8InvalidUnicode { |
| + kind = "invalid unicode" |
| + } |
| + return errorAt(src, "Invalid UTF-8 in query ("+kind+")", off) |
| +} |
|
|
