Derive value type

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

@@ -15,6 +15,7 @@ mod related_entity;
 mod relation;
 mod try_getable_from_json;
 mod util;
+mod value_type;
 
 pub use active_enum::*;
 pub use active_model::*;
@@ -31,3 +32,4 @@ pub use primary_key::*;
 pub use related_entity::*;
 pub use relation::*;
 pub use try_getable_from_json::*;
+pub use value_type::*;

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

@@ -0,0 +1,240 @@
+use proc_macro2::TokenStream;
+use quote::{quote, quote_spanned};
+use syn::{spanned::Spanned, Lit, LitStr, Type};
+
+struct DeriveValueType {
+ name: syn::Ident,
+ ty: Type,
+ column_type: TokenStream,
+ array_type: TokenStream,
+}
+
+impl DeriveValueType {
+ pub fn new(input: syn::DeriveInput) -> Option<Self> {
+ let dat = input.data;
+ let fields: Option<syn::punctuated::Punctuated<syn::Field, syn::token::Comma>> = match dat {
+ syn::Data::Struct(syn::DataStruct {
+ fields: syn::Fields::Unnamed(syn::FieldsUnnamed { unnamed, .. }),
+ ..
+ }) => Some(unnamed),
+ _ => None,
+ };
+
+ let field = fields
+ .expect("This derive accept only struct")
+ .first()
+ .expect("The struct should contain one value field")
+ .to_owned();
+
+ let name = input.ident;
+ let mut col_type = None;
+ let mut arr_type = None;
+
+ for attr in input.attrs.iter() {
+ if !attr.path().is_ident("sea_orm") {
+ continue;
+ }
+
+ attr.parse_nested_meta(|meta| {
+ if meta.path.is_ident("column_type") {
+ let lit = meta.value()?.parse()?;
+ if let Lit::Str(litstr) = lit {
+ let ty: TokenStream = syn::parse_str(&litstr.value())?;
+ col_type = Some(ty);
+ } else {
+ return Err(meta.error(format!("Invalid column_type {:?}", lit)));
+ }
+ } else if meta.path.is_ident("array_type") {
+ let lit = meta.value()?.parse()?;
+ if let Lit::Str(litstr) = lit {
+ let ty: TokenStream = syn::parse_str(&litstr.value())?;
+ arr_type = Some(ty);
+ } else {
+ return Err(meta.error(format!("Invalid array_type {:?}", lit)));
+ }
+ } else {
+ // received other attribute
+ return Err(meta.error(format!("Invalid attribute {:?}", meta.path)));
+ }
+
+ Ok(())
+ })
+ .unwrap_or(());
+ }
+
+ let ty = field.clone().ty;
+ let field_type = quote! { #ty }
+ .to_string() //E.g.: "Option < String >"
+ .replace(' ', ""); // Remove spaces
+ let field_type = if field_type.starts_with("Option<") {
+ &field_type[7..(field_type.len() - 1)] // Extract `T` out of `Option<T>`
+ } else {
+ field_type.as_str()
+ };
+
+ let column_type = match col_type {
+ Some(t) => quote! { sea_orm::sea_query::ColumnType::#t },
+ None => {
+ let col_type = match field_type {
+ "char" => quote! { Char(None) },
+ "String" | "&str" => quote! { String(None) },
+ "i8" => quote! { TinyInteger },
+ "u8" => quote! { TinyUnsigned },
+ "i16" => quote! { SmallInteger },
+ "u16" => quote! { SmallUnsigned },
+ "i32" => quote! { Integer },
+ "u32" => quote! { Unsigned },
+ "i64" => quote! { BigInteger },
+ "u64" => quote! { BigUnsigned },
+ "f32" => quote! { Float },
+ "f64" => quote! { Double },
+ "bool" => quote! { Boolean },
+ "Date" | "NaiveDate" => quote! { Date },
+ "Time" | "NaiveTime" => quote! { Time },
+ "DateTime" | "NaiveDateTime" => {
+ quote! { DateTime }
+ }
+ "DateTimeUtc" | "DateTimeLocal" | "DateTimeWithTimeZone" => {
+ quote! { TimestampWithTimeZone }
+ }
+ "Uuid" => quote! { Uuid },
+ "Json" => quote! { Json },
+ "Decimal" => quote! { Decimal(None) },
+ "Vec<u8>" => {
+ quote! { Binary(sea_orm::sea_query::BlobSize::Blob(None)) }
+ }
+ _ => {
+ // Assumed it's ActiveEnum if none of the above type matches
+ quote! {}
+ }
+ };
+ if col_type.is_empty() {
+ let field_span = field.span();
+ let ty: Type = LitStr::new(field_type, field_span)
+ .parse()
+ .expect("field type error");
+ let def = quote_spanned! { field_span =>
+ std::convert::Into::<sea_orm::ColumnType>::into(
+ <#ty as sea_orm::sea_query::ValueType>::column_type()
+ )
+ };
+ quote! { #def }
+ } else {
+ quote! { sea_orm::sea_query::ColumnType::#col_type }
+ }
+ }
+ };
+
+ let array_type = match arr_type {
+ Some(t) => quote! { sea_orm::sea_query::ArrayType::#t },
+ None => {
+ let arr_type = match field_type {
+ "char" => quote! { Char },
+ "String" | "&str" => quote! { String },
+ "i8" => quote! { TinyInt },
+ "u8" => quote! { TinyUnsigned },
+ "i16" => quote! { SmallInt },
+ "u16" => quote! { SmallUnsigned },
+ "i32" => quote! { Int },
+ "u32" => quote! { Unsigned },
+ "i64" => quote! { BigInt },
+ "u64" => quote! { BigUnsigned },
+ "f32" => quote! { Float },
+ "f64" => quote! { Double },
+ "bool" => quote! { Bool },
+ "Date" | "NaiveDate" => quote! { ChronoDate },
+ "Time" | "NaiveTime" => quote! { ChronoTime },
+ "DateTime" | "NaiveDateTime" => {
+ quote! { ChronoDateTime }
+ }
+ "DateTimeUtc" | "DateTimeLocal" | "DateTimeWithTimeZone" => {
+ quote! { ChronoDateTimeWithTimeZone }
+ }
+ "Uuid" => quote! { Uuid },
+ "Json" => quote! { Json },
+ "Decimal" => quote! { Decimal },
+ _ => {
+ // Assumed it's ActiveEnum if none of the above type matches
+ quote! {}
+ }
+ };
+ if arr_type.is_empty() {
+ let field_span = field.span();
+ let ty: Type = LitStr::new(field_type, field_span)
+ .parse()
+ .expect("field type error");
+ let def = quote_spanned! { field_span =>
+ std::convert::Into::<sea_orm::ArrayType>::into(
+ <#ty as sea_orm::sea_query::ValueType>::array_type()
+ )
+ };
+ quote! { #def }
+ } else {
+ quote! { sea_orm::sea_query::ArrayType::#arr_type }
+ }
+ }
+ };
+
+ Some(DeriveValueType {
+ name,
+ ty,
+ column_type,
+ array_type,
+ })
+ }
+
+ fn expand(&self) -> syn::Result<TokenStream> {
+ let expanded_impl_value_type: TokenStream = self.impl_value_type();
+ Ok(expanded_impl_value_type)
+ }
+
+ fn impl_value_type(&self) -> TokenStream {
+ let name = &self.name;
+ let field_type = &self.ty;
+ let column_type = &self.column_type;
+ let array_type = &self.array_type;
+
+ quote!(
+ #[automatically_derived]
+ impl From<#name> for Value {
+ fn from(source: #name) -> Self {
+ source.0.into()
+ }
+ }
+
+ #[automatically_derived]
+ impl sea_orm::TryGetable for #name {
+ fn try_get_by<I: sea_orm::ColIdx>(res: &QueryResult, idx: I) -> Result<Self, sea_orm::TryGetError> {
+ <#field_type as sea_orm::TryGetable>::try_get_by(res, idx).map(|v| #name(v))
+ }
+ }
+
+ #[automatically_derived]
+ impl sea_orm::sea_query::ValueType for #name {
+ fn try_from(v: Value) -> Result<Self, sea_orm::sea_query::ValueTypeErr> {
+ <#field_type as sea_orm::sea_query::ValueType>::try_from(v).map(|v| #name(v))
+ }
+
+ fn type_name() -> String {
+ stringify!(#name).to_owned()
+ }
+
+ fn array_type() -> sea_orm::sea_query::ArrayType {
+ #array_type
+ }
+
+ fn column_type() -> sea_orm::sea_query::ColumnType {
+ #column_type
+ }
+ }
+ )
+ }
+}
+
+pub fn expand_derive_value_type(input: syn::DeriveInput) -> syn::Result<TokenStream> {
+ let input_span = input.span();
+ match DeriveValueType::new(input) {
+ Some(model) => model.expand(),
+ None => Err(syn::Error::new(input_span, "error")),
+ }
+}

sea-orm-macros/src/lib.rs

@@ -832,3 +832,13 @@ pub fn enum_iter(input: TokenStream) -> TokenStream {
  .unwrap_or_else(Error::into_compile_error)
  .into()
 }
+
+#[cfg(feature = "derive")]
+#[proc_macro_derive(DeriveValueType, attributes(sea_orm))]
+pub fn derive_value_type(input: TokenStream) -> TokenStream {
+ let derive_input = parse_macro_input!(input as DeriveInput);
+ match derives::expand_derive_value_type(derive_input) {
+ Ok(token_stream) => token_stream.into(),
+ Err(e) => e.to_compile_error().into(),
+ }
+}

tests/common/features/mod.rs

@@ -23,6 +23,7 @@ pub mod self_join;
 pub mod teas;
 pub mod transaction_log;
 pub mod uuid_fmt;
+pub mod value_type;
 
 pub use active_enum::Entity as ActiveEnum;
 pub use active_enum_child::Entity as ActiveEnumChild;

tests/common/features/schema.rs

@@ -48,6 +48,7 @@ pub async fn create_tables(db: &DatabaseConnection) -> Result<(), DbErr> {
  create_binary_table(db).await?;
  create_bits_table(db).await?;
  create_dyn_table_name_lazy_static_table(db).await?;
+ create_value_type_table(db).await?;
 
  if DbBackend::Postgres == db_backend {
  create_collection_table(db).await?;
@@ -634,3 +635,23 @@ pub async fn create_dyn_table_name_lazy_static_table(db: &DbConn) -> Result<(),
 
  Ok(())
 }
+
+pub async fn create_value_type_table(db: &DbConn) -> Result<ExecResult, DbErr> {
+ let stmt = sea_query::Table::create()
+ .table(value_type::Entity)
+ .col(
+ ColumnDef::new(value_type::Column::Id)
+ .integer()
+ .not_null()
+ .auto_increment()
+ .primary_key(),
+ )
+ .col(
+ ColumnDef::new(value_type::Column::Number)
+ .integer()
+ .not_null(),
+ )
+ .to_owned();
+
+ create_table(db, &stmt, value_type::Entity).await
+}

tests/common/features/value_type.rs

@@ -0,0 +1,26 @@
+use sea_orm::entity::prelude::*;
+use sea_orm_macros::DeriveValueType;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "value_type")]
+pub struct Model {
+ #[sea_orm(primary_key)]
+ pub id: i32,
+ pub number: Integer,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveValueType)]
+pub struct Integer(pub i32);
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveValueType)]
+#[sea_orm(column_type = "String(Some(1))", array_type = "String")]
+pub struct StringVec(pub Vec<String>);
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveValueType)]
+#[sea_orm(column_type = "Boolean", array_type = "Bool")]
+pub struct Boolbean(pub String);