1use proc_macro2::{Span, TokenStream};
2use syn::spanned::Spanned;
3use syn::{Expr, Field as SynField, Ident, Index, Result, Type};
4
5use crate::attrs::{parse_attributes, AttributeSpanWrapper, FieldAttr, SqlIdentifier};
6
7pub struct Field {
8 pub ty: Type,
9 pub span: Span,
10 pub name: FieldName,
11 column_name: Option<AttributeSpanWrapper<SqlIdentifier>>,
12 pub sql_type: Option<AttributeSpanWrapper<Type>>,
13 pub treat_none_as_default_value: Option<AttributeSpanWrapper<bool>>,
14 pub treat_none_as_null: Option<AttributeSpanWrapper<bool>>,
15 pub serialize_as: Option<AttributeSpanWrapper<Type>>,
16 pub deserialize_as: Option<AttributeSpanWrapper<Type>>,
17 pub select_expression: Option<AttributeSpanWrapper<Expr>>,
18 pub select_expression_type: Option<AttributeSpanWrapper<Type>>,
19 pub embed: Option<AttributeSpanWrapper<bool>>,
20 pub skip_insertion: Option<AttributeSpanWrapper<bool>>,
21}
22
23impl Field {
24 pub fn from_struct_field(field: &SynField, index: usize) -> Result<Self> {
25 let SynField {
26 ident, attrs, ty, ..
27 } = field;
28
29 let mut column_name = None;
30 let mut sql_type = None;
31 let mut serialize_as = None;
32 let mut deserialize_as = None;
33 let mut embed = None;
34 let mut skip_insertion = None;
35 let mut select_expression = None;
36 let mut select_expression_type = None;
37 let mut treat_none_as_default_value = None;
38 let mut treat_none_as_null = None;
39
40 for attr in parse_attributes(attrs)? {
41 let attribute_span = attr.attribute_span;
42 let ident_span = attr.ident_span;
43 match attr.item {
44 FieldAttr::ColumnName(_, value) => {
45 column_name = Some(AttributeSpanWrapper {
46 item: value,
47 attribute_span,
48 ident_span,
49 })
50 }
51 FieldAttr::SqlType(_, value) => {
52 sql_type = Some(AttributeSpanWrapper {
53 item: Type::Path(value),
54 attribute_span,
55 ident_span,
56 })
57 }
58 FieldAttr::TreatNoneAsDefaultValue(_, value) => {
59 treat_none_as_default_value = Some(AttributeSpanWrapper {
60 item: value.value,
61 attribute_span,
62 ident_span,
63 })
64 }
65 FieldAttr::TreatNoneAsNull(_, value) => {
66 treat_none_as_null = Some(AttributeSpanWrapper {
67 item: value.value,
68 attribute_span,
69 ident_span,
70 })
71 }
72 FieldAttr::SerializeAs(_, value) => {
73 serialize_as = Some(AttributeSpanWrapper {
74 item: Type::Path(value),
75 attribute_span,
76 ident_span,
77 })
78 }
79 FieldAttr::DeserializeAs(_, value) => {
80 deserialize_as = Some(AttributeSpanWrapper {
81 item: Type::Path(value),
82 attribute_span,
83 ident_span,
84 })
85 }
86 FieldAttr::SelectExpression(_, value) => {
87 select_expression = Some(AttributeSpanWrapper {
88 item: value,
89 attribute_span,
90 ident_span,
91 })
92 }
93 FieldAttr::SelectExpressionType(_, value) => {
94 select_expression_type = Some(AttributeSpanWrapper {
95 item: value,
96 attribute_span,
97 ident_span,
98 })
99 }
100 FieldAttr::Embed(_) => {
101 embed = Some(AttributeSpanWrapper {
102 item: true,
103 attribute_span,
104 ident_span,
105 })
106 }
107 FieldAttr::SkipInsertion(_) => {
108 skip_insertion = Some(AttributeSpanWrapper {
109 item: true,
110 attribute_span,
111 ident_span,
112 })
113 }
114 }
115 }
116
117 let name = match ident.clone() {
118 Some(x) => FieldName::Named(x),
119 None => FieldName::Unnamed(index.into()),
120 };
121
122 let span = match name {
123 FieldName::Named(ref ident) => ident.span(),
124 FieldName::Unnamed(_) => ty.span(),
125 };
126
127 Ok(Self {
128 ty: ty.clone(),
129 span,
130 name,
131 column_name,
132 sql_type,
133 treat_none_as_default_value,
134 treat_none_as_null,
135 serialize_as,
136 deserialize_as,
137 select_expression,
138 select_expression_type,
139 embed,
140 skip_insertion,
141 })
142 }
143
144 pub fn column_name(&self) -> Result<SqlIdentifier> {
145 let identifier = self.column_name.as_ref().map(|a| a.item.clone());
146 if let Some(identifier) = identifier {
147 Ok(identifier)
148 } else {
149 match self.name {
150 FieldName::Named(ref x) => Ok(x.into()),
151 FieldName::Unnamed(ref x) => Err(syn::Error::new(
152 x.span(),
153 "All fields of tuple structs must be annotated with `#[diesel(column_name)]`",
154 )),
155 }
156 }
157 }
158
159 pub fn ty_for_deserialize(&self) -> &Type {
160 if let Some(AttributeSpanWrapper { item: value, .. }) = &self.deserialize_as {
161 value
162 } else {
163 &self.ty
164 }
165 }
166
167 pub(crate) fn embed(&self) -> bool {
168 self.embed.as_ref().map(|a| a.item).unwrap_or(false)
169 }
170
171 pub(crate) fn skip_insertion(&self) -> bool {
172 self.skip_insertion
173 .as_ref()
174 .map(|a| a.item)
175 .unwrap_or(false)
176 }
177}
178
179pub enum FieldName {
180 Named(Ident),
181 Unnamed(Index),
182}
183
184impl quote::ToTokens for FieldName {
185 fn to_tokens(&self, tokens: &mut TokenStream) {
186 match *self {
187 FieldName::Named(ref x) => x.to_tokens(tokens),
188 FieldName::Unnamed(ref x) => x.to_tokens(tokens),
189 }
190 }
191}