public override void PropagateUpdate(IExecutionContext context, List <Fact> facts)
{
var aggregationContext = new AggregationContext(context, NodeInfo);
var joinedSets = JoinedSets(context, facts);
var aggregation = new Aggregation();
foreach (var set in joinedSets)
{
if (set.Facts.Count == 0)
{
continue;
}
var matchingFacts = set.Facts;
if (matchingFacts.Count > 0)
{
IFactAggregator aggregator = GetFactAggregator(set.Tuple);
if (aggregator != null)
{
UpdateInAggregate(aggregationContext, aggregator, aggregation, set.Tuple, matchingFacts);
}
else
{
var fullSet = JoinedSet(context, set.Tuple);
var allMatchingFacts = fullSet.Facts;
aggregator = CreateFactAggregator(fullSet.Tuple);
AddToAggregate(aggregationContext, aggregator, aggregation, fullSet.Tuple, allMatchingFacts);
}
}
}
PropagateAggregation(context, aggregation);
}
public override void PropagateUpdate(IExecutionContext context, List <Tuple> tuples)
{
var aggregationContext = new AggregationContext(context, NodeInfo);
var joinedSets = JoinedSets(context, tuples);
var aggregation = new Aggregation();
foreach (var set in joinedSets)
{
IFactAggregator aggregator = GetFactAggregator(set.Tuple);
if (aggregator != null)
{
if (_isSubnetJoin && set.Facts.Count > 0)
{
//Update already propagated from the right
continue;
}
var matchingFacts = set.Facts;
UpdateInAggregate(aggregationContext, aggregator, aggregation, set.Tuple, matchingFacts);
}
else
{
var matchingFacts = set.Facts;
aggregator = CreateFactAggregator(set.Tuple);
AddToAggregate(aggregationContext, aggregator, aggregation, set.Tuple, matchingFacts);
}
}
PropagateAggregation(context, aggregation);
}
public IEnumerable <AggregationResult> Modify(AggregationContext context, ITuple tuple, IEnumerable <IFact> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var collection = (IEnumerable <TElement>)fact.Value;
foreach (var value in collection)
{
if (_firstElements.TryGetValue(fact, out var oldFirst))
{
if (Equals(oldFirst, value))
{
results.Add(AggregationResult.Modified(value, value, Enumerable.Repeat(fact, 1)));
}
else
{
results.Add(AggregationResult.Removed(oldFirst));
results.Add(AggregationResult.Added(value, Enumerable.Repeat(fact, 1)));
}
}
else
{
results.Add(AggregationResult.Added(value, Enumerable.Repeat(fact, 1)));
}
_firstElements[fact] = value;
break;
}
}
return(results);
}
public override void PropagateAssert(IExecutionContext context, List <Fact> facts)
{
var aggregationContext = new AggregationContext(context, NodeInfo);
var joinedSets = JoinedSets(context, facts);
var aggregation = new Aggregation();
foreach (var set in joinedSets)
{
if (set.Facts.Count == 0)
{
continue;
}
var matchingFacts = set.Facts;
if (matchingFacts.Count > 0)
{
IFactAggregator aggregator = GetFactAggregator(set.Tuple);
if (aggregator == null)
{
aggregator = CreateFactAggregator(set.Tuple);
var originalSet = JoinedSet(context, set.Tuple);
var matchingOriginalFacts = originalSet.Facts;
AddToAggregate(aggregationContext, aggregator, aggregation, originalSet.Tuple, matchingOriginalFacts);
}
AddToAggregate(aggregationContext, aggregator, aggregation, set.Tuple, matchingFacts);
}
}
PropagateAggregation(context, aggregation);
}
public override void PropagateRetract(IExecutionContext context, List <Fact> facts)
{
var aggregationContext = new AggregationContext(context, NodeInfo);
var aggregation = new Aggregation();
using (var counter = PerfCounter.Retract(context, this))
{
var joinedSets = JoinedSets(context, facts);
foreach (var set in joinedSets)
{
if (set.Facts.Count == 0)
{
continue;
}
IFactAggregator aggregator = GetFactAggregator(context, set.Tuple);
if (aggregator != null)
{
RetractFromAggregate(aggregationContext, aggregator, aggregation, set.Tuple, set.Facts);
}
}
counter.AddInputs(facts.Count);
counter.AddOutputs(aggregation.Count);
}
PropagateAggregation(context, aggregation);
}
public override void PropagateAssert(IExecutionContext context, List <Fact> facts)
{
var aggregationContext = new AggregationContext(context, NodeInfo);
var aggregation = new Aggregation();
using (var counter = PerfCounter.Assert(context, this))
{
var joinedSets = JoinedSets(context, facts);
foreach (var set in joinedSets)
{
if (set.Facts.Count == 0)
{
continue;
}
IFactAggregator aggregator = GetFactAggregator(context, set.Tuple);
if (aggregator == null)
{
aggregator = CreateFactAggregator(context, set.Tuple);
var originalSet = JoinedSet(context, set.Tuple);
var matchingOriginalFacts = originalSet.Facts;
AddToAggregate(aggregationContext, aggregator, aggregation, originalSet.Tuple, matchingOriginalFacts);
}
AddToAggregate(aggregationContext, aggregator, aggregation, set.Tuple, set.Facts);
}
counter.AddInputs(facts.Count);
counter.AddOutputs(aggregation.Count);
}
PropagateAggregation(context, aggregation);
}
public IQueryable <Customer> Get()
{
ResetDataSource();
var db = new AggregationContext();
return(db.Customers);
}
public GuiHost(List<AControl> controls,
AggregationContext aggregationContext,
ITransition transition)
: base()
{
this.controls = controls;
this.aggregationContext = aggregationContext;
this.Transition = transition;
this.ScreenState = ScreenState.Exit;
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])
{
CreateSubQuery = true
});
if (sequence.SelectQuery.Select.IsDistinct ||
sequence.SelectQuery.Select.TakeValue != null ||
sequence.SelectQuery.Select.SkipValue != null ||
!sequence.SelectQuery.GroupBy.IsEmpty)
{
sequence = new SubQueryContext(sequence);
}
if (sequence.SelectQuery.OrderBy.Items.Count > 0)
{
if (sequence.SelectQuery.Select.TakeValue == null && sequence.SelectQuery.Select.SkipValue == null)
{
sequence.SelectQuery.OrderBy.Items.Clear();
}
else
{
sequence = new SubQueryContext(sequence);
}
}
var context = new AggregationContext(buildInfo.Parent, sequence, methodCall);
var methodName = methodCall.Method.Name.Replace("Async", "");
var sql = sequence.ConvertToSql(null, 0, ConvertFlags.Field).Select(_ => _.Sql).ToArray();
if (sql.Length == 1 && sql[0] is SelectQuery query)
{
if (query.Select.Columns.Count == 1)
{
var join = query.OuterApply();
context.SelectQuery.From.Tables[0].Joins.Add(join.JoinedTable);
sql[0] = query.Select.Columns[0];
}
}
ISqlExpression sqlExpression = new SqlFunction(methodCall.Type, methodName, true, sql);
if (sqlExpression == null)
{
throw new LinqToDBException("Invalid Aggregate function implementation");
}
context.Sql = context.SelectQuery;
context.FieldIndex = context.SelectQuery.Select.Add(sqlExpression, methodName);
return(context);
}
public IEnumerable <AggregationResult> Remove(AggregationContext context, ITuple tuple, IEnumerable <IFact> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var oldValue = _sourceToValue[fact];
_sourceToValue.Remove(fact);
results.Add(AggregationResult.Removed(oldValue));
}
return(results);
}
public IEnumerable <AggregationResult> Add(AggregationContext context, ITuple tuple, IEnumerable <IFact> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var value = _selector.Invoke(context, tuple, fact);
_sourceToValue[fact] = value;
results.Add(AggregationResult.Added(value, Enumerable.Repeat(fact, 1)));
}
return(results);
}
public IEnumerable <AggregationResult> Remove(AggregationContext context, ITuple tuple, IEnumerable <IFact> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
if (_firstElements.TryGetValue(fact, out var oldFirst))
{
results.Add(AggregationResult.Removed(oldFirst));
_firstElements.Remove(fact);
}
}
return(results);
}
public override void PropagateAssert(IExecutionContext context, List <Tuple> tuples)
{
var aggregationContext = new AggregationContext(context, NodeInfo);
var joinedSets = JoinedSets(context, tuples);
var aggregation = new Aggregation();
foreach (var set in joinedSets)
{
var matchingFacts = set.Facts;
IFactAggregator aggregator = CreateFactAggregator(set.Tuple);
AddToAggregate(aggregationContext, aggregator, aggregation, set.Tuple, matchingFacts);
}
PropagateAggregation(context, aggregation);
}
protected override IParseContext ParseMethodCall(ExpressionParser parser, IParseContext parent, MethodCallExpression methodCall, SqlQuery sqlQuery)
{
var sequence = parser.ParseSequence(parent, methodCall.Arguments[0], sqlQuery);
if (sequence.SqlQuery.Select.IsDistinct || sequence.SqlQuery.Select.TakeValue != null || sequence.SqlQuery.Select.SkipValue != null)
{
//sequence.ConvertToIndex(null, 0, ConvertFlags.All);
sequence = new SubQueryContext(sequence);
}
if (sequence.SqlQuery.OrderBy.Items.Count > 0)
{
if (sequence.SqlQuery.Select.TakeValue == null && sequence.SqlQuery.Select.SkipValue == null)
{
sequence.SqlQuery.OrderBy.Items.Clear();
}
else
{
sequence = new SubQueryContext(sequence);
}
}
if (methodCall.Arguments.Count == 2)
{
var lambda = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var context = new AggregationContext(sequence, lambda, methodCall.Method.ReturnType);
context.FieldIndex = context.SqlQuery.Select.Add(
new SqlFunction(
methodCall.Type,
methodCall.Method.Name,
parser.ParseExpression(context, context.Lambda.Body.Unwrap())));
return(context);
}
else
{
var context = new AggregationContext(sequence, null, methodCall.Method.ReturnType);
context.FieldIndex = context.SqlQuery.Select.Add(
new SqlFunction(
methodCall.Type,
methodCall.Method.Name,
sequence.ConvertToSql(null, 0, ConvertFlags.Field).Select(_ => _.Sql).ToArray()));
return(context);
}
}
private void RetractFromAggregate(AggregationContext context, IFactAggregator aggregator, Aggregation aggregation, Tuple tuple, List <Fact> facts)
{
try
{
aggregator.Remove(context, aggregation, tuple, facts);
}
catch (ExpressionEvaluationException e)
{
if (!e.IsHandled)
{
throw new RuleLhsExpressionEvaluationException("Failed to evaluate aggregate expression",
e.Expression.ToString(), e.InnerException);
}
ResetAggregator(aggregation, tuple, aggregator);
}
}
public IEnumerable <AggregationResult> Add(AggregationContext context, ITuple tuple, IEnumerable <IFact> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var collection = (IEnumerable <TElement>)fact.Value;
foreach (var value in collection)
{
_firstElements[fact] = value;
results.Add(AggregationResult.Added(value, Enumerable.Repeat(fact, 1)));
break;
}
}
return(results);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall,
BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
if (sequence.Select.Select.IsDistinct ||
sequence.Select.Select.TakeValue != null ||
sequence.Select.Select.SkipValue != null ||
!sequence.Select.GroupBy.IsEmpty)
{
sequence = new SubQueryContext(sequence);
}
if (sequence.Select.OrderBy.Items.Count > 0)
{
if (sequence.Select.Select.TakeValue == null && sequence.Select.Select.SkipValue == null)
{
sequence.Select.OrderBy.Items.Clear();
}
else
{
sequence = new SubQueryContext(sequence);
}
}
var context = new AggregationContext(buildInfo.Parent, sequence, methodCall);
var sql = sequence.ConvertToSql(null, 0, ConvertFlags.Field).Select(_ => _.Sql).ToArray();
if (sql.Length == 1 && sql[0] is ISelectQuery)
{
var query = (ISelectQuery)sql[0];
if (query.Select.Columns.Count == 1)
{
var join = SelectQuery.OuterApply(query);
context.Select.From.Tables.First.Value.Joins.AddLast(join.JoinedTable);
sql[0] = query.Select.Columns[0];
}
}
context.Sql = context.Select;
context.FieldIndex = context.Select.Select.Add(
new SqlFunction(methodCall.Type, methodCall.Method.Name, sql));
return(context);
}
static async Task Main(string[] args)
{
var store = new InMemoryStorage();
store.Add("123", new User {
Name = "ABC", Email = "*****@*****.**", Id = "123"
});
Console.WriteLine(store.Get <User>("123"));
var aggregationContext = new AggregationContext(Assembly.GetExecutingAssembly(), store);
await aggregationContext.SendAsync <User, NameUpdate>(new NameUpdate { Name = "ABCD", Id = "123" });
Console.WriteLine(store.Get <User>("123"));
Console.ReadLine();
}
public override void PropagateAssert(IExecutionContext context, List <Tuple> tuples)
{
var aggregationContext = new AggregationContext(context, NodeInfo);
var aggregation = new Aggregation();
using (var counter = PerfCounter.Assert(context, this))
{
var joinedSets = JoinedSets(context, tuples);
foreach (var set in joinedSets)
{
IFactAggregator aggregator = CreateFactAggregator(context, set.Tuple);
AddToAggregate(aggregationContext, aggregator, aggregation, set.Tuple, set.Facts);
}
counter.AddInputs(tuples.Count);
counter.AddOutputs(aggregation.Count);
}
PropagateAggregation(context, aggregation);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
if (sequence.SqlQuery != buildInfo.SqlQuery)
{
throw new NotImplementedException();
}
if (sequence.SqlQuery.Select.IsDistinct ||
sequence.SqlQuery.Select.TakeValue != null ||
sequence.SqlQuery.Select.SkipValue != null ||
!sequence.SqlQuery.GroupBy.IsEmpty)
{
sequence = new SubQueryContext(sequence);
}
if (sequence.SqlQuery.OrderBy.Items.Count > 0)
{
if (sequence.SqlQuery.Select.TakeValue == null && sequence.SqlQuery.Select.SkipValue == null)
{
sequence.SqlQuery.OrderBy.Items.Clear();
}
else
{
sequence = new SubQueryContext(sequence);
}
}
//var index = sequence.ConvertToIndex(null, 0, ConvertFlags.Field);
var context = new AggregationContext(buildInfo.Parent, sequence, null, methodCall.Method.ReturnType);
context.FieldIndex = context.SqlQuery.Select.Add(
new SqlFunction(
methodCall.Type,
methodCall.Method.Name,
sequence.ConvertToSql(null, 0, ConvertFlags.Field).Select(_ => _.Sql).ToArray()));
return(context);
}
public override void PropagateRetract(IExecutionContext context, List <Fact> facts)
{
var aggregationContext = new AggregationContext(context, NodeInfo);
var joinedSets = JoinedSets(context, facts);
var aggregation = new Aggregation();
foreach (var set in joinedSets)
{
if (set.Facts.Count == 0)
{
continue;
}
var matchingFacts = set.Facts;
if (matchingFacts.Count > 0)
{
IFactAggregator aggregator = GetFactAggregator(set.Tuple);
if (aggregator != null)
{
RetractFromAggregate(aggregationContext, aggregator, aggregation, set.Tuple, set.Facts);
}
}
}
PropagateAggregation(context, aggregation);
}
public object Invoke(AggregationContext context, ITuple tuple, IFact fact)
{
return(_func((TFact)fact.Value));
}
public WebAnalyticsServiceAppWrapper(SPWebApplication webApp)
{
aggregationContext = AggregationContext.GetContext(webApp);
}
public WebAnalyticsServiceAppWrapper(SPSite site)
{
aggregationContext = AggregationContext.GetContext(site);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])
{
CreateSubQuery = true
});
if (sequence.SelectQuery.Select.IsDistinct ||
sequence.SelectQuery.Select.TakeValue != null ||
sequence.SelectQuery.Select.SkipValue != null ||
!sequence.SelectQuery.GroupBy.IsEmpty)
{
sequence = new SubQueryContext(sequence);
}
if (sequence.SelectQuery.OrderBy.Items.Count > 0)
{
if (sequence.SelectQuery.Select.TakeValue == null && sequence.SelectQuery.Select.SkipValue == null)
{
sequence.SelectQuery.OrderBy.Items.Clear();
}
else
{
sequence = new SubQueryContext(sequence);
}
}
var context = new AggregationContext(buildInfo.Parent, sequence, methodCall);
var attr = GetAggregateDefinition(methodCall, builder.MappingSchema);
ISqlExpression sqlExpression = null;
if (attr != null)
{
sqlExpression = attr.GetExpression(builder.MappingSchema, sequence.SelectQuery, methodCall, e =>
{
var ex = e.Unwrap();
var l = ex as LambdaExpression;
if (l != null)
{
var p = sequence.Parent;
var ctx = new ExpressionContext(buildInfo.Parent, sequence, l);
var res = builder.ConvertToSql(ctx, l.Body, true);
builder.ReplaceParent(ctx, p);
return(res);
}
return(builder.ConvertToSql(context, ex, true));
});
}
if (sqlExpression == null)
{
var sql = sequence.ConvertToSql(null, 0, ConvertFlags.Field).Select(_ => _.Sql).ToArray();
if (sql.Length == 1 && sql[0] is SelectQuery)
{
var query = (SelectQuery)sql[0];
if (query.Select.Columns.Count == 1)
{
var join = query.OuterApply();
context.SelectQuery.From.Tables[0].Joins.Add(join.JoinedTable);
sql[0] = query.Select.Columns[0];
}
}
if (attr != null)
{
sqlExpression = attr.GetExpression(methodCall.Method, sql);
}
else
{
sqlExpression = new SqlFunction(methodCall.Type, methodCall.Method.Name, true, sql);
}
}
if (sqlExpression == null)
{
throw new LinqToDBException("Invalid Aggregate function implementation");
}
context.Sql = context.SelectQuery;
context.FieldIndex = context.SelectQuery.Select.Add(sqlExpression, methodCall.Method.Name);
return(context);
}
public void Remove(AggregationContext context, Aggregation aggregation, Tuple tuple, IEnumerable <Fact> facts)
{
var results = _aggregator.Remove(context, tuple, facts);
AddAggregationResult(aggregation, tuple, results);
}
