savanni
/
monorepo
1
0
Fork 0
Code Issues 76 Pull Requests Projects 6 Releases Wiki Activity

Implement the Timestamp structure 

This struct now allows dates and datetimes to both be used together
This commit is contained in:
Savanni D'Gerinel 2023-05-24 23:59:06 -04:00 committed by Gitea
parent d4a55ccb17
commit 7546a81876
6 changed files with 102 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
emseries/fixtures/weight.json
View File

@ -1,2 +0,0 @@
{"data":{"weight":77.79109,"date":"2003-11-10T06:00:00.000000000000Z"},"id":"3330c5b0-783f-4919-b2c4-8169c38f65ff"}
{"data":{"weight":77.56429,"date":"2003-11-11T06:00:00.000000000000Z"},"id":"54c10502-030e-43d2-9ca6-df2f9a5a5ddf"}

12
emseries/src/criteria.rs
View File

@ -11,7 +11,7 @@ You should have received a copy of the GNU General Public License along with Lum
*/
use date_time_tz::DateTimeTz;
use types::Recordable;
use types::{Recordable, Timestamp};
/// This trait is used for constructing queries for searching the database.
pub trait Criteria {
@ -45,7 +45,7 @@ pub struct Or<A: Criteria, B: Criteria> {
/// Specify the starting time for a search. This consists of a UTC timestamp and a specifier as to
/// whether the exact time is included in the search criteria.
pub struct StartTime {
pub time: DateTimeTz,
pub time: Timestamp,
pub incl: bool,
}
@ -62,7 +62,7 @@ impl Criteria for StartTime {
/// Specify the ending time for a search. This consists of a UTC timestamp and a specifier as to
/// whether the exact time is included in the search criteria.
pub struct EndTime {
pub time: DateTimeTz,
pub time: Timestamp,
pub incl: bool,
}
@ -89,7 +89,7 @@ impl Criteria for Tags {
}
/// Specify a criteria that searches for records matching an exact time.
pub fn exact_time(time: DateTimeTz) -> And<StartTime, EndTime> {
pub fn exact_time(time: Timestamp) -> And<StartTime, EndTime> {
And {
lside: StartTime {
time: time.clone(),
@ -101,9 +101,9 @@ pub fn exact_time(time: DateTimeTz) -> And<StartTime, EndTime> {
/// Specify a criteria that searches for all records within a time range.
pub fn time_range(
start: DateTimeTz,
start: Timestamp,
start_incl: bool,
end: DateTimeTz,
end: Timestamp,
end_incl: bool,
) -> And<StartTime, EndTime> {
And {

6
emseries/src/date_time_tz.rs
View File

@ -70,6 +70,12 @@ impl std::str::FromStr for DateTimeTz {
}
}
impl From<chrono::DateTime<chrono_tz::Tz>> for DateTimeTz {
fn from(dt: chrono::DateTime<chrono_tz::Tz>) -> DateTimeTz {
DateTimeTz(dt)
}
}
struct DateTimeTzVisitor;
impl<'de> Visitor<'de> for DateTimeTzVisitor {

2
emseries/src/lib.rs
View File

@ -78,4 +78,4 @@ mod types;
pub use criteria::*;
pub use date_time_tz::DateTimeTz;
pub use series::Series;
pub use types::{EmseriesReadError, EmseriesWriteError, Recordable, UniqueId};
pub use types::{EmseriesReadError, EmseriesWriteError, Recordable, Timestamp, UniqueId};

85
emseries/src/types.rs
View File

@ -14,7 +14,7 @@ use chrono::NaiveDate;
use date_time_tz::DateTimeTz;
use serde::de::DeserializeOwned;
use serde::ser::Serialize;
use std::{fmt, io, str};
use std::{cmp::Ordering, fmt, io, str};
use thiserror::Error;
use uuid::Uuid;
@ -44,9 +44,10 @@ pub enum EmseriesWriteError {
JSONWriteError(serde_json::error::Error),
}
#[derive(Debug, Clone, PartialEq)]
enum Timestamp {
DateTimeTz(DateTimeTz),
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Timestamp {
DateTime(DateTimeTz),
Date(NaiveDate),
}
@ -54,16 +55,45 @@ impl str::FromStr for Timestamp {
type Err = chrono::ParseError;
fn from_str(line: &str) -> Result<Self, Self::Err> {
DateTimeTz::from_str(line)
.map(|dtz| Timestamp::DateTimeTz(dtz))
.map(|dtz| Timestamp::DateTime(dtz))
.or(NaiveDate::from_str(line).map(|d| Timestamp::Date(d)))
}
}
impl PartialOrd for Timestamp {
fn partial_cmp(&self, other: &Timestamp) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for Timestamp {
fn cmp(&self, other: &Timestamp) -> Ordering {
match (self, other) {
(Timestamp::DateTime(dt1), Timestamp::DateTime(dt2)) => dt1.cmp(dt2),
(Timestamp::DateTime(dt1), Timestamp::Date(dt2)) => dt1.0.date().naive_utc().cmp(&dt2),
(Timestamp::Date(dt1), Timestamp::DateTime(dt2)) => dt1.cmp(&dt2.0.date().naive_utc()),
(Timestamp::Date(dt1), Timestamp::Date(dt2)) => dt1.cmp(dt2),
}
}
}
impl From<DateTimeTz> for Timestamp {
fn from(d: DateTimeTz) -> Self {
Self::DateTime(d)
}
}
impl From<NaiveDate> for Timestamp {
fn from(d: NaiveDate) -> Self {
Self::Date(d)
}
}
/// Any element to be put into the database needs to be Recordable. This is the common API that
/// will aid in searching and later in indexing records.
pub trait Recordable {
/// The timestamp for the record.
fn timestamp(&self) -> DateTimeTz;
fn timestamp(&self) -> Timestamp;
/// A list of string tags that can be used for indexing. This list defined per-type.
fn tags(&self) -> Vec<String>;
@ -127,10 +157,8 @@ mod test {
use self::dimensioned::si::{Kilogram, KG};
use super::*;
use super::{Record, Recordable};
use chrono::TimeZone;
use chrono_tz::Etc::UTC;
use chrono_tz::US::Central;
use chrono_tz::{Etc::UTC, US::Central};
use date_time_tz::DateTimeTz;
#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
@ -138,12 +166,12 @@ mod test {
#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
pub struct WeightRecord {
pub date: DateTimeTz,
pub date: Timestamp,
pub weight: Weight,
}
impl Recordable for WeightRecord {
fn timestamp(&self) -> DateTimeTz {
fn timestamp(&self) -> Timestamp {
self.date.clone()
}
@ -156,7 +184,7 @@ mod test {
fn timestamp_parses_datetimetz_without_timezone() {
assert_eq!(
"2003-11-10T06:00:00Z".parse::<Timestamp>().unwrap(),
Timestamp::DateTimeTz(DateTimeTz(UTC.ymd(2003, 11, 10).and_hms(6, 0, 0))),
Timestamp::DateTime(DateTimeTz(UTC.ymd(2003, 11, 10).and_hms(6, 0, 0))),
);
}
@ -168,10 +196,10 @@ mod test {
);
}
const WEIGHT_ENTRY: &str = "{\"data\":{\"weight\":77.79109,\"date\":\"2003-11-10T06:00:00.000000000000Z\"},\"id\":\"3330c5b0-783f-4919-b2c4-8169c38f65ff\"}";
#[test]
fn legacy_deserialization() {
fn v_alpha_serialization() {
const WEIGHT_ENTRY: &str = "{\"data\":{\"weight\":77.79109,\"date\":\"2003-11-10T06:00:00.000000000000Z\"},\"id\":\"3330c5b0-783f-4919-b2c4-8169c38f65ff\"}";
let rec: Record<WeightRecord> = WEIGHT_ENTRY
.parse()
.expect("should successfully parse the record");
@ -182,7 +210,7 @@ mod test {
assert_eq!(
rec.data,
Some(WeightRecord {
date: DateTimeTz(UTC.ymd(2003, 11, 10).and_hms(6, 0, 0)),
date: Timestamp::DateTime(DateTimeTz(UTC.ymd(2003, 11, 10).and_hms(6, 0, 0))),
weight: Weight(77.79109 * KG),
})
);
@ -191,7 +219,7 @@ mod test {
#[test]
fn serialization_output() {
let rec = WeightRecord {
date: DateTimeTz(UTC.ymd(2003, 11, 10).and_hms(6, 0, 0)),
date: Timestamp::DateTime(DateTimeTz(UTC.ymd(2003, 11, 10).and_hms(6, 0, 0))),
weight: Weight(77.0 * KG),
};
assert_eq!(
@ -200,7 +228,7 @@ mod test {
);
let rec2 = WeightRecord {
date: DateTimeTz(Central.ymd(2003, 11, 10).and_hms(0, 0, 0)),
date: Timestamp::DateTime(Central.ymd(2003, 11, 10).and_hms(0, 0, 0).into()),
weight: Weight(77.0 * KG),
};
assert_eq!(
@ -208,4 +236,25 @@ mod test {
"{\"date\":\"2003-11-10T06:00:00Z US/Central\",\"weight\":77.0}"
);
}
#[test]
fn two_datetimes_can_be_compared() {
let time1 = Timestamp::DateTime(DateTimeTz(UTC.ymd(2003, 11, 10).and_hms(6, 0, 0)));
let time2 = Timestamp::DateTime(DateTimeTz(UTC.ymd(2003, 11, 11).and_hms(6, 0, 0)));
assert!(time1 < time2);
}
#[test]
fn two_dates_can_be_compared() {
let time1 = Timestamp::Date(NaiveDate::from_ymd(2003, 11, 10));
let time2 = Timestamp::Date(NaiveDate::from_ymd(2003, 11, 11));
assert!(time1 < time2);
}
#[test]
fn datetime_and_date_can_be_compared() {
let time1 = Timestamp::DateTime(DateTimeTz(UTC.ymd(2003, 11, 10).and_hms(6, 0, 0)));
let time2 = Timestamp::Date(NaiveDate::from_ymd(2003, 11, 11));
assert!(time1 < time2)
}
}

42
emseries/tests/test_io.rs
View File

@ -41,8 +41,8 @@ mod test {
}
impl Recordable for BikeTrip {
fn timestamp(&self) -> DateTimeTz {
self.datetime.clone()
fn timestamp(&self) -> Timestamp {
self.datetime.clone().into()
}
fn tags(&self) -> Vec<String> {
Vec::new()
@ -122,7 +122,7 @@ mod test {
Some(tr) => {
assert_eq!(
tr.timestamp(),
DateTimeTz(UTC.ymd(2011, 10, 29).and_hms(0, 0, 0))
DateTimeTz(UTC.ymd(2011, 10, 29).and_hms(0, 0, 0)).into()
);
assert_eq!(tr.duration, Duration(11040.0 * S));
assert_eq!(tr.comments, String::from("long time ago"));
@ -144,9 +144,9 @@ mod test {
}
let v: Vec<(&UniqueId, &BikeTrip)> = ts
.search(exact_time(DateTimeTz(
UTC.ymd(2011, 10, 31).and_hms(0, 0, 0),
)))
.search(exact_time(
DateTimeTz(UTC.ymd(2011, 10, 31).and_hms(0, 0, 0)).into(),
))
.collect();
assert_eq!(v.len(), 1);
assert_eq!(*v[0].1, trips[1]);
@ -166,9 +166,9 @@ mod test {
let v: Vec<(&UniqueId, &BikeTrip)> = ts.search_sorted(
time_range(
DateTimeTz(UTC.ymd(2011, 10, 31).and_hms(0, 0, 0)),
DateTimeTz(UTC.ymd(2011, 10, 31).and_hms(0, 0, 0)).into(),
true,
DateTimeTz(UTC.ymd(2011, 11, 04).and_hms(0, 0, 0)),
DateTimeTz(UTC.ymd(2011, 11, 04).and_hms(0, 0, 0)).into(),
true,
),
|l, r| l.1.timestamp().cmp(&r.1.timestamp()),
@ -199,9 +199,9 @@ mod test {
.expect("expect the time series to open correctly");
let v: Vec<(&UniqueId, &BikeTrip)> = ts.search_sorted(
time_range(
DateTimeTz(UTC.ymd(2011, 10, 31).and_hms(0, 0, 0)),
DateTimeTz(UTC.ymd(2011, 10, 31).and_hms(0, 0, 0)).into(),
true,
DateTimeTz(UTC.ymd(2011, 11, 04).and_hms(0, 0, 0)),
DateTimeTz(UTC.ymd(2011, 11, 04).and_hms(0, 0, 0)).into(),
true,
),
|l, r| l.1.timestamp().cmp(&r.1.timestamp()),
@ -233,9 +233,9 @@ mod test {
.expect("expect the time series to open correctly");
let v: Vec<(&UniqueId, &BikeTrip)> = ts.search_sorted(
time_range(
DateTimeTz(UTC.ymd(2011, 10, 31).and_hms(0, 0, 0)),
DateTimeTz(UTC.ymd(2011, 10, 31).and_hms(0, 0, 0)).into(),
true,
DateTimeTz(UTC.ymd(2011, 11, 04).and_hms(0, 0, 0)),
DateTimeTz(UTC.ymd(2011, 11, 04).and_hms(0, 0, 0)).into(),
true,
),
|l, r| l.1.timestamp().cmp(&r.1.timestamp()),
@ -252,9 +252,9 @@ mod test {
.expect("expect the time series to open correctly");
let v: Vec<(&UniqueId, &BikeTrip)> = ts.search_sorted(
time_range(
DateTimeTz(UTC.ymd(2011, 10, 31).and_hms(0, 0, 0)),
DateTimeTz(UTC.ymd(2011, 10, 31).and_hms(0, 0, 0)).into(),
true,
DateTimeTz(UTC.ymd(2011, 11, 05).and_hms(0, 0, 0)),
DateTimeTz(UTC.ymd(2011, 11, 05).and_hms(0, 0, 0)).into(),
true,
),
|l, r| l.1.timestamp().cmp(&r.1.timestamp()),
@ -334,9 +334,9 @@ mod test {
assert_eq!(trips.len(), 3);
let trips: Vec<(&UniqueId, &BikeTrip)> = ts
.search(exact_time(DateTimeTz(
UTC.ymd(2011, 11, 02).and_hms(0, 0, 0),
)))
.search(exact_time(
DateTimeTz(UTC.ymd(2011, 11, 02).and_hms(0, 0, 0)).into(),
))
.collect();
assert_eq!(trips.len(), 1);
assert_eq!(
@ -382,13 +382,13 @@ mod test {
#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
pub struct WeightRecord {
pub date: DateTimeTz,
pub date: chrono::NaiveDate,
pub weight: Weight,
}
impl Recordable for WeightRecord {
fn timestamp(&self) -> DateTimeTz {
self.date.clone()
fn timestamp(&self) -> Timestamp {
self.date.into()
}
fn tags(&self) -> Vec<String> {
@ -396,6 +396,7 @@ mod test {
}
}
/*
#[test]
pub fn legacy_file_load() {
let ts: Series<WeightRecord> =
@ -410,4 +411,5 @@ mod test {
Some(rec) => assert_eq!(rec.weight, Weight(77.79109 * KG)),
}
}
*/
}