fix(parser): polish PIVOT/UNPIVOT round-trip and validation

- Formatter emits AS before PIVOT/UNPIVOT aliases for clean round-trip.
- Tokenizer records Quote='[' on SQL Server bracket-quoted identifiers;
  pivot parser uses renderQuotedIdent to preserve [North] etc. in
  PivotClause.InValues and UnpivotClause.InColumns.
- Reject empty IN lists for both PIVOT and UNPIVOT.
- Extract parsePivotAlias helper, collapsing four duplicated alias
  blocks in select_subquery.go.
- Add TestPivotNegativeCases (missing parens, missing FOR/IN, empty IN)
  and TestPivotBracketedInValuesPreserved.

Full test suite passes with -race.

Author: Ajit Pratap Singh

pkg/formatter/render.go

@@ -1205,7 +1205,13 @@ func tableRefSQL(t *ast.TableReference) string {
 		sb.WriteString("))")
 	}
 	if t.Alias != "" {
-		sb.WriteString(" ")
+		// PIVOT/UNPIVOT aliases conventionally use AS to avoid ambiguity
+		// with the closing paren of the clause.
+		if t.Pivot != nil || t.Unpivot != nil {
+			sb.WriteString(" AS ")
+		} else {
+			sb.WriteString(" ")
+		}
 		sb.WriteString(t.Alias)
 	}
 	return sb.String()

pkg/sql/parser/pivot.go

@@ -25,6 +25,43 @@ import (
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
 )
 
+// renderQuotedIdent reproduces the original delimiters of a quoted identifier
+// token so the parsed value round-trips through the formatter. The tokenizer
+// strips delimiters but records them in QuoteStyle.
+func renderQuotedIdent(tok models.Token) string {
+	q := tok.Quote
+	if q == 0 && tok.Word != nil {
+		q = tok.Word.QuoteStyle
+	}
+	switch q {
+	case '[':
+		return "[" + tok.Value + "]"
+	case '"':
+		return "\"" + tok.Value + "\""
+	case '`':
+		return "`" + tok.Value + "`"
+	}
+	return tok.Value
+}
+
+// parsePivotAlias consumes an optional alias (with or without AS) following a
+// PIVOT/UNPIVOT clause. Extracted to avoid four copies of the same logic in
+// the table-reference and join paths.
+func (p *Parser) parsePivotAlias(ref *ast.TableReference) {
+	if p.isType(models.TokenTypeAs) {
+		p.advance() // consume AS
+		if p.isIdentifier() {
+			ref.Alias = p.currentToken.Token.Value
+			p.advance()
+		}
+		return
+	}
+	if p.isIdentifier() {
+		ref.Alias = p.currentToken.Token.Value
+		p.advance()
+	}
+}
+
 // pivotDialectAllowed reports whether PIVOT/UNPIVOT is a recognized clause
 // for the parser's current dialect. PIVOT/UNPIVOT are SQL Server / Oracle
 // extensions; in other dialects the words must remain valid identifiers.
