public CodegenExpression ComputeCodegen(CodegenExpression doubleValue)
{
return Op(doubleValue, "/", Constant(1000d));
}
public CodegenExpression CoerceCodegen(
CodegenExpression value,
Type valueType)
{
return value;
}
public CodegenExpression CoerceCodegen(
CodegenExpression value,
Type valueType)
{
return(CodegenFloat(value, valueType));
}
public CodegenExpression ToDateCodegen(CodegenExpression ts)
{
return StaticMethod(typeof(DateTimeEx), "UtcInstance", Op(ts, "/", Constant(1000)));
}
public static CodegenExpression CodegenEvaluatorReturnObjectOrArrayWCoerce(
ExprForge[] forges,
Type[] targetTypes,
bool arrayMultikeyWhenSingleEvaluator,
CodegenMethod method,
Type generator,
CodegenClassScope classScope)
{
var evaluate = new CodegenExpressionLambda(method.Block)
.WithParams(PARAMS);
var evaluator = NewInstance <ProxyExprEvaluator>(evaluate);
// CodegenMethod evaluate = CodegenMethod
// .MakeParentNode(typeof(object), generator, classScope)
// .AddParam(ExprForgeCodegenNames.PARAMS);
// evaluator.AddMethod("evaluate", evaluate);
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
var exprMethod = method
.MakeChildWithScope(typeof(object), typeof(CodegenLegoMethodExpression), exprSymbol, classScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
var expressions = new CodegenExpression[forges.Length];
for (var i = 0; i < forges.Length; i++)
{
expressions[i] = forges[i].EvaluateCodegen(forges[i].EvaluationType, exprMethod, exprSymbol, classScope);
}
exprSymbol.DerivedSymbolsCodegen(method, exprMethod.Block, classScope);
if (forges.Length == 0)
{
exprMethod.Block.MethodReturn(ConstantNull());
}
else if (forges.Length == 1)
{
var evaluationType = forges[0].EvaluationType;
CodegenExpression coerced;
if (arrayMultikeyWhenSingleEvaluator && evaluationType.IsArray)
{
var clazz = MultiKeyPlanner.GetMKClassForComponentType(evaluationType.GetElementType());
coerced = NewInstance(clazz, expressions[0]);
}
else
{
coerced = ExprNodeUtilityCodegen.CodegenCoerce(expressions[0], evaluationType, targetTypes?[0], false);
}
exprMethod.Block.MethodReturn(coerced);
}
else
{
exprMethod.Block.DeclareVar <object[]>("values", NewArrayByLength(typeof(object), Constant(forges.Length)));
for (var i = 0; i < forges.Length; i++)
{
var coerced = ExprNodeUtilityCodegen.CodegenCoerce(
expressions[i],
forges[i].EvaluationType,
targetTypes?[i],
false);
exprMethod.Block.AssignArrayElement("values", Constant(i), coerced);
}
exprMethod.Block.MethodReturn(Ref("values"));
}
evaluate.Block.BlockReturn(LocalMethod(exprMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT));
return(evaluator);
}
public CodegenExpression Codegen(CodegenExpression input) => ProcCodegen?.Invoke(input);
public CodegenExpression CoerceCodegen(
CodegenExpression value,
Type valueType)
{
return(CodegenDecimal(value, valueType));
}
public SAIFFInitializeBuilder Expression(
string name,
CodegenExpression expression)
{
return SetValue(name, expression == null ? ConstantNull() : expression);
}
public CodegenStatementThrow(CodegenExpression expression)
{
this.expression = expression;
}
public CodegenBlock WhileLoop(CodegenExpression expression)
{
return WhileOrDoLoop(expression, true);
}
public CodegenBlock DoLoop(CodegenExpression expression)
{
return WhileOrDoLoop(expression, false);
}
public CodegenBlock IfRefNullThrowException(
CodegenExpressionRef @ref,
CodegenExpression exceptionGenerator)
{
return IfRefNull(@ref).BlockThrow(exceptionGenerator);
}
public CodegenBlock DeclareVar<T>(
string var,
CodegenExpression initializer)
{
return DeclareVar(typeof(T), var, initializer);
}
private JsonDelegateRefs(CodegenExpression baseHandler)
{
BaseHandler = baseHandler;
}
public static CodegenExpression Codegen(
ExprDotForgeEnumMethodBase forge,
CodegenExpression inner,
Type innerType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var returnType = EPTypeHelper.GetCodegenReturnType(forge.TypeInfo);
var methodNode = codegenMethodScope
.MakeChild(returnType, typeof(ExprDotForgeEnumMethodEval), codegenClassScope)
.AddParam(innerType, "param");
methodNode.Block.DebugStack();
var refEPS = exprSymbol.GetAddEPS(methodNode);
var refIsNewData = exprSymbol.GetAddIsNewData(methodNode);
var refExprEvalCtx = exprSymbol.GetAddExprEvalCtx(methodNode);
var forgeMember = codegenClassScope.AddDefaultFieldUnshared(
true, typeof(object), NewInstance(typeof(object)));
var block = methodNode.Block;
//block.Debug("param: {0}", ExprDotMethod(Ref("param"), "RenderAny"));
if (innerType == typeof(EventBean)) {
block.DeclareVar<FlexCollection>("coll", FlexEvent(Ref("param")));
}
else if (innerType.IsGenericCollection()) {
block.DeclareVar(innerType, "coll", Ref("param"));
}
else {
throw new IllegalStateException("invalid type presented for unwrapping");
}
block.DeclareVar<ExpressionResultCacheForEnumerationMethod>(
"cache",
ExprDotMethodChain(refExprEvalCtx)
.Get("ExpressionResultCacheService")
.Get("AllocateEnumerationMethod"));
var premade = new EnumForgeCodegenParams(
Ref("eventsLambda"),
Ref("coll"),
innerType,
refIsNewData,
refExprEvalCtx);
if (forge.cache) {
block
.DeclareVar<ExpressionResultCacheEntryLongArrayAndObj>(
"cacheValue",
ExprDotMethod(Ref("cache"), "GetEnumerationMethodLastValue", forgeMember))
.IfCondition(NotEqualsNull(Ref("cacheValue")))
.BlockReturn(Cast(returnType, ExprDotName(Ref("cacheValue"), "Result")))
.IfRefNullReturnNull("coll")
.DeclareVar<EventBean[]>(
"eventsLambda",
StaticMethod(
typeof(ExprDotForgeEnumMethodEval),
"AllocateCopyEventLambda",
refEPS,
Constant(forge.enumEvalNumRequiredEvents)))
.DeclareVar(
EPTypeHelper.GetCodegenReturnType(forge.TypeInfo),
"result",
forge.enumForge.Codegen(premade, methodNode, codegenClassScope))
.Expression(
ExprDotMethod(Ref("cache"), "SaveEnumerationMethodLastValue", forgeMember, Ref("result")))
.MethodReturn(Ref("result"));
}
else {
var contextNumberMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(AtomicLong),
NewInstance(typeof(AtomicLong)));
var returnInvocation = forge.enumForge.Codegen(premade, methodNode, codegenClassScope);
block
.DeclareVar<long>("contextNumber", ExprDotMethod(contextNumberMember, "GetAndIncrement"))
.TryCatch()
.Expression(ExprDotMethod(Ref("cache"), "PushContext", Ref("contextNumber")))
.IfRefNullReturnNull("coll")
.DeclareVar<EventBean[]>(
"eventsLambda",
StaticMethod(
typeof(ExprDotForgeEnumMethodEval),
"AllocateCopyEventLambda",
refEPS,
Constant(forge.enumEvalNumRequiredEvents)))
.TryReturn(CodegenLegoCast.CastSafeFromObjectType(returnType, returnInvocation))
.TryFinally()
.Expression(ExprDotMethod(Ref("cache"), "PopContext"))
.BlockEnd()
.MethodEnd();
}
return LocalMethod(methodNode, inner);
}
public CodegenSetterBuilder Expression(
string name,
CodegenExpression expression)
{
return(SetValue(name, expression));
}
public override CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var manufacturer = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventBeanManufacturer),
eventManufacturer.Make(methodNode.Block, codegenMethodScope, codegenClassScope));
var block = methodNode.Block
.DeclareVar <object[]>(
"values",
CodegenExpressionBuilder.NewArrayByLength(
typeof(object),
CodegenExpressionBuilder.Constant(exprForges.Length)));
for (var i = 0; i < exprForges.Length; i++)
{
var expression = CodegenLegoMayVoid.ExpressionMayVoid(
exprForges[i].EvaluationType,
exprForges[i],
methodNode,
exprSymbol,
codegenClassScope);
if (wideners[i] == null)
{
block.AssignArrayElement("values", CodegenExpressionBuilder.Constant(i), expression);
}
else
{
var refname = "evalResult" + i;
block.DeclareVar(exprForges[i].EvaluationType, refname, expression);
if (exprForges[i].EvaluationType.CanBeNull())
{
block.IfRefNotNull(refname)
.AssignArrayElement(
"values",
CodegenExpressionBuilder.Constant(i),
wideners[i]
.WidenCodegen(
CodegenExpressionBuilder.Ref(refname),
methodNode,
codegenClassScope))
.BlockEnd();
}
else
{
block.AssignArrayElement(
"values",
CodegenExpressionBuilder.Constant(i),
wideners[i]
.WidenCodegen(
CodegenExpressionBuilder.Ref(refname),
methodNode,
codegenClassScope));
}
}
}
block.MethodReturn(
CodegenExpressionBuilder.ExprDotMethod(
manufacturer,
"Make",
CodegenExpressionBuilder.Ref("values")));
return(methodNode);
}
public abstract CodegenExpression Codegen(
CodegenExpression inner,
Type innerType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope);
public CodegenStatementReturnExpression(CodegenExpression expression)
{
_expression = expression ?? throw new ArgumentException("No expression provided");
}
public abstract CodegenExpression Codegen(
CodegenExpression start,
CodegenExpression end,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope);
public abstract CodegenExpression EventBeanGetCodegen(
CodegenExpression beanExpression,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope);
public static CodegenExpression CodegenEvaluatorMayMultiKeyWCoerce(
IList<ExprForge> forges,
IList<Type> optCoercionTypes,
CodegenMethod method,
Type generator,
CodegenClassScope classScope)
{
if (forges.Count == 1) {
return CodegenEvaluatorWCoerce(
forges[0],
optCoercionTypes?[0],
method,
generator,
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<object>(generator, classScope).AddParam(PARAMS);
//evaluator.AddMethod("Evaluate", evaluate);
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
var exprMethod = method.MakeChildWithScope(
typeof(object),
typeof(CodegenLegoMethodExpression),
exprSymbol,
classScope)
.AddParam(PARAMS);
var exprBlock = exprMethod.Block;
var expressions = new CodegenExpression[forges.Count];
for (var i = 0; i < forges.Count; i++) {
expressions[i] = forges[i].EvaluateCodegen(
forges[i].EvaluationType,
exprMethod,
exprSymbol,
classScope);
}
exprSymbol.DerivedSymbolsCodegen(exprMethod, exprBlock, classScope);
exprBlock.DeclareVar<object[]>(
"values",
NewArrayByLength(typeof(object), Constant(forges.Count)))
.DeclareVar<HashableMultiKey>("valuesMk", NewInstance<HashableMultiKey>(Ref("values")));
for (var i = 0; i < forges.Count; i++) {
var result = expressions[i];
if (optCoercionTypes != null &&
forges[i].EvaluationType.GetBoxedType() != optCoercionTypes[i].GetBoxedType()) {
var coercer = SimpleNumberCoercerFactory.GetCoercer(
forges[i].EvaluationType,
optCoercionTypes[i].GetBoxedType());
var name = "result_" + i;
exprBlock.DeclareVar(forges[i].EvaluationType, name, expressions[i]);
result = coercer.CoerceCodegen(Ref(name), forges[i].EvaluationType);
}
exprBlock.AssignArrayElement("values", Constant(i), result);
}
exprBlock.ReturnMethodOrBlock(Ref("valuesMk"));
evaluate.Block.ReturnMethodOrBlock(
LocalMethod(exprMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT));
return evaluator;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), this.GetType(), codegenClassScope);
methodNode.Block.DeclareVar(_jsonEventType.UnderlyingType, "und", NewInstanceInner(_jsonEventType.Detail.UnderlyingClassName));
for (var i = 0; i < _selectContext.ColumnNames.Length; i++)
{
var columnName = _selectContext.ColumnNames[i];
var fieldClassBoxed = Boxing.GetBoxedType(_jsonEventType.Detail.FieldDescriptors.Get(columnName).PropertyType);
var propertyType = _jsonEventType.Types.Get(columnName);
var evalType = _selectContext.ExprForges[i].EvaluationType;
var field = _jsonEventType.Detail.FieldDescriptors.Get(_selectContext.ColumnNames[i]);
CodegenExpression rhs = null;
// handle
if (evalType == typeof(EventBean))
{
var conversion = methodNode.MakeChild(fieldClassBoxed, this.GetType(), codegenClassScope).AddParam(typeof(object), "value");
conversion.Block
.IfRefNullReturnNull("value")
.MethodReturn(Cast(fieldClassBoxed, ExprDotName(Cast(typeof(EventBean), Ref("value")), "Underlying")));
rhs = LocalMethod(
conversion,
CodegenLegoMayVoid.ExpressionMayVoid(typeof(EventBean), _selectContext.ExprForges[i], methodNode, exprSymbol, codegenClassScope));
}
else if (propertyType is Type)
{
rhs = CodegenLegoMayVoid.ExpressionMayVoid(fieldClassBoxed, _selectContext.ExprForges[i], methodNode, exprSymbol, codegenClassScope);
}
else if (propertyType is TypeBeanOrUnderlying)
{
var underlyingType = ((TypeBeanOrUnderlying)propertyType).EventType.UnderlyingType;
var conversion = methodNode.MakeChild(underlyingType, this.GetType(), codegenClassScope).AddParam(typeof(object), "value");
conversion.Block
.IfRefNullReturnNull("value")
.IfInstanceOf("value", typeof(EventBean))
.BlockReturn(Cast(underlyingType, ExprDotUnderlying(Cast(typeof(EventBean), Ref("value")))))
.MethodReturn(Cast(underlyingType, Ref("value")));
rhs = LocalMethod(
conversion,
CodegenLegoMayVoid.ExpressionMayVoid(typeof(object), _selectContext.ExprForges[i], methodNode, exprSymbol, codegenClassScope));
}
else if (propertyType is TypeBeanOrUnderlying[])
{
var underlyingType = ((TypeBeanOrUnderlying[])propertyType)[0].EventType.UnderlyingType;
var underlyingArrayType = TypeHelper.GetArrayType(underlyingType);
var conversion = methodNode.MakeChild(underlyingArrayType, this.GetType(), codegenClassScope).AddParam(typeof(object), "value");
conversion.Block
.IfRefNullReturnNull("value")
.IfInstanceOf("value", underlyingArrayType)
.BlockReturn(Cast(underlyingArrayType, Ref("value")))
.DeclareVar <EventBean[]>("events", Cast(typeof(EventBean[]), Ref("value")))
.DeclareVar(underlyingArrayType, "array", NewArrayByLength(underlyingType, ArrayLength(Ref("events"))))
.ForLoopIntSimple("i", ArrayLength(Ref("events")))
.AssignArrayElement("array", Ref("i"), Cast(underlyingType, ExprDotUnderlying(ArrayAtIndex(Ref("events"), Ref("i")))))
.BlockEnd()
.MethodReturn(Ref("array"));
rhs = LocalMethod(
conversion,
CodegenLegoMayVoid.ExpressionMayVoid(typeof(object), _selectContext.ExprForges[i], methodNode, exprSymbol, codegenClassScope));
}
else if (propertyType == null)
{
methodNode.Block.Expression(
CodegenLegoMayVoid.ExpressionMayVoid(typeof(object), _selectContext.ExprForges[i], methodNode, exprSymbol, codegenClassScope));
}
else
{
throw new UnsupportedOperationException("Unrecognized property ");
}
if (rhs != null)
{
if (field.PropertyType.IsPrimitive)
{
var tmp = "result_" + i;
methodNode.Block
.DeclareVar(fieldClassBoxed, tmp, rhs)
.IfRefNotNull(tmp)
.AssignRef(ExprDotName(Ref("und"), field.FieldName), Unbox(Ref(tmp), fieldClassBoxed))
.BlockEnd();
}
else
{
methodNode.Block.AssignRef(ExprDotName(Ref("und"), field.FieldName), rhs);
}
}
}
methodNode.Block.MethodReturn(ExprDotMethod(eventBeanFactory, "AdapterForTypedJson", Ref("und"), resultEventType));
return(methodNode);
}
public void ProviderCodegen(
CodegenMethod method,
CodegenClassScope classScope,
AggregationClassNames classNames)
{
method.Block.DeclareVar<AggregationLocalGroupByLevel>("optionalTop", ConstantNull());
if (localGroupByPlan.OptionalLevelTopForge != null) {
method.Block.AssignRef(
"optionalTop",
localGroupByPlan.OptionalLevelTopForge.ToExpression(
classNames.RowFactoryTop,
classNames.RowSerdeTop,
ConstantNull(),
method,
classScope));
}
int numLevels = localGroupByPlan.AllLevelsForges.Length;
method.Block.DeclareVar<AggregationLocalGroupByLevel[]>(
"levels",
NewArrayByLength(typeof(AggregationLocalGroupByLevel), Constant(numLevels)));
for (var i = 0; i < numLevels; i++) {
AggregationLocalGroupByLevelForge forge = localGroupByPlan.AllLevelsForges[i];
CodegenExpression eval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(
forge.PartitionForges,
null,
forge.PartitionMKClasses,
method,
classScope);
method.Block.AssignArrayElement(
"levels",
Constant(i),
localGroupByPlan.AllLevelsForges[i]
.ToExpression(
classNames.GetRowFactoryPerLevel(i),
classNames.GetRowSerdePerLevel(i),
eval,
method,
classScope));
}
method.Block.DeclareVar<AggregationLocalGroupByColumn[]>(
"columns",
NewArrayByLength(
typeof(AggregationLocalGroupByColumn),
Constant(localGroupByPlan.ColumnsForges.Length)));
var rowLevelDesc = RowLevelDesc;
for (var i = 0; i < localGroupByPlan.ColumnsForges.Length; i++) {
AggregationLocalGroupByColumnForge col = localGroupByPlan.ColumnsForges[i];
int fieldNum;
if (hasGroupBy && col.IsDefaultGroupLevel) {
AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalAdditionalRows[col.LevelNum];
fieldNum = GetRowFieldNum(col, levelDesc);
}
else if (col.LevelNum == -1) {
AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalTopRow;
fieldNum = GetRowFieldNum(col, levelDesc);
}
else {
AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalAdditionalRows[col.LevelNum];
fieldNum = GetRowFieldNum(col, levelDesc);
}
method.Block.AssignArrayElement(
"columns",
Constant(i),
localGroupByPlan.ColumnsForges[i].ToExpression(fieldNum));
}
method.Block
.DeclareVar<AggregationServiceFactory>(
"svcFactory",
NewInstanceInner(classNames.ServiceFactory, Ref("this")))
.MethodReturn(
ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(AGGREGATIONSERVICEFACTORYSERVICE)
.Add(
"GroupLocalGroupBy",
Ref("svcFactory"),
useFlags.ToExpression(),
Constant(hasGroupBy),
Ref("optionalTop"),
Ref("levels"),
Ref("columns")));
}
public CodegenExpression ComputeCodegen(CodegenExpression doubleValue)
{
return TimePeriodAdderUtil.ComputeCodegenTimesMultiplier(doubleValue, MULTIPLIER);
}
public CodegenExpression CoerceBoxedBigIntCodegen(
CodegenExpression expr,
Type type)
{
return(CoerceCodegen(expr, type));
}
public CodegenExpression CoerceCodegen(
CodegenExpression value,
Type valueType)
{
return StaticMethod(typeof(ArrayCoercerFactory), "NarrowArray", value);
}
private CodegenExpression MakeInstrumentationProvider(
CodegenMethod method,
CodegenClassScope classScope)
{
if (!_instrumented) {
return ConstantNull();
}
var instrumentation = Ref("instrumentation");
method.Block.AssignRef(instrumentation, NewInstance<ProxyInstrumentationCommon>());
//var anonymousClass = NewAnonymousClass(
// method.Block,
// typeof(InstrumentationCommon));
//var activated = CodegenMethod.MakeMethod(typeof(bool), GetType(), classScope);
//activated.Block.MethodReturn(ConstantTrue());
method.Block.SetProperty(
instrumentation,
"ProcActivated",
new CodegenExpressionLambda(method.Block)
.WithBody(
block => block.BlockReturn(
ConstantTrue())));
foreach (var forwarded in typeof(InstrumentationCommon).GetMethods()) {
if (forwarded.DeclaringType == typeof(object)) {
continue;
}
if (forwarded.Name == "Activated") {
continue;
}
IList<CodegenNamedParam> @params = new List<CodegenNamedParam>();
var forwardedParameters = forwarded.GetParameters();
var expressions = new CodegenExpression[forwardedParameters.Length];
var num = 0;
foreach (var param in forwardedParameters) {
@params.Add(new CodegenNamedParam(param.ParameterType, param.Name));
expressions[num] = Ref(param.Name);
num++;
}
//var m = CodegenMethod.MakeMethod(typeof(void), GetType(), classScope)
// .AddParam(@params);
// Now we need a lambda to associate with the instrumentation and tie them together
var proc = $"Proc{forwarded.Name}";
method.Block.SetProperty(
instrumentation,
"ProcActivated",
new CodegenExpressionLambda(method.Block)
.WithParams(@params)
.WithBody(
block => block
.Apply(
InstrumentationCode.Instblock(
classScope,
forwarded.Name,
expressions))));
//instrumentation.AddMethod(forwarded.Name, m);
}
return instrumentation;
}
public abstract CodegenExpression EventBeanWithCtxGet(
CodegenExpression beanExpression,
CodegenExpression ctxExpression,
CodegenMethodScope parent,
CodegenClassScope classScope);
public CodegenExpression ToDateCodegen(CodegenExpression ts)
{
return StaticMethod(typeof(DateTimeEx), "UtcInstance", ts);
}
