Merge pull request #985 from SeaQL/sea-query-v0.27

Upgrade SeaQuery at SeaORM root to v0.27

Cargo.toml

@@ -34,7 +34,8 @@ log = { version = "^0.4" }
 tracing = { version = "^0.1", features = ["log"] }
 rust_decimal = { version = "^1", optional = true }
 sea-orm-macros = { version = "^0.10.0", path = "sea-orm-macros", optional = true }
-sea-query = { version = "^0.26.3", features = ["thread-safe"] }
+sea-query = { version = "^0.27", git = "https://github.com/SeaQL/sea-query", features = ["thread-safe"] }
+sea-query-binder = { version = "^0.2", git = "https://github.com/SeaQL/sea-query", optional = true }
 sea-strum = { version = "^0.23", features = ["derive", "sea-orm"] }
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0", optional = true }
@@ -70,19 +71,20 @@ default = [
 ]
 macros = ["sea-orm-macros"]
 mock = []
-with-json = ["serde_json", "sea-query/with-json", "chrono/serde", "time/serde", "sqlx?/json"]
+with-json = ["serde_json", "sea-query/with-json", "chrono?/serde", "time?/serde", "sea-query-binder?/with-json", "sqlx?/json"]
-with-chrono = ["chrono", "sea-query/with-chrono", "sqlx?/chrono"]
+with-chrono = ["chrono", "sea-query/with-chrono", "sea-query-binder?/with-chrono", "sqlx?/chrono"]
-with-rust_decimal = ["rust_decimal", "sea-query/with-rust_decimal", "sqlx?/decimal"]
+with-rust_decimal = ["rust_decimal", "sea-query/with-rust_decimal", "sea-query-binder?/with-rust_decimal", "sqlx?/decimal"]
-with-uuid = ["uuid", "sea-query/with-uuid", "sqlx?/uuid"]
+with-uuid = ["uuid", "sea-query/with-uuid", "sea-query-binder?/with-uuid", "sqlx?/uuid"]
-with-time = ["time", "sea-query/with-time", "sqlx?/time"]
+with-time = ["time", "sea-query/with-time", "sea-query-binder?/with-time", "sqlx?/time"]
 sqlx-dep = []
 sqlx-all = ["sqlx-mysql", "sqlx-postgres", "sqlx-sqlite"]
