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

Refactoring

Browse Source 
`ColumnDef` with default value

Cargo fmt

Update docs

Fixup

Support `DateTimeLocal`

Update docs

Codegen write db timestamp column as `DateTimeUtc` type

Update dependency

Merge branch 'sea-query/add-new-column-ref' into pr/429

feat: apply alias on `ColumnRef::SchemaTableColumn`
This commit is contained in:
Billy Chan 2022-01-26 16:11:08 +08:00 committed by Chris Tsang
parent 52f38a10ea
commit 8145088814
15 changed files with 137 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -30,7 +30,7 @@ futures-util = { version = "^0.3" }
tracing = { version = "0.1", features = ["log"] }
rust_decimal = { version = "^1", optional = true }
sea-orm-macros = { version = "^0.5.0", path = "sea-orm-macros", optional = true }
sea-query = { git = "https://github.com/charleschege/sea-query.git", features = ["thread-safe"] }
sea-query = { git = "https://github.com/SeaQL/sea-query.git", features = ["thread-safe"] }
sea-strum = { version = "^0.23", features = ["derive", "sea-orm"] }
serde = { version = "^1.0", features = ["derive"] }
serde_json = { version = "^1", optional = true }

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

@ -38,7 +38,8 @@ impl Column {
ColumnType::Json | ColumnType::JsonBinary => "Json".to_owned(),
ColumnType::Date => "Date".to_owned(),
ColumnType::Time(_) => "Time".to_owned(),
ColumnType::DateTime(_) | ColumnType::Timestamp(_) => "DateTime".to_owned(),
ColumnType::DateTime(_) => "DateTime".to_owned(),
ColumnType::Timestamp(_) => "DateTimeUtc".to_owned(),
ColumnType::TimestampWithTimeZone(_) => "DateTimeWithTimeZone".to_owned(),
ColumnType::Decimal(_) | ColumnType::Money(_) => "Decimal".to_owned(),
ColumnType::Uuid => "Uuid".to_owned(),
@ -271,7 +272,7 @@ mod tests {
"Date",
"Time",
"DateTime",
"DateTime",
"DateTimeUtc",
"DateTimeWithTimeZone",
];
for (mut col, rs_type) in columns.into_iter().zip(rs_types) {

2
sea-orm-macros/src/derives/entity_model.rs
View File

@ -242,7 +242,7 @@ pub fn expand_derive_entity_model(data: Data, attrs: Vec<Attribute>) -> syn::Res
"DateTime" | "NaiveDateTime" => {
quote! { DateTime }
}
"DateTimeWithTimeZone" => {
"DateTimeUtc" | "DateTimeLocal" | "DateTimeWithTimeZone" => {
quote! { TimestampWithTimeZone }
}
"Uuid" => quote! { Uuid },

3
src/entity/active_model.rs
View File

@ -612,6 +612,9 @@ impl_into_active_value!(crate::prelude::DateTimeWithTimeZone, Set);
#[cfg_attr(docsrs, doc(cfg(feature = "with-chrono")))]
impl_into_active_value!(crate::prelude::DateTimeUtc, Set);
#[cfg(feature = "with-chrono")]
#[cfg_attr(docsrs, doc(cfg(feature = "with-chrono")))]
impl_into_active_value!(crate::prelude::DateTimeLocal, Set);
#[cfg(feature = "with-rust_decimal")]
#[cfg_attr(docsrs, doc(cfg(feature = "with-rust_decimal")))]

11
src/entity/column.rs
View File

@ -9,6 +9,7 @@ pub struct ColumnDef {
pub(crate) null: bool,
pub(crate) unique: bool,
pub(crate) indexed: bool,
pub(crate) default_value: Option<Value>,
}
/// The type of column as defined in the SQL format
@ -300,6 +301,7 @@ impl ColumnType {
null: false,
unique: false,
indexed: false,
default_value: None,
}
}
@ -335,6 +337,15 @@ impl ColumnDef {
self
}
/// Set the default value
pub fn default_value<T>(mut self, value: T) -> Self
where
T: Into<Value>,
{
self.default_value = Some(value.into());
self
}
/// Get [ColumnType] as reference
pub fn get_column_type(&self) -> &ColumnType {
&self.col_type

48
src/entity/prelude.rs
View File

@ -24,54 +24,18 @@ pub use chrono::NaiveTime as Time;
#[cfg(feature = "with-chrono")]
pub use chrono::NaiveDateTime as DateTime;
/// Handles the time and dates
/// Date time with fixed offset
#[cfg(feature = "with-chrono")]
pub type DateTimeWithTimeZone = chrono::DateTime<chrono::FixedOffset>;
/// Handles the time and dates in UTC
///
/// ### Example Usage
/// ```ignore
/// use chrono::{DateTime, NaiveDateTime, Utc};
/// use sea_orm::prelude::*;
///
/// let my_model = fruit::Model {
/// id: 3_i32,
/// name: "Fruit".to_owned(),
/// cake_id: Some(4),
/// timer: DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(61, 0), Utc),
/// };
///
/// assert_eq!(
/// fruit::Model {
/// id: 3,
/// name: "Fruit".to_owned(),
/// cake_id: Some(4,),
/// timer: DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(61, 0), Utc),
/// },
/// my_model
/// );
///
/// // Define a `Model` containing a type of `DateTimeUtc` field
/// #[derive(Clone, Debug, PartialEq, DeriveModel, DeriveActiveModel)]
/// pub struct Model {
/// pub id: i32,
/// pub name: String,
/// pub cake_id: Option<i32>,
/// pub timer: DateTimeUtc,
/// }
///
/// #[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
/// pub enum Column {
/// Id,
/// Name,
/// CakeId,
/// Timer,
/// }
/// ```
/// Date time represented in UTC
#[cfg(feature = "with-chrono")]
pub type DateTimeUtc = chrono::DateTime<chrono::Utc>;
/// Date time represented in local time
#[cfg(feature = "with-chrono")]
pub type DateTimeLocal = chrono::DateTime<chrono::Local>;
#[cfg(feature = "with-rust_decimal")]
pub use rust_decimal::Decimal;

7
src/executor/query.rs
View File

@ -272,8 +272,10 @@ try_getable_all!(chrono::NaiveDateTime);
try_getable_date_time!(chrono::DateTime<chrono::FixedOffset>);
#[cfg(feature = "with-chrono")]
try_getable_date_time!(chrono::DateTime<chrono::Utc>);
try_getable_all!(chrono::DateTime<chrono::Utc>);
#[cfg(feature = "with-chrono")]
try_getable_all!(chrono::DateTime<chrono::Local>);
#[cfg(feature = "with-rust_decimal")]
use rust_decimal::Decimal;
@ -621,6 +623,9 @@ try_from_u64_err!(chrono::DateTime<chrono::FixedOffset>);
#[cfg(feature = "with-chrono")]
try_from_u64_err!(chrono::DateTime<chrono::Utc>);
#[cfg(feature = "with-chrono")]
try_from_u64_err!(chrono::DateTime<chrono::Local>);
#[cfg(feature = "with-rust_decimal")]
try_from_u64_err!(rust_decimal::Decimal);

18
src/query/combine.rs
View File

@ -45,15 +45,21 @@ where
None => {
let col = match &sel.expr {
SimpleExpr::Column(col_ref) => match &col_ref {
ColumnRef::Column(col) | ColumnRef::TableColumn(_, col) => col,
_ => panic!("Unimplemented"),
ColumnRef::Column(col)
| ColumnRef::TableColumn(_, col)
| ColumnRef::SchemaTableColumn(_, _, col) => col,
ColumnRef::Asterisk | ColumnRef::TableAsterisk(_) => {
panic!("cannot apply alias for Column with asterisk")
}
},
SimpleExpr::AsEnum(_, simple_expr) => match simple_expr.as_ref() {
SimpleExpr::Column(col_ref) => match &col_ref {
ColumnRef::Column(col) | ColumnRef::TableColumn(_, col) => col,
_ => panic!(
"cannot apply alias for AsEnum with expr other than Column"
),
ColumnRef::Column(col)
| ColumnRef::TableColumn(_, col)
| ColumnRef::SchemaTableColumn(_, _, col) => col,
ColumnRef::Asterisk | ColumnRef::TableAsterisk(_) => {
panic!("cannot apply alias for AsEnum with asterisk")
}
},
_ => {
panic!("cannot apply alias for AsEnum with expr other than Column")

2
src/query/util.rs
View File

@ -122,7 +122,7 @@ macro_rules! debug_query_stmt {
/// let raw_sql = debug_query!(&c, DbBackend::Sqlite);
/// assert_eq!(
/// raw_sql,
/// r#"INSERT INTO `cake` (`id`, `name`) VALUES (1, 'Apple Pie')"#
/// r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie')"#
/// );
/// ```
#[macro_export]

3
src/schema/entity.rs
View File

@ -103,6 +103,9 @@ where
if orm_column_def.unique {
column_def.unique_key();
}
if let Some(value) = orm_column_def.default_value {
column_def.default(value);
}
for primary_key in E::PrimaryKey::iter() {
if column.to_string() == primary_key.into_column().to_string() {
if E::PrimaryKey::auto_increment() {

80
tests/active_enum_tests.rs
View File

@ -405,8 +405,14 @@ mod tests {
#[cfg(any(feature = "sqlx-mysql", feature = "sqlx-sqlite"))]
{
assert_eq!(
_select.build(DbBackend::MySql).to_string(),
_select.build(DbBackend::Sqlite).to_string(),
[
r#"SELECT "active_enum_child"."id", "active_enum_child"."parent_id", "active_enum_child"."category", "active_enum_child"."color", "active_enum_child"."tea""#,
r#"FROM "active_enum_child""#,
r#"INNER JOIN "active_enum" ON "active_enum"."id" = "active_enum_child"."parent_id""#,
r#"WHERE "active_enum"."id" = 1"#,
]
.join(" ")
);
assert_eq!(
_select.build(DbBackend::MySql).to_string(),
@ -435,8 +441,16 @@ mod tests {
#[cfg(any(feature = "sqlx-mysql", feature = "sqlx-sqlite"))]
{
assert_eq!(
_select.build(DbBackend::MySql).to_string(),
_select.build(DbBackend::Sqlite).to_string(),
_select
.build(DbBackend::Sqlite)
.to_string(),
[
r#"SELECT "active_enum"."id" AS "A_id", "active_enum"."category" AS "A_category", "active_enum"."color" AS "A_color", "active_enum"."tea" AS "A_tea","#,
r#""active_enum_child"."id" AS "B_id", "active_enum_child"."parent_id" AS "B_parent_id", "active_enum_child"."category" AS "B_category", "active_enum_child"."color" AS "B_color", "active_enum_child"."tea" AS "B_tea""#,
r#"FROM "active_enum""#,
r#"LEFT JOIN "active_enum_child" ON "active_enum"."id" = "active_enum_child"."parent_id""#,
]
.join(" ")
);
assert_eq!(
_select
@ -478,8 +492,14 @@ mod tests {
#[cfg(any(feature = "sqlx-mysql", feature = "sqlx-sqlite"))]
{
assert_eq!(
_select.build(DbBackend::MySql).to_string(),
_select.build(DbBackend::Sqlite).to_string(),
[
r#"SELECT "active_enum_child"."id", "active_enum_child"."parent_id", "active_enum_child"."category", "active_enum_child"."color", "active_enum_child"."tea""#,
r#"FROM "active_enum_child""#,
r#"INNER JOIN "active_enum" AS "r0" ON "r0"."id" = "active_enum_child"."parent_id""#,
r#"WHERE "r0"."id" = 1"#,
]
.join(" ")
);
assert_eq!(
_select.build(DbBackend::MySql).to_string(),
@ -508,8 +528,16 @@ mod tests {
#[cfg(any(feature = "sqlx-mysql", feature = "sqlx-sqlite"))]
{
assert_eq!(
_select.build(DbBackend::MySql).to_string(),
_select.build(DbBackend::Sqlite).to_string(),
_select
.build(DbBackend::Sqlite)
.to_string(),
[
r#"SELECT "active_enum"."id" AS "A_id", "active_enum"."category" AS "A_category", "active_enum"."color" AS "A_color", "active_enum"."tea" AS "A_tea","#,
r#""r0"."id" AS "B_id", "r0"."parent_id" AS "B_parent_id", "r0"."category" AS "B_category", "r0"."color" AS "B_color", "r0"."tea" AS "B_tea""#,
r#"FROM "active_enum""#,
r#"LEFT JOIN "active_enum_child" AS "r0" ON "active_enum"."id" = "r0"."parent_id""#,
]
.join(" ")
);
assert_eq!(
_select
@ -552,8 +580,14 @@ mod tests {
#[cfg(any(feature = "sqlx-mysql", feature = "sqlx-sqlite"))]
{
assert_eq!(
_select.build(DbBackend::MySql).to_string(),
_select.build(DbBackend::Sqlite).to_string(),
[
r#"SELECT "active_enum"."id", "active_enum"."category", "active_enum"."color", "active_enum"."tea""#,
r#"FROM "active_enum""#,
r#"INNER JOIN "active_enum_child" ON "active_enum_child"."parent_id" = "active_enum"."id""#,
r#"WHERE "active_enum_child"."id" = 1"#,
]
.join(" ")
);
assert_eq!(
_select.build(DbBackend::MySql).to_string(),
@ -582,8 +616,16 @@ mod tests {
#[cfg(any(feature = "sqlx-mysql", feature = "sqlx-sqlite"))]
{
assert_eq!(
_select.build(DbBackend::MySql).to_string(),
_select.build(DbBackend::Sqlite).to_string(),
_select
.build(DbBackend::Sqlite)
.to_string(),
[
r#"SELECT "active_enum_child"."id" AS "A_id", "active_enum_child"."parent_id" AS "A_parent_id", "active_enum_child"."category" AS "A_category", "active_enum_child"."color" AS "A_color", "active_enum_child"."tea" AS "A_tea","#,
r#""active_enum"."id" AS "B_id", "active_enum"."category" AS "B_category", "active_enum"."color" AS "B_color", "active_enum"."tea" AS "B_tea""#,
r#"FROM "active_enum_child""#,
r#"LEFT JOIN "active_enum" ON "active_enum_child"."parent_id" = "active_enum"."id""#,
]
.join(" ")
);
assert_eq!(
_select
@ -626,8 +668,14 @@ mod tests {
#[cfg(any(feature = "sqlx-mysql", feature = "sqlx-sqlite"))]
{
assert_eq!(
_select.build(DbBackend::MySql).to_string(),
_select.build(DbBackend::Sqlite).to_string(),
[
r#"SELECT "active_enum"."id", "active_enum"."category", "active_enum"."color", "active_enum"."tea""#,
r#"FROM "active_enum""#,
r#"INNER JOIN "active_enum_child" AS "r0" ON "r0"."parent_id" = "active_enum"."id""#,
r#"WHERE "r0"."id" = 1"#,
]
.join(" ")
);
assert_eq!(
_select.build(DbBackend::MySql).to_string(),
@ -656,8 +704,16 @@ mod tests {
#[cfg(any(feature = "sqlx-mysql", feature = "sqlx-sqlite"))]
{
assert_eq!(
_select.build(DbBackend::MySql).to_string(),
_select.build(DbBackend::Sqlite).to_string(),
_select
.build(DbBackend::Sqlite)
.to_string(),
[
r#"SELECT "active_enum_child"."id" AS "A_id", "active_enum_child"."parent_id" AS "A_parent_id", "active_enum_child"."category" AS "A_category", "active_enum_child"."color" AS "A_color", "active_enum_child"."tea" AS "A_tea","#,
r#""r0"."id" AS "B_id", "r0"."category" AS "B_category", "r0"."color" AS "B_color", "r0"."tea" AS "B_tea""#,
r#"FROM "active_enum_child""#,
r#"LEFT JOIN "active_enum" AS "r0" ON "active_enum_child"."parent_id" = "r0"."id""#,
]
.join(" ")
);
assert_eq!(
_select

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

@ -2,9 +2,9 @@ pub mod active_enum;
pub mod active_enum_child;
pub mod applog;
pub mod byte_primary_key;
pub mod datetimeutc;
pub mod metadata;
pub mod repository;
pub mod satellite;
pub mod schema;
pub mod sea_orm_active_enums;
pub mod self_join;
@ -13,9 +13,9 @@ pub use active_enum::Entity as ActiveEnum;
pub use active_enum_child::Entity as ActiveEnumChild;
pub use applog::Entity as Applog;
pub use byte_primary_key::Entity as BytePrimaryKey;
pub use datetimeutc::Entity as DateTimeUtcTest;
pub use metadata::Entity as Metadata;
pub use repository::Entity as Repository;
pub use satellite::Entity as Satellite;
pub use schema::*;
pub use sea_orm_active_enums::*;
pub use self_join::Entity as SelfJoin;

6
tests/common/features/datetimeutc.rs → tests/common/features/satellite.rs
View File

@ -1,13 +1,15 @@
use sea_orm::entity::prelude::*;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
#[sea_orm(table_name = "satellites")]
#[sea_orm(table_name = "satellite")]
pub struct Model {
#[sea_orm(primary_key)]
pub id: i32,
pub satellite_name: String,
#[sea_orm(default_value = "2022-01-26 16:24:00")]
pub launch_date: DateTimeUtc,
pub deployment_date: DateTimeUtc,
#[sea_orm(default_value = "2022-01-26 16:24:00")]
pub deployment_date: DateTimeLocal,
}
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

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

@ -205,30 +205,32 @@ pub async fn create_active_enum_child_table(db: &DbConn) -> Result<ExecResult, D
pub async fn create_satellites_table(db: &DbConn) -> Result<ExecResult, DbErr> {
let stmt = sea_query::Table::create()
.table(datetimeutc::Entity)
.table(satellite::Entity)
.col(
ColumnDef::new(datetimeutc::Column::Id)
ColumnDef::new(satellite::Column::Id)
.integer()
.not_null()
.auto_increment()
.primary_key(),
)
.col(
ColumnDef::new(datetimeutc::Column::SatelliteName)
ColumnDef::new(satellite::Column::SatelliteName)
.string()
.not_null(),
)
.col(
ColumnDef::new(datetimeutc::Column::LaunchDate)
ColumnDef::new(satellite::Column::LaunchDate)
.timestamp_with_time_zone()
.not_null(),
.not_null()
.default("2022-01-26 16:24:00"),
)
.col(
ColumnDef::new(datetimeutc::Column::DeploymentDate)
ColumnDef::new(satellite::Column::DeploymentDate)
.timestamp_with_time_zone()
.not_null(),
.not_null()
.default("2022-01-26 16:24:00"),
)
.to_owned();
create_table(db, &stmt, DateTimeUtcTest).await
create_table(db, &stmt, Satellite).await
}

22
tests/timestamp_tests.rs
View File

@ -12,17 +12,10 @@ async fn main() -> Result<(), DbErr> {
let ctx = TestContext::new("bakery_chain_schema_timestamp_tests").await;
create_tables(&ctx.db).await?;
create_applog(&ctx.db).await?;
create_satellites_log(&ctx.db).await?;
ctx.delete().await;
{
let ctx = TestContext::new("bakery_chain_schema_timestamp_tests").await;
create_tables(&ctx.db).await?;
create_satellites_log(&ctx.db).await?;
ctx.delete().await;
}
Ok(())
}
@ -38,29 +31,26 @@ pub async fn create_applog(db: &DatabaseConnection) -> Result<(), DbErr> {
.exec(db)
.await?;
assert_eq!(log.id.clone(), res.last_insert_id);
assert_eq!(log.id, res.last_insert_id);
assert_eq!(Applog::find().one(db).await?, Some(log.clone()));
Ok(())
}
pub async fn create_satellites_log(db: &DatabaseConnection) -> Result<(), DbErr> {
let archive = datetimeutc::Model {
let archive = satellite::Model {
id: 1,
satellite_name: "Sea-00001-2022".to_owned(),
launch_date: "2022-01-07T12:11:23Z".parse().unwrap(),
deployment_date: "2022-01-07T12:11:23Z".parse().unwrap(),
};
let res = DateTimeUtcTest::insert(archive.clone().into_active_model())
let res = Satellite::insert(archive.clone().into_active_model())
.exec(db)
.await?;
assert_eq!(archive.id.clone(), res.last_insert_id);
assert_eq!(
DateTimeUtcTest::find().one(db).await?,
Some(archive.clone())
);
assert_eq!(archive.id, res.last_insert_id);
assert_eq!(Satellite::find().one(db).await?, Some(archive.clone()));
Ok(())
}