apache · finchxxia · Jun 18, 2026 · Jun 18, 2026
diff --git a/examples/cli.rs b/examples/cli.rs
@@ -52,6 +52,7 @@ $ cargo run --example cli - [--dialectname]
         "--postgres" => Box::new(PostgreSqlDialect {}),
         "--ms" => Box::new(MsSqlDialect {}),
         "--mysql" => Box::new(MySqlDialect {}),
+        "--doris" => Box::new(DorisDialect {}),
         "--snowflake" => Box::new(SnowflakeDialect {}),
         "--hive" => Box::new(HiveDialect {}),
         "--redshift" => Box::new(RedshiftSqlDialect {}),

diff --git a/src/ast/ddl.rs b/src/ast/ddl.rs
@@ -2001,6 +2001,12 @@ pub enum ColumnOption {
     /// ```
     /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/invisible-columns.html
     Invisible,
+    /// Column-level auto-increment option with an optional start value.
+    ///
+    /// MySQL and Generic use this unified AST node without a start value.
+    /// Dialects that support a start value can use `Some`.
+    /// Syntax: `AUTO_INCREMENT` or `AUTO_INCREMENT(<start_value>)`.
+    AutoIncrement(Option<u64>),
 }
 
 impl From<UniqueConstraint> for ColumnOption {
@@ -2149,6 +2155,13 @@ impl fmt::Display for ColumnOption {
             Invisible => {
                 write!(f, "INVISIBLE")
             }
+            AutoIncrement(start) => {
+                f.write_str("AUTO_INCREMENT")?;
+                if let Some(start) = start {
+                    write!(f, "({start})")?;
+                }
+                Ok(())
+            }
         }
     }
 }