@@ -107,7 +144,7 @@ func (p *Parser) parsePivotClause() (*ast.PivotClause, error) {
 		if !p.isIdentifier() && !p.isType(models.TokenTypeNumber) && !p.isStringLiteral() {
 			return nil, p.expectedError("value in PIVOT IN list")
 		}
-		inValues = append(inValues, p.currentToken.Token.Value)
+		inValues = append(inValues, renderQuotedIdent(p.currentToken.Token))
 		p.advance()
 		if p.isType(models.TokenTypeComma) {
 			p.advance()
@@ -117,6 +154,9 @@ func (p *Parser) parsePivotClause() (*ast.PivotClause, error) {
 	if !p.isType(models.TokenTypeRParen) {
 		return nil, p.expectedError(") to close PIVOT IN list")
 	}
+	if len(inValues) == 0 {
+		return nil, p.expectedError("at least one value in PIVOT IN list")
+	}
 	p.advance() // close IN list )
 
 	if !p.isType(models.TokenTypeRParen) {
@@ -181,7 +221,7 @@ func (p *Parser) parseUnpivotClause() (*ast.UnpivotClause, error) {
 		if !p.isIdentifier() {
 			return nil, p.expectedError("column name in UNPIVOT IN list")
 		}
-		cols = append(cols, p.currentToken.Token.Value)
+		cols = append(cols, renderQuotedIdent(p.currentToken.Token))
 		p.advance()
 		if p.isType(models.TokenTypeComma) {
 			p.advance()
@@ -191,6 +231,9 @@ func (p *Parser) parseUnpivotClause() (*ast.UnpivotClause, error) {
 	if !p.isType(models.TokenTypeRParen) {
 		return nil, p.expectedError(") to close UNPIVOT IN list")
 	}
+	if len(cols) == 0 {
+		return nil, p.expectedError("at least one column in UNPIVOT IN list")
+	}
 	p.advance() // close IN list )
 
 	if !p.isType(models.TokenTypeRParen) {

pkg/sql/parser/select_subquery.go

@@ -134,17 +134,7 @@ func (p *Parser) parseFromTableReference() (ast.TableReference, error) {
 			return tableRef, err
 		}
 		tableRef.Pivot = pivot
-		// PIVOT result often has its own alias: PIVOT (...) AS pvt
-		if p.isType(models.TokenTypeAs) {
-			p.advance() // consume AS
-			if p.isIdentifier() {
-				tableRef.Alias = p.currentToken.Token.Value
-				p.advance()
-			}
-		} else if p.isIdentifier() {
-			tableRef.Alias = p.currentToken.Token.Value
-			p.advance()
-		}
+		p.parsePivotAlias(&tableRef)
 	}
 
 	// SQL Server / Oracle UNPIVOT clause
@@ -154,17 +144,7 @@ func (p *Parser) parseFromTableReference() (ast.TableReference, error) {
 			return tableRef, err
 		}
 		tableRef.Unpivot = unpivot
-		// UNPIVOT result alias: UNPIVOT (...) AS unpvt
-		if p.isType(models.TokenTypeAs) {
-			p.advance() // consume AS
-			if p.isIdentifier() {
-				tableRef.Alias = p.currentToken.Token.Value
-				p.advance()
-			}
-		} else if p.isIdentifier() {
-			tableRef.Alias = p.currentToken.Token.Value
-			p.advance()
-		}
+		p.parsePivotAlias(&tableRef)
 	}
 
 	return tableRef, nil
@@ -268,16 +248,7 @@ func (p *Parser) parseJoinedTableRef(joinType string) (ast.TableReference, error
 			return ref, err
 		}
 		ref.Pivot = pivot
-		if p.isType(models.TokenTypeAs) {
-			p.advance()
-			if p.isIdentifier() {
-				ref.Alias = p.currentToken.Token.Value
-				p.advance()
-			}
-		} else if p.isIdentifier() {
-			ref.Alias = p.currentToken.Token.Value
-			p.advance()
-		}
+		p.parsePivotAlias(&ref)
 	}
 
 	// SQL Server / Oracle UNPIVOT clause
@@ -287,16 +258,7 @@ func (p *Parser) parseJoinedTableRef(joinType string) (ast.TableReference, error
 			return ref, err
 		}
 		ref.Unpivot = unpivot
-		if p.isType(models.TokenTypeAs) {
-			p.advance()
-			if p.isIdentifier() {
-				ref.Alias = p.currentToken.Token.Value
-				p.advance()
-			}
-		} else if p.isIdentifier() {
-			ref.Alias = p.currentToken.Token.Value
-			p.advance()
-		}
+		p.parsePivotAlias(&ref)
 	}
 
 	return ref, nil

pkg/sql/parser/tsql_test.go

@@ -433,7 +433,7 @@ PIVOT (
 	if len(ref.Pivot.InValues) != 4 {
 		t.Errorf("expected 4 IN values, got %d", len(ref.Pivot.InValues))
 	}
-	expected := []string{"North", "South", "East", "West"}
+	expected := []string{"[North]", "[South]", "[East]", "[West]"}
 	for i, v := range expected {
 		if i < len(ref.Pivot.InValues) && ref.Pivot.InValues[i] != v {
 			t.Errorf("IN value [%d]: expected %q, got %q", i, v, ref.Pivot.InValues[i])
@@ -540,6 +540,54 @@ func TestTSQL_PivotWithASAlias(t *testing.T) {
 	}
 }
 
+// TestPivotNegativeCases covers parser error paths for malformed PIVOT/UNPIVOT.
+func TestPivotNegativeCases(t *testing.T) {
+	cases := []struct {
+		name string
+		sql  string
+	}{
+		{"missing_lparen", "SELECT * FROM t PIVOT SUM(x) FOR c IN (a))"},
+		{"missing_for", "SELECT * FROM t PIVOT (SUM(x) c IN (a))"},
+		{"missing_in", "SELECT * FROM t PIVOT (SUM(x) FOR c (a))"},
+		{"missing_in_lparen", "SELECT * FROM t PIVOT (SUM(x) FOR c IN a)"},
+		{"empty_in_list", "SELECT * FROM t PIVOT (SUM(x) FOR c IN ())"},
+		{"unpivot_missing_for", "SELECT * FROM t UNPIVOT (v c IN (a))"},
+		{"unpivot_empty_in_list", "SELECT * FROM t UNPIVOT (v FOR n IN ())"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			_, err := ParseWithDialect(tc.sql, keywords.DialectSQLServer)
+			if err == nil {
+				t.Fatalf("expected parse error, got nil for: %s", tc.sql)
+			}
+		})
+	}
+}
+
+// TestPivotBracketedInValuesPreserved verifies SQL Server bracket-quoted IN
+// values survive parsing so the formatter can re-emit them.
+func TestPivotBracketedInValuesPreserved(t *testing.T) {
+	sql := `SELECT * FROM sales PIVOT (SUM(amt) FOR region IN ([North], [South])) AS p`
+	result, err := ParseWithDialect(sql, keywords.DialectSQLServer)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	stmt, ok := result.Statements[0].(*ast.SelectStatement)
+	if !ok {
+		t.Fatalf("expected SelectStatement, got %T", result.Statements[0])
+	}
+	got := stmt.From[0].Pivot.InValues
+	want := []string{"[North]", "[South]"}
+	if len(got) != len(want) {
+		t.Fatalf("expected %d values, got %d (%v)", len(want), len(got), got)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Errorf("InValues[%d] = %q, want %q", i, got[i], want[i])
+		}
+	}
+}
+
 // TestPivotIdentifierInNonTSQLDialects verifies PIVOT/UNPIVOT remain valid
 // identifiers in dialects that don't recognize the contextual clause.
 // Regression for global-tokenizer-keyword leak.

pkg/sql/tokenizer/tokenizer.go

@@ -1283,7 +1283,7 @@ func (t *Tokenizer) readPunctuation() (models.Token, error) {
 				ch, chSize := utf8.DecodeRune(t.input[t.pos.Index:])
 				if ch == ']' {
 					t.pos.AdvanceRune(ch, chSize) // Consume ]
-					return models.Token{Type: models.TokenTypeIdentifier, Value: string(ident)}, nil
+					return models.Token{Type: models.TokenTypeIdentifier, Value: string(ident), Quote: '['}, nil
 				}
 				ident = append(ident, t.input[t.pos.Index:t.pos.Index+chSize]...)
 				t.pos.AdvanceRune(ch, chSize)