Add support column prefix index for MySQL

Author: Alex.Mo

src/ast/ddl.rs

@@ -32,8 +32,9 @@ use crate::ast::value::escape_single_quote_string;
 use crate::ast::{
     display_comma_separated, display_separated, CommentDef, CreateFunctionBody,
     CreateFunctionUsing, DataType, Expr, FunctionBehavior, FunctionCalledOnNull,
-    FunctionDeterminismSpecifier, FunctionParallel, Ident, MySQLColumnPosition, ObjectName,
-    OperateFunctionArg, OrderByExpr, ProjectionSelect, SequenceOptions, SqlOption, Tag, Value,
+    FunctionDeterminismSpecifier, FunctionParallel, Ident, IndexField, MySQLColumnPosition,
+    ObjectName, OperateFunctionArg, OrderByExpr, ProjectionSelect, SequenceOptions, SqlOption, Tag,
+    Value,
 };
 use crate::keywords::Keyword;
 use crate::tokenizer::Token;
@@ -832,8 +833,8 @@ pub enum TableConstraint {
         ///
         /// [1]: IndexType
         index_type: Option<IndexType>,
-        /// Identifiers of the columns that are unique.
-        columns: Vec<Ident>,
+        /// Index field list.
+        index_fields: Vec<IndexField>,
         index_options: Vec<IndexOption>,
         characteristics: Option<ConstraintCharacteristics>,
         /// Optional Postgres nulls handling: `[ NULLS [ NOT ] DISTINCT ]`
@@ -868,8 +869,8 @@ pub enum TableConstraint {
         ///
         /// [1]: IndexType
         index_type: Option<IndexType>,
-        /// Identifiers of the columns that form the primary key.
-        columns: Vec<Ident>,
+        /// Index field list that form the primary key.
+        index_fields: Vec<IndexField>,
         index_options: Vec<IndexOption>,
         characteristics: Option<ConstraintCharacteristics>,
     },
@@ -907,8 +908,10 @@ pub enum TableConstraint {
         ///
         /// [1]: IndexType
         index_type: Option<IndexType>,
-        /// Referred column identifier list.
-        columns: Vec<Ident>,
+        /// [Index field list][1].
+        ///
+        /// [1]: IndexField
+        index_fields: Vec<IndexField>,
     },
     /// MySQLs [fulltext][1] definition. Since the [`SPATIAL`][2] definition is exactly the same,
     /// and MySQL displays both the same way, it is part of this definition as well.
@@ -930,8 +933,8 @@ pub enum TableConstraint {
         index_type_display: KeyOrIndexDisplay,
         /// Optional index name.
         opt_index_name: Option<Ident>,
-        /// Referred column identifier list.
-        columns: Vec<Ident>,
+        /// Index field list.
+        index_fields: Vec<IndexField>,
     },
 }
 
