protected override void ApplyTableEnterNonNull(
CodegenExpressionRef value,
Type[] evaluationTypes,
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.ExprDotMethod(plugin, "Enter", value);
}
protected override void ApplyTableLeaveFiltered(
CodegenExpressionRef value,
Type[] evaluationTypes,
CodegenMethod method,
CodegenClassScope classScope)
{
// This is an "ever" aggregator and is designed for use in non-window env
}
public override void ApplyTableLeaveCodegen(
CodegenExpressionRef value,
Type[] evaluationTypes,
CodegenMethod method,
CodegenClassScope classScope)
{
// no-op
}
protected override CodegenExpression CallCodegen(
CodegenExpressionRef desc,
CodegenExpressionRef @object,
CodegenMethodScope parent,
CodegenClassScope codegenClassScope)
{
return(StaticMethod(typeof(DynamicIndexedPropertyGetterByField), "DynamicIndexedPropertyGet", desc, @object, Constant(_index)));
}
protected override void ApplyTableEnterNonNull(
CodegenExpressionRef value,
Type[] evaluationTypes,
CodegenMethod method,
CodegenClassScope classScope)
{
ApplyEvalEnterNonNull(method, ExprDotMethod(Cast(typeof(object), value), "AsDouble"));
}
protected override void InlineInitializeOnTriggerSpecific(
CodegenExpressionRef saiff,
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
method.Block.SetProperty(saiff, "MergeHelper", mergeHelperForge.Make(method, symbols, classScope));
}
protected override void CodegenInlineSet(
CodegenExpressionRef @ref,
CodegenMethod method,
ModuleTableInitializeSymbol symbols,
CodegenClassScope classScope)
{
method.Block.SetProperty(@ref, "FunctionName", Constant(_functionName));
}
protected override CodegenExpression CallCodegen(
CodegenExpressionRef desc,
CodegenExpressionRef @object,
CodegenMethodScope parent,
CodegenClassScope codegenClassScope)
{
return(StaticMethod(GetType(), "DynamicSimplePropertyCall", desc, @object));
}
internal override void Assign(
CodegenMethod method,
CodegenExpressionRef factory,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
ViewMultiKeyHelper.Assign(criteriaExpressions, multiKeyClassNames, method, factory, symbols, classScope);
}
protected override void ApplyTableLeaveNonNull(
CodegenExpressionRef value,
Type[] evaluationTypes,
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.ExprDotMethod(_vector, "Remove", ExprDotMethod(Cast(typeof(object), value), "AsDouble"));
}
internal override void Assign(
CodegenMethod method,
CodegenExpressionRef factory,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
method.Block.SetProperty(factory, "IsUnbound", Constant(unbound));
}
public abstract void WriteCodegen(
CodegenExpressionRef row,
int col,
CodegenExpressionRef @ref,
CodegenExpressionRef unitKey,
CodegenExpressionRef output,
CodegenMethod method,
CodegenClassScope classScope);
protected override void ApplyTableLeaveNonNull(
CodegenExpressionRef value,
Type[] evaluationTypes,
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.ExprDotMethod(refSet, "Remove", value);
}
protected override void ApplyTableEnterNonNull(
CodegenExpressionRef value,
Type[] evaluationTypes,
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.Apply(EnterConsumer(value));
}
protected override void ApplyTableLeaveFiltered(
CodegenExpressionRef value,
Type[] evaluationTypes,
CodegenMethod method,
CodegenClassScope classScope)
{
throw new UnsupportedOperationException("Not available with tables");
}
public AggregatorLeaving(
AggregationFactoryMethodLeaving factory,
int col,
CodegenMemberCol membersColumnized)
{
this.factory = factory;
leaving = membersColumnized.AddMember(col, typeof(bool), "leaving");
}
public void ApplyTableLeaveCodegen(
CodegenExpressionRef value,
Type[] evaluationTypes,
CodegenMethod method,
CodegenClassScope classScope)
{
method.Block.AssignRef(leaving, ConstantTrue());
}
protected override void ApplyTableEnterSum(
CodegenExpressionRef value,
Type[] evaluationTypes,
CodegenMethod method,
CodegenClassScope classScope)
{
ApplyTable(true, value, method, classScope);
}
protected override CodegenExpression ProcessSpecificCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenExpressionRef props,
CodegenClassScope codegenClassScope)
{
return ExprDotMethod(eventBeanFactory, "AdapterForTypedObjectArray", props, resultEventType);
}
public static CodegenExpression ReadNullable(
CodegenExpressionInstanceField serde,
CodegenExpressionRef input,
CodegenExpressionRef unitKey,
CodegenClassScope classScope)
{
return ExprDotMethod(serde, "Read", input, unitKey);
}
protected override void ApplyTableEnterNonNull(
CodegenExpressionRef value,
Type[] evaluationTypes,
CodegenMethod method,
CodegenClassScope classScope)
{
ApplyEvalEnterNonNull(value, method);
}
protected override void ApplyTableLeaveNonNull(
CodegenExpressionRef value,
Type[] evaluationTypes,
CodegenMethod method,
CodegenClassScope classScope)
{
// no op
}
protected abstract void WriteWODistinct(
CodegenExpressionRef row,
int col,
CodegenExpressionRef output,
CodegenExpressionRef unitKey,
CodegenExpressionRef writer,
CodegenMethod method,
CodegenClassScope classScope);
protected override void CodegenInlineSetWFilterWInputType(
CodegenExpressionRef @ref,
CodegenMethod method,
ModuleTableInitializeSymbol symbols,
CodegenClassScope classScope)
{
method.Block.SetProperty(@ref, "IsFirst", Constant(IsFirst));
}
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 CodegenExpressionRef GetAddInitSvc(CodegenMethodScope scope)
{
if (optionalInitServicesRef == null) {
optionalInitServicesRef = REF_INITSVC;
}
scope.AddSymbol(optionalInitServicesRef);
return optionalInitServicesRef;
}
internal override void Assign(
CodegenMethod method,
CodegenExpressionRef factory,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var sizeEval = CodegenEvaluator(sizeForge, method, GetType(), classScope);
method.Block.SetProperty(factory, "SizeEvaluator", sizeEval);
}
private static CodegenExpression CodegenCompare(
CodegenExpressionRef lhs,
Type lhsType,
CodegenExpressionRef rhs,
Type rhsType,
ExprCaseNodeForge forge,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
if (lhsType == null) {
return EqualsNull(rhs);
}
if (rhsType == null) {
return EqualsNull(lhs);
}
if (lhsType.CanNotBeNull() && rhsType.CanNotBeNull() && !forge.IsMustCoerce) {
return CodegenLegoCompareEquals.CodegenEqualsNonNullNoCoerce(lhs, lhsType, rhs, rhsType);
}
var block = codegenMethodScope
.MakeChild(typeof(bool), typeof(ExprCaseNodeForgeEvalSyntax2), codegenClassScope)
.AddParam(lhsType, "leftResult")
.AddParam(rhsType, "rightResult")
.Block;
if (lhsType.CanBeNull()) {
var ifBlock = block.IfCondition(EqualsNull(Ref("leftResult")));
if (rhsType.CanNotBeNull()) {
ifBlock.BlockReturn(ConstantFalse());
}
else {
ifBlock.BlockReturn(EqualsNull(Ref("rightResult")));
}
}
if (rhsType.CanBeNull()) {
block.IfCondition(EqualsNull(Ref("rightResult"))).BlockReturn(ConstantFalse());
}
CodegenMethod method;
if (!forge.IsMustCoerce) {
method = block.MethodReturn(
CodegenLegoCompareEquals.CodegenEqualsNonNullNoCoerce(
Ref("leftResult"),
lhsType,
Ref("rightResult"),
rhsType));
}
else {
block.DeclareVar<object>("left", forge.Coercer.CoerceCodegen(Ref("leftResult"), lhsType));
block.DeclareVar<object>("right", forge.Coercer.CoerceCodegen(Ref("rightResult"), rhsType));
method = block.MethodReturn(StaticMethod<object>("Equals", Ref("left"), Ref("right")));
}
return LocalMethodBuild(method).Pass(lhs).Pass(rhs).Call();
}
public CodegenExpressionRef GetAddEventType(CodegenMethodScope scope)
{
if (optionalEventTypeRef == null) {
optionalEventTypeRef = REF_EVENTTYPE;
}
scope.AddSymbol(optionalEventTypeRef);
return optionalEventTypeRef;
}
protected override void ApplyEvalLeaveNonNull(
CodegenExpressionRef value,
Type valueType,
CodegenMethod method,
ExprForgeCodegenSymbol symbols,
ExprForge[] forges,
CodegenClassScope classScope)
{
}
