public static SqlExpression <From> CreateQuery <From, Into>(this IAutoQueryDb autoQuery, IQueryDb <From, Into> model, IRequest request)
{
return(autoQuery.CreateQuery(model, request.GetRequestParams(), request));
}
public abstract IQueryResponse ExecuteObject(AutoQuery autoQuery, IQueryDb request, ISqlExpression query);
public ISqlExpression AddToQuery(
ISqlExpression query,
IQueryDb dto,
Dictionary <string, string> dynamicParams,
IAutoQueryOptions options = null)
{
dynamicParams = new Dictionary <string, string>(dynamicParams, StringComparer.OrdinalIgnoreCase);
var q = (SqlExpression <From>)query;
if (options != null && options.EnableSqlFilters)
{
AppendSqlFilters(q, dto, dynamicParams, options);
}
AppendJoins(q, dto);
AppendLimits(q, dto, options);
var dtoAttr = dto.GetType().FirstAttribute <QueryDbAttribute>();
var defaultTerm = dtoAttr != null && dtoAttr.DefaultTerm == QueryTerm.Or ? "OR" : "AND";
var aliases = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
var props = typeof(From).GetProperties();
foreach (var pi in props)
{
var attr = pi.FirstAttribute <DataMemberAttribute>();
if (attr?.Name == null)
{
continue;
}
aliases[attr.Name] = pi.Name;
}
AppendTypedQueries(q, dto, dynamicParams, defaultTerm, options, aliases);
if (options?.EnableUntypedQueries == true && dynamicParams.Count > 0)
{
AppendUntypedQueries(q, dynamicParams, defaultTerm, options, aliases);
}
if (defaultTerm == "OR" && q.WhereExpression == null)
{
q.Where("1=0"); //Empty OR queries should be empty
}
if (!string.IsNullOrEmpty(dto.Fields))
{
var fields = dto.Fields;
var selectDistinct = fields.StartsWith("DISTINCT ", StringComparison.OrdinalIgnoreCase);
if (selectDistinct)
{
fields = fields.Substring("DISTINCT ".Length);
}
var fieldNames = fields.Split(',')
.Where(x => x.Trim().Length > 0)
.Map(x => x.Trim());
if (selectDistinct)
{
q.SelectDistinct(fieldNames.ToArray());
}
else
{
q.Select(fieldNames.ToArray());
}
}
return(q);
}
public QueryResponse <Into> Execute <From, Into>(IQueryDb <From, Into> model, SqlExpression <From> query)
{
var typedQuery = GetTypedQuery(model.GetType(), typeof(From));
return(ResponseFilter(typedQuery.Execute <Into>(GetDb <From>(), query), query, model));
}
public QueryResponse <Into> ResponseFilter <From, Into>(QueryResponse <Into> response, SqlExpression <From> expr, IQueryDb dto)
{
response.Meta = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
var commands = dto.Include.ParseCommands();
var ctx = new QueryDbFilterContext
{
Db = Db,
Commands = commands,
Dto = dto,
SqlExpression = expr,
Response = response,
};
var totalCommand = commands.FirstOrDefault(x => x.Name.EqualsIgnoreCase("Total"));
if (totalCommand != null)
{
totalCommand.Name = "COUNT";
}
var totalRequested = commands.Any(x =>
x.Name.EqualsIgnoreCase("COUNT") &&
(x.Args.Count == 0 || x.Args.Count == 1 && x.Args[0].EqualsOrdinal("*")));
if (IncludeTotal || totalRequested)
{
if (!totalRequested)
{
commands.Add(new Command {
Name = "COUNT", Args = { "*".AsMemory() }
});
}
foreach (var responseFilter in ResponseFilters)
{
responseFilter(ctx);
}
response.Total = response.Meta.TryGetValue("COUNT(*)", out var total)
? total.ToInt()
: (int)Db.Count(expr); //fallback if it's not populated (i.e. if stripped by custom ResponseFilter)
//reduce payload on wire
if (totalCommand != null || !totalRequested)
{
response.Meta.Remove("COUNT(*)");
if (response.Meta.Count == 0)
{
response.Meta = null;
}
}
}
else
{
foreach (var responseFilter in ResponseFilters)
{
responseFilter(ctx);
}
}
return(response);
}
public SqlExpression <From> CreateQuery <From, Into>(IQueryDb <From, Into> dto, Dictionary <string, string> dynamicParams, IRequest req = null)
{
var typedQuery = GetTypedQuery(dto.GetType(), typeof(From));
return(Filter <From>(typedQuery.CreateQuery(GetDb <From>(req), dto, dynamicParams, this), dto, req));
}
public QueryResponse <Into> ResponseFilter <From, Into>(QueryResponse <Into> response, SqlExpression <From> sqlExpression, IQueryDb dto)
{
response.Meta = new Dictionary <string, string>(StringComparer.InvariantCultureIgnoreCase);
var commands = dto.Include.ParseCommands();
var ctx = new QueryDbFilterContext
{
Db = Db,
Commands = commands,
Dto = dto,
SqlExpression = sqlExpression,
Response = response,
};
if (IncludeTotal)
{
var totalCountRequested = commands.Any(x =>
"COUNT".EqualsIgnoreCase(x.Name) &&
(x.Args.Count == 0 || (x.Args.Count == 1 && x.Args[0] == "*")));
if (!totalCountRequested)
{
commands.Add(new Command {
Name = "COUNT", Args = { "*" }
});
}
foreach (var responseFilter in ResponseFilters)
{
responseFilter(ctx);
}
string total;
response.Total = response.Meta.TryGetValue("COUNT(*)", out total)
? total.ToInt()
: (int)Db.Count(sqlExpression); //fallback if it's not populated (i.e. if stripped by custom ResponseFilter)
//reduce payload on wire
if (!totalCountRequested)
{
response.Meta.Remove("COUNT(*)");
if (response.Meta.Count == 0)
{
response.Meta = null;
}
}
}
else
{
foreach (var responseFilter in ResponseFilters)
{
responseFilter(ctx);
}
}
return(response);
}
public QueryResponse <From> Consultar <From>(IQueryDb <From> modelo,
Dictionary <string, string> peticion,
Expression <Func <From, bool> > filtro = null)
{
return(ConsultarAsync(modelo, peticion, filtro).Result);
}
