Renameable time field (#162)

* WIP: enable time fields with non-standard names in derive macro

* Enable serializing DateTime<Utc>

* Place chrono-dependent code behind feature flag

* Add impl for the time-crate counterpart

* remove unused import

* remove unused import

---------

Co-authored-by: Matthew Badger <[email protected]>
Co-authored-by: Dominic <[email protected]>

Author: 3 people

influxdb/src/query/write_query.rs

@@ -152,6 +152,28 @@ impl From<&str> for Type {
         Type::Text(b.into())
     }
 }
+
+#[cfg(feature = "chrono")]
+impl<Tz: chrono::TimeZone> From<chrono::DateTime<Tz>> for Type {
+    fn from(dt: chrono::DateTime<Tz>) -> Self {
+        match dt.timestamp_nanos_opt() {
+            Some(nanos) => Type::SignedInteger(nanos),
+            None => {
+                // For dates before 1677-09-21, or after
+                // 2262-04-11, we're just going to return 0.
+                Type::SignedInteger(0)
+            }
+        }
+    }
+}
+
+#[cfg(feature = "time")]
+impl From<time::UtcDateTime> for Type {
+    fn from(dt: time::UtcDateTime) -> Self {
+        Type::SignedInteger(dt.unix_timestamp_nanos().try_into().unwrap_or(0))
+    }
+}
+
 impl<T> From<&T> for Type
 where
     T: Copy + Into<Type>,

influxdb/tests/derive_integration_tests.rs

@@ -23,6 +23,20 @@ struct WeatherReading {
     wind_strength: Option<u64>,
 }
 
+#[derive(Debug, PartialEq)]
+#[cfg_attr(feature = "derive", derive(InfluxDbWriteable))]
+struct WeatherReadingWithNonstandardTime {
+    #[influxdb(time)]
+    reading_time: DateTime<Utc>,
+    #[influxdb(ignore)]
+    time: DateTime<Utc>,
+    #[influxdb(ignore)]
+    humidity: i32,
+    pressure: i32,
+    #[influxdb(tag)]
+    wind_strength: Option<u64>,
+}
+
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(Deserialize))]
 struct WeatherReadingWithoutIgnored {
@@ -47,6 +61,23 @@ fn test_build_query() {
     );
 }
 
+#[test]
+fn test_build_nonstandard_query() {
+    let weather_reading = WeatherReadingWithNonstandardTime {
+        reading_time: Timestamp::Hours(1).into(),
+        time: Timestamp::Hours(1).into(),
+        humidity: 30,
+        pressure: 100,
+        wind_strength: Some(5),
+    };
+    let query = weather_reading.into_query("weather_reading");
+    let query = query.build().unwrap();
+    assert_eq!(
+        query.get(),
+        "weather_reading,wind_strength=5 pressure=100i 3600000000000"
+    );
+}
+
 #[cfg(feature = "derive")]
 /// INTEGRATION TEST
 ///

influxdb_derive/src/writeable.rs

