refactor: split parser/generator from Hive nested classes, rename to dialect.py, bump to v0.4.0

- Rename maxcompute.py → dialect.py; update entry point, __init__, and docs
- MaxComputeParser now inherits HiveParser (sqlglot.parsers.hive)
- MaxComputeGenerator now inherits HiveGenerator (sqlglot.generators.hive)
- Raise sqlglot dependency floor to >=30.1.0 (first release with split modules)
- Bump version to 0.4.0

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: azurechen97

CHANGELOG.md

@@ -1,6 +1,13 @@
 # Changelog
 
-## [0.3.2] - 2026-04-01
+## [0.4.0] - 2026-04-01
+
+### Changed (internal refactor)
+
+- `maxcompute.py` renamed to `dialect.py` — the coordinator class `MaxCompute` is now in `src/sqlglot_maxcompute/dialect.py`
+- `MaxComputeParser` now inherits from `HiveParser` (imported from `sqlglot.parsers.hive`) instead of `Hive.Parser`
+- `MaxComputeGenerator` now inherits from `HiveGenerator` (imported from `sqlglot.generators.hive`) instead of `Hive.Generator`
+- `sqlglot` dependency floor raised to `>=30.1.0` (first release with split `parsers/` and `generators/` modules)
 
 ### Fixed (parser + generator correctness)
 
@@ -32,7 +39,7 @@
 
 ### Changed (internal)
 