@@ -943,7 +946,7 @@ impl fmt::Display for TableConstraint {
                 index_name,
                 index_type_display,
                 index_type,
-                columns,
+                index_fields,
                 index_options,
                 characteristics,
                 nulls_distinct,
@@ -954,7 +957,7 @@ impl fmt::Display for TableConstraint {
                     display_constraint_name(name),
                     display_option_spaced(index_name),
                     display_option(" USING ", "", index_type),
-                    display_comma_separated(columns),
+                    display_comma_separated(index_fields),
                 )?;
 
                 if !index_options.is_empty() {
@@ -968,7 +971,7 @@ impl fmt::Display for TableConstraint {
                 name,
                 index_name,
                 index_type,
-                columns,
+                index_fields,
                 index_options,
                 characteristics,
             } => {
@@ -978,7 +981,7 @@ impl fmt::Display for TableConstraint {
                     display_constraint_name(name),
                     display_option_spaced(index_name),
                     display_option(" USING ", "", index_type),
-                    display_comma_separated(columns),
+                    display_comma_separated(index_fields),
                 )?;
 
                 if !index_options.is_empty() {
@@ -1025,7 +1028,7 @@ impl fmt::Display for TableConstraint {
                 display_as_key,
                 name,
                 index_type,
-                columns,
+                index_fields,
             } => {
                 write!(f, "{}", if *display_as_key { "KEY" } else { "INDEX" })?;
                 if let Some(name) = name {
@@ -1034,15 +1037,16 @@ impl fmt::Display for TableConstraint {
                 if let Some(index_type) = index_type {
                     write!(f, " USING {index_type}")?;
                 }
-                write!(f, " ({})", display_comma_separated(columns))?;
+
+                write!(f, " ({})", display_comma_separated(index_fields))?;
 
                 Ok(())
             }
             Self::FulltextOrSpatial {
                 fulltext,
                 index_type_display,
                 opt_index_name,
-                columns,
+                index_fields,
             } => {
                 if *fulltext {
                     write!(f, "FULLTEXT")?;
@@ -1056,7 +1060,7 @@ impl fmt::Display for TableConstraint {
                     write!(f, " {name}")?;
                 }
 
-                write!(f, " ({})", display_comma_separated(columns))?;
+                write!(f, " ({})", display_comma_separated(index_fields))?;
 
                 Ok(())
             }

src/ast/mod.rs

@@ -8591,6 +8591,61 @@ pub enum CopyIntoSnowflakeKind {
     Location,
 }
 
+/// Index Field
+///
+/// This structure used here [`MySQL` CREATE INDEX][1], [`PostgreSQL` CREATE INDEX][2], [`MySQL` CREATE TABLE][3].
+///
+/// [1]: https://dev.mysql.com/doc/refman/8.3/en/create-index.html
+/// [2]: https://www.postgresql.org/docs/17/sql-createindex.html
+/// [3]: https://dev.mysql.com/doc/refman/8.3/en/create-table.html
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct IndexField {
+    pub expr: IndexExpr,
+    /// Optional `ASC` or `DESC`
+    pub asc: Option<bool>,
+}
+
+impl fmt::Display for IndexField {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.expr)?;
+        match self.asc {
+            Some(true) => write!(f, " ASC")?,
+            Some(false) => write!(f, " DESC")?,
+            None => (),
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum IndexExpr {
+    Column(Ident),
+    /// Mysql specific syntax
+    ///
+    /// See [Mysql documentation](https://dev.mysql.com/doc/refman/8.3/en/create-index.html)
+    /// for more details.
+    ColumnPrefix {
+        column: Ident,
+        length: u64,
+    },
+    Functional(Box<Expr>),
+}
+
+impl fmt::Display for IndexExpr {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            IndexExpr::Column(column) => write!(f, "{}", column),
+            IndexExpr::ColumnPrefix { column, length } => write!(f, "{column}({length})"),
+            IndexExpr::Functional(expr) => write!(f, "({expr})"),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/ast/spans.rs

@@ -632,29 +632,27 @@ impl Spanned for TableConstraint {
                 index_name,
                 index_type_display: _,
                 index_type: _,
-                columns,
+                index_fields: _,
                 index_options: _,
                 characteristics,
                 nulls_distinct: _,
             } => union_spans(
                 name.iter()
                     .map(|i| i.span)
                     .chain(index_name.iter().map(|i| i.span))
-                    .chain(columns.iter().map(|i| i.span))
                     .chain(characteristics.iter().map(|i| i.span())),
             ),
             TableConstraint::PrimaryKey {
                 name,
                 index_name,
                 index_type: _,
-                columns,
+                index_fields: _,
                 index_options: _,
                 characteristics,
             } => union_spans(
                 name.iter()
                     .map(|i| i.span)
                     .chain(index_name.iter().map(|i| i.span))
-                    .chain(columns.iter().map(|i| i.span))
                     .chain(characteristics.iter().map(|i| i.span())),
             ),
             TableConstraint::ForeignKey {
@@ -682,23 +680,14 @@ impl Spanned for TableConstraint {
                 display_as_key: _,
                 name,
                 index_type: _,
-                columns,
-            } => union_spans(
-                name.iter()
-                    .map(|i| i.span)
-                    .chain(columns.iter().map(|i| i.span)),
-            ),
+                index_fields: _,
+            } => union_spans(name.iter().map(|i| i.span)),
             TableConstraint::FulltextOrSpatial {
                 fulltext: _,
                 index_type_display: _,
                 opt_index_name,
-                columns,
-            } => union_spans(
-                opt_index_name
-                    .iter()
-                    .map(|i| i.span)
-                    .chain(columns.iter().map(|i| i.span)),
-            ),
+                index_fields: _,
+            } => union_spans(opt_index_name.iter().map(|i| i.span)),
         }
     }
 }