feat: adding type hint parsing in JSON column type

parser/ast.go

@@ -4169,11 +4169,18 @@ func (j *JSONPath) String() string {
 	return builder.String()
 }
 
+type JSONTypeHint struct {
+	Path *JSONPath
+	Type ColumnType
+}
+
 type JSONOption struct {
 	SkipPath        *JSONPath
 	SkipRegex       *StringLiteral
 	MaxDynamicPaths *NumberLiteral
 	MaxDynamicTypes *NumberLiteral
+	// Type hint for specific JSON subcolumn path, e.g., "message String" or "a.b UInt64"
+	Column *JSONTypeHint
 }
 
 func (j *JSONOption) String() string {
@@ -4196,6 +4203,16 @@ func (j *JSONOption) String() string {
 		builder.WriteByte('=')
 		builder.WriteString(j.MaxDynamicTypes.String())
 	}
+	if j.Column != nil && j.Column.Path != nil && j.Column.Type != nil {
+		// add a leading space if there is already content
+		if builder.Len() > 0 {
+			builder.WriteByte(' ')
+		}
+		builder.WriteString(j.Column.Path.String())
+		builder.WriteByte(' ')
+		builder.WriteString(j.Column.Type.String())
+	}
+
 	return builder.String()
 }
 
@@ -4216,12 +4233,41 @@ func (j *JSONOptions) End() Pos {
 func (j *JSONOptions) String() string {
 	var builder strings.Builder
 	builder.WriteByte('(')
-	for i, item := range j.Items {
-		if i > 0 {
-			builder.WriteString(", ")
+	// Ensure stable, readable ordering:
+	// 1) numeric options (max_dynamic_*), 2) type-hint items, 3) skip options (SKIP, SKIP REGEXP)
+	// Preserve original relative order within each group.
+	numericOptionItems := make([]*JSONOption, 0, len(j.Items))
+	columnItems := make([]*JSONOption, 0, len(j.Items))
+	skipOptionItems := make([]*JSONOption, 0, len(j.Items))
+	for _, item := range j.Items {
+		if item.MaxDynamicPaths != nil || item.MaxDynamicTypes != nil {
+			numericOptionItems = append(numericOptionItems, item)
+			continue
+		}
+		if item.Column != nil {
+			columnItems = append(columnItems, item)
+			continue
+		}
+		if item.SkipPath != nil || item.SkipRegex != nil {
+			skipOptionItems = append(skipOptionItems, item)
+			continue
+		}
+		// Fallback: treat as numeric option to avoid dropping unknown future fields
+		numericOptionItems = append(numericOptionItems, item)
+	}
+
+	writeItems := func(items []*JSONOption) {
+		for _, item := range items {
+			if builder.Len() > 1 { // account for the initial '('
+				builder.WriteString(", ")
+			}
+			builder.WriteString(item.String())
 		}
-		builder.WriteString(item.String())
 	}
+
+	writeItems(numericOptionItems)
+	writeItems(columnItems)
+	writeItems(skipOptionItems)
 	builder.WriteByte(')')
 	return builder.String()
 }

parser/parser_column.go

@@ -1018,7 +1018,51 @@ func (p *Parser) parseJSONOption() (*JSONOption, error) {
 			SkipPath: jsonPath,
 		}, nil
 	case p.matchTokenKind(TokenKindIdent):
-		return p.parseJSONMaxDynamicOptions(p.Pos())
+		// Could be max_dynamic_* option OR a type hint like: a.b String
+		// Lookahead to see if there's an '=' following the identifier path (max_dynamic_*)
+		// or if it's a path followed by a ColumnType.
+		// We'll parse a JSONPath first, then decide.
+		// Save lexer state by consuming as path greedily using existing helpers.
+		// Try: if single ident and next is '=' -> max_dynamic_*; else treat as path + type
+
+		// Peek next token after current ident without consuming type; we need to
+		// attempt to parse as max_dynamic_* first as it's existing behavior for a single ident.
+		// To support dotted paths, we need to capture path, then if '=' exists, it's option; otherwise parse type.
+		path, err := p.parseJSONPath()
+		if err != nil {
+			return nil, err
+		}
+		if p.tryConsumeTokenKind(TokenKindSingleEQ) != nil {
+			// This is a max_dynamic_* option; only valid when path is a single ident of that name
+			// Reconstruct handling similar to parseJSONMaxDynamicOptions but we already consumed ident and '='
+			// Determine which option based on the first ident name
+			if len(path.Idents) != 1 {
+				return nil, fmt.Errorf("unexpected token kind: %s", p.lastTokenKind())
+			}
+			name := path.Idents[0].Name
+			switch name {
+			case "max_dynamic_types":
+				number, err := p.parseNumber(p.Pos())
+				if err != nil {
+					return nil, err
+				}
+				return &JSONOption{MaxDynamicTypes: number}, nil
+			case "max_dynamic_paths":
+				number, err := p.parseNumber(p.Pos())
+				if err != nil {
+					return nil, err
+				}
+				return &JSONOption{MaxDynamicPaths: number}, nil
+			default:
+				return nil, fmt.Errorf("unexpected token kind: %s", p.lastTokenKind())
+			}
+		}
+		// Otherwise, expect a ColumnType as a type hint for the JSON subpath
+		colType, err := p.parseColumnType(p.Pos())
+		if err != nil {
+			return nil, err
+		}
+		return &JSONOption{Column: &JSONTypeHint{Path: path, Type: colType}}, nil
 	default:
 		return nil, fmt.Errorf("unexpected token kind: %s", p.lastTokenKind())
 	}

parser/testdata/ddl/create_table_json_typehints.sql

@@ -0,0 +1,6 @@
+CREATE TABLE t (
+    j JSON(message String, a.b UInt64, max_dynamic_paths=0, SKIP x, SKIP REGEXP 're')
+) ENGINE = MergeTree
+ORDER BY tuple();
+
+

parser/testdata/ddl/format/create_table_json_typehints.sql

@@ -0,0 +1,11 @@
+-- Origin SQL:
+CREATE TABLE t (
+    j JSON(message String, a.b UInt64, max_dynamic_paths=0, SKIP x, SKIP REGEXP 're')
+) ENGINE = MergeTree
+ORDER BY tuple();
+
+
+
+
+-- Format SQL:
+CREATE TABLE t (j JSON(max_dynamic_paths=0, message String, a.b UInt64, SKIP x,  SKIP REGEXP 're')) ENGINE = MergeTree ORDER BY tuple();

parser/testdata/ddl/output/create_table_basic.sql.golden.json

@@ -685,22 +685,24 @@
                   "SkipRegex": null,
                   "MaxDynamicPaths": null,
                   "MaxDynamicTypes": {
-                    "NumPos": 571,
+                    "NumPos": 589,
                     "NumEnd": 591,
                     "Literal": "10",
                     "Base": 10
-                  }
+                  },
+                  "Column": null
                 },
                 {
                   "SkipPath": null,
                   "SkipRegex": null,
                   "MaxDynamicPaths": {
-                    "NumPos": 593,
+                    "NumPos": 611,
                     "NumEnd": 612,
                     "Literal": "3",
                     "Base": 10
                   },
-                  "MaxDynamicTypes": null
+                  "MaxDynamicTypes": null,
+                  "Column": null
                 },
                 {
                   "SkipPath": {
@@ -715,7 +717,8 @@
                   },
                   "SkipRegex": null,
                   "MaxDynamicPaths": null,
-                  "MaxDynamicTypes": null
+                  "MaxDynamicTypes": null,
+                  "Column": null
                 },
                 {
                   "SkipPath": {
@@ -742,7 +745,8 @@
                   },
                   "SkipRegex": null,
                   "MaxDynamicPaths": null,
-                  "MaxDynamicTypes": null
+                  "MaxDynamicTypes": null,
+                  "Column": null
                 },
                 {
                   "SkipPath": null,
@@ -752,7 +756,8 @@
                     "Literal": "hello"
                   },
                   "MaxDynamicPaths": null,
-                  "MaxDynamicTypes": null
+                  "MaxDynamicTypes": null,
+                  "Column": null
                 }
               ]
             }