public T DoQuerySingle(RestrictionBuilderBase restrictionBuilder, OrderByBuilder orderByBuilder = null)
{
DoQuerySingleCalled = true;
this.RestrictionBuilder = restrictionBuilder;
this.OrderByBuilder = orderByBuilder;
return(default(T));
}
public QuerySpecificationBuilderImpl(
SQLVendor vendor,
SelectColumnClauseBuilder columnsBuilder,
FromBuilder fromBuilder,
BooleanBuilder whereBuilder,
GroupByBuilder groupByBuilder,
BooleanBuilder havingBuilder,
OrderByBuilder orderByBuilder
)
: base(vendor)
{
ArgumentValidator.ValidateNotNull(nameof(columnsBuilder), columnsBuilder);
ArgumentValidator.ValidateNotNull(nameof(fromBuilder), fromBuilder);
ArgumentValidator.ValidateNotNull(nameof(whereBuilder), whereBuilder);
ArgumentValidator.ValidateNotNull(nameof(groupByBuilder), groupByBuilder);
ArgumentValidator.ValidateNotNull(nameof(havingBuilder), havingBuilder);
ArgumentValidator.ValidateNotNull(nameof(orderByBuilder), orderByBuilder);
this._colsBuilder = columnsBuilder;
this._fromBuilder = fromBuilder;
this._whereBuilder = whereBuilder;
this._groupByBuilder = groupByBuilder;
this._havingBuilder = havingBuilder;
this._orderByBuilder = orderByBuilder;
}
private IList <T> InnerDoQuery(RestrictionBuilderBase restrictionBuilder, OrderByBuilder orderByBuilder, int max, int skip)
{
ArchiveExecutionContext executionContext = _archiveExecutionContextProvider.Get();
if (executionContext == null)
{
throw new InvalidOperationException(nameof(executionContext) + " not set, cannot be null");
}
ArchiveQueryParameters context = new ArchiveQueryParameters();
context.ArchiveName = executionContext.ArchiveName;
context.Entities = executionContext.Entities;
context.RequestedColumns = DynamicPropertyHelper.GetAllDbColumnsPrefixed <T>();
int page = 0;
if (skip > 0)
{
page = SetPageSizeAndGetPage(skip, max, context);
}
if (restrictionBuilder != null)
{
context.Restrictions = restrictionBuilder.GetRestrictions();
}
if (orderByBuilder != null)
{
context.OrderBy = orderByBuilder.Get();
}
return(_resultParser.Parse <T>(executionContext, _executor.GetItems(context, max, page)));
}
public void TestingSort()
{
// subject.
var posts = new List <Post>()
{
new Post {
Id = 1, AuthorId = 1, Title = "Hello 1", Content = "World"
},
new Post {
Id = 2, AuthorId = 1, Title = "Hello 2", Content = "World"
},
new Post {
Id = 3, AuthorId = 2, Title = "Hello 3", Content = "World"
},
};
// the query.
var query = posts.AsQueryable();
var queryBuilder = new OrderByBuilder(query);
// add some sorting.
queryBuilder
.OrderByDescending("AuthorId")
.ThenBy("Id");
query = queryBuilder.Build().Cast <Post>();
var first = query.First();
var second = query.Skip(1).First();
Assert.IsTrue(first.Id == 3);
Assert.IsTrue(second.Id == 1);
}
public static IQueryable <T> ApplyQueryParams <T>(this IQueryable <T> queryable, QueryParams @params)
where T : class
{
if (@params == null)
{
return(queryable);
}
IQueryBuilder <T> expandBuilder = new IncludeBuilder <T>();
var result = expandBuilder.Build(@params, queryable);
IQueryBuilder <T> filterBuilder = new QueryBuilder <T>();
result = filterBuilder.Build(@params, result);
IQueryBuilder <T> orderBuilder = new OrderByBuilder <T>();
result = orderBuilder.Build(@params, result);
IQueryBuilder <T> pagingBuilder = new PagingBuilder <T>();
result = pagingBuilder.Build(@params, result);
return(result);
}
public void ByDescending_WithColumnName_SetsOrderByProperty()
{
var builder = new OrderByBuilder("products");
builder.ByDescending("id");
builder.OrderBy.Should().BeEquivalentTo(new OrderBy("products", "id", SortDirection.Descending));
}
private OrderByBuilder <Child> ConfigureOrderBy(OrderByBuilder <Child> builder)
{
return(builder
.AddValue("custom", descending: false)
.AddValue("custom", descending: true)
.Ignore(x => x.Irrelevant)
);
}
public IList <T> DoQuery(RestrictionBuilderBase restrictionBuilder, OrderByBuilder orderByBuilder = null, int noItems = 0, int page = 0)
{
this.RestrictionBuilder = restrictionBuilder;
this.OrderByBuilder = orderByBuilder;
this.NoItems = noItems;
this.Page = page;
return(new List <T>());
}
// non generic.
public static IQueryable OrderBy(this IQueryable query, string path, QueryOrderByDirection direction, bool append)
{
var qb = new OrderByBuilder(query);
qb.OrderBy(path, direction, append);
var ret = qb.Build();
return(ret);
}
private static IQueryOver <TScheme, TScheme> SetOrderByDirection(OrderByBuilder <TScheme> orderBy, IQueryOver <TScheme, TScheme> query)
{
// ReSharper disable once ConvertIfStatementToReturnStatement
if (orderBy.OrderByDirection == OrderByDirection.Ascending)
{
return(query.OrderBy(orderBy.OrderExpresssion).Asc);
}
return(query.OrderBy(orderBy.OrderExpresssion).Desc);
}
public void ByDescending_WhenColumnIsNull_ThrowsException()
{
var builder = new OrderByBuilder("table");
Action action = () => builder.ByDescending(null);
action.Should()
.Throw <ArgumentNullException>()
.Which.ParamName.Should()
.Be("column");
}
public T DoQuerySingle(RestrictionBuilderBase restrictionBuilder, OrderByBuilder orderByBuilder = null)
{
IList <T> result = InnerDoQuery(restrictionBuilder, orderByBuilder, 1, 0);
if (result != null)
{
return(result.FirstOrDefault());
}
else
{
return(default(T));
}
}
public void TestAddOrder()
{
var ob = new OrderByBuilder();
ob.AddOrder("contact.name", true);
ob.AddOrder("contact.id", false);
List <ArchiveOrderByInfo> result = ob.Get();
Assert.Equal("contact.name", result[0].Name);
Assert.Equal("contact.id", result[1].Name);
Assert.Equal(OrderBySortType.ASC, result[0].Direction);
Assert.Equal(OrderBySortType.DESC, result[1].Direction);
}
public void TestAddOrderGeneric()
{
var ob = new OrderByBuilder();
ob.AddOrder <TestPerson>("name", true);
ob.AddOrder <TestPerson>("id", false);
List <ArchiveOrderByInfo> result = ob.Get();
Assert.Equal("testperson.name", result[0].Name);
Assert.Equal("testperson.id", result[1].Name);
Assert.Equal(OrderBySortType.ASC, result[0].Direction);
Assert.Equal(OrderBySortType.DESC, result[1].Direction);
}
public PagedSelectCommandBuilder Clear()
{
SelectBuilder.Clear();
FromBuilder.Clear();
WhereBuilder.Clear();
OrderByBuilder.Clear();
GroupByBuilder.Clear();
HavingBuilder.Clear();
CommandParameters.Clear();
Distinct = false;
Offset = 0;
PageSize = 0;
return(this);
}
private string GetSqlGrid(LazyPagination pagger)
{
var sql = _sql ?? _gridModel.GridSql;
sql = _filter.AddCondition(sql);
var orderColumns = _gridModel.Column.First(x => string.Equals(x.SystemName, _gridOptions.SortOptions.Column, StringComparison.OrdinalIgnoreCase));
string orderColumn = orderColumns.OrderByName ?? orderColumns.SystemName;
var orderBy = new OrderByBuilder(orderColumn, _gridOptions.SortOptions.Direction).QueryResult;
sql += Environment.NewLine + orderBy;
sql += Environment.NewLine + pagger.GetOffestRow();
return(sql);
}
internal virtual IQueryable <T> BuildQuery <T>(IQueryable <T> source)
where T : class
{
if (_filterSource == null)
{
return(source);
}
var whereBuilder = new WhereBuilder <T>(source, _filterSource);
source = whereBuilder.Build();
if (_filterSource is ISortableSearch search)
{
var orderByBuilder = new OrderByBuilder <T>(source);
source = orderByBuilder.Build(search);
}
return(source);
}
public static Task <T> ApplyQueryOneParams <T>(this IQueryable <T> queryable, QueryParams @params)
where T : class
{
if (@params == null)
{
return(queryable.FirstOrDefaultAsync());
}
IQueryBuilder <T> expandBuilder = new IncludeBuilder <T>();
var result = expandBuilder.Build(@params, queryable);
IQueryBuilder <T> filterBuilder = new QueryBuilder <T>();
result = filterBuilder.Build(@params, result);
IQueryBuilder <T> orderBuilder = new OrderByBuilder <T>();
result = orderBuilder.Build(@params, result);
return(result.FirstOrDefaultAsync());
}
private string GetSqlWithSelectedRows()
{
var sql = _sql ?? _gridModel.GridSql;
if (_gridOptions.SelectedRows.Count > 0)
{
if (_gridOptions.IsSelectedAll)
{
List <string> ids = _gridOptions.SelectedRows.Where(x => x.IsSelected == false)
.Select(x => x.ParentId == null ? x.RowId.Substring(2) : x.RowId.Replace($"{x.ParentId.Substring(2)}", "").Substring(2)).ToList();
sql = _filter.AddCondition(sql, ids, false);
}
else
{
List <string> ids = _gridOptions.SelectedRows.Where(x => x.IsSelected == true)
.Select(x => x.ParentId == null ? x.RowId.Substring(2) : x.RowId.Replace($"{x.ParentId.Substring(2)}", "").Substring(2)).ToList();
sql = _filter.AddCondition(sql, ids, true);
}
}
else
{
sql = _filter.AddCondition(sql);
}
var orderColumns = _gridModel.Column.First(x => string.Equals(x.SystemName, _gridOptions.SortOptions.Column, StringComparison.OrdinalIgnoreCase));
string orderColumn = orderColumns.OrderByName ?? orderColumns.SystemName;
var orderBy = new OrderByBuilder(orderColumn, _gridOptions.SortOptions.Direction).QueryResult;
sql += Environment.NewLine + orderBy;
return(sql);
}
public T GetFirst(RestrictionBuilderBase restrictionBuilder, OrderByBuilder orderByBuilder = null)
{
return(_archiveWrapper.DoQuerySingle(restrictionBuilder, orderByBuilder));
}
public OrderByDirectionBuilder(OrderByBuilder <TScheme> builder)
{
_builder = builder;
}
/// <summary>
/// 测试初始化
/// </summary>
public OrderByBuilderTest()
{
_builder = new OrderByBuilder();
}
public IList <T> DoQuery(RestrictionBuilderBase restrictionBuilder, OrderByBuilder orderByBuilder = null, int noItems = 0, int skip = 0)
{
return(InnerDoQuery(restrictionBuilder, orderByBuilder, noItems, skip));
}
public static OrderByBuilder AddSortSpecificationsP(this OrderByBuilder builder, params SortSpecification[] specifications)
{
return(builder.AddSortSpecifications(specifications));
}
private Node HandleTable(Node?parent, Field fieldAst, FieldType field, IComplexGraphType graphType,
SqlTableConfig config, int depth, IResolveFieldContext context)
{
var arguments = HandleArguments(field, fieldAst, context);
var fieldName = fieldAst.Alias ?? fieldAst.Name;
var tableName = config.Table(arguments, context);
var tableAs = _aliasGenerator.GenerateTableAlias(fieldName);
var grabMany = field.ResolvedType.IsListType();
var where = field.GetSqlWhere();
var join = field.GetSqlJoin();
var junction = field.GetSqlJunction();
var batch = field.GetSqlBatch();
var orderBy = field.GetSqlOrder();
var sortKey = field.GetSqlSortKey();
var paginate = false;
if (!grabMany && field.ResolvedType.GetNamedType().IsConnectionType())
{
paginate = field.GetSqlPaginate().GetValueOrDefault(false);
grabMany = true;
}
var sqlTable = new SqlTable(parent, config, tableName, fieldName, tableAs, arguments, grabMany)
.WithLocation(fieldAst.SourceLocation);
if (config.UniqueKey.Length == 1)
{
var alias = _aliasGenerator.GenerateColumnAlias(config.UniqueKey[0]);
sqlTable.Columns.Add(new SqlColumn(sqlTable, config.UniqueKey[0], config.UniqueKey[0], alias, true));
}
else
{
var clumsyName = string.Join("#", config.UniqueKey);
var alias = _aliasGenerator.GenerateColumnAlias(clumsyName);
sqlTable.Columns.Add(new SqlComposite(sqlTable, config.UniqueKey, clumsyName, alias, true));
}
if (config.AlwaysFetch != null)
{
foreach (var column in config.AlwaysFetch)
{
var alias = _aliasGenerator.GenerateColumnAlias(column);
sqlTable.Columns.Add(new SqlColumn(sqlTable, column, column, alias));
}
}
if (fieldAst.SelectionSet != null)
{
HandleSelections(sqlTable, graphType, fieldAst.SelectionSet.Selections, depth, context);
}
sqlTable.ColumnExpression = config.ColumnExpression;
if (where != null)
{
sqlTable.Where = where;
}
if (orderBy != null)
{
var builder = new OrderByBuilder(sqlTable.As);
orderBy(builder, arguments, context, sqlTable);
sqlTable.OrderBy = builder.OrderBy;
}
if (sortKey != null)
{
var builder = new SortKeyBuilder(sqlTable.As, _aliasGenerator);
sortKey(builder, arguments, context, sqlTable);
sqlTable.SortKey = builder.SortKey;
}
sqlTable.Paginate = paginate;
if (join != null)
{
sqlTable.Join = join;
}
else if (junction != null)
{
sqlTable.Junction = new SqlJunction(sqlTable, junction.Table, _aliasGenerator.GenerateTableAlias(junction.Table));
if (junction.Where != null)
{
sqlTable.Junction.Where = junction.Where;
}
if (junction.OrderBy != null)
{
var builder = new OrderByBuilder(tableAs);
junction.OrderBy(builder, arguments, context, sqlTable);
sqlTable.Junction.OrderBy = builder.OrderBy;
}
if (junction.SortKey != null)
{
var builder = new SortKeyBuilder(tableAs, _aliasGenerator);
junction.SortKey(builder, arguments, context, sqlTable);
sqlTable.Junction.SortKey = builder.SortKey;
}
var batchConfig = junction.BatchConfig;
if (junction.FromParent != null && junction.ToChild != null)
{
sqlTable.Junction.FromParent = junction.FromParent;
sqlTable.Junction.ToChild = junction.ToChild;
}
else if (batchConfig != null)
{
sqlTable.Junction.Batch = new SqlBatch(
new SqlColumn(sqlTable, batchConfig.ThisKey, batchConfig.ThisKey,
_aliasGenerator.GenerateColumnAlias(batchConfig.ThisKey))
{
FromOtherTable = sqlTable.Junction.As,
Expression = batchConfig.ThisKeyExpression
},
new SqlColumn(sqlTable, batchConfig.ParentKey, fieldName,
_aliasGenerator.GenerateColumnAlias(batchConfig.ParentKey))
{
Expression = batchConfig.ParentKeyExpression
}
)
{
Join = batchConfig.Join,
Where = batchConfig.Where
};
}
}
else if (batch != null)
{
sqlTable.Batch = new SqlBatch(
new SqlColumn(sqlTable, batch.ThisKey, batch.ThisKey, _aliasGenerator.GenerateColumnAlias(batch.ThisKey))
{
Expression = batch.ThisKeyExpression
},
new SqlColumn(sqlTable, batch.ParentKey, batch.ParentKey, _aliasGenerator.GenerateColumnAlias(batch.ParentKey))
{
Expression = batch.ParentKeyExpression
}
)
{
Where = batch.Where
};
}
if (paginate)
{
HandleColumnsRequiredForPagination(sqlTable);
}
return(sqlTable);
}
public PagedSelectCommandBuilder OrderBy(string value) => this.Chain(() => OrderByBuilder.Append(value));
public void TestInit()
{
_builder = new OrderByBuilder();
}
public ICollection <T> GetList(RestrictionBuilderBase restrictionBuilder, OrderByBuilder orderByBuilder = null)
{
return(_archiveWrapper.DoQuery(restrictionBuilder, orderByBuilder));
}
