Prepare @questdb/sql-parser for 0.1.0 publish

- Rename package from @questdb/questdb-sql-parser to @questdb/sql-parser
- Fix parseToAst() silent swallow and _semicolonBoundedRecovery state leak
- Use single quotes for identifier escaping (QuestDB convention)
- Improve autocomplete: string literal suppression, SELECT FROM fallback,
  CTE performance threshold (150 tokens)
- Remove unsupported SQL: NATURAL JOIN, GROUPS frame mode, EXCLUDE GROUPS
- Reorganize review-proofs tests into parser/lexer/autocomplete test files

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: emrberk

README.md

@@ -1,4 +1,4 @@
-# @questdb/questdb-sql-parser
+# @questdb/sql-parser
 
 A production-ready SQL parser for [QuestDB](https://questdb.io/) syntax, built with [Chevrotain](https://chevrotain.io/). Parses SQL into a fully typed AST, converts AST back to SQL, and provides context-aware autocomplete — all in a single package.
 
@@ -17,7 +17,7 @@ A production-ready SQL parser for [QuestDB](https://questdb.io/) syntax, built w
 ### Parse SQL to AST
 
 ```typescript
-import { parseToAst } from "@questdb/questdb-sql-parser";
+import { parseToAst } from "@questdb/sql-parser";
 
 const result = parseToAst("SELECT * FROM trades WHERE symbol = 'BTC-USD'");
 
@@ -39,7 +39,7 @@ if (result.errors.length === 0) {
 ### Convert AST back to SQL
 
 ```typescript
-import { parseToAst, toSql } from "@questdb/questdb-sql-parser";
+import { parseToAst, toSql } from "@questdb/sql-parser";
 
 const result = parseToAst("SELECT avg(price) FROM trades SAMPLE BY 1h FILL(PREV)");
 const sql = toSql(result.ast);
@@ -49,7 +49,7 @@ const sql = toSql(result.ast);
 ### Parse a single statement
 
 ```typescript
-import { parseOne } from "@questdb/questdb-sql-parser";
+import { parseOne } from "@questdb/sql-parser";
 
 const stmt = parseOne("INSERT INTO trades VALUES (now(), 'BTC', 42000.50)");
 console.log(stmt.type); // "insert"
@@ -58,7 +58,7 @@ console.log(stmt.type); // "insert"
 ### Parse multiple statements
 
 ```typescript
-import { parseStatements } from "@questdb/questdb-sql-parser";
+import { parseStatements } from "@questdb/sql-parser";
 
 const statements = parseStatements(`
   SELECT * FROM trades
@@ -72,7 +72,7 @@ console.log(statements.length); // 3
 ### Autocomplete
 
 ```typescript
-import { createAutocompleteProvider } from "@questdb/questdb-sql-parser";
+import { createAutocompleteProvider } from "@questdb/sql-parser";
 
 const provider = createAutocompleteProvider({
   tables: [
@@ -204,7 +204,7 @@ The parser uses Chevrotain's [CST pattern](https://chevrotain.io/docs/guide/conc
 Arrays of keywords, functions, data types, operators, and constants for syntax highlighting integration:
 
 ```typescript
-import { keywords, functions, dataTypes, operators, constants } from "@questdb/questdb-sql-parser/grammar";
+import { keywords, functions, dataTypes, operators, constants } from "@questdb/sql-parser/grammar";
 ```
 
 ## Development

package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@questdb/questdb-sql-parser",
+  "name": "@questdb/sql-parser",
   "version": "0.1.0",
   "description": "SQL parser for QuestDB syntax using Chevrotain",
   "type": "module",
@@ -59,11 +59,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/questdb/questdb-sql-parser.git"
+    "url": "https://github.com/questdb/sql-parser.git"
   },
-  "homepage": "https://questdb.com",
+  "homepage": "https://github.com/questdb/sql-parser",
   "bugs": {
-    "url": "https://github.com/questdb/questdb-sql-parser/issues"
+    "url": "https://github.com/questdb/sql-parser/issues"
   },
   "license": "Apache-2.0",
   "dependencies": {

src/autocomplete/content-assist.ts

@@ -1,10 +1,52 @@
 import { type ILexingError, IToken, TokenType } from "chevrotain"
 import { parser, parse as parseRaw } from "../parser/parser"
 import { visitor } from "../parser/visitor"
-import { QuestDBLexer } from "../parser/lexer"
+import { QuestDBLexer, IdentifierKeyword } from "../parser/lexer"
 import type { Statement } from "../parser/ast"
 import { IDENTIFIER_KEYWORD_TOKENS } from "./token-classification"
 
+// =============================================================================
+// Constants
+// =============================================================================
+
+/**
+ * When the token count exceeds this threshold, skip Chevrotain's
+ * computeContentAssist (which is exponential on deeply nested CTEs)
+ * and return IdentifierKeyword to trigger table/column suggestions.
+ */
+const CONTENT_ASSIST_TOKEN_LIMIT = 150
+
+const WORD_BOUNDARY_CHARS = new Set([
+  " ",
+  "\n",
+  "\t",
+  "\r",
+  "(",
+  ")",
+  ",",
+  ";",
+  ".",
+  "=",
+  "<",
+  ">",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "'",
+  '"',
+  "|",
+  "&",
+  "^",
+  "~",
+  "!",
+  "@",
+  ":",
+  "[",
+  "]",
+])
+
 // =============================================================================
 // Types
 // =============================================================================
@@ -315,6 +357,13 @@ function collapseTrailingQualifiedRef(tokens: IToken[]): IToken[] | null {
  * from all WITH-capable statement types.
  */
 function computeSuggestions(tokens: IToken[]): TokenType[] {
+  // For large token sequences (deeply nested CTEs), Chevrotain's
+  // computeContentAssist becomes exponentially slow. Fall back to a
+  // generic set of suggestions to avoid freezing the editor.
+  if (tokens.length > CONTENT_ASSIST_TOKEN_LIMIT) {
+    return [IdentifierKeyword]
+  }
+
   const ruleName = tokens.some((t) => t.tokenType.name === "Semicolon")
     ? "statements"
     : "statement"
@@ -428,6 +477,26 @@ export function getContentAssist(
   fullSql: string,
   cursorOffset: number,
 ): ContentAssistResult {
+  // Tokenize the full SQL to check if the cursor is inside a string literal.
+  // If so, suppress suggestions — the user is editing a value, not SQL syntax.
+  // This also covers single-quoted identifiers (FROM 'table'), which is an
+  // acceptable trade-off to avoid fragile context-detection heuristics.
+  const fullTokens = QuestDBLexer.tokenize(fullSql).tokens
+  for (const token of fullTokens) {
+    if (token.tokenType.name !== "StringLiteral") continue
+    const start = token.startOffset
+    const end = token.startOffset + token.image.length
+    if (cursorOffset > start && cursorOffset < end) {
+      return {
+        nextTokenTypes: [],
+        tablesInScope: [],
+        tokensBefore: [],
+        isMidWord: true,
+        lexErrors: [],
+      }
+    }
+  }
+
   // Split the text at cursor position
   const beforeCursor = fullSql.substring(0, cursorOffset)
 
@@ -444,36 +513,6 @@ export function getContentAssist(
     cursorOffset > 0 && cursorOffset <= fullSql.length
       ? fullSql[cursorOffset - 1]
       : " "
-  const WORD_BOUNDARY_CHARS = new Set([
-    " ",
-    "\n",
-    "\t",
-    "\r",
-    "(",
-    ")",
-    ",",
-    ";",
-    ".",
-    "=",
-    "<",
-    ">",
-    "+",
-    "-",
-    "*",
-    "/",
-    "%",
-    "'",
-    '"',
-    "|",
-    "&",
-    "^",
-    "~",
-    "!",
-    "@",
-    ":",
-    "[",
-    "]",
-  ])
   const isMidWord = !WORD_BOUNDARY_CHARS.has(lastChar)
   const tokensForAssist =
     isMidWord && tokens.length > 0 ? tokens.slice(0, -1) : tokens
@@ -487,8 +526,7 @@ export function getContentAssist(
     // This can happen with malformed input
   }
 
-  // Extract tables from the full query
-  const fullTokens = QuestDBLexer.tokenize(fullSql).tokens
+  // Extract tables from the full query (reuses fullTokens from above)
   const tablesInScope = extractTables(fullSql, fullTokens)
 
   if (tablesInScope.length === 0) {

src/autocomplete/provider.ts

@@ -23,6 +23,7 @@ import { getContentAssist } from "./content-assist"
 import { buildSuggestions } from "./suggestion-builder"
 import { shouldSkipToken } from "./token-classification"
 import type { AutocompleteProvider, SchemaInfo, Suggestion } from "./types"
+import { SuggestionKind, SuggestionPriority } from "./types"
 
 const TABLE_NAME_TOKENS = new Set([
   "From",
@@ -129,6 +130,27 @@ export function createAutocompleteProvider(
         )
       }
 
+      // Fallback: when Chevrotain returns no suggestions (malformed SQL like
+      // "SELECT FROM |" where columns are missing), check if the cursor follows
+      // a table-introducing keyword. If so, suggest table names directly.
+      const fallbackTokens =
+        isMidWord && tokensBefore.length > 0
+          ? tokensBefore.slice(0, -1)
+          : tokensBefore
+      const [lastFallback] = getLastSignificantTokens(fallbackTokens)
+      if (lastFallback && TABLE_NAME_TOKENS.has(lastFallback)) {
+        const suggestions: Suggestion[] = []
+        for (const table of normalizedSchema.tables) {
+          suggestions.push({
+            label: table.name,
+            kind: SuggestionKind.Table,
+            insertText: table.name,
+            priority: SuggestionPriority.MediumLow,
+          })
+        }
+        return suggestions
+      }
+
       return []
     },
   }

src/grammar/keywords.ts

@@ -106,7 +106,6 @@ export const keywords: string[] = [
   "lt",
   "materialized",
   "maxUncommittedRows",
-  "natural",
   "no",
   "nocache",
   "not",

src/index.ts

@@ -87,14 +87,16 @@ export function parseToAst(sql: string): ParseResult {
   }
 
   let ast: Statement[] = []
-  try {
+  if (errors.length > 0) {
+    try {
+      ast = visitor.visit(cst) as Statement[]
+    } catch {
+      // The visitor may throw on incomplete CST nodes produced by error recovery
+      // (e.g. "Unknown primary expression", null dereferences on missing children).
+      // Since we already have parse errors, return them with whatever AST was built.
+    }
+  } else {
     ast = visitor.visit(cst) as Statement[]
-  } catch {
-    // The visitor throws on incomplete CST nodes produced by error recovery
-    // (e.g. "Unknown primary expression", null dereferences on missing children).
-    // Rather than making every visitor method resilient to partial CSTs, we catch
-    // here and return whatever AST was successfully built, along with the parse
-    // errors that already describe what went wrong.
   }
 
   return { ast, errors }

src/parser/ast.ts

@@ -959,10 +959,10 @@ export interface WindowSpecification extends AstNode {
 
 export interface WindowFrame extends AstNode {
   type: "windowFrame"
-  mode: "rows" | "range" | "groups" | "cumulative"
+  mode: "rows" | "range" | "cumulative"
   start?: WindowFrameBound
   end?: WindowFrameBound
-  exclude?: "currentRow" | "noOthers" | "groups"
+  exclude?: "currentRow" | "noOthers"
 }
 
 export interface WindowFrameBound extends AstNode {

src/parser/cst-types.d.ts

@@ -252,7 +252,6 @@ export type JoinClauseCstChildren = {
   Lt?: IToken[];
   Splice?: IToken[];
   Window?: IToken[];
-  Natural?: IToken[];
   Prevailing?: (IToken)[];
   Outer?: IToken[];
   Join: IToken[];
@@ -2146,7 +2145,6 @@ export interface WindowFrameClauseCstNode extends CstNode {
 export type WindowFrameClauseCstChildren = {
   Rows?: IToken[];
   Range?: IToken[];
-  Groups?: (IToken)[];
   Cumulative?: IToken[];
   Between?: IToken[];
   windowFrameBound?: (WindowFrameBoundCstNode)[];

src/parser/lexer.ts

@@ -152,7 +152,6 @@ import {
   NaN,
   Nanosecond,
   Nanoseconds,
-  Natural,
   No,
   Nocache,
   None,
@@ -432,7 +431,6 @@ export {
   NaN,
   Nanosecond,
   Nanoseconds,
-  Natural,
   No,
   Nocache,
   None,

src/parser/parser.ts

@@ -300,7 +300,6 @@ import {
   Exclude,
   Cumulative,
   Others,
-  Natural,
   Database,
   Backup,
   Prevailing,
@@ -417,8 +416,11 @@ class QuestDBParser extends CstParser {
   public statements = this.RULE("statements", () => {
     this.MANY(() => {
       this._semicolonBoundedRecovery = true
-      this.SUBRULE(this.statement)
-      this._semicolonBoundedRecovery = false
+      try {
+        this.SUBRULE(this.statement)
+      } finally {
+        this._semicolonBoundedRecovery = false
+      }
       this.OPTION(() => this.CONSUME(Semicolon))
     })
   })
@@ -785,7 +787,6 @@ class QuestDBParser extends CstParser {
         { ALT: () => this.CONSUME(Lt) },
         { ALT: () => this.CONSUME(Splice) },
         { ALT: () => this.CONSUME(Window) },
-        { ALT: () => this.CONSUME(Natural) },
         { ALT: () => this.CONSUME(Prevailing) },
       ])
       this.OPTION1(() => this.CONSUME(Outer))
@@ -3705,7 +3706,6 @@ class QuestDBParser extends CstParser {
     this.OR([
       { ALT: () => this.CONSUME(Rows) },
       { ALT: () => this.CONSUME(Range) },
-      { ALT: () => this.CONSUME(Groups) },
       { ALT: () => this.CONSUME(Cumulative) },
     ])
     this.OPTION(() => {
@@ -3723,7 +3723,7 @@ class QuestDBParser extends CstParser {
         },
       ])
     })
-    // Optional EXCLUDE clause
+    // Optional EXCLUDE clause (QuestDB supports EXCLUDE CURRENT ROW and EXCLUDE NO OTHERS)
     this.OPTION1(() => {
       this.CONSUME(Exclude)
       this.OR2([
@@ -3739,7 +3739,6 @@ class QuestDBParser extends CstParser {
             this.CONSUME(Others)
           },
         },
-        { ALT: () => this.CONSUME1(Groups) },
       ])
     })
   })