public async Task <TalkSummary[]> GetTalkSummaries(int page = 1)
{
using (var session = this.store.OpenAsyncSession())
{
var actualPage = Math.Max(0, page - 1);
QueryStatistics stats;
var talks = await session.Query <Talk>()
.Statistics(out stats)
.Customize(x =>
{
x.WaitForNonStaleResults();
})
//this can throw a timeout exception since you are waiting for potentially 30 seconds for the results of a query
.Skip(page * Constants.PageSize)
.Take(Constants.PageSize)
.Select(t =>
new TalkSummary()
{
Id = t.Id,
Headline = t.Headline,
Description = t.Description,
Published = t.Published,
Speaker = t.Speaker,
SpeakerName = RavenQuery.Load <Speaker>(t.Speaker).Name
}).ToListAsync();
return(talks.ToArray());
}
}
public async Task <TalkSummary[]> SearchTalks(string search, int page = 1)
{
using (var session = this.store.OpenAsyncSession())
{
var actualPage = Math.Max(0, page - 1);
var normalizedSearch = search.ToLowerInvariant();
var results = await session.Query <Talk, Talks_Search>()
.Search(t => t.Headline, search, boost: 2)
.Search(t => t.Description, search)
.Skip(actualPage * Constants.PageSize)
.Take(Constants.PageSize)
.Select(t => new TalkSummary()
{
Id = t.Id,
Headline = t.Headline,
Description = t.Description,
Published = t.Published,
Speaker = t.Speaker,
SpeakerName = RavenQuery.Load <Speaker>(t.Speaker).Name
})
.ToListAsync();
return(results.ToArray());
}
}
public void Can_project_on_sub_collection_with_Id_property()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), "users/705-A");
session.Store(new PostComment
{
PostId = "posts/20785-A",
Comments = new List <Comment>
{
new Comment
{
Id = "fcdffb03-ea82-410c-b415-a6d5859a50f8",
OwnerId = "users/705-A",
Text = "test comment",
DatePosted = new DateTime(2019, 3, 4, 7, 26, 29, 45)
}
}
});
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = from x in session.Query <PostComment>()
select new PostCommentsAsPublic
{
Comments = from comment in x.Comments
let owner = RavenQuery.Load <User>(comment.OwnerId)
select new PostCommentAsPublic
{
Id = comment.Id,
Owner = new UserAsReference
{
Id = owner.Id,
}
}
};
RavenTestHelper.AssertEqualRespectingNewLines(
"from PostComments as x select { " +
"Comments : x.Comments.map(function(comment){return {comment:comment,owner:load(comment.OwnerId)};})" +
".map(function(__rvn0){return {Id:id(__rvn0.comment),Owner:{Id:id(__rvn0.owner)}};}) }"
, query.ToString());
var result = query.ToList();
Assert.Equal(1, result.Count);
var commentsList = result[0].Comments.ToList();
Assert.Equal("fcdffb03-ea82-410c-b415-a6d5859a50f8", commentsList[0].Id);
Assert.Equal("users/705-A", commentsList[0].Owner.Id);
}
}
}
public void Can_project_with_two_loads_when_2nd_load_argument_defined_in_let_between_the_loads()
{
using (var store = GetDocumentStore())
{
Setup(store);
using (var session = store.OpenSession())
{
const string organizationParameter = "organizations/1";
var projection =
from membership in session.Query <MembershipIndexEntry, MembershipIndex>()
let userGroups = RavenQuery.Load <UserGroup>(membership.UserGroups)
let organizationId = organizationParameter
let organization = RavenQuery.Load <Organization>(organizationId)
select new Projection
{
Organization = organization.Id
};
Assert.Contains("organization = load(organizationId)", projection.ToString());
var results = projection.ToList();
Assert.Equal(1, results.Count);
Assert.Equal(organizationParameter, results[0].Organization);
}
}
}
public void Can_do_Multipule_Loads_Where_1st_has_Alias_thats_a_Reserved_Word_and_2nd_has_LoadArg_thats_dependent_on_the_1st_Alias()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Employee
{
FirstName = "Jerry"
}, "employees/1-A");
session.Store(new Employee
{
FirstName = "Bob"
}, "employees/2-A");
session.Store(new Company
{
Name = "GD",
EmployeesIds = new List <string>
{
"employees/1-A",
"employees/2-A"
}
}, "companies/1-A");
session.Store(new Order
{
Company = "companies/1-A"
});
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = from o in session.Query <Order>()
let update = session.Load <Company>(o.Company)
let employees = RavenQuery.Load <Employee>(update.EmployeesIds)
select new
{
Company = update.Name,
Employees = employees.Select(e => e.FirstName).ToList()
};
RavenTestHelper.AssertEqualRespectingNewLines(
@"declare function output(o, __alias0) {
var update = __alias0;
var employees = load(update.EmployeesIds);
return { Company : update.Name, Employees : employees.map(function(e){return e.FirstName;}) };
}
from 'Orders' as o load o.Company as __alias0 select output(o, __alias0)", query.ToString());
var result = query.ToList();
Assert.Equal("GD", result[0].Company);
Assert.Equal(2, result[0].Employees.Count);
Assert.Equal("Jerry", result[0].Employees[0]);
Assert.Equal("Bob", result[0].Employees[1]);
}
}
}
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 ShouldReturnLastModifiedInUtc()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User
{
Name = "Grisha"
});
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = from u in session.Query <User>()
select new
{
Name = u.Name,
Metadata = RavenQuery.Metadata(u),
};
var list = query.ToList();
Assert.Equal(1, list.Count);
var lastModifiedFromProjection = list[0].Metadata.GetString(Constants.Documents.Metadata.LastModified);
Assert.EndsWith("Z", lastModifiedFromProjection);
}
}
}
public void CanLoadViaLetAndProjectMember()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Employee
{
FirstName = "Jerry"
}, "employees/1-A");
session.Store(new Order
{
Company = "HR",
Employee = "employees/1-A"
}, "orders/1-A");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = from o in session.Query <Order>()
let employee = RavenQuery.Load <Employee>(o.Employee)
select employee.FirstName;
Assert.Equal("from Orders as o load o.Employee as employee select employee.FirstName", query.ToString());
var employees = query.ToList();
Assert.Equal(1, employees.Count);
Assert.Equal("Jerry", employees[0]);
}
}
}
public void ShouldReturnLastModifiedInUtc()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User
{
Name = "Grisha"
});
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = from u in session.Query <User>()
select new
{
Name = u.Name,
Metadata = RavenQuery.Metadata(u),
LastModified = RavenQuery.LastModified(u),
};
var list = query.ToList();
Assert.Equal(1, list.Count);
var lastModifiedFromProjection = list[0].Metadata.GetString(Constants.Documents.Metadata.LastModified);
Assert.Equal(DateTimeKind.Utc, list[0].LastModified.Kind);
DateTime dateTime = DateTime.ParseExact(lastModifiedFromProjection, "o", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
Assert.Equal(list[0].LastModified, dateTime.ToUniversalTime());
}
}
}
public async Task <ActionResult> Index(Page currentPage, Home currentContent)
{
using (IDocumentSession session = documentStore.OpenSession())
{
var query = from page in session.Query <Home>()
where page.Id == currentPage.Id
let featuresHeading = page.Features.Heading
let features = RavenQuery.Load <Feature>(page.Features.FeatureList.Select(x => x.Id))
let services = RavenQuery.Load <Service>(page.ServicesCarousel.Select(x => x.Id))
let portfolio = RavenQuery.Load <PortfolioItem>(page.PortfolioCarousel.Select(x => x.Id))
let team = RavenQuery.Load <TeamMember>(page.TeamCarousel.Select(x => x.Id))
let hero = session.Load <Hero>(page.Hero.Id)
select new
{
CurrentPage = page,
Hero = hero,
FeaturesHeading = featuresHeading,
Features = features,
Services = services,
Portfolio = portfolio,
Team = team
};
var viewModel = query.FirstOrDefault();
return(View(new HomeViewModel {
CurrentPage = viewModel.CurrentPage,
Hero = viewModel.Hero,
FeaturesHeading = viewModel.FeaturesHeading,
Features = viewModel.Features.ToList(),
Services = viewModel.Services.ToList(),
Team = viewModel.Team.ToList()
}));
}
}
public void CanSelectMetadata_SingleCallExpression()
{
using (var store = GetDocumentStore())
{
const string id = "users/1";
using (var session = store.OpenSession())
{
session.Store(new User(), id);
session.SaveChanges();
}
DateTime?lastModified;
using (var session = store.OpenSession())
{
var user = session.Load <User>(id);
lastModified = session.Advanced.GetLastModifiedFor(user);
}
using (var session = store.OpenSession())
{
var query = session.Query <User>()
.Select(u => RavenQuery.Metadata(u));
var metadata = query.First();
Assert.True(metadata.TryGetValue(Constants.Documents.Metadata.LastModified, out string lm));
DateTime lastModifiedFromProjection = DateTime.ParseExact(lm, "o", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal).ToUniversalTime();
Assert.Equal(lastModified, lastModifiedFromProjection);
}
}
}
public ElfBO[] SearchWithFilters(string search)
{
/*
* I tried to Do multiple term search creatring AbstractIndexCreationTask in RavenAccessor.RavenHelper
* public class ElvesSearch and did not work out as time restriction i went for folloeing method
* var results =
* dac.Query<SearchByQuery.QueryModel,SearchByQuery>()
* .Where(o => o.Query == search)
* .OfType<Elves>(); Thid id not the most effeciant way*/
using (var dac = _ravanStore.CreateConnection().OpenSession())
{
try
{
int number;
var valon = int.TryParse(search, out number);
var value = valon ? number : 0;
var results = dac.Query <Elves>()
.Where(d => d.Name.StartsWith(RavenQuery.Escape(search)) || d.Age.In(value) || d.Naughtiness.In(value) || d.Specialty.In(RavenQuery.Escape(search)))
.ToList();
var elfobject = AutoMapper.Mapper.Map <Elves[], ElfBO[]>(results.ToArray());
return(elfobject);
}
catch (Exception exception)
{
throw exception;
}
}
}
public static IQueryable <UserDisplay> Transform(IQueryable <UserMaster> query)
{
return(from master in query
where master.IsActive.Value
let config = RavenQuery.Load <UserConfig>(master.ConfigId)
select new UserDisplay
{
Id = master.Id,
Name = master.Name,
Email = master.Email,
TenantId = master.TenantId,
TenantName = master.TenantName,
AuthorId = master.AuthorId,
AuthorName = master.AuthorName,
RegionKey = master.RegionKey,
DateModified = master.DateModified,
DateCreated = master.DateCreated,
HasProfile = master.HasProfile,
ProfileId = master.ProfileId,
ProfileThumbUrl = master.ProfileThumbUrl,
ChatCounter = config.ChatCounter,
EmailNotify = config.EmailNotify,
PushNotify = config.PushNotify,
SmsNotify = config.SmsNotify,
CanAuth = master.CanAuth,
CanAdmin = master.CanAdmin,
CanSuperuser = master.CanSuperuser,
IsActive = master.IsActive,
HasPhone = master.HasPhone
});
}
public async Task <TossConversationQueryResult> Handle(TossConversationQuery request, CancellationToken cancellationToken)
{
var currentUser = await mediator.Send(new CurrentUserQuery());
var tossId = _ravenDbIdUtil.GetRavenDbIdFromUrlId <TossEntity>(request.TossId);
var toss = await _session.LoadAsync <TossEntity>(tossId);
IQueryable <TossConversation> queryable = _session.Query <TossConversation>()
.Where(c => c.TossId == tossId);
if (!toss.IsCreator(currentUser))
{
queryable = queryable.Where(c => c.CreatorUserId == currentUser.Id);
}
var items = await(from c in queryable
let u = RavenQuery.Load <ApplicationUser>(c.CreatorUserId)
select new TossConversationQueryResultItem()
{
Id = c.Id,
CreatorUserName = u.UserName,
MessageCount = c.Messages.Count()
}).ToListAsync();
items.ForEach(c => c.Id = _ravenDbIdUtil.GetUrlId(c.Id));
return(new TossConversationQueryResult()
{
Conversations = items,
TossCreatorUserId = toss.UserId
});
}
public object Get(GetActivityRecords getLogs)
{
ActivityLog[] logs;
var documentStore = this.ResolveService <IDocumentStore>();
using (var session = documentStore.OpenSession())
{
logs = (from log in session.Query <ActivityLog>()
let u = RavenQuery.Load <User>(log.UserId)
let s = RavenQuery.Load <User>(log.SubjectUserId ?? log.UserId)
select new ActivityLog
{
Time = log.Time,
Notes = log.Notes,
RemoteIP = log.RemoteIP,
UserAgent = log.UserAgent,
UserId = $"{u.FirstName} {u.LastName}",
SubjectUserId = $"{s.FirstName} {s.LastName}",
Activity = log.Activity,
}).
OrderByDescending(x => x.Time).Take(getLogs.Count ?? int.MaxValue).ToArray();
}
return(logs);
}
public void CanProjectMemberWithFromAlias()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Employee(), "employees/1-A");
session.Store(new Order
{
Employee = "employees/1-A",
ShipTo = new Address
{
City = "Berlin",
Country = "Germany"
}
}, "orders/1-A");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = from o in session.Query <Order>()
let employee = RavenQuery.Load <Employee>(o.Employee)
select o.ShipTo.Country;
Assert.Equal("from Orders as o load o.Employee as employee select o.ShipTo.Country", query.ToString());
var shipToCountries = query.ToList();
Assert.Equal(1, shipToCountries.Count);
Assert.Equal("Germany", shipToCountries[0]);
}
}
}
private static string TransformToEqualValue(WhereEqualsParams whereEqualsParams)
{
if (whereEqualsParams.Value == null)
{
return("[[NULL_VALUE]]");
}
if (whereEqualsParams.Value is bool)
{
return((bool)whereEqualsParams.Value ? "true" : "false");
}
if (whereEqualsParams.Value is DateTime)
{
return(DateTools.DateToString((DateTime)whereEqualsParams.Value, DateTools.Resolution.MILLISECOND));
}
var escaped = RavenQuery.Escape(Convert.ToString(whereEqualsParams.Value, CultureInfo.InvariantCulture),
whereEqualsParams.AllowWildcards && whereEqualsParams.IsAnalyzed);
if (whereEqualsParams.Value is string == false)
{
return(escaped);
}
return(whereEqualsParams.IsAnalyzed ? escaped : String.Concat("[[", escaped, "]]"));
}
public void CanLoadOnStoredField()
{
using (var store = GetDocumentStore())
{
new Index1().Execute(store);
using (var session = store.OpenSession())
{
session.Store(new Company
{
Name = "HR"
});
session.Store(new Order
{
Company = "HR-Order"
}, "orders/1-A");
session.SaveChanges();
}
WaitForIndexing(store);
using (var session = store.OpenSession())
{
var query = from c in session.Query <Index1.Result, Index1>()
let o = RavenQuery.Load <Order>(c.OrderId)
select o;
var order = query.First();
Assert.Equal("HR-Order", order.Company);
}
}
}
private static string TransformToRangeValue(object value)
{
if (value == null)
{
return("[[NULL_VALUE]]");
}
if (value is int)
{
return(NumberUtil.NumberToString((int)value));
}
if (value is long)
{
return(NumberUtil.NumberToString((long)value));
}
if (value is decimal)
{
return(NumberUtil.NumberToString((double)(decimal)value));
}
if (value is double)
{
return(NumberUtil.NumberToString((double)value));
}
if (value is float)
{
return(NumberUtil.NumberToString((float)value));
}
if (value is DateTime)
{
return(DateTools.DateToString((DateTime)value, DateTools.Resolution.MILLISECOND));
}
return(RavenQuery.Escape(value.ToString(), false));
}
public void CanUseSingleOrDefaultInQueries()
{
using (var store = GetDocumentStore())
{
new CarsIndex().Execute(store);
using (var session = store.OpenSession())
{
session.Store(new ModelConfig
{
Id = ModelConfig.DocumentId,
Models = new List <Model>
{
new Model {
ModelId = "Models-1", Name = "Ford"
},
new Model {
ModelId = "Models-2", Name = "Chevy"
},
new Model {
ModelId = "Models-3", Name = "Honda"
}
}
});
session.Store(new Car
{
ModelId = "Models-1",
Name = "Car1"
});
session.Store(new Car
{
ModelId = "Models-2",
Name = "Car2"
});
session.SaveChanges();
}
WaitForIndexing(store);
using (var session = store.OpenSession())
{
var results =
from result in session.Query <Car, CarsIndex>().Where(x => x.Name == "Car1")
let modelConfig = RavenQuery.Load <ModelConfig>("ModelConfig")
let model = modelConfig.Models.SingleOrDefault(x => x.ModelId == result.ModelId)
// let model = modelConfig.Models.FirstOrDefault(x => x.ModelId == result.ModelId) // Changing this to FirstOrDefault works
select new CarOutput
{
CarName = result.Name,
ModelName = model != null ? model.Name : "UNKNOWN_MODEL"
};
var e = Assert.Throws <NotSupportedException>(() => results.ToList());
Assert.Equal("Unable to translate 'SingleOrDefault' to RQL operation because this method is not familiar to the RavenDB query provider.", e.Message);
}
}
}
public void CountersInSelectClauseShouldAffectQueryEtag_CollectionQuery()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), "users/1");
session.CountersFor("users/1").Increment("Downloads", 100);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var counterValue = session.Query <User>().Select(u => RavenQuery.Counter(u, "Downloads")).First();
Assert.Equal(100, counterValue);
}
using (var session = store.OpenSession())
{
session.CountersFor("users/1").Increment("Downloads", 50);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
// should not be served from cache
var counterValue = session.Query <User>().Select(u => RavenQuery.Counter(u, "Downloads")).First();
Assert.Equal(150, counterValue);
}
}
}
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);
}
}
}
private void StoreFactions(List <EDDBFaction> factions)
{
using (var session = DB.Instance.GetSession())
{
List <Faction> localFactions = new List <Faction>();
var batches = Math.Ceiling((double)factions.Count / 15);
for (var i = 0; i < batches; i++)
{
var names = factions.Where(x => !String.IsNullOrEmpty(x.Name))
.Select(y => RavenQuery.Escape(y.Name.ToLower())).Skip(i * 15).Take(15);
var tmpFactions = session.Advanced.DocumentQuery <Faction>("Faction/Query")
.Where("@In<NameExact>:(" + String.Join(",", names) + ")")
.ToList();
localFactions.AddRange(tmpFactions);
}
foreach (var f in factions)
{
var localFaction = localFactions.FirstOrDefault(x => x.Name.Equals(f.Name, StringComparison.CurrentCultureIgnoreCase));
if (localFaction != null && localFaction.EDDB_Id == 0)
{
localFaction.EDDB_Id = f.Id;
}
}
session.SaveChanges();
}
}
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 WhereIn(string fieldName, IEnumerable <object> values)
{
AppendSpaceIfNeeded(queryText.Length > 0 && char.IsWhiteSpace(queryText[queryText.Length - 1]) == false);
NegateIfNeeded();
var whereParams = new WhereParams
{
FieldName = fieldName
};
fieldName = EnsureValidFieldName(whereParams);
var list = UnpackEnumerable(values).ToList();
if (list.Count == 0)
{
queryText.Append("@emptyIn<")
.Append(RavenQuery.EscapeField(fieldName))
.Append(">:(no-results)");
return;
}
queryText.Append("@in<")
.Append(RavenQuery.EscapeField(fieldName))
.Append(">:(");
var first = true;
AddItemToInClause(whereParams, list, first);
queryText.Append(") ");
}
private void WhereEquals(WhereParams whereParams, bool isReversed)
{
var fieldName = EnsureValidFieldName(whereParams, isReversed);
var transformToEqualValue = TransformToEqualValue(whereParams, isReversed);
lastEquality = new KeyValuePair <string, string>(fieldName, transformToEqualValue);
AppendSpaceIfNeeded(queryText.Length > 0 && queryText[queryText.Length - 1] != '(');
NegateIfNeeded();
queryText.Append(RavenQuery.EscapeField(fieldName));
queryText.Append(":");
if (fieldName.EndsWith("_numeric"))
{
queryText.Append("[");
queryText.Append(transformToEqualValue);
queryText.Append(" TO ");
queryText.Append(transformToEqualValue);
queryText.Append("]");
}
else
{
queryText.Append(transformToEqualValue);
}
}
public void CanProject()
{
Document doc;
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
var child1 = new Document
{
Name = "Jerry"
};
var child2 = new Document
{
Name = "Bobby"
};
session.Store(child1);
session.Store(child2);
doc = new Document
{
Name = "parent",
Children = new List <ChildReference>
{
new ChildReference
{
Id = child1.Id
},
new ChildReference
{
Id = child2.Id
}
}
};
session.Store(doc);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var query = from result in session.Query <Document>()
.Customize(x => x.WaitForNonStaleResults())
.Where(x => x.Id == doc.Id)
let children = RavenQuery.Load <Document>(result.Children.Select(x => x.Id))
select new
{
ChildNames = children.Select(x => x.Name).ToList()
};
var docs = query.ToList();
Assert.Equal(1, docs.Count);
Assert.Equal(2, docs[0].ChildNames.Count);
Assert.Equal("Jerry", docs[0].ChildNames[0]);
Assert.Equal("Bobby", docs[0].ChildNames[1]);
}
}
}
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 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]);
}
}
}
private string TransformToRangeValue(WhereParams whereParams)
{
if (whereParams.Value == null)
{
return(Constants.NullValueNotAnalyzed);
}
if (Equals(whereParams.Value, string.Empty))
{
return(Constants.EmptyStringNotAnalyzed);
}
if (whereParams.Value is DateTime)
{
var dateTime = (DateTime)whereParams.Value;
var dateStr = dateTime.GetDefaultRavenFormat(dateTime.Kind == DateTimeKind.Utc);
return(dateStr);
}
if (whereParams.Value is DateTimeOffset)
{
return(((DateTimeOffset)whereParams.Value).UtcDateTime.GetDefaultRavenFormat(true));
}
if (whereParams.Value is TimeSpan)
{
return(NumberUtil.NumberToString(((TimeSpan)whereParams.Value).Ticks));
}
if (whereParams.Value is int)
{
return(NumberUtil.NumberToString((int)whereParams.Value));
}
if (whereParams.Value is long)
{
return(NumberUtil.NumberToString((long)whereParams.Value));
}
if (whereParams.Value is decimal)
{
return(NumberUtil.NumberToString((double)(decimal)whereParams.Value));
}
if (whereParams.Value is double)
{
return(NumberUtil.NumberToString((double)whereParams.Value));
}
if (whereParams.Value is float)
{
return(NumberUtil.NumberToString((float)whereParams.Value));
}
if (whereParams.Value is string)
{
return(RavenQuery.Escape(whereParams.Value.ToString(), false, true));
}
if (whereParams.Value is ValueType)
{
return(RavenQuery.Escape(Convert.ToString(whereParams.Value, CultureInfo.InvariantCulture), false, true));
}
throw new NotSupportedException();
}
