/// <summary> /// Populates into the supplied list all aggregation functions within this expression, if any. /// <para /> /// Populates by going bottom-up such that nested aggregates appear first. /// <para /> /// I.e. sum(volume * sum(price)) would put first A then B into the list with A=sum(price) and B=sum(volume * A) /// </summary> /// <param name="topNode">is the expression node to deep inspect</param> /// <param name="aggregateNodes">is a list of node to populate into</param> public static void GetAggregatesBottomUp( ExprNode topNode, IList<ExprAggregateNode> aggregateNodes) { // Map to hold per level of the node (1 to N depth) of expression node a list of aggregation expr nodes, if any // exist at that level var aggregateExprPerLevel = new OrderedListDictionary<int, IList<ExprAggregateNode>>(); RecursiveAggregate(topNode, aggregateExprPerLevel, 1); // Done if none found if (aggregateExprPerLevel.IsEmpty()) { return; } // From the deepest (highest) level to the lowest, add aggregates to list int deepLevel = aggregateExprPerLevel.Last().Key; for (var i = deepLevel; i >= 1; i--) { var list = aggregateExprPerLevel.Get(i); if (list == null) { continue; } aggregateNodes.AddAll(list); } }
public void Run(RegressionEnvironment env) { var fields = "c0".SplitCsv(); var treemap = new OrderedListDictionary <int, IList <SupportBean> >(); var epl = "@Name('s0') select sorted(IntPrimitive).floorEvent(IntPrimitive-1) as c0 from SupportBean#length(3) as sb"; env.EplToModelCompileDeploy(epl).AddListener("s0"); MakeSendBean(env, treemap, "E1", 10); EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] { LessThanOrEqualToFirstEvent(treemap, 10 - 1) }); MakeSendBean(env, treemap, "E2", 20); EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] { LessThanOrEqualToFirstEvent(treemap, 20 - 1) }); env.Milestone(0); MakeSendBean(env, treemap, "E3", 15); EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] { LessThanOrEqualToFirstEvent(treemap, 15 - 1) }); MakeSendBean(env, treemap, "E3", 17); EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] { LessThanOrEqualToFirstEvent(treemap, 17 - 1) }); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var epl = "create table MyTable(sortcol sorted(IntPrimitive) @type('SupportBean'));\n" + "into table MyTable select sorted(*) as sortcol from SupportBean;\n" + "@Name('s0') select " + "MyTable.sortcol.dictionaryReference() as nmr" + " from SupportBean_S0"; env.CompileDeploy(epl).AddListener("s0"); AssertType(env, typeof(IOrderedDictionary <object, object>), "nmr"); var treemap = new OrderedListDictionary <int, IList <SupportBean> >(); PrepareTestData(env, treemap); // 1, 1, 4, 6, 6, 8, 9 env.SendEventBean(new SupportBean_S0(-1)); var @event = env.Listener("s0").AssertOneGetNewAndReset(); var eventDictionary = (IOrderedDictionary <object, ICollection <EventBean> >)@event.Get("nmr"); AssertOrderedDictionary(treemap, eventDictionary); env.UndeployAll(); }
public static FilterSpecPlanPathForge SortRemoveDups(FilterSpecPlanPathForge parameters) { if (parameters.Triplets.Length <= 1) { return parameters; } var map = new OrderedListDictionary<FilterOperator, IList<FilterSpecPlanPathTripletForge>>(COMPARATOR_PARAMETERS); foreach (FilterSpecPlanPathTripletForge parameter in parameters.Triplets) { if (!map.TryGetValue(parameter.Param.FilterOperator, out var list)) { list = new List<FilterSpecPlanPathTripletForge>(); map[parameter.Param.FilterOperator] = list; } var hasDuplicate = list.Any(existing => Equals(existing.Param.Lookupable, parameter.Param.Lookupable)); if (hasDuplicate) { continue; } list.Add(parameter); } var result = new List<FilterSpecPlanPathTripletForge>(); foreach (var entry in map) { result.AddAll(entry.Value); } return new FilterSpecPlanPathForge( result.ToArray(), parameters.PathNegate); }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); var epl = "create table MyTable(sortcol sorted(IntPrimitive) @type('SupportBean'));\n" + "into table MyTable select sorted(*) as sortcol from SupportBean;\n"; env.CompileDeploy(epl, path); env.EplToModelCompileDeploy("@Name('s0') select sortcol.floorEvent(Id) as c0 from SupportBean_S0, MyTable", path) .AddListener("s0"); var treemap = new OrderedListDictionary <int, IList <SupportBean> >(); MakeSendBean(env, treemap, "E1", 10); MakeSendBean(env, treemap, "E2", 20); MakeSendBean(env, treemap, "E3", 30); env.Milestone(0); for (var i = 0; i < 40; i++) { env.SendEventBean(new SupportBean_S0(i)); Assert.AreEqual(LessThanOrEqualToFirstEvent(treemap, i), env.Listener("s0").AssertOneGetNewAndReset().Get("c0")); } env.UndeployAll(); }
/// <summary> /// Given a child URI and a map of factory URIs, inspect the child URI against the factory /// URIs and return a collection of entries for which the child URI falls within or is equals /// to the factory URI. /// </summary> /// <param name="child">is the child URI to match against factory URIs</param> /// <param name="uris">is a map of factory URI and an object</param> /// <returns>matching factory URIs, if any</returns> public static ICollection <KeyValuePair <Uri, V> > FilterSort <V>( Uri child, IDictionary <Uri, V> uris) { var childPathIsOpaque = IsOpaque(child); var childPathIsRelative = !child.IsAbsoluteUri; var childPathElements = ParsePathElements(child); var result = new OrderedListDictionary <int, KeyValuePair <Uri, V> >(); foreach (var entry in uris) { var factoryUri = entry.Key; // handle opaque (mailto:) and relative (a/b) using equals if (childPathIsOpaque || childPathIsRelative || !factoryUri.IsAbsoluteUri || IsOpaque(factoryUri)) { if (factoryUri.Equals(child)) { result.Put(int.MinValue, entry); // Equals is a perfect match } continue; } // handle absolute URIs, compare scheme and authority if present if (((child.Scheme != null) && (factoryUri.Scheme == null)) || ((child.Scheme == null) && (factoryUri.Scheme != null))) { continue; } if ((child.Scheme != null) && (!child.Scheme.Equals(factoryUri.Scheme))) { continue; } if (((child.Authority != null) && (factoryUri.Authority == null)) || ((child.Authority == null) && (factoryUri.Authority != null))) { continue; } if ((child.Authority != null) && (child.Authority != factoryUri.Authority)) { continue; } // Match the child string[] factoryPathElements = ParsePathElements(factoryUri); int score = ComputeScore(childPathElements, factoryPathElements); if (score > 0) { result.Put(score, entry); // Partial match if score is positive } } return(result.Values); }
private static void ReadState( DataInput input, CountMinSketchState state) { var depth = input.ReadInt(); var width = input.ReadInt(); var rowsTable = input.ReadInt(); var table = new long[rowsTable][]; for (var i = 0; i < rowsTable; i++) { var colsRows = input.ReadInt(); table[i] = new long[colsRows]; for (var j = 0; j < colsRows; j++) { table[i][j] = input.ReadLong(); } } var rowsHash = input.ReadInt(); var hash = new long[rowsHash]; for (var i = 0; i < rowsTable; i++) { hash[i] = input.ReadLong(); } var total = input.ReadLong(); state.Hashes = new CountMinSketchStateHashes(depth, width, table, hash, total); var hasTopk = input.ReadBoolean(); state.Topk = null; if (hasTopk) { var topkMax = input.ReadInt(); var topMap = new OrderedListDictionary<long, object>( Comparers.Default<long>().Inverse()); var refMap = new Dictionary<ByteBuffer, long>(); var numRows = input.ReadInt(); for (var i = 0; i < numRows; i++) { var freq = input.ReadLong(); var numEntries = input.ReadInt(); if (numEntries == 1) { var buf = ReadBytes(input); topMap.Put(freq, buf); refMap.Put(buf, freq); } else { Deque<ByteBuffer> q = new ArrayDeque<ByteBuffer>(numEntries); for (var j = 0; j < numEntries; j++) { var buf = ReadBytes(input); q.AddLast(buf); refMap.Put(buf, freq); } topMap.Put(freq, q); } } state.Topk = new CountMinSketchStateTopk(topkMax, topMap, refMap); } }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); var epl = "create table MyTable(sortcol sorted(IntPrimitive) @type('SupportBean'));\n" + "into table MyTable select sorted(*) as sortcol from SupportBean;\n"; env.CompileDeploy(epl, path); var select = "@Name('s0') select " + "MyTable.sortcol as sortedItself, " + "MyTable.sortcol.ceilingEvent(Id) as ce, " + "MyTable.sortcol.ceilingEvents(Id) as ces, " + "MyTable.sortcol.ceilingKey(Id) as ck, " + "MyTable.sortcol.floorEvent(Id) as fe, " + "MyTable.sortcol.floorEvents(Id) as fes, " + "MyTable.sortcol.floorKey(Id) as fk, " + "MyTable.sortcol.higherEvent(Id) as he, " + "MyTable.sortcol.higherEvents(Id) as hes, " + "MyTable.sortcol.higherKey(Id) as hk, " + "MyTable.sortcol.lowerEvent(Id) as le, " + "MyTable.sortcol.lowerEvents(Id) as les, " + "MyTable.sortcol.lowerKey(Id) as lk" + " from SupportBean_S0"; env.EplToModelCompileDeploy(select, path).AddListener("s0"); AssertType(env, typeof(SupportBean), "ce,fe,he,le"); AssertType(env, typeof(SupportBean[]), "ces,fes,hes,les"); AssertType(env, typeof(int?), "ck,fk,hk,lk"); var treemap = new OrderedListDictionary <int, IList <SupportBean> >(); PrepareTestData(env, treemap); // 1, 1, 4, 6, 6, 8, 9 for (var i = 0; i < 12; i++) { env.SendEventBean(new SupportBean_S0(i)); var @event = env.Listener("s0").AssertOneGetNewAndReset(); Assert.AreEqual(FirstEvent(treemap.GreaterThanOrEqualTo(i)), @event.Get("ce")); EPAssertionUtil.AssertEqualsExactOrder(AllEvents(treemap.GreaterThanOrEqualTo(i)), (SupportBean[])@event.Get("ces")); Assert.AreEqual(treemap.GreaterThanOrEqualTo(i)?.Key, @event.Get("ck")); Assert.AreEqual(FirstEvent(treemap.LessThanOrEqualTo(i)), @event.Get("fe")); EPAssertionUtil.AssertEqualsExactOrder(AllEvents(treemap.LessThanOrEqualTo(i)), (SupportBean[])@event.Get("fes")); Assert.AreEqual(treemap.LessThanOrEqualTo(i)?.Key, @event.Get("fk")); Assert.AreEqual(FirstEvent(treemap.GreaterThan(i)), @event.Get("he")); EPAssertionUtil.AssertEqualsExactOrder(AllEvents(treemap.GreaterThan(i)), (SupportBean[])@event.Get("hes")); Assert.AreEqual(treemap.GreaterThan(i)?.Key, @event.Get("hk")); Assert.AreEqual(FirstEvent(treemap.LessThan(i)), @event.Get("le")); EPAssertionUtil.AssertEqualsExactOrder(AllEvents(treemap.LessThan(i)), (SupportBean[])@event.Get("les")); Assert.AreEqual(treemap.LessThan(i)?.Key, @event.Get("lk")); } env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var epl = "@public @buseventtype create schema MySubmapEvent as " + typeof(MySubmapEvent).MaskTypeName() + ";\n" + "create table MyTable(sortcol sorted(IntPrimitive) @type('SupportBean'));\n" + "into table MyTable select sorted(*) as sortcol from SupportBean;\n" + "@Name('s0') select " + "MyTable.sortcol.eventsBetween(FromKey, IsFromInclusive, ToKey, IsToInclusive) as eb," + "MyTable.sortcol.eventsBetween(FromKey, IsFromInclusive, ToKey, IsToInclusive).lastOf() as eblastof," + "MyTable.sortcol.subMap(FromKey, IsFromInclusive, ToKey, IsToInclusive) as sm" + " from MySubmapEvent"; env.CompileDeploy(epl).AddListener("s0"); AssertType(env, typeof(SupportBean[]), "eb"); AssertType(env, typeof(IOrderedDictionary <object, object>), "sm"); AssertType(env, typeof(SupportBean), "eblastof"); var treemap = new OrderedListDictionary <int, IList <SupportBean> >(); PrepareTestData(env, treemap); // 1, 1, 4, 6, 6, 8, 9 for (var start = 0; start < 12; start++) { for (var end = 0; end < 12; end++) { if (start > end) { continue; } foreach (var includeStart in new bool[] { false, true }) { foreach (var includeEnd in new bool[] { false, true }) { var sme = new MySubmapEvent(start, includeStart, end, includeEnd); env.SendEventBean(sme); var @event = env.Listener("s0").AssertOneGetNewAndReset(); var submap = @event.Get("sm") .AsObjectDictionary(MagicMarker.SingletonInstance) .TransformLeft <object, object, SupportBean[]>(); AssertEventsBetween(treemap, sme, (SupportBean[])@event.Get("eb"), (SupportBean)@event.Get("eblastof")); AssertSubmap(treemap, sme, submap); } } } } env.UndeployAll(); }
public IOrderedDictionary <string, V> PrefixMap(string key) { var result = new OrderedListDictionary <string, V>(); foreach (var entry in simple) { if (entry.Key.StartsWith(key)) { result.Put(entry.Key, entry.Value); } } return(result); }
public void Run(RegressionEnvironment env) { var epl = "create table MyTable(sortcol sorted(IntPrimitive) @type('SupportBean'));\n" + "into table MyTable select sorted(*) as sortcol from SupportBean;\n" + "@Name('s0') select " + "MyTable.sortcol.ceilingEvent(Id).TheString as ceid," + "MyTable.sortcol.ceilingEvent(Id).firstOf() as cefo," + "MyTable.sortcol.ceilingEvents(Id).lastOf() as ceslo," + "MyTable.sortcol.floorEvent(Id).TheString as feid," + "MyTable.sortcol.floorEvent(Id).firstOf() as fefo," + "MyTable.sortcol.floorEvents(Id).lastOf() as feslo," + "MyTable.sortcol.higherEvent(Id).TheString as heid," + "MyTable.sortcol.higherEvent(Id).firstOf() as hefo," + "MyTable.sortcol.higherEvents(Id).lastOf() as heslo," + "MyTable.sortcol.lowerEvent(Id).TheString as leid," + "MyTable.sortcol.lowerEvent(Id).firstOf() as lefo," + "MyTable.sortcol.lowerEvents(Id).lastOf() as leslo " + " from SupportBean_S0"; env.CompileDeploy(epl).AddListener("s0"); AssertType(env, typeof(string), "ceid,feid,heid,leid"); AssertType(env, typeof(SupportBean), "cefo,fefo,hefo,lefo,ceslo,feslo,heslo,leslo"); var treemap = new OrderedListDictionary <int, IList <SupportBean> >(); PrepareTestData(env, treemap); // 1, 1, 4, 6, 6, 8, 9 for (var i = 0; i < 12; i++) { env.SendEventBean(new SupportBean_S0(i)); var @event = env.Listener("s0").AssertOneGetNewAndReset(); var message = "failed at " + i; Assert.AreEqual(FirstEventString(treemap.GreaterThanOrEqualTo(i)), @event.Get("ceid"), message); Assert.AreEqual(FirstEvent(treemap.GreaterThanOrEqualTo(i)), @event.Get("cefo"), message); Assert.AreEqual(LastEvent(treemap.GreaterThanOrEqualTo(i)), @event.Get("ceslo"), message); Assert.AreEqual(FirstEventString(treemap.LessThanOrEqualTo(i)), @event.Get("feid"), message); Assert.AreEqual(FirstEvent(treemap.LessThanOrEqualTo(i)), @event.Get("fefo"), message); Assert.AreEqual(LastEvent(treemap.LessThanOrEqualTo(i)), @event.Get("feslo"), message); Assert.AreEqual(FirstEventString(treemap.GreaterThan(i)), @event.Get("heid"), message); Assert.AreEqual(FirstEvent(treemap.GreaterThan(i)), @event.Get("hefo"), message); Assert.AreEqual(LastEvent(treemap.GreaterThan(i)), @event.Get("heslo"), message); Assert.AreEqual(FirstEventString(treemap.LessThan(i)), @event.Get("leid"), message); Assert.AreEqual(FirstEvent(treemap.LessThan(i)), @event.Get("lefo"), message); Assert.AreEqual(LastEvent(treemap.LessThan(i)), @event.Get("leslo"), message); } env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var epl = "create table MyTable(sortcol sorted(IntPrimitive) @type('SupportBean'));\n" + "into table MyTable select sorted(*) as sortcol from SupportBean;\n" + "@Name('s0') select " + "MyTable.sortcol.getEvent(Id) as ge," + "MyTable.sortcol.getEvents(Id) as ges," + "MyTable.sortcol.containsKey(Id) as ck," + "MyTable.sortcol.countEvents() as cnte," + "MyTable.sortcol.countKeys() as cntk," + "MyTable.sortcol.getEvent(Id).TheString as geid," + "MyTable.sortcol.getEvent(Id).firstOf() as gefo," + "MyTable.sortcol.getEvents(Id).lastOf() as geslo " + " from SupportBean_S0"; env.CompileDeploy(epl).AddListener("s0"); AssertType(env, typeof(SupportBean), "ge,gefo,geslo"); AssertType(env, typeof(SupportBean[]), "ges"); AssertType(env, typeof(int?), "cnte,cntk"); AssertType(env, typeof(bool?), "ck"); AssertType(env, typeof(string), "geid"); var treemap = new OrderedListDictionary <int, IList <SupportBean> >(); PrepareTestData(env, treemap); // 1, 1, 4, 6, 6, 8, 9 for (var i = 0; i < 12; i++) { env.SendEventBean(new SupportBean_S0(i)); var @event = env.Listener("s0").AssertOneGetNewAndReset(); var message = "failed at " + i; var valueAtIndex = treemap.Get(i); Assert.AreEqual(FirstEvent(valueAtIndex), @event.Get("ge"), message); EPAssertionUtil.AssertEqualsExactOrder(AllEvents(valueAtIndex), (SupportBean[])@event.Get("ges")); Assert.AreEqual(treemap.ContainsKey(i), @event.Get("ck"), message); Assert.AreEqual(7, @event.Get("cnte"), message); Assert.AreEqual(5, @event.Get("cntk"), message); Assert.AreEqual(FirstEventString(valueAtIndex), @event.Get("geid"), message); Assert.AreEqual(FirstEvent(valueAtIndex), @event.Get("gefo"), message); Assert.AreEqual(LastEvent(valueAtIndex), @event.Get("geslo"), message); } env.UndeployAll(); }
public object GetValue( int aggColNum, AggregationRow row, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext) { AggregationStateSorted sorted = (AggregationStateSorted)row.GetAccessState(aggColNum); var fromKey = _fromKeyEval.Evaluate(eventsPerStream, isNewData, exprEvaluatorContext); if (fromKey == null) { return(null); } var fromInclusive = _fromInclusiveEval.Evaluate(eventsPerStream, isNewData, exprEvaluatorContext).AsBoxedBoolean(); if (fromInclusive == null) { return(null); } var toKey = _toKeyEval.Evaluate(eventsPerStream, isNewData, exprEvaluatorContext); if (toKey == null) { return(null); } var toInclusive = _toInclusiveEval.Evaluate(eventsPerStream, isNewData, exprEvaluatorContext).AsBoxedBoolean(); if (toInclusive == null) { return(null); } var mapOfArrays = new OrderedListDictionary <object, object>(sorted.Sorted.KeyComparer); var submap = sorted.Sorted.Between(fromKey, fromInclusive.Value, toKey, toInclusive.Value); foreach (KeyValuePair <object, object> entry in submap) { mapOfArrays.Put(entry.Key, AggregatorAccessSortedImpl.CheckedPayloadGetUnderlyingArray(entry.Value, _underlyingClass)); } return(mapOfArrays); }
/// <summary> /// NOTE: Code-generation-invoked method, method name and parameter order matters /// </summary> /// <param name="outgoingEvents">events</param> /// <param name="orderKeys">keys</param> /// <param name="comparator">comparator</param> /// <returns>sorted</returns> public static EventBean[] SortWOrderKeys( EventBean[] outgoingEvents, object[] orderKeys, IComparer<object> comparator) { var sort = new OrderedListDictionary<object, object>(comparator); if (outgoingEvents == null || outgoingEvents.Length < 2) { return outgoingEvents; } for (var i = 0; i < outgoingEvents.Length; i++) { var entry = sort.Get(orderKeys[i]); if (entry == null) { sort.Put(orderKeys[i], outgoingEvents[i]); } else if (entry is EventBean) { IList<EventBean> list = new List<EventBean>(); list.Add((EventBean) entry); list.Add(outgoingEvents[i]); sort.Put(orderKeys[i], list); } else { var list = (IList<EventBean>) entry; list.Add(outgoingEvents[i]); } } var result = new EventBean[outgoingEvents.Length]; var count = 0; foreach (object entry in sort.Values) { if (entry is IList<EventBean> output) { foreach (var theEvent in output) { result[count++] = theEvent; } } else { result[count++] = (EventBean) entry; } } return result; }
public void Run(RegressionEnvironment env) { var epl = "create table MyTable(sortcol sorted(IntPrimitive) @type('SupportBean'));\n" + "into table MyTable select sorted(*) as sortcol from SupportBean;\n" + "@Name('s0') select " + "MyTable.sortcol.firstEvent() as fe," + "MyTable.sortcol.minBy() as minb," + "MyTable.sortcol.firstEvents() as fes," + "MyTable.sortcol.firstKey() as fk," + "MyTable.sortcol.lastEvent() as le," + "MyTable.sortcol.maxBy() as maxb," + "MyTable.sortcol.lastEvents() as les," + "MyTable.sortcol.lastKey() as lk" + " from SupportBean_S0"; env.CompileDeploy(epl).AddListener("s0"); AssertType(env, typeof(SupportBean), "fe,le,minb,maxb"); AssertType(env, typeof(SupportBean[]), "fes,les"); AssertType(env, typeof(int?), "fk,lk"); var treemap = new OrderedListDictionary <int, IList <SupportBean> >(); PrepareTestData(env, treemap); // 1, 1, 4, 6, 6, 8, 9 var treeMapFirst = treemap.First(); var treeMapLast = treemap.Last(); env.SendEventBean(new SupportBean_S0(-1)); var @event = env.Listener("s0").AssertOneGetNewAndReset(); Assert.AreEqual(FirstEvent <IList <SupportBean> >(treeMapFirst), @event.Get("fe")); Assert.AreEqual(FirstEvent <IList <SupportBean> >(treeMapFirst), @event.Get("minb")); EPAssertionUtil.AssertEqualsExactOrder(AllEvents <IList <SupportBean> >(treeMapFirst), (SupportBean[])@event.Get("fes")); Assert.AreEqual(treeMapFirst.Key, @event.Get("fk")); Assert.AreEqual(FirstEvent <IList <SupportBean> >(treeMapLast), @event.Get("le")); Assert.AreEqual(FirstEvent <IList <SupportBean> >(treeMapLast), @event.Get("maxb")); EPAssertionUtil.AssertEqualsExactOrder(AllEvents <IList <SupportBean> >(treeMapLast), (SupportBean[])@event.Get("les")); Assert.AreEqual(treeMapLast.Key, @event.Get("lk")); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var epl = "create table MyTable(sortcol sorted(IntPrimitive) @type('SupportBean'));\n" + "into table MyTable select sorted(*) as sortcol from SupportBean;\n" + "@Name('s0') select " + "MyTable.sortcol.firstEvent().TheString as feid," + "MyTable.sortcol.firstEvent().firstOf() as fefo," + "MyTable.sortcol.firstEvents().lastOf() as feslo," + "MyTable.sortcol.lastEvent().TheString() as leid," + "MyTable.sortcol.lastEvent().firstOf() as lefo," + "MyTable.sortcol.lastEvents().lastOf as leslo" + " from SupportBean_S0"; env.CompileDeploy(epl).AddListener("s0"); AssertType(env, typeof(string), "feid,leid"); AssertType(env, typeof(SupportBean), "fefo,feslo,lefo,leslo"); var treemap = new OrderedListDictionary <int, IList <SupportBean> >(); PrepareTestData(env, treemap); // 1, 1, 4, 6, 6, 8, 9 var treeMapFirst = treemap.First(); var treeMapLast = treemap.Last(); env.SendEventBean(new SupportBean_S0(-1)); var @event = env.Listener("s0").AssertOneGetNewAndReset(); Assert.AreEqual(FirstEventString <IList <SupportBean> >(treeMapFirst), @event.Get("feid")); Assert.AreEqual(FirstEvent <IList <SupportBean> >(treeMapFirst), @event.Get("fefo")); Assert.AreEqual(LastEvent <IList <SupportBean> >(treeMapFirst), @event.Get("feslo")); Assert.AreEqual(FirstEventString <IList <SupportBean> >(treeMapLast), @event.Get("leid")); Assert.AreEqual(FirstEvent <IList <SupportBean> >(treeMapLast), @event.Get("lefo")); Assert.AreEqual(LastEvent <IList <SupportBean> >(treeMapLast), @event.Get("leslo")); env.UndeployAll(); }
public void EvaluateEventForStatement( EventBean theEvent, IList<AgentInstance> agentInstances, AgentInstanceContext agentInstanceContextCreate) { // context was created - reevaluate for the given event ArrayDeque<FilterHandle> callbacks = new ArrayDeque<FilterHandle>(2); agentInstanceContextCreate.FilterService.Evaluate(theEvent, callbacks, agentInstanceContextCreate); // evaluates for ALL statements if (callbacks.IsEmpty()) { return; } // there is a single callback and a single context, if they match we are done if (agentInstances.Count == 1 && callbacks.Count == 1) { AgentInstance agentInstance = agentInstances[0]; AgentInstanceContext agentInstanceContext = agentInstance.AgentInstanceContext; FilterHandle callback = callbacks.First; if (agentInstanceContext.StatementId == callback.StatementId && agentInstanceContext.AgentInstanceId == callback.AgentInstanceId) { Process(agentInstance, callbacks, theEvent); } return; } // use the right sorted/unsorted Map keyed by AgentInstance to sort bool isPrioritized = agentInstanceContextCreate.RuntimeSettingsService.ConfigurationRuntime.Execution .IsPrioritized; IDictionary<AgentInstance, object> stmtCallbacks; if (!isPrioritized) { stmtCallbacks = new Dictionary<AgentInstance, object>(); } else { stmtCallbacks = new OrderedListDictionary<AgentInstance, object>(AgentInstanceComparator.INSTANCE); } // process all callbacks foreach (FilterHandle filterHandle in callbacks) { EPStatementHandleCallbackFilter handleCallback = (EPStatementHandleCallbackFilter) filterHandle; // determine if this filter entry applies to any of the affected agent instances int statementId = filterHandle.StatementId; AgentInstance agentInstanceFound = null; foreach (AgentInstance agentInstance in agentInstances) { AgentInstanceContext agentInstanceContext = agentInstance.AgentInstanceContext; if (agentInstanceContext.StatementId == statementId && agentInstanceContext.AgentInstanceId == handleCallback.AgentInstanceId) { agentInstanceFound = agentInstance; break; } } if (agentInstanceFound == null) { // when the callback is for some other stmt continue; } EPStatementAgentInstanceHandle handle = handleCallback.AgentInstanceHandle; // Self-joins require that the internal dispatch happens after all streams are evaluated. // Priority or preemptive settings also require special ordering. if (handle.IsCanSelfJoin || isPrioritized) { var stmtCallback = stmtCallbacks.Get(agentInstanceFound); if (stmtCallback == null) { stmtCallbacks.Put(agentInstanceFound, handleCallback); } else if (stmtCallback is ArrayDeque<FilterHandle> callbackFilterDeque) { if (!callbackFilterDeque.Contains(handleCallback)) { // De-duplicate for Filter OR expression paths callbackFilterDeque.Add(handleCallback); } } else { var filterDeque = new ArrayDeque<FilterHandle>(4); filterDeque.Add((FilterHandle) stmtCallback); if (stmtCallback != handleCallback) { // De-duplicate for Filter OR expression paths filterDeque.Add(handleCallback); } stmtCallbacks.Put(agentInstanceFound, filterDeque); } continue; } // no need to be sorted, process Process(agentInstanceFound, Collections.SingletonList<FilterHandle>(handleCallback), theEvent); } if (stmtCallbacks.IsEmpty()) { return; } // Process self-join or sorted prioritized callbacks foreach (KeyValuePair<AgentInstance, object> entry in stmtCallbacks) { AgentInstance agentInstance = entry.Key; object callbackList = entry.Value; if (callbackList is ICollection<FilterHandle> filterHandleCollection) { Process(agentInstance, filterHandleCollection, theEvent); } else { Process( agentInstance, Collections.SingletonList<FilterHandle>((FilterHandle) callbackList), theEvent); } if (agentInstance.AgentInstanceContext.EpStatementAgentInstanceHandle.IsPreemptive) { return; } } }
// Wherein: Object either is ByteBuffer or Deque<ByteBuffer> public CountMinSketchStateTopk(int topKMax) { TopKMax = topKMax; _lastFreqForItem = new Dictionary <ByteBuffer, long>(); Topk = new OrderedListDictionary <long, object>(SimpleComparer <long> .Reverse); }
public static RowRecogPlan ValidateAndPlan( IContainer container, EventType parentEventType, bool unbound, StatementBaseInfo @base, StatementCompileTimeServices services) { var statementRawInfo = @base.StatementRawInfo; var matchRecognizeSpec = @base.StatementSpec.Raw.MatchRecognizeSpec; var annotations = statementRawInfo.Annotations; var iterateOnly = HintEnum.ITERATE_ONLY.GetHint(annotations) != null; var additionalForgeables = new List<StmtClassForgeableFactory>(); // Expanded pattern already there RowRecogExprNode expandedPatternNode = matchRecognizeSpec.Pattern; // Determine single-row and multiple-row variables var variablesSingle = new LinkedHashSet<string>(); var variablesMultiple = new LinkedHashSet<string>(); RowRecogHelper.RecursiveInspectVariables(expandedPatternNode, false, variablesSingle, variablesMultiple); // each variable gets associated with a stream number (multiple-row variables as well to hold the current event for the expression). var streamNum = 0; var variableStreams = new LinkedHashMap<string, Pair<int, bool>>(); foreach (var variableSingle in variablesSingle) { variableStreams.Put(variableSingle, new Pair<int, bool>(streamNum, false)); streamNum++; } foreach (var variableMultiple in variablesMultiple) { variableStreams.Put(variableMultiple, new Pair<int, bool>(streamNum, true)); streamNum++; } // mapping of stream to variable var streamVariables = new OrderedListDictionary<int, string>(); foreach (var entry in variableStreams) { streamVariables.Put(entry.Value.First, entry.Key); } // determine visibility rules var visibility = RowRecogHelper.DetermineVisibility(expandedPatternNode); // assemble all single-row variables for expression validation var allStreamNames = new string[variableStreams.Count]; var allTypes = new EventType[variableStreams.Count]; streamNum = 0; foreach (var variableSingle in variablesSingle) { allStreamNames[streamNum] = variableSingle; allTypes[streamNum] = parentEventType; streamNum++; } foreach (var variableMultiple in variablesMultiple) { allStreamNames[streamNum] = variableMultiple; allTypes[streamNum] = parentEventType; streamNum++; } // determine type service for use with DEFINE // validate each DEFINE clause expression ISet<string> definedVariables = new HashSet<string>(); IList<ExprAggregateNode> aggregateNodes = new List<ExprAggregateNode>(); var isExprRequiresMultimatchState = new bool[variableStreams.Count]; var previousNodes = new OrderedListDictionary<int, IList<ExprPreviousMatchRecognizeNode>>(); for (var defineIndex = 0; defineIndex < matchRecognizeSpec.Defines.Count; defineIndex++) { MatchRecognizeDefineItem defineItem = matchRecognizeSpec.Defines[defineIndex]; if (definedVariables.Contains(defineItem.Identifier)) { throw new ExprValidationException( "Variable '" + defineItem.Identifier + "' has already been defined"); } definedVariables.Add(defineItem.Identifier); // stream-type visibilities handled here var typeServiceDefines = BuildDefineStreamTypeServiceDefine( defineIndex, variableStreams, defineItem, visibility, parentEventType, statementRawInfo, services); var exprNodeResult = HandlePreviousFunctions(defineItem.Expression, previousNodes); var validationContext = new ExprValidationContextBuilder(typeServiceDefines, statementRawInfo, services) .WithAllowBindingConsumption(true) .WithDisablePropertyExpressionEventCollCache(true) .Build(); ExprNode validated; try { // validate validated = ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.MATCHRECOGDEFINE, exprNodeResult, validationContext); // check aggregates defineItem.Expression = validated; ExprAggregateNodeUtil.GetAggregatesBottomUp(validated, aggregateNodes); if (!aggregateNodes.IsEmpty()) { throw new ExprValidationException("An aggregate function may not appear in a DEFINE clause"); } } catch (ExprValidationException ex) { throw new ExprValidationException( "Failed to validate condition expression for variable '" + defineItem.Identifier + "': " + ex.Message, ex); } // determine access to event properties from multi-matches var visitor = new ExprNodeStreamRequiredVisitor(); validated.Accept(visitor); var streamsRequired = visitor.StreamsRequired; foreach (var streamRequired in streamsRequired) { if (streamRequired >= variableStreams.Count) { var streamNumIdent = variableStreams.Get(defineItem.Identifier).First; isExprRequiresMultimatchState[streamNumIdent] = true; break; } } } var defineAsksMultimatches = CollectionUtil.IsAnySet(isExprRequiresMultimatchState); // determine type service for use with MEASURE IDictionary<string, object> measureTypeDef = new LinkedHashMap<string, object>(); foreach (var variableSingle in variablesSingle) { measureTypeDef.Put(variableSingle, parentEventType); } foreach (var variableMultiple in variablesMultiple) { measureTypeDef.Put(variableMultiple, new[] {parentEventType}); } var compositeTypeName = services.EventTypeNameGeneratorStatement.AnonymousRowrecogCompositeName; var compositeTypeMetadata = new EventTypeMetadata( compositeTypeName, @base.ModuleName, EventTypeTypeClass.MATCHRECOGDERIVED, EventTypeApplicationType.OBJECTARR, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var compositeEventType = BaseNestableEventUtil.MakeOATypeCompileTime( compositeTypeMetadata, measureTypeDef, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(compositeEventType); StreamTypeService compositeTypeServiceMeasure = new StreamTypeServiceImpl(compositeEventType, "MATCH_RECOGNIZE", true); // find MEASURE clause aggregations var measureReferencesMultivar = false; IList<ExprAggregateNode> measureAggregateExprNodes = new List<ExprAggregateNode>(); foreach (var measureItem in matchRecognizeSpec.Measures) { ExprAggregateNodeUtil.GetAggregatesBottomUp(measureItem.Expr, measureAggregateExprNodes); } AggregationServiceForgeDesc[] aggregationServices = null; if (!measureAggregateExprNodes.IsEmpty()) { aggregationServices = PlanAggregations( measureAggregateExprNodes, compositeTypeServiceMeasure, allStreamNames, allTypes, streamVariables, variablesMultiple, @base, services); foreach (AggregationServiceForgeDesc svc in aggregationServices) { if (svc != null) { additionalForgeables.AddAll(svc.AdditionalForgeables); } } } // validate each MEASURE clause expression IDictionary<string, object> rowTypeDef = new LinkedHashMap<string, object>(); var streamRefVisitor = new ExprNodeStreamUseCollectVisitor(); foreach (var measureItem in matchRecognizeSpec.Measures) { if (measureItem.Name == null) { throw new ExprValidationException( "The measures clause requires that each expression utilizes the AS keyword to assign a column name"); } var validated = ValidateMeasureClause( measureItem.Expr, compositeTypeServiceMeasure, variablesMultiple, variablesSingle, statementRawInfo, services); measureItem.Expr = validated; rowTypeDef.Put(measureItem.Name, validated.Forge.EvaluationType); validated.Accept(streamRefVisitor); } // Determine if any of the multi-var streams are referenced in the measures (non-aggregated only) foreach (var @ref in streamRefVisitor.Referenced) { var rootPropName = @ref.RootPropertyNameIfAny; if (rootPropName != null) { if (variablesMultiple.Contains(rootPropName)) { measureReferencesMultivar = true; break; } } var streamRequired = @ref.StreamReferencedIfAny; if (streamRequired != null) { var streamVariable = streamVariables.Get(streamRequired.Value); if (streamVariable != null) { var def = variableStreams.Get(streamVariable); if (def != null && def.Second) { measureReferencesMultivar = true; break; } } } } var collectMultimatches = measureReferencesMultivar || defineAsksMultimatches; // create rowevent type var rowTypeName = services.EventTypeNameGeneratorStatement.AnonymousRowrecogRowName; var rowTypeMetadata = new EventTypeMetadata( rowTypeName, @base.ModuleName, EventTypeTypeClass.MATCHRECOGDERIVED, EventTypeApplicationType.MAP, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var rowEventType = BaseNestableEventUtil.MakeMapTypeCompileTime( rowTypeMetadata, rowTypeDef, null, null, null, null, services.BeanEventTypeFactoryPrivate, services.EventTypeCompileTimeResolver); services.EventTypeCompileTimeRegistry.NewType(rowEventType); // validate partition-by expressions, if any ExprNode[] partitionBy; MultiKeyClassRef partitionMultiKey; if (!matchRecognizeSpec.PartitionByExpressions.IsEmpty()) { StreamTypeService typeServicePartition = new StreamTypeServiceImpl( parentEventType, "MATCH_RECOGNIZE_PARTITION", true); IList<ExprNode> validated = new List<ExprNode>(); var validationContext = new ExprValidationContextBuilder(typeServicePartition, statementRawInfo, services) .WithAllowBindingConsumption(true) .Build(); foreach (var partitionExpr in matchRecognizeSpec.PartitionByExpressions) { validated.Add( ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.MATCHRECOGPARTITION, partitionExpr, validationContext)); } matchRecognizeSpec.PartitionByExpressions = validated; partitionBy = ExprNodeUtilityQuery.ToArray(validated); MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKey(partitionBy, false, @base.StatementRawInfo, services.SerdeResolver); partitionMultiKey = multiKeyPlan.ClassRef; additionalForgeables.AddAll(multiKeyPlan.MultiKeyForgeables); } else { partitionBy = null; partitionMultiKey = null; } // validate interval if present if (matchRecognizeSpec.Interval != null) { var validationContext = new ExprValidationContextBuilder(new StreamTypeServiceImpl(false), statementRawInfo, services) .WithAllowBindingConsumption(true) .Build(); var validated = (ExprTimePeriod) ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.MATCHRECOGINTERVAL, matchRecognizeSpec.Interval.TimePeriodExpr, validationContext); matchRecognizeSpec.Interval.TimePeriodExpr = validated; } // compile variable definition expressions IDictionary<string, ExprNode> variableDefinitions = new Dictionary<string, ExprNode>(); foreach (var defineItem in matchRecognizeSpec.Defines) { variableDefinitions.Put(defineItem.Identifier, defineItem.Expression); } // create evaluators var columnNames = new string[matchRecognizeSpec.Measures.Count]; var columnForges = new ExprNode[matchRecognizeSpec.Measures.Count]; var count = 0; foreach (var measureItem in matchRecognizeSpec.Measures) { columnNames[count] = measureItem.Name; columnForges[count] = measureItem.Expr; count++; } // build states var strand = RowRecogHelper.BuildStartStates( expandedPatternNode, variableDefinitions, variableStreams, isExprRequiresMultimatchState); var startStates = strand.StartStates.ToArray(); RowRecogNFAStateForge[] allStates = strand.AllStates.ToArray(); if (Log.IsInfoEnabled) { Log.Info("NFA tree:\n" + RowRecogNFAViewUtil.Print(startStates)); } // determine names of multimatching variables string[] multimatchVariablesArray; int[] multimatchStreamNumToVariable; int[] multimatchVariableToStreamNum; if (variablesSingle.Count == variableStreams.Count) { multimatchVariablesArray = new string[0]; multimatchStreamNumToVariable = new int[0]; multimatchVariableToStreamNum = new int[0]; } else { multimatchVariablesArray = new string[variableStreams.Count - variablesSingle.Count]; multimatchVariableToStreamNum = new int[multimatchVariablesArray.Length]; multimatchStreamNumToVariable = new int[variableStreams.Count]; CompatExtensions.Fill(multimatchStreamNumToVariable, -1); count = 0; foreach (var entry in variableStreams) { if (entry.Value.Second) { var index = count; multimatchVariablesArray[index] = entry.Key; multimatchVariableToStreamNum[index] = entry.Value.First; multimatchStreamNumToVariable[entry.Value.First] = index; count++; } } } var numEventsEventsPerStreamDefine = defineAsksMultimatches ? variableStreams.Count + 1 : variableStreams.Count; // determine interval-or-terminated var orTerminated = matchRecognizeSpec.Interval != null && matchRecognizeSpec.Interval.IsOrTerminated; TimePeriodComputeForge intervalCompute = null; if (matchRecognizeSpec.Interval != null) { intervalCompute = matchRecognizeSpec.Interval.TimePeriodExpr.TimePeriodComputeForge; } EventType multimatchEventType = null; if (defineAsksMultimatches) { multimatchEventType = GetDefineMultimatchEventType(variableStreams, parentEventType, @base, services); } // determine previous-access indexes and assign "prev" node indexes // Since an expression such as "prior(2, price), prior(8, price)" translates into {2, 8} the relative index is {0, 1}. // Map the expression-supplied index to a relative index int[] previousRandomAccessIndexes = null; if (!previousNodes.IsEmpty()) { previousRandomAccessIndexes = new int[previousNodes.Count]; var countPrev = 0; foreach (var entry in previousNodes) { previousRandomAccessIndexes[countPrev] = entry.Key; foreach (var callback in entry.Value) { callback.AssignedIndex = countPrev; } countPrev++; } } RowRecogDescForge forge = new RowRecogDescForge( parentEventType, rowEventType, compositeEventType, multimatchEventType, multimatchStreamNumToVariable, multimatchVariableToStreamNum, partitionBy, partitionMultiKey, variableStreams, matchRecognizeSpec.Interval != null, iterateOnly, unbound, orTerminated, collectMultimatches, defineAsksMultimatches, numEventsEventsPerStreamDefine, multimatchVariablesArray, startStates, allStates, matchRecognizeSpec.IsAllMatches, matchRecognizeSpec.Skip.Skip, columnForges, columnNames, intervalCompute, previousRandomAccessIndexes, aggregationServices); return new RowRecogPlan(forge, additionalForgeables); }
public static ViewResourceDelegateDesc[] VerifyPreviousAndPriorRequirements( IList<ViewFactoryForge>[] unmaterializedViewChain, ViewResourceDelegateExpr @delegate) { var numStreams = unmaterializedViewChain.Length; var perStream = new ViewResourceDelegateDesc[numStreams]; // verify "previous" var previousPerStream = new bool[numStreams]; foreach (ExprPreviousNode previousNode in @delegate.PreviousRequests) { var stream = previousNode.StreamNumber; var forges = unmaterializedViewChain[stream]; var pass = InspectViewFactoriesForPrevious(forges); if (!pass) { throw new ExprValidationException( "Previous function requires a single data window view onto the stream"); } var found = FindDataWindow(forges); if (!found) { throw new ExprValidationException( "Required data window not found for the 'prev' function, specify a data window for which previous events are retained"); } previousPerStream[stream] = true; } // determine 'prior' indexes var priorPerStream = new IOrderedDictionary<int, IList<ExprPriorNode>>[numStreams]; foreach (var priorNode in @delegate.PriorRequests) { var stream = priorNode.StreamNumber; if (priorPerStream[stream] == null) { priorPerStream[stream] = new OrderedListDictionary<int, IList<ExprPriorNode>>(); } var treemap = priorPerStream[stream]; var callbackList = treemap.Get(priorNode.ConstantIndexNumber); if (callbackList == null) { callbackList = new List<ExprPriorNode>(); treemap.Put(priorNode.ConstantIndexNumber, callbackList); } callbackList.Add(priorNode); } // when a given stream has multiple 'prior' nodes, assign a relative index for (var i = 0; i < numStreams; i++) { if (priorPerStream[i] != null) { var relativeIndex = 0; foreach (var entry in priorPerStream[i]) { foreach (var node in entry.Value) { node.RelativeIndex = relativeIndex; } relativeIndex++; } } } // build per-stream info for (var i = 0; i < numStreams; i++) { if (priorPerStream[i] == null) { priorPerStream[i] = new OrderedListDictionary<int, IList<ExprPriorNode>>(); } perStream[i] = new ViewResourceDelegateDesc( previousPerStream[i], new SortedSet<int>(priorPerStream[i].Keys)); } return perStream; }