diff --git a/src/ast/spans.rs b/src/ast/spans.rs
@@ -822,6 +822,7 @@ impl Spanned for RaiseStatementValue {
 /// - [ColumnOption::PrimaryKey]
 /// - [ColumnOption::Unique]
 /// - [ColumnOption::DialectSpecific]
+/// - [ColumnOption::AutoIncrement]
 /// - [ColumnOption::Generated]
 impl Spanned for ColumnOption {
     fn span(&self) -> Span {
@@ -849,6 +850,7 @@ impl Spanned for ColumnOption {
             ColumnOption::Tags(..) => Span::empty(),
             ColumnOption::Srid(..) => Span::empty(),
             ColumnOption::Invisible => Span::empty(),
+            ColumnOption::AutoIncrement(_) => Span::empty(),
         }
     }
 }

diff --git a/src/dialect/doris.rs b/src/dialect/doris.rs
@@ -0,0 +1,53 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use crate::dialect::Dialect;
+
+/// A [`Dialect`] for [Apache Doris](https://doris.apache.org/).
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct DorisDialect {}
+
+impl Dialect for DorisDialect {
+    fn is_delimited_identifier_start(&self, ch: char) -> bool {
+        ch == '`'
+    }
+
+    fn identifier_quote_style(&self, _identifier: &str) -> Option<char> {
+        Some('`')
+    }
+
+    fn is_identifier_start(&self, ch: char) -> bool {
+        ch.is_ascii_alphabetic() || ch == '_' || !ch.is_ascii()
+    }
+
+    fn is_identifier_part(&self, ch: char) -> bool {
+        self.is_identifier_start(ch) || ch.is_ascii_digit()
+    }
+
+    fn supports_string_literal_backslash_escape(&self) -> bool {
+        true
+    }
+
+    fn ignores_wildcard_escapes(&self) -> bool {
+        true
+    }
+
+    fn supports_numeric_prefix(&self) -> bool {
+        true
+    }
+}
diff --git a/src/dialect/mod.rs b/src/dialect/mod.rs
@@ -19,6 +19,7 @@ mod ansi;
 mod bigquery;
 mod clickhouse;
 mod databricks;
+mod doris;
 mod duckdb;
 mod generic;
 mod hive;
@@ -43,6 +44,7 @@ pub use self::ansi::AnsiDialect;
 pub use self::bigquery::BigQueryDialect;
 pub use self::clickhouse::ClickHouseDialect;
 pub use self::databricks::DatabricksDialect;
+pub use self::doris::DorisDialect;
 pub use self::duckdb::DuckDbDialect;
 pub use self::generic::GenericDialect;
 pub use self::hive::HiveDialect;
@@ -1883,6 +1885,7 @@ pub fn dialect_from_str(dialect_name: impl AsRef<str>) -> Option<Box<dyn Dialect
         "bigquery" => Some(Box::new(BigQueryDialect)),
         "ansi" => Some(Box::new(AnsiDialect {})),
         "duckdb" => Some(Box::new(DuckDbDialect {})),
+        "doris" => Some(Box::new(DorisDialect {})),
         "databricks" => Some(Box::new(DatabricksDialect {})),
         "spark" | "sparksql" => Some(Box::new(SparkSqlDialect {})),
         "oracle" => Some(Box::new(OracleDialect {})),
@@ -1938,6 +1941,8 @@ mod tests {
         assert!(parse_dialect("ANSI").is::<AnsiDialect>());
         assert!(parse_dialect("duckdb").is::<DuckDbDialect>());
         assert!(parse_dialect("DuckDb").is::<DuckDbDialect>());
+        assert!(parse_dialect("doris").is::<DorisDialect>());
+        assert!(parse_dialect("Doris").is::<DorisDialect>());
         assert!(parse_dialect("DataBricks").is::<DatabricksDialect>());
         assert!(parse_dialect("databricks").is::<DatabricksDialect>());
         assert!(parse_dialect("teradata").is::<TeradataDialect>());

diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -9657,9 +9657,7 @@ impl<'a> Parser<'a> {
             && dialect_of!(self is MySqlDialect | GenericDialect)
         {
             // Support AUTO_INCREMENT for MySQL
-            Ok(Some(ColumnOption::DialectSpecific(vec![
-                Token::make_keyword("AUTO_INCREMENT"),
-            ])))
+            Ok(Some(ColumnOption::AutoIncrement(None)))
         } else if self.parse_keyword(Keyword::AUTOINCREMENT)
             && dialect_of!(self is SQLiteDialect |  GenericDialect)
         {

diff --git a/src/test_utils.rs b/src/test_utils.rs
@@ -286,6 +286,7 @@ pub fn all_dialects() -> TestedDialects {
         Box::new(HiveDialect {}),
         Box::new(RedshiftSqlDialect {}),
         Box::new(MySqlDialect {}),
+        Box::new(DorisDialect {}),
         Box::new(BigQueryDialect {}),
         Box::new(SQLiteDialect {}),
         Box::new(DuckDbDialect {}),

diff --git a/tests/sqlparser_doris.rs b/tests/sqlparser_doris.rs
@@ -0,0 +1,55 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#![warn(clippy::all)]
+//! Test SQL syntax specific to Apache Doris.
+
+#[macro_use]
+mod test_utils;
+
+use sqlparser::dialect::{Dialect, DorisDialect, GenericDialect};
+use test_utils::*;
+
+fn doris() -> TestedDialects {
+    TestedDialects::new(vec![Box::new(DorisDialect {})])
+}
+
+fn doris_and_generic() -> TestedDialects {
+    TestedDialects::new(vec![Box::new(DorisDialect {}), Box::new(GenericDialect {})])
+}
+
+#[test]
+fn doris_identifier_and_string_literal_gates() {
+    let dialect = DorisDialect {};
+    assert_eq!(dialect.identifier_quote_style("identifier"), Some('`'));
+    assert!(dialect.is_delimited_identifier_start('`'));
+    assert!(dialect.supports_string_literal_backslash_escape());
+    assert!(dialect.ignores_wildcard_escapes());
+    assert!(dialect.supports_numeric_prefix());
+}
+
+#[test]
+fn parse_doris_strings_and_identifiers() {
+    doris().verified_stmt(
+        r#"SELECT "double quoted string", 'single quoted string', `select` FROM `db`.`table`"#,
+    );
+}
+
+#[test]
+fn doris_and_generic_parse_common_sql_identically() {
+    doris_and_generic().verified_stmt("SELECT 1 AS properties FROM t");
+}
diff --git a/tests/sqlparser_mysql.rs b/tests/sqlparser_mysql.rs
@@ -27,7 +27,6 @@ use sqlparser::ast::*;
 use sqlparser::dialect::{GenericDialect, MySqlDialect};
 use sqlparser::parser::{ParserError, ParserOptions};
 use sqlparser::tokenizer::Span;
-use sqlparser::tokenizer::Token;
 use test_utils::*;
 
 #[macro_use]
@@ -661,9 +660,7 @@ fn parse_create_table_auto_increment() {
                         },
                         ColumnOptionDef {
                             name: None,
-                            option: ColumnOption::DialectSpecific(vec![Token::make_keyword(
-                                "AUTO_INCREMENT"
-                            )]),
+                            option: ColumnOption::AutoIncrement(None),
                         },
                     ],
                 }],
@@ -770,9 +767,7 @@ fn parse_create_table_primary_and_unique_key() {
                                 },
                                 ColumnOptionDef {
                                     name: None,
-                                    option: ColumnOption::DialectSpecific(vec![
-                                        Token::make_keyword("AUTO_INCREMENT")
-                                    ]),
+                                    option: ColumnOption::AutoIncrement(None),
                                 },
                             ],
                         },