public void TimeSeriesLinqQuery_CanUseStringInterpolationInName()
{
using (var store = GetDocumentStore())
{
var timeSeries = "HeartRate";
using (var session = store.OpenSession())
{
session.Store(new User(), DocId);
session.TimeSeriesFor(DocId, timeSeries).Append(DateTime.Now, 2);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var q = session.Query <User>()
.Where(u => u.Id == DocId)
.Select(u => RavenQuery.TimeSeries(u, $"'{timeSeries}'").ToList());
var result = q.First();
Assert.Equal(1, result.Count);
Assert.Equal(2, result.Results[0].Value);
}
}
}
public void CanUseDynamicGrouping_WithFunc()
{
using (var store = GetDocumentStore())
{
var baseline = DateTime.Today;
using (var session = store.OpenSession())
{
session.Store(new User
{
Name = "Jerry",
LastName = "Garcia"
}, "users/1");
var tsf = session.TimeSeriesFor("users/1", "HeartRate");
tsf.Append(baseline.AddMinutes(61), new[] { 59d }, "watches/fitbit");
tsf.Append(baseline.AddMinutes(62), new[] { 79d }, "watches/fitbit");
tsf.Append(baseline.AddMinutes(63), new[] { 69d }, "watches/fitbit");
tsf.Append(baseline.AddMonths(1).AddMinutes(61), new[] { 159d }, "watches/fitbit");
tsf.Append(baseline.AddMonths(1).AddMinutes(62), new[] { 179d }, "watches/fitbit");
tsf.Append(baseline.AddMonths(1).AddMinutes(63), new[] { 169d }, "watches/fitbit");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var grouping = GroupingInterval.Month; // This could vary based on client input
Action <ITimePeriodBuilder> action = builder => Func(builder, grouping);
var query = session.Query <User>()
.Select(u => RavenQuery.TimeSeries(u, "Heartrate")
.GroupBy(action)
.Select(g => new
{
Avg = g.Average(),
Max = g.Max()
})
.ToList());
var result = query.ToList();
Assert.Equal(1, result.Count);
Assert.Equal(6, result[0].Count);
var agg = result[0].Results;
Assert.Equal(2, agg.Length);
Assert.Equal(79, agg[0].Max[0]);
Assert.Equal(69, agg[0].Average[0]);
Assert.Equal(179, agg[1].Max[0]);
Assert.Equal(169, agg[1].Average[0]);
}
}
}
public void TimeSeriesLinqQuery_CanUseSimpleCallExpressionInGroupBy()
{
using (var store = GetDocumentStore())
{
var timeSeries = "HeartRate";
using (var session = store.OpenSession())
{
session.Store(new User(), DocId);
session.TimeSeriesFor(DocId, timeSeries).Append(DateTime.Now, 2);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var days = 1;
var q = session.Query <User>()
.Where(u => u.Id == DocId)
.Select(u => RavenQuery.TimeSeries(u, timeSeries)
.GroupBy(GetGroupBy(days))
.ToList());
var result = q.First();
Assert.Equal(1, result.Count);
Assert.Equal(2, result.Results[0].Min[0]);
}
}
}
public void Examples()
{
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
#region RQL_Query
var query = session.Advanced.RawQuery <TimeSeriesAggregationResult>(@"
from People
select timeseries(
from HeartRates
group by 1 second
with interpolation(linear)
");
#endregion
}
using (var session = store.OpenSession())
{
#region LINQ_Query
var query = session.Query <People>()
.Select(p => RavenQuery.TimeSeries(p, "HeartRates")
.GroupBy(g => g
.Hours(1)
.WithOptions(new TimeSeriesAggregationOptions
{
Interpolation = InterpolationType.Linear
}))
.ToList());
#endregion
}
}
}
public void CanGroupByDocument()
{
using (var store = GetDocumentStore())
{
var baseline = PopulateCanGroupByLoadedTag(store);
using (var session = store.OpenSession())
{
var query = session.Query <TimeSeriesLinqQuery.Person>()
.Select(u => RavenQuery.TimeSeries(u, "Heartrate", baseline.EnsureUtc(), baseline.AddMonths(2).EnsureUtc())
.GroupBy(g => g
.Months(1)
.ByTag <TimeSeriesLinqQuery.Watch>(w => w)
)
.Select(g => new { Average = g.Average(), Max = g.Max() })
.ToList());
var result = query.First();
Assert.Equal(6, result.Count);
var agg = result.Results;
Assert.Equal(5, agg.Length);
var monthBaseline = new DateTime(baseline.Year, baseline.Month, 1);
var val1 = agg[0];
Assert.Equal("watches/fitbit", val1.Key);
Assert.Equal(monthBaseline, val1.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(monthBaseline.AddMonths(1), val1.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(2, val1.Count[0]);
var val2 = agg[1];
Assert.Equal("watches/apple", val2.Key);
Assert.Equal(monthBaseline, val2.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(monthBaseline.AddMonths(1), val2.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(1, val2.Count[0]);
var val3 = agg[2];
Assert.Equal("watches/apple", val3.Key);
Assert.Equal(monthBaseline.AddMonths(1), val3.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(monthBaseline.AddMonths(2), val3.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(1, val3.Count[0]);
var val4 = agg[3];
Assert.Equal("watches/sony", val4.Key);
Assert.Equal(monthBaseline.AddMonths(1), val4.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(monthBaseline.AddMonths(2), val4.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(1, val4.Count[0]);
var val5 = agg[4];
Assert.Equal("watches/fitbit", val5.Key);
Assert.Equal(monthBaseline.AddMonths(1), val5.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(monthBaseline.AddMonths(2), val5.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(1, val5.Count[0]);
}
}
}
public void CanQueryTimeSeriesAggregation_UsingLinq()
{
using (var store = GetDocumentStore())
{
var baseline = RavenTestHelper.UtcToday;
using (var session = store.OpenSession())
{
session.Store(new User
{
Name = "Oren",
Age = 35
}, "users/ayende");
var tsf = session.TimeSeriesFor("users/ayende", "HeartRate");
tsf.Append(baseline.AddMinutes(61), new[] { 59d }, "watches/fitbit");
tsf.Append(baseline.AddMinutes(62), new[] { 79d }, "watches/fitbit");
tsf.Append(baseline.AddMinutes(63), new[] { 69d }, "watches/fitbit");
tsf.Append(baseline.AddMonths(1).AddMinutes(61), new[] { 159d }, "watches/fitbit");
tsf.Append(baseline.AddMonths(1).AddMinutes(62), new[] { 179d }, "watches/fitbit");
tsf.Append(baseline.AddMonths(1).AddMinutes(63), new[] { 169d }, "watches/fitbit");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = session.Query <User>()
.Where(u => u.Age > 21)
.Select(u => RavenQuery.TimeSeries <HeartRateMeasure>(u, "Heartrate")
.Where(ts => ts.Tag == "watches/fitbit")
.GroupBy("1 month")
.Select(g => new
{
Avg = g.Average(),
Sum = g.Sum(),
Max = g.Max()
}).ToList()
);
var result = query.ToList();
Assert.Equal(1, result.Count);
Assert.Equal(6, result[0].Count);
var agg = result[0].Results;
Assert.Equal(2, agg.Length);
Assert.Equal(79, agg[0].Max.HeartRate);
Assert.Equal(207, agg[0].Sum.HeartRate);
Assert.Equal(69, agg[0].Average.HeartRate);
Assert.Equal(179, agg[1].Max.HeartRate);
Assert.Equal(507, agg[1].Sum.HeartRate);
Assert.Equal(169, agg[1].Average.HeartRate);
}
}
}
public async Task TimeSeriesLinqQuery_CanUseSimpleCallExpressionInName()
{
using (var store = GetDocumentStore())
{
var timeSeries = "HeartRate";
var retention = TimeValue.FromHours(48);
var p = new TimeSeriesPolicy("ByHour", TimeValue.FromHours(1), TimeValue.FromHours(24));
var config = new TimeSeriesConfiguration
{
Collections = new Dictionary <string, TimeSeriesCollectionConfiguration>
{
["Users"] = new TimeSeriesCollectionConfiguration
{
RawPolicy = new RawTimeSeriesPolicy(TimeValue.FromHours(96)),
Policies = new List <TimeSeriesPolicy> {
p
}
}
}
};
await store.Maintenance.SendAsync(new ConfigureTimeSeriesOperation(config));
var baseline = DateTime.UtcNow.Add(-retention * 2);
using (var session = store.OpenSession())
{
session.Store(new User(), DocId);
var timeSeriesFor = session.TimeSeriesFor(DocId, timeSeries);
for (int i = 0; i < 100; i++)
{
timeSeriesFor.Append(baseline.AddHours(i), 29 * i, "watches/fitbit");
}
session.SaveChanges();
}
var database = await Databases.GetDocumentDatabaseInstanceFor(store);
await TimeSeries.WaitForPolicyRunnerAsync(database);
using (var session = store.OpenSession())
{
// todo aviv : remove the single quotes from name when RavenDB-15792 is fixed
var q = session.Query <User>()
.Where(u => u.Id == DocId)
.Select(u => RavenQuery.TimeSeries(u, $"'{p.GetTimeSeriesName(timeSeries)}'")
.ToList());
var result = q.First();
Assert.Equal(24, result.Count);
}
}
}
public void CanUseDynamicGrouping_WithFuncAndLoadedTag()
{
using (var store = GetDocumentStore())
{
var baseline = TimeSeriesGroupByTag.PopulateCanGroupByLoadedTag(store);
using (var session = store.OpenSession())
{
var interval = GroupingInterval.Month;
var query = session.Query <TimeSeriesLinqQuery.Person>()
.Select(u => RavenQuery.TimeSeries(u, "Heartrate", baseline.EnsureUtc(), baseline.AddMonths(2).EnsureUtc())
.GroupBy(g => Func(g, interval)
.ByTag <TimeSeriesLinqQuery.Watch>(w => w.Accuracy))
.Select(g => new
{
Average = g.Average(),
Max = g.Max()
})
.ToList());
var result = query.First();
Assert.Equal(6, result.Count);
var agg = result.Results;
Assert.Equal(3, agg.Length);
var monthBaseline = new DateTime(baseline.Year, baseline.Month, 1);
var val1 = agg[0];
Assert.Equal(10.0m, val1.Key);
Assert.Equal(monthBaseline, val1.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(monthBaseline.AddMonths(1), val1.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(3, val1.Count[0]);
var val2 = agg[1];
Assert.Equal(10.0m, val2.Key);
Assert.Equal(monthBaseline.AddMonths(1), val2.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(monthBaseline.AddMonths(2), val2.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(2, val2.Count[0]);
var val3 = agg[2];
Assert.Equal(5.0m, val3.Key);
Assert.Equal(monthBaseline.AddMonths(1), val3.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(monthBaseline.AddMonths(2), val3.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(1, val3.Count[0]);
}
}
}
public void CanQueryTimeSeriesRaw_UsingLinq()
{
using (var store = GetDocumentStore())
{
var baseline = RavenTestHelper.UtcToday;
using (var session = store.OpenSession())
{
session.Store(new User
{
Age = 25
}, "people/1");
var tsf = session.TimeSeriesFor("people/1", "Heartrate");
tsf.Append(baseline.AddMinutes(61), new[] { 59d }, "watches/fitbit");
tsf.Append(baseline.AddMinutes(62), new[] { 79d }, "watches/apple");
tsf.Append(baseline.AddMinutes(63), new[] { 69d }, "watches/fitbit");
tsf.Append(baseline.AddMonths(1).AddMinutes(61), new[] { 159d }, "watches/apple");
tsf.Append(baseline.AddMonths(1).AddMinutes(62), new[] { 179d }, "watches/sony");
tsf.Append(baseline.AddMonths(1).AddMinutes(63), new[] { 169d }, "watches/fitbit");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = session.Query <User>()
.Where(p => p.Age > 21)
.Select(p => RavenQuery.TimeSeries <HeartRateMeasure>(p, "Heartrate", baseline, baseline.AddMonths(2))
.Where(ts => ts.Values[0] > 75 && ts.Values[0] < 175)
.ToList());
var result = query.First();
Assert.Equal(3, result.Count);
var timeSeriesValues = result.Results;
Assert.Equal(79, timeSeriesValues[0].Value.HeartRate);
Assert.Equal(baseline.AddMinutes(62), timeSeriesValues[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(159, timeSeriesValues[1].Value.HeartRate);
Assert.Equal(baseline.AddMonths(1).AddMinutes(61), timeSeriesValues[1].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(169, timeSeriesValues[2].Value.HeartRate);
Assert.Equal(baseline.AddMonths(1).AddMinutes(63), timeSeriesValues[2].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
}
}
}
public void CanUseDynamicGrouping()
{
using var store = GetDocumentStore();
store.TimeSeries.Register <MobaroLocation, DispatchEntry>(DispatchEntryDefinition.Name);
PopulateData(store);
var grouping = GroupingInterval.Month; // This could vary based on client input
using var session = store.OpenSession();
var groupingAction = grouping switch
{
GroupingInterval.Year => (Action <ITimePeriodBuilder>)(builder => builder.Years(1)),
GroupingInterval.Month => (Action <ITimePeriodBuilder>)(builder => builder.Months(1)),
GroupingInterval.Day => (Action <ITimePeriodBuilder>)(builder => builder.Days(1)),
GroupingInterval.Hour => (Action <ITimePeriodBuilder>)(builder => builder.Hours(1)),
_ => throw new ArgumentOutOfRangeException()
};
var locations = session.Query <MobaroLocation>()
.Select(location => new {
DispatchEntries = RavenQuery
.TimeSeries <DispatchEntry>(DispatchEntryDefinition.Name)
.GroupBy(groupingAction)
.Select(x => new {
Sum = x.Sum(),
Count = x.Count()
})
.ToList(),
LocationId = location.Id,
LocationName = location.Name
})
.ToList();
var firstLocation = locations.First();
var firstTimeSeriesGrouping = firstLocation.DispatchEntries.Results.First();
Assert.Equal(expected: "locations/1", actual: firstLocation.LocationId);
Assert.Equal(expected: 35, actual: firstTimeSeriesGrouping.Sum.Riders);
Assert.Equal(expected: 5, actual: firstTimeSeriesGrouping.Sum.Dispatches);
Assert.Equal(expected: 2, actual: firstTimeSeriesGrouping.Count.Riders);
Assert.Equal(expected: 2, actual: firstTimeSeriesGrouping.Count.Dispatches);
}
public void RavenDB15732_3()
{
using (var store = GetDocumentStore())
{
var baseline = new DateTime(2019, 12, 24).EnsureUtc();
var id = "companies/1";
var total = TimeSpan.FromDays(15).TotalHours;
using (var session = store.OpenSession())
{
session.Store(new Company
{
Name = "HR",
}, id);
var tsf = session.TimeSeriesFor(id, "StockPrices");
for (int i = 0; i <= total; i++)
{
tsf.Append(baseline.AddHours(i), i);
}
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var q = session.Query <Company>()
.Where(c => c.Id == id)
.Select(c => RavenQuery.TimeSeries(c, "StockPrices")
.GroupBy(g => g.Days(7))
.Select(x => x.Average())
.ToList());
var result = q.First();
var expected = new DateTime(2019, 12, 23).EnsureUtc();
Assert.Equal(expected, result.Results[0].From);
Assert.Equal(DayOfWeek.Monday, result.Results[0].From.DayOfWeek);
}
}
}
public void CanGroupByLoadedTagWithTagFilter()
{
using (var store = GetDocumentStore())
{
var baseline = PopulateCanGroupByLoadedTag(store);
using (var session = store.OpenSession())
{
var query = session.Query <TimeSeriesLinqQuery.Person>()
.Select(u => RavenQuery.TimeSeries(u, "Heartrate", baseline.EnsureUtc(), baseline.AddMonths(2).EnsureUtc())
.LoadByTag <TimeSeriesLinqQuery.Watch>().Where((entry, watch) => watch.Manufacturer != "Sony")
.GroupBy(g => g
.Months(1)
.ByTag <TimeSeriesLinqQuery.Watch>(w => w.Accuracy)
)
.Select(g => new { Average = g.Average(), Max = g.Max() })
.ToList());
var result = query.First();
Assert.Equal(5, result.Count);
var agg = result.Results;
Assert.Equal(2, agg.Length);
var monthBaseline = new DateTime(baseline.Year, baseline.Month, 1);
var val1 = agg[0];
Assert.Equal(10.0m, val1.Key);
Assert.Equal(monthBaseline, val1.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(monthBaseline.AddMonths(1), val1.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(3, val1.Count[0]);
var val2 = agg[1];
Assert.Equal(10.0m, val2.Key);
Assert.Equal(monthBaseline.AddMonths(1), val2.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(monthBaseline.AddMonths(2), val2.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(2, val2.Count[0]);
}
}
}
public void TimeSeriesLinqQuery_CanUseWrappedConstantVariableInGroupBy()
{
const string documentId = "users/ayende";
using (var store = GetDocumentStore())
{
var baseline = RavenTestHelper.UtcToday.AddHours(2);
var total = TimeSpan.FromDays(10).TotalHours;
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
var tsf = session.TimeSeriesFor(documentId, "HeartRate");
for (int i = 0; i < total; i++)
{
tsf.Append(baseline.AddHours(i), i);
}
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var groupBy = "Days";
var groupByUnit = $"1 {groupBy.ToLowerInvariant()}";
var query = session.Query <User>()
.Select(x => RavenQuery.TimeSeries(x, "HeartRate")
.GroupBy(groupByUnit)
.ToList());
var result = query.First();
Assert.Equal(total, result.Count);
Assert.Equal(11, result.Results.Length);
}
}
}
public void CanQueryTimeSeriesWithSpacesInName2()
{
const string documentId = "users/ayende";
using (var store = GetDocumentStore())
{
var baseline = RavenTestHelper.UtcToday;
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
var tsf = session.TimeSeriesFor(documentId, "gas m3 usage");
tsf.Append(baseline, 1);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = session.Query <User>()
.Select(x => RavenQuery.TimeSeries(x, "'gas m3 usage'")
.GroupBy(g => g.Days(1))
.Select(g => new
{
Min = g.Min(),
Max = g.Max()
})
.ToList());
var result = query.First();
Assert.Equal(1, result.Count);
}
}
}
public void CanGetNonExistedRange()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), "users/ayende");
session.SaveChanges();
}
var baseline = DateTime.Today;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation {
Tag = "watches/fitbit", Timestamp = baseline.AddSeconds(1), Values = new[] { 59d }
});
var timeSeriesBatch = new TimeSeriesBatchOperation("users/ayende", timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
var timeSeriesRangeResult = store.Operations.Send(
new GetTimeSeriesOperation("users/ayende", "Heartrate", baseline.AddMonths(-2), baseline.AddMonths(-1)));
Assert.Empty(timeSeriesRangeResult.Entries);
using (var session = store.OpenSession())
{
var query = session.Query <User>().Select(u => RavenQuery.TimeSeries(u, "Heartrate", baseline.AddMonths(-2), baseline.AddMonths(-1)).ToList()).ToList();
Assert.Equal(0, query[0].Results.Length);
}
}
}
public void CanSelectAverageWithInterpolationInTimeSeriesQuery()
{
using (var store = GetDocumentStore())
{
var baseline = DateTime.Today.EnsureUtc();
var id = "people/1";
using (var session = store.OpenSession())
{
session.Store(new Person {
Name = "Oren",
}, id);
var tsf = session.TimeSeriesFor(id, "HeartRate");
tsf.Append(baseline, 0);
tsf.Append(baseline.AddMinutes(1), 1);
tsf.Append(baseline.AddMinutes(2), 2);
tsf.Append(baseline.AddMinutes(3), 3);
tsf.Append(baseline.AddMinutes(4), 4);
tsf.Append(baseline.AddMinutes(5), 5);
tsf.Append(baseline.AddMinutes(6), 6);
tsf.Append(baseline.AddMinutes(7), 7);
tsf.Append(baseline.AddMinutes(8), 8);
tsf.Append(baseline.AddMinutes(9), 9);
tsf.Append(baseline.AddMinutes(20), 20);
tsf.Append(baseline.AddMinutes(21), 21);
tsf.Append(baseline.AddMinutes(22), 22);
tsf.Append(baseline.AddMinutes(23), 23);
tsf.Append(baseline.AddMinutes(24), 24);
tsf.Append(baseline.AddMinutes(25), 25);
tsf.Append(baseline.AddMinutes(26), 26);
tsf.Append(baseline.AddMinutes(27), 27);
tsf.Append(baseline.AddMinutes(28), 28);
tsf.Append(baseline.AddMinutes(29), 29);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = session.Query <Person>()
.Select(p => RavenQuery.TimeSeries(p, "HeartRate")
.GroupBy(g => g
.Minutes(10)
.WithOptions(new TimeSeriesAggregationOptions
{
Interpolation = InterpolationType.Linear
}))
.Select(x => new
{
Sum = x.Sum(),
Avg = x.Average()
})
.ToList());
var result = query.First();
Assert.Equal(3, result.Results.Length);
var range = result.Results[0]; // 00:00-00:10
Assert.Equal(10, range.Count[0]);
Assert.Equal(45, range.Sum[0]);
Assert.Equal(4.5, range.Average[0]);
range = result.Results[2]; // 00:20-00:30
Assert.Equal(10, range.Count[0]);
Assert.Equal(245, range.Sum[0]);
Assert.Equal(24.5, range.Average[0]);
//gap : 00:10-00:20
range = result.Results[1];
Assert.Equal(10, range.Count[0]);
Assert.Equal(145, range.Sum[0]);
var expectedAvg = (24.5 + 4.5) / 2;
Assert.Equal(expectedAvg, range.Average[0]);
}
}
}
private void Examples()
{
using (var store = new DocumentStore
{
Urls = new[] { "http://*****:*****@"
from Employees as e
select timeseries(
from e.HeartRate
select percentile(90)
)
");
#endregion
}
using (var session = store.OpenSession())
{
#region LINQ_percentile
var query = session.Query <Employee>()
.Select(p => RavenQuery.TimeSeries(p, "HeartRates")
.Select(x => new
{
P = x.Percentile(90)
}
)
);
#endregion
}
using (var session = store.OpenSession())
{
#region RQL_slope
var query = session.Advanced.RawQuery <TimeSeriesAggregationResult>(@"
from Employees as e
select timeseries(
from e.HeartRates
group by 1 hour
select slope()
)
");
#endregion
}
using (var session = store.OpenSession())
{
#region LINQ_slope
var query = session.Query <Employee>()
.Select(p => RavenQuery.TimeSeries(p, "HeartRates")
.GroupBy(g => g.Hours(1))
.Select(x => new
{
Slope = x.Slope()
}
)
);
#endregion
}
using (var session = store.OpenSession())
{
#region RQL_stddev
//Example query with defined range
var date = DateTime.Today;
var query = session.Advanced.RawQuery <TimeSeriesAggregationResult>(@"
from Employees as e
select timeseries(
from e.HeartRates
between $start and $end
select stddev()
)
")
.AddParameter("start", date)
.AddParameter("end", date.AddDays(1));
#endregion
}
using (var session = store.OpenSession())
{
#region LINQ_stddev
//Example query with defined range
var date = DateTime.Today;
var query = session.Query <Employee>()
.Select(p => RavenQuery.TimeSeries(p, "HeartRates", date, date.AddDays(1))
.Select(x => new
{
StdDev = x.StandardDeviation()
}
)
);
#endregion
}
}
}
public void CanFillGaps_SeveralValuesPerBucket_Linq()
{
using (var store = GetDocumentStore())
{
var baseline = RavenTestHelper.UtcToday;
string id = "people/1";
using (var session = store.OpenSession())
{
session.Store(new Person(), id);
var tsf = session.TimeSeriesFor(id, "HeartRate");
tsf.Append(baseline, 0);
tsf.Append(baseline.AddMinutes(10), 1);
tsf.Append(baseline.AddMinutes(30), 3);
tsf.Append(baseline.AddMinutes(50), 5);
tsf.Append(baseline.AddMinutes(60), 6);
tsf.Append(baseline.AddMinutes(90), 9);
tsf.Append(baseline.AddMinutes(110), 11);
tsf.Append(baseline.AddMinutes(190), 19);
tsf.Append(baseline.AddMinutes(230), 23);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = session.Query <Person>()
.Where(p => p.Id == id)
.Select(p => RavenQuery.TimeSeries(p, "HeartRate", baseline, baseline.AddDays(1))
.GroupBy(g => g
.Hours(1)
.WithOptions(new TimeSeriesAggregationOptions
{
Interpolation = InterpolationType.Linear
}))
.Select(x => x.Max())
.ToList());
var result = query.First();
Assert.Equal(4, result.Results.Length);
var tsAgg = result.Results[0];
Assert.Equal(baseline, tsAgg.From);
Assert.Equal(baseline.AddHours(1), tsAgg.To);
Assert.Equal(5, tsAgg.Max[0]);
tsAgg = result.Results[1];
Assert.Equal(baseline.AddHours(1), tsAgg.From);
Assert.Equal(baseline.AddHours(2), tsAgg.To);
Assert.Equal(11, tsAgg.Max[0]);
tsAgg = result.Results[2];
Assert.Equal(baseline.AddHours(2), tsAgg.From);
Assert.Equal(baseline.AddHours(3), tsAgg.To);
var expected = (11 + 23) / 2;
Assert.Equal(expected, tsAgg.Max[0]);
tsAgg = result.Results[3];
Assert.Equal(baseline.AddHours(3), tsAgg.From);
Assert.Equal(baseline.AddHours(4), tsAgg.To);
Assert.Equal(23, tsAgg.Max[0]);
}
}
}
public void CanFillGaps_NextRangeValue_Linq()
{
using (var store = GetDocumentStore())
{
var baseline = RavenTestHelper.UtcToday;
string id = "people/1";
using (var session = store.OpenSession())
{
session.Store(new Person(), id);
var tsf = session.TimeSeriesFor(id, "HeartRate");
tsf.Append(baseline, 0);
for (int i = 1; i <= 10; i++)
{
if (i.In(2, 3, 4, 7, 8, 9))
{
continue;
}
tsf.Append(baseline.AddMinutes(i), i * 2.5);
}
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = session.Query <Person>()
.Where(p => p.Id == id)
.Select(p => RavenQuery.TimeSeries(p, "HeartRate", baseline, baseline.AddDays(1))
.GroupBy(g => g
.Minutes(1)
.WithOptions(new TimeSeriesAggregationOptions
{
Interpolation = InterpolationType.Next
}))
.Select(x => x.Max())
.ToList());
var result = query.First();
Assert.Equal(11, result.Results.Length);
for (var index = 0; index < result.Results.Length; index++)
{
var tsAggregation = result.Results[index];
Assert.Equal(baseline.AddMinutes(index), tsAggregation.From);
Assert.Equal(baseline.AddMinutes(index + 1), tsAggregation.To);
if (index.In(2, 7))
{
// should be the same as next range
Assert.Equal((index + 3) * 2.5, tsAggregation.Max[0]);
continue;
}
if (index.In(3, 8))
{
// should be the same as next range
Assert.Equal((index + 2) * 2.5, tsAggregation.Max[0]);
continue;
}
if (index.In(4, 9))
{
// should be the same as next range
Assert.Equal((index + 1) * 2.5, tsAggregation.Max[0]);
continue;
}
Assert.Equal(index * 2.5, tsAggregation.Max[0]);
}
}
}
}
public void CanUseDynamicGrouping_WithTagAndInterpolation()
{
using (var store = GetDocumentStore())
{
var baseline = TimeSeriesGroupByTag.PopulateCanGroupByTagWithInterpolation(store);
using (var session = store.OpenSession())
{
var grouping = GroupingInterval.Hour; // This could vary based on client input
var query = session.Query <TimeSeriesLinqQuery.Person>()
.Select(u => RavenQuery.TimeSeries(u, "Heartrate", baseline.EnsureUtc(), baseline.AddMonths(2).EnsureUtc())
.GroupBy(g => Func2(g, grouping, InterpolationType.Linear, true))
.Select(g => new
{
Max = g.Max(),
Average = g.Average(),
})
.ToList());
var result = query.First();
Assert.Equal(32 * 3, result.Count);
var agg = result.Results;
Assert.Equal(32 * 3, agg.Length);
var groups = agg.GroupBy(x => x.Key);
foreach (var group in groups)
{
var key = group.Key;
var value = group.OrderBy(x => x.From).ToArray();
Assert.Equal(32, value.Length);
for (int i = 0; i < value.Length; i++)
{
var val = value[i];
switch (key)
{
case "watches/fitbit":
Assert.Equal(i * 10, val.Average[0]);
break;
case "watches/apple":
Assert.Equal(i * 100, val.Average[0]);
break;
case "watches/sony":
Assert.Equal(i * 1000, val.Average[0]);
break;
default:
throw new ArgumentException();
}
Assert.Equal(baseline.AddHours(i), val.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddHours(i + 1), val.To, RavenTestHelper.DateTimeComparer.Instance);
}
}
}
}
}
public async Task CanWorkWithRollupTimeSeries2()
{
using (var store = GetDocumentStore())
{
var raw = new RawTimeSeriesPolicy(TimeSpan.FromHours(24));
var p1 = new TimeSeriesPolicy("By6Hours", TimeSpan.FromHours(6), raw.RetentionTime * 4);
var p2 = new TimeSeriesPolicy("By1Day", TimeSpan.FromDays(1), raw.RetentionTime * 5);
var p3 = new TimeSeriesPolicy("By30Minutes", TimeSpan.FromMinutes(30), raw.RetentionTime * 2);
var p4 = new TimeSeriesPolicy("By1Hour", TimeSpan.FromMinutes(60), raw.RetentionTime * 3);
var config = new TimeSeriesConfiguration
{
Collections = new Dictionary <string, TimeSeriesCollectionConfiguration>
{
["Users"] = new TimeSeriesCollectionConfiguration
{
RawPolicy = raw,
Policies = new List <TimeSeriesPolicy>
{
p1, p2, p3, p4
}
},
},
PolicyCheckFrequency = TimeSpan.FromSeconds(1)
};
await store.Maintenance.SendAsync(new ConfigureTimeSeriesOperation(config));
await store.TimeSeries.RegisterAsync <User, StockPrice>();
var database = await Databases.GetDocumentDatabaseInstanceFor(store);
var now = DateTime.UtcNow;
var baseline = now.AddDays(-12);
var total = TimeSpan.FromDays(12).TotalMinutes;
using (var session = store.OpenSession())
{
session.Store(new User {
Name = "Karmel"
}, "users/karmel");
var ts = session.TimeSeriesFor <StockPrice>("users/karmel");
var entry = new StockPrice();
for (int i = 0; i <= total; i++)
{
entry.Open = i;
entry.Close = i + 100_000;
entry.High = i + 200_000;
entry.Low = i + 300_000;
entry.Volume = i + 400_000;
ts.Append(baseline.AddMinutes(i), entry, "watches/fitbit");
}
session.SaveChanges();
}
await database.TimeSeriesPolicyRunner.RunRollups();
await database.TimeSeriesPolicyRunner.DoRetention();
await TimeSeries.VerifyPolicyExecutionAsync(store, config.Collections["Users"], 12, rawName: "StockPrices");
using (var session = store.OpenSession())
{
var query = session.Query <User>()
.Select(u =>
RavenQuery.TimeSeries <StockPrice>(u, "StockPrices").Select(x =>
new {
First = x.First(),
Last = x.Last(),
Min = x.Min(),
Max = x.Max(),
Sum = x.Sum(),
Count = x.Count(),
Avg = x.Average()
})
.ToList());
var result = query.Single();
Assert.Equal(1, result.Results.Length);
var r = result.Results[0];
Assert.NotNull(r.First);
Assert.NotNull(r.Last);
Assert.NotNull(r.Min);
Assert.NotNull(r.Max);
Assert.NotNull(r.Sum);
Assert.NotNull(r.Count);
Assert.NotNull(r.Average);
}
using (var session = store.OpenSession())
{
var query = session.Query <User>()
.Select(u =>
RavenQuery.TimeSeries <StockPrice>(u, "StockPrices")
.GroupBy(x => x.Hours(3))
.Select(x =>
new
{
First = x.First(),
Last = x.Last(),
Min = x.Min(),
Max = x.Max(),
Sum = x.Sum(),
Count = x.Count(),
Avg = x.Average()
})
.ToList());
var result = query.Single();
var r = result.Results[0];
Assert.NotNull(r.First);
Assert.NotNull(r.Last);
Assert.NotNull(r.Min);
Assert.NotNull(r.Max);
Assert.NotNull(r.Sum);
Assert.NotNull(r.Count);
Assert.NotNull(r.Average);
}
using (var session = store.OpenSession())
{
var ts1 = session.TimeSeriesRollupFor <StockPrice>("users/karmel", p1.Name);
var r = ts1.Get().First();
Assert.NotNull(r.First);
Assert.NotNull(r.Last);
Assert.NotNull(r.Min);
Assert.NotNull(r.Max);
Assert.NotNull(r.Sum);
Assert.NotNull(r.Count);
Assert.NotNull(r.Average);
}
}
}
public async Task CanWorkWithRollupTimeSeries()
{
using (var store = GetDocumentStore())
{
var raw = new RawTimeSeriesPolicy(TimeSpan.FromHours(24));
var p1 = new TimeSeriesPolicy("By6Hours", TimeSpan.FromHours(6), raw.RetentionTime * 4);
var p2 = new TimeSeriesPolicy("By1Day", TimeSpan.FromDays(1), raw.RetentionTime * 5);
var p3 = new TimeSeriesPolicy("By30Minutes", TimeSpan.FromMinutes(30), raw.RetentionTime * 2);
var p4 = new TimeSeriesPolicy("By1Hour", TimeSpan.FromMinutes(60), raw.RetentionTime * 3);
var config = new TimeSeriesConfiguration
{
Collections = new Dictionary <string, TimeSeriesCollectionConfiguration>
{
["Users"] = new TimeSeriesCollectionConfiguration
{
RawPolicy = raw,
Policies = new List <TimeSeriesPolicy>
{
p1, p2, p3, p4
}
},
},
PolicyCheckFrequency = TimeSpan.FromSeconds(1)
};
await store.Maintenance.SendAsync(new ConfigureTimeSeriesOperation(config));
await store.TimeSeries.RegisterAsync <User, StockPrice>();
var database = await Databases.GetDocumentDatabaseInstanceFor(store);
var now = DateTime.UtcNow;
var nowMinutes = now.Minute;
now = now.AddMinutes(-nowMinutes);
database.Time.UtcDateTime = () => DateTime.UtcNow.AddMinutes(-nowMinutes);
var baseline = now.AddDays(-12);
var total = TimeSpan.FromDays(12).TotalMinutes;
using (var session = store.OpenSession())
{
session.Store(new User {
Name = "Karmel"
}, "users/karmel");
var ts = session.TimeSeriesFor <StockPrice>("users/karmel");
var entry = new StockPrice();
for (int i = 0; i <= total; i++)
{
entry.Open = i;
entry.Close = i + 100_000;
entry.High = i + 200_000;
entry.Low = i + 300_000;
entry.Volume = i + 400_000;
ts.Append(baseline.AddMinutes(i), entry, "watches/fitbit");
}
session.SaveChanges();
}
await database.TimeSeriesPolicyRunner.RunRollups();
await database.TimeSeriesPolicyRunner.DoRetention();
await TimeSeries.VerifyPolicyExecutionAsync(store, config.Collections["Users"], 12, rawName: "StockPrices");
using (var session = store.OpenSession())
{
var query = session.Advanced.RawQuery <TimeSeriesRawResult <StockPrice> >(@"
declare timeseries out()
{
from StockPrices
between $start and $end
}
from Users as u
select out()
")
.AddParameter("start", baseline.AddDays(-1))
.AddParameter("end", now.AddDays(1));
var result = query.Single();
var count = result.Results.Length;
Assert.Equal(5, result.Results[count - 1440].Values.Length);
foreach (var res in result.Results)
{
Assert.Equal(5, res.Values.Length);
}
}
using (var session = store.OpenSession())
{
// test the same query using linq
var query = session.Query <User>()
.Select(u =>
RavenQuery.TimeSeries <StockPrice>(u, "StockPrices", baseline.AddDays(-1), now.AddDays(1))
.ToList());
var result = query.Single();
var count = result.Results.Length;
Assert.Equal(5, result.Results[count - 1440].Values.Length);
foreach (var res in result.Results)
{
Assert.Equal(5, res.Values.Length);
}
}
now = DateTime.UtcNow;
using (var session = store.OpenSession())
{
var ts = session.TimeSeriesRollupFor <StockPrice>("users/karmel", p1.Name);
var a = new TimeSeriesRollupEntry <StockPrice>(DateTime.Now)
{
Max = new StockPrice
{
Close = 1
}
};
ts.Append(a);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var ts = session.TimeSeriesRollupFor <StockPrice>("users/karmel", p1.Name);
var res = ts.Get(from: now.AddMilliseconds(-1)).ToList();
Assert.Equal(1, res.Count);
Assert.Equal(1, res[0].Max.Close);
}
}
}
public void CanFillGaps_DifferentNumberOfValues_Linq()
{
using (var store = GetDocumentStore())
{
var baseline = RavenTestHelper.UtcToday;
string id = "people/1";
using (var session = store.OpenSession())
{
session.Store(new Person(), id);
var tsf = session.TimeSeriesFor(id, "HeartRate");
tsf.Append(baseline, 0);
tsf.Append(baseline.AddDays(1), 1);
tsf.Append(baseline.AddDays(30), new[] { 30d, 60 });
tsf.Append(baseline.AddDays(60), new[] { 60d, 120, 180 });
tsf.Append(baseline.AddDays(90), 90);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = session.Query <Person>()
.Where(p => p.Id == id)
.Select(p => RavenQuery.TimeSeries(p, "HeartRate", baseline, baseline.AddYears(1))
.GroupBy(g => g
.Days(1)
.WithOptions(new TimeSeriesAggregationOptions
{
Interpolation = InterpolationType.Linear
}))
.Select(x => x.Max())
.ToList());
var result = query.First();
Assert.Equal(91, result.Results.Length);
for (int i = 0; i < 30; i++)
{
var tsAgg = result.Results[i];
Assert.Equal(1, tsAgg.Max.Length);
}
for (int i = 30; i < 60; i++)
{
var tsAgg = result.Results[i];
Assert.Equal(2, tsAgg.Max.Length);
}
Assert.Equal(3, result.Results[60].Max.Length);
for (int i = 61; i < result.Results.Length; i++)
{
var tsAgg = result.Results[i];
Assert.Equal(1, tsAgg.Max.Length);
}
}
}
}
public void CanGroupByMilliseconds()
{
using (var store = GetDocumentStore())
{
var documentId = "users/ayende";
var baseline = DateTime.Today.EnsureUtc();
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
var tsf = session.TimeSeriesFor(documentId, "HeartRate");
for (int i = 0; i < TimeSpan.FromSeconds(1).TotalMilliseconds; i++)
{
tsf.Append(baseline.AddMilliseconds(i), i);
}
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var result = session.Query <User>()
.Where(u => u.Id == documentId)
.Select(u => RavenQuery.TimeSeries(u, "HeartRate", baseline, baseline.AddSeconds(1))
.GroupBy(g => g.Milliseconds(500))
.Select(x => x.Max())
.ToList())
.First();
Assert.Equal(TimeSpan.FromSeconds(1).TotalMilliseconds, result.Count);
Assert.Equal(2, result.Results.Length);
var rangeAggregation = result.Results[0];
Assert.Equal(500, rangeAggregation.Count[0]);
Assert.Equal(499, rangeAggregation.Max[0]);
Assert.Equal(baseline, rangeAggregation.From);
Assert.Equal(baseline.AddMilliseconds(500), rangeAggregation.To);
rangeAggregation = result.Results[1];
Assert.Equal(500, rangeAggregation.Count[0]);
Assert.Equal(999, rangeAggregation.Max[0]);
Assert.Equal(baseline.AddMilliseconds(500), rangeAggregation.From);
Assert.Equal(baseline.AddSeconds(1), rangeAggregation.To);
}
using (var session = store.OpenSession())
{
var result = session.Advanced.RawQuery <TimeSeriesAggregationResult>(@"
from Users
where id() = $id
select timeseries(
from HeartRate
between $start and $end
group by 100 milliseconds
select max()
)")
.AddParameter("id", documentId)
.AddParameter("start", baseline)
.AddParameter("end", baseline.AddMinutes(1))
.First();
Assert.Equal(TimeSpan.FromSeconds(1).TotalMilliseconds, result.Count);
Assert.Equal(10, result.Results.Length);
foreach (var rangeAggregation in result.Results)
{
Assert.Equal(100, rangeAggregation.Count[0]);
}
}
}
}
public void TimeSeriesSelectShouldAffectQueryEtag()
{
using (var store = GetDocumentStore())
{
var baseline = DateTime.Today;
using (var session = store.OpenSession())
{
session.Store(new Person
{
Name = "ayende"
}, "people/1");
var tsf = session.TimeSeriesFor("people/1", "Heartrate");
tsf.Append(baseline.AddMinutes(61), new[] { 59d }, "watches/fitbit");
tsf.Append(baseline.AddMinutes(62), new[] { 79d }, "watches/apple");
tsf.Append(baseline.AddMinutes(63), new[] { 69d }, "watches/fitbit");
tsf.Append(baseline.AddMonths(1).AddMinutes(61), new[] { 159d }, "watches/apple");
tsf.Append(baseline.AddMonths(1).AddMinutes(62), new[] { 179d }, "watches/fitbit");
tsf.Append(baseline.AddMonths(1).AddMinutes(63), new[] { 169d }, "watches/fitbit");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = session.Query <Person>()
.Select(p => new
{
p.Id,
p.Name,
HeartRate = RavenQuery.TimeSeries(p, "Heartrate")
.Where(ts => ts.Tag == "watches/fitbit")
.GroupBy(g => g.Months(1))
.Select(g => new
{
Max = g.Max(),
Count = g.Count()
})
.ToList()
});
var result = query.First();
Assert.Equal("ayende", result.Name);
Assert.Equal("people/1", result.Id);
Assert.Equal(4, result.HeartRate.Count);
var aggregation = result.HeartRate.Results;
Assert.Equal(2, aggregation.Length);
Assert.Equal(69, aggregation[0].Max[0]);
Assert.Equal(2, aggregation[0].Count[0]);
Assert.Equal(179, aggregation[1].Max[0]);
Assert.Equal(2, aggregation[1].Count[0]);
}
using (var session = store.OpenSession())
{
var tsf = session.TimeSeriesFor("people/1", "Heartrate");
tsf.Append(baseline.AddMinutes(64), 89, "watches/fitbit");
tsf.Append(baseline.AddMinutes(65), 99, "watches/apple");
tsf.Append(baseline.AddMonths(1).AddMinutes(64), 189, "watches/fitbit");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
// re run the query
// result should not be served from cache
var query = session.Query <Person>()
.Select(p => new
{
p.Id,
p.Name,
HeartRate = RavenQuery.TimeSeries(p, "Heartrate")
.Where(ts => ts.Tag == "watches/fitbit")
.GroupBy(g => g.Months(1))
.Select(g => new
{
Max = g.Max(),
Count = g.Count()
})
.ToList()
});
var result = query.First();
Assert.Equal("ayende", result.Name);
Assert.Equal("people/1", result.Id);
Assert.Equal(6, result.HeartRate.Count);
var aggregation = result.HeartRate.Results;
Assert.Equal(2, aggregation.Length);
Assert.Equal(89, aggregation[0].Max[0]);
Assert.Equal(3, aggregation[0].Count[0]);
Assert.Equal(189, aggregation[1].Max[0]);
Assert.Equal(3, aggregation[1].Count[0]);
}
}
}
public void CanStreamGroupByTagWithInterpolation()
{
using (var store = GetDocumentStore())
{
var baseline = PopulateCanGroupByTagWithInterpolation(store);
using (var session = store.OpenSession())
{
var query = session.Query <TimeSeriesLinqQuery.Person>()
.Select(u => RavenQuery.TimeSeries(u, "Heartrate", baseline.EnsureUtc(), baseline.AddMonths(2).EnsureUtc())
.GroupBy(g => g
.Hours(1)
.ByTag()
.WithOptions(new TimeSeriesAggregationOptions
{
Interpolation = InterpolationType.Linear
}))
.Select(g => new
{
Max = g.Max(),
Average = g.Average(),
})
.ToList());
var dic = new Dictionary <string, List <TimeSeriesRangeAggregation> >();
using (var docStream = session.Advanced.Stream(query))
{
while (docStream.MoveNext())
{
using (var entryStream = docStream.Current.Result.Stream)
{
while (entryStream.MoveNext())
{
var current = entryStream.Current;
dic.TryAdd(current.Key.ToString(), new List <TimeSeriesRangeAggregation>());
dic[current.Key.ToString()].Add(current);
}
}
}
}
Assert.Equal(3, dic.Count);
foreach (var group in dic)
{
var key = group.Key;
var value = group.Value.OrderBy(x => x.From).ToArray();
Assert.Equal(32, value.Length);
for (int i = 0; i < value.Length; i++)
{
var val = value[i];
switch (key)
{
case "watches/fitbit":
Assert.Equal(i * 10, val.Average[0]);
break;
case "watches/apple":
Assert.Equal(i * 100, val.Average[0]);
break;
case "watches/sony":
Assert.Equal(i * 1000, val.Average[0]);
break;
default:
throw new ArgumentException();
}
Assert.Equal(baseline.AddHours(i), val.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddHours(i + 1), val.To, RavenTestHelper.DateTimeComparer.Instance);
}
}
}
}
}
public void CanGroupByTagWithInterpolationLinq()
{
using (var store = GetDocumentStore())
{
var baseline = PopulateCanGroupByTagWithInterpolation(store);
using (var session = store.OpenSession())
{
var query = session.Query <TimeSeriesLinqQuery.Person>()
.Select(u => RavenQuery.TimeSeries(u, "Heartrate", baseline.EnsureUtc(), baseline.AddMonths(2).EnsureUtc())
// .LoadByTag<TimeSeriesLinqQuery.Watch>().Where((entry, watch) => true)
.GroupBy(g => g
.Hours(1)
.ByTag()
.WithOptions(new TimeSeriesAggregationOptions
{
Interpolation = InterpolationType.Linear
}))
.Select(g => new
{
Max = g.Max(),
Average = g.Average(),
})
.ToList());
var result = query.First();
Assert.Equal(32 * 3, result.Count);
var agg = result.Results;
Assert.Equal(32 * 3, agg.Length);
var groups = agg.GroupBy(x => x.Key);
foreach (var group in groups)
{
var key = group.Key;
var value = group.OrderBy(x => x.From).ToArray();
Assert.Equal(32, value.Length);
for (int i = 0; i < value.Length; i++)
{
var val = value[i];
switch (key)
{
case "watches/fitbit":
Assert.Equal(i * 10, val.Average[0]);
break;
case "watches/apple":
Assert.Equal(i * 100, val.Average[0]);
break;
case "watches/sony":
Assert.Equal(i * 1000, val.Average[0]);
break;
default:
throw new ArgumentException();
}
Assert.Equal(baseline.AddHours(i), val.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddHours(i + 1), val.To, RavenTestHelper.DateTimeComparer.Instance);
}
}
}
}
}
public void CanFillGaps_LinearInterpolation_Linq()
{
using (var store = GetDocumentStore())
{
var baseline = RavenTestHelper.UtcToday;
string id = "people/1";
using (var session = store.OpenSession())
{
session.Store(new Person(), id);
var tsf = session.TimeSeriesFor(id, "HeartRate");
tsf.Append(baseline, 50);
tsf.Append(baseline.AddHours(1), 60);
tsf.Append(baseline.AddHours(4), 90);
tsf.Append(baseline.AddHours(5), 100);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = session.Query <Person>()
.Where(p => p.Id == id)
.Select(p => RavenQuery.TimeSeries(p, "HeartRate", baseline, baseline.AddDays(1))
.GroupBy(g => g
.Hours(1)
.WithOptions(new TimeSeriesAggregationOptions
{
Interpolation = InterpolationType.Linear
}))
.Select(x => x.Max())
.ToList());
var result = query.First();
Assert.Equal(6, result.Results.Length);
var aggResult = result.Results[0];
Assert.Equal(baseline, aggResult.From);
Assert.Equal(baseline.AddHours(1), aggResult.To);
Assert.Equal(50, aggResult.Max[0]);
aggResult = result.Results[1];
Assert.Equal(baseline.AddHours(1), aggResult.From);
Assert.Equal(baseline.AddHours(2), aggResult.To);
Assert.Equal(60, aggResult.Max[0]);
aggResult = result.Results[2];
Assert.Equal(baseline.AddHours(2), aggResult.From);
Assert.Equal(baseline.AddHours(3), aggResult.To);
Assert.Equal(70, aggResult.Max[0]);
aggResult = result.Results[3];
Assert.Equal(baseline.AddHours(3), aggResult.From);
Assert.Equal(baseline.AddHours(4), aggResult.To);
Assert.Equal(80, aggResult.Max[0]);
aggResult = result.Results[4];
Assert.Equal(baseline.AddHours(4), aggResult.From);
Assert.Equal(baseline.AddHours(5), aggResult.To);
Assert.Equal(90, aggResult.Max[0]);
aggResult = result.Results[5];
Assert.Equal(baseline.AddHours(5), aggResult.From);
Assert.Equal(baseline.AddHours(6), aggResult.To);
Assert.Equal(100, aggResult.Max[0]);
}
}
}
public void CanGroupByTagLinq()
{
using (var store = GetDocumentStore())
{
var baseline = RavenTestHelper.UtcToday;
using (var session = store.OpenSession())
{
session.Store(new User {
Name = "Oren"
}, "users/ayende");
var tsf = session.TimeSeriesFor("users/ayende", "Heartrate");
tsf.Append(baseline.AddMinutes(61), new[] { 59d }, "watches/fitbit");
tsf.Append(baseline.AddMinutes(62), new[] { 79d }, "watches/fitbit");
tsf.Append(baseline.AddMinutes(63), new[] { 69d }, "watches/apple");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = session.Query <User>()
.Select(u => RavenQuery.TimeSeries(u, "Heartrate", baseline.EnsureUtc(), baseline.AddDays(1).EnsureUtc())
.GroupBy(g => g
.Hours(1)
.ByTag()
)
.Select(g => new
{
First = g.First(),
Max = g.Max(),
Min = g.Min(),
Last = g.Last(),
})
.ToList());
var agg = query.First();
Assert.Equal(3, agg.Count);
Assert.Equal(2, agg.Results.Length);
var val1 = agg.Results[0];
Assert.Equal(59, val1.First[0]);
Assert.Equal(59, val1.Min[0]);
Assert.Equal(79, val1.Last[0]);
Assert.Equal(79, val1.Max[0]);
Assert.Equal(baseline.AddMinutes(60), val1.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(120), val1.To, RavenTestHelper.DateTimeComparer.Instance);
var val2 = agg.Results[1];
Assert.Equal(69, val2.First[0]);
Assert.Equal(69, val2.Min[0]);
Assert.Equal(69, val2.Last[0]);
Assert.Equal(69, val2.Max[0]);
Assert.Equal(baseline.AddMinutes(60), val2.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(120), val2.To, RavenTestHelper.DateTimeComparer.Instance);
}
}
}
public void GroupByOneMinuteShouldHaveNoGaps()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), "zzz/1");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var d = new DateTime(1980, 1, 1);
var r = new Random();
var previous = 0.0;
for (var i = 0; i < 1000; i++)
{
var nextDouble = previous * 0.9 + 0.1 * r.NextDouble();
session.TimeSeriesFor("zzz/1", "small")
.Append(d, nextDouble);
d = d.AddMinutes(1);
previous = nextDouble;
}
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var result = session.Query <User>()
.Select(u => new
{
HeartRate = RavenQuery.TimeSeries("small")
.GroupBy(g => g.Minutes(1))
.Select(x => new
{
Max = x.Max(),
Min = x.Min(),
Average = x.Average()
})
.ToList()
})
.First();
Assert.Equal(1000, result.HeartRate.Count);
DateTime lastTo = default;
foreach (var rangeAggregation in result.HeartRate.Results)
{
Assert.Equal(1, rangeAggregation.Count[0]);
if (lastTo != default)
{
var currentFrom = rangeAggregation.From;
Assert.Equal(lastTo, currentFrom);
}
lastTo = rangeAggregation.To;
}
}
}
}