-- Dialect split: `maxcompute.py` now delegates to `parser.py` and `generator.py` (mirrors sqlglot's own mypyc-compile refactor)
+- Dialect split: `dialect.py` now delegates to `parser.py` and `generator.py` (mirrors sqlglot's own mypyc-compile refactor)
 
 ### Tests
 

CLAUDE.md

@@ -28,23 +28,23 @@ uv run pytest tests/test_foo.py::test_bar
 
 The dialect is split across three files in `src/sqlglot_maxcompute/`:
 
-- **`parser.py`** — `MaxComputeParser(Hive.Parser)`: `FUNCTIONS` dict mapping MaxCompute function names to canonical `sqlglot.exp` nodes; `PROPERTY_PARSERS` for `LIFECYCLE`, `RANGE`, and `AUTO`; helper builders `_build_dateadd`, `_build_datetrunc`.
-- **`generator.py`** — `MaxComputeGenerator(Hive.Generator)`: `TYPE_MAPPING`, `TRANSFORMS`, and named `_sql` methods that map canonical AST nodes back to MaxCompute SQL.
-- **`maxcompute.py`** — `MaxCompute(Hive)`: slim coordinator that sets `TIME_MAPPING`/`DATE_FORMAT`/`TIME_FORMAT`, adds `Tokenizer` keywords (`EXPORT`, `LIFECYCLE`, `OPTION`), and wires `Parser = MaxComputeParser` / `Generator = MaxComputeGenerator`.
+- **`parser.py`** — `MaxComputeParser(HiveParser)`: `FUNCTIONS` dict mapping MaxCompute function names to canonical `sqlglot.exp` nodes; `PROPERTY_PARSERS` for `LIFECYCLE`, `RANGE`, and `AUTO`; helper builders `_build_dateadd`, `_build_datetrunc`.
+- **`generator.py`** — `MaxComputeGenerator(HiveGenerator)`: `TYPE_MAPPING`, `TRANSFORMS`, and named `_sql` methods that map canonical AST nodes back to MaxCompute SQL.
+- **`dialect.py`** — `MaxCompute(Hive)`: slim coordinator that sets `TIME_MAPPING`/`DATE_FORMAT`/`TIME_FORMAT`, adds `Tokenizer` keywords (`EXPORT`, `LIFECYCLE`, `OPTION`), and wires `Parser = MaxComputeParser` / `Generator = MaxComputeGenerator`.
 
 The dialect is registered as a plugin in `pyproject.toml` under `[project.entry-points."sqlglot.dialects"]`, so after installation it is automatically discoverable by sqlglot as `"maxcompute"`.
 
-This split mirrors sqlglot's own mypyc-compile refactor (parsers/generators split by file) and is required for compatibility with sqlglot ≥ 31 compiled wheels.
+This split mirrors sqlglot's own mypyc-compile refactor (parsers/generators split into `sqlglot.parsers.*` / `sqlglot.generators.*` modules) and requires sqlglot ≥ 30.1.0.
 
 `local/` contains development scratch files and references — **not part of the package**:
 - `scratch.py` — keyword comparison scratch script
-- `sqlglot/` — full clone of the sqlglot repo for reference (expressions, dialects, generator internals); `sqlglot/posts/` contains official guides (`onboarding.md` for architecture deep-dive, `ast_primer.md` for AST tutorial). Note: local clone is newer than installed (30.0.1) — dialect parsers moved to `parsers/`, expressions split into `expressions/` package
+- `sqlglot/` — full clone of the sqlglot repo for reference (expressions, dialects, generator internals); `sqlglot/posts/` contains official guides (`onboarding.md` for architecture deep-dive, `ast_primer.md` for AST tutorial). Parsers live in `parsers/`, generators in `generators/`, expressions in `expressions/` package
 - `ydb-sqlglot-plugin/` — YDB dialect plugin, used as reference for how a well-behaved plugin is structured
 - `maxcompute_doc/` — MaxCompute official function documentation (e.g., `date_func.md`, `func_comparison.md`)
 
 ## Implementation Status
 
-The dialect is complete at v0.3.2:
+The dialect is complete at v0.4.0:
 - **Parser**: ~65 functions explicitly mapped (date/time, string, aggregate, array, map); remainder inherited from Hive.
 - **Generator**: `TRANSFORMS` + named `_sql` methods for all major expression types; Hive handles the rest.
 - **Tests**: 40 test methods, 186 subtests covering parse, round-trip, and cross-dialect transpilation.

README.md

@@ -10,7 +10,7 @@ Registers the `maxcompute` dialect via Python entry points so that SQLGlot can p
 pip install sqlglot-maxcompute
 ```
 
-Requires Python ≥ 3.9 and SQLGlot ≥ 29.
+Requires Python ≥ 3.9 and SQLGlot ≥ 30.1.
 
 ## Usage
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlglot-maxcompute"
-version = "0.3.2"
+version = "0.4.0"
 description = "MaxCompute dialect plugin for SQLGlot"
 readme = "README.md"
 license = { text = "MIT" }
@@ -9,7 +9,7 @@ authors = [
 ]
 requires-python = ">=3.9"
 dependencies = [
-    "sqlglot>=29.0.0,<31",
+    "sqlglot>=30.1.0,<31",
 ]
 classifiers = [
     "Development Status :: 3 - Alpha",
@@ -38,4 +38,4 @@ dev = [
 testpaths = ["tests"]
 
 [project.entry-points."sqlglot.dialects"]
-maxcompute = "sqlglot_maxcompute.maxcompute:MaxCompute"
+maxcompute = "sqlglot_maxcompute.dialect:MaxCompute"

src/sqlglot_maxcompute/__init__.py

@@ -1,4 +1,4 @@
-from sqlglot_maxcompute.maxcompute import MaxCompute
+from sqlglot_maxcompute.dialect import MaxCompute
 from sqlglot_maxcompute.parser import MaxComputeParser
 from sqlglot_maxcompute.generator import MaxComputeGenerator
 

src/sqlglot_maxcompute/maxcompute.py src/sqlglot_maxcompute/dialect.pysrc/sqlglot_maxcompute/maxcompute.py renamed to src/sqlglot_maxcompute/dialect.py

@@ -3,7 +3,7 @@
 import typing as t
 
 from sqlglot import exp
-from sqlglot.dialects.hive import Hive
+from sqlglot.generators.hive import HiveGenerator
 from sqlglot.dialects.dialect import rename_func, unit_to_str
 from sqlglot.transforms import (
     move_schema_columns_to_partitioned_by,
@@ -13,7 +13,12 @@
 )
 
 
-_AUTO_PARTITION_TYPES = (exp.DateTrunc, exp.TimestampTrunc, exp.DatetimeTrunc, exp.Alias)
+_AUTO_PARTITION_TYPES = (
+    exp.DateTrunc,
+    exp.TimestampTrunc,
+    exp.DatetimeTrunc,
+    exp.Alias,
+)
 
 
 def _move_schema_columns_to_partitioned_by(expression: exp.Expr) -> exp.Expr:
@@ -25,17 +30,17 @@ def _move_schema_columns_to_partitioned_by(expression: exp.Expr) -> exp.Expr:
     return move_schema_columns_to_partitioned_by(expression)
 
 
-class MaxComputeGenerator(Hive.Generator):
+class MaxComputeGenerator(HiveGenerator):
     TYPE_MAPPING = {
-        **Hive.Generator.TYPE_MAPPING,
+        **HiveGenerator.TYPE_MAPPING,
         exp.DType.DATETIME: "DATETIME",
         exp.DType.VARCHAR: "STRING",
         exp.DType.CHAR: "STRING",
         exp.DType.TEXT: "STRING",
     }
 
     TRANSFORMS = {
-        **Hive.Generator.TRANSFORMS,
+        **HiveGenerator.TRANSFORMS,
         exp.Create: preprocess(
             [
                 remove_unique_constraints,
@@ -76,14 +81,24 @@ class MaxComputeGenerator(Hive.Generator):
         # Numeric truncation: TRUNC(n, d)
         exp.Trunc: lambda self, e: self.func("TRUNC", e.this, e.args.get("decimals")),
         # String position: MaxCompute uses INSTR(str, substr), not LOCATE(substr, str)
-        exp.StrPosition: lambda self, e: self.func("INSTR", e.this, e.args.get("substr"), e.args.get("position")),
+        exp.StrPosition: lambda self, e: self.func(
+            "INSTR", e.this, e.args.get("substr"), e.args.get("position")
+        ),
         # TO_DATE(str, fmt) returns DATETIME — modeled as StrToTime; emit TO_DATE in MaxCompute
-        exp.StrToTime: lambda self, e: self.func("TO_DATE", e.this, e.args.get("format")),
+        exp.StrToTime: lambda self, e: self.func(
+            "TO_DATE", e.this, e.args.get("format")
+        ),
     }
 
     def _dateadd_sql(
         self,
-        expression: exp.TsOrDsAdd | exp.DateAdd | exp.DateSub | exp.TimestampAdd | exp.DatetimeAdd,
+        expression: (
+            exp.TsOrDsAdd
+            | exp.DateAdd
+            | exp.DateSub
+            | exp.TimestampAdd
+            | exp.DatetimeAdd
+        ),
     ) -> str:
         unit = unit_to_str(expression) if expression.args.get("unit") else "'DAY'"
         delta = expression.expression
@@ -122,18 +137,26 @@ def tochar_sql(self, expression: exp.ToChar) -> str:
         return self.func("TO_CHAR", expression.this, expression.args.get("format"))
 
     def substring_sql(self, expression: exp.Substring) -> str:
-        return self.func("SUBSTR", expression.this, expression.args.get("start"), expression.args.get("length"))
+        return self.func(
+            "SUBSTR",
+            expression.this,
+            expression.args.get("start"),
+            expression.args.get("length"),
+        )
 
     def extract_sql(self, expression: exp.Extract) -> str:
         unit = expression.this
-        return self.func("DATEPART", expression.expression, exp.Literal.string(unit.name))
+        return self.func(
+            "DATEPART", expression.expression, exp.Literal.string(unit.name)
+        )
 
     def mod_sql(self, expression: exp.Mod) -> str:
         # Reverse the WEEKDAY parser transform: (DAYOFWEEK(x) + 5) % 7 → WEEKDAY(x)
         rhs = expression.expression
         lhs = expression.this
         if (
-            isinstance(rhs, exp.Literal) and rhs.this == "7"
+            isinstance(rhs, exp.Literal)
+            and rhs.this == "7"
             and isinstance(lhs, exp.Paren)
             and isinstance(lhs.this, exp.Add)
             and isinstance(lhs.this.this, exp.DayOfWeek)
@@ -152,7 +175,9 @@ def _partitioned_by_sql(self, expression: exp.PartitionedByProperty) -> str:
                 inner = inner.this
             unit = inner.args.get("unit")
             unit_str = unit.name.lower() if unit else ""
-            trunc_sql = self.func("TRUNC_TIME", inner.this, exp.Literal.string(unit_str))
+            trunc_sql = self.func(
+                "TRUNC_TIME", inner.this, exp.Literal.string(unit_str)
+            )
             return f"AUTO PARTITIONED BY ({trunc_sql}{alias_sql})"
         return f"PARTITIONED BY {self.sql(expression, 'this')}"
 
@@ -163,7 +188,9 @@ def clusteredbyproperty_sql(self, expression: exp.ClusteredByProperty) -> str:
     def datatype_sql(self, expression: exp.DataType) -> str:
         # VARCHAR and CHAR map to STRING in MaxCompute, with no length parameters
         if expression.this in (exp.DType.VARCHAR, exp.DType.CHAR):
-            return self.TYPE_MAPPING.get(expression.this, super().datatype_sql(expression))
+            return self.TYPE_MAPPING.get(
+                expression.this, super().datatype_sql(expression)
+            )
         return super().datatype_sql(expression)
 
     def properties_sql(self, expression: exp.Properties) -> str:

src/sqlglot_maxcompute/generator.py

@@ -4,7 +4,7 @@
 import typing as t
 
 from sqlglot import exp
-from sqlglot.dialects.hive import Hive
+from sqlglot.parsers.hive import HiveParser
 from sqlglot.dialects.dialect import build_timetostr_or_tochar
 from sqlglot.helper import seq_get
 from sqlglot.tokens import TokenType
@@ -61,9 +61,9 @@ def _build_datetrunc(
     return exp.DateTrunc(unit=unit, this=this)
 
 
-class MaxComputeParser(Hive.Parser):
+class MaxComputeParser(HiveParser):
     FUNCTIONS = {
-        **Hive.Parser.FUNCTIONS,
+        **HiveParser.FUNCTIONS,
         # Hive overrides: MaxCompute accepts date/datetime/timestamp/string directly
         # without needing TsOrDsToDate wrapping
         "DAY": exp.Day.from_arg_list,
@@ -86,7 +86,9 @@ class MaxComputeParser(Hive.Parser):
         # Hive override: produce exp.DateSub so _dateadd_sql emits DATEADD(date, -n, unit)
         # cleanly. Hive maps DATE_SUB to TsOrDsAdd(expression=Mul(n, -1)) which generates
         # "3 * -1" in the output.
-        "DATE_SUB": lambda args: exp.DateSub(this=seq_get(args, 0), expression=seq_get(args, 1)),
+        "DATE_SUB": lambda args: exp.DateSub(
+            this=seq_get(args, 0), expression=seq_get(args, 1)
+        ),
         # Date arithmetic
         "DATEADD": _build_dateadd,
         "DATEDIFF": lambda args: exp.DateDiff(
@@ -118,7 +120,10 @@ class MaxComputeParser(Hive.Parser):
         "MINUTE": exp.Minute.from_arg_list,
         "SECOND": exp.Second.from_arg_list,
         "QUARTER": exp.Quarter.from_arg_list,
-        "WEEKDAY": lambda args: exp.paren(exp.DayOfWeek(this=seq_get(args, 0)) + 5, copy=False) % 7,
+        "WEEKDAY": lambda args: exp.paren(
+            exp.DayOfWeek(this=seq_get(args, 0)) + 5, copy=False
+        )
+        % 7,
         "WEEKOFYEAR": exp.WeekOfYear.from_arg_list,
         # Last/next day
         "LAST_DAY": exp.LastDay.from_arg_list,
@@ -141,7 +146,9 @@ class MaxComputeParser(Hive.Parser):
         ),
         "ISDATE": lambda args: exp.not_(
             exp.Is(
-                this=exp.TsOrDsToDate(this=seq_get(args, 0), format=seq_get(args, 1), safe=True),
+                this=exp.TsOrDsToDate(
+                    this=seq_get(args, 0), format=seq_get(args, 1), safe=True
+                ),
                 expression=exp.Null(),
             )
         ),
@@ -198,7 +205,7 @@ class MaxComputeParser(Hive.Parser):
     }
 
     PROPERTY_PARSERS = {
-        **Hive.Parser.PROPERTY_PARSERS,
+        **HiveParser.PROPERTY_PARSERS,
         # LIFECYCLE n — MaxCompute table retention in days. Stored as a generic
         # exp.Property with a Var key so no custom expression class is needed and
         # sqlglot's PROPERTIES_LOCATION contract is not broken.
@@ -209,7 +216,9 @@ class MaxComputeParser(Hive.Parser):
         "AUTO": lambda self: self._parse_auto_partition(),
     }
 
-    def _parse_auto_partition(self) -> exp.PartitionedByProperty | exp.AutoRefreshProperty | None:
+    def _parse_auto_partition(
+        self,
+    ) -> exp.PartitionedByProperty | exp.AutoRefreshProperty | None:
         if self._match(TokenType.PARTITION_BY):
             self._match(TokenType.L_PAREN)
             expr = self._parse_conjunction()