Fix 53 parser issues: keyword types, implicit aliases, empty tuples, CAST syntax

- Fix parseColumnDeclaration to accept keywords as column names (KEY, etc.)
- Fix parseDataType to accept keyword type names (Array, Tuple, Nested, etc.)
- Add more data types: INT, JSON, VARIANT, DYNAMIC, aggregation functions, etc.
- Support empty tuple parsing: SELECT ()
- Support CAST(x, 'Type') comma syntax in addition to CAST(x AS Type)
- Support WITH TIES clause after LIMIT
- Add implicit alias support for columns (SELECT 'a' c0 means SELECT 'a' AS c0)

Tests: 5405 passing, 1418 skipped (was 5352 passing, 1471 skipped)

Author: claude

parser/expression.go

@@ -80,16 +80,56 @@ func (p *Parser) parseExpressionList() []ast.Expression {
 		return exprs
 	}
 
-	exprs = append(exprs, p.parseExpression(LOWEST))
+	expr := p.parseExpression(LOWEST)
+	if expr != nil {
+		// Handle implicit alias (identifier without AS)
+		expr = p.parseImplicitAlias(expr)
+		exprs = append(exprs, expr)
+	}
 
 	for p.currentIs(token.COMMA) {
 		p.nextToken()
-		exprs = append(exprs, p.parseExpression(LOWEST))
+		expr := p.parseExpression(LOWEST)
+		if expr != nil {
+			// Handle implicit alias (identifier without AS)
+			expr = p.parseImplicitAlias(expr)
+			exprs = append(exprs, expr)
+		}
 	}
 
 	return exprs
 }
 
