public CodegenExpression Make(
CodegenMethodScope parent,
ModuleTableInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(TableMetaData), GetType(), classScope);
method.Block
.DeclareVar<TableMetaData>("meta", NewInstance(typeof(TableMetaData)))
.SetProperty(Ref("meta"), "TableName", Constant(TableName))
.SetProperty(Ref("meta"), "TableModuleName", Constant(TableModuleName))
.SetProperty(Ref("meta"), "TableVisibility", Constant(TableVisibility))
.SetProperty(Ref("meta"), "OptionalContextName", Constant(OptionalContextName))
.SetProperty(Ref("meta"), "OptionalContextVisibility", Constant(OptionalContextVisibility))
.SetProperty(Ref("meta"), "OptionalContextModule", Constant(OptionalContextModule))
.SetProperty(
Ref("meta"),
"InternalEventType",
EventTypeUtility.ResolveTypeCodegen(InternalEventType, symbols.GetAddInitSvc(method)))
.SetProperty(
Ref("meta"),
"PublicEventType",
EventTypeUtility.ResolveTypeCodegen(PublicEventType, symbols.GetAddInitSvc(method)))
.SetProperty(Ref("meta"), "KeyColumns", Constant(KeyColumns))
.SetProperty(Ref("meta"), "KeyTypes", Constant(KeyTypes))
.SetProperty(Ref("meta"), "KeyColNums", Constant(KeyColNums))
.SetProperty(
Ref("meta"),
"Columns",
TableMetadataColumn.MakeColumns(Columns, method, symbols, classScope))
.SetProperty(Ref("meta"), "NumMethodAggs", Constant(NumMethodAggs))
.ExprDotMethod(Ref("meta"), "Init")
.MethodReturn(Ref("meta"));
return LocalMethod(method);
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(PropertyEvaluatorNested), GetType(), classScope);
method.Block
.DeclareVar<PropertyEvaluatorNested>("pe", NewInstance(typeof(PropertyEvaluatorNested)))
.SetProperty(
Ref("pe"),
"ResultEventType",
EventTypeUtility.ResolveTypeCodegen(
fragmentEventTypes[fragmentEventTypes.Length - 1].FragmentType,
symbols.GetAddInitSvc(method)))
.SetProperty(Ref("pe"), "ExpressionTexts", Constant(expressionTexts))
.SetProperty(
Ref("pe"),
"WhereClauses",
PropertyEvaluatorAccumulativeForge.MakeWhere(whereClauses, method, symbols, classScope))
.SetProperty(
Ref("pe"),
"ContainedEventEvals",
PropertyEvaluatorAccumulativeForge.MakeContained(containedEventEvals, method, symbols, classScope))
.SetProperty(Ref("pe"), "FragmentEventTypeIsIndexed", Constant(fragmentEventTypesIsIndexed))
.MethodReturn(Ref("pe"));
return LocalMethod(method);
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventTypeOuter,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
// NOTE: Maintaining result-event-type as out own field as we may be an "inner" select-expr-processor
var mType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(_resultEventTypeAvro, EPStatementInitServicesConstants.REF));
var schema = codegenClassScope.NamespaceScope.AddDefaultFieldUnshared(
true,
typeof(RecordSchema),
CodegenExpressionBuilder.StaticMethod(
typeof(AvroSchemaUtil),
"ResolveRecordSchema",
EventTypeUtility.ResolveTypeCodegen(_resultEventTypeAvro, EPStatementInitServicesConstants.REF)));
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block.MethodReturn(
CodegenExpressionBuilder.StaticMethod(
typeof(SelectExprJoinWildcardProcessorAvro),
"ProcessSelectExprJoinWildcardAvro",
refEPS,
schema,
eventBeanFactory,
mType));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventTypeOuter,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
// NOTE: Maintaining result-event-type as out own field as we may be an "inner" select-expr-processor
var mType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(ResultEventType, EPStatementInitServicesConstants.REF));
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block
.DeclareVar<object[]>("tuple", NewArrayByLength(typeof(object), Constant(streamNames.Length)))
.StaticMethod(
typeof(Array),
"Copy",
refEPS,
Constant(0),
Ref("tuple"),
Constant(0),
Constant(streamNames.Length))
.MethodReturn(ExprDotMethod(eventBeanFactory, "AdapterForTypedObjectArray", Ref("tuple"), mType));
return methodNode;
}
public static CodegenExpression Codegen(
EnumCountOfSelectorScalarForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var typeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.type, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(typeof(int), typeof(EnumCountOfSelectorScalarForgeEval), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.DeclareVar<int>("count", Constant(0))
.DeclareVar<ObjectArrayEventBean>(
"evalEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), typeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("evalEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("evalEvent"), "Properties"));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(Ref("props"), Constant(0), Ref("next"));
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
forEach,
forge.InnerExpression.EvaluationType,
forge.InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope));
forEach.Increment("count");
block.MethodReturn(Ref("count"));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumTakeWhileScalarForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var typeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.type, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
typeof(FlexCollection),
typeof(EnumTakeWhileScalarForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var innerValue = forge.InnerExpression.EvaluateCodegen(
typeof(bool?),
methodNode,
scope,
codegenClassScope);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL);
block.DeclareVar<ObjectArrayEventBean>(
"evalEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), typeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("evalEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("evalEvent"), "Properties"));
var blockSingle = block
.IfCondition(EqualsIdentity(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), Constant(1)))
.DeclareVar<object>(
"item",
ExprDotMethodChain(EnumForgeCodegenNames.REF_ENUMCOLL).Add("First"))
.AssignArrayElement("props", Constant(0), Ref("item"));
CodegenLegoBooleanExpression.CodegenReturnValueIfNotNullAndNotPass(
blockSingle,
forge.InnerExpression.EvaluationType,
innerValue,
FlexEmpty());
blockSingle.BlockReturn(FlexValue(Ref("item")));
block.DeclareVar<ArrayDeque<object>>("result", NewInstance(typeof(ArrayDeque<object>)));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"));
CodegenLegoBooleanExpression.CodegenBreakIfNotNullAndNotPass(
forEach,
forge.InnerExpression.EvaluationType,
innerValue);
forEach.Expression(ExprDotMethod(Ref("result"), "Add", Ref("next")));
block.MethodReturn(FlexWrap(Ref("result")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
protected override CodegenExpression CodegenEventsPerStreamRewritten(
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var method = codegenMethodScope.MakeChild(typeof(EventBean[]), typeof(ExprDeclaredForgeRewriteWValue), codegenClassScope);
var valueType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(typeof(ObjectArrayEventType), EventTypeUtility.ResolveTypeCodegen(_valueEventType, EPStatementInitServicesConstants.REF)));
method.Block
.DeclareVar<object[]>("props", NewArrayByLength(typeof(object), Constant(_valueExpressions.Count)))
.DeclareVar<EventBean[]>("events", NewArrayByLength(typeof(EventBean), Constant(_eventEnumerationForges.Length)))
.AssignArrayElement("events", Constant(0), NewInstance(typeof(ObjectArrayEventBean), Ref("props"), valueType));
for (var i = 0; i < _valueExpressions.Count; i++) {
method.Block.AssignArrayElement(
"props",
Constant(i),
_valueExpressions[i].Forge.EvaluateCodegen(typeof(object), method, exprSymbol, codegenClassScope));
}
for (var i = 1; i < _eventEnumerationForges.Length; i++) {
method.Block.AssignArrayElement(
"events",
Constant(i),
_eventEnumerationForges[i].EvaluateGetEventBeanCodegen(method, exprSymbol, codegenClassScope));
}
method.Block.MethodReturn(Ref("events"));
return LocalMethod(method);
}
private static CodegenExpression MakeCopyMethods(
IDictionary <EventTypeSPI, EventBeanCopyMethodForge> copyMethods,
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
if (copyMethods.IsEmpty())
{
return(EnumValue(typeof(EmptyDictionary <EventTypeSPI, EventBeanCopyMethod>), "Instance"));
}
var method = parent.MakeChild(
typeof(IDictionary <EventTypeSPI, EventBeanCopyMethod>),
typeof(VariableReadWritePackageForge),
classScope);
method.Block.DeclareVar <IDictionary <EventTypeSPI, EventBeanCopyMethod> >(
"methods",
NewInstance <Dictionary <EventTypeSPI, EventBeanCopyMethod> >(Constant(copyMethods.Count)));
foreach (var entry in copyMethods)
{
var type = EventTypeUtility.ResolveTypeCodegen(entry.Key, symbols.GetAddInitSvc(method));
var copyMethod = entry.Value.MakeCopyMethodClassScoped(classScope);
method.Block.ExprDotMethod(Ref("methods"), "Put", type, copyMethod);
}
method.Block.MethodReturn(Ref("methods"));
return(LocalMethod(method));
}
public CodegenMethod InitializeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(TypeOfSubclass(), GetType(), classScope);
method.Block
.DeclareVar(TypeOfSubclass(), "saiff", NewInstance(TypeOfSubclass()))
.SetProperty(Ref("saiff"), "Activator", activator.MakeCodegen(method, symbols, classScope))
.SetProperty(
Ref("saiff"),
"ResultEventType",
EventTypeUtility.ResolveTypeCodegen(resultEventType, symbols.GetAddInitSvc(method)))
.SetProperty(
Ref("saiff"),
"Subselects",
SubSelectFactoryForge.CodegenInitMap(subselects, GetType(), method, symbols, classScope))
.SetProperty(
Ref("saiff"),
"TableAccesses",
ExprTableEvalStrategyUtil.CodegenInitMap(tableAccesses, GetType(), method, symbols, classScope));
InlineInitializeOnTriggerBase(Ref("saiff"), method, symbols, classScope);
method.Block.MethodReturn(Ref("saiff"));
return method;
}
public static CodegenExpression Codegen(
SelectExprProcessorTypableMapForge forge,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenExpression mapType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(forge.MapType, EPStatementInitServicesConstants.REF));
CodegenExpression beanFactory =
codegenClassScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE);
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
typeof(SelectExprProcessorTypableMapEval),
codegenClassScope);
methodNode.Block
.DeclareVar<IDictionary<string, object>>(
"values",
forge.innerForge.EvaluateCodegen(
typeof(IDictionary<string, object>),
methodNode,
exprSymbol,
codegenClassScope))
.DeclareVarNoInit(typeof(IDictionary<string, object>), "map")
.IfRefNull("values")
.AssignRef("values", StaticMethod(typeof(Collections), "GetEmptyMap", new[] { typeof(string), typeof(object) }))
.BlockEnd()
.MethodReturn(ExprDotMethod(beanFactory, "AdapterForTypedMap", Ref("values"), mapType));
return LocalMethod(methodNode);
}
public CodegenExpression MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(ViewableActivator), typeof(ViewableActivatorPatternForge), classScope);
var childCode = _spec.Root.MakeCodegen(method, symbols, classScope);
method.Block
.DeclareVar<EvalRootFactoryNode>("root", LocalMethod(childCode))
.DeclareVar<ViewableActivatorPattern>(
"activator",
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPStatementInitServicesConstants.VIEWABLEACTIVATORFACTORY)
.Add("CreatePattern"))
.SetProperty(Ref("activator"), "RootFactoryNode", Ref("root"))
.SetProperty(
Ref("activator"),
"EventBeanTypedEventFactory",
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPStatementInitServicesConstants.EVENTBEANTYPEDEVENTFACTORY))
.DeclareVar<EventType>(
"eventType",
EventTypeUtility.ResolveTypeCodegen(_eventType, symbols.GetAddInitSvc(method)))
.SetProperty(Ref("activator"), "EventType", Ref("eventType"))
.SetProperty(Ref("activator"), "PatternContext", _patternContext.Make(method, symbols, classScope))
.SetProperty(Ref("activator"), "HasConsumingFilter", Constant(_spec.IsConsumingFilters))
.SetProperty(Ref("activator"), "SuppressSameEventMatches", Constant(_spec.IsSuppressSameEventMatches))
.SetProperty(Ref("activator"), "DiscardPartialsOnMatch", Constant(_spec.IsDiscardPartialsOnMatch))
.SetProperty(Ref("activator"), "CanIterate", Constant(_isCanIterate))
.MethodReturn(Ref("activator"));
return LocalMethod(method);
}
public CodegenExpression Make(
CodegenBlock codegenBlock,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var factory = codegenClassScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE);
var eventType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(_beanEventType, EPStatementInitServicesConstants.REF));
var makeUndLambda = new CodegenExpressionLambda(codegenBlock)
.WithParam<object[]>("properties")
.WithBody(block => MakeUnderlyingCodegen(codegenMethodScope, block, codegenClassScope));
var manufacturer = NewInstance<ProxyBeanEventBeanManufacturer>(
eventType, factory, makeUndLambda);
//var manufacturer = NewAnonymousClass(init.Block, typeof(EventBeanManufacturer));
//var makeUndMethod = CodegenMethod.MakeMethod(typeof(object), GetType(), codegenClassScope)
// .AddParam(typeof(object[]), "properties");
//manufacturer.AddMethod("MakeUnderlying", makeUndMethod);
//MakeUnderlyingCodegen(makeUndMethod, codegenClassScope);
//var makeMethod = CodegenMethod.MakeMethod(typeof(EventBean), GetType(), codegenClassScope)
// .AddParam(typeof(object[]), "properties");
//manufacturer.AddMethod("Make", makeMethod);
//makeMethod.Block
// .DeclareVar<object>("und", LocalMethod(makeUndMethod, Ref("properties")))
// .MethodReturn(ExprDotMethod(factory, "AdapterForTypedObject", Ref("und"), beanType));
return codegenClassScope.AddDefaultFieldUnshared(true, typeof(EventBeanManufacturer), manufacturer);
}
public CodegenExpression InitCtorScoped()
{
var type = Cast(
typeof(VariantEventType),
EventTypeUtility.ResolveTypeCodegen(variantEventType, EPStatementInitServicesConstants.REF));
return ExprDotName(type, "VariantPropertyGetterCache");
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventTypeOuter,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
// NOTE: Maintaining result-event-type as out own field as we may be an "inner" select-expr-processor
var mType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(resultEventType, EPStatementInitServicesConstants.REF));
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block
.DeclareVar(resultEventType.UnderlyingType, "tuple", NewInstanceInner(resultEventType.Detail.UnderlyingClassName));
for (var i = 0; i < streamNames.Length; i++) {
var @event = ArrayAtIndex(refEPS, Constant(i));
var field = resultEventType.Detail.FieldDescriptors.Get(streamNames[i]);
var rhs = Cast(field.PropertyType, ExprDotUnderlying(@event));
methodNode.Block.AssignRef(ExprDotName(Ref("tuple"), field.FieldName), rhs);
}
methodNode.Block.MethodReturn(ExprDotMethod(eventBeanFactory, "AdapterForTypedJson", Ref("tuple"), mType));
return methodNode;
}
private CodegenExpression GetDefinition(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(ContextDefinition), GetType(), classScope);
// controllers
method.Block.DeclareVar<ContextControllerFactory[]>(
"controllers",
NewArrayByLength(typeof(ContextControllerFactory), Constant(forges.Length)));
for (var i = 0; i < forges.Length; i++) {
method.Block
.AssignArrayElement(
"controllers",
Constant(i),
LocalMethod(forges[i].MakeCodegen(classScope, method, symbols)))
.ExprDotMethod(
ArrayAtIndex(Ref("controllers"), Constant(i)),
"WithFactoryEnv",
forges[i].FactoryEnv.ToExpression());
}
method.Block.DeclareVar<ContextDefinition>("def", NewInstance(typeof(ContextDefinition)))
.SetProperty(Ref("def"), "ContextName", Constant(contextName))
.SetProperty(Ref("def"), "ControllerFactories", Ref("controllers"))
.SetProperty(
Ref("def"),
"EventTypeContextProperties",
EventTypeUtility.ResolveTypeCodegen(
eventTypeContextProperties,
EPStatementInitServicesConstants.REF))
.MethodReturn(Ref("def"));
return LocalMethod(method);
}
private void MakeUnderlyingCodegen(
CodegenBlock block,
CodegenClassScope codegenClassScope)
{
var schema = codegenClassScope.NamespaceScope.AddDefaultFieldUnshared(
true,
typeof(RecordSchema),
StaticMethod(
typeof(AvroSchemaUtil),
"ResolveRecordSchema",
EventTypeUtility.ResolveTypeCodegen(_eventType, EPStatementInitServicesConstants.REF)));
block
.DeclareVar<GenericRecord>(
"record",
NewInstance(typeof(GenericRecord), schema));
for (var i = 0; i < _indexPerWritable.Length; i++) {
block.StaticMethod(
typeof(GenericRecordExtensions), "Put",
Ref("record"),
Constant(_indexPerWritable[i].Name),
ArrayAtIndex(Ref("properties"), Constant(i)));
}
block.BlockReturn(Ref("record"));
}
public static CodegenExpression ProcessFirstColCodegen(
CodegenExpression expression,
CodegenExpression eventBeanFactory,
CodegenClassScope codegenClassScope,
WrapperEventType wrapperEventType,
string adapterMethod,
Type castType)
{
var memberUndType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(
wrapperEventType.UnderlyingEventType,
EPStatementInitServicesConstants.REF));
var memberWrapperType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(WrapperEventType),
Cast(
typeof(WrapperEventType),
EventTypeUtility.ResolveTypeCodegen(wrapperEventType, EPStatementInitServicesConstants.REF)));
var wrapped = ExprDotMethod(
eventBeanFactory,
adapterMethod,
castType == typeof(object) ? expression : Cast(castType, expression),
memberUndType);
return ExprDotMethod(
eventBeanFactory,
"AdapterForTypedWrapper",
wrapped,
StaticMethod(typeof(Collections), "GetEmptyMap", new[] { typeof(string), typeof(object) }),
memberWrapperType);
}
private CodegenMethod GetFragmentCodegen(
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var factory = codegenClassScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE);
var eventType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(FragmentType, EPStatementInitServicesConstants.REF));
var method = codegenMethodScope.MakeChild(typeof(object), GetType(), codegenClassScope)
.AddParam(Field.DeclaringType, "record");
method.Block
.DeclareVar<object>("value", UnderlyingGetCodegen(Ref("record"), codegenMethodScope, codegenClassScope))
.IfRefNullReturnNull("value");
string adapterMethod;
if (FragmentType is BeanEventType) {
adapterMethod = "AdapterForTypedObject";
}
else if (FragmentType is JsonEventType) {
adapterMethod = "AdapterForTypedJson";
}
else {
throw new IllegalStateException("Unrecognized fragment event type " + FragmentType);
}
method.Block.MethodReturn(ExprDotMethod(factory, adapterMethod, Ref("value"), eventType));
return method;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventTypeOuter,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
// NOTE: Maintaining result-event-type as out own field as we may be an "inner" select-expr-processor
CodegenExpressionInstanceField mType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(resultEventType, EPStatementInitServicesConstants.REF));
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
this.GetType(),
codegenClassScope);
CodegenExpressionRef refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block.DeclareVar<IDictionary<string, object>>(
"tuple", NewInstance(typeof(HashMap<string, object>)));
for (int i = 0; i < streamNames.Length; i++) {
methodNode.Block.Expression(
ExprDotMethod(Ref("tuple"), "Put", Constant(streamNames[i]), ArrayAtIndex(refEPS, Constant(i))));
}
methodNode.Block.MethodReturn(ExprDotMethod(eventBeanFactory, "AdapterForTypedMap", Ref("tuple"), mType));
return methodNode;
}
public CodegenExpression Make(
CodegenBlock codegenBlock,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var factory = codegenClassScope.AddOrGetDefaultFieldSharable(
EventBeanTypedEventFactoryCodegenField.INSTANCE);
var eventType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(this.eventType, EPStatementInitServicesConstants.REF));
var makeUndLambda = new CodegenExpressionLambda(codegenBlock)
.WithParam<object[]>("properties")
.WithBody(block => MakeUnderlyingCodegen(block, codegenClassScope));
var manufacturer = NewInstance<ProxyObjectArrayEventBeanManufacturer>(
eventType, factory, makeUndLambda);
//var makeUndProc = CodegenMethod.MakeMethod(typeof(object[]), GetType(), codegenClassScope)
// .AddParam(typeof(object[]), "properties");
//manufacturer.AddMethod("MakeUnderlying", makeUndProc);
//MakeUnderlyingCodegen(makeUndProc, codegenClassScope);
//var makeProc = CodegenMethod.MakeMethod(typeof(EventBean), GetType(), codegenClassScope)
// .AddParam(typeof(object[]), "properties");
//manufacturer.AddMethod("Make", makeProc);
return codegenClassScope.AddDefaultFieldUnshared(true, typeof(EventBeanManufacturer), manufacturer);
}
public CodegenExpression Make(
CodegenBlock codegenBlock,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var init = codegenClassScope.NamespaceScope.InitMethod;
var factory = codegenClassScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE);
var eventType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(_jsonEventType, EPStatementInitServicesConstants.REF));
var makeUndFunc = new CodegenExpressionLambda(codegenBlock)
.WithParam <object[]>("properties")
.WithBody(block => MakeUnderlyingCodegen(block, codegenMethodScope, codegenClassScope));
var manufacturer = NewInstance <ProxyJsonEventBeanManufacturer>(eventType, factory, makeUndFunc);
// CodegenExpressionNewAnonymousClass manufacturer = newAnonymousClass(init.getBlock(), EventBeanManufacturer.class);
//
// CodegenMethod makeUndMethod = CodegenMethod.makeParentNode(Object.class, this.getClass(), codegenClassScope).addParam(Object[].class, "properties");
// manufacturer.addMethod("makeUnderlying", makeUndMethod);
// makeUnderlyingCodegen(makeUndMethod, codegenClassScope);
//
// CodegenMethod makeMethod = CodegenMethod.makeParentNode(EventBean.class, this.getClass(), codegenClassScope).addParam(Object[].class, "properties");
// manufacturer.addMethod("make", makeMethod);
// makeMethod.getBlock()
// .declareVar(Object.class, "und", localMethod(makeUndMethod, ref("properties")))
// .methodReturn(exprDotMethod(factory, "adapterForTypedJson", ref("und"), beanType));
return(codegenClassScope.AddDefaultFieldUnshared(true, typeof(EventBeanManufacturer), manufacturer));
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(InternalEventRouterDesc), GetType(), classScope);
var eventTypeExpr = EventTypeUtility.ResolveTypeCodegen(eventType, symbols.GetAddInitSvc(method));
var optionalWhereClauseExpr = optionalWhereClause == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(
optionalWhereClause.Forge,
method,
GetType(),
classScope);
var assignmentsExpr = ExprNodeUtilityCodegen.CodegenEvaluators(assignments, method, GetType(), classScope);
var writersExpr = MakeWriters(writers, method, symbols, classScope);
method.Block
.DeclareVar<InternalEventRouterDesc>("ire", NewInstance(typeof(InternalEventRouterDesc)))
.SetProperty(Ref("ire"), "Wideners", MakeWideners(wideners, method, classScope))
.SetProperty(Ref("ire"), "EventType", eventTypeExpr)
.SetProperty(Ref("ire"), "OptionalWhereClauseEval", optionalWhereClauseExpr)
.SetProperty(Ref("ire"), "Properties", Constant(properties))
.SetProperty(Ref("ire"), "Assignments", assignmentsExpr)
.SetProperty(Ref("ire"), "Writers", writersExpr)
.MethodReturn(Ref("ire"));
return LocalMethod(method);
}
public CodegenExpression InitCtorScoped()
{
return StaticMethod(
typeof(XPathPropertyGetterCodegenFieldSharable),
"ResolveXPathPropertyGetter",
EventTypeUtility.ResolveTypeCodegen(baseXMLEventType, EPStatementInitServicesConstants.REF),
Constant(xPathPropertyGetter.Property));
}
public CodegenExpression MakeCopyMethodClassScoped(CodegenClassScope classScope)
{
var factory = classScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE);
return NewInstance(
typeof(JsonEventBeanCopyMethod),
Cast(typeof(JsonEventType), EventTypeUtility.ResolveTypeCodegen(_eventType, EPStatementInitServicesConstants.REF)),
factory);
}
public CodegenExpression Codegen(
CodegenMethod method,
CodegenClassScope classScope,
CodegenExpression typeInitSvcRef)
{
return(CodegenExpressionBuilder.NewInstance <EventEPType>(
EventTypeUtility.ResolveTypeCodegen(EventType, typeInitSvcRef)));
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams premade,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(typeof(ObjectArrayEventType), EventTypeUtility.ResolveTypeCodegen(_resultEventType, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(typeof(IDictionary <object, object>), GetType(), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var hasIndex = _numParameters >= 2;
var hasSize = _numParameters >= 3;
var returnIfEmpty = ReturnIfEmptyOptional();
if (returnIfEmpty != null)
{
methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(returnIfEmpty);
}
InitBlock(methodNode.Block, methodNode, scope, codegenClassScope);
methodNode.Block
.DeclareVar <ObjectArrayEventBean>(
"resultEvent",
NewInstance(typeof(ObjectArrayEventBean), NewArrayByLength(typeof(object), Constant(_numParameters)), resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda), Ref("resultEvent"))
.DeclareVar <object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
if (hasIndex)
{
methodNode.Block.DeclareVar <int>("count", Constant(-1));
}
if (hasSize)
{
methodNode.Block.AssignArrayElement(Ref("props"), Constant(2), ExprDotName(REF_ENUMCOLL, "Count"));
}
var forEach = methodNode.Block
.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"));
if (hasIndex)
{
forEach.IncrementRef("count").AssignArrayElement("props", Constant(1), Ref("count"));
}
ForEachBlock(forEach, methodNode, scope, codegenClassScope);
ReturnResult(methodNode.Block);
return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx));
}
public static CodegenExpression Codegen(
EnumMinMaxByScalarLambdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerType = forge.InnerExpression.EvaluationType;
var innerTypeBoxed = Boxing.GetBoxedType(innerType);
var resultTypeBoxed = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(forge.resultType));
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
resultTypeBoxed,
typeof(EnumMinMaxByScalarLambdaForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.DeclareVar(innerTypeBoxed, "minKey", ConstantNull())
.DeclareVar(resultTypeBoxed, "result", ConstantNull())
.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"))
.DeclareVar(
innerTypeBoxed,
"value",
forge.InnerExpression.EvaluateCodegen(innerTypeBoxed, methodNode, scope, codegenClassScope))
.IfRefNull("value")
.BlockContinue();
forEach.IfCondition(EqualsNull(Ref("minKey")))
.AssignRef("minKey", Ref("value"))
.AssignRef("result", Cast(resultTypeBoxed, Ref("next")))
.IfElse()
.IfCondition(
Relational(
ExprDotMethod(Unbox(Ref("minKey"), innerTypeBoxed), "CompareTo", Ref("value")),
forge.max ? LT : GT,
Constant(0)))
.AssignRef("minKey", Ref("value"))
.AssignRef("result", Cast(resultTypeBoxed, Ref("next")));
block.MethodReturn(Ref("result"));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public CodegenMethod InitializeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
// add aggregation row+factory+serde as inner classes
var aggregationClassNames = new AggregationClassNames();
var inners = AggregationServiceFactoryCompiler.MakeTable(
AggregationCodegenRowLevelDesc.FromTopOnly(_plan.AggDesc),
GetType(),
classScope,
aggregationClassNames,
_className);
classScope.AddInnerClasses(inners);
var method = parent.MakeChild(typeof(StatementAgentInstanceFactoryCreateTable), GetType(), classScope);
CodegenExpression primaryKeyGetter = MultiKeyCodegen.CodegenGetterMayMultiKey(
_plan.InternalEventType,
_plan.PrimaryKeyGetters,
_plan.PrimaryKeyTypes,
null,
_plan.PrimaryKeyMultikeyClasses,
method,
classScope);
CodegenExpression fafTransform = MultiKeyCodegen.CodegenMultiKeyFromArrayTransform(
_plan.PrimaryKeyMultikeyClasses,
method,
classScope);
CodegenExpression intoTableTransform = MultiKeyCodegen.CodegenMultiKeyFromMultiKeyTransform(
_plan.PrimaryKeyMultikeyClasses,
method,
classScope);
var propertyForgeEval = DataInputOutputSerdeForgeExtensions.CodegenArray(
_plan.InternalEventTypePropertySerdes,
method,
classScope,
ExprDotName(symbols.GetAddInitSvc(method), EPStatementInitServicesConstants.EVENTTYPERESOLVER));
method.Block
.DeclareVar<StatementAgentInstanceFactoryCreateTable>("saiff", NewInstance(typeof(StatementAgentInstanceFactoryCreateTable)))
.SetProperty(Ref("saiff"), "TableName", Constant(_tableName))
.SetProperty(Ref("saiff"), "PublicEventType", EventTypeUtility.ResolveTypeCodegen(_plan.PublicEventType, symbols.GetAddInitSvc(method)))
.SetProperty(Ref("saiff"), "EventToPublic", MakeEventToPublic(method, symbols, classScope))
.SetProperty(Ref("saiff"), "AggregationRowFactory", NewInstanceInner(aggregationClassNames.RowFactoryTop, Ref("this")))
.SetProperty(Ref("saiff"), "AggregationSerde", NewInstanceInner(aggregationClassNames.RowSerdeTop, Ref("this")))
.SetProperty(Ref("saiff"), "PrimaryKeyGetter", primaryKeyGetter)
.SetProperty(Ref("saiff"), "PrimaryKeySerde", _plan.PrimaryKeyMultikeyClasses.GetExprMKSerde(method, classScope))
.SetProperty(Ref("saiff"), "PropertyForges", propertyForgeEval)
.SetProperty(Ref("saiff"), "PrimaryKeyObjectArrayTransform", fafTransform)
.SetProperty(Ref("saiff"), "PrimaryKeyIntoTableTransform", intoTableTransform)
.ExprDotMethod(symbols.GetAddInitSvc(method), "AddReadyCallback", Ref("saiff"))
.MethodReturn(Ref("saiff"));
return method;
}
public CodegenMethod InitializeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(
typeof(StatementAgentInstanceFactoryCreateNW),
this.GetType(),
classScope);
method.Block
.DeclareVar<StatementAgentInstanceFactoryCreateNW>(
"saiff",
NewInstance(typeof(StatementAgentInstanceFactoryCreateNW)));
method.Block
.SetProperty(Ref("saiff"), "Activator", activator.MakeCodegen(method, symbols, classScope))
.SetProperty(Ref("saiff"), "NamedWindowName", Constant(namedWindowName))
.SetProperty(
Ref("saiff"),
"ViewFactories",
ViewFactoryForgeUtil.CodegenForgesWInit(views, 0, null, method, symbols, classScope))
.SetProperty(
Ref("saiff"),
"InsertFromNamedWindow",
insertFromNamedWindow == null
? ConstantNull()
: NamedWindowDeployTimeResolver.MakeResolveNamedWindow(
insertFromNamedWindow,
symbols.GetAddInitSvc(method)))
.SetProperty(
Ref("saiff"),
"InsertFromFilter",
insertFromFilter == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(
insertFromFilter.Forge,
method,
this.GetType(),
classScope))
.SetProperty(
Ref("saiff"),
"AsEventType",
asEventType == null
? ConstantNull()
: EventTypeUtility.ResolveTypeCodegen(asEventType, EPStatementInitServicesConstants.REF))
.SetProperty(
Ref("saiff"),
"ResultSetProcessorFactoryProvider",
NewInstance(
resultSetProcessorProviderClassName,
symbols.GetAddInitSvc(method),
Ref("statementFields")))
.ExprDotMethod(symbols.GetAddInitSvc(method), "AddReadyCallback", Ref("saiff"));
method.Block.MethodReturn(Ref("saiff"));
return method;
}
public CodegenExpression Codegen(
CodegenMethod method,
CodegenClassScope classScope,
CodegenExpression typeInitSvcRef)
{
return(CodegenExpressionBuilder.NewInstance <EventMultiValuedEPType>(
CodegenExpressionBuilder.Constant(Container),
EventTypeUtility.ResolveTypeCodegen(Component, typeInitSvcRef)));
}