Fix identifier and materialized view parsing for 03711 test

- Fix lexer to handle identifiers starting with numbers after a dot (e.g., db.03711_table)
- Add isIdentifierAfterDot() to distinguish 03711_table from decimal numbers
- Fix TO clause in CREATE MATERIALIZED VIEW to support qualified names (database.table)
- Add ToDatabase field to CreateQuery for materialized view targets

Author: claude

ast/ast.go

@@ -254,8 +254,9 @@ type CreateQuery struct {
 	Table            string               `json:"table,omitempty"`
 	View             string               `json:"view,omitempty"`
 	Materialized     bool                 `json:"materialized,omitempty"`
-	To               string               `json:"to,omitempty"`       // Target table for materialized views
-	Populate         bool                 `json:"populate,omitempty"` // POPULATE for materialized views
+	ToDatabase       string               `json:"to_database,omitempty"` // Target database for materialized views
+	To               string               `json:"to,omitempty"`          // Target table for materialized views
+	Populate         bool                 `json:"populate,omitempty"`    // POPULATE for materialized views
 	Columns          []*ColumnDeclaration `json:"columns,omitempty"`
 	Indexes          []*IndexDefinition   `json:"indexes,omitempty"`
 	Projections      []*Projection        `json:"projections,omitempty"`

lexer/lexer.go

@@ -80,6 +80,55 @@ func (l *Lexer) skipWhitespace() {
 	}
 }
 
+// isIdentifierAfterDot checks if what follows the DOT looks like an identifier pattern.
+// This handles cases like db.03711_table where 03711_table should be treated as an identifier.
+// We look ahead to see if we have: digits followed by underscore followed by letter/digit
+func (l *Lexer) isIdentifierAfterDot() bool {
+	// We're currently at '.', peek ahead to check the pattern
+	// Save current reader position by peeking
+	bytes, _ := l.reader.Peek(32) // peek enough to see the pattern, ignore EOF error
+	if len(bytes) == 0 {
+		return false
+	}
+
+	idx := 0
+	// Skip initial digits
+	for idx < len(bytes) && bytes[idx] >= '0' && bytes[idx] <= '9' {
+		idx++
+	}
+	// If no digits found, it's not our pattern
+	if idx == 0 {
+		return false
+	}
+	// Check for underscore followed by letter/digit (identifier pattern)
+	if idx < len(bytes) && bytes[idx] == '_' {
+		idx++
+		if idx < len(bytes) && isIdentContinueByte(bytes[idx]) {
+			return true
+		}
+	}
+	// Also check for letter directly after digits (like 1abc)
+	if idx < len(bytes) {
+		ch, _ := utf8.DecodeRune(bytes[idx:])
+		// Check it's a letter but not exponent (e/E followed by digit/+/-)
+		if unicode.IsLetter(ch) {
+			if (ch == 'e' || ch == 'E') && idx+1 < len(bytes) {
+				next := bytes[idx+1]
+				if next >= '0' && next <= '9' || next == '+' || next == '-' {
+					return false // This is a scientific notation number
+				}
+			}
+			return true
+		}
+	}
+	return false
+}
+
+// isIdentContinueByte checks if a byte is a valid identifier continuation character
+func isIdentContinueByte(b byte) bool {
+	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || (b >= '0' && b <= '9') || b == '_'
+}
+
 // isClickHouseWhitespace returns true for characters ClickHouse treats as whitespace
 // but Go's unicode.IsSpace does not recognize.
 func isClickHouseWhitespace(ch rune) bool {
@@ -226,6 +275,12 @@ func (l *Lexer) NextToken() Item {
 		return Item{Token: token.COMMA, Value: ",", Pos: pos}
 	case '.':
 		if unicode.IsDigit(l.peekChar()) {
+			// Before treating .digits as a number, check if it's part of an identifier pattern
+			// For example, db.03711_table should be DOT + IDENT, not DOT + NUMBER + IDENT
+			if l.isIdentifierAfterDot() {
+				l.readChar()
+				return Item{Token: token.DOT, Value: ".", Pos: pos}
+			}
 			return l.readNumber()
 		}
 		l.readChar()

parser/parser.go

@@ -1975,7 +1975,14 @@ func (p *Parser) parseCreateView(create *ast.CreateQuery) {
 			return
 		}
 		p.nextToken()
-		create.To = p.parseIdentifierName()
+		toName := p.parseIdentifierName()
+		if p.currentIs(token.DOT) {
+			p.nextToken()
+			create.ToDatabase = toName
+			create.To = p.parseIdentifierName()
+		} else {
+			create.To = toName
+		}
 	}
 
 	// Parse ENGINE (for materialized views)

parser/testdata/03711_deduplication_blocks_part_log/metadata.json

@@ -1,23 +1 @@
-{
-  "explain_todo": {
-    "stmt10": true,
-    "stmt11": true,
-    "stmt12": true,
-    "stmt13": true,
-    "stmt14": true,
-    "stmt15": true,
-    "stmt16": true,
-    "stmt17": true,
-    "stmt18": true,
-    "stmt19": true,
-    "stmt20": true,
-    "stmt27": true,
-    "stmt3": true,
-    "stmt4": true,
-    "stmt5": true,
-    "stmt6": true,
-    "stmt7": true,
-    "stmt8": true,
-    "stmt9": true
-  }
-}
+{}