feat: use edition 2024

Cargo.toml

@@ -30,7 +30,7 @@ include = [
     "Cargo.toml",
     "LICENSE.TXT",
 ]
-edition = "2021"
+edition = "2024"
 
 [lib]
 name = "sqlparser"

examples/cli.rs

@@ -21,7 +21,7 @@
 //! Run with `cargo run --example cli`
 
 use std::fs;
-use std::io::{stdin, Read};
+use std::io::{Read, stdin};
 
 use simple_logger::SimpleLogger;
 use sqlparser::dialect::*;

src/ast/data_type.rs

@@ -25,9 +25,9 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "visitor")]
 use sqlparser_derive::{Visit, VisitMut};
 
-use crate::ast::{display_comma_separated, Expr, ObjectName, StructField, UnionField};
+use crate::ast::{Expr, ObjectName, StructField, UnionField, display_comma_separated};
 
-use super::{value::escape_single_quote_string, ColumnDef};
+use super::{ColumnDef, value::escape_single_quote_string};
 
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

src/ast/dcl.rs

@@ -28,8 +28,8 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "visitor")]
 use sqlparser_derive::{Visit, VisitMut};
 
-use super::{display_comma_separated, Expr, Ident, Password};
-use crate::ast::{display_separated, ObjectName};
+use super::{Expr, Ident, Password, display_comma_separated};
+use crate::ast::{ObjectName, display_separated};
 
 /// An option in `ROLE` statement.
 ///

src/ast/ddl.rs

@@ -30,10 +30,10 @@ use sqlparser_derive::{Visit, VisitMut};
 
 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,
+    CommentDef, CreateFunctionBody, CreateFunctionUsing, DataType, Expr, FunctionBehavior,
+    FunctionCalledOnNull, FunctionDeterminismSpecifier, FunctionParallel, Ident,
+    MySQLColumnPosition, ObjectName, OperateFunctionArg, OrderByExpr, ProjectionSelect,
+    SequenceOptions, SqlOption, Tag, Value, display_comma_separated, display_separated,
 };
 use crate::keywords::Keyword;
 use crate::tokenizer::Token;
@@ -1840,11 +1840,7 @@ impl ConstraintCharacteristics {
     fn enforced_text(&self) -> Option<&'static str> {
         self.enforced.map(
             |enforced| {
-                if enforced {
-                    "ENFORCED"
-                } else {
-                    "NOT ENFORCED"
-                }
+                if enforced { "ENFORCED" } else { "NOT ENFORCED" }
             },
         )
     }

src/ast/dml.rs

@@ -32,12 +32,12 @@ use sqlparser_derive::{Visit, VisitMut};
 pub use super::ddl::{ColumnDef, TableConstraint};
 
 use super::{
-    display_comma_separated, display_separated, query::InputFormatClause, Assignment, ClusteredBy,
-    CommentDef, Expr, FileFormat, FromTable, HiveDistributionStyle, HiveFormat, HiveIOFormat,
-    HiveRowFormat, Ident, InsertAliases, MysqlInsertPriority, ObjectName, OnCommit, OnInsert,
-    OneOrManyWithParens, OrderByExpr, Query, RowAccessPolicy, SelectItem, Setting, SqlOption,
-    SqliteOnConflict, StorageSerializationPolicy, TableEngine, TableObject, TableWithJoins, Tag,
-    WrappedCollection,
+    Assignment, ClusteredBy, CommentDef, Expr, FileFormat, FromTable, HiveDistributionStyle,
+    HiveFormat, HiveIOFormat, HiveRowFormat, Ident, InsertAliases, MysqlInsertPriority, ObjectName,
+    OnCommit, OnInsert, OneOrManyWithParens, OrderByExpr, Query, RowAccessPolicy, SelectItem,
+    Setting, SqlOption, SqliteOnConflict, StorageSerializationPolicy, TableEngine, TableObject,
+    TableWithJoins, Tag, WrappedCollection, display_comma_separated, display_separated,
+    query::InputFormatClause,
 };
 
 /// CREATE INDEX statement.
