public PropertyCompositeEventTableFactoryFactory( int indexedStreamNum, int? subqueryNum, bool isFireAndForget, string[] keyProps, Type[] keyTypes, EventPropertyValueGetter keyGetter, DataInputOutputSerde keySerde, string[] rangeProps, Type[] rangeTypes, EventPropertyValueGetter[] rangeGetters, DataInputOutputSerde[] rangeKeySerdes) { this._indexedStreamNum = indexedStreamNum; this._subqueryNum = subqueryNum; this._isFireAndForget = isFireAndForget; this._keyProps = keyProps; this._keyTypes = keyTypes; this._keyGetter = keyGetter; this._keySerde = keySerde; this._rangeProps = rangeProps; this._rangeTypes = rangeTypes; this._rangeGetters = rangeGetters; this._rangeKeySerdes = rangeKeySerdes; }
public static IEnumerator<EventBean> For( IEnumerator<EventBean> sourceIterator, EventPropertyValueGetter distinctKeyGetter) { if (sourceIterator != null && sourceIterator.MoveNext()) { // there is at least one event... var first = sourceIterator.Current; // but is there only one event? if (!sourceIterator.MoveNext()) { return EnumerationHelper.Singleton(first); } // build distinct set because there are multiple events var events = new ArrayDeque<EventBean>(); events.Add(first); events.Add(sourceIterator.Current); while (sourceIterator.MoveNext()) { events.Add(sourceIterator.Current); } // Determine the reader that we need to use for this use case var unique = EventBeanUtility.GetDistinctByProp(events, distinctKeyGetter); return unique.GetEnumerator(); } return EnumerationHelper.Empty<EventBean>(); }
public QueryPlanIndexItem( string[] hashProps, Type[] hashPropTypes, EventPropertyValueGetter hashGetter, MultiKeyFromObjectArray transformFireAndForget, DataInputOutputSerde hashKeySerde, string[] rangeProps, Type[] rangePropTypes, EventPropertyValueGetter[] rangeGetters, DataInputOutputSerde[] rangeKeySerdes, bool unique, EventAdvancedIndexProvisionRuntime advancedIndexProvisionDesc) { HashProps = hashProps; HashPropTypes = hashPropTypes; HashGetter = hashGetter; HashKeySerde = hashKeySerde; RangeProps = rangeProps == null || rangeProps.Length == 0 ? null : rangeProps; RangePropTypes = rangePropTypes; RangeGetters = rangeGetters; RangeKeySerdes = rangeKeySerdes; TransformFireAndForget = transformFireAndForget; IsUnique = unique; AdvancedIndexProvisionDesc = advancedIndexProvisionDesc; }
/// <summary> /// NOTE: Code-generation-invoked method, method name and parameter order matters /// </summary> /// <param name="joinExecutionStrategy">join strategy</param> /// <param name="resultSetProcessor">processor</param> /// <param name="parentView">view</param> /// <param name="distinct">flag</param> /// <param name="distinctKeyGetter"></param> /// <returns>iterator</returns> public static IEnumerator<EventBean> GetEnumerator( JoinExecutionStrategy joinExecutionStrategy, ResultSetProcessor resultSetProcessor, Viewable parentView, bool distinct, EventPropertyValueGetter distinctKeyGetter) { IEnumerator<EventBean> enumerator; if (joinExecutionStrategy != null) { var joinSet = joinExecutionStrategy.StaticJoin(); enumerator = resultSetProcessor.GetEnumerator(joinSet); } else if (resultSetProcessor != null) { enumerator = resultSetProcessor.GetEnumerator(parentView); } else { enumerator = parentView.GetEnumerator(); } if (!distinct) { return enumerator; } return EventDistinctEnumerator.For(enumerator, distinctKeyGetter); }
public static ICollection<EventBean> GetDistinctByProp( ArrayDeque<EventBean> events, EventPropertyValueGetter getter) { if (events == null || events.IsEmpty()) { return new EventBean[0]; } if (events.Count < 2) { return events; } var map = new LinkedHashMap<object, EventBean>(); if (events.First is NaturalEventBean) { foreach (var theEvent in events) { var inner = ((NaturalEventBean) theEvent).OptionalSynthetic; var key = getter.Get(inner); map[key] = inner; } } else { foreach (var theEvent in events) { var key = getter.Get(theEvent); map[key] = theEvent; } } return map.Values.ToArray(); }
public EventTableFactory CreateComposite( int indexedStreamNum, EventType eventType, string[] indexProps, Type[] indexCoercionTypes, EventPropertyValueGetter indexGetter, MultiKeyFromObjectArray transformFireAndForget, DataInputOutputSerde keySerde, string[] rangeProps, Type[] rangeCoercionTypes, EventPropertyValueGetter[] rangeGetters, DataInputOutputSerde[] rangeSerdes, DataInputOutputSerde optionalValueSerde, bool isFireAndForget) { return new PropertyCompositeEventTableFactory( indexedStreamNum, indexProps, indexCoercionTypes, indexGetter, transformFireAndForget, rangeProps, rangeCoercionTypes, rangeGetters); }
/// <summary> /// Returns the distinct events by properties. /// </summary> /// <param name="events">to inspect</param> /// <param name="getter">for retrieving properties</param> /// <returns>distinct events</returns> public static EventBean[] GetDistinctByProp( EventBean[] events, EventPropertyValueGetter getter) { if (events == null || events.Length < 2 || getter == null) { return events; } var map = new Dictionary<object, EventBean>(); if (events[0] is NaturalEventBean) { foreach (var theEvent in events) { var inner = ((NaturalEventBean) theEvent).OptionalSynthetic; var key = getter.Get(inner); map[key] = theEvent; } } else { foreach (var theEvent in events) { var key = getter.Get(theEvent); map[key] = theEvent; } } return map.Values.ToArray(); }
public IndexedTableLookupPlanHashedOnlyFactory( int lookupStream, int indexedStream, TableLookupIndexReqKey[] indexNum, EventPropertyValueGetter eventPropertyValueGetter) : base(lookupStream, indexedStream, indexNum) { exprEvaluator = null; this.eventPropertyValueGetter = eventPropertyValueGetter; }
public PropertySortedEventTableFactory( int streamNum, string propertyName, EventPropertyValueGetter propertyGetter, Type valueType) { this.streamNum = streamNum; this.propertyName = propertyName; this.propertyGetter = propertyGetter; this.valueType = valueType; }
public ExprFilterSpecLookupable( string expression, EventPropertyValueGetter getter, Type returnType, bool isNonPropertyGetter) { this.getter = getter; // apparently, the getter can be null (wth) Expression = expression ?? throw new ArgumentNullException(nameof(expression)); // For type consistency for recovery and serde define as boxed type ReturnType = returnType?.GetBoxedType(); IsNonPropertyGetter = isNonPropertyGetter; }
public EventTableFactory CreateSorted( int indexedStreamNum, EventType eventType, string indexedProp, Type indexType, EventPropertyValueGetter getter, DataInputOutputSerde serde, DataInputOutputSerde optionalValueSerde, bool isFireAndForget, EventTableFactoryFactoryContext eventTableFactoryContext) { return new PropertySortedEventTableFactory(indexedStreamNum, indexedProp, getter, indexType); }
public OutputProcessViewDirectDistinctOrAfterFactory( OutputStrategyPostProcessFactory postProcessFactory, bool distinct, EventPropertyValueGetter distinctKeyGetter, TimePeriodCompute afterTimePeriod, int? afterConditionNumberOfEvents, EventType resultEventType) : base(postProcessFactory) { IsDistinct = distinct; DistinctKeyGetter = distinctKeyGetter; this.AfterTimePeriod = afterTimePeriod; this.AfterConditionNumberOfEvents = afterConditionNumberOfEvents; }
public PropertySortedFactoryFactory( int indexedStreamNum, int? subqueryNum, bool isFireAndForget, string indexProp, Type indexType, EventPropertyValueGetter valueGetter, DataInputOutputSerde indexSerde) : base(indexedStreamNum, subqueryNum, isFireAndForget) { _indexProp = indexProp; _indexType = indexType; _valueGetter = valueGetter; _indexSerde = indexSerde; }
protected internal static EPPreparedQueryResult ProcessedNonJoin( ResultSetProcessor resultSetProcessor, ICollection<EventBean> events, EventPropertyValueGetter distinctKeyGetter) { var rows = events.ToArray(); var results = resultSetProcessor.ProcessViewResult(rows, null, true); EventBean[] distinct; if (distinctKeyGetter == null) { distinct = results.First; } else { distinct = EventBeanUtility.GetDistinctByProp(results.First, distinctKeyGetter); } return new EPPreparedQueryResult(resultSetProcessor.ResultEventType, distinct); }
public PropertyHashedFactoryFactory( int indexedStreamNum, int? subqueryNum, bool isFireAndForget, String[] indexProps, Type[] indexTypes, bool unique, EventPropertyValueGetter valueGetter, MultiKeyFromObjectArray transformFireAndForget, DataInputOutputSerde keySerde) : base(indexedStreamNum, subqueryNum, isFireAndForget) { this.indexProps = indexProps; this.indexTypes = indexTypes; this.unique = unique; this.valueGetter = valueGetter; this.transformFireAndForget = transformFireAndForget; this.keySerde = keySerde; }
public PropertyHashedEventTableFactory( int streamNum, string[] propertyNames, bool unique, string optionalIndexName, EventPropertyValueGetter propertyGetter, MultiKeyFromObjectArray multiKeyTransform) { StreamNum = streamNum; PropertyNames = propertyNames; Unique = unique; OptionalIndexName = optionalIndexName; PropertyGetter = propertyGetter; MultiKeyTransform = multiKeyTransform; if (propertyGetter == null) { throw new ArgumentException("Property-getter is null"); } }
public PropertyCompositeEventTableFactory( int streamNum, string[] optionalKeyedProps, Type[] optKeyCoercedTypes, EventPropertyValueGetter hashGetter, MultiKeyFromObjectArray transformFireAndForget, string[] rangeProps, Type[] optRangeCoercedTypes, EventPropertyValueGetter[] rangeGetters) { this.StreamNum = streamNum; this.OptionalKeyedProps = optionalKeyedProps; this.OptKeyCoercedTypes = optKeyCoercedTypes; this.HashGetter = hashGetter; this.TransformFireAndForget = transformFireAndForget; this.RangeProps = rangeProps; this.OptRangeCoercedTypes = optRangeCoercedTypes; this.RangeGetters = rangeGetters; // construct chain IList<CompositeIndexEnterRemove> enterRemoves = new List<CompositeIndexEnterRemove>(); if (optionalKeyedProps != null && optionalKeyedProps.Length > 0) { enterRemoves.Add(new CompositeIndexEnterRemoveKeyed(hashGetter)); } foreach (var rangeGetter in rangeGetters) { enterRemoves.Add(new CompositeIndexEnterRemoveRange(rangeGetter)); } // Hook up as chain for remove CompositeIndexEnterRemove last = null; foreach (var action in enterRemoves) { if (last != null) { last.Next = action; } last = action; } Chain = enterRemoves[0]; }
public InfraOnSelectViewFactory( EventType infraEventType, bool addToFront, bool isDistinct, EventPropertyValueGetter distinctKeyGetter, bool selectAndDelete, StreamSelector? optionalStreamSelector, Table optionalInsertIntoTable, bool insertInto, ResultSetProcessorFactoryProvider resultSetProcessorPrototype) : base(infraEventType) { IsAddToFront = addToFront; IsDistinct = isDistinct; DistinctKeyGetter = distinctKeyGetter; IsSelectAndDelete = selectAndDelete; OptionalStreamSelector = optionalStreamSelector; this.optionalInsertIntoTable = optionalInsertIntoTable; IsInsertInto = insertInto; this.resultSetProcessorPrototype = resultSetProcessorPrototype; }
public EventTableFactory CreateHashedOnly( int indexedStreamNum, EventType eventType, string[] indexProps, Type[] indexTypes, MultiKeyFromObjectArray transformFireAndForget, DataInputOutputSerde keySerde, bool unique, string optionalIndexName, EventPropertyValueGetter getter, DataInputOutputSerde optionalValueSerde, bool isFireAndForget, EventTableFactoryFactoryContext eventTableFactoryContext) { return new PropertyHashedEventTableFactory( indexedStreamNum, indexProps, unique, optionalIndexName, getter, transformFireAndForget); }
public CompositeIndexEnterRemoveKeyed(EventPropertyValueGetter hashGetter) { this._hashGetter = hashGetter; }
public SupportExprEventEvaluator(EventPropertyValueGetter getter) { _getter = getter; }
public CompositeIndexEnterRemoveRange(EventPropertyValueGetter propertyGetter) { this._propertyGetter = propertyGetter; }