+// parseImplicitAlias handles implicit column aliases like "SELECT 'a' c0" (meaning 'a' AS c0)
+func (p *Parser) parseImplicitAlias(expr ast.Expression) ast.Expression {
+	// If next token is a plain identifier (not a keyword), treat as implicit alias
+	// Keywords like FROM, WHERE etc. are tokenized as their own token types, not IDENT
+	if p.currentIs(token.IDENT) {
+		alias := p.current.Value
+		p.nextToken()
+
+		// Set alias on the expression if it supports it
+		switch e := expr.(type) {
+		case *ast.Identifier:
+			e.Alias = alias
+			return e
+		case *ast.FunctionCall:
+			e.Alias = alias
+			return e
+		case *ast.Subquery:
+			e.Alias = alias
+			return e
+		default:
+			return &ast.AliasedExpr{
+				Position: expr.Pos(),
+				Expr:     expr,
+				Alias:    alias,
+			}
+		}
+	}
+	return expr
+}
+
 func (p *Parser) parseExpression(precedence int) ast.Expression {
 	left := p.parsePrefixExpression()
 	if left == nil {
@@ -543,6 +583,16 @@ func (p *Parser) parseGroupedOrTuple() ast.Expression {
 	pos := p.current.Pos
 	p.nextToken() // skip (
 
+	// Handle empty tuple ()
+	if p.currentIs(token.RPAREN) {
+		p.nextToken()
+		return &ast.Literal{
+			Position: pos,
+			Type:     ast.LiteralTuple,
+			Value:    []ast.Expression{},
+		}
+	}
+
 	// Check for subquery
 	if p.currentIs(token.SELECT) || p.currentIs(token.WITH) {
 		subquery := p.parseSelectWithUnion()
@@ -661,12 +711,22 @@ func (p *Parser) parseCast() ast.Expression {
 	// Use ALIAS_PREC to avoid consuming AS as an alias operator
 	expr.Expr = p.parseExpression(ALIAS_PREC)
 
-	if !p.expect(token.AS) {
-		return nil
+	// Handle both CAST(x AS Type) and CAST(x, 'Type') syntax
+	if p.currentIs(token.AS) {
+		p.nextToken()
+		expr.Type = p.parseDataType()
+	} else if p.currentIs(token.COMMA) {
+		p.nextToken()
+		// Type is given as a string literal
+		if p.currentIs(token.STRING) {
+			expr.Type = &ast.DataType{
+				Position: p.current.Pos,
+				Name:     p.current.Value,
+			}
+			p.nextToken()
+		}
 	}
 
-	expr.Type = p.parseDataType()
-
 	p.expect(token.RPAREN)
 
 	return expr

parser/parser.go

@@ -291,6 +291,12 @@ func (p *Parser) parseSelect() *ast.SelectQuery {
 			sel.Offset = sel.Limit
 			sel.Limit = p.parseExpression(LOWEST)
 		}
+
+		// WITH TIES modifier
+		if p.currentIs(token.WITH) && p.peekIs(token.TIES) {
+			p.nextToken() // skip WITH
+			p.nextToken() // skip TIES
+		}
 	}
 
 	// Parse OFFSET clause
@@ -1136,8 +1142,8 @@ func (p *Parser) parseColumnDeclaration() *ast.ColumnDeclaration {
 		Position: p.current.Pos,
 	}
 
-	// Parse column name
-	if p.currentIs(token.IDENT) {
+	// Parse column name (can be identifier or keyword like KEY)
+	if p.currentIs(token.IDENT) || p.current.Token.IsKeyword() {
 		col.Name = p.current.Value
 		p.nextToken()
 	} else {
@@ -1188,7 +1194,8 @@ func (p *Parser) parseColumnDeclaration() *ast.ColumnDeclaration {
 }
 
 func (p *Parser) parseDataType() *ast.DataType {
-	if !p.currentIs(token.IDENT) {
+	// Type names can be identifiers or keywords (Array, Nested, Key, etc.)
+	if !p.currentIs(token.IDENT) && !p.current.Token.IsKeyword() {
 		return nil
 	}
 
@@ -1203,7 +1210,8 @@ func (p *Parser) parseDataType() *ast.DataType {
 		p.nextToken()
 		for !p.currentIs(token.RPAREN) && !p.currentIs(token.EOF) {
 			// Could be another data type or an expression
-			if p.currentIs(token.IDENT) && p.isDataTypeName(p.current.Value) {
+			// Type names can be identifiers or keywords (Array, Nested, etc.)
+			if (p.currentIs(token.IDENT) || p.current.Token.IsKeyword()) && p.isDataTypeName(p.current.Value) {
 				dt.Parameters = append(dt.Parameters, p.parseDataType())
 			} else {
 				dt.Parameters = append(dt.Parameters, p.parseExpression(LOWEST))
@@ -1223,9 +1231,9 @@ func (p *Parser) parseDataType() *ast.DataType {
 func (p *Parser) isDataTypeName(name string) bool {
 	upper := strings.ToUpper(name)
 	types := []string{
-		"INT8", "INT16", "INT32", "INT64", "INT128", "INT256",
+		"INT", "INT8", "INT16", "INT32", "INT64", "INT128", "INT256",
 		"UINT8", "UINT16", "UINT32", "UINT64", "UINT128", "UINT256",
-		"FLOAT32", "FLOAT64",
+		"FLOAT32", "FLOAT64", "FLOAT",
 		"DECIMAL", "DECIMAL32", "DECIMAL64", "DECIMAL128", "DECIMAL256",
 		"STRING", "FIXEDSTRING",
 		"UUID", "DATE", "DATE32", "DATETIME", "DATETIME64",
@@ -1235,6 +1243,11 @@ func (p *Parser) isDataTypeName(name string) bool {
 		"BOOL", "BOOLEAN",
 		"IPV4", "IPV6",
 		"NOTHING", "INTERVAL",
+		"JSON", "OBJECT", "VARIANT",
+		"AGGREGATEFUNCTION", "SIMPLEAGGREGATEFUNCTION",
+		"POINT", "RING", "POLYGON", "MULTIPOLYGON",
+		"TIME64", "TIME",
+		"DYNAMIC",
 	}
 	for _, t := range types {
 		if upper == t {