internal void Refresh(QueryOrderBy orderBy)
{
if (orderBy == null)
{
return;
}
ucField.SelectedValue = orderBy.FieldName;
ucOrderDirection.SelectEnum(orderBy.Direction);
}
public override Node VisitQueryOrderBy(QueryOrderBy orderby)
{
orderby.Source = this.VisitExpression(orderby.Source);
Composer save = this.contextComposer;
Composer c = this.contextComposer = this.GetComposer(orderby.Source);
bool savehcr = this.hasContextReference;
this.hasContextReference = false;
this.VisitExpressionList(orderby.OrderList);
this.hasContextReference = savehcr;
this.contextComposer = save;
return(this.Compose(orderby, c));
}
private void AddFilter(QueryOrderBy orderBy = null)
{
var filter = Controller.Add();
filter.Refresh(orderBy);
filter.SetBinding(OrderByFilterControl.DisplayColumnsByTitleProperty, new Binding
{
Source = this,
Path = new PropertyPath(nameof(DisplayColumnsByTitle)),
Mode = BindingMode.TwoWay
});
}
public void QueryOrderByTest()
{
// prepare
var query = new QueryOrderBy(new Dictionary <string, OrderType>
{
{ "phenomenonTime", OrderType.Descending },
{ "result", OrderType.Ascending }
});
// assert
Assert.AreEqual(2, query.Value.Count);
Assert.AreEqual("orderby", query.GetQueryParam());
Assert.AreEqual("phenomenonTime desc,result asc", query.GetQueryValueString());
}
private void Initialize(string typeOf, params object[] primaryOf)
{
TypeOf = typeOf;
CacheOf = new QueryCacheOf();
Parameters = new QueryParameters();
OrderBy = new QueryOrderBy();
HasPrimaryOf = primaryOf.Length > 0;
OrderBy.Direction = OrderByDirection.Asc;
foreach (var primaryOfValue in primaryOf)
{
AddParameter(new QueryParameter
{
Type = ParameterType.PrimaryOf,
Field = DocumentDefaults.DocumentMetaPrimaryOfProperty,
Value = primaryOfValue
});
}
}
public override Node VisitQueryOrderBy(QueryOrderBy orderby){
if (orderby == null) return null;
orderby.Source = this.VisitExpression(orderby.Source);
if (orderby.Source == null || orderby.Source.Type == null) return orderby;
TypeNode sourceElementType = this.typeSystem.GetStreamElementType(orderby.Source, this.TypeViewer);
orderby.Context = this.contextScope = new ContextScope(this.contextScope, sourceElementType);
orderby.OrderList = this.VisitExpressionList(orderby.OrderList);
this.contextScope = this.contextScope.Previous;
orderby.Type = this.GetResultType(orderby.Source, null, Cardinality.One);
return orderby;
}
public virtual void VisitQueryOrderBy(QueryOrderBy orderby){
if (orderby == null) return;
this.VisitExpression(orderby.Source);
this.VisitExpressionList(orderby.OrderList);
}
public override Node VisitQueryOrderBy(QueryOrderBy orderby){
if (orderby == null) return null;
return base.VisitQueryOrderBy((QueryOrderBy)orderby.Clone());
}
public virtual Node VisitQueryOrderBy(QueryOrderBy orderby1, QueryOrderBy orderby2){
if (orderby1 == null) return null;
if (orderby2 == null){
orderby1.Source = this.VisitExpression(orderby1.Source, null);
orderby1.OrderList = this.VisitExpressionList(orderby1.OrderList, null);
}else{
orderby1.Source = this.VisitExpression(orderby1.Source, orderby2.Source);
orderby1.OrderList = this.VisitExpressionList(orderby1.OrderList, orderby2.OrderList);
}
return orderby1;
}
public virtual Differences VisitQueryOrderBy(QueryOrderBy orderby1, QueryOrderBy orderby2){
Differences differences = new Differences(orderby1, orderby2);
if (orderby1 == null || orderby2 == null){
if (orderby1 != orderby2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryOrderBy changes = (QueryOrderBy)orderby2.Clone();
QueryOrderBy deletions = (QueryOrderBy)orderby2.Clone();
QueryOrderBy insertions = (QueryOrderBy)orderby2.Clone();
// orderby1.Context;
// orderby1.OrderList;
// orderby1.Source;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public static IOrder <TEntity> ApplyOrderBy <TEntity>(this IOrder <TEntity> order, Expression <Func <TEntity, object> > query, QueryOrderBy sort) where TEntity : BaseEntity
{
order.Setstock(query, sort);
return(order);
}
public override Node VisitQueryOrderBy(QueryOrderBy orderby) {
orderby.Source = this.VisitExpression(orderby.Source);
Composer save = this.contextComposer;
Composer c = this.contextComposer = this.GetComposer(orderby.Source);
bool savehcr = this.hasContextReference;
this.hasContextReference = false;
this.VisitExpressionList(orderby.OrderList);
this.hasContextReference = savehcr;
this.contextComposer = save;
return this.Compose(orderby, c);
}
public void Setstock(Expression <Func <TEntity, object> > order, QueryOrderBy sort)
{
stock.Add(order, sort);
}
public override Node VisitQueryOrderBy(QueryOrderBy qob) {
if (qob == null) return null;
Class cc = this.currentMethod.Scope.ClosureClass;
qob.Source = this.VisitExpression(qob.Source);
if (qob.Source == null || qob.Source.Type == null) return null;
Cardinality card = this.typeSystem.GetCardinality(qob.Source, this.TypeViewer);
if (card != Cardinality.OneOrMore && card != Cardinality.ZeroOrMore) {
this.HandleError(qob.Source, Error.QueryNotStream);
}
if (qob.OrderList == null || qob.OrderList.Count == 0) {
this.HandleError(qob, Error.QueryBadOrderList);
return null;
}
for (int i = 0, n = qob.OrderList.Count; i < n; i++) {
Expression x = qob.OrderList[i];
if (x == null) {
this.HandleError(qob, Error.QueryBadOrderList);
return null;
}
QueryOrderItem oi = x as QueryOrderItem;
if (oi != null) {
oi.Expression = this.VisitExpression(oi.Expression);
if (oi.Expression == null || oi.Type == null) return null;
} else {
x = this.VisitExpression(x);
if (x == null || x.Type == null) return null;
}
card = this.typeSystem.GetCardinality(x, this.TypeViewer);
if (card == Cardinality.OneOrMore || card == Cardinality.ZeroOrMore) {
this.HandleError(x, Error.QueryNotScalar);
return null;
}
qob.OrderList[i] = x;
}
if (qob.Type == null) return null;
return qob;
}
public override Node VisitQueryOrderBy( QueryOrderBy qob ){
if (qob == null) return null;
qob.Source = this.VisitExpression(qob.Source);
QueryGroupBy save = this.currentGroup;
this.currentGroup = this.GetGroupBySource(qob.Source);
if (this.currentGroup == null){
this.currentGroup = new QueryGroupBy();
}
this.VisitExpressionList(qob.OrderList);
if (this.currentGroup.Source == null && this.currentGroup.AggregateList.Count > 0){
qob.Source = this.InjectGroupBy(qob.Source, this.currentGroup);
}
this.currentGroup = save;
return qob;
}
public virtual Node VisitQueryOrderBy(QueryOrderBy orderby){
if (orderby == null) return null;
orderby.Source = this.VisitExpression(orderby.Source);
orderby.OrderList = this.VisitExpressionList(orderby.OrderList);
return orderby;
}
public override Node VisitQueryOrderBy(QueryOrderBy qo) {
// generate translation code
Block block = null;
Node closure = this.StartQueryClosure(this.typeSystem.GetStreamElementType(qo, this.TypeViewer), "orderby", out block);
BlockScope scope = block.Scope;
// construct list for sorting
Local locList = new Local(SystemTypes.ArrayList);
Construct cons = new Construct();
cons.Constructor = new MemberBinding(null, SystemTypes.ArrayList.GetConstructor());
cons.Type = SystemTypes.ArrayList;
block.Statements.Add(new AssignmentStatement(locList, cons));
// build key type
int len = qo.OrderList.Count;
FieldList fields = new FieldList(len + 1);
ArrayList orderTypes = new ArrayList(len);
ExpressionList expressions = new ExpressionList(len);
for( int i = 0; i < len; i++ ) {
Expression x = qo.OrderList[i];
QueryOrderType ot = QueryOrderType.Ascending;
QueryOrderItem order = x as QueryOrderItem;
if (x != null) {
ot = order.OrderType;
x = order.Expression;
}
Field f = new Field(null, new AttributeList(1), FieldFlags.Public, Identifier.For("Item"+i), x.Type, null);
f.Attributes.Add(new AttributeNode(new MemberBinding(null, SystemTypes.AnonymousAttribute.GetConstructor()), null));
fields.Add(f);
orderTypes.Add(ot);
expressions.Add(x);
}
Field fRow = new Field(null, new AttributeList(1), FieldFlags.Public, Identifier.For("Item"+len), SystemTypes.Object, null);
fRow.Attributes.Add(new AttributeNode(new MemberBinding(null, SystemTypes.AnonymousAttribute.GetConstructor()), null));
fields.Add(fRow);
// construct key type
TypeNode keyType = TupleType.For(fields, this.currentType);
// build comparer for key
MemberList members = this.typeSystem.GetDataMembers(keyType);
fRow = (Field)members[len];
TypeNode comparerType = this.BuildComparer(keyType, members, (QueryOrderType[])orderTypes.ToArray(typeof(QueryOrderType)), len);
block.Statements.Add(new QueryGeneratedType(comparerType));
// iterate rows
Expression feTarget = null;
Block inner = null;
block.Statements.Add(this.BuildClosureForEach(qo.Source, ref feTarget, out inner, scope));
qo.Context.Target = feTarget;
// prepare key instance
Expression locKey = new Local(keyType);
for( int i = 0; i < len; i++ ) {
Expression x = expressions[i];
Field f = (Field) members[i];
inner.Statements.Add(new AssignmentStatement(new MemberBinding(locKey, f), x));
}
inner.Statements.Add(new AssignmentStatement(new MemberBinding(locKey, fRow), this.Box(feTarget)));
// add key to the list
Method madd = SystemTypes.ArrayList.GetMethod(StandardIds.Add, SystemTypes.Object);
MethodCall mcAdd = new MethodCall(new MemberBinding(locList, madd), new ExpressionList(this.Box(locKey)));
mcAdd.Type = madd.ReturnType;
inner.Statements.Add(new ExpressionStatement(mcAdd));
// sort the list, now outside original foreach
Method mthSort = SystemTypes.ArrayList.GetMethod(Identifier.For("Sort"), SystemTypes.IComparer);
Construct consc = new Construct();
consc.Constructor = new MemberBinding(null, this.GetTypeView(comparerType).GetConstructor());
consc.Type = comparerType;
MethodCall mcSort = new MethodCall(new MemberBinding(locList, mthSort), new ExpressionList(consc));
mcSort.Type = mthSort.ReturnType;
block.Statements.Add(new ExpressionStatement(mcSort));
// now iterate over sorted results
block.Statements.Add(this.BuildClosureForEach(locList, ref locKey, out inner, scope));
// get row out of key
inner.Statements.Add(new Yield(this.Unbox(new MemberBinding(locKey, fRow), feTarget.Type)));
return this.EndQueryClosure(closure, qo.Type);
}
public virtual Node VisitQueryOrderBy(QueryOrderBy orderby, QueryOrderBy changes, QueryOrderBy deletions, QueryOrderBy insertions){
this.UpdateSourceContext(orderby, changes);
if (orderby == null) return changes;
return orderby;
}
public EventingVisitor(Action<QueryOrderBy> visitQueryOrderBy) { VisitedQueryOrderBy += visitQueryOrderBy; } public event Action<QueryOrderBy> VisitedQueryOrderBy; public override Node VisitQueryOrderBy(QueryOrderBy orderby) { if (VisitedQueryOrderBy != null) VisitedQueryOrderBy(orderby); return base.VisitQueryOrderBy(orderby); }