-sqlx-mysql = ["sqlx-dep", "sea-query/sqlx-mysql", "sqlx/mysql"]
+sqlx-mysql = ["sqlx-dep", "sea-query-binder/sqlx-mysql", "sqlx/mysql"]
-sqlx-postgres = ["sqlx-dep", "sea-query/sqlx-postgres", "sqlx/postgres"]
+sqlx-postgres = ["sqlx-dep", "sea-query-binder/sqlx-postgres", "sqlx/postgres"]
-sqlx-sqlite = ["sqlx-dep", "sea-query/sqlx-sqlite", "sqlx/sqlite"]
+sqlx-sqlite = ["sqlx-dep", "sea-query-binder/sqlx-sqlite", "sqlx/sqlite"]
 runtime-async-std = []
 runtime-async-std-native-tls = [
     "sqlx/runtime-async-std-native-tls",
+    "sea-query-binder/runtime-async-std-native-tls",
     "runtime-async-std",
 ]
 runtime-async-std-rustls = [
@@ -90,9 +92,25 @@ runtime-async-std-rustls = [
     "runtime-async-std",
 ]
 runtime-actix = []
-runtime-actix-native-tls = ["sqlx/runtime-actix-native-tls", "runtime-actix"]
+runtime-actix-native-tls = [
-runtime-actix-rustls = ["sqlx/runtime-actix-rustls", "runtime-actix"]
+    "sqlx/runtime-actix-native-tls",
+    "sea-query-binder/runtime-actix-native-tls",
+    "runtime-actix",
+]
+runtime-actix-rustls = [
+    "sqlx/runtime-actix-rustls",
+    "sea-query-binder/runtime-actix-rustls",
+    "runtime-actix",
+]
 runtime-tokio = []
-runtime-tokio-native-tls = ["sqlx/runtime-tokio-native-tls", "runtime-tokio"]
+runtime-tokio-native-tls = [
-runtime-tokio-rustls = ["sqlx/runtime-tokio-rustls", "runtime-tokio"]
+    "sqlx/runtime-tokio-native-tls",
+    "sea-query-binder/runtime-tokio-native-tls",
+    "runtime-tokio",
+]
+runtime-tokio-rustls = [
+    "sqlx/runtime-tokio-rustls",
+    "sea-query-binder/runtime-tokio-rustls",
+    "runtime-tokio",
+]
 tests-cfg = []

issues/324/src/model.rs

@@ -69,6 +69,10 @@ macro_rules! into_sea_query_value {
                 stringify!($newtype).to_owned()
             }
 
+            fn array_type() -> sea_orm::sea_query::ArrayType {
+                sea_orm::sea_query::ArrayType::$name
+            }
+
             fn column_type() -> sea_orm::sea_query::ColumnType {
                 sea_orm::sea_query::ColumnType::$name
             }

issues/400/src/model.rs

@@ -70,6 +70,10 @@ impl<T> sea_orm::sea_query::ValueType for AccountId<T> {
         stringify!(AccountId).to_owned()
     }
 
+    fn array_type() -> sea_orm::sea_query::ArrayType {
+        sea_orm::sea_query::ArrayType::Uuid
+    }
+
     fn column_type() -> sea_orm::sea_query::ColumnType {
         sea_orm::sea_query::ColumnType::Uuid
     }

sea-orm-cli/Cargo.toml

@@ -35,7 +35,7 @@ clap = { version = "^3.2", features = ["env", "derive"] }
 dotenvy = { version = "^0.15", optional = true }
 async-std = { version = "^1.9", features = [ "attributes", "tokio1" ], optional = true }
 sea-orm-codegen = { version = "^0.10.0", path = "../sea-orm-codegen", optional = true }
-sea-schema = { version = "^0.9.3" }
+sea-schema = { version = "^0.10.0", git = "https://github.com/SeaQL/sea-schema", branch = "sea-query-0.27" }
 sqlx = { version = "^0.6", default-features = false, features = [ "mysql", "postgres" ], optional = true }
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 tracing = { version = "0.1" }

sea-orm-codegen/Cargo.toml

@@ -17,7 +17,7 @@ name = "sea_orm_codegen"
 path = "src/lib.rs"
 
 [dependencies]
-sea-query = { version = "^0.26.3" }
+sea-query = { version = "^0.27", git = "https://github.com/SeaQL/sea-query", features = ["thread-safe"] }
 syn = { version = "^1", default-features = false, features = [
     "derive",
     "parsing",

sea-orm-codegen/src/entity/active_enum.rs

@@ -1,21 +1,22 @@
 use heck::CamelCase;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
+use sea_query::DynIden;
 
 use crate::WithSerde;
 
 #[derive(Clone, Debug)]
 pub struct ActiveEnum {
-    pub(crate) enum_name: String,
+    pub(crate) enum_name: DynIden,
-    pub(crate) values: Vec<String>,
+    pub(crate) values: Vec<DynIden>,
 }
 
 impl ActiveEnum {
     pub fn impl_active_enum(&self, with_serde: &WithSerde, with_copy_enums: bool) -> TokenStream {
-        let enum_name = &self.enum_name;
+        let enum_name = &self.enum_name.to_string();
         let enum_iden = format_ident!("{}", enum_name.to_camel_case());
-        let values = &self.values;
+        let values: Vec<String> = self.values.iter().map(|v| v.to_string()).collect();
-        let variants = self.values.iter().map(|v| v.trim()).map(|v| {
+        let variants = values.iter().map(|v| v.trim()).map(|v| {
             if v.chars().all(|c| c.is_numeric()) {
                 format_ident!("_{}", v)
             } else {

sea-orm-codegen/src/entity/column.rs

@@ -70,7 +70,7 @@ impl Column {
             ColumnType::Uuid => "Uuid".to_owned(),
             ColumnType::Binary(_) | ColumnType::VarBinary(_) => "Vec<u8>".to_owned(),
             ColumnType::Boolean => "bool".to_owned(),
-            ColumnType::Enum(name, _) => name.to_camel_case(),
+            ColumnType::Enum { name, .. } => name.to_string().to_camel_case(),
             _ => unimplemented!(),
         }
         .parse()
@@ -146,8 +146,8 @@ impl Column {
                 let s = s.to_string();
                 quote! { ColumnType::Custom(#s.to_owned()).def() }
             }
-            ColumnType::Enum(enum_name, _) => {
+            ColumnType::Enum { name, .. } => {
-                let enum_ident = format_ident!("{}", enum_name.to_camel_case());
+                let enum_ident = format_ident!("{}", name.to_string().to_camel_case());
                 quote! { #enum_ident::db_type() }
             }
             #[allow(unreachable_patterns)]

sea-orm-codegen/src/entity/relation.rs

@@ -1,3 +1,4 @@
+use crate::util::unpack_table_ref;
 use heck::{CamelCase, SnakeCase};
 use proc_macro2::{Ident, TokenStream};
 use quote::{format_ident, quote};
@@ -155,7 +156,7 @@ impl Relation {
 impl From<&TableForeignKey> for Relation {
     fn from(tbl_fk: &TableForeignKey) -> Self {
         let ref_table = match tbl_fk.get_ref_table() {
-            Some(s) => s,
+            Some(s) => unpack_table_ref(s),
             None => panic!("RefTable should not be empty"),
         };
         let columns = tbl_fk.get_columns();

sea-orm-codegen/src/entity/transformer.rs

@@ -1,6 +1,6 @@
 use crate::{
-    ActiveEnum, Column, ConjunctRelation, Entity, EntityWriter, Error, PrimaryKey, Relation,
+    util::unpack_table_ref, ActiveEnum, Column, ConjunctRelation, Entity, EntityWriter, Error,
-    RelationType,
+    PrimaryKey, Relation, RelationType,
 };
 use sea_query::{ColumnSpec, TableCreateStatement};
 use std::collections::HashMap;
@@ -59,12 +59,12 @@ impl EntityTransformer {
                     col
                 })
                 .map(|col| {
-                    if let sea_query::ColumnType::Enum(enum_name, values) = &col.col_type {
+                    if let sea_query::ColumnType::Enum { name, variants } = &col.col_type {
                         enums.insert(
-                            enum_name.clone(),
+                            name.to_string(),
                             ActiveEnum {
-                                enum_name: enum_name.clone(),
+                                enum_name: name.clone(),
-                                values: values.clone(),
+                                values: variants.clone(),
                             },
                         );
                     }
@@ -77,7 +77,7 @@ impl EntityTransformer {
                 .iter()
                 .map(|fk_create_stmt| fk_create_stmt.get_foreign_key())
                 .map(|tbl_fk| {
-                    let ref_tbl = tbl_fk.get_ref_table().unwrap();
+                    let ref_tbl = unpack_table_ref(tbl_fk.get_ref_table().unwrap());
                     if let Some(count) = ref_table_counts.get_mut(&ref_tbl) {
                         if *count == 0 {
                             *count = 1;

sea-orm-codegen/src/entity/writer.rs

@@ -364,8 +364,8 @@ impl EntityWriter {
             .columns
             .iter()
             .fold(TokenStream::new(), |mut ts, col| {
-                if let sea_query::ColumnType::Enum(enum_name, _) = &col.col_type {
+                if let sea_query::ColumnType::Enum { name, .. } = &col.col_type {
-                    let enum_name = format_ident!("{}", enum_name.to_camel_case());
+                    let enum_name = format_ident!("{}", name.to_string().to_camel_case());
                     ts.extend(vec![quote! {
                         use super::sea_orm_active_enums::#enum_name;
                     }]);

sea-orm-codegen/src/util.rs

@@ -1,3 +1,5 @@
+use sea_query::TableRef;
+
 pub(crate) fn escape_rust_keyword<T>(string: T) -> String
 where
     T: ToString,
@@ -21,3 +23,16 @@ pub(crate) const RUST_KEYWORDS: [&str; 49] = [
 ];
 
 pub(crate) const RUST_SPECIAL_KEYWORDS: [&str; 3] = ["crate", "Self", "self"];
+
+pub(crate) fn unpack_table_ref(table_ref: &TableRef) -> String {
+    match table_ref {
+        TableRef::Table(tbl)
+        | TableRef::SchemaTable(_, tbl)
+        | TableRef::DatabaseSchemaTable(_, _, tbl)
+        | TableRef::TableAlias(tbl, _)
+        | TableRef::SchemaTableAlias(_, tbl, _)
+        | TableRef::DatabaseSchemaTableAlias(_, _, tbl, _)
+        | TableRef::SubQuery(_, tbl)
+        | TableRef::ValuesList(_, tbl) => tbl.to_string(),
+    }
+}

sea-orm-macros/src/derives/active_enum.rs

@@ -1,6 +1,6 @@
 use heck::CamelCase;
 use proc_macro2::TokenStream;
-use quote::{quote, quote_spanned};
+use quote::{format_ident, quote, quote_spanned};
 use syn::{parse, punctuated::Punctuated, token::Comma, Expr, Lit, LitInt, LitStr, Meta, UnOp};
 
 enum Error {
@@ -59,7 +59,10 @@ impl ActiveEnum {
                                     match s.as_ref() {
                                         "Enum" => {
                                             db_type = Ok(quote! {
-                                                Enum(Self::name(), Self::values())
+                                                Enum {
+                                                    name: Self::name(),
+                                                    variants: Self::iden_values(),
+                                                }
                                             })
                                         }
                                         _ => {
@@ -227,13 +230,59 @@ impl ActiveEnum {
             quote! { v }
         };
 
+        let enum_name_iden = format_ident!("{}Enum", ident);
+
+        let str_variants: Vec<String> = variants
+            .iter()
+            .filter_map(|variant| {
+                variant
+                    .string_value
+                    .as_ref()
+                    .map(|string_value| string_value.value())
+            })
+            .collect();
+
+        let impl_enum_variant_iden = if !str_variants.is_empty() {
+            let enum_variant_iden = format_ident!("{}Variant", ident);
+            let enum_variants: Vec<syn::Ident> = str_variants
+                .iter()
+                .map(|v| format_ident!("{}", v.to_camel_case()))
+                .collect();
+
+            quote!(
+                #[derive(Debug, Clone, PartialEq, Eq, EnumIter, Iden)]
+                pub enum #enum_variant_iden {
+                    #(
+                        #[iden = #str_variants]
+                        #enum_variants,
+                    )*
+                }
+
+                impl #ident {
+                    pub fn iden_values() -> Vec<sea_orm::sea_query::DynIden> {
+                        <#enum_variant_iden as sea_orm::strum::IntoEnumIterator>::iter()
+                            .map(|v| sea_orm::sea_query::SeaRc::new(v) as sea_orm::sea_query::DynIden)
+                            .collect()
+                    }
+                }
+            )
+        } else {
+            quote!()
+        };
+
         quote!(
+            #[derive(Debug, Clone, PartialEq, Eq, Iden)]
+            #[iden = #enum_name]
+            pub struct #enum_name_iden;
+
+            #impl_enum_variant_iden
+
             #[automatically_derived]
             impl sea_orm::ActiveEnum for #ident {
                 type Value = #rs_type;
 
-                fn name() -> String {
+                fn name() -> sea_orm::sea_query::DynIden {
-                    #enum_name.to_owned()
+                    sea_orm::sea_query::SeaRc::new(#enum_name_iden) as sea_orm::sea_query::DynIden
                 }
 
                 fn to_value(&self) -> Self::Value {
@@ -286,6 +335,10 @@ impl ActiveEnum {
                     <<Self as sea_orm::ActiveEnum>::Value as sea_orm::sea_query::ValueType>::type_name()
                 }
 
+                fn array_type() -> sea_orm::sea_query::ArrayType {
+                    unimplemented!("Array of Enum is not supported")
+                }
+
                 fn column_type() -> sea_orm::sea_query::ColumnType {
                     <Self as sea_orm::ActiveEnum>::db_type()
                         .get_column_type()

sea-orm-macros/src/derives/try_getable_from_json.rs

@@ -28,6 +28,10 @@ pub fn expand_derive_from_json_query_result(ident: Ident) -> syn::Result<TokenSt
                 stringify!(#ident).to_owned()
             }
 
+            fn array_type() -> sea_orm::sea_query::ArrayType {
+                sea_orm::sea_query::ArrayType::Json
+            }
+
             fn column_type() -> sea_orm::sea_query::ColumnType {
                 sea_orm::sea_query::ColumnType::Json
             }

sea-orm-migration/Cargo.toml

@@ -25,7 +25,7 @@ clap = { version = "^3.2", features = ["env", "derive"] }
 dotenvy = { version = "^0.15" }
 sea-orm = { version = "^0.10.0", path = "../", default-features = false, features = ["macros"] }
 sea-orm-cli = { version = "^0.10.0", path = "../sea-orm-cli", default-features = false }
-sea-schema = { version = "^0.9.3" }
+sea-schema = { version = "^0.10.0", git = "https://github.com/SeaQL/sea-schema", branch = "sea-query-0.27" }
 tracing = { version = "0.1", features = ["log"] }
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 

src/driver/sqlx_mysql.rs

@@ -1,12 +1,12 @@
+use sea_query::Values;
 use std::{future::Future, pin::Pin, sync::Arc};
 
 use sqlx::{
-    mysql::{MySqlArguments, MySqlConnectOptions, MySqlQueryResult, MySqlRow},
+    mysql::{MySqlConnectOptions, MySqlQueryResult, MySqlRow},
     MySql, MySqlPool,
 };
 
-sea_query::sea_query_driver_mysql!();
+use sea_query_binder::SqlxValues;
-use sea_query_driver_mysql::bind_query;
 use tracing::instrument;
 
 use crate::{
@@ -203,10 +203,10 @@ impl From<MySqlQueryResult> for ExecResult {
     }
 }
 
-pub(crate) fn sqlx_query(stmt: &Statement) -> sqlx::query::Query<'_, MySql, MySqlArguments> {
+pub(crate) fn sqlx_query(stmt: &Statement) -> sqlx::query::Query<'_, MySql, SqlxValues> {
-    let mut query = sqlx::query(&stmt.sql);
+    let values = stmt
-    if let Some(values) = &stmt.values {
+        .values
-        query = bind_query(query, values);
+        .as_ref()
-    }
+        .map_or(Values(Vec::new()), |values| values.clone());
-    query
+    sqlx::query_with(&stmt.sql, SqlxValues(values))
 }

src/driver/sqlx_postgres.rs

@@ -1,12 +1,12 @@
+use sea_query::Values;
 use std::{future::Future, pin::Pin, sync::Arc};
 
 use sqlx::{
-    postgres::{PgArguments, PgConnectOptions, PgQueryResult, PgRow},
+    postgres::{PgConnectOptions, PgQueryResult, PgRow},
     PgPool, Postgres,
 };
 
-sea_query::sea_query_driver_postgres!();
+use sea_query_binder::SqlxValues;
-use sea_query_driver_postgres::bind_query;
 use tracing::instrument;
 
 use crate::{
@@ -218,10 +218,10 @@ impl From<PgQueryResult> for ExecResult {
     }
 }
 
-pub(crate) fn sqlx_query(stmt: &Statement) -> sqlx::query::Query<'_, Postgres, PgArguments> {
+pub(crate) fn sqlx_query(stmt: &Statement) -> sqlx::query::Query<'_, Postgres, SqlxValues> {
-    let mut query = sqlx::query(&stmt.sql);
+    let values = stmt
-    if let Some(values) = &stmt.values {
+        .values
-        query = bind_query(query, values);
+        .as_ref()
-    }
+        .map_or(Values(Vec::new()), |values| values.clone());
-    query
+    sqlx::query_with(&stmt.sql, SqlxValues(values))
 }

src/driver/sqlx_sqlite.rs

@@ -1,12 +1,12 @@
+use sea_query::Values;
 use std::{future::Future, pin::Pin, sync::Arc};
 
 use sqlx::{
-    sqlite::{SqliteArguments, SqliteConnectOptions, SqliteQueryResult, SqliteRow},
+    sqlite::{SqliteConnectOptions, SqliteQueryResult, SqliteRow},
     Sqlite, SqlitePool,
 };
 
-sea_query::sea_query_driver_sqlite!();
+use sea_query_binder::SqlxValues;
-use sea_query_driver_sqlite::bind_query;
 use tracing::instrument;
 
 use crate::{
@@ -210,10 +210,10 @@ impl From<SqliteQueryResult> for ExecResult {
     }
 }
 
-pub(crate) fn sqlx_query(stmt: &Statement) -> sqlx::query::Query<'_, Sqlite, SqliteArguments> {
+pub(crate) fn sqlx_query(stmt: &Statement) -> sqlx::query::Query<'_, Sqlite, SqlxValues> {
-    let mut query = sqlx::query(&stmt.sql);
+    let values = stmt
-    if let Some(values) = &stmt.values {
+        .values
-        query = bind_query(query, values);
+        .as_ref()
-    }
+        .map_or(Values(Vec::new()), |values| values.clone());
-    query
+    sqlx::query_with(&stmt.sql, SqlxValues(values))
 }

src/entity/active_enum.rs

@@ -1,5 +1,5 @@
 use crate::{ColumnDef, DbErr, Iterable, TryGetable};
-use sea_query::{Nullable, Value, ValueType};
+use sea_query::{DynIden, Nullable, Value, ValueType};
 
 /// A Rust representation of enum defined in database.
 ///
@@ -14,7 +14,10 @@ use sea_query::{Nullable, Value, ValueType};
 /// > See [DeriveActiveEnum](sea_orm_macros::DeriveActiveEnum) for the full specification of macro attributes.
 ///
 /// ```rust
-/// use sea_orm::entity::prelude::*;
+/// use sea_orm::{
+///     entity::prelude::*,
+///     sea_query::{DynIden, SeaRc},
+/// };
 ///
 /// // Using the derive macro
 /// #[derive(Debug, PartialEq, EnumIter, DeriveActiveEnum)]
@@ -37,13 +40,16 @@ use sea_query::{Nullable, Value, ValueType};
 ///     Small,
 /// }
 ///
+/// #[derive(Debug, Iden)]
+/// pub struct CategoryEnum;
+///
 /// impl ActiveEnum for Category {
 ///     // The macro attribute `rs_type` is being pasted here
 ///     type Value = String;
 ///
 ///     // Will be atomically generated by `DeriveActiveEnum`
-///     fn name() -> String {
+///     fn name() -> DynIden {
-///         "category".to_owned()
+///         SeaRc::new(CategoryEnum)
 ///     }
 ///
 ///     // Will be atomically generated by `DeriveActiveEnum`
@@ -109,7 +115,7 @@ pub trait ActiveEnum: Sized + Iterable {
     type Value: Into<Value> + ValueType + Nullable + TryGetable;
 
     /// Get the name of enum
-    fn name() -> String;
+    fn name() -> DynIden;
 
     /// Convert enum variant into the corresponding value.
     fn to_value(&self) -> Self::Value;
@@ -134,7 +140,7 @@ pub trait ActiveEnum: Sized + Iterable {
 #[cfg(test)]
 mod tests {
     use crate as sea_orm;
-    use crate::{entity::prelude::*, *};
+    use crate::{entity::prelude::*, sea_query::SeaRc, *};
     use pretty_assertions::assert_eq;
 
     #[test]
@@ -145,11 +151,15 @@ mod tests {
             Small,
         }
 
+        #[derive(Debug, Iden)]
+        #[iden = "category"]
+        pub struct CategoryEnum;
+
         impl ActiveEnum for Category {
             type Value = String;
 
-            fn name() -> String {
+            fn name() -> DynIden {
-                "category".to_owned()
+                SeaRc::new(CategoryEnum)
             }
 
             fn to_value(&self) -> Self::Value {
@@ -226,7 +236,10 @@ mod tests {
         assert_eq!(Category::db_type(), ColumnType::String(Some(1)).def());
         assert_eq!(DeriveCategory::db_type(), ColumnType::String(Some(1)).def());
 
-        assert_eq!(Category::name(), DeriveCategory::name());
+        assert_eq!(
+            Category::name().to_string(),
+            DeriveCategory::name().to_string()
+        );
         assert_eq!(Category::values(), DeriveCategory::values());
     }
 

src/entity/column.rs

@@ -13,7 +13,7 @@ pub struct ColumnDef {
 }
 
 /// The type of column as defined in the SQL format
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone)]
 pub enum ColumnType {
     /// `CHAR` type of specified fixed length
     Char(Option<u32>),
@@ -78,7 +78,39 @@ pub enum ColumnType {
     /// A Universally Unique IDentifier that is specified in  RFC 4122
     Uuid,
     /// `ENUM` data type with name and variants
-    Enum(String, Vec<String>),
+    Enum {
+        /// Name of enum
+        name: DynIden,
+        /// Variants of enum
+        variants: Vec<DynIden>,
+    },
+}
+
+impl PartialEq for ColumnType {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Char(l0), Self::Char(r0)) => l0 == r0,
+            (Self::String(l0), Self::String(r0)) => l0 == r0,
+            (Self::Decimal(l0), Self::Decimal(r0)) => l0 == r0,
+            (Self::Money(l0), Self::Money(r0)) => l0 == r0,
+            (Self::Custom(l0), Self::Custom(r0)) => l0 == r0,
+            (
+                Self::Enum {
+                    name: l_name,
+                    variants: l_variants,
+                },
+                Self::Enum {
+                    name: r_name,
+                    variants: r_variants,
+                },
+            ) => {
+                l_name.to_string() == r_name.to_string()
+                    && l_variants.iter().map(|v| v.to_string()).collect::<Vec<_>>()
+                        == r_variants.iter().map(|v| v.to_string()).collect::<Vec<_>>()
+            }
+            _ => core::mem::discriminant(self) == core::mem::discriminant(other),
+        }
+    }
 }
 
 macro_rules! bind_oper {
@@ -318,9 +350,9 @@ impl ColumnType {
         }
     }
 
-    pub(crate) fn get_enum_name(&self) -> Option<&String> {
+    pub(crate) fn get_enum_name(&self) -> Option<&DynIden> {
         match self {
-            ColumnType::Enum(s, _) => Some(s),
+            ColumnType::Enum { name, .. } => Some(name),
             _ => None,
         }
     }
@@ -399,7 +431,7 @@ impl From<ColumnType> for sea_query::ColumnType {
                 sea_query::ColumnType::Custom(sea_query::SeaRc::new(sea_query::Alias::new(&s)))
             }
             ColumnType::Uuid => sea_query::ColumnType::Uuid,
-            ColumnType::Enum(name, variants) => sea_query::ColumnType::Enum(name, variants),
+            ColumnType::Enum { name, variants } => sea_query::ColumnType::Enum { name, variants },
         }
     }
 }
@@ -437,7 +469,7 @@ impl From<sea_query::ColumnType> for ColumnType {
             sea_query::ColumnType::JsonBinary => Self::JsonBinary,
             sea_query::ColumnType::Custom(s) => Self::Custom(s.to_string()),
             sea_query::ColumnType::Uuid => Self::Uuid,
-            sea_query::ColumnType::Enum(name, variants) => Self::Enum(name, variants),
+            sea_query::ColumnType::Enum { name, variants } => Self::Enum { name, variants },
             _ => unimplemented!(),
         }
     }

src/executor/cursor.rs

@@ -444,8 +444,8 @@ mod tests {
                     r#"FROM "cake_filling""#,
                     r#"WHERE "cake_filling"."cake_id" > $1"#,
                     r#"AND "cake_filling"."filling_id" > $2"#,
-                    r#"AND ("cake_filling"."cake_id" < $3"#,
+                    r#"AND "cake_filling"."cake_id" < $3"#,
-                    r#"AND "cake_filling"."filling_id" < $4)"#,
+                    r#"AND "cake_filling"."filling_id" < $4"#,
                     r#"ORDER BY "cake_filling"."cake_id" ASC, "cake_filling"."filling_id" ASC"#,
                     r#"LIMIT $5"#,
                 ]

src/executor/paginator.rs

@@ -253,7 +253,7 @@ where
     type Selector = S;
     fn paginate(self, db: &'db C, page_size: u64) -> Paginator<'db, C, S> {
         assert!(page_size != 0, "page_size should not be zero");
-        let sql = &self.stmt.sql.trim()[6..];
+        let sql = &self.stmt.sql.trim()[6..].trim();
         let mut query = SelectStatement::new();
         query.expr(if let Some(values) = self.stmt.values {
             Expr::cust_with_values(sql, values.0)

src/query/helper.rs

@@ -638,7 +638,7 @@ where
     let col_def = col.def();
     let col_type = col_def.get_column_type();
     match col_type.get_enum_name() {
-        Some(enum_name) => f(expr, SeaRc::new(Alias::new(enum_name))),
+        Some(enum_name) => f(expr, SeaRc::clone(enum_name)),
         None => expr.into(),
     }
 }

src/query/insert.rs

@@ -138,7 +138,7 @@ where
             }
         }
         self.query.columns(columns);
-        self.query.exprs_panic(values);
+        self.query.values_panic(values);
         self
     }
 

src/query/update.rs

@@ -110,7 +110,7 @@ where
             let av = self.model.get(col);
             if av.is_set() {
                 let expr = cast_text_as_enum(Expr::val(av.into_value().unwrap()), &col);
-                self.query.value_expr(col, expr);
+                self.query.value(col, expr);
             }
         }
         self
@@ -200,7 +200,7 @@ where
     where
         T: IntoIden,
     {
-        self.query.col_expr(col, expr);
+        self.query.value(col, expr);
         self
     }
 }

src/schema/entity.rs

@@ -4,8 +4,7 @@ use crate::{
 };
 use sea_query::{
     extension::postgres::{Type, TypeCreateStatement},
-    Alias, ColumnDef, ForeignKeyCreateStatement, Iden, Index, IndexCreateStatement,
+    ColumnDef, ForeignKeyCreateStatement, Iden, Index, IndexCreateStatement, TableCreateStatement,
-    TableCreateStatement,
 };
 
 impl Schema {
@@ -57,13 +56,10 @@ where
 
 pub(crate) fn create_enum_from_column_type(col_type: &ColumnType) -> TypeCreateStatement {
     let (name, values) = match col_type {
-        ColumnType::Enum(s, v) => (s.as_str(), v),
+        ColumnType::Enum { name, variants } => (name.clone(), variants.clone()),
         _ => panic!("Should be ColumnType::Enum"),
     };
-    Type::create()
+    Type::create().as_enum(name).values(values).to_owned()
-        .as_enum(Alias::new(name))
-        .values(values.iter().map(|val| Alias::new(val.as_str())))
-        .to_owned()
 }
 
 #[allow(clippy::needless_borrow)]
@@ -78,7 +74,7 @@ where
     for col in E::Column::iter() {
         let col_def = col.def();
         let col_type = col_def.get_column_type();
-        if !matches!(col_type, ColumnType::Enum(_, _)) {
+        if !matches!(col_type, ColumnType::Enum { .. }) {
             continue;
         }
         let stmt = create_enum_from_column_type(&col_type);
@@ -123,11 +119,12 @@ where
     for column in E::Column::iter() {
         let orm_column_def = column.def();
         let types = match orm_column_def.col_type {
-            ColumnType::Enum(s, variants) => match backend {
+            ColumnType::Enum { name, variants } => match backend {
                 DbBackend::MySql => {
+                    let variants: Vec<String> = variants.iter().map(|v| v.to_string()).collect();
                     ColumnType::Custom(format!("ENUM('{}')", variants.join("', '")))
                 }
-                DbBackend::Postgres => ColumnType::Custom(s),
+                DbBackend::Postgres => ColumnType::Custom(name.to_string()),
                 DbBackend::Sqlite => ColumnType::Text,
             }
             .into(),

tests/common/features/json_vec.rs

@@ -45,6 +45,10 @@ impl sea_query::ValueType for StringVec {
         stringify!(StringVec).to_owned()
     }
 
+    fn array_type() -> sea_orm::sea_query::ArrayType {
+        sea_orm::sea_query::ArrayType::String
+    }
+
     fn column_type() -> sea_query::ColumnType {
         sea_query::ColumnType::String(None)
     }

tests/common/features/schema.rs

@@ -166,7 +166,7 @@ pub async fn create_active_enum_table(db: &DbConn) -> Result<ExecResult, DbErr>
         .col(ColumnDef::new(active_enum::Column::Color).integer())
         .col(
             ColumnDef::new(active_enum::Column::Tea)
-                .enumeration("tea", vec!["EverydayTea", "BreakfastTea"]),
+                .enumeration(TeaEnum, [TeaVariant::EverydayTea, TeaVariant::BreakfastTea]),
         )
         .to_owned();
 
@@ -192,7 +192,7 @@ pub async fn create_active_enum_child_table(db: &DbConn) -> Result<ExecResult, D
         .col(ColumnDef::new(active_enum_child::Column::Color).integer())
         .col(
             ColumnDef::new(active_enum_child::Column::Tea)
-                .enumeration("tea", vec!["EverydayTea", "BreakfastTea"]),
+                .enumeration(TeaEnum, [TeaVariant::EverydayTea, TeaVariant::BreakfastTea]),
         )
         .foreign_key(
             ForeignKeyCreateStatement::new()

tests/common/setup/mod.rs

@@ -5,7 +5,7 @@ use sea_orm::{
 };
 use sea_query::{
     extension::postgres::{Type, TypeCreateStatement},
-    Alias, Table, TableCreateStatement,
+    SeaRc, Table, TableCreateStatement,
 };
 
 pub async fn setup(base_url: &str, db_name: &str) -> DatabaseConnection {
@@ -88,15 +88,15 @@ where
         for col in E::Column::iter() {
             let col_def = col.def();
             let col_type = col_def.get_column_type();
-            if !matches!(col_type, ColumnType::Enum(_, _)) {
+            if !matches!(col_type, ColumnType::Enum { .. }) {
                 continue;
             }
             let name = match col_type {
-                ColumnType::Enum(s, _) => s.as_str(),
+                ColumnType::Enum { name, .. } => name,
                 _ => unreachable!(),
             };
             let drop_type_stmt = Type::drop()
-                .name(Alias::new(name))
+                .name(SeaRc::clone(name))
                 .if_exists()
                 .cascade()
                 .to_owned();