@@ -225,16 +225,15 @@ impl Display for CreateTable {
             "CREATE {or_replace}{external}{global}{temporary}{transient}{volatile}{iceberg}TABLE {if_not_exists}{name}",
             or_replace = if self.or_replace { "OR REPLACE " } else { "" },
             external = if self.external { "EXTERNAL " } else { "" },
-            global = self.global
-                .map(|global| {
-                    if global {
-                        "GLOBAL "
-                    } else {
-                        "LOCAL "
-                    }
-                })
+            global = self
+                .global
+                .map(|global| { if global { "GLOBAL " } else { "LOCAL " } })
                 .unwrap_or(""),
-            if_not_exists = if self.if_not_exists { "IF NOT EXISTS " } else { "" },
+            if_not_exists = if self.if_not_exists {
+                "IF NOT EXISTS "
+            } else {
+                ""
+            },
             temporary = if self.temporary { "TEMPORARY " } else { "" },
             transient = if self.transient { "TRANSIENT " } else { "" },
             volatile = if self.volatile { "VOLATILE " } else { "" },

src/ast/mod.rs

@@ -85,8 +85,8 @@ pub use self::trigger::{
 };
 
 pub use self::value::{
-    escape_double_quote_string, escape_quoted_string, DateTimeField, DollarQuotedString,
-    NormalizationForm, TrimWhereField, Value,
+    DateTimeField, DollarQuotedString, NormalizationForm, TrimWhereField, Value,
+    escape_double_quote_string, escape_quoted_string,
 };
 
 use crate::ast::helpers::key_value_options::KeyValueOptions;
@@ -3708,7 +3708,7 @@ impl fmt::Display for Statement {
                     local = if *local { " LOCAL" } else { "" },
                     path = path
                 )?;
-                if let Some(ref ff) = file_format {
+                if let Some(ff) = file_format {
                     write!(f, " STORED AS {ff}")?
                 }
                 write!(f, " {source}")
@@ -3760,7 +3760,7 @@ impl fmt::Display for Statement {
                     }
                 }
 
-                if let Some(ref parts) = partitions {
+                if let Some(parts) = partitions {
                     if !parts.is_empty() {
                         write!(f, " PARTITION ({})", display_comma_separated(parts))?;
                     }
@@ -3827,7 +3827,7 @@ impl fmt::Display for Statement {
                     "ANALYZE{}{table_name}",
                     if *has_table_keyword { " TABLE " } else { " " }
                 )?;
-                if let Some(ref parts) = partitions {
+                if let Some(parts) = partitions {
                     if !parts.is_empty() {
                         write!(f, " PARTITION ({})", display_comma_separated(parts))?;
                     }
@@ -4149,7 +4149,7 @@ impl fmt::Display for Statement {
                     overwrite = if *overwrite { "OVERWRITE " } else { "" },
                     table_name = table_name,
                 )?;
-                if let Some(ref parts) = &partitioned {
+                if let Some(parts) = &partitioned {
                     if !parts.is_empty() {
                         write!(f, " PARTITION ({})", display_comma_separated(parts))?;
                     }
@@ -4253,37 +4253,37 @@ impl fmt::Display for Statement {
                     superuser = match *superuser {
                         Some(true) => " SUPERUSER",
                         Some(false) => " NOSUPERUSER",
-                        None => ""
+                        None => "",
                     },
                     create_db = match *create_db {
                         Some(true) => " CREATEDB",
                         Some(false) => " NOCREATEDB",
-                        None => ""
+                        None => "",
                     },
                     create_role = match *create_role {
                         Some(true) => " CREATEROLE",
                         Some(false) => " NOCREATEROLE",
-                        None => ""
+                        None => "",
                     },
                     inherit = match *inherit {
                         Some(true) => " INHERIT",
                         Some(false) => " NOINHERIT",
-                        None => ""
+                        None => "",
                     },
                     login = match *login {
                         Some(true) => " LOGIN",
                         Some(false) => " NOLOGIN",
-                        None => ""
+                        None => "",
                     },
                     replication = match *replication {
                         Some(true) => " REPLICATION",
                         Some(false) => " NOREPLICATION",
-                        None => ""
+                        None => "",
                     },
                     bypassrls = match *bypassrls {
                         Some(true) => " BYPASSRLS",
                         Some(false) => " NOBYPASSRLS",
-                        None => ""
+                        None => "",
                     }
                 )?;
                 if let Some(limit) = connection_limit {

src/ast/spans.rs

@@ -21,21 +21,21 @@ use core::iter;
 use crate::tokenizer::Span;
 
 use super::{
-    dcl::SecondaryRoles, AccessExpr, AlterColumnOperation, AlterIndexOperation,
-    AlterTableOperation, Array, Assignment, AssignmentTarget, CloseCursor, ClusteredIndex,
-    ColumnDef, ColumnOption, ColumnOptionDef, ConflictTarget, ConnectBy, ConstraintCharacteristics,
-    CopySource, CreateIndex, CreateTable, CreateTableOptions, Cte, Delete, DoUpdate,
-    ExceptSelectItem, ExcludeSelectItem, Expr, ExprWithAlias, Fetch, FromTable, Function,
-    FunctionArg, FunctionArgExpr, FunctionArgumentClause, FunctionArgumentList, FunctionArguments,
-    GroupByExpr, HavingBound, IlikeSelectItem, Insert, Interpolate, InterpolateExpr, Join,
-    JoinConstraint, JoinOperator, JsonPath, JsonPathElem, LateralView, MatchRecognizePattern,
-    Measure, NamedWindowDefinition, ObjectName, ObjectNamePart, Offset, OnConflict,
-    OnConflictAction, OnInsert, OrderBy, OrderByExpr, Partition, PivotValueSource,
-    ProjectionSelect, Query, ReferentialAction, RenameSelectItem, ReplaceSelectElement,
-    ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr, SqlOption, Statement, Subscript,
-    SymbolDefinition, TableAlias, TableAliasColumnDef, TableConstraint, TableFactor, TableObject,
-    TableOptionsClustered, TableWithJoins, UpdateTableFromKind, Use, Value, Values, ViewColumnDef,
-    WildcardAdditionalOptions, With, WithFill,
+    AccessExpr, AlterColumnOperation, AlterIndexOperation, AlterTableOperation, Array, Assignment,
+    AssignmentTarget, CloseCursor, ClusteredIndex, ColumnDef, ColumnOption, ColumnOptionDef,
+    ConflictTarget, ConnectBy, ConstraintCharacteristics, CopySource, CreateIndex, CreateTable,
+    CreateTableOptions, Cte, Delete, DoUpdate, ExceptSelectItem, ExcludeSelectItem, Expr,
+    ExprWithAlias, Fetch, FromTable, Function, FunctionArg, FunctionArgExpr,
+    FunctionArgumentClause, FunctionArgumentList, FunctionArguments, GroupByExpr, HavingBound,
+    IlikeSelectItem, Insert, Interpolate, InterpolateExpr, Join, JoinConstraint, JoinOperator,
+    JsonPath, JsonPathElem, LateralView, MatchRecognizePattern, Measure, NamedWindowDefinition,
+    ObjectName, ObjectNamePart, Offset, OnConflict, OnConflictAction, OnInsert, OrderBy,
+    OrderByExpr, Partition, PivotValueSource, ProjectionSelect, Query, ReferentialAction,
+    RenameSelectItem, ReplaceSelectElement, ReplaceSelectItem, Select, SelectInto, SelectItem,
+    SetExpr, SqlOption, Statement, Subscript, SymbolDefinition, TableAlias, TableAliasColumnDef,
+    TableConstraint, TableFactor, TableObject, TableOptionsClustered, TableWithJoins,
+    UpdateTableFromKind, Use, Value, Values, ViewColumnDef, WildcardAdditionalOptions, With,
+    WithFill, dcl::SecondaryRoles,
 };
 
 /// Given an iterator of spans, return the [Span::union] of all spans.
@@ -2267,25 +2267,37 @@ pub mod tests {
     #[test]
     pub fn test_cte() {
         let dialect = &GenericDialect;
-        let mut test = SpanTest::new(dialect, "WITH cte_outer AS (SELECT a FROM postgres.public.source), cte_ignored AS (SELECT a FROM cte_outer), cte_inner AS (SELECT a FROM cte_outer) SELECT a FROM cte_inner");
+        let mut test = SpanTest::new(
+            dialect,
+            "WITH cte_outer AS (SELECT a FROM postgres.public.source), cte_ignored AS (SELECT a FROM cte_outer), cte_inner AS (SELECT a FROM cte_outer) SELECT a FROM cte_inner",
+        );
 
         let query = test.0.parse_query().unwrap();
 
         let select_span = query.span();
 
-        assert_eq!(test.get_source(select_span), "WITH cte_outer AS (SELECT a FROM postgres.public.source), cte_ignored AS (SELECT a FROM cte_outer), cte_inner AS (SELECT a FROM cte_outer) SELECT a FROM cte_inner");
+        assert_eq!(
+            test.get_source(select_span),
+            "WITH cte_outer AS (SELECT a FROM postgres.public.source), cte_ignored AS (SELECT a FROM cte_outer), cte_inner AS (SELECT a FROM cte_outer) SELECT a FROM cte_inner"
+        );
     }
 
     #[test]
     pub fn test_snowflake_lateral_flatten() {
         let dialect = &SnowflakeDialect;
-        let mut test = SpanTest::new(dialect, "SELECT FLATTENED.VALUE:field::TEXT AS FIELD FROM SNOWFLAKE.SCHEMA.SOURCE AS S, LATERAL FLATTEN(INPUT => S.JSON_ARRAY) AS FLATTENED");
+        let mut test = SpanTest::new(
+            dialect,
+            "SELECT FLATTENED.VALUE:field::TEXT AS FIELD FROM SNOWFLAKE.SCHEMA.SOURCE AS S, LATERAL FLATTEN(INPUT => S.JSON_ARRAY) AS FLATTENED",
+        );
 
         let query = test.0.parse_select().unwrap();
 
         let select_span = query.span();
 
-        assert_eq!(test.get_source(select_span), "SELECT FLATTENED.VALUE:field::TEXT AS FIELD FROM SNOWFLAKE.SCHEMA.SOURCE AS S, LATERAL FLATTEN(INPUT => S.JSON_ARRAY) AS FLATTENED");
+        assert_eq!(
+            test.get_source(select_span),
+            "SELECT FLATTENED.VALUE:field::TEXT AS FIELD FROM SNOWFLAKE.SCHEMA.SOURCE AS S, LATERAL FLATTEN(INPUT => S.JSON_ARRAY) AS FLATTENED"
+        );
     }
 
     #[test]

src/ast/visitor.rs

@@ -876,7 +876,7 @@ mod tests {
                     "POST: EXPR: EMPID",
                     "POST: QUERY: SELECT * FROM monthly_sales PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d) ORDER BY EMPID",
                     "POST: STATEMENT: SELECT * FROM monthly_sales PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d) ORDER BY EMPID",
-                ]
+                ],
             ),
             (
                 "SHOW COLUMNS FROM t1",

src/keywords.rs

@@ -36,7 +36,7 @@ use sqlparser_derive::{Visit, VisitMut};
 /// Defines a string constant for a single keyword: `kw_def!(SELECT);`
 /// expands to `pub const SELECT = "SELECT";`
 macro_rules! kw_def {
-    ($ident:ident = $string_keyword:expr) => {
+    ($ident:ident = $string_keyword:expr_2021) => {
         pub const $ident: &'static str = $string_keyword;
     };
     ($ident:ident) => {
@@ -48,7 +48,7 @@ macro_rules! kw_def {
 /// and defines an ALL_KEYWORDS array of the defined constants.
 macro_rules! define_keywords {
     ($(
-        $ident:ident $(= $string_keyword:expr)?
+        $ident:ident $(= $string_keyword:expr_2021)?
     ),*) => {
         #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)]
         #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]