caisin/sea-orm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
Upgrade SeaQuery at SeaORM root to v0.27
This commit is contained in:
Chris Tsang 2022-10-19 00:16:53 +08:00 committed by GitHub
commit ef14412348
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 249 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
Cargo.toml
View File

@ -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-chrono = ["chrono", "sea-query/with-chrono", "sqlx?/chrono"]
with-rust_decimal = ["rust_decimal", "sea-query/with-rust_decimal", "sqlx?/decimal"]
with-uuid = ["uuid", "sea-query/with-uuid", "sqlx?/uuid"]
with-time = ["time", "sea-query/with-time", "sqlx?/time"]
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", "sea-query-binder?/with-chrono", "sqlx?/chrono"]
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", "sea-query-binder?/with-uuid", "sqlx?/uuid"]
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-postgres = ["sqlx-dep", "sea-query/sqlx-postgres", "sqlx/postgres"]
sqlx-sqlite = ["sqlx-dep", "sea-query/sqlx-sqlite", "sqlx/sqlite"]
sqlx-mysql = ["sqlx-dep", "sea-query-binder/sqlx-mysql", "sqlx/mysql"]
sqlx-postgres = ["sqlx-dep", "sea-query-binder/sqlx-postgres", "sqlx/postgres"]
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-rustls = ["sqlx/runtime-actix-rustls", "runtime-actix"]
runtime-actix-native-tls = [
"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-rustls = ["sqlx/runtime-tokio-rustls", "runtime-tokio"]
runtime-tokio-native-tls = [
"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 = []

4
issues/324/src/model.rs
View File

@ -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
}

4
issues/400/src/model.rs
View File

@ -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
}

2
sea-orm-cli/Cargo.toml
View File

@ -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" }

2
sea-orm-codegen/Cargo.toml
View File

@ -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",

11
sea-orm-codegen/src/entity/active_enum.rs
View File

@ -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) values: Vec<String>,
pub(crate) enum_name: DynIden,
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 variants = self.values.iter().map(|v| v.trim()).map(|v| {
let values: Vec<String> = self.values.iter().map(|v| v.to_string()).collect();
let variants = values.iter().map(|v| v.trim()).map(|v| {
if v.chars().all(|c| c.is_numeric()) {
format_ident!("_{}", v)
} else {

6
sea-orm-codegen/src/entity/column.rs
View File

@ -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, _) => {
let enum_ident = format_ident!("{}", enum_name.to_camel_case());
ColumnType::Enum { name, .. } => {
let enum_ident = format_ident!("{}", name.to_string().to_camel_case());
quote! { #enum_ident::db_type() }
}
#[allow(unreachable_patterns)]

3
sea-orm-codegen/src/entity/relation.rs
View File

@ -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();

14
sea-orm-codegen/src/entity/transformer.rs
View File

@ -1,6 +1,6 @@
use crate::{
ActiveEnum, Column, ConjunctRelation, Entity, EntityWriter, Error, PrimaryKey, Relation,
RelationType,
util::unpack_table_ref, ActiveEnum, Column, ConjunctRelation, Entity, EntityWriter, Error,
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(),
values: values.clone(),
enum_name: name.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;

4
sea-orm-codegen/src/entity/writer.rs
View File

@ -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 {
let enum_name = format_ident!("{}", enum_name.to_camel_case());
if let sea_query::ColumnType::Enum { name, .. } = &col.col_type {
let enum_name = format_ident!("{}", name.to_string().to_camel_case());
ts.extend(vec![quote! {
use super::sea_orm_active_enums::#enum_name;
}]);

15
sea-orm-codegen/src/util.rs
View File

@ -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(),
}
}

61
sea-orm-macros/src/derives/active_enum.rs
View File

@ -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 {
#enum_name.to_owned()
fn name() -> sea_orm::sea_query::DynIden {
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()

4
sea-orm-macros/src/derives/try_getable_from_json.rs
View File

@ -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
}

2
sea-orm-migration/Cargo.toml
View File

@ -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"] }

18
src/driver/sqlx_mysql.rs
View File

@ -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_driver_mysql::bind_query;
use sea_query_binder::SqlxValues;
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> {
let mut query = sqlx::query(&stmt.sql);
if let Some(values) = &stmt.values {
query = bind_query(query, values);
}
query
pub(crate) fn sqlx_query(stmt: &Statement) -> sqlx::query::Query<'_, MySql, SqlxValues> {
let values = stmt
.values
.as_ref()
.map_or(Values(Vec::new()), |values| values.clone());
sqlx::query_with(&stmt.sql, SqlxValues(values))
}

18
src/driver/sqlx_postgres.rs
View File

@ -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_driver_postgres::bind_query;
use sea_query_binder::SqlxValues;
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> {
let mut query = sqlx::query(&stmt.sql);
if let Some(values) = &stmt.values {
query = bind_query(query, values);
}
query
pub(crate) fn sqlx_query(stmt: &Statement) -> sqlx::query::Query<'_, Postgres, SqlxValues> {
let values = stmt
.values
.as_ref()
.map_or(Values(Vec::new()), |values| values.clone());
sqlx::query_with(&stmt.sql, SqlxValues(values))
}

18
src/driver/sqlx_sqlite.rs
View File

@ -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_driver_sqlite::bind_query;
use sea_query_binder::SqlxValues;
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> {
let mut query = sqlx::query(&stmt.sql);
if let Some(values) = &stmt.values {
query = bind_query(query, values);
}
query
pub(crate) fn sqlx_query(stmt: &Statement) -> sqlx::query::Query<'_, Sqlite, SqlxValues> {
let values = stmt
.values
.as_ref()
.map_or(Values(Vec::new()), |values| values.clone());
sqlx::query_with(&stmt.sql, SqlxValues(values))
}

31
src/entity/active_enum.rs
View File

@ -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 {
/// "category".to_owned()
/// fn name() -> DynIden {
/// 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 {
"category".to_owned()
fn name() -> DynIden {
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());
}

44
src/entity/column.rs
View File

@ -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!(),
}
}

4
src/executor/cursor.rs
View File

@ -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"."filling_id" < $4)"#,
r#"AND "cake_filling"."cake_id" < $3"#,
r#"AND "cake_filling"."filling_id" < $4"#,
r#"ORDER BY "cake_filling"."cake_id" ASC, "cake_filling"."filling_id" ASC"#,
r#"LIMIT $5"#,
]

2
src/executor/paginator.rs
View File

@ -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)

2
src/query/helper.rs
View File

@ -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(),
}
}

2
src/query/insert.rs
View File

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

4
src/query/update.rs
View File

@ -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
}
}

17
src/schema/entity.rs
View File

@ -4,8 +4,7 @@ use crate::{
};
use sea_query::{
extension::postgres::{Type, TypeCreateStatement},
Alias, ColumnDef, ForeignKeyCreateStatement, Iden, Index, IndexCreateStatement,
TableCreateStatement,
ColumnDef, ForeignKeyCreateStatement, Iden, Index, IndexCreateStatement, 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()
.as_enum(Alias::new(name))
.values(values.iter().map(|val| Alias::new(val.as_str())))
.to_owned()
Type::create().as_enum(name).values(values).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(),

4
tests/common/features/json_vec.rs
View File

@ -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)
}

4
tests/common/features/schema.rs
View File

@ -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()

8
tests/common/setup/mod.rs
View File

@ -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();