public ResultSetProcessorRowPerGroupForge(
EventType resultEventType,
EventType[] typesPerStream,
ExprNode[] groupKeyNodeExpressions,
ExprForge optionalHavingNode,
bool isSelectRStream,
bool isUnidirectional,
OutputLimitSpec outputLimitSpec,
bool isSorting,
bool isHistoricalOnly,
ResultSetProcessorOutputConditionType? outputConditionType,
EventType[] eventTypes,
OutputConditionPolledFactoryForge optionalOutputFirstConditionFactory,
MultiKeyClassRef multiKeyClassRef,
bool unboundedProcessor)
{
ResultEventType = resultEventType;
this.typesPerStream = typesPerStream;
GroupKeyNodeExpressions = groupKeyNodeExpressions;
OptionalHavingNode = optionalHavingNode;
IsSorting = isSorting;
IsSelectRStream = isSelectRStream;
IsUnidirectional = isUnidirectional;
OutputLimitSpec = outputLimitSpec;
IsHistoricalOnly = isHistoricalOnly;
OutputConditionType = outputConditionType;
EventTypes = eventTypes;
OptionalOutputFirstConditionFactory = optionalOutputFirstConditionFactory;
groupKeyTypes = ExprNodeUtilityQuery.GetExprResultTypes(groupKeyNodeExpressions);
this.multiKeyClassRef = multiKeyClassRef;
this.unboundedProcessor = unboundedProcessor;
}
public SubSelectStrategyFactoryLocalViewPreloadedForge(
IList <ViewFactoryForge> viewForges,
ViewResourceDelegateDesc viewResourceDelegateDesc,
Pair <EventTableFactoryFactoryForge, SubordTableLookupStrategyFactoryForge> lookupStrategy,
ExprNode filterExprNode,
bool correlatedSubquery,
AggregationServiceForgeDesc aggregationServiceForgeDesc,
int subqueryNumber,
ExprNode[] groupKeys,
NamedWindowMetaData namedWindow,
ExprNode namedWindowFilterExpr,
QueryGraphForge namedWindowFilterQueryGraph,
MultiKeyClassRef groupByMultiKeyClasses)
{
_viewForges = viewForges;
_viewResourceDelegateDesc = viewResourceDelegateDesc;
_lookupStrategy = lookupStrategy;
_filterExprNode = filterExprNode;
_correlatedSubquery = correlatedSubquery;
_aggregationServiceForgeDesc = aggregationServiceForgeDesc;
_subqueryNumber = subqueryNumber;
_groupKeys = groupKeys;
_namedWindow = namedWindow;
_namedWindowFilterExpr = namedWindowFilterExpr;
_namedWindowFilterQueryGraph = namedWindowFilterQueryGraph;
_groupByMultiKeyClasses = groupByMultiKeyClasses;
}
public ResultSetProcessorAggregateGroupedForge(
EventType resultEventType,
ExprNode[] groupKeyNodeExpressions,
ExprForge optionalHavingNode,
bool isSelectRStream,
bool isUnidirectional,
OutputLimitSpec outputLimitSpec,
bool isSorting,
bool isHistoricalOnly,
ResultSetProcessorOutputConditionType? outputConditionType,
OutputConditionPolledFactoryForge optionalOutputFirstConditionFactory,
EventType[] eventTypes,
MultiKeyClassRef multiKeyClassRef)
{
ResultEventType = resultEventType;
GroupKeyNodeExpressions = groupKeyNodeExpressions;
OptionalHavingNode = optionalHavingNode;
IsSorting = isSorting;
IsSelectRStream = isSelectRStream;
IsUnidirectional = isUnidirectional;
OutputLimitSpec = outputLimitSpec;
IsHistoricalOnly = isHistoricalOnly;
OutputConditionType = outputConditionType;
OptionalOutputFirstConditionFactory = optionalOutputFirstConditionFactory;
EventTypes = eventTypes;
GroupKeyTypes = ExprNodeUtilityQuery.GetExprResultTypes(groupKeyNodeExpressions);
MultiKeyClassRef = multiKeyClassRef;
}
public TableAccessAnalysisResult(
IDictionary<string, TableMetadataColumn> tableColumns,
ObjectArrayEventType internalEventType,
DataInputOutputSerdeForge[] internalEventTypePropertySerdes,
ObjectArrayEventType publicEventType,
TableMetadataColumnPairPlainCol[] colsPlain,
TableMetadataColumnPairAggMethod[] colsAggMethod,
TableMetadataColumnPairAggAccess[] colsAccess,
AggregationRowStateForgeDesc aggDesc,
string[] primaryKeyColumns,
EventPropertyGetterSPI[] primaryKeyGetters,
Type[] primaryKeyTypes,
int[] primaryKeyColNums,
MultiKeyClassRef primaryKeyMultikeyClasses,
IList<StmtClassForgeableFactory> additionalForgeables)
{
TableColumns = tableColumns;
InternalEventType = internalEventType;
InternalEventTypePropertySerdes = internalEventTypePropertySerdes;
PublicEventType = publicEventType;
ColsPlain = colsPlain;
ColsAggMethod = colsAggMethod;
ColsAccess = colsAccess;
AggDesc = aggDesc;
PrimaryKeyColumns = primaryKeyColumns;
PrimaryKeyGetters = primaryKeyGetters;
PrimaryKeyTypes = primaryKeyTypes;
PrimaryKeyColNums = primaryKeyColNums;
PrimaryKeyMultikeyClasses = primaryKeyMultikeyClasses;
AdditionalForgeables = additionalForgeables;
}
public static CodegenExpression CodegenGetterMayMultiKey(
EventType eventType,
EventPropertyGetterSPI[] getters,
Type[] getterResultTypes,
Type[] optionalCoercionTypes,
MultiKeyClassRef multiKeyClassRef,
CodegenMethod method,
CodegenClassScope classScope)
{
if (getters == null || getters.Length == 0)
{
return(ConstantNull());
}
if (multiKeyClassRef != null && multiKeyClassRef.ClassNameMK != null)
{
return(CodegenMultiKeyGetter(eventType, getters, getterResultTypes, multiKeyClassRef, method, classScope));
}
return(EventTypeUtility.CodegenGetterWCoerce(
getters[0],
getterResultTypes[0],
optionalCoercionTypes?[0],
method,
typeof(MultiKeyCodegen),
classScope));
}
public StatementAgentInstanceFactoryOnTriggerInfraSelectForge(
ViewableActivatorForge activator,
EventType resultEventType,
IDictionary<ExprSubselectNode, SubSelectFactoryForge> subselects,
IDictionary<ExprTableAccessNode, ExprTableEvalStrategyFactoryForge> tableAccesses,
NamedWindowMetaData namedWindow,
TableMetaData table,
SubordinateWMatchExprQueryPlanForge queryPlanForge,
string resultSetProcessorProviderClassName,
bool insertInto,
bool addToFront,
TableMetaData optionalInsertIntoTable,
bool selectAndDelete,
bool distinct,
MultiKeyClassRef distinctMultiKey)
: base(activator, resultEventType, subselects, tableAccesses, null, namedWindow, table, queryPlanForge)
{
this.resultSetProcessorProviderClassName = resultSetProcessorProviderClassName;
this.insertInto = insertInto;
this.addToFront = addToFront;
this.optionalInsertIntoTable = optionalInsertIntoTable;
this.selectAndDelete = selectAndDelete;
this.distinct = distinct;
this.distinctMultiKey = distinctMultiKey;
}
public OutputProcessViewConditionForge(
OutputStrategyPostProcessForge outputStrategyPostProcessForge,
bool isDistinct,
MultiKeyClassRef distinctMultiKey,
ExprTimePeriod afterTimePeriodExpr,
int? afterNumberOfEvents,
OutputConditionFactoryForge outputConditionFactoryForge,
int streamCount,
ResultSetProcessorOutputConditionType conditionType,
bool terminable,
bool hasAfter,
bool unaggregatedUngrouped,
SelectClauseStreamSelectorEnum selectClauseStreamSelector,
EventType[] eventTypes,
EventType resultEventType)
{
_outputStrategyPostProcessForge = outputStrategyPostProcessForge;
_isDistinct = isDistinct;
_distinctMultiKey = distinctMultiKey;
_afterTimePeriodExpr = afterTimePeriodExpr;
_afterNumberOfEvents = afterNumberOfEvents;
_outputConditionFactoryForge = outputConditionFactoryForge;
_streamCount = streamCount;
_conditionType = conditionType;
_terminable = terminable;
_hasAfter = hasAfter;
_unaggregatedUngrouped = unaggregatedUngrouped;
_selectClauseStreamSelector = selectClauseStreamSelector;
_eventTypes = eventTypes;
_resultEventType = resultEventType;
}
public MultiKeyPlan(
IList<StmtClassForgeableFactory> multiKeyForgeables,
MultiKeyClassRef classRef)
{
MultiKeyForgeables = multiKeyForgeables;
ClassRef = classRef;
}
private static CodegenExpression CodegenMultikeyGetterBeanGet(
EventPropertyGetterSPI[] getters,
Type[] getterResultTypes,
MultiKeyClassRef multiKeyClassRef,
CodegenMethod method,
CodegenClassScope classScope)
{
var get = new CodegenExpressionLambda(method.Block)
.WithParams(CodegenNamedParam.From(typeof(EventBean), "bean"));
var lambda = NewInstance <ProxyEventPropertyValueGetter>(get);
var expressions = new CodegenExpression[getters.Length];
for (var i = 0; i < getters.Length; i++)
{
expressions[i] = getters[i].EventBeanGetCodegen(Ref("bean"), method, classScope);
var mkType = multiKeyClassRef.MKTypes[i];
var getterType = getterResultTypes[i];
expressions[i] = ExprNodeUtilityCodegen.CodegenCoerce(expressions[i], getterType, mkType, true);
}
var instance = multiKeyClassRef.ClassNameMK.Type != null
? NewInstance(multiKeyClassRef.ClassNameMK.Type, expressions)
: NewInstanceInner(multiKeyClassRef.ClassNameMK.Name, expressions);
get.Block.BlockReturn(instance);
return(lambda);
}
public static CodegenMethod CodegenMethod(
ExprNode[] expressionNodes,
MultiKeyClassRef multiKeyClassRef,
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var eventUnpackMethod = parent
.MakeChildWithScope(typeof(object), typeof(CodegenLegoMethodExpression), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
var exprMethod = eventUnpackMethod
.MakeChildWithScope(typeof(object), typeof(CodegenLegoMethodExpression), exprSymbol, classScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
var expressions = new CodegenExpression[expressionNodes.Length];
for (var i = 0; i < expressionNodes.Length; i++)
{
var forge = expressionNodes[i].Forge;
expressions[i] = CodegenExpressionMayCoerce(forge, multiKeyClassRef.MKTypes[i], exprMethod, exprSymbol, classScope);
}
var instance = multiKeyClassRef.ClassNameMK.Type != null
? NewInstance(multiKeyClassRef.ClassNameMK.Type, expressions)
: NewInstanceInner(multiKeyClassRef.ClassNameMK.Name, expressions);
exprSymbol.DerivedSymbolsCodegen(eventUnpackMethod, exprMethod.Block, classScope);
exprMethod.Block.MethodReturn(instance);
eventUnpackMethod.Block.MethodReturn(LocalMethod(exprMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT));
return(eventUnpackMethod);
}
public AggregationCodegenRowDetailDesc(
AggregationCodegenRowDetailStateDesc stateDesc,
AggregationAccessorSlotPairForge[] accessAccessors,
MultiKeyClassRef multiKeyClassRef)
{
StateDesc = stateDesc;
AccessAccessors = accessAccessors;
MultiKeyClassRef = multiKeyClassRef;
}
public override IList<StmtClassForgeableFactory> InitAdditionalForgeables(ViewForgeEnv viewForgeEnv)
{
var desc = MultiKeyPlanner.PlanMultiKey(
_criteriaExpressions,
false,
viewForgeEnv.StatementRawInfo,
viewForgeEnv.SerdeResolver);
_multiKeyClassNames = desc.ClassRef;
return desc.MultiKeyForgeables;
}
public static CodegenMethod GenerateGroupKeySingleCodegen(
ExprNode[] groupKeyExpressions,
MultiKeyClassRef optionalMultiKeyClasses,
CodegenClassScope classScope,
CodegenInstanceAux instance)
{
Consumer<CodegenMethod> code = methodNode => {
string[] expressions = null;
if (classScope.IsInstrumented) {
expressions = ExprNodeUtilityPrint.ToExpressionStringsMinPrecedence(groupKeyExpressions);
}
methodNode.Block.Apply(
Instblock(
classScope,
"qResultSetProcessComputeGroupKeys",
ExprForgeCodegenNames.REF_ISNEWDATA,
Constant(expressions),
REF_EPS));
if (optionalMultiKeyClasses != null && optionalMultiKeyClasses.ClassNameMK != null) {
var method = MultiKeyCodegen.CodegenMethod(groupKeyExpressions, optionalMultiKeyClasses, methodNode, classScope);
methodNode
.Block
.DeclareVar<object>("key", LocalMethod(method, REF_EPS, ExprForgeCodegenNames.REF_ISNEWDATA, MEMBER_AGENTINSTANCECONTEXT))
.Apply(Instblock(classScope, "aResultSetProcessComputeGroupKeys", ExprForgeCodegenNames.REF_ISNEWDATA, Ref("key")))
.MethodReturn(Ref("key"));
return;
}
if (groupKeyExpressions.Length > 1) {
throw new IllegalStateException("Multiple group-by expression and no multikey");
}
var expression = CodegenLegoMethodExpression.CodegenExpression(groupKeyExpressions[0].Forge, methodNode, classScope);
methodNode
.Block
.DeclareVar<object>("key", LocalMethod(expression, REF_EPS, ExprForgeCodegenNames.REF_ISNEWDATA, MEMBER_AGENTINSTANCECONTEXT))
.Apply(Instblock(classScope, "aResultSetProcessComputeGroupKeys", ExprForgeCodegenNames.REF_ISNEWDATA, Ref("key")))
.MethodReturn(Ref("key"));
};
return instance.Methods.AddMethod(
typeof(object),
"GenerateGroupKeySingle",
CodegenNamedParam.From(
typeof(EventBean[]),
NAME_EPS,
typeof(bool),
ResultSetProcessorCodegenNames.NAME_ISNEWDATA),
typeof(ResultSetProcessorUtil),
classScope,
code);
}
public RowRecogDescForge(
EventType parentEventType,
EventType rowEventType,
EventType compositeEventType,
EventType multimatchEventType,
int[] multimatchStreamNumToVariable,
int[] multimatchVariableToStreamNum,
ExprNode[] partitionBy,
MultiKeyClassRef partitionByMultiKey,
LocalMap variableStreams,
bool hasInterval,
bool iterateOnly,
bool unbound,
bool orTerminated,
bool collectMultimatches,
bool defineAsksMultimatches,
int numEventsEventsPerStreamDefine,
string[] multimatchVariablesArray,
RowRecogNFAStateForge[] startStates,
RowRecogNFAStateForge[] allStates,
bool allMatches,
MatchRecognizeSkipEnum skip,
ExprNode[] columnEvaluators,
string[] columnNames,
TimePeriodComputeForge intervalCompute,
int[] previousRandomAccessIndexes,
AggregationServiceForgeDesc[] aggregationServices)
{
this._parentEventType = parentEventType;
RowEventType = rowEventType;
this._compositeEventType = compositeEventType;
this._multimatchEventType = multimatchEventType;
this._multimatchStreamNumToVariable = multimatchStreamNumToVariable;
this._multimatchVariableToStreamNum = multimatchVariableToStreamNum;
this._partitionBy = partitionBy;
this._partitionByMultiKey = partitionByMultiKey;
this._variableStreams = variableStreams;
this._hasInterval = hasInterval;
this._iterateOnly = iterateOnly;
this._unbound = unbound;
this._orTerminated = orTerminated;
this._collectMultimatches = collectMultimatches;
this._defineAsksMultimatches = defineAsksMultimatches;
this._numEventsEventsPerStreamDefine = numEventsEventsPerStreamDefine;
this._multimatchVariablesArray = multimatchVariablesArray;
this._startStates = startStates;
this._allStates = allStates;
this._allMatches = allMatches;
this._skip = skip;
this._columnEvaluators = columnEvaluators;
this._columnNames = columnNames;
this._intervalCompute = intervalCompute;
this._previousRandomAccessIndexes = previousRandomAccessIndexes;
this._aggregationServices = aggregationServices;
}
public HistoricalIndexLookupStrategyCompositeForge(
int lookupStream,
ExprForge[] evaluators,
MultiKeyClassRef multiKeyClasses,
QueryGraphValueEntryRangeForge[] ranges)
{
this.lookupStream = lookupStream;
this.evaluators = evaluators;
this.multiKeyClasses = multiKeyClasses;
this.ranges = ranges;
}
public HistoricalIndexLookupStrategyHashForge(
int lookupStream,
ExprForge[] evaluators,
Type[] coercionTypes,
MultiKeyClassRef multiKeyClassRef)
{
_lookupStream = lookupStream;
_evaluators = evaluators;
_coercionTypes = coercionTypes;
_multiKeyClassRef = multiKeyClassRef;
}
public GroupByRollupInfo(
ExprNode[] exprNodes,
AggregationGroupByRollupDescForge rollupDesc,
IList<StmtClassForgeableFactory> additionalForgeables,
MultiKeyClassRef optionalMultiKey)
{
ExprNodes = exprNodes;
RollupDesc = rollupDesc;
AdditionalForgeables = additionalForgeables;
OptionalMultiKey = optionalMultiKey;
}
public PollResultIndexingStrategyHashForge(
int streamNum,
EventType eventType,
string[] propertyNames,
Type[] coercionTypes,
MultiKeyClassRef multiKeyClasses)
{
_streamNum = streamNum;
_eventType = eventType;
_propertyNames = propertyNames;
_coercionTypes = coercionTypes;
_multiKeyClasses = multiKeyClasses;
}
public SelectSubscriberDescriptor(
Type[] selectClauseTypes,
string[] selectClauseColumnNames,
bool forClauseDelivery,
ExprNode[] groupDelivery,
MultiKeyClassRef groupDeliveryMultiKey)
{
SelectClauseTypes = selectClauseTypes;
SelectClauseColumnNames = selectClauseColumnNames;
IsForClauseDelivery = forClauseDelivery;
GroupDelivery = groupDelivery;
GroupDeliveryMultiKey = groupDeliveryMultiKey;
}
public static CodegenMethod ComputeMultiKeyCodegen(
int idNumber,
ExprNode[] partitionForges,
MultiKeyClassRef optionalMultiKey,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods)
{
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
Consumer<CodegenMethod> code = method => {
if (optionalMultiKey == null || optionalMultiKey.ClassNameMK == null) {
var expression = partitionForges[0].Forge.EvaluateCodegen(typeof(object), method, exprSymbol, classScope);
exprSymbol.DerivedSymbolsCodegen(method, method.Block, classScope);
method.Block.MethodReturn(expression);
return;
}
var expressions = new CodegenExpression[partitionForges.Length];
for (var i = 0; i < partitionForges.Length; i++) {
expressions[i] = partitionForges[i].Forge
.EvaluateCodegen(
typeof(object),
method,
exprSymbol,
classScope);
}
var instance = optionalMultiKey.ClassNameMK.Type != null
? NewInstance(optionalMultiKey.ClassNameMK.Type, expressions)
: NewInstanceInner(optionalMultiKey.ClassNameMK.Name, expressions);
exprSymbol.DerivedSymbolsCodegen(method, method.Block, classScope);
method.Block.MethodReturn(instance);
};
return namedMethods.AddMethodWithSymbols(
typeof(object),
"ComputeKeyArrayCodegen_" + idNumber,
CodegenNamedParam.From(
typeof(EventBean[]),
NAME_EPS,
typeof(bool),
NAME_ISNEWDATA,
typeof(ExprEvaluatorContext),
NAME_EXPREVALCONTEXT),
typeof(AggregationServiceCodegenUtil),
classScope,
code,
exprSymbol);
}
public static void Assign(
ExprNode[] criteriaExpressions,
MultiKeyClassRef multiKeyClassNames,
CodegenMethod method,
CodegenExpressionRef factory,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenExpression criteriaEval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(criteriaExpressions, null, multiKeyClassNames, method, classScope);
method.Block
.SetProperty(factory, "CriteriaEval", criteriaEval)
.SetProperty(factory, "CriteriaTypes", Constant(ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions)))
.SetProperty(factory, "KeySerde", multiKeyClassNames.GetExprMKSerde(method, classScope));
}
public AggregationGroupByRollupLevelForge(
int levelNumber,
int levelOffset,
int[] rollupKeys,
Type[] allGroupKeyTypes,
MultiKeyClassRef allKeysMultikey,
MultiKeyClassRef subKeyMultikey)
{
_levelNumber = levelNumber;
_levelOffset = levelOffset;
_rollupKeys = rollupKeys;
_allGroupKeyTypes = allGroupKeyTypes;
_allKeysMultikey = allKeysMultikey;
_subKeyMultikey = subKeyMultikey;
}
public AggregationLocalGroupByLevelForge(
ExprForge[][] methodForges,
AggregationForgeFactory[] methodFactories,
AggregationStateFactoryForge[] accessStateForges,
ExprNode[] partitionForges,
MultiKeyClassRef partitionMkClasses,
bool defaultLevel)
{
MethodForges = methodForges;
MethodFactories = methodFactories;
AccessStateForges = accessStateForges;
PartitionForges = partitionForges;
PartitionMKClasses = partitionMkClasses;
IsDefaultLevel = defaultLevel;
}
public OutputProcessViewDirectDistinctOrAfterFactoryForge(
OutputStrategyPostProcessForge outputStrategyPostProcessForge,
bool isDistinct,
MultiKeyClassRef distinctMultiKey,
ExprTimePeriod afterTimePeriod,
int? afterConditionNumberOfEvents,
EventType resultEventType)
{
_outputStrategyPostProcessForge = outputStrategyPostProcessForge;
_isDistinct = isDistinct;
DistinctMultiKey = distinctMultiKey;
AfterTimePeriod = afterTimePeriod;
AfterConditionNumberOfEvents = afterConditionNumberOfEvents;
ResultEventType = resultEventType;
}
public AggGroupByDesc(
AggregationRowStateForgeDesc rowStateForgeDescs,
bool isUnidirectional,
bool isFireAndForget,
bool isOnSelect,
ExprNode[] groupByNodes,
MultiKeyClassRef groupByMultiKey)
{
RowStateForgeDescs = rowStateForgeDescs;
IsUnidirectional = isUnidirectional;
IsFireAndForget = isFireAndForget;
IsOnSelect = isOnSelect;
GroupByNodes = groupByNodes;
GroupByMultiKey = groupByMultiKey;
}
public static CodegenExpression CodegenMultiKeyFromArrayTransform(
MultiKeyClassRef optionalMultiKeyClasses,
CodegenMethod method,
CodegenClassScope classScope)
{
var fromLambda = new CodegenExpressionLambda(method.Block).WithParam <object[]>("keys");
var fromClass = NewInstance <ProxyMultiKeyFromObjectArray>(fromLambda);
// CodegenExpressionNewAnonymousClass fromClass = NewAnonymousClass(method.Block, typeof(MultiKeyFromObjectArray));
// CodegenMethod from = CodegenMethod
// .MakeParentNode(typeof(object), typeof(MultiKeyCodegen), classScope)
// .AddParam(typeof(object[]), "keys");
// fromClass.AddMethod("from", from);
if (optionalMultiKeyClasses == null || optionalMultiKeyClasses.ClassNameMK == null)
{
fromLambda.Block.BlockReturn(ArrayAtIndex(Ref("keys"), Constant(0)));
}
else if (optionalMultiKeyClasses.MKTypes.Length == 1)
{
var paramType = optionalMultiKeyClasses.MKTypes[0];
if (paramType == null || !paramType.IsArray)
{
fromLambda.Block.BlockReturn(ArrayAtIndex(Ref("keys"), Constant(0)));
}
else
{
var mktype = MultiKeyPlanner.GetMKClassForComponentType(paramType.GetElementType());
fromLambda.Block.BlockReturn(NewInstance(mktype, FlexCast(paramType, ArrayAtIndex(Ref("keys"), Constant(0)))));
}
}
else
{
var expressions = new CodegenExpression[optionalMultiKeyClasses.MKTypes.Length];
for (var i = 0; i < expressions.Length; i++)
{
expressions[i] = FlexCast(optionalMultiKeyClasses.MKTypes[i], ArrayAtIndex(Ref("keys"), Constant(i)));
}
var instance = optionalMultiKeyClasses.ClassNameMK.Type != null
? NewInstance(optionalMultiKeyClasses.ClassNameMK.Type, expressions)
: NewInstanceInner(optionalMultiKeyClasses.ClassNameMK.Name, expressions);
fromLambda.Block.BlockReturn(instance);
}
return(fromClass);
}
public PollResultIndexingStrategyCompositeForge(
int streamNum,
EventType eventType,
string[] optHashPropertyNames,
Type[] optHashCoercedTypes,
MultiKeyClassRef optHashMultiKeyClasses,
string[] rangeProps,
Type[] rangeTypes)
{
this.streamNum = streamNum;
this.eventType = eventType;
this.optHashPropertyNames = optHashPropertyNames;
this.optHashCoercedTypes = optHashCoercedTypes;
this.optHashMultiKeyClasses = optHashMultiKeyClasses;
this.rangeProps = rangeProps;
this.rangeTypes = rangeTypes;
}
public static CodegenExpression CodegenGetterEventDistinct(
bool isDistinct,
EventType eventType,
MultiKeyClassRef optionalDistinctMultiKey,
CodegenMethod method,
CodegenClassScope classScope)
{
if (!isDistinct)
{
return(ConstantNull());
}
var propertyNames = eventType.PropertyNames;
var spi = (EventTypeSPI)eventType;
if (propertyNames.Length == 1)
{
var propertyName = propertyNames[0];
var result = eventType.GetPropertyType(propertyName);
var getter = spi.GetGetterSPI(propertyName);
return(EventTypeUtility.CodegenGetterWCoerceWArray(
typeof(EventPropertyValueGetter),
getter,
result,
null,
method,
typeof(MultiKeyCodegen),
classScope));
}
var getters = new EventPropertyGetterSPI[propertyNames.Length];
var getterResultTypes = new Type[propertyNames.Length];
for (var i = 0; i < propertyNames.Length; i++)
{
getterResultTypes[i] = eventType.GetPropertyType(propertyNames[i]);
getters[i] = spi.GetGetterSPI(propertyNames[i]);
}
if (eventType is VariantEventType)
{
return(CodegenMultikeyGetterBeanGet(getters, getterResultTypes, optionalDistinctMultiKey, method, classScope));
}
return(CodegenGetterMayMultiKey(eventType, getters, getterResultTypes, null, optionalDistinctMultiKey, method, classScope));
}
public SubordCompositeTableLookupStrategyFactoryForge(
bool isNWOnTrigger,
int numStreams,
IList<SubordPropHashKeyForge> keyExpr,
Type[] coercionKeyTypes,
MultiKeyClassRef hashMultikeyClasses,
IList<SubordPropRangeKeyForge> rangeProps,
Type[] coercionRangeTypes)
{
_isNWOnTrigger = isNWOnTrigger;
_numStreams = numStreams;
_hashKeys = keyExpr;
_hashTypes = coercionKeyTypes;
_rangeProps = rangeProps;
_coercionRangeTypes = coercionRangeTypes;
_hashMultikeyClasses = hashMultikeyClasses;
}
public PropertyHashedFactoryFactoryForge(
int indexedStreamNum,
int? subqueryNum,
bool isFireAndForget,
string[] indexedProps,
EventType eventType,
bool unique,
CoercionDesc hashCoercionDesc,
MultiKeyClassRef multiKeyClassRef)
: base(indexedStreamNum, subqueryNum, isFireAndForget)
{
this.indexedProps = indexedProps;
this.eventType = eventType;
this.unique = unique;
this.hashCoercionDesc = hashCoercionDesc;
this.multiKeyClassRef = multiKeyClassRef;
}