@@ -1,5 +1,5 @@
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
+use quote::quote;
 use syn::{
     parse::{Parse, ParseStream},
     punctuated::Punctuated,
@@ -9,27 +9,32 @@ use syn::{
 #[derive(Debug)]
 struct WriteableField {
     ident: Ident,
+    is_time: bool,
     is_tag: bool,
     is_ignore: bool,
 }
 
 mod kw {
     use syn::custom_keyword;
 
+    custom_keyword!(time);
     custom_keyword!(tag);
     custom_keyword!(ignore);
 }
 
 #[allow(dead_code)] // TODO do we need to store the keywords?
 enum FieldAttr {
+    Time(kw::time),
     Tag(kw::tag),
     Ignore(kw::ignore),
 }
 
 impl Parse for FieldAttr {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
         let lookahead = input.lookahead1();
-        if lookahead.peek(kw::tag) {
+        if lookahead.peek(kw::time) {
+            Ok(Self::Time(input.parse()?))
+        } else if lookahead.peek(kw::tag) {
             Ok(Self::Tag(input.parse()?))
         } else if lookahead.peek(kw::ignore) {
             Ok(Self::Ignore(input.parse()?))
@@ -52,6 +57,7 @@ impl TryFrom<Field> for WriteableField {
 
     fn try_from(field: Field) -> syn::Result<WriteableField> {
         let ident = field.ident.expect("fields without ident are not supported");
+        let mut has_time_attr = false;
         let mut is_tag = false;
         let mut is_ignore = false;
 
@@ -60,6 +66,7 @@ impl TryFrom<Field> for WriteableField {
                 Meta::List(list) if list.path.is_ident("influxdb") => {
                     for attr in syn::parse2::<FieldAttrs>(list.tokens)?.0 {
                         match attr {
+                            FieldAttr::Time(_) => has_time_attr = true,
                             FieldAttr::Tag(_) => is_tag = true,
                             FieldAttr::Ignore(_) => is_ignore = true,
                         }
@@ -69,8 +76,23 @@ impl TryFrom<Field> for WriteableField {
             }
         }
 
+        if [has_time_attr, is_tag, is_ignore]
+            .iter()
+            .filter(|&&b| b)
+            .count()
+            > 1
+        {
+            panic!("only one of time, tag, or ignore can be used");
+        }
+
+        // A field is considered a time field if:
+        // 1. It has the #[influxdb(time)] attribute, OR
+        // 2. It's named "time" and doesn't have #[influxdb(ignore)]
+        let is_time = has_time_attr || (ident == "time" && !is_ignore);
+
         Ok(WriteableField {
             ident,
+            is_time,
             is_tag,
             is_ignore,
         })
@@ -97,39 +119,52 @@ pub fn expand_writeable(input: DeriveInput) -> syn::Result<TokenStream> {
         }
     };
 
-    let time_field = format_ident!("time");
-    let time_field_str = time_field.to_string();
-    #[allow(clippy::cmp_owned)] // that's not how idents work clippy
-    let fields = match fields {
+    let writeable_fields: Vec<WriteableField> = match fields {
         Fields::Named(fields) => fields
             .named
             .into_iter()
-            .filter_map(|f| {
-                WriteableField::try_from(f)
-                    .map(|wf| {
-                        if !wf.is_ignore && wf.ident.to_string() != time_field_str {
-                            let ident = wf.ident;
-                            Some(match wf.is_tag {
-                                true => quote!(query.add_tag(stringify!(#ident), self.#ident)),
-                                false => quote!(query.add_field(stringify!(#ident), self.#ident)),
-                            })
-                        } else {
-                            None
-                        }
-                    })
-                    .transpose()
-            })
+            .map(WriteableField::try_from)
             .collect::<syn::Result<Vec<_>>>()?,
-        _ => panic!("a struct without named fields is not supported"),
+        _ => panic!("A struct without named fields is not supported!"),
     };
 
+    // Find the time field
+    let mut time_field = None;
+    for wf in &writeable_fields {
+        if wf.is_time {
+            if time_field.is_some() {
+                panic!("multiple time fields found!");
+            }
+            time_field = Some(wf.ident.clone());
+        }
+    }
+
+    // There must be exactly one time field
+    let time_field = time_field.expect("no time field found");
+
+    // Generate field assignments (excluding time and ignored fields)
+    let field_assignments = writeable_fields
+        .into_iter()
+        .filter_map(|wf| {
+            if wf.is_ignore || wf.is_time {
+                None
+            } else {
+                let ident = wf.ident;
+                Some(match wf.is_tag {
+                    true => quote!(query.add_tag(stringify!(#ident), self.#ident)),
+                    false => quote!(query.add_field(stringify!(#ident), self.#ident)),
+                })
+            }
+        })
+        .collect::<Vec<_>>();
+
     Ok(quote! {
         impl #impl_generics ::influxdb::InfluxDbWriteable for #ident #ty_generics #where_clause {
             fn into_query<I: Into<String>>(self, name: I) -> ::influxdb::WriteQuery {
                 let timestamp: ::influxdb::Timestamp = self.#time_field.into();
                 let mut query = timestamp.into_query(name);
                 #(
-                    query = #fields;
+                    query = #field_assignments;
                 )*
                 query
             }