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;
}
