async Task <List <IEntity> > LoadFromDatabase()
{
List <IEntity> result;
if (NeedsTypeResolution())
{
var queries = EntityFinder.FindPossibleTypes(EntityType, mustFind: true)
.Select(t => CloneFor(t))
.Select(q => q.Provider.GetList(q));
result = await queries.SelectManyAsync(x => x).ToList();
}
else
{
result = await Provider.GetList(this).ToList();
}
if (OrderByParts.None())
{
// TODO: If the entity is sortable by a single DB column, then automatically add that to the DB call.
result.Sort();
}
await LoadIncludedAssociations(result);
return(result);
}
/// Adds a LEFT/RIGHT JOIN part of the SQL query as FROM parts, while replacing corresponding FROM parts.
///
/// If a subquery parts aggregator is open, redirects the call to it instead.
public void AddOuterJoinPart(string outerMember, string innerMember)
{
if (_visitingSubQueryExpression)
{
_subQueryExpressionPartsAggregator.AddOuterJoinPart(outerMember, innerMember);
}
else
{
var outerSource = outerMember.Split('.')[0];
var innerSource = innerMember.Split('.')[0];
var groupJoinPart =
$"{outerSource} LEFT OUTER JOIN {innerSource} ON ({outerMember} = {innerMember})";
// We're using the fact that the left source table was already added in AddFromPart
var index = FromParts.IndexOf(outerSource);
FromParts[index] = groupJoinPart;
var groupingPart =
$"(SELECT COUNT(*) FROM {innerSource} AS \"temp_{innerSource.Substring(1)} " +
$"WHERE \"temp_{innerMember.Substring(1)} = {outerMember}) AS";
if (SelectPart.Contains(groupingPart))
{
OrderByParts.Add(outerMember);
OrderByParts.Add(innerMember);
}
}
}
async Task <List <IEntity> > LoadFromDatabase()
{
List <IEntity> result;
if (NeedsTypeResolution())
{
var queries = EntityFinder.FindPossibleTypes(EntityType, mustFind: true)
.Select(t => CloneFor(t))
.Select(q => q.Provider.GetList(q));
result = await queries.SelectManyAsync(x => x).ToList();
}
else
{
result = await Provider.GetList(this).ToList();
}
foreach (var item in result)
{
await Entity.Services.RaiseOnLoaded(item);
}
if (OrderByParts.None() && !SkipAutoSortAttribute.HasAttribute(EntityType))
{
if (EntityType.Implements <ISortable>())
{
result = result.OrderBy(x => (x as ISortable).Order).ToList();
}
else
{
result.Sort();
}
}
await LoadIncludedAssociations(result);
return(result);
}
string GetCacheKey()
{
var r = new StringBuilder();
r.Append(EntityType.GetCachedAssemblyQualifiedName());
r.Append(':');
foreach (var c in Criteria)
{
r.Append(c.ToString());
r.Append('|');
}
if (TakeTop.HasValue)
{
r.Append("|N:" + TakeTop);
}
r.Append(OrderByParts.Select(x => x.ToString()).ToString(",").WithPrefix("|S:"));
return(r.ToString());
}
async Task <List <IEntity> > LoadFromDatabase()
{
List <IEntity> result;
if (NeedsTypeResolution())
{
var queries = ResolveDataProviders().Select(p => p.GetList(this));
result = await queries.SelectManyAsync(x => x).ToList();
}
else
{
result = await Provider.GetList(this).ToList();
}
if (OrderByParts.None())
{
// TODO: If the entity is sortable by a single DB column, then automatically add that to the DB call.
result.Sort();
}
await LoadIncludedAssociations(result);
return(result);
}
public void AddOrderByPart(IEnumerable <string> orderings)
{
OrderByParts.Insert(0, String.Join(", ", orderings));
}
/// <summary>
/// Builds a primary select query
/// </summary>
/// <returns>Query string</returns>
private string BuildSelectQuery()
{
var sb = new StringBuilder();
if (QueryType == N1QlQueryType.Subquery)
{
if (!string.IsNullOrEmpty(PropertyExtractionPart))
{
// Subqueries will always return a list of objects
// But we need to use an ARRAY statement to convert it into an array of a particular property of that object
sb.AppendFormat("ARRAY `ArrayExtent`.{0} FOR `ArrayExtent` IN (", PropertyExtractionPart);
}
else
{
sb.Append('(');
}
}
else if (QueryType == N1QlQueryType.SubqueryAny)
{
sb.AppendFormat("ANY {0} IN (", PropertyExtractionPart);
}
else if (QueryType == N1QlQueryType.SubqueryAll)
{
sb.AppendFormat("EVERY {0} IN (", PropertyExtractionPart);
}
if (!string.IsNullOrWhiteSpace(ExplainPart))
{
sb.Append(ExplainPart);
}
if (!string.IsNullOrEmpty(AggregateFunction))
{
sb.AppendFormat("SELECT {0}({1}{2})",
AggregateFunction,
!string.IsNullOrWhiteSpace(DistinctPart) ? DistinctPart : string.Empty,
SelectPart);
}
else
{
sb.AppendFormat("SELECT {0}{1}",
!string.IsNullOrWhiteSpace(DistinctPart) ? DistinctPart : string.Empty,
SelectPart);
//TODO support multiple select parts: http://localhost:8093/tutorial/content/#5
}
if (!IsBucketSubquery && !string.IsNullOrEmpty(PropertyExtractionPart))
{
sb.AppendFormat(" as {0}", PropertyExtractionPart);
}
if (FromParts.Any())
{
var mainFrom = FromParts.First();
sb.AppendFormat(" FROM {0} as {1}",
mainFrom.Source,
mainFrom.ItemName);
if (!string.IsNullOrEmpty(UseKeysPart))
{
sb.AppendFormat(" USE KEYS {0}", UseKeysPart);
}
foreach (var joinPart in FromParts.Skip(1))
{
sb.AppendFormat(" {0} {1} as {2}",
joinPart.JoinType,
joinPart.Source,
joinPart.ItemName);
if (!string.IsNullOrEmpty(joinPart.OnKeys))
{
sb.AppendFormat(" ON KEYS {0}", joinPart.OnKeys);
}
}
}
ApplyLetParts(sb);
if (WhereParts.Any())
{
sb.AppendFormat(" WHERE {0}", String.Join(" AND ", WhereParts));
}
if ((GroupByParts != null) && GroupByParts.Any())
{
sb.AppendFormat(" GROUP BY {0}", string.Join(", ", GroupByParts));
}
if ((HavingParts != null) && HavingParts.Any())
{
sb.AppendFormat(" HAVING {0}", string.Join(" AND ", HavingParts));
}
if (OrderByParts.Any())
{
sb.AppendFormat(" ORDER BY {0}", String.Join(", ", OrderByParts));
}
if (LimitPart != null)
{
sb.Append(LimitPart);
}
if (LimitPart != null && OffsetPart != null)
{
sb.Append(OffsetPart);
}
if (QueryType == N1QlQueryType.Subquery)
{
if (!string.IsNullOrEmpty(PropertyExtractionPart))
{
sb.Append(") END");
}
else
{
sb.Append(')');
}
}
else if (QueryType == N1QlQueryType.SubqueryAny)
{
sb.Append(") SATISFIES true END");
}
else if (QueryType == N1QlQueryType.SubqueryAll)
{
sb.AppendFormat(") SATISFIES {0} END", WhereAllPart);
}
return(sb.ToString());
}
public void AddOrderByPart(IEnumerable <string> orderings)
{
OrderByParts.Insert(0, SeparatedStringBuilder.Build(", ", orderings));
}
