Fix multiple parser and explain output issues

- Add HasParentheses field to DataType to track empty parentheses (e.g., Tuple())
- Add NameTypePair AST node for Nested type column declarations
- Update array expansion to treat tuple/array literals as complex expressions
- Change boolean literal format from UInt8 to Bool
- Fix InsertQuery to include Settings from SELECT clause as child
- Add nil safety checks for InsertQuery SELECT parsing

Author: claude

ast/ast.go

@@ -266,15 +266,27 @@ func (c *ColumnDeclaration) End() token.Position { return c.Position }
 
 // DataType represents a data type.
 type DataType struct {
-	Position   token.Position `json:"-"`
-	Name       string         `json:"name"`
-	Parameters []Expression   `json:"parameters,omitempty"`
+	Position       token.Position `json:"-"`
+	Name           string         `json:"name"`
+	Parameters     []Expression   `json:"parameters,omitempty"`
+	HasParentheses bool           `json:"has_parentheses,omitempty"`
 }
 
 func (d *DataType) Pos() token.Position { return d.Position }
 func (d *DataType) End() token.Position { return d.Position }
 func (d *DataType) expressionNode()     {}
 
+// NameTypePair represents a named type pair, used in Nested types.
+type NameTypePair struct {
+	Position token.Position `json:"-"`
+	Name     string         `json:"name"`
+	Type     *DataType      `json:"type"`
+}
+
+func (n *NameTypePair) Pos() token.Position { return n.Position }
+func (n *NameTypePair) End() token.Position { return n.Position }
+func (n *NameTypePair) expressionNode()     {}
+
 // CodecExpr represents a CODEC expression.
 type CodecExpr struct {
 	Position token.Position    `json:"-"`

internal/explain/explain.go

@@ -121,6 +121,8 @@ func Node(sb *strings.Builder, node interface{}, depth int) {
 	// Types
 	case *ast.DataType:
 		explainDataType(sb, n, indent, depth)
+	case *ast.NameTypePair:
+		explainNameTypePair(sb, n, indent, depth)
 	case *ast.Parameter:
 		explainParameter(sb, n, indent)
 

internal/explain/expressions.go

@@ -61,7 +61,9 @@ func explainLiteral(sb *strings.Builder, n *ast.Literal, indent string, depth in
 			}
 			hasComplexExpr := false
 			for _, e := range exprs {
-				if _, isLit := e.(*ast.Literal); !isLit {
+				lit, isLit := e.(*ast.Literal)
+				// Non-literals or tuple/array literals count as complex
+				if !isLit || (isLit && (lit.Type == ast.LiteralTuple || lit.Type == ast.LiteralArray)) {
 					hasComplexExpr = true
 					break
 				}

internal/explain/format.go

@@ -33,9 +33,9 @@ func FormatLiteral(lit *ast.Literal) string {
 		return fmt.Sprintf("\\'%s\\'", s)
 	case ast.LiteralBoolean:
 		if lit.Value.(bool) {
-			return "UInt8_1"
+			return "Bool_1"
 		}
-		return "UInt8_0"
+		return "Bool_0"
 	case ast.LiteralNull:
 		return "NULL"
 	case ast.LiteralArray:

internal/explain/statements.go

@@ -182,11 +182,20 @@ func explainDataType(sb *strings.Builder, n *ast.DataType, indent string, depth
 		for _, p := range n.Parameters {
 			Node(sb, p, depth+2)
 		}
+	} else if n.HasParentheses {
+		// Empty parentheses, e.g., Tuple()
+		fmt.Fprintf(sb, "%sDataType %s (children %d)\n", indent, n.Name, 1)
+		fmt.Fprintf(sb, "%s ExpressionList\n", indent)
 	} else {
 		fmt.Fprintf(sb, "%sDataType %s\n", indent, n.Name)
 	}
 }
 
+func explainNameTypePair(sb *strings.Builder, n *ast.NameTypePair, indent string, depth int) {
+	fmt.Fprintf(sb, "%sNameTypePair %s (children %d)\n", indent, n.Name, 1)
+	Node(sb, n.Type, depth+1)
+}
+
 func explainParameter(sb *strings.Builder, n *ast.Parameter, indent string) {
 	if n.Name != "" {
 		fmt.Fprintf(sb, "%sQueryParameter %s\n", indent, n.Name)

parser/parser.go

@@ -173,11 +173,23 @@ func (p *Parser) parseSelectWithUnion() *ast.SelectWithUnionQuery {
 			p.nextToken()
 		}
 		query.UnionModes = append(query.UnionModes, mode)
-		sel := p.parseSelect()
-		if sel == nil {
-			break
+
+		// Handle parenthesized subqueries: UNION ALL (SELECT ... UNION ALL SELECT ...)
+		if p.currentIs(token.LPAREN) {
+			p.nextToken() // skip (
+			nested := p.parseSelectWithUnion()
+			p.expect(token.RPAREN)
+			// Flatten nested union selects into current query
+			for _, s := range nested.Selects {
+				query.Selects = append(query.Selects, s)
+			}
+		} else {
+			sel := p.parseSelect()
+			if sel == nil {
+				break
+			}
+			query.Selects = append(query.Selects, sel)
 		}
-		query.Selects = append(query.Selects, sel)
 	}
 
 	return query
@@ -917,6 +929,17 @@ func (p *Parser) parseInsert() *ast.InsertQuery {
 		}
 	} else if p.currentIs(token.SELECT) || p.currentIs(token.WITH) {
 		ins.Select = p.parseSelectWithUnion()
+		// If the SELECT has settings, mark the INSERT as having settings too
+		if ins.Select != nil {
+			if sel, ok := ins.Select.(*ast.SelectWithUnionQuery); ok && sel != nil && len(sel.Selects) > 0 {
+				lastSel := sel.Selects[len(sel.Selects)-1]
+				if lastSel != nil {
+					if selQuery, ok := lastSel.(*ast.SelectQuery); ok && selQuery != nil && len(selQuery.Settings) > 0 {
+						ins.HasSettings = true
+					}
+				}
+			}
+		}
 	}
 
 	// Parse FORMAT (format names can be keywords like Null, JSON, etc.)
@@ -1314,21 +1337,27 @@ func (p *Parser) parseDataType() *ast.DataType {
 
 	// Parse type parameters
 	if p.currentIs(token.LPAREN) {
+		dt.HasParentheses = true
 		p.nextToken()
 
 		// Special handling for Nested type - it contains column declarations, not just types
 		if strings.ToUpper(dt.Name) == "NESTED" {
 			for !p.currentIs(token.RPAREN) && !p.currentIs(token.EOF) {
 				// Parse as column name + type
 				if p.currentIs(token.IDENT) || p.current.Token.IsKeyword() {
+					pos := p.current.Pos
 					colName := p.current.Value
 					p.nextToken()
 					// Parse the type for this column
 					colType := p.parseDataType()
 					if colType != nil {
-						// Wrap in a special format or just store as data type
-						colType.Name = colName + " " + colType.Name
-						dt.Parameters = append(dt.Parameters, colType)
+						// Use NameTypePair for Nested column declarations
+						ntp := &ast.NameTypePair{
+							Position: pos,
+							Name:     colName,
+							Type:     colType,
+						}
+						dt.Parameters = append(dt.Parameters, ntp)
 					}
 				}
 				if p.currentIs(token.COMMA) {