Support single-quoted identifiers and bare * in select list

- Accept StringLiteral in the identifier parser rule so QuestDB single-quoted
  identifiers (FROM 'trades', AS 'alias') parse correctly and roundtrip through toSql
- Allow bare * anywhere in the select list (SELECT amount, * FROM t),
  not only as the first item
- Suppress autocomplete inside both single- and double-quoted strings

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

Author: emrberk

src/autocomplete/content-assist.ts

@@ -477,13 +477,17 @@ 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.
+  // Suppress suggestions when the cursor is inside any quoted string (single or double).
+  // This covers both string literal values and single-quoted identifiers — while QuestDB
+  // accepts single-quoted identifiers, providing completions inside quotes causes more
+  // problems than it solves (prefix filtering breaks, ambiguity with string values).
   const fullTokens = QuestDBLexer.tokenize(fullSql).tokens
   for (const token of fullTokens) {
-    if (token.tokenType.name !== "StringLiteral") continue
+    if (
+      token.tokenType.name !== "StringLiteral" &&
+      token.tokenType.name !== "QuotedIdentifier"
+    )
+      continue
     const start = token.startOffset
     const end = token.startOffset + token.image.length
     if (cursorOffset > start && cursorOffset < end) {

src/parser/cst-types.d.ts

@@ -142,6 +142,7 @@ export interface SelectItemCstNode extends CstNode {
 
 export type SelectItemCstChildren = {
   qualifiedStar?: QualifiedStarCstNode[];
+  Star?: IToken[];
   expression?: ExpressionCstNode[];
   As?: IToken[];
   identifier?: IdentifierCstNode[];
@@ -2286,6 +2287,7 @@ export interface IdentifierCstNode extends CstNode {
 export type IdentifierCstChildren = {
   Identifier?: IToken[];
   QuotedIdentifier?: IToken[];
+  StringLiteral?: IToken[];
   IdentifierKeyword?: IToken[];
 };
 

src/parser/parser.ts

@@ -609,6 +609,8 @@ class QuestDBParser extends CstParser {
         GATE: this.BACKTRACK(this.qualifiedStar),
         ALT: () => this.SUBRULE(this.qualifiedStar),
       },
+      // Bare * can appear anywhere in the select list (e.g., SELECT amount, *)
+      { ALT: () => this.CONSUME(Star) },
       { ALT: () => this.SUBRULE(this.expression) },
     ])
     this.OPTION({
@@ -3881,9 +3883,12 @@ class QuestDBParser extends CstParser {
     // keyword token as an identifier, avoiding a 160+ alternative OR that
     // would make performSelfAnalysis() extremely slow.
     // See tokens.ts IDENTIFIER_KEYWORD_NAMES for the full list.
+    // QuestDB accepts single-quoted strings in identifier positions (table names,
+    // column names, aliases), so StringLiteral is accepted here alongside QuotedIdentifier.
     this.OR([
       { ALT: () => this.CONSUME(Identifier) },
       { ALT: () => this.CONSUME(QuotedIdentifier) },
+      { ALT: () => this.CONSUME(StringLiteral) },
       { ALT: () => this.CONSUME(IdentifierKeyword) },
     ])
   })

src/parser/visitor.ts

@@ -454,6 +454,11 @@ class QuestDBVisitor extends BaseVisitor {
       return result
     }
 
+    // Bare * appearing as a non-first select item (e.g., SELECT amount, *)
+    if (ctx.Star) {
+      return { type: "star" }
+    }
+
     const result: AST.ExpressionSelectItem = {
       type: "selectItem",
       expression: this.visit(ctx.expression!) as AST.Expression,
@@ -3732,6 +3737,11 @@ class QuestDBVisitor extends BaseVisitor {
       const raw = this.tokenImage(ctx.QuotedIdentifier[0] as IToken)
       return raw.slice(1, -1).replace(/""/g, '"')
     }
+    // QuestDB accepts single-quoted strings in identifier positions
+    if (ctx.StringLiteral) {
+      const raw = this.tokenImage(ctx.StringLiteral[0] as IToken)
+      return raw.slice(1, -1).replace(/''/g, "'")
+    }
     // Handle keyword tokens used as identifiers
     // Find the first token in the context
     for (const key of Object.keys(ctx)) {

tests/parser.test.ts

@@ -3343,6 +3343,49 @@ orders PIVOT (sum(amount) FOR status IN ('open'))`
       expect(stmt.type).toBe("select")
     })
 
+    it("should parse SELECT expr, * (star not first)", () => {
+      const result = parseToAst("SELECT amount, * FROM btc_trades")
+      expect(result.errors).toHaveLength(0)
+      const stmt = result.ast[0]
+      expect(stmt.type).toBe("select")
+      if (stmt.type === "select") {
+        expect(stmt.columns).toHaveLength(2)
+        expect(stmt.columns[0].type).toBe("selectItem")
+        expect(stmt.columns[1].type).toBe("star")
+      }
+    })
+
+    it("should roundtrip SELECT expr, *", () => {
+      const result = parseToAst("SELECT amount, * FROM btc_trades")
+      expect(result.errors).toHaveLength(0)
+      const sql = toSql(result.ast[0])
+      expect(sql).toBe("SELECT amount, * FROM btc_trades")
+    })
+
+    it("should parse SELECT with star in middle of select list", () => {
+      const result = parseToAst(
+        "SELECT symbol, *, price FROM btc_trades",
+      )
+      expect(result.errors).toHaveLength(0)
+      if (result.ast[0].type === "select") {
+        expect(result.ast[0].columns).toHaveLength(3)
+        expect(result.ast[0].columns[0].type).toBe("selectItem")
+        expect(result.ast[0].columns[1].type).toBe("star")
+        expect(result.ast[0].columns[2].type).toBe("selectItem")
+      }
+    })
+
+    it("should parse SELECT with multiple expressions before star", () => {
+      const result = parseToAst(
+        "SELECT a, b, c, * FROM t",
+      )
+      expect(result.errors).toHaveLength(0)
+      if (result.ast[0].type === "select") {
+        expect(result.ast[0].columns).toHaveLength(4)
+        expect(result.ast[0].columns[3].type).toBe("star")
+      }
+    })
+
     // --- Fix 4: Array column types ---
 
     it("should parse CREATE TABLE with single-dimension array column type", () => {