/// <summary>
/// Prepares the ORDER BY clause of the SQL query using the <see cref="Select"/> argument: ORDER BY ABC
/// </summary>
private string PrepareOrderBy(JoinTree joinTree)
{
var orderByAtoms = Select.Where(e => !string.IsNullOrEmpty(e.OrderDirection));
var orderByAtomsCount = orderByAtoms.Count();
if (orderByAtomsCount == 0)
{
return("");
}
List <string> orderbys = new List <string>(orderByAtomsCount);
foreach (var atom in orderByAtoms)
{
var join = joinTree[atom.Path];
if (join == null)
{
// Developer mistake
throw new InvalidOperationException($"The path '{string.Join('/', atom.Path)}' was not found in the joinTree");
}
var symbol = join.Symbol;
string orderby = QueryTools.AtomSql(symbol, atom.Property, atom.Aggregation, atom.Modifier) + $" {atom.OrderDirection.ToUpper()}";
orderbys.Add(orderby);
}
string orderbySql = ""; // "ORDER BY Id DESC"; // Default order by
if (orderbys.Count > 0)
{
orderbySql = "ORDER BY " + string.Join(", ", orderbys);
}
return(orderbySql);
}
/// <summary>
/// Parses a string representing a single filter atom (no ANDs, ORs or NOTs) into an <see cref="FilterAtom"/>
/// </summary>
/// <param name="atom">String representing a simple logical expression (should not contain ANDs, ORs or NOTs)</param>
public new static FilterAtom Parse(string atom)
{
if (string.IsNullOrWhiteSpace(atom))
{
throw new ArgumentNullException(nameof(atom));
}
var pieces = atom.Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (pieces.Length < 3)
{
throw new InvalidOperationException($"One of the atomic expressions ({atom}) does not have the valid form: 'Path op Value'");
}
else
{
// (A) Parse the member access path (e.g. "Address/Street")
var(path, property, modifier) = QueryTools.ExtractPathPropertyAndModifier(pieces[0]);
// (B) Parse the value (e.g. "'Huntington Rd.'")
var value = string.Join(" ", pieces.Skip(2));
// (C) parse the operator (e.g. "eq")
var op = pieces[1];
return(new FilterAtom
{
Path = path,
Property = property,
Modifier = modifier,
Op = op,
Value = value
});
}
}
/// <summary>
/// If this query has a principal query, this method returns the SQL of the principal query in the form of an
/// INNER JOIN to restrict the result to those entities that are related to the principal query
/// </summary>
private string PreparePrincipalQuerySql(QxCompilationContext ctx)
{
string principalQuerySql = "";
if (PrincipalQuery != null)
{
// Get the inner sql and append 4 spaces before each line for aesthetics
string innerSql = PrincipalQuery.PrepareStatementAsPrincipal(
ctx.Sources,
ctx.Variables,
ctx.Parameters,
IsAncestorExpand,
PathToCollectionPropertyInPrincipal,
ctx.UserId,
ctx.Today);
innerSql = QueryTools.IndentLines(innerSql);
if (IsAncestorExpand)
{
principalQuerySql = $@"INNER JOIN (
{innerSql}
) As [S] ON [S].[Node].IsDescendantOf([P].[Node]) = 1 AND [S].[Node] <> [P].[Node]";
}
else
{
// This works since when there is a principal query, there is no WHERE clause
principalQuerySql = $@"WHERE [P].[{ForeignKeyToPrincipalQuery}] IN (
{innerSql}
)";
}
}
return(principalQuerySql);
}
/// <summary>
/// Parses a string representing a single orderby atom (no commas) into an <see cref="OrderByAtom"/>
/// </summary>
/// <param name="atom">String representing a single orderby atom (should not contain commas)</param>
public static OrderByAtom Parse(string atom)
{
// item comes in the general formats:
// - "Order/Customer/Name desc"
// - "Customer/DateOfBirth"
if (string.IsNullOrWhiteSpace(atom))
{
throw new ArgumentNullException(nameof(atom));
}
atom = atom.Trim();
// Extract desc
bool desc = false;
if (atom.ToLower().EndsWith("desc"))
{
desc = true;
atom = atom.Substring(0, atom.Length - 4).Trim();
}
// extract the path and the property
var(path, property) = QueryTools.ExtractPathAndProperty(atom);
return(new OrderByAtom
{
Path = path,
Property = property,
Desc = desc
});
}
/// <summary>
/// If this query has a principal query, this method returns the SQL of the principal query in the form of an
/// INNER JOIN to restrict the result to those entities that are related to the principal query
/// </summary>
private string PreparePrincipalQuery(Func <Type, string> sources, SqlStatementParameters ps, int userId, DateTime?userToday)
{
string principalQuerySql = "";
if (PrincipalQuery != null)
{
// Get the inner sql and append 4 spaces before each line for aesthetics
string innerSql = PrincipalQuery.PrepareStatementAsPrincipal(sources, ps, IsAncestorExpand, PathToCollectionPropertyInPrincipal, userId, userToday);
innerSql = QueryTools.IndentLines(innerSql);
if (IsAncestorExpand)
{
principalQuerySql = $@"INNER JOIN (
{innerSql}
) As [S] ON [S].[Node].IsDescendantOf([P].[Node]) = 1 AND [S].[Node] <> [P].[Node]";
}
else
{
principalQuerySql = $@"INNER JOIN (
{innerSql}
) As [S] ON [S].[Id] = [P].[{ForeignKeyToPrincipalQuery}]";
}
}
return(principalQuerySql);
}
/// <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,
});
}
/// <summary>
/// Prepares the WHERE clause of the SQL query from the <see cref="Filter"/> argument: WHERE ABC
/// </summary>
private string PrepareWhere(Func <Type, string> sources, JoinTree joinTree, SqlStatementParameters ps, int userId, DateTime?userToday)
{
string whereSql = QueryTools.FilterToSql(Filter, sources, ps, joinTree, userId, userToday) ?? "";
// Add the "WHERE" keyword
if (!string.IsNullOrEmpty(whereSql))
{
whereSql = "WHERE " + whereSql;
}
return(whereSql);
}
// 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>
/// Parses a string representing a single atom (no commas) into an <see cref="AggregateSelectAtom"/>
/// </summary>
/// <param name="atom">String representing a single atom (should not contain commas)</param>
public static SelectAtom Parse(string atom)
{
// item comes in the general formats:
// - "Customer/Name"
// - "Amount"
if (string.IsNullOrWhiteSpace(atom))
{
throw new ArgumentNullException(nameof(atom));
}
atom = atom.Trim();
var(path, property) = QueryTools.ExtractPathAndProperty(atom);
return(new SelectAtom
{
Path = path,
Property = property
});
}
/// <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);
}
/// <summary>
/// Prepares the WHERE clause of the SQL query from the <see cref="Filter"/> argument: WHERE ABC
/// </summary>
private string PrepareWhere(Func <Type, string> sources, JoinTree joinTree, SqlStatementParameters ps, int userId, DateTime?userToday)
{
// WHERE is cached
if (_cachedWhere == null)
{
string whereFilter = null;
string whereInIds = null;
string whereInParentIds = null;
if (Filter != null)
{
whereFilter = QueryTools.FilterToSql(Filter, sources, ps, joinTree, userId, userToday);
}
if (Ids != null && Ids.Count() >= 1)
{
if (Ids.Count() == 1)
{
string paramName = ps.AddParameter(Ids.Single());
whereInIds = $"[P].[Id] = @{paramName}";
}
else
{
var isIntKey = (Nullable.GetUnderlyingType(KeyType) ?? KeyType) == typeof(int);
var isStringKey = KeyType == typeof(string);
// Prepare the ids table
DataTable idsTable = isIntKey ? RepositoryUtilities.DataTable(Ids.Select(id => new { Id = (int)id }))
: isStringKey?RepositoryUtilities.DataTable(Ids.Select(id => new { Id = id.ToString() }))
: throw new InvalidOperationException("Only string and Integer Ids are supported");
//
var idsTvp = new SqlParameter("@Ids", idsTable)
{
TypeName = isIntKey ? "[dbo].[IdList]" : isStringKey ? "[dbo].[StringList]" : throw new InvalidOperationException("Only string and Integer Ids are supported"),
SqlDbType = SqlDbType.Structured
};
ps.AddParameter(idsTvp);
whereInIds = $"[P].[Id] IN (SELECT Id FROM @Ids)";
}
}
if (ParentIds != null)
{
if (!ParentIds.Any())
{
if (IncludeRoots)
{
whereInParentIds = $"[P].[ParentId] IS NULL";
}
}
else if (ParentIds.Count() == 1)
{
string paramName = ps.AddParameter(ParentIds.Single());
whereInParentIds = $"[P].[ParentId] = @{paramName}";
if (IncludeRoots)
{
whereInParentIds += " OR [P].[ParentId] IS NULL";
}
}
else
{
var isIntKey = (Nullable.GetUnderlyingType(KeyType) ?? KeyType) == typeof(int);
var isStringKey = KeyType == typeof(string);
// Prepare the data table
DataTable parentIdsTable = new DataTable();
string propName = "Id";
var column = new DataColumn(propName, KeyType);
if (isStringKey)
{
column.MaxLength = 450; // Just for performance
}
parentIdsTable.Columns.Add(column);
foreach (var id in ParentIds.Where(e => e != null))
{
DataRow row = parentIdsTable.NewRow();
row[propName] = id;
parentIdsTable.Rows.Add(row);
}
// Prepare the TVP
var parentIdsTvp = new SqlParameter("@ParentIds", parentIdsTable)
{
TypeName = isIntKey ? "[dbo].[IdList]" : isStringKey ? "[dbo].[StringList]" : throw new InvalidOperationException("Only string and Integer ParentIds are supported"),
SqlDbType = SqlDbType.Structured
};
ps.AddParameter(parentIdsTvp);
whereInParentIds = $"[P].[ParentId] IN (SELECT Id FROM @ParentIds)";
if (IncludeRoots)
{
whereInParentIds += " OR [P].[ParentId] IS NULL";
}
}
}
// The final WHERE clause (if any)
string whereSql = "";
var clauses = new List <string> {
whereFilter, whereInIds, whereInParentIds
}.Where(e => e != null);
if (clauses.Any())
{
whereSql = clauses.Aggregate((c1, c2) => $"{c1}) AND ({c2}");
whereSql = $"WHERE ({whereSql})";
}
_cachedWhere = whereSql;
}
return(_cachedWhere);
}