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);
}
public CodegenExpression EvaluateMatchesCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
CodegenExpression aggService = classScope.NamespaceScope.AddOrGetDefaultFieldWellKnown(
new CodegenFieldNameSubqueryAgg(subselect.SubselectNumber),
typeof(AggregationResultFuture));
var method = parent.MakeChild(typeof(bool), GetType(), classScope);
var evalCtx = symbols.GetAddExprEvalCtx(method);
method.Block
.ApplyTri(new ReturnIfNoMatch(ConstantFalse(), ConstantFalse()), method, symbols)
.DeclareVar<int>("cpid", ExprDotName(evalCtx, "AgentInstanceId"))
.DeclareVar<AggregationService>(
"aggregationService",
ExprDotMethod(aggService, "GetContextPartitionAggregationService", Ref("cpid")))
.DeclareVar<ICollection<object>>(
"groupKeys",
ExprDotMethod(Ref("aggregationService"), "GetGroupKeys", evalCtx));
method.Block.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols);
var forEach = method.Block.ForEach(typeof(object), "groupKey", Ref("groupKeys"));
{
forEach.ExprDotMethod(
Ref("aggregationService"),
"SetCurrentAccess",
Ref("groupKey"),
Ref("cpid"),
ConstantNull());
CodegenLegoBooleanExpression.CodegenContinueIfNullOrNotPass(
forEach,
havingEval.EvaluationType,
havingEval.EvaluateCodegen(havingEval.EvaluationType, method, symbols, classScope));
forEach.BlockReturn(ConstantTrue());
}
method.Block.MethodReturn(ConstantFalse());
return LocalMethod(method);
}
protected override CodegenExpression CodegenEvaluateInternal(
CodegenMethodScope parent,
SubselectForgeNRSymbol 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);
var left = symbols.GetAddLeftResult(method);
method.Block
.DeclareVar<int>("cpid", ExprDotName(evalCtx, "AgentInstanceId"))
.DeclareVar<AggregationService>(
"aggregationService",
ExprDotMethod(aggService, "GetContextPartitionAggregationService", Ref("cpid")))
.DeclareVar<ICollection<object>>(
"groupKeys",
ExprDotMethod(Ref("aggregationService"), "GetGroupKeys", evalCtx))
.DeclareVar<bool>("hasNullRow", ConstantFalse());
var forEach = method.Block.ForEach(typeof(object), "groupKey", Ref("groupKeys"));
{
forEach.IfCondition(EqualsNull(left))
.BlockReturn(ConstantNull())
.ExprDotMethod(
Ref("aggregationService"),
"SetCurrentAccess",
Ref("groupKey"),
Ref("cpid"),
ConstantNull());
if (havingEval != null) {
CodegenLegoBooleanExpression.CodegenContinueIfNullOrNotPass(
forEach,
havingEval.EvaluationType,
havingEval.EvaluateCodegen(havingEval.EvaluationType, method, symbols, classScope));
}
Type valueRightType;
if (selectEval != null) {
valueRightType = Boxing.GetBoxedType(selectEval.EvaluationType);
forEach.DeclareVar(
valueRightType,
"valueRight",
selectEval.EvaluateCodegen(valueRightType, method, symbols, classScope));
}
else {
valueRightType = typeof(object);
forEach.DeclareVar(
valueRightType,
"valueRight",
ExprDotUnderlying(ArrayAtIndex(symbols.GetAddEPS(method), Constant(0))));
}
var ifRightNotNull = forEach.IfCondition(EqualsNull(Ref("valueRight")))
.AssignRef("hasNullRow", ConstantTrue())
.IfElse();
{
if (coercer == null) {
ifRightNotNull.DeclareVar<bool>("eq", ExprDotMethod(left, "Equals", Ref("valueRight")));
}
else {
ifRightNotNull.DeclareVar<object>("left", coercer.CoerceCodegen(left, symbols.LeftResultType))
.DeclareVar<object>("right", coercer.CoerceCodegen(Ref("valueRight"), valueRightType))
.DeclareVar<bool>("eq", StaticMethod<object>("Equals", Ref("left"), Ref("right")));
}
if (isNot) {
if (isAll) {
ifRightNotNull.IfCondition(Ref("eq")).BlockReturn(ConstantFalse());
}
else {
ifRightNotNull.IfCondition(Not(Ref("eq"))).BlockReturn(ConstantTrue());
}
}
else {
if (isAll) {
ifRightNotNull.IfCondition(Not(Ref("eq"))).BlockReturn(ConstantFalse());
}
else {
ifRightNotNull.IfCondition(Ref("eq")).BlockReturn(ConstantTrue());
}
}
}
}
method.Block
.IfCondition(Ref("hasNullRow"))
.BlockReturn(ConstantNull())
.MethodReturn(isAll ? ConstantTrue() : ConstantFalse());
return LocalMethod(method);
}
public override CodegenExpression EvaluateGetCollEventsCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
if (subselect.FilterExpr == null) {
if (subselect.SelectClause == null) {
return symbols.GetAddMatchingEvents(parent);
}
else {
if (subselect.subselectMultirowType == null) {
var eval = ((ExprIdentNode) subselect.SelectClause[0]).ExprEvaluatorIdent;
var method = parent.MakeChild(
typeof(FlexCollection),
this.GetType(),
classScope);
method.Block.DeclareVar<ICollection<EventBean>>(
"events",
NewInstance<ArrayDeque<EventBean>>(
ExprDotName(symbols.GetAddMatchingEvents(method), "Count")));
var @foreach = method.Block.ForEach(
typeof(EventBean),
"@event",
symbols.GetAddMatchingEvents(method));
{
@foreach.DeclareVar<EventBean>(
"fragment",
CodegenLegoCast.CastSafeFromObjectType(
typeof(EventBean),
eval.Getter.EventBeanFragmentCodegen(Ref("@event"), method, classScope)))
.IfRefNull("fragment")
.BlockContinue()
.ExprDotMethod(Ref("events"), "Add", Ref("fragment"));
}
method.Block.MethodReturn(FlexWrap(Ref("events")));
return LocalMethod(method);
}
// when selecting a combined output row that contains multiple fields
var methodX = parent.MakeChild(typeof(FlexCollection), this.GetType(), classScope);
var fieldEventType = classScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(
subselect.subselectMultirowType,
EPStatementInitServicesConstants.REF));
var eventBeanSvc =
classScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE);
methodX.Block
.DeclareVar<ICollection<EventBean>>(
"result",
NewInstance<ArrayDeque<EventBean>>(
ExprDotName(symbols.GetAddMatchingEvents(methodX), "Count")))
.ApplyTri(DECLARE_EVENTS_SHIFTED, methodX, symbols);
var foreachX = methodX.Block.ForEach(
typeof(EventBean),
"@event",
symbols.GetAddMatchingEvents(methodX));
{
foreachX.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("@event"))
.DeclareVar<IDictionary<string, object>>(
"row",
LocalMethod(
subselect.EvaluateRowCodegen(methodX, classScope),
REF_EVENTS_SHIFTED,
ConstantTrue(),
symbols.GetAddExprEvalCtx(methodX)))
.DeclareVar<EventBean>(
"rowEvent",
ExprDotMethod(eventBeanSvc, "AdapterForTypedMap", Ref("row"), fieldEventType))
.ExprDotMethod(Ref("result"), "Add", Ref("rowEvent"));
}
methodX.Block.MethodReturn(FlexWrap(Ref("result")));
return LocalMethod(methodX);
}
}
if (subselect.SelectClause != null) {
return ConstantNull();
}
// handle filtered
var methodY = parent.MakeChild(typeof(FlexCollection), this.GetType(), classScope);
methodY.Block.ApplyTri(DECLARE_EVENTS_SHIFTED, methodY, symbols);
methodY.Block.DeclareVar<ArrayDeque<EventBean>>("filtered", ConstantNull());
var foreachY = methodY.Block.ForEach(
typeof(EventBean),
"@event",
symbols.GetAddMatchingEvents(methodY));
{
foreachY.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("@event"));
var filter = CodegenLegoMethodExpression.CodegenExpression(subselect.FilterExpr, methodY, classScope, true);
CodegenLegoBooleanExpression.CodegenContinueIfNullOrNotPass(
foreachY,
typeof(bool?),
LocalMethod(
filter,
REF_EVENTS_SHIFTED,
symbols.GetAddIsNewData(methodY),
symbols.GetAddExprEvalCtx(methodY)));
foreachY.IfCondition(EqualsNull(Ref("filtered")))
.AssignRef("filtered", NewInstance(typeof(ArrayDeque<EventBean>)))
.BlockEnd()
.ExprDotMethod(Ref("filtered"), "Add", Ref("@event"));
}
methodY.Block.MethodReturn(FlexWrap(Ref("filtered")));
return LocalMethod(methodY);
}
public CodegenExpression EvaluateTypableMultirowCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
if (subselect.SelectClause == null) {
return ConstantNull();
}
if (subselect.FilterExpr == null) {
var method = parent.MakeChild(typeof(object[][]), GetType(), classScope);
method.Block
.DeclareVar<object[][]>(
"rows",
NewArrayByLength(typeof(object[]), ExprDotName(symbols.GetAddMatchingEvents(method), "Count")))
.DeclareVar<int>("index", Constant(-1))
.ApplyTri(SubselectForgeCodegenUtil.DECLARE_EVENTS_SHIFTED, method, symbols);
var foreachEvent = method.Block.ForEach(
typeof(EventBean),
"@event",
symbols.GetAddMatchingEvents(method));
{
foreachEvent
.IncrementRef("index")
.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("@event"))
.DeclareVar<object[]>(
"results",
NewArrayByLength(typeof(object), Constant(subselect.SelectClause.Length)))
.AssignArrayElement("rows", Ref("index"), Ref("results"));
for (var i = 0; i < subselect.SelectClause.Length; i++) {
var eval = CodegenLegoMethodExpression.CodegenExpression(subselect.SelectClause[i].Forge, method, classScope, true);
foreachEvent.AssignArrayElement(
"results",
Constant(i),
LocalMethod(
eval,
REF_EVENTS_SHIFTED,
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method)));
}
}
method.Block.MethodReturn(Ref("rows"));
return LocalMethod(method);
}
else {
var method = parent.MakeChild(typeof(object[][]), GetType(), classScope);
method.Block
.DeclareVar<ArrayDeque<object[]>>("rows", NewInstance(typeof(ArrayDeque<object[]>)))
.ApplyTri(SubselectForgeCodegenUtil.DECLARE_EVENTS_SHIFTED, method, symbols);
var foreachEvent = method.Block.ForEach(
typeof(EventBean),
"@event",
symbols.GetAddMatchingEvents(method));
{
foreachEvent.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("@event"));
var filter = CodegenLegoMethodExpression.CodegenExpression(subselect.FilterExpr, method, classScope, true);
CodegenLegoBooleanExpression.CodegenContinueIfNullOrNotPass(
foreachEvent,
typeof(bool?),
LocalMethod(
filter,
REF_EVENTS_SHIFTED,
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method)));
foreachEvent
.DeclareVar<object[]>(
"results",
NewArrayByLength(typeof(object), Constant(subselect.SelectClause.Length)))
.ExprDotMethod(Ref("rows"), "Add", Ref("results"));
for (var i = 0; i < subselect.SelectClause.Length; i++) {
var eval = CodegenLegoMethodExpression.CodegenExpression(subselect.SelectClause[i].Forge, method, classScope, true);
foreachEvent.AssignArrayElement(
"results",
Constant(i),
LocalMethod(
eval,
REF_EVENTS_SHIFTED,
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method)));
}
}
method.Block
.IfCondition(ExprDotMethod(Ref("rows"), "IsEmpty"))
.BlockReturn(EnumValue(typeof(CollectionUtil), "OBJECTARRAYARRAY_EMPTY"))
.MethodReturn(ExprDotMethod(Ref("rows"), "ToArray"));
return LocalMethod(method);
}
}
