private KeyValuePair <string, object> Fetch(AggregateOperand source)
{
var basePropertyOperand = source.CollectionProperty;
var subPropertyOperator = source.Condition;
var binaryOperator = subPropertyOperator as BinaryOperator;
if (binaryOperator != null)
{
var subPropertyFetchingResult = Fetch(binaryOperator);
var basePropertyName = basePropertyOperand.PropertyName;
var subPropertyName = subPropertyFetchingResult.Key;
var propertyName = basePropertyName + "." + subPropertyName;
var propertyValue = subPropertyFetchingResult.Value;
return(new KeyValuePair <string, object>(propertyName, propertyValue));
}
return(new KeyValuePair <string, object>());
}
public object Visit(AggregateOperand theOperand)
{
if(theOperand.AggregateType == Aggregate.Exists){
return BooleanCriteriaStateObject.Logical;
}
return BooleanCriteriaStateObject.Value;
}
private bool ProcessSingleAggregate(MemberExpression node)
{
AggregateOperand singleAggregate = ExtractSingleAggregate(node);
singleAggregate.AggregatedExpression = new OperandProperty(node.Member.Name);
Result = singleAggregate;
return(true);
}
protected virtual CriteriaOperator VisitAggregate(AggregateOperand theOperand)
{
CriteriaOperator aggregatedExpression = this.AcceptOperator(theOperand.AggregatedExpression);
CriteriaOperator condition = this.AcceptOperator(theOperand.Condition);
if (object.ReferenceEquals(theOperand.AggregatedExpression, aggregatedExpression) &&
object.ReferenceEquals(theOperand.Condition, condition))
{
return(theOperand);
}
return(new AggregateOperand(theOperand.CollectionProperty, aggregatedExpression, theOperand.AggregateType, condition));
}
private AggregateOperand ExtractSingleAggregate(MemberExpression node)
{
AggregateOperand singleAggregate = ExtractOperand(node.Expression) as AggregateOperand;
if (IsNull(singleAggregate) || singleAggregate.AggregateType != Aggregate.Single)
{
string msg = string.Format(CultureInfo.CurrentCulture, Resources.ExpressionNotSupportedException, node);
throw new NotSupportedException(msg);
}
return(singleAggregate);
}
public virtual CriteriaOperator Visit(AggregateOperand theOperand)
{
OperandProperty operand = theOperand.CollectionProperty.Accept(this) as OperandProperty;
CriteriaOperator condition = theOperand.Condition.Accept(this) as CriteriaOperator;
CriteriaOperator expression = theOperand.AggregatedExpression.Accept(this) as CriteriaOperator;
if (object.ReferenceEquals(condition, null) || object.ReferenceEquals(expression, null) || object.ReferenceEquals(operand, null))
{
return(null);
}
return(new AggregateOperand(operand, expression, theOperand.AggregateType, condition));
}
object IClientCriteriaVisitor <object> .Visit(AggregateOperand operand)
{
Process(operand);
AggregateLevel++;
if (!ReferenceEquals(operand.AggregatedExpression, null))
{
operand.AggregatedExpression.Accept(this);
}
if (!ReferenceEquals(operand.CollectionProperty, null))
{
operand.CollectionProperty.Accept(this);
}
AggregateLevel--;
return(null);
}
public override CriteriaOperator Visit(AggregateOperand theOperand)
{
CriteriaOperator collectionProperty = Visit(theOperand.CollectionProperty);
if (IsNull(collectionProperty))
{
return(null);
}
CriteriaOperator patched = base.Visit(theOperand);
if (object.ReferenceEquals(theOperand, patched))
{
return(theOperand);
}
return(null);
}
/*
* AND
* Human Case ID = 'AAA'
* Human Case ID = 'BBB'
* Exists Human Case Test
* AND
* Human case Test Type = 6618590000000 ('Anaplasma test')
*/
private void CreateFilterCondition1(QueryFilterControl filter, out GroupOperator rootGroup, out GroupOperator aggrGroup)
{
CriteriaOperator criteria;
rootGroup = QueryFilterControl.AddGroupOperator(null, null, null, out criteria);
QueryFilterControl.AddFieldOperator(rootGroup, CaseIDAlias, StrValue1, SearchOperator.Binary, BinaryOperatorType.Equal, false);
QueryFilterControl.AddFieldOperator(rootGroup, CaseIDAlias, StrValue2, SearchOperator.Binary, BinaryOperatorType.Equal, false);
AggregateOperand aggrOp = QueryFilterControl.AddAggregateOperand(rootGroup, "<Human Case Test>", false);
CriteriaOperator aggrCriteria;
aggrGroup = QueryFilterControl.AddGroupOperator(null, null, null, out aggrCriteria);
QueryFilterControl.AddFieldOperator(aggrGroup, TestNameAlias, TestNameIdValue, SearchOperator.Binary, BinaryOperatorType.Equal,
false);
aggrOp.Condition = aggrCriteria;
filter.FilterCriteria = criteria;
filter.HasChanges = true;
}
private AggregateOperand BuildAggregation(Expression collectionProperty, Expression aggregationExpression,
Expression condition, Aggregate aggregationType)
{
CriteriaOperator @operator = ExtractOperand(collectionProperty);
OperandProperty collection = @operator as OperandProperty;
if (!IsNull(collection))
{
return(new AggregateOperand(collection, ExtractOperand(aggregationExpression), aggregationType, ExtractOperand(condition)));
}
AggregateOperand aggregation = @operator as AggregateOperand;
if (!IsNull(aggregation))
{
aggregation.AggregatedExpression = ExtractOperand(aggregationExpression);
aggregation.AggregateType = aggregationType;
return(aggregation);
}
string msg = string.Format(CultureInfo.CurrentCulture, Resources.CollectionPropertyAbsentException, collectionProperty);
throw new NotSupportedException(msg);
}
public void GetSummaryValues(GridViewCustomBindingGetSummaryValuesArgs e)
{
XPView data = new XPView(Session, ClassInfo);
data.Criteria = CriteriaOperator.Parse(e.FilterExpression) & GetGroupFilter(e.GroupInfoList);
foreach (GridViewSummaryItemState summaryItem in e.SummaryItems)
{
Aggregate aggregateType = GetAggregateType(summaryItem.SummaryType);
CriteriaOperator aggregatedExpression = new OperandProperty(summaryItem.FieldName);
CriteriaOperator property = new AggregateOperand(null, aggregatedExpression, aggregateType, null);
string name = string.Concat(summaryItem.FieldName, summaryItem.SummaryType);
data.AddProperty(name, property);
}
ArrayList result = new ArrayList();
ViewRecord rec = data[0];
for (int i = 0; i < data.Properties.Count; i++)
{
result.Add(rec[i]);
}
e.Data = result;
}
private static IObservable <Unit> PositionNewObjects(this IObservable <XafApplication> whenApplication)
=> whenApplication.SelectMany(application => application.WhenObjectSpaceCreated().SelectMany(t => t.e.ObjectSpace.WhenNewObjectCommiting <object>().Pair(t.e.ObjectSpace))
.Do(t => {
var modelPositionInListView = application.Model.ModelPositionInListView();
var listViewItems = modelPositionInListView.ListViewItems;
if (listViewItems.Any())
{
var objectType = t.source.GetType();
var listViewItem = listViewItems.FirstOrDefault(item => item.ListView.ModelClass.TypeInfo.Type == objectType);
if (listViewItem != null)
{
var modelClassItem = modelPositionInListView.ModelClassItems
.FirstOrDefault(item => item.ModelClass.TypeInfo.Type == objectType && item.ModelMember == listViewItem.PositionMember);
var aggregate = Aggregate.Max;
if (modelClassItem != null && modelClassItem.NewObjectsStrategy == PositionInListViewNewObjectsStrategy.First)
{
aggregate = Aggregate.Min;
}
var memberInfo = listViewItem.PositionMember.MemberInfo;
var aggregateOperand = new AggregateOperand("", memberInfo.Name, aggregate);
var value = (int)(t.other.Evaluate(objectType, aggregateOperand, null) ?? 0);
var allValues = t.other.ModifiedObjects.Cast <object>().Select(o => memberInfo.GetValue(o) ?? 0).Cast <int>().Add(value);
if (aggregate == Aggregate.Max)
{
value = allValues.Max();
value++;
}
else
{
value = allValues.Min();
value--;
}
memberInfo.SetValue(t.source, value);
}
}
}))
.TracePositionInListView(_ => $"{_.source}")
.ToUnit();
/// <summary>
/// The UpdateSummation.
/// </summary>
/// <returns>The <see cref="MemberRubrics"/>.</returns>
public MemberRubrics UpdateSummation()
{
AggregateOperand parsed = new AggregateOperand();
summaryRubrics = new MemberRubrics();
Figure summaryFigure = new Figure(figures.Rubrics.AsValues().Where(c =>
(c.RubricName.Split('=').Length > 1 ||
(c.SummaryOperand != AggregateOperand.None))).Select(c =>
(new MemberRubric(c)
{
SummaryRubric = (c.SummaryRubric != null) ? c.SummaryRubric :
(c.RubricName.Split('=').Length > 1) ?
new MemberRubric(c)
{
RubricName = c.RubricName.Split('=')[1]
} : null,
SummaryOperand = (Enum.TryParse(c.RubricName.Split('=')[0], true, out parsed)) ? parsed : c.SummaryOperand
})).ToArray(), "Summary_" + figures.GetType().Name);
figures.Summary = summaryFigure.Combine();
summaryRubrics = (MemberRubrics)summaryFigure.Rubrics;
return(summaryRubrics);
}
public virtual object Visit(AggregateOperand theOperand)
{
if(theOperand.IsTopLevel)
throw new InvalidOperationException("can't evaluate top level aggregate on single objct, collection property expected");
Validate(theOperand.CollectionProperty);
return null;
}
public object Visit(AggregateOperand theOperand)
{
return(theOperand);
}
private string ProcessAggregateOperand(AggregateOperand aggregateOperand, string alias)
{
var aggregateOperandAlias = ProcessOperandProperty(aggregateOperand.CollectionProperty, alias);
return InterpritateFilter(aggregateOperand.Condition, aggregateOperandAlias);
}
public object Visit(AggregateOperand theOperand)
{
return evaluatorCore.Visit(theOperand);
}
CriteriaOperator IClientCriteriaVisitor <CriteriaOperator> .Visit(AggregateOperand theOperand)
{
return(this.VisitAggregate(theOperand));
}
protected virtual void Process(AggregateOperand operand)
{
}
private void btnFiterStandard_Click(object sender, System.EventArgs e)
{
CriteriaOperator criteria = new AggregateOperand("Orders", Aggregate.Count) > 0;
SetFilter(criteria);
}
private string ProcessAggregateOperand(AggregateOperand aggregateOperand, string alias)
{
var aggregateOperandAlias = ProcessOperandProperty(aggregateOperand.CollectionProperty, alias);
return(InterpritateFilter(aggregateOperand.Condition, aggregateOperandAlias));
}
Object yyparse (yyInput yyLex) {
if (yyMax <= 0) yyMax = 256;
int yyState = 0;
int [] yyStates = new int[yyMax];
Object yyVal = null;
Object [] yyVals = new Object[yyMax];
int yyToken = -1;
int yyErrorFlag = 0;
int yyTop = 0;
goto skip;
yyLoop:
yyTop++;
skip:
for(;; ++yyTop) {
if(yyTop >= yyStates.Length) {
int[] i = new int[yyStates.Length + yyMax];
yyStates.CopyTo(i, 0);
yyStates = i;
Object[] o = new Object[yyVals.Length + yyMax];
yyVals.CopyTo(o, 0);
yyVals = o;
}
yyStates[yyTop] = yyState;
yyVals[yyTop] = yyVal;
yyDiscarded:
for(;;) {
int yyN;
if ((yyN = yyDefRed[yyState]) == 0) {
if(yyToken < 0)
yyToken = yyLex.advance() ? yyLex.token() : 0;
if((yyN = yySindex[yyState]) != 0 && ((yyN += yyToken) >= 0)
&& (yyN < yyTable.Length) && (yyCheck[yyN] == yyToken)) {
yyState = yyTable[yyN];
yyVal = yyLex.value();
yyToken = -1;
if (yyErrorFlag > 0) -- yyErrorFlag;
goto yyLoop;
}
if((yyN = yyRindex[yyState]) != 0 && (yyN += yyToken) >= 0
&& yyN < yyTable.Length && yyCheck[yyN] == yyToken)
yyN = yyTable[yyN];
else
switch(yyErrorFlag) {
case 0:
yyerror("syntax error");
goto case 1;
case 1: case 2:
yyErrorFlag = 3;
do {
if((yyN = yySindex[yyStates[yyTop]]) != 0
&& (yyN += Token.yyErrorCode) >= 0 && yyN < yyTable.Length
&& yyCheck[yyN] == Token.yyErrorCode) {
yyState = yyTable[yyN];
yyVal = yyLex.value();
goto yyLoop;
}
} while (--yyTop >= 0);
yyerror("irrecoverable syntax error");
goto yyDiscarded;
case 3:
if (yyToken == 0)
yyerror("irrecoverable syntax error at end-of-file");
yyToken = -1;
goto yyDiscarded;
}
}
int yyV = yyTop + 1 - yyLen[yyN];
yyVal = yyV > yyTop ? null : yyVals[yyV];
switch(yyN) {
case 1:
#line 54 "grammar.y"
{ result = new CriteriaOperator[0]; }
break;
case 2:
#line 55 "grammar.y"
{ result = ((List<CriteriaOperator>)yyVals[-1+yyTop]).ToArray(); }
break;
case 3:
#line 59 "grammar.y"
{ yyVal = new List<CriteriaOperator>(new CriteriaOperator[] {(CriteriaOperator)yyVals[0+yyTop]}); }
break;
case 4:
#line 60 "grammar.y"
{ yyVal = yyVals[-2+yyTop]; ((List<CriteriaOperator>)yyVal).Add((CriteriaOperator)yyVals[0+yyTop]); }
break;
case 5:
#line 64 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 6:
#line 65 "grammar.y"
{
OperandProperty prop2 = (OperandProperty)yyVals[-2+yyTop];
OperandProperty prop4 = (OperandProperty)yyVals[0+yyTop];
prop2.PropertyName = '<' + prop2.PropertyName + '>' + prop4.PropertyName;
yyVal = prop2;
}
break;
case 7:
#line 74 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 8:
#line 75 "grammar.y"
{ yyVal = new OperandProperty("^"); }
break;
case 9:
#line 79 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 10:
#line 80 "grammar.y"
{
OperandProperty prop1 = (OperandProperty)yyVals[-2+yyTop];
OperandProperty prop3 = (OperandProperty)yyVals[0+yyTop];
prop1.PropertyName += '.' + prop3.PropertyName;
yyVal = prop1;
}
break;
case 11:
#line 89 "grammar.y"
{
AggregateOperand agg = (AggregateOperand)yyVals[0+yyTop];
yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-2+yyTop], null, agg.AggregateType, agg.AggregatedExpression);
}
break;
case 12:
#line 93 "grammar.y"
{
AggregateOperand agg = (AggregateOperand)yyVals[0+yyTop];
yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-5+yyTop], (CriteriaOperator)yyVals[-3+yyTop], agg.AggregateType, agg.AggregatedExpression);
}
break;
case 13:
#line 97 "grammar.y"
{
AggregateOperand agg = (AggregateOperand)yyVals[0+yyTop];
yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-4+yyTop], null, agg.AggregateType, agg.AggregatedExpression);
}
break;
case 14:
#line 101 "grammar.y"
{ yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-3+yyTop], (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Exists, null); }
break;
case 15:
#line 102 "grammar.y"
{ yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-2+yyTop], null, Aggregate.Exists, null); }
break;
case 18:
#line 110 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Count, null); }
break;
case 19:
#line 111 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Exists, null); }
break;
case 20:
#line 112 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Count, null); }
break;
case 21:
#line 113 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Exists, null); }
break;
case 22:
#line 114 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Min, null); }
break;
case 23:
#line 115 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Max, null); }
break;
case 24:
#line 116 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Avg, null); }
break;
case 25:
#line 117 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Sum, null); }
break;
case 26:
#line 121 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 27:
#line 122 "grammar.y"
{
string paramName = (string)yyVals[0+yyTop];
if(string.IsNullOrEmpty(paramName)) {
OperandValue param = new OperandValue();
resultParameters.Add(param);
yyVal = param;
} else {
bool paramNotFound = true;
foreach(OperandValue v in resultParameters) {
OperandParameter p = v as OperandParameter;
if(ReferenceEquals(p, null))
continue;
if(p.ParameterName != paramName)
continue;
paramNotFound = false;
resultParameters.Add(p);
yyVal = p;
break;
}
if(paramNotFound) {
OperandParameter param = new OperandParameter(paramName);
resultParameters.Add(param);
yyVal = param;
}
}
}
break;
case 28:
#line 148 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 29:
#line 149 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 30:
#line 150 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Multiply ); }
break;
case 31:
#line 151 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Divide ); }
break;
case 32:
#line 152 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Plus ); }
break;
case 33:
#line 153 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Minus ); }
break;
case 34:
#line 154 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Modulo ); }
break;
case 35:
#line 155 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.BitwiseOr ); }
break;
case 36:
#line 156 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.BitwiseAnd ); }
break;
case 37:
#line 157 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.BitwiseXor ); }
break;
case 38:
#line 158 "grammar.y"
{
yyVal = new UnaryOperator( UnaryOperatorType.Minus, (CriteriaOperator)yyVals[0+yyTop] );
try {
if(yyVals[0+yyTop] is OperandValue) {
OperandValue operand = (OperandValue)yyVals[0+yyTop];
if(operand.Value is Int32) {
operand.Value = -(Int32)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Int64) {
operand.Value = -(Int64)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Double) {
operand.Value = -(Double)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Decimal) {
operand.Value = -(Decimal)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Int16) {
operand.Value = -(Int16)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is SByte) {
operand.Value = -(SByte)operand.Value;
yyVal = operand;
break;
}
}
} catch {}
}
break;
case 39:
#line 191 "grammar.y"
{ yyVal = new UnaryOperator( UnaryOperatorType.Plus, (CriteriaOperator)yyVals[0+yyTop] ); }
break;
case 40:
#line 192 "grammar.y"
{ yyVal = new UnaryOperator( UnaryOperatorType.BitwiseNot, (CriteriaOperator)yyVals[0+yyTop] ); }
break;
case 41:
#line 193 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Equal); }
break;
case 42:
#line 194 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.NotEqual); }
break;
case 43:
#line 195 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Greater); }
break;
case 44:
#line 196 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Less); }
break;
case 45:
#line 197 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.GreaterOrEqual); }
break;
case 46:
#line 198 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.LessOrEqual); }
break;
case 47:
#line 199 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Like); }
break;
case 48:
#line 200 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.Not, new BinaryOperator( (CriteriaOperator)yyVals[-3+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Like)); }
break;
case 49:
#line 201 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.Not, (CriteriaOperator)yyVals[0+yyTop]); }
break;
case 50:
#line 202 "grammar.y"
{ yyVal = GroupOperator.And((CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop]); }
break;
case 51:
#line 203 "grammar.y"
{ yyVal = GroupOperator.Or((CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop]); }
break;
case 52:
#line 204 "grammar.y"
{ yyVal = yyVals[-1+yyTop]; }
break;
case 53:
#line 205 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.IsNull, (CriteriaOperator)yyVals[-2+yyTop]); }
break;
case 54:
#line 206 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.Not, new UnaryOperator(UnaryOperatorType.IsNull, (CriteriaOperator)yyVals[-3+yyTop])); }
break;
case 55:
#line 207 "grammar.y"
{ yyVal = new InOperator((CriteriaOperator)yyVals[-2+yyTop], (IEnumerable<CriteriaOperator>)yyVals[0+yyTop]); }
break;
case 56:
#line 208 "grammar.y"
{ yyVal = new BetweenOperator((CriteriaOperator)yyVals[-6+yyTop], (CriteriaOperator)yyVals[-3+yyTop], (CriteriaOperator)yyVals[-1+yyTop]); }
break;
case 57:
#line 209 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.IsNull, (CriteriaOperator)yyVals[-1+yyTop]); }
break;
case 58:
#line 210 "grammar.y"
{ yyVal = new FunctionOperator(FunctionOperatorType.IsNull, (CriteriaOperator)yyVals[-3+yyTop], (CriteriaOperator)yyVals[-1+yyTop]); }
break;
case 59:
#line 211 "grammar.y"
{ FunctionOperator fo = new FunctionOperator((FunctionOperatorType)yyVals[-1+yyTop], (IEnumerable<CriteriaOperator>)yyVals[0+yyTop]); lexer.CheckFunctionArgumentsCount(fo.OperatorType, fo.Operands.Count); yyVal = fo; }
break;
case 60:
#line 212 "grammar.y"
{ yyVal = null; }
break;
case 61:
#line 216 "grammar.y"
{ yyVal = yyVals[-1+yyTop]; }
break;
case 62:
#line 217 "grammar.y"
{ yyVal = new List<CriteriaOperator>(); }
break;
case 63:
#line 221 "grammar.y"
{
List<CriteriaOperator> lst = new List<CriteriaOperator>();
lst.Add((CriteriaOperator)yyVals[0+yyTop]);
yyVal = lst;
}
break;
case 64:
#line 226 "grammar.y"
{
List<CriteriaOperator> lst = (List<CriteriaOperator>)yyVals[-2+yyTop];
lst.Add((CriteriaOperator)yyVals[0+yyTop]);
yyVal = lst;
}
break;
#line default
}
yyTop -= yyLen[yyN];
yyState = yyStates[yyTop];
int yyM = yyLhs[yyN];
if(yyState == 0 && yyM == 0) {
yyState = yyFinal;
if(yyToken < 0)
yyToken = yyLex.advance() ? yyLex.token() : 0;
if(yyToken == 0)
return yyVal;
goto yyLoop;
}
if(((yyN = yyGindex[yyM]) != 0) && ((yyN += yyState) >= 0)
&& (yyN < yyTable.Length) && (yyCheck[yyN] == yyState))
yyState = yyTable[yyN];
else
yyState = yyDgoto[yyM];
goto yyLoop;
}
}
}
object IClientCriteriaVisitor.Visit(AggregateOperand theOperand)
{
throw new NotImplementedException();
}
object IClientCriteriaVisitor.Visit(AggregateOperand theOperand)
{
if(theOperand.IsTopLevel && !this.contexts[0].Descriptor.IsTopLevelCollectionSource)
throw new InvalidOperationException("can't evaluate top level aggregate on single objct, collection property expected");
EvaluatorContext[] rememberedContexts = this.contexts;
try {
EvaluatorProperty property = theOperand.IsTopLevel ? null : PropertyCache[theOperand.CollectionProperty];
IEnumerable nestedContextsCollection = CreateNestedContext(property);
return DoAggregate(theOperand.AggregateType, nestedContextsCollection, theOperand.Condition, theOperand.AggregatedExpression);
} finally {
this.contexts = rememberedContexts;
}
}
/// <summary>
/// The UpdateAggregation.
/// </summary>
/// <returns>The <see cref="MemberRubrics"/>.</returns>
public MemberRubrics UpdateAggregation()
{
AggregateOperand parsed = new AggregateOperand();
Links targetLinks = figures.Linker.TargetLinks;
aggregateRubrics = new MemberRubrics();
MemberRubric[] _aggregateRubrics = figures.Rubrics.AsValues()
.Where(c => (c.RubricName.Split('#').Length > 1) ||
(c.AggregateRubric != null &&
c.AggregateOperand != AggregateOperand.None) ||
c.AggregateOperand != AggregateOperand.None).ToArray();
foreach (MemberRubric c in _aggregateRubrics)
{
c.AggregateRubric = (c.AggregateRubric != null) ?
c.AggregateRubric :
(c.AggregateOperand != AggregateOperand.None) ?
new MemberRubric(c)
{
RubricName = c.RubricName
} :
new MemberRubric(c)
{
RubricName = c.RubricName.Split('#')[1]
};
c.AggregateOperand = c.AggregateOperand != AggregateOperand.None ?
c.AggregateOperand :
(Enum.TryParse(c.RubricName.Split('#')[0], true, out parsed)) ?
parsed : AggregateOperand.None;
c.AggregateLinkId = (targetLinks.AsValues().Where(cr => cr.Target.Figures.Rubrics.AsValues()
.Where(ct => ct.RubricName == ((c.AggregateRubric != null) ?
c.AggregateRubric.RubricName :
c.RubricName.Split('#')[1])).Any()).Any()) ?
targetLinks.AsValues().Where(cr => cr.Target.Figures.Rubrics.AsValues()
.Where(ct => ct.RubricName == ((c.AggregateRubric != null) ?
c.AggregateRubric.RubricName :
c.RubricName.Split('#')[1])).Any()).ToArray()
.Select(ix => targetLinks.IndexOf(ix)).FirstOrDefault()
: -1;
c.AggregateOrdinal = targetLinks.AsValues().Where(cr => cr.Target.Figures.Rubrics.AsValues()
.Where(ct => ct.RubricName == ((c.AggregateRubric != null) ?
c.AggregateRubric.RubricName :
c.RubricName.Split('#')[1])).Any())
.Select(cr => cr.Target.Figures.Rubrics.AsValues()
.Where(ct => ct.RubricName == ((c.AggregateRubric != null) ?
c.AggregateRubric.RubricName :
c.RubricName.Split('#')[1]))
.Select(o => o.RubricId).FirstOrDefault()).FirstOrDefault();
}
aggregateRubrics.Put(_aggregateRubrics);
aggregateRubrics.AsValues().Where(j => j.AggregateLinkId > -1)
.Select(p => p.AggregateLinks =
new Links(targetLinks.AsCards().Where((x, y) =>
p.AggregateLinkId == x.Index).Select(v => v.Value).ToArray()));
UpdateReplication();
return(aggregateRubrics);
}
public CriteriaOperator Visit(AggregateOperand theOperand)
{
return(theOperand);
}
public override Object Visit(AggregateOperand operand)
{
Object result = null;
if (operand.AggregateType == Aggregate.Count)
{
if (Object.ReferenceEquals(operand.CollectionProperty, null))
{
result = new CriteriaToStringVisitResult("Count(0)");
}
else
{
result = new CriteriaToStringVisitResult(String.Format("Count(select value 1 from {0})", Process(operand.CollectionProperty).Result));
}
}
else if (operand.AggregateType == Aggregate.Sum)
{
if (Object.ReferenceEquals(operand.CollectionProperty, null))
{
result = new CriteriaToStringVisitResult(String.Format("Sum({0})", Process(operand.AggregatedExpression).Result));
}
else
{
String collectionTableName = operand.CollectionProperty.PropertyName;
Xpand.ExpressApp.NH.DataLayer.CriteriaToHqlConverter criteriaToEFSqlConverter = new Xpand.ExpressApp.NH.DataLayer.CriteriaToHqlConverter(collectionTableName, GetListElementType(operand.CollectionProperty.PropertyName));
result = new CriteriaToStringVisitResult(String.Format("Sum(select value {0} from {1} as {2})",
criteriaToEFSqlConverter.Convert(operand.AggregatedExpression),
Process(operand.CollectionProperty).Result,
collectionTableName));
}
}
else if (operand.AggregateType == Aggregate.Exists)
{
String collectionTableName = operand.CollectionProperty.PropertyName;
Xpand.ExpressApp.NH.DataLayer.CriteriaToHqlConverter criteriaToEFSqlConverter = new Xpand.ExpressApp.NH.DataLayer.CriteriaToHqlConverter(collectionTableName, GetListElementType(operand.CollectionProperty.PropertyName));
result = new CriteriaToStringVisitResult(String.Format("Exists(from {0} as {1} where {2})",
Process(operand.CollectionProperty).Result,
collectionTableName,
criteriaToEFSqlConverter.Convert(operand.Condition)));
}
else
{
String resultString = ((CriteriaToStringVisitResult)base.Visit(operand)).Result;
result = new CriteriaToStringVisitResult(resultString.TrimStart('[', ']', '.'));
}
return result;
}
public object Visit(AggregateOperand theOperand){
return theOperand;
}
CriteriaOperator IClientCriteriaVisitor <CriteriaOperator> .Visit(AggregateOperand theOperand)
{
throw new NotImplementedException();
}
private KeyValuePair<string, object> Fetch(AggregateOperand source)
{
var basePropertyOperand = source.CollectionProperty;
var subPropertyOperator = source.Condition;
var binaryOperator = subPropertyOperator as BinaryOperator;
if (binaryOperator != null)
{
var subPropertyFetchingResult = Fetch(binaryOperator);
var basePropertyName = basePropertyOperand.PropertyName;
var subPropertyName = subPropertyFetchingResult.Key;
var propertyName = basePropertyName + "." + subPropertyName;
var propertyValue = subPropertyFetchingResult.Value;
return new KeyValuePair<string, object>(propertyName, propertyValue);
}
return new KeyValuePair<string, object>();
}
public override void Visit(AggregateOperand theOperand)
{
}
protected override void Process(AggregateOperand operand) {
base.Process(operand);
Type collectionElementType = objectTypeInfo.FindMember(operand.CollectionProperty.PropertyName).ListElementType;
Xpand.ExpressApp.NH.ObjectMemberValueCriteriaProcessor aggregatedCriteriaProcessor = new ObjectMemberValueCriteriaProcessor(typesInfo, collectionElementType);
aggregatedCriteriaProcessor.Process(operand.Condition);
}
