Address review comments

- Update doc comments to use [Dialect](link) format
- Remove dialect-specific inline comments
- Rename parse_column_def_for_partition to parse_partitioned_by_column_def
- Use maybe_parse instead of manual token checking
- Use backticks for SQL keywords in doc comments

Author: funcpp

src/ast/mod.rs

@@ -4670,17 +4670,23 @@ pub enum Statement {
         name: ObjectName,
         /// Whether the `TABLE` keyword was present (ClickHouse uses `OPTIMIZE TABLE`, Databricks uses `OPTIMIZE`).
         has_table_keyword: bool,
-        /// Optional cluster identifier (ClickHouse).
+        /// Optional cluster identifier.
+        /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/optimize)
         on_cluster: Option<Ident>,
-        /// Optional partition spec (ClickHouse).
+        /// Optional partition spec.
+        /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/optimize)
         partition: Option<Partition>,
-        /// Whether `FINAL` was specified (ClickHouse).
+        /// Whether `FINAL` was specified.
+        /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/optimize)
         include_final: bool,
-        /// Optional deduplication settings (ClickHouse).
+        /// Optional deduplication settings.
+        /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/optimize)
         deduplicate: Option<Deduplicate>,
-        /// Optional WHERE predicate (Databricks).
+        /// Optional WHERE predicate.
+        /// [Databricks](https://docs.databricks.com/en/sql/language-manual/delta-optimize.html)
         predicate: Option<Expr>,
-        /// Optional ZORDER BY columns (Databricks).
+        /// Optional ZORDER BY columns.
+        /// [Databricks](https://docs.databricks.com/en/sql/language-manual/delta-optimize.html)
         zorder: Option<Vec<Expr>>,
     },
     /// ```sql

src/parser/mod.rs

@@ -3334,9 +3334,7 @@ impl<'a> Parser<'a> {
     /// Syntax:
     ///
     /// ```sql
-    /// -- BigQuery style
     /// [field_name] field_type
-    /// -- Databricks/Hive style (colon separator)
     /// field_name: field_type
     /// ```
     ///
@@ -3348,17 +3346,13 @@ impl<'a> Parser<'a> {
     ) -> Result<(StructField, MatchedTrailingBracket), ParserError> {
         // Look beyond the next item to infer whether both field name
         // and type are specified.
-        // Supports both:
-        //   - `field_name field_type` (BigQuery style)
-        //   - `field_name: field_type` (Databricks/Hive style)
         let is_named_field = matches!(
             (self.peek_nth_token(0).token, self.peek_nth_token(1).token),
             (Token::Word(_), Token::Word(_)) | (Token::Word(_), Token::Colon)
         );
 
         let field_name = if is_named_field {
             let name = self.parse_identifier()?;
-            // Consume optional colon separator (Databricks/Hive style)
             let _ = self.consume_token(&Token::Colon);
             Some(name)
         } else {
@@ -7890,33 +7884,29 @@ impl<'a> Parser<'a> {
     pub fn parse_hive_distribution(&mut self) -> Result<HiveDistributionStyle, ParserError> {
         if self.parse_keywords(&[Keyword::PARTITIONED, Keyword::BY]) {
             self.expect_token(&Token::LParen)?;
-            let columns = self.parse_comma_separated(Parser::parse_column_def_for_partition)?;
+            let columns = self.parse_comma_separated(Parser::parse_partitioned_by_column_def)?;
             self.expect_token(&Token::RParen)?;
             Ok(HiveDistributionStyle::PARTITIONED { columns })
         } else {
             Ok(HiveDistributionStyle::NONE)
         }
     }
 
-    /// Parse column definition for PARTITIONED BY clause.
+    /// Parse column definition for `PARTITIONED BY` clause.
     ///
-    /// Databricks allows partition columns without types when referencing
+    /// Allows partition columns without types when referencing
     /// columns already defined in the table specification:
     /// ```sql
     /// CREATE TABLE t (col1 STRING, col2 INT) PARTITIONED BY (col1)
     /// CREATE TABLE t (col1 STRING) PARTITIONED BY (col2 INT)
     /// ```
     ///
-    /// See [Databricks](https://docs.databricks.com/en/sql/language-manual/sql-ref-partition.html)
-    fn parse_column_def_for_partition(&mut self) -> Result<ColumnDef, ParserError> {
+    /// [Databricks](https://docs.databricks.com/en/sql/language-manual/sql-ref-partition.html)
+    fn parse_partitioned_by_column_def(&mut self) -> Result<ColumnDef, ParserError> {
         let name = self.parse_identifier()?;
-
-        // Check if the next token indicates there's no type specified
-        // (comma or closing paren means end of this column definition)
-        let data_type = match self.peek_token().token {
-            Token::Comma | Token::RParen => DataType::Unspecified,
-            _ => self.parse_data_type()?,
-        };
+        let data_type = self
+            .maybe_parse(|parser| parser.parse_data_type())?
+            .unwrap_or(DataType::Unspecified);
 
         Ok(ColumnDef {
             name,
@@ -18256,7 +18246,6 @@ impl<'a> Parser<'a> {
     /// ```
     /// [Databricks](https://docs.databricks.com/en/sql/language-manual/delta-optimize.html)
     pub fn parse_optimize_table(&mut self) -> Result<Statement, ParserError> {
-        // Check for TABLE keyword (ClickHouse uses it, Databricks does not)
         let has_table_keyword = self.parse_keyword(Keyword::TABLE);
 
         let name = self.parse_object_name(false)?;