public static string List <T>(IDynamicQuery paramData) where T : IEntity, new()
{
T target = new T();
StringBuilder query = new StringBuilder(200);
query.Append($"SELECT TOP ({paramData.PageSize}) resultTable.* FROM");
query.Append($"( SELECT TOP ({paramData.PageSize * paramData.CurPage}) ROW_NUMBER () OVER ");
if (!string.IsNullOrWhiteSpace(paramData.OrderBy))
{
query.Append($" (ORDER BY { paramData.OrderBy }) AS rownumber, *");
}
else
{
query.Append($" (ORDER BY { target.TargetColumn } desc) AS rownumber, *");
}
query.Append($" FROM [{target.TableName}]");
if (!string.IsNullOrWhiteSpace(paramData.WhereString))
{
query.Append(" where " + paramData.WhereString);
}
if (!string.IsNullOrWhiteSpace(paramData.OrderBy))
{
query.Append($" ORDER BY { paramData.OrderBy }");
}
query.Append(") AS resultTable");
query.Append($" WHERE rownumber > {(paramData.CurPage - 1) * paramData.PageSize}");
return(query.ToString());
}
public static string List(string EntityName, IDynamicQuery paramData, string appendWhere)
{
StringBuilder query = new StringBuilder(200);
query.Append($"SELECT TOP ({paramData.PageSize}) resultTable.* FROM");
query.Append($"( SELECT TOP ({paramData.PageSize * paramData.CurPage}) ROW_NUMBER () OVER ");
query.Append($" (ORDER BY { paramData.OrderBy }) AS rownumber, *");
query.Append($" FROM [{EntityName}]");
if (!string.IsNullOrWhiteSpace(paramData.WhereString))
{
query.Append(" where " + paramData.WhereString);
if (!string.IsNullOrWhiteSpace(appendWhere))
{
query.Append($" and {appendWhere}");
}
}
else
{
if (!string.IsNullOrWhiteSpace(appendWhere))
{
query.Append($" where {appendWhere}");
}
}
if (!string.IsNullOrWhiteSpace(paramData.OrderBy))
{
query.Append($" ORDER BY { paramData.OrderBy }");
}
query.Append(") AS resultTable");
query.Append($" WHERE rownumber > {(paramData.CurPage - 1) * paramData.PageSize}");
return(query.ToString());
}
public DynamicQuery(IModelDescriptorCollection descriptors,
IServiceProvider serviceProvider,
IQueryRuleCollection queryRuleCollection)
{
if (descriptors == null)
{
throw new ArgumentNullException(nameof(descriptors));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
var descriptor = descriptors[typeof(T)] ?? throw new InvalidOperationException($"Missing descriptor of dto {typeof(T).Name}");
var contextType = descriptor.Bag.__Context__ ?? throw new InvalidOperationException($"Missing db context for descriptor of dto {typeof(T).Name}");
var context = serviceProvider.GetService(contextType) ?? throw new InvalidOperationException($"Can not resolve db context {contextType.Name}");
var map = (Dictionary <string, string>)descriptor.SourceMap;
Descriptor = descriptor;
ContextType = contextType;
Context = context;
EntityMap = map;
_query = (IDynamicQuery <T>)Activator.CreateInstance(
typeof(QueryWrapper <,>).MakeGenericType(descriptor.SourceType, typeof(T)),
context, descriptor, serviceProvider, queryRuleCollection, (IDictionary <string, string>)map);
}
protected virtual Task <IQueryable <TSource> > GetQueryableAsync(IDynamicQuery query, CancellationToken cancellationToken = default)
{
if (this.queryableProviders.Any())
{
return(queryableProviders.ElementAt(0).GetQueryableAsync(query, cancellationToken));
}
throw new Exception($"You must provide a QueryableProvider<TSource> for {typeof(TSource).Name}");
}
public static string toCount <T>(this IDynamicQuery paramData) where T : IEntity
{
StringBuilder builder = new StringBuilder(200);
T data = default(T);
builder.AppendLine($"select count(1) from {data.TableName} with (nolock)");
if (!string.IsNullOrWhiteSpace(paramData.WhereString))
{
builder.AppendLine($" where {paramData.WhereString}");
}
return(builder.ToString());
}
protected virtual IQueryCriteria CreateCriteriaFromQuery(IDynamicQuery query)
{
var criteria = new QueryCriteria
{
Page = query?.GetPage(),
PageSize = query?.GetPageSize(),
Filters = query?.GetFilters() ?? new List <IFilter>(),
Sorts = query?.GetSorts() ?? new List <ISort>(),
Groups = query.GetGroups() ?? new List <IGroup>(),
Aggregates = query.GetAggregates() ?? new List <IAggregate>()
};
return(criteria);
}
public static string toPaging <T>(this IDynamicQuery paramData) where T : IEntity
{
StringBuilder builder = new StringBuilder(200);
T data = default(T);
builder.AppendLine($"SELECT TOP ({paramData.PageSize}) resultTable.* FROM");
builder.Append($"( SELECT TOP ({paramData.PageSize * paramData.CurPage}) ROW_NUMBER () OVER (ORDER BY ");
if (string.IsNullOrWhiteSpace(paramData.OrderBy))
{
builder.Append($"{paramData.OrderBy} desc");
}
else
{
builder.Append(paramData.OrderBy);
}
builder.AppendLine($") AS rownumber, * FROM [{data.TableName}] with (nolock)");
if (!string.IsNullOrWhiteSpace(paramData.WhereString))
{
builder.AppendLine($" where {paramData.WhereString}");
}
builder.AppendLine(") AS resultTable");
builder.AppendLine($"WHERE rownumber > {(paramData.CurPage - 1) * paramData.PageSize}");
return(builder.ToString());
}
public RelativeDataParser(IDynamicQuery dynamicQuery, MasterConfiguration masterConfiguration)
{
_masterConfiguration = masterConfiguration;
_dynamicQuery = dynamicQuery;
}
/// <summary>
///
/// </summary>
/// <param name="commandBus"></param>
/// <param name="queryService"></param>
public DefaultExportHandler(ICommandBus commandBus, IDynamicQuery queryService)
: base(null)
{
this.CommandBus = commandBus;
this.QueryService = queryService;
}
/// <summary>
/// 获取所有记录集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="thisQuery"></param>
/// <returns></returns>
public static IEnumerable <DataRow> GetTableAll <T>(this IDynamicQuery thisQuery) where T : DataEntityBase
{
return(thisQuery.GetTable <T>(QueryParamater.Create()));
}
public static string List <T>(this IDynamicQuery paramData, string appendWhere) where T : IEntity, new()
{
return(DynamicQuery.List <T>(paramData, appendWhere));
}
/// <summary>
/// 是否存在
/// </summary>
public static bool ExistsById <T, TId>(this IDynamicQuery thisQuery, TId id) where T : DataEntityBase
{
var query = QueryParamater.Create(string.Format("ID={0}", id));
return(thisQuery.Exists <T>(query));
}
public Query(IDynamicQuery dynamicQuery)
{
_DynamicQuery = dynamicQuery;
}
/// <summary>
/// 根据Id获取记录
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TId"></typeparam>
/// <param name="thisQuery"></param>
/// <param name="id"></param>
/// <returns></returns>
public static T GetSingleObjectById <T, TId>(this IDynamicQuery thisQuery, TId id) where T : DataEntityBase
{
var query = QueryParamater.Create(string.Format("ID={0}", id));
return(thisQuery.GetSingleObject <T>(query));
}
public DynamicEditor(IDynamicQuery dynamicQuery)
{
_DynamicQuery = dynamicQuery;
}
protected virtual async Task <IQueryable <TSource> > AlterSourceAsync(IQueryable <TSource> source, IDynamicQuery query, CancellationToken cancellationToken)
{
foreach (var t in alterQueryableServices)
{
source = await t.AlterQueryableAsync(source, query, cancellationToken);
}
return(source);
}
protected async Task <IQueryExecutionResult <TDestination> > ProcessQueryAsync(IDynamicQuery query, CancellationToken cancellationToken = default)
{
var source = await GetQueryableAsync(query, cancellationToken);
source = await AlterSourceAsync(source, query, cancellationToken);
var options = GetQueryExecutionOptions(source, query);
var interceptors = this.GetInterceptors();
foreach (var interceptor in interceptors)
{
queryHandlerAsync.AddInterceptor(interceptor);
}
var criteria = CreateCriteriaFromQuery(query);
var result = await queryHandlerAsync.ExecuteAsync <TSource, TDestination>(source, criteria, options, cancellationToken);
return(result);
}
public virtual IQueryExecutionOptions GetQueryExecutionOptions(IQueryable <TSource> source, IDynamicQuery query)
{
return(new QueryExecutionOptions());
}
public DynamicEditor(IDynamicQuery dynamicQuery)
{
_DynamicQuery = dynamicQuery;
}
public async Task <GraphQLDynamicQueryExecutionResult <TDestination> > RunAsync(IDynamicQuery <TSource, TDestination, TParams> query, CancellationToken cancellationToken = default)
{
var result = await handler.HandleAsync(query);
var outcome = new GraphQLDynamicQueryExecutionResult <TDestination>();
outcome.FromResult(result);
return(outcome);
}
public Task <IQueryExecutionResult <TDestination> > HandleAsync(IDynamicQuery <TSource, TDestination> query, CancellationToken cancellationToken = default)
{
return(ProcessQueryAsync(query, cancellationToken));
}
public Query(IDynamicQuery dynamicQuery)
{
_DynamicQuery = dynamicQuery;
}
