/// <summary>
/// Create a <see cref="SqlStatement"/> that contains all the needed information to execute the query
/// as an INNER JOIN of any one of the other queries that uses it as a principal query
/// IMPORTANT: Calling this method will keep a permanent cache of some parts of the result, therefore
/// if the arguments need to change after that, a new <see cref="QueryInternal"/> must be created
/// </summary>
private string PrepareStatementAsPrincipal(
Func <Type, string> sources,
SqlStatementVariables vars,
SqlStatementParameters ps,
bool isAncestorExpand,
ArraySegment <string> pathToCollectionProperty,
int userId,
DateTime?userToday)
{
// (1) Prepare the JOIN's clause
JoinTrie joinTrie = PrepareJoin(pathToCollectionProperty);
var joinSql = joinTrie.GetSql(sources, FromSql);
// Compilation context
var today = userToday ?? DateTime.Today;
var now = DateTimeOffset.Now;
var ctx = new QxCompilationContext(joinTrie, sources, vars, ps, today, now, userId);
// (2) Prepare the SELECT clause
SqlSelectClause selectClause = PrepareSelectAsPrincipal(joinTrie, pathToCollectionProperty, isAncestorExpand);
var selectSql = selectClause.ToSql(IsAncestorExpand);
// (3) Prepare the inner join with the principal query (if any)
string principalQuerySql = PreparePrincipalQuerySql(ctx);
// (4) Prepare the WHERE clause
string whereSql = PrepareWhereSql(ctx);
// (5) Prepare the ORDERBY clause
string orderbySql = PrepareOrderBySql(ctx);
// (6) Prepare the OFFSET and FETCH clauses
string offsetFetchSql = PrepareOffsetFetch();
if (string.IsNullOrWhiteSpace(offsetFetchSql))
{
// In a principal query, order by is only added if there is an offset-fetch (usually in the root query)
orderbySql = "";
}
// (7) Finally put together the final SQL statement and return it
string sql = QueryTools.CombineSql(
selectSql: selectSql,
joinSql: joinSql,
principalQuerySql: principalQuerySql,
whereSql: whereSql,
orderbySql: orderbySql,
offsetFetchSql: offsetFetchSql,
groupbySql: null,
havingSql: null,
selectFromTempSql: null
);
// (8) Return the result
return(sql);
}
/// <summary>
/// Create a <see cref="SqlStatement"/> that contains all the needed information to execute the query against a SQL Server database and load and hydrate the entities
/// IMPORTANT: Calling this method will keep a permanent cache of some parts of the result, therefore if the arguments need to change after
/// that, a new <see cref="QueryInternal"/> must be created
/// </summary>
public SqlStatement PrepareStatement(
Func <Type, string> sources,
SqlStatementVariables vars,
SqlStatementParameters ps,
int userId,
DateTime?userToday)
{
// (1) Prepare the JOIN's clause
var joinTrie = PrepareJoin();
var joinSql = joinTrie.GetSql(sources, FromSql);
// Compilation context
var today = userToday ?? DateTime.Today;
var now = DateTimeOffset.Now;
var ctx = new QxCompilationContext(joinTrie, sources, vars, ps, today, now, userId);
// (2) Prepare the SELECT clause
SqlSelectClause selectClause = PrepareSelect(joinTrie);
var selectSql = selectClause.ToSql(IsAncestorExpand);
// (3) Prepare the inner join with the principal query (if any)
string principalQuerySql = PreparePrincipalQuerySql(ctx);
// (4) Prepare the WHERE clause
string whereSql = PrepareWhereSql(ctx);
// (5) Prepare the ORDERBY clause
string orderbySql = PrepareOrderBySql(ctx);
// (6) Prepare the OFFSET and FETCH clauses
string offsetFetchSql = PrepareOffsetFetch();
// (7) Finally put together the final SQL statement and return it
string sql = QueryTools.CombineSql(
selectSql: selectSql,
joinSql: joinSql,
principalQuerySql: principalQuerySql,
whereSql: whereSql,
orderbySql: orderbySql,
offsetFetchSql: offsetFetchSql,
groupbySql: null,
havingSql: null,
selectFromTempSql: null
);
// (8) Return the result
return(new SqlStatement
{
Sql = sql,
ResultDescriptor = ResultDescriptor,
ColumnMap = selectClause.GetColumnMap(),
Query = this,
});
}
// Functionality
/// <summary>
/// Create a <see cref="SqlStatement"/> that contains all the needed information to execute the query against a SQL Server database and load and hydrate the entities
/// IMPORTANT: Calling this method will keep a permanent cache of some parts of the result, therefore if the arguments need to change after
/// that, a new <see cref="QueryInternal"/> must be created
/// </summary>
public SqlStatement PrepareStatement(
Func <Type, string> sources,
SqlStatementParameters ps,
int userId,
DateTime?userToday)
{
// (1) Prepare the JOIN's clause
var joinTree = PrepareJoin();
var joinSql = joinTree.GetSql(sources, FromSql);
// (2) Prepare the SELECT clause
SqlSelectClause selectClause = PrepareSelect(joinTree);
var selectSql = selectClause.ToSql(IsAncestorExpand);
// (3) Prepare the inner join with the principal query (if any)
string principalQuerySql = PreparePrincipalQuery(sources, ps, userId, userToday);
// (4) Prepare the WHERE clause
string whereSql = PrepareWhere(sources, joinTree, ps, userId, userToday);
// (5) Prepare the ORDERBY clause
string orderbySql = PrepareOrderBy(joinTree);
// (6) Prepare the OFFSET and FETCH clauses
string offsetFetchSql = PrepareOffsetFetch();
// (7) Finally put together the final SQL statement and return it
string sql = QueryTools.CombineSql(
selectSql: selectSql,
joinSql: joinSql,
principalQuerySql: principalQuerySql,
whereSql: whereSql,
orderbySql: orderbySql,
offsetFetchSql: offsetFetchSql,
groupbySql: null
);
// (8) Return the result
return(new SqlStatement
{
Sql = sql,
ResultType = ResultType,
ColumnMap = selectClause.GetColumnMap(),
Query = this,
});
}
// Functionality
public string PrepareCountSql(
Func <Type, string> sources,
SqlStatementVariables vars,
SqlStatementParameters ps,
int userId,
DateTime?userToday,
int maxCount)
{
// (1) Prepare the JOIN's clause
var joinTrie = PrepareJoin();
var joinSql = joinTrie.GetSql(sources, FromSql);
// Compilation context
var today = userToday ?? DateTime.Today;
var now = DateTimeOffset.Now;
var ctx = new QxCompilationContext(joinTrie, sources, vars, ps, today, now, userId);
// (2) Prepare the SELECT clause
string selectSql = maxCount > 0 ? $"SELECT TOP {maxCount} [P].*" : "SELECT [P].*";
// (3) Prepare the WHERE clause
string whereSql = PrepareWhereSql(ctx);
// (4) Finally put together the final SQL statement and return it
string sql = QueryTools.CombineSql(
selectSql: selectSql,
joinSql: joinSql,
principalQuerySql: null,
whereSql: whereSql,
orderbySql: null,
offsetFetchSql: null,
groupbySql: null,
havingSql: null,
selectFromTempSql: null
);
sql = $@"SELECT COUNT(*) As [Count] FROM (
{QueryTools.IndentLines(sql)}
) AS [Q]";
return(sql);
}
/// <summary>
/// Implementation of <see cref="IQueryInternal"/>
/// </summary>
public SqlStatement PrepareStatement(
Func <Type, string> sources,
SqlStatementParameters ps,
int userId,
DateTime?userToday)
{
// (1) Prepare the JOIN's clause
var joinTree = PrepareJoin();
var joinSql = joinTree.GetSql(sources, fromSql: null);
// (2) Prepare the SELECT clause
SqlSelectGroupByClause selectClause = PrepareSelect(joinTree);
var selectSql = selectClause.ToSelectSql();
var groupbySql = selectClause.ToGroupBySql();
// (3) Prepare the WHERE clause
string whereSql = PrepareWhere(sources, joinTree, ps, userId, userToday);
// (4) Prepare the ORDERBY clause
string orderbySql = PrepareOrderBy(joinTree);
// (5) Finally put together the final SQL statement and return it
string sql = QueryTools.CombineSql(
selectSql: selectSql,
joinSql: joinSql,
principalQuerySql: null,
whereSql: whereSql,
orderbySql: orderbySql,
offsetFetchSql: null,
groupbySql: groupbySql
);
// (6) Return the result
return(new SqlStatement
{
Sql = sql,
ResultType = ResultType,
ColumnMap = selectClause.GetColumnMap(),
Query = null, // Not used anyways
});
}
public async Task <(List <DynamicRow> result, IEnumerable <TreeDimensionResult> trees)> ToListAsync(CancellationToken cancellation)
{
var queryArgs = await _factory(cancellation);
var conn = queryArgs.Connection;
var sources = queryArgs.Sources;
var userId = queryArgs.UserId;
var userToday = queryArgs.UserToday;
var localizer = queryArgs.Localizer;
var logger = queryArgs.Logger;
// ------------------------ Validation Step
// SELECT Validation
if (_select == null)
{
string message = $"The select argument is required";
throw new InvalidOperationException(message);
}
// Make sure that measures are well formed: every column access is wrapped inside an aggregation function
foreach (var exp in _select)
{
if (exp.ContainsAggregations) // This is a measure
{
// Every column access must descend from an aggregation function
var exposedColumnAccess = exp.UnaggregatedColumnAccesses().FirstOrDefault();
if (exposedColumnAccess != null)
{
throw new QueryException($"Select parameter contains a measure with a column access {exposedColumnAccess} that is not included within an aggregation.");
}
}
}
// ORDER BY Validation
if (_orderby != null)
{
foreach (var exp in _orderby)
{
// Order by cannot be a constant
if (!exp.ContainsAggregations && !exp.ContainsColumnAccesses)
{
throw new QueryException("OrderBy parameter cannot be a constant, every orderby expression must contain either an aggregation or a column access.");
}
}
}
// FILTER Validation
if (_filter != null)
{
var conditionWithAggregation = _filter.Expression.Aggregations().FirstOrDefault();
if (conditionWithAggregation != null)
{
throw new QueryException($"Filter contains a condition with an aggregation function: {conditionWithAggregation}");
}
}
// HAVING Validation
if (_having != null)
{
// Every column access must descend from an aggregation function
var exposedColumnAccess = _having.Expression.UnaggregatedColumnAccesses().FirstOrDefault();
if (exposedColumnAccess != null)
{
throw new QueryException($"Having parameter contains a column access {exposedColumnAccess} that is not included within an aggregation.");
}
}
// ------------------------ Preparation Step
// If all is good Prepare some universal variables and parameters
var vars = new SqlStatementVariables();
var ps = new SqlStatementParameters();
var today = userToday ?? DateTime.Today;
var now = DateTimeOffset.Now;
// ------------------------ Tree Analysis Step
// By convention if A.B.Id AND A.B.ParentId are both in the select expression,
// then this is a tree dimension and we return all the ancestors of A.B,
// What do we select for the ancestors? All non-aggregated expressions in
// the original select that contain column accesses exclusively starting with A.B
var additionalNodeSelects = new List <QueryexColumnAccess>();
var ancestorsStatements = new List <DimensionAncestorsStatement>();
{
// Find all column access atoms that terminate with ParentId, those are the potential tree dimensions
var parentIdSelects = _select
.Where(e => e is QueryexColumnAccess ca && ca.Property == "ParentId")
.Cast <QueryexColumnAccess>();
foreach (var parentIdSelect in parentIdSelects)
{
var pathToTreeEntity = parentIdSelect.Path; // A.B
// Confirm it's a tree dimension
var idSelect = _select.FirstOrDefault(e => e is QueryexColumnAccess ca && ca.Property == "Id" && ca.PathEquals(pathToTreeEntity));
if (idSelect != null)
{
// Prepare the Join Trie
var treeType = TypeDescriptor.Get <T>();
foreach (var step in pathToTreeEntity)
{
treeType = treeType.NavigationProperty(step)?.TypeDescriptor ??
throw new QueryException($"Property {step} does not exist on type {treeType.Name}.");
}
// Create or Get the name of the Node column
string nodeColumnName = NodeColumnName(additionalNodeSelects.Count);
additionalNodeSelects.Add(new QueryexColumnAccess(pathToTreeEntity, "Node")); // Tell the principal query to include this node
// Get all atoms that contain column accesses exclusively starting with A.B
var principalSelectsWithMatchingPrefix = _select
.Where(exp => exp.ColumnAccesses().All(ca => ca.PathStartsWith(pathToTreeEntity)));
// Calculate the target indices
var targetIndices = principalSelectsWithMatchingPrefix
.Select(exp => SelectIndexDictionary[exp]);
// Remove the prefix from all column accesses
var ancestorSelects = principalSelectsWithMatchingPrefix
.Select(exp => exp.Clone(prefixToRemove: pathToTreeEntity));
var allPaths = ancestorSelects.SelectMany(e => e.ColumnAccesses()).Select(e => e.Path);
var joinTrie = JoinTrie.Make(treeType, allPaths);
var joinSql = joinTrie.GetSql(sources, fromSql: null);
// Prepare the Context
var ctx = new QxCompilationContext(joinTrie, sources, vars, ps, today, now, userId);
// Prepare the SQL components
var selectSql = PrepareAncestorSelectSql(ctx, ancestorSelects);
var principalQuerySql = PreparePrincipalQuerySql(nodeColumnName);
// Combine the SQL components
string sql = QueryTools.CombineSql(
selectSql: selectSql,
joinSql: joinSql,
principalQuerySql: principalQuerySql,
whereSql: null,
orderbySql: null,
offsetFetchSql: null,
groupbySql: null,
havingSql: null,
selectFromTempSql: null);
// Get the index of the id select
int idIndex = SelectIndexDictionary[idSelect];
// Create and add the statement object
var statement = new DimensionAncestorsStatement(idIndex, sql, targetIndices);
ancestorsStatements.Add(statement);
}
}
}
// ------------------------ The SQL Generation Step
// (1) Prepare the JOIN's clause
var principalJoinTrie = PreparePrincipalJoin();
var principalJoinSql = principalJoinTrie.GetSql(sources, fromSql: null);
// Compilation context
var principalCtx = new QxCompilationContext(principalJoinTrie, sources, vars, ps, today, now, userId);
// (2) Prepare all the SQL clauses
var(principalSelectSql, principalGroupbySql, principalColumnCount) = PreparePrincipalSelectAndGroupBySql(principalCtx, additionalNodeSelects);
string principalWhereSql = PreparePrincipalWhereSql(principalCtx);
string principalHavingSql = PreparePrincipalHavingSql(principalCtx);
string principalOrderbySql = PreparePrincipalOrderBySql();
string principalSelectFromTempSql = PrepareSelectFromTempSql();
// (3) Put together the final SQL statement and return it
string principalSql = QueryTools.CombineSql(
selectSql: principalSelectSql,
joinSql: principalJoinSql,
principalQuerySql: null,
whereSql: principalWhereSql,
orderbySql: principalOrderbySql,
offsetFetchSql: null,
groupbySql: principalGroupbySql,
havingSql: principalHavingSql,
selectFromTempSql: principalSelectFromTempSql
);
// ------------------------ Execute SQL and return Result
var principalStatement = new SqlDynamicStatement(principalSql, principalColumnCount);
var(result, trees, _) = await EntityLoader.LoadDynamicStatement(
principalStatement : principalStatement,
dimAncestorsStatements : ancestorsStatements,
includeCount : false,
vars : vars,
ps : ps,
conn : conn,
logger : logger,
cancellation : cancellation);
return(result, trees);
}
private async Task <(List <DynamicRow>, int count)> ToListAndCountInnerAsync(bool includeCount, int maxCount, CancellationToken cancellation)
{
var queryArgs = await _factory(cancellation);
var conn = queryArgs.Connection;
var sources = queryArgs.Sources;
var userId = queryArgs.UserId;
var userToday = queryArgs.UserToday;
var localizer = queryArgs.Localizer;
var logger = queryArgs.Logger;
// ------------------------ Validation Step
// SELECT Validation
if (_select == null)
{
string message = $"The select argument is required";
throw new InvalidOperationException(message);
}
// Make sure that measures are well formed: every column access is wrapped inside an aggregation function
foreach (var exp in _select)
{
var aggregation = exp.Aggregations().FirstOrDefault();
if (aggregation != null)
{
throw new QueryException($"Select cannot contain an aggregation function like: {aggregation.Name}");
}
}
// ORDER BY Validation
if (_orderby != null)
{
foreach (var exp in _orderby)
{
// Order by cannot be a constant
if (!exp.ContainsAggregations && !exp.ContainsColumnAccesses)
{
throw new QueryException("OrderBy parameter cannot be a constant, every orderby expression must contain either an aggregation or a column access.");
}
}
}
// FILTER Validation
if (_filter != null)
{
var conditionWithAggregation = _filter.Expression.Aggregations().FirstOrDefault();
if (conditionWithAggregation != null)
{
throw new QueryException($"Filter contains a condition with an aggregation function: {conditionWithAggregation}");
}
}
// ------------------------ Preparation Step
// If all is good Prepare some universal variables and parameters
var vars = new SqlStatementVariables();
var ps = new SqlStatementParameters();
var today = userToday ?? DateTime.Today;
var now = DateTimeOffset.Now;
// ------------------------ The SQL Generation Step
// (1) Prepare the JOIN's clause
var joinTrie = PrepareJoin();
var joinSql = joinTrie.GetSql(sources, fromSql: null);
// Compilation context
var ctx = new QxCompilationContext(joinTrie, sources, vars, ps, today, now, userId);
// (2) Prepare all the SQL clauses
var(selectSql, columnCount) = PrepareSelectSql(ctx);
string whereSql = PrepareWhereSql(ctx);
string orderbySql = PrepareOrderBySql(ctx);
string offsetFetchSql = PrepareOffsetFetch();
// (3) Put together the final SQL statement and return it
string sql = QueryTools.CombineSql(
selectSql: selectSql,
joinSql: joinSql,
principalQuerySql: null,
whereSql: whereSql,
orderbySql: orderbySql,
offsetFetchSql: offsetFetchSql,
groupbySql: null,
havingSql: null,
selectFromTempSql: null
);
// ------------------------ Prepare the Count SQL
if (includeCount)
{
string countSelectSql = maxCount > 0 ? $"SELECT TOP {maxCount} [P].*" : "SELECT [P].*";
string countSql = QueryTools.CombineSql(
selectSql: countSelectSql,
joinSql: joinSql,
principalQuerySql: null,
whereSql: whereSql,
orderbySql: null,
offsetFetchSql: null,
groupbySql: null,
havingSql: null,
selectFromTempSql: null
);
sql = $@"
{sql}
SELECT COUNT(*) As [Count] FROM (
{QueryTools.IndentLines(countSql)}
) AS [Q]";
}
// ------------------------ Execute SQL and return Result
var principalStatement = new SqlDynamicStatement(sql, columnCount);
var(result, _, count) = await EntityLoader.LoadDynamicStatement(
principalStatement : principalStatement,
dimAncestorsStatements : null,
includeCount,
vars : vars,
ps : ps,
conn : conn,
logger : logger,
cancellation : cancellation);
return(result, count);
}