private static void ProcessOutputLimitedLastAllNonBufferedCodegen(
ResultSetProcessorSimpleForge forge,
string methodName,
CodegenClassScope classScope,
CodegenMethod method,
CodegenInstanceAux instance)
{
var factory = classScope.AddOrGetDefaultFieldSharable(ResultSetProcessorHelperFactoryField.INSTANCE);
CodegenExpression eventTypes = classScope.AddDefaultFieldUnshared(
true,
typeof(EventType[]),
EventTypeUtility.ResolveTypeArrayCodegen(forge.EventTypes, EPStatementInitServicesConstants.REF));
if (forge.IsOutputAll) {
instance.AddMember(NAME_OUTPUTALLHELPER, typeof(ResultSetProcessorSimpleOutputAllHelper));
instance.ServiceCtor.Block.AssignRef(
NAME_OUTPUTALLHELPER,
ExprDotMethod(factory, "MakeRSSimpleOutputAll", Ref("this"), MEMBER_AGENTINSTANCECONTEXT, eventTypes));
method.Block.ExprDotMethod(Member(NAME_OUTPUTALLHELPER), methodName, REF_NEWDATA, REF_OLDDATA);
}
else if (forge.IsOutputLast) {
instance.AddMember(NAME_OUTPUTLASTHELPER, typeof(ResultSetProcessorSimpleOutputLastHelper));
instance.ServiceCtor.Block.AssignRef(
NAME_OUTPUTLASTHELPER,
ExprDotMethod(
factory,
"MakeRSSimpleOutputLast",
Ref("this"),
MEMBER_AGENTINSTANCECONTEXT,
eventTypes));
method.Block.ExprDotMethod(Member(NAME_OUTPUTLASTHELPER), methodName, REF_NEWDATA, REF_OLDDATA);
}
}
public static void ProcessOutputLimitedLastAllNonBufferedJoinCodegen(
ResultSetProcessorSimpleForge forge,
CodegenClassScope classScope,
CodegenMethod method,
CodegenInstanceAux instance)
{
ProcessOutputLimitedLastAllNonBufferedCodegen(forge, "ProcessJoin", classScope, method, instance);
}
public static void ContinueOutputLimitedLastAllNonBufferedJoinCodegen(
ResultSetProcessorSimpleForge forge,
CodegenClassScope classScope,
CodegenMethod method,
CodegenInstanceAux instance)
{
if (forge.IsOutputAll) {
method.Block.MethodReturn(ExprDotMethod(Member(NAME_OUTPUTALLHELPER), "OutputJoin", REF_ISSYNTHESIZE));
}
else if (forge.IsOutputLast) {
method.Block.MethodReturn(ExprDotMethod(Member(NAME_OUTPUTLASTHELPER), "OutputJoin", REF_ISSYNTHESIZE));
}
else {
method.Block.MethodReturn(ConstantNull());
}
}
public static void ProcessJoinResultCodegen(
ResultSetProcessorSimpleForge forge,
CodegenClassScope classScope,
CodegenMethod method,
CodegenInstanceAux instance)
{
method.Block.DeclareVar<EventBean[]>("selectOldEvents", ConstantNull())
.DeclareVarNoInit(typeof(EventBean[]), "selectNewEvents");
ResultSetProcessorUtil.ProcessJoinResultCodegen(
method,
classScope,
instance,
forge.OptionalHavingNode != null,
forge.IsSelectRStream,
forge.IsSorting,
false);
}
public static void GetEnumeratorJoinCodegen(
ResultSetProcessorSimpleForge forge,
CodegenClassScope classScope,
CodegenMethod method,
CodegenInstanceAux instance)
{
method.Block.DeclareVar<UniformPair<EventBean[]>>(
"result",
ExprDotMethod(
Ref("this"),
"ProcessJoinResult",
REF_JOINSET,
StaticMethod(typeof(Collections), "GetEmptySet", new[] {typeof(MultiKeyArrayOfKeys<EventBean>)}),
ConstantTrue()))
.IfRefNull("result")
.BlockReturn(
StaticMethod(typeof(Collections), "GetEmptyEnumerator", new[] {typeof(EventBean)}))
.MethodReturn(
ExprDotMethod(
StaticMethod(typeof(Arrays), "Enumerate", GetProperty(Ref("result"), "First")),
"GetEnumerator"));
}
public static void ProcessOutputLimitedViewCodegen(
ResultSetProcessorSimpleForge forge,
CodegenMethod method)
{
if (!forge.IsOutputLast) {
method.Block.DeclareVar<UniformPair<EventBean[]>>(
"pair",
StaticMethod(
typeof(EventBeanUtility),
EventBeanUtility.METHOD_FLATTENBATCHSTREAM,
REF_VIEWEVENTSLIST))
.MethodReturn(
ExprDotMethod(
Ref("this"),
"ProcessViewResult",
GetProperty(Ref("pair"), "First"),
GetProperty(Ref("pair"), "Second"),
REF_ISSYNTHESIZE));
return;
}
method.Block.MethodThrowUnsupported();
}
public static void ProcessOutputLimitedJoinCodegen(
ResultSetProcessorSimpleForge forge,
CodegenMethod method)
{
if (!forge.IsOutputLast) {
method.Block.DeclareVar<UniformPair<ISet<MultiKeyArrayOfKeys<EventBean>>>>(
"pair",
StaticMethod(
typeof(EventBeanUtility),
EventBeanUtility.METHOD_FLATTENBATCHJOIN,
REF_JOINEVENTSSET))
.MethodReturn(
ExprDotMethod(
Ref("this"),
"ProcessJoinResult",
GetProperty(Ref("pair"), "First"),
GetProperty(Ref("pair"), "Second"),
REF_ISSYNTHESIZE));
return;
}
method.Block.MethodThrowUnsupported();
}
public static void GetEnumeratorViewCodegen(
ResultSetProcessorSimpleForge forge,
CodegenClassScope classScope,
CodegenMethod method,
CodegenInstanceAux instance)
{
if (!forge.IsSorting) {
// Return an iterator that gives row-by-row a result
method.Block.MethodReturn(
NewInstance<TransformEventEnumerator>(
ExprDotMethod(REF_VIEWABLE, "GetEnumerator"),
NewInstance<ResultSetProcessorHandtruTransform>(Ref("this"))
));
return;
}
// Pull all events, generate order keys
method.Block
.DeclareVar<EventBean[]>("eventsPerStream", NewArrayByLength(typeof(EventBean), Constant(1)))
.DeclareVar<IList<EventBean>>("events", NewInstance(typeof(List<EventBean>)))
.DeclareVar<IList<object>>("orderKeys", NewInstance(typeof(List<object>)))
.DeclareVar<IEnumerator<EventBean>>("parentIterator", ExprDotMethod(REF_VIEWABLE, "GetEnumerator"))
.IfCondition(EqualsNull(Ref("parentIterator")))
.BlockReturn(PublicConstValue(typeof(CollectionUtil), "NULL_EVENT_ITERATOR"));
{
var loop = method.Block.ForEach(typeof(EventBean), "aParent", REF_VIEWABLE);
loop.AssignArrayElement("eventsPerStream", Constant(0), Ref("aParent"))
.DeclareVar<object>(
"orderKey",
ExprDotMethod(
REF_ORDERBYPROCESSOR,
"GetSortKey",
Ref("eventsPerStream"),
ConstantTrue(),
MEMBER_AGENTINSTANCECONTEXT));
if (forge.OptionalHavingNode == null) {
loop.DeclareVar<EventBean[]>(
"result",
StaticMethod(
typeof(ResultSetProcessorUtil),
ResultSetProcessorUtil.METHOD_GETSELECTEVENTSNOHAVING,
MEMBER_SELECTEXPRPROCESSOR,
Ref("eventsPerStream"),
ConstantTrue(),
ConstantTrue(),
MEMBER_AGENTINSTANCECONTEXT));
}
else {
var select = ResultSetProcessorUtil.GetSelectEventsHavingCodegen(classScope, instance);
loop.DeclareVar<EventBean[]>(
"result",
LocalMethod(
select,
MEMBER_SELECTEXPRNONMEMBER,
Ref("eventsPerStream"),
ConstantTrue(),
ConstantTrue(),
MEMBER_AGENTINSTANCECONTEXT));
}
loop.IfCondition(
And(NotEqualsNull(Ref("result")), Not(EqualsIdentity(ArrayLength(Ref("result")), Constant(0)))))
.ExprDotMethod(Ref("events"), "Add", ArrayAtIndex(Ref("result"), Constant(0)))
.ExprDotMethod(Ref("orderKeys"), "Add", Ref("orderKey"));
}
method.Block.DeclareVar<EventBean[]>(
"outgoingEvents",
StaticMethod(typeof(CollectionUtil), CollectionUtil.METHOD_TOARRAYEVENTS, Ref("events")))
.DeclareVar<object[]>(
"orderKeysArr",
StaticMethod(typeof(CollectionUtil), CollectionUtil.METHOD_TOARRAYOBJECTS, Ref("orderKeys")))
.DeclareVar<EventBean[]>(
"orderedEvents",
ExprDotMethod(
REF_ORDERBYPROCESSOR,
"SortWOrderKeys",
Ref("outgoingEvents"),
Ref("orderKeysArr"),
MEMBER_AGENTINSTANCECONTEXT))
.MethodReturn(
ExprDotMethod(
StaticMethod(typeof(Arrays), "Enumerate", Ref("orderedEvents")),
"GetEnumerator"));
}
