public CodegenExpression EvaluateCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(subselect.EvaluationType, GetType(), classScope);
var havingMethod = CodegenLegoMethodExpression.CodegenExpression(subselect.HavingExpr, method, classScope, true);
CodegenExpression having = LocalMethod(
havingMethod,
REF_EVENTS_SHIFTED,
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method));
method.Block.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols);
CodegenLegoBooleanExpression.CodegenReturnValueIfNotNullAndNotPass(
method.Block,
typeof(bool?),
having,
ConstantNull());
if (subselect.SelectClause.Length == 1) {
var eval = CodegenLegoMethodExpression.CodegenExpression(subselect.SelectClause[0].Forge, method, classScope, true);
method.Block.MethodReturn(
LocalMethod(eval, REF_EVENTS_SHIFTED, ConstantTrue(), symbols.GetAddExprEvalCtx(method)));
}
else {
method.Block.MethodReturn(LocalMethod(subselect.EvaluateRowCodegen(method, classScope)));
}
return LocalMethod(method);
}
public static CodegenExpression CodegenEvaluatorWCoerce(
ExprForge forge,
Type optCoercionType,
CodegenMethod method,
Type generator,
CodegenClassScope classScope)
{
var evaluate = new CodegenExpressionLambda(method.Block)
.WithParams(PARAMS);
var evaluator = NewInstance<ProxyExprEvaluator>(evaluate);
//var evaluator = NewAnonymousClass(method.Block, typeof(ExprEvaluator));
//var evaluate = CodegenMethod.MakeParentNode(typeof(object), generator, classScope)
// .AddParam(PARAMS);
//evaluator.AddMethod("Evaluate", evaluate);
var result = ConstantNull();
if (forge.EvaluationType != null) {
var evalMethod = CodegenLegoMethodExpression.CodegenExpression(forge, method, classScope, true);
result = LocalMethod(evalMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT);
var forgeEvaluationType = forge.EvaluationType.GetBoxedType();
if (optCoercionType != null && forgeEvaluationType != optCoercionType.GetBoxedType()) {
var coercer = SimpleNumberCoercerFactory.GetCoercer(
forgeEvaluationType,
optCoercionType.GetBoxedType());
evaluate.Block.DeclareVar(forgeEvaluationType, "result", result);
result = coercer.CoerceCodegen(Ref("result"), forge.EvaluationType);
}
}
evaluate.Block.BlockReturn(result);
return evaluator;
}
public static void GetEnumerableScalarCodegen(
AggregationAccessorLastWEvalForge forge,
AggregationStateLinearForge stateForge,
AggregationAccessorForgeGetCodegenContext context)
{
CodegenMethod childExpr = CodegenLegoMethodExpression.CodegenExpression(
forge.ChildNode,
context.Method,
context.ClassScope,
true);
context.Method.Block.DeclareVar<EventBean>(
"bean",
stateForge.AggregatorLinear.GetLastValueCodegen(
context.ClassScope,
context.Method,
context.NamedMethods))
.DebugStack()
.IfRefNullReturnNull("bean")
.DeclareVar<EventBean[]>(
"eventsPerStreamBuf",
NewArrayByLength(typeof(EventBean), Constant(forge.StreamNum + 1)))
.AssignArrayElement("eventsPerStreamBuf", Constant(forge.StreamNum), Ref("bean"))
.DeclareVar<object>(
"value",
LocalMethod(childExpr, Ref("eventsPerStreamBuf"), Constant(true), ConstantNull()))
.IfRefNullReturnNull("value")
.MethodReturn(StaticMethod(typeof(Collections), "SingletonList", Ref("value")));
}
public static CodegenExpression CodegenEvaluator(
ExprForge forge,
CodegenMethod method,
Type originator,
CodegenClassScope classScope)
{
var lambda = new CodegenExpressionLambda(method.Block)
.WithParams(LAMBDA_PARAMS);
if (forge.EvaluationType == null) {
lambda.Block.BlockReturn(ConstantNull());
return NewInstance<ProxyExprEvaluator>(lambda);
}
else if (forge.EvaluationType == typeof(void)) {
var evalMethod = CodegenLegoMethodExpression.CodegenExpression(forge, method, classScope);
lambda.Block
.LocalMethod(
evalMethod,
LAMBDA_REF_EPS,
LAMBDA_REF_ISNEWDATA,
LAMBDA_REF_EXPREVALCONTEXT)
.BlockReturn(ConstantNull());
}
else {
var evalMethod = CodegenLegoMethodExpression.CodegenExpression(forge, method, classScope, true);
lambda.Block.BlockReturn(
LocalMethod(
evalMethod,
LAMBDA_REF_EPS,
LAMBDA_REF_ISNEWDATA,
LAMBDA_REF_EXPREVALCONTEXT));
}
return NewInstance<ProxyExprEvaluator>(lambda);
}
public static void GetValueCodegen(
AggregationAccessorFirstLastIndexWEvalForge forge,
AggregationAccessorForgeGetCodegenContext context)
{
AggregationStateLinearForge stateForge = (AggregationStateLinearForge) context.AccessStateForge;
CodegenMethod getBeanFirstLastIndex = GetBeanFirstLastIndexCodegen(
forge,
context.Column,
context.ClassScope,
stateForge,
context.Method,
context.NamedMethods);
context.Method.Block.DeclareVar<EventBean>("bean", LocalMethod(getBeanFirstLastIndex))
.DebugStack()
.IfRefNullReturnNull("bean")
.DeclareVar<EventBean[]>(
"eventsPerStreamBuf",
NewArrayByLength(typeof(EventBean), Constant(forge.StreamNum + 1)))
.AssignArrayElement("eventsPerStreamBuf", Constant(forge.StreamNum), Ref("bean"))
.MethodReturn(
LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(
forge.ChildNode,
context.Method,
context.ClassScope,
true),
Ref("eventsPerStreamBuf"),
ConstantTrue(),
ConstantNull()));
}
private CodegenExpressionInstanceField CodegenFormatFieldInit(CodegenClassScope classScope)
{
var formatEvalDtx = CodegenLegoMethodExpression.CodegenExpression(
_formatter,
classScope.NamespaceScope.InitMethod,
classScope,
true);
var formatEval = LocalMethod(formatEvalDtx, ConstantNull(), ConstantTrue(), ConstantNull());
CodegenExpression init;
if (_formatterType.FormatterType != typeof(string)) {
init = formatEval;
}
else {
var parse = classScope.NamespaceScope.InitMethod.MakeChild(
typeof(DateFormat),
GetType(),
classScope);
parse.Block.MethodReturn(NewInstance<SimpleDateFormat>(formatEval));
init = LocalMethod(parse);
}
return classScope.AddDefaultFieldUnshared(
true,
typeof(DateFormat),
init);
}
public CodegenExpression EvaluateMatchesCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(bool), GetType(), classScope);
method.Block.ApplyTri(new ReturnIfNoMatch(ConstantFalse(), ConstantFalse()), method, symbols);
if (filterEval == null && havingEval == null) {
method.Block.MethodReturn(ConstantTrue());
return LocalMethod(method);
}
method.Block.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols);
if (havingEval != null) {
throw new UnsupportedOperationException();
}
var filter = CodegenLegoMethodExpression.CodegenExpression(filterEval, method, classScope, true);
method.Block
.ForEach(typeof(EventBean), "subselectEvent", symbols.GetAddMatchingEvents(method))
.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("subselectEvent"))
.DeclareVar<bool?>(
"pass",
LocalMethod(filter, REF_EVENTS_SHIFTED, ConstantTrue(), symbols.GetAddExprEvalCtx(method)))
.IfCondition(And(NotEqualsNull(Ref("pass")), Unbox(Ref("pass"))))
.BlockReturn(ConstantTrue())
.BlockEnd()
.MethodReturn(ConstantFalse());
return LocalMethod(method);
}
protected override CodegenExpression CodegenEvaluateInternal(
CodegenMethodScope parent,
SubselectForgeNRSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(bool?), GetType(), classScope);
var eps = symbols.GetAddEPS(method);
var evalCtx = symbols.GetAddExprEvalCtx(method);
var left = symbols.GetAddLeftResult(method);
method.Block.IfNullReturnNull(symbols.GetAddLeftResult(method));
if (havingEval != null) {
CodegenExpression having = LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(havingEval, method, classScope, true),
eps,
ConstantTrue(),
evalCtx);
CodegenLegoBooleanExpression.CodegenReturnValueIfNullOrNotPass(
method.Block,
havingEval.EvaluationType,
having,
ConstantNull());
}
CodegenExpression select = LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(selectEval, method, classScope, true),
eps,
ConstantTrue(),
evalCtx);
var rightEvalType = selectEval.EvaluationType.GetBoxedType();
method.Block
.DeclareVar(rightEvalType, "rhs", select)
.IfRefNullReturnNull("rhs");
if (coercer == null) {
method.Block.DeclareVar<bool>("eq", ExprDotMethod(left, "Equals", Ref("rhs")));
if (isNot) {
method.Block.IfCondition(Ref("eq")).BlockReturn(ConstantFalse());
}
else {
method.Block.IfCondition(Not(Ref("eq"))).BlockReturn(ConstantFalse());
}
}
else {
method.Block
.DeclareVar<object>("left", coercer.CoerceCodegen(left, symbols.LeftResultType))
.DeclareVar<object>("right", coercer.CoerceCodegen(Ref("rhs"), rightEvalType))
.DeclareVar<bool>("eq", StaticMethod<object>("Equals", Ref("left"), Ref("right")));
if (isNot) {
method.Block.IfCondition(Ref("eq")).BlockReturn(ConstantFalse());
}
else {
method.Block.IfCondition(Not(Ref("eq"))).BlockReturn(ConstantFalse());
}
}
method.Block.MethodReturn(ConstantTrue());
return LocalMethod(method);
}
public override CodegenExpression EvaluateGetCollScalarCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
if (subselect.FilterExpr == null) {
if (subselect.SelectClause == null) {
return ConstantNull();
}
else {
var method = parent.MakeChild(typeof(FlexCollection), this.GetType(), classScope);
method.Block
.DeclareVar<IList<object>>("result", NewInstance(typeof(List<object>)))
.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols);
var selectClause = GetSelectClauseExpr(method, symbols, classScope);
var @foreach = method.Block.ForEach(
typeof(EventBean),
"@event",
symbols.GetAddMatchingEvents(method));
{
@foreach.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("@event"))
.DeclareVar<object>("value", selectClause)
.ExprDotMethod(Ref("result"), "Add", Ref("value"));
}
method.Block.MethodReturn(FlexWrap(Ref("result")));
return LocalMethod(method);
}
}
if (subselect.SelectClause == null) {
return ConstantNull();
}
var methodX = parent.MakeChild(typeof(FlexCollection), this.GetType(), classScope);
methodX.Block
.DeclareVar<IList<object>>("result", NewInstance(typeof(List<object>)))
.ApplyTri(DECLARE_EVENTS_SHIFTED, methodX, symbols);
var selectClauseX = GetSelectClauseExpr(methodX, symbols, classScope);
var filter = CodegenLegoMethodExpression.CodegenExpression(subselect.FilterExpr, methodX, classScope, true);
var foreachX = methodX.Block.ForEach(
typeof(EventBean),
"@event",
symbols.GetAddMatchingEvents(methodX));
{
foreachX.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("@event"));
CodegenLegoBooleanExpression.CodegenContinueIfNullOrNotPass(
foreachX,
typeof(bool?),
LocalMethod(
filter,
REF_EVENTS_SHIFTED,
symbols.GetAddIsNewData(methodX),
symbols.GetAddExprEvalCtx(methodX)));
foreachX.DeclareVar<object>("value", selectClauseX)
.ExprDotMethod(Ref("result"), "Add", Ref("value"));
}
methodX.Block.MethodReturn(FlexWrap(Ref("result")));
return LocalMethod(methodX);
}
private static CodegenMethod GetComparableWMultiKeyCodegen(
ExprNode[] criteria,
CodegenExpressionRef @ref,
CodegenNamedMethods namedMethods,
CodegenClassScope classScope)
{
var methodName = "GetComparable_" + @ref.Ref;
Consumer<CodegenMethod> code = method => {
if (criteria.Length == 1) {
method.Block.MethodReturn(
LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(
criteria[0].Forge,
method,
classScope,
true),
REF_EPS,
REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
}
else {
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
var expressions = new CodegenExpression[criteria.Length];
for (var i = 0; i < criteria.Length; i++) {
expressions[i] = criteria[i]
.Forge.EvaluateCodegen(
typeof(object),
method,
exprSymbol,
classScope);
}
exprSymbol.DerivedSymbolsCodegen(method, method.Block, classScope);
method.Block.DeclareVar<object[]>(
"result",
NewArrayByLength(typeof(object), Constant(criteria.Length)));
for (var i = 0; i < criteria.Length; i++) {
method.Block.AssignArrayElement(Ref("result"), Constant(i), expressions[i]);
}
method.Block.MethodReturn(NewInstance<HashableMultiKey>(Ref("result")));
}
};
return namedMethods.AddMethod(
typeof(object),
methodName,
CodegenNamedParam.From(
typeof(EventBean[]),
NAME_EPS,
typeof(bool),
NAME_ISNEWDATA,
typeof(ExprEvaluatorContext),
NAME_EXPREVALCONTEXT),
typeof(AggregatorAccessSortedImpl),
classScope,
code);
}
public override CodegenExpression EvaluateCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
CodegenExpression aggService = classScope.NamespaceScope.AddOrGetDefaultFieldWellKnown(
new CodegenFieldNameSubqueryAgg(subselect.SubselectNumber),
typeof(AggregationResultFuture));
var method = parent.MakeChild(subselect.EvaluationType, this.GetType(), classScope);
var evalCtx = symbols.GetAddExprEvalCtx(method);
method.Block
.DeclareVar<int>("cpid", ExprDotName(evalCtx, "AgentInstanceId"))
.DeclareVar<ICollection<object>>(
"groupKeys",
ExprDotMethod(aggService, "GetGroupKeys", evalCtx))
.IfCondition(Not(EqualsIdentity(ExprDotName(Ref("groupKeys"), "Count"), Constant(1))))
.BlockReturn(ConstantNull())
.ExprDotMethod(
aggService,
"SetCurrentAccess",
ExprDotMethodChain(Ref("groupKeys")).Add("First"),
Ref("cpid"),
ConstantNull())
.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols)
.AssignArrayElement(
REF_EVENTS_SHIFTED,
Constant(0),
StaticMethod(
typeof(EventBeanUtility),
"GetNonemptyFirstEvent",
symbols.GetAddMatchingEvents(method)));
if (subselect.SelectClause.Length == 1) {
var eval = CodegenLegoMethodExpression.CodegenExpression(subselect.SelectClause[0].Forge, method, classScope, true);
method.Block.MethodReturn(
LocalMethod(eval, REF_EVENTS_SHIFTED, ConstantTrue(), symbols.GetAddExprEvalCtx(method)));
}
else {
var methodSelect = ExprNodeUtilityCodegen.CodegenMapSelect(
subselect.SelectClause,
subselect.SelectAsNames,
this.GetType(),
method,
classScope);
CodegenExpression select = LocalMethod(
methodSelect,
REF_EVENTS_SHIFTED,
ConstantTrue(),
symbols.GetAddExprEvalCtx(method));
method.Block.MethodReturn(select);
}
return LocalMethod(method);
}
public CodegenExpression EvaluateGetROCollectionScalarCodegen(
CodegenMethodScope parent,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
if (PreviousType == ExprPreviousNodePreviousType.PREVCOUNT) {
return ConstantNull();
}
if (PreviousType == ExprPreviousNodePreviousType.PREVWINDOW) {
var methodX = parent.MakeChild(typeof(ICollection<object>), GetType(), codegenClassScope);
methodX.Block
.DeclareVar<PreviousGetterStrategy>(
"strategy",
ExprDotMethod(
GetterField(codegenClassScope),
"GetStrategy",
exprSymbol.GetAddExprEvalCtx(methodX)))
.Apply(
new PreviousBlockGetSizeAndIterator(methodX, exprSymbol, StreamNumber, Ref("strategy")).Accept);
var eps = exprSymbol.GetAddEPS(methodX);
var innerEval = CodegenLegoMethodExpression.CodegenExpression(
ChildNodes[1].Forge,
methodX,
codegenClassScope,
true);
methodX.Block
.DeclareVar<EventBean>("originalEvent", ArrayAtIndex(eps, Constant(StreamNumber)))
.DeclareVar<ICollection<object>>("result", NewInstance<ArrayDeque<object>>(Ref("size")))
.ForLoopIntSimple("i", Ref("size"))
.AssignArrayElement(
eps,
Constant(StreamNumber),
Cast(typeof(EventBean), ExprDotMethod(Ref("events"), "Advance")))
.ExprDotMethod(
Ref("result"),
"Add",
LocalMethod(innerEval, eps, ConstantTrue(), exprSymbol.GetAddExprEvalCtx(methodX)))
.BlockEnd()
.AssignArrayElement(eps, Constant(StreamNumber), Ref("originalEvent"))
.MethodReturn(Ref("result"));
return LocalMethod(methodX);
}
var method = parent.MakeChild(typeof(ICollection<object>), GetType(), codegenClassScope);
method.Block.DeclareVar<object>(
"result",
EvaluateCodegenPrevAndTail(method, exprSymbol, codegenClassScope))
.IfRefNullReturnNull("result")
.MethodReturn(StaticMethod(typeof(Collections), "SingletonList", Ref("result")));
return LocalMethod(method);
}
protected internal static CodegenMethod GenerateOrderKeyCodegen(
string methodName,
OrderByElementForge[] orderBy,
CodegenClassScope classScope,
CodegenNamedMethods namedMethods)
{
Consumer<CodegenMethod> code = methodNode => {
if (orderBy.Length == 1) {
var expression = CodegenLegoMethodExpression.CodegenExpression(
orderBy[0].ExprNode.Forge,
methodNode,
classScope,
true);
methodNode.Block.MethodReturn(
LocalMethod(
expression,
EnumForgeCodegenNames.REF_EPS,
ResultSetProcessorCodegenNames.REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
return;
}
methodNode.Block.DeclareVar<object[]>(
"keys",
NewArrayByLength(typeof(object), Constant(orderBy.Length)));
for (var i = 0; i < orderBy.Length; i++) {
var expression = CodegenLegoMethodExpression.CodegenExpression(
orderBy[i].ExprNode.Forge,
methodNode,
classScope,
true);
methodNode.Block.AssignArrayElement(
"keys",
Constant(i),
LocalMethod(
expression,
EnumForgeCodegenNames.REF_EPS,
ResultSetProcessorCodegenNames.REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
}
methodNode.Block.MethodReturn(NewInstance<HashableMultiKey>(Ref("keys")));
};
return namedMethods.AddMethod(
typeof(object),
methodName,
CodegenNamedParam.From(
typeof(EventBean[]), NAME_EPS,
typeof(bool), NAME_ISNEWDATA,
typeof(ExprEvaluatorContext), NAME_EXPREVALCONTEXT),
typeof(ResultSetProcessorUtil),
classScope,
code);
}
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 CodegenExpression MakeCodegen(
CodegenClassScope classScope,
CodegenMethodScope parent)
{
var method = parent.MakeChild(typeof(double), GetType(), classScope);
var result = CodegenLegoMethodExpression.CodegenExpression(_runtimeConstant.Forge, method, classScope, true);
method.Block.MethodReturn(
ExprDotMethod(
LocalMethod(result, ConstantNull(), ConstantTrue(), ConstantNull()),
"AsDouble"));
return LocalMethod(method);
}
private static CodegenExpression FormatFieldExpr(
Type type,
ExprForge formatExpr,
CodegenClassScope codegenClassScope)
{
var formatEval = CodegenLegoMethodExpression.CodegenExpression(
formatExpr,
codegenClassScope.NamespaceScope.InitMethod,
codegenClassScope,
true);
CodegenExpression formatInit = LocalMethod(formatEval, ConstantNull(), ConstantTrue(), ConstantNull());
return codegenClassScope.AddDefaultFieldUnshared(true, type, formatInit);
}
public CodegenExpression EventBeanWithCtxGet(
CodegenExpression beanExpression,
CodegenExpression ctxExpression,
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var method = parent
.MakeChild(typeof(object), GetType(), classScope)
.AddParam(typeof(EventBean), "eventBean")
.AddParam(typeof(ExprEvaluatorContext), "ctx");
var getImpl = CodegenLegoMethodExpression.CodegenExpression(_lookupable.Forge, method, classScope);
method.Block
.DeclareVar<EventBean[]>("events", NewArrayWithInit(typeof(EventBean), Ref("eventBean")))
.MethodReturn(LocalMethod(getImpl, NewArrayWithInit(typeof(EventBean), Ref("eventBean")), ConstantTrue(), Ref("ctx")));
return LocalMethod(method, beanExpression, ctxExpression);
}
public override CodegenExpression EvaluateCodegenUninstrumented(
Type requiredType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
if (EvaluationType == typeof(void)) {
return Noop();
}
var initMethod = codegenClassScope.NamespaceScope.InitMethod;
var evaluate = CodegenLegoMethodExpression.CodegenExpression(_inner, initMethod, codegenClassScope, true);
return codegenClassScope.AddDefaultFieldUnshared(
true,
EvaluationType,
LocalMethod(evaluate, ConstantNull(), ConstantTrue(), ConstantNull()));
}
public CodegenExpression EventBeanGetCodegen(
CodegenExpression beanExpression,
CodegenMethodScope parent,
CodegenClassScope codegenClassScope)
{
var method = parent.MakeChild(exprForge.EvaluationType, GetType(), codegenClassScope)
.AddParam(typeof(EventBean), "bean");
var exprMethod =
CodegenLegoMethodExpression.CodegenExpression(exprForge, method, codegenClassScope, true);
method.Block
.DeclareVar<EventBean[]>("events", NewArrayByLength(typeof(EventBean), Constant(1)))
.AssignArrayElement(Ref("events"), Constant(0), Ref("bean"))
.MethodReturn(LocalMethod(exprMethod, Ref("events"), ConstantTrue(), ConstantNull()));
return LocalMethod(method, beanExpression);
}
private CodegenExpression GetSelectClauseExpr(
CodegenMethod method,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
if (subselect.SelectClause.Length == 1) {
var eval = CodegenLegoMethodExpression.CodegenExpression(subselect.SelectClause[0].Forge, method, classScope, true);
return LocalMethod(eval, REF_EVENTS_SHIFTED, ConstantTrue(), symbols.GetAddExprEvalCtx(method));
}
var methodSelect = ExprNodeUtilityCodegen.CodegenMapSelect(
subselect.SelectClause,
subselect.SelectAsNames,
this.GetType(),
method,
classScope);
return LocalMethod(methodSelect, REF_EVENTS_SHIFTED, ConstantTrue(), symbols.GetAddExprEvalCtx(method));
}
private static CodegenMethod GetBeanFirstLastIndexCodegen(
AggregationAccessorFirstLastIndexWEvalForge forge,
int column,
CodegenClassScope classScope,
AggregationStateLinearForge stateForge,
CodegenMethod parent,
CodegenNamedMethods namedMethods)
{
CodegenMethod method = parent.MakeChild(
typeof(EventBean),
typeof(AggregationAccessorFirstLastIndexWEval),
classScope);
if (forge.Constant == -1) {
Type evalType = forge.IndexNode.EvaluationType;
method.Block.DeclareVar(
evalType,
"indexResult",
LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(
forge.IndexNode,
method,
classScope,
true),
ConstantNull(),
ConstantTrue(),
ConstantNull()));
if (evalType.CanBeNull()) {
method.Block.IfRefNullReturnNull("indexResult");
}
method.Block.DeclareVar<int>(
"index",
SimpleNumberCoercerFactory.CoercerInt.CodegenInt(Ref("indexResult"), evalType));
}
else {
method.Block.DeclareVar<int>("index", Constant(forge.Constant));
}
CodegenExpression value = forge.IsFirst
? stateForge.AggregatorLinear.GetFirstNthValueCodegen(Ref("index"), method, classScope, namedMethods)
: stateForge.AggregatorLinear.GetLastNthValueCodegen(Ref("index"), method, classScope, namedMethods);
method.Block.MethodReturn(value);
return method;
}
public override CodegenExpression EvaluateCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
CodegenExpressionInstanceField eventToPublic =
TableDeployTimeResolver.MakeTableEventToPublicField(table, classScope, this.GetType());
CodegenMethod method = parent.MakeChild(subselect.EvaluationType, this.GetType(), classScope);
method.Block.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols);
method.Block.DeclareVar<EventBean>("filtered", ConstantNull());
CodegenBlock @foreach = method.Block.ForEach(
typeof(EventBean),
"@event",
symbols.GetAddMatchingEvents(method));
{
@foreach.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("@event"));
CodegenMethod filter = CodegenLegoMethodExpression.CodegenExpression(subselect.FilterExpr, method, classScope, true);
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
@foreach,
typeof(bool?),
LocalMethod(
filter,
REF_EVENTS_SHIFTED,
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method)));
@foreach.IfCondition(NotEqualsNull(Ref("filtered")))
.BlockReturn(ConstantNull())
.AssignRef("filtered", Ref("@event"));
}
method.Block.IfRefNullReturnNull("filtered")
.MethodReturn(
ExprDotMethod(
eventToPublic,
"ConvertToUnd",
Ref("filtered"),
symbols.GetAddEPS(method),
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method)));
return LocalMethod(method);
}
public CodegenExpression MakeCodegen(
CodegenClassScope classScope,
CodegenMethodScope parent)
{
var method = parent.MakeChild(typeof(object), GetType(), classScope).AddParam(GET_FILTER_VALUE_FP);
var rhsExpression = CodegenLegoMethodExpression.CodegenExpression(value.Forge, method, classScope);
var matchEventConvertor = convertor.Make(method, classScope);
CodegenExpression valueExpr = LocalMethod(rhsExpression, Ref("eps"), ConstantTrue(), REF_EXPREVALCONTEXT);
if (numberCoercer != null) {
valueExpr = numberCoercer.CoerceCodegenMayNullBoxed(valueExpr, value.Forge.EvaluationType, method, classScope);
}
method.Block
.DeclareVar<EventBean[]>("eps", LocalMethod(matchEventConvertor, REF_MATCHEDEVENTMAP))
.MethodReturn(valueExpr);
return LocalMethod(method, GET_FILTER_VALUE_REFS);
}
public CodegenExpression EventBeanGetCodegen(
CodegenExpression beanExpression,
CodegenMethodScope parent,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(typeof(object), this.GetType(), classScope)
.AddParam(typeof(EventBean), "eventBean");
CodegenMethod methodExpr = CodegenLegoMethodExpression.CodegenExpression(eval.Forge, method, classScope, true);
method.Block
.DeclareVar<EventBean[]>("events", NewArrayWithInit(typeof(EventBean), Ref("eventBean")))
.DeclareVar<object>("code", LocalMethod(methodExpr, Ref("events"), ConstantTrue(), ConstantNull()))
.MethodReturn(
StaticMethod(
typeof(ContextControllerHashedGetterHashSingleForge),
"ObjectToNativeHash",
Ref("code"),
Constant(granularity)));
return LocalMethod(method, beanExpression);
}
public static void GetValueCodegen(
AggregationAccessorFirstWEvalForge forge,
AggregationStateLinearForge accessStateFactory,
AggregationAccessorForgeGetCodegenContext context)
{
CodegenMethod childExpr = CodegenLegoMethodExpression.CodegenExpression(
forge.ChildNode,
context.Method,
context.ClassScope,
true);
context.Method.Block.DeclareVar<EventBean>(
"bean",
accessStateFactory.AggregatorLinear.GetFirstValueCodegen(context.ClassScope, context.Method))
.DebugStack()
.IfRefNullReturnNull("bean")
.DeclareVar<EventBean[]>(
"eventsPerStreamBuf",
NewArrayByLength(typeof(EventBean), Constant(forge.StreamNum + 1)))
.AssignArrayElement("eventsPerStreamBuf", Constant(forge.StreamNum), Ref("bean"))
.MethodReturn(LocalMethod(childExpr, Ref("eventsPerStreamBuf"), Constant(true), ConstantNull()));
}
public CodegenExpression EvaluateCodegenUninstrumented(
Type requiredType,
CodegenMethodScope parent,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var method = parent.MakeChild(EvaluationType, GetType(), codegenClassScope);
var innerEval = CodegenLegoMethodExpression.CodegenExpression(InnerForge, method, codegenClassScope, true);
var eps = exprSymbol.GetAddEPS(method);
// see ExprPriorEvalStrategyBase
CodegenExpression future = codegenClassScope.NamespaceScope.AddOrGetDefaultFieldWellKnown(
priorStrategyFieldName,
typeof(PriorEvalStrategy));
var innerMethod = LocalMethod(
innerEval,
eps,
exprSymbol.GetAddIsNewData(method),
exprSymbol.GetAddExprEvalCtx(method));
method.Block
.DeclareVar<EventBean>("originalEvent", ArrayAtIndex(eps, Constant(StreamNumber)))
.DeclareVar<EventBean>(
"substituteEvent",
ExprDotMethod(
future,
"GetSubstituteEvent",
Ref("originalEvent"),
exprSymbol.GetAddIsNewData(method),
Constant(ConstantIndexNumber),
Constant(RelativeIndex),
exprSymbol.GetAddExprEvalCtx(method),
Constant(StreamNumber)))
.AssignArrayElement(eps, Constant(StreamNumber), Ref("substituteEvent"))
.DeclareVar(EvaluationType, "evalResult", innerMethod)
.AssignArrayElement(eps, Constant(StreamNumber), Ref("originalEvent"))
.MethodReturn(Ref("evalResult"));
return LocalMethod(method);
}
public static void GetEnumerableScalarCodegen(
AggregationAccessorWindowWEvalForge forge,
AggregationStateLinearForge stateForge,
AggregationAccessorForgeGetCodegenContext context)
{
context.Method.Block
.DeclareVar<int>("size", stateForge.AggregatorLinear.SizeCodegen())
.IfCondition(EqualsIdentity(Ref("size"), Constant(0)))
.BlockReturn(ConstantNull())
.DeclareVar<IList<object>>("values", NewInstance<List<object>>(Ref("size")))
.DeclareVar<IEnumerator<EventBean>>(
"enumerator",
stateForge.AggregatorLinear.EnumeratorCodegen(
context.ClassScope,
context.Method,
context.NamedMethods))
.DebugStack()
.DeclareVar<EventBean[]>(
"eventsPerStreamBuf",
NewArrayByLength(typeof(EventBean), Constant(forge.StreamNum + 1)))
.WhileLoop(ExprDotMethod(Ref("enumerator"), "MoveNext"))
.DeclareVar<EventBean>("bean", Cast(typeof(EventBean), ExprDotName(Ref("enumerator"), "Current")))
.AssignArrayElement("eventsPerStreamBuf", Constant(forge.StreamNum), Ref("bean"))
.DeclareVar(
forge.ChildNode.EvaluationType.GetBoxedType(),
"value",
LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(
forge.ChildNode,
context.Method,
context.ClassScope,
true),
Ref("eventsPerStreamBuf"),
ConstantTrue(),
ConstantNull()))
.ExprDotMethod(Ref("values"), "Add", Ref("value"))
.BlockEnd()
.MethodReturn(Ref("values"));
}
private CodegenExpression EvaluateCodegenPrevAndTail(
CodegenMethodScope parent,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var method = parent.MakeChild(ResultType, GetType(), codegenClassScope);
var eps = exprSymbol.GetAddEPS(method);
var innerEval = CodegenLegoMethodExpression.CodegenExpression(
ChildNodes[1].Forge,
method,
codegenClassScope,
true);
method.Block
.IfCondition(Not(exprSymbol.GetAddIsNewData(method)))
.BlockReturn(ConstantNull())
.DeclareVar<EventBean>(
"substituteEvent",
LocalMethod(
GetSubstituteCodegen(method, exprSymbol, codegenClassScope),
eps,
exprSymbol.GetAddExprEvalCtx(method)))
.IfRefNullReturnNull("substituteEvent")
.DeclareVar<EventBean>("originalEvent", ArrayAtIndex(eps, Constant(StreamNumber)))
.AssignArrayElement(eps, Constant(StreamNumber), Ref("substituteEvent"))
.DeclareVar(
ResultType,
"evalResult",
LocalMethod(
innerEval,
eps,
exprSymbol.GetAddIsNewData(method),
exprSymbol.GetAddExprEvalCtx(method)))
.AssignArrayElement(eps, Constant(StreamNumber), Ref("originalEvent"))
.MethodReturn(Ref("evalResult"));
return LocalMethod(method);
}
public CodegenExpression EvaluateMatchesCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(bool), GetType(), classScope);
var havingMethod = CodegenLegoMethodExpression.CodegenExpression(havingEval, method, classScope, true);
CodegenExpression having = LocalMethod(
havingMethod,
REF_EVENTS_SHIFTED,
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method));
method.Block.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols);
CodegenLegoBooleanExpression.CodegenReturnValueIfNullOrNotPass(
method.Block,
typeof(bool?),
having,
ConstantFalse());
method.Block.MethodReturn(ConstantTrue());
return LocalMethod(method);
}
public override CodegenMethod MakeCodegen(
CodegenClassScope classScope,
CodegenMethodScope parent,
SAIFFInitializeSymbolWEventType symbols)
{
var method = parent
.MakeChild(typeof(FilterSpecParam), GetType(), classScope);
method.Block
.DeclareVar <ExprFilterSpecLookupable>(
"lookupable",
LocalMethod(lookupable.MakeCodegen(method, symbols, classScope)))
.DeclareVar <FilterOperator>("filterOperator", EnumValue(typeof(FilterOperator), filterOperator.GetName()));
var getFilterValue = new CodegenExpressionLambda(method.Block)
.WithParams(FilterSpecParam.GET_FILTER_VALUE_FP);
var inner = NewInstance <ProxyFilterSpecParam>(
Ref("lookupable"),
Ref("filterOperator"),
getFilterValue);
var rhsExpression = CodegenLegoMethodExpression.CodegenExpression(_value.Forge, method, classScope);
var matchEventConvertor = _convertor.Make(method, classScope);
CodegenExpression valueExpr = LocalMethod(rhsExpression, Ref("eps"), ConstantTrue(), REF_EXPREVALCONTEXT);
if (_numberCoercer != null)
{
valueExpr = _numberCoercer.CoerceCodegenMayNullBoxed(valueExpr, _value.Forge.EvaluationType, method, classScope);
}
getFilterValue.Block
.DeclareVar <EventBean[]>("eps", LocalMethod(matchEventConvertor, FilterSpecParam.REF_MATCHEDEVENTMAP))
.BlockReturn(FilterValueSetParamImpl.CodegenNew(valueExpr));
method.Block.MethodReturn(inner);
return(method);
}
