internal override void Assign(
CodegenMethod method,
CodegenExpressionRef factory,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
method.Block
.SetProperty(
factory,
"SizeEvaluator",
CodegenEvaluator(sizeForge, method, GetType(), classScope))
.SetProperty(
factory,
"SortCriteriaEvaluators",
CodegenEvaluators(sortCriteriaExpressions, method, GetType(), classScope))
.SetProperty(
factory,
"SortCriteriaTypes",
Constant(ExprNodeUtilityQuery.GetExprResultTypes(sortCriteriaExpressions)))
.SetProperty(
factory,
"IsDescendingValues",
Constant(isDescendingValues))
.SetProperty(
factory,
"IsUseCollatorSort",
Constant(useCollatorSort))
.SetProperty(
factory,
"SortSerdes",
DataInputOutputSerdeForgeExtensions.CodegenArray(sortSerdes, method, classScope, null));
ViewMultiKeyHelper.Assign(criteriaExpressions, multiKeyClassNames, method, factory, symbols, classScope);
}
public CodegenExpression Make(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(QueryPlanIndexItem), GetType(), classScope);
var propertyGetters = EventTypeUtility.GetGetters(eventType, HashProps);
var propertyTypes = EventTypeUtility.GetPropertyTypes(eventType, HashProps);
var valueGetter = MultiKeyCodegen.CodegenGetterMayMultiKey(
eventType, propertyGetters, propertyTypes, HashTypes, HashMultiKeyClasses, method, classScope);
CodegenExpression rangeGetters;
if (RangeProps.Length == 0) {
rangeGetters = NewArrayByLength(typeof(EventPropertyValueGetter), Constant(0));
}
else {
var makeMethod = parent.MakeChild(typeof(EventPropertyValueGetter[]), GetType(), classScope);
makeMethod.Block.DeclareVar<EventPropertyValueGetter[]>(
"getters",
NewArrayByLength(typeof(EventPropertyValueGetter), Constant(RangeProps.Length)));
for (var i = 0; i < RangeProps.Length; i++) {
var getter = ((EventTypeSPI) eventType).GetGetterSPI(RangeProps[i]);
var getterType = eventType.GetPropertyType(RangeProps[i]);
var coercionType = RangeTypes == null ? null : RangeTypes[i];
var eval = EventTypeUtility.CodegenGetterWCoerce(
getter,
getterType,
coercionType,
method,
GetType(),
classScope);
makeMethod.Block.AssignArrayElement(Ref("getters"), Constant(i), eval);
}
makeMethod.Block.MethodReturn(Ref("getters"));
rangeGetters = LocalMethod(makeMethod);
}
CodegenExpression multiKeyTransform = MultiKeyCodegen.CodegenMultiKeyFromArrayTransform(
HashMultiKeyClasses, method, classScope);
method.Block.MethodReturn(
NewInstance<QueryPlanIndexItem>(
Constant(HashProps),
Constant(HashTypes),
valueGetter,
multiKeyTransform,
HashMultiKeyClasses != null ? HashMultiKeyClasses.GetExprMKSerde(method, classScope) : ConstantNull(),
Constant(RangeProps),
Constant(RangeTypes),
rangeGetters,
DataInputOutputSerdeForgeExtensions.CodegenArray(RangeSerdes, method, classScope, null),
Constant(IsUnique),
AdvancedIndexProvisionDesc == null
? ConstantNull()
: AdvancedIndexProvisionDesc.CodegenMake(method, classScope)));
return LocalMethod(method);
}
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 CodegenExpression Codegen(
CodegenMethod method,
CodegenClassScope classScope)
{
return NewInstance<StatViewAdditionalPropsEval>(
Constant(AdditionalProps),
CodegenEvaluators(AdditionalEvals, method, this.GetType(), classScope),
Constant(AdditionalTypes),
DataInputOutputSerdeForgeExtensions.CodegenArray(AdditionalSerdes, method, classScope, null));
}
public AggregatorAccessSortedImpl(
bool join,
AggregationStateSortedForge forge,
int col,
CodegenCtor ctor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
ExprNode optionalFilter)
: base(optionalFilter)
{
this.forge = forge;
sorted = membersColumnized.AddMember(col, typeof(IOrderedDictionary <object, object>), "sorted");
size = membersColumnized.AddMember(col, typeof(int), "size");
var types = ExprNodeUtilityQuery.GetExprResultTypes(forge.Spec.Criteria);
comparator = classScope.AddOrGetDefaultFieldSharable(
new CodegenFieldSharableComparator(
COMPARATORHASHABLEMULTIKEYS,
types,
forge.Spec.IsSortUsingCollator,
forge.Spec.SortDescending));
ctor.Block.AssignRef(sorted, NewInstance <OrderedListDictionary <object, object> >(comparator));
sortedSerde = classScope.AddOrGetDefaultFieldSharable(
new ProxyCodegenFieldSharable()
{
ProcType = () => { return(typeof(DIOSerdeTreeMapEventsMayDeque)); },
ProcInitCtorScoped = () => {
var type = EventTypeUtility
.ResolveTypeCodegen(forge.Spec.StreamEventType, EPStatementInitServicesConstants.REF);
var criteriaSerdes = DataInputOutputSerdeForgeExtensions
.CodegenArray(forge.Spec.CriteriaSerdes, classScope.NamespaceScope.InitMethod, classScope, null);
return(ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(EPStatementInitServicesConstants.EVENTTYPERESOLVER)
.Add(EventTypeResolverConstants.GETEVENTSERDEFACTORY)
.Add("TreeMapEventsMayDeque", criteriaSerdes, type));
},
});
if (join)
{
joinRefs = membersColumnized.AddMember(col, typeof(RefCountedSetAtomicInteger <object>), "refs");
ctor.Block.AssignRef(joinRefs, NewInstance(typeof(RefCountedSetAtomicInteger <object>)));
joinRefsSerde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeEventTyped(
REFCOUNTEDSETATOMICINTEGER, forge.Spec.StreamEventType));
}
else
{
joinRefs = null;
joinRefsSerde = null;
}
}
public CodegenExpression InitCtorScoped()
{
return(ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(EPStatementInitServicesConstants.EVENTTYPERESOLVER)
.Add(EventTypeResolverConstants.GETEVENTSERDEFACTORY)
.Add(
_name.MethodName,
DataInputOutputSerdeForgeExtensions.CodegenArray(
_serdes,
_classScope.NamespaceScope.InitMethod,
_classScope,
null)));
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(PropertyCompositeEventTableFactoryFactory), GetType(), classScope);
var hashGetter = ConstantNull();
if (_optKeyProps != null && _optKeyProps.Length > 0) {
var propertyTypes = EventTypeUtility.GetPropertyTypes(_eventType, _optKeyProps);
var getters = EventTypeUtility.GetGetters(_eventType, _optKeyProps);
hashGetter = MultiKeyCodegen.CodegenGetterMayMultiKey(
_eventType, getters, propertyTypes, _optKeyTypes, _hashMultikeyClasses, method, classScope);
}
method.Block.DeclareVar<EventPropertyValueGetter[]>(
"rangeGetters",
NewArrayByLength(typeof(EventPropertyValueGetter), Constant(_rangeProps.Length)));
for (var i = 0; i < _rangeProps.Length; i++) {
var propertyType = _eventType.GetPropertyType(_rangeProps[i]);
var getterSPI = ((EventTypeSPI) _eventType).GetGetterSPI(_rangeProps[i]);
var getter = EventTypeUtility.CodegenGetterWCoerce(
getterSPI,
propertyType,
_rangeTypes[i],
method,
GetType(),
classScope);
method.Block.AssignArrayElement(Ref("rangeGetters"), Constant(i), getter);
}
IList<CodegenExpression> @params = new List<CodegenExpression>();
@params.Add(Constant(_indexedStreamNum));
@params.Add(Constant(_subqueryNum));
@params.Add(Constant(_isFireAndForget));
@params.Add(Constant(_optKeyProps));
@params.Add(Constant(_optKeyTypes));
@params.Add(hashGetter);
@params.Add(_hashMultikeyClasses.GetExprMKSerde(method, classScope));
@params.Add(Constant(_rangeProps));
@params.Add(Constant(_rangeTypes));
@params.Add(Ref("rangeGetters"));
@params.Add(DataInputOutputSerdeForgeExtensions.CodegenArray(_rangeSerdes, method, classScope, null));
method.Block.MethodReturn(
NewInstance<PropertyCompositeEventTableFactoryFactory>(@params.ToArray()));
return LocalMethod(method);
}
public static SerdeEventPropertyDesc ForgeForEventProperty(
EventType eventTypeSerde,
string propertyName,
object propertyType,
StatementRawInfo raw,
SerdeCompileTimeResolver resolver)
{
DataInputOutputSerdeForge forge;
if (propertyType == null)
{
return(new SerdeEventPropertyDesc(new DataInputOutputSerdeForgeSingleton(typeof(DIOSkipSerde)), EmptySet <EventType> .Instance));
}
if (propertyType is Type propertyTypeType)
{
// handle special Json catch-all types
if (eventTypeSerde is JsonEventType)
{
forge = null;
if (propertyTypeType == typeof(IDictionary <string, object>))
{
forge = new DataInputOutputSerdeForgeSingleton(typeof(DIOJsonObjectSerde));
}
else if (propertyTypeType == typeof(object[]))
{
forge = new DataInputOutputSerdeForgeSingleton(typeof(DIOJsonArraySerde));
}
else if (propertyTypeType == typeof(object))
{
forge = new DataInputOutputSerdeForgeSingleton(typeof(DIOJsonAnyValueSerde));
}
if (forge != null)
{
return(new SerdeEventPropertyDesc(forge, EmptySet <EventType> .Instance));
}
}
// handle all Class-type properties
var typedProperty = (Type)propertyType;
if (typedProperty == typeof(object) && propertyName.Equals(INTERNAL_RESERVED_PROPERTY))
{
forge = new DataInputOutputSerdeForgeSingleton(
typeof(DIOSkipSerde)); // for expression data window or others that include transient references in the field
}
else
{
forge = resolver.SerdeForEventProperty(typedProperty, eventTypeSerde.Name, propertyName, raw);
}
return(new SerdeEventPropertyDesc(forge, EmptySet <EventType> .Instance));
}
if (propertyType is EventType)
{
var eventType = (EventType)propertyType;
Func <DataInputOutputSerdeForgeParameterizedVars, CodegenExpression> func = vars =>
ResolveTypeCodegenGivenResolver(eventType, vars.OptionalEventTypeResolver);
forge = new DataInputOutputSerdeForgeEventSerde("NullableEvent", func);
return(new SerdeEventPropertyDesc(forge, Collections.SingletonSet(eventType)));
}
else if (propertyType is EventType[])
{
var eventType = ((EventType[])propertyType)[0];
Func <DataInputOutputSerdeForgeParameterizedVars, CodegenExpression> func = vars =>
ResolveTypeCodegenGivenResolver(eventType, vars.OptionalEventTypeResolver);
forge = new DataInputOutputSerdeForgeEventSerde("NullableEventArray", func);
return(new SerdeEventPropertyDesc(forge, Collections.SingletonSet(eventType)));
}
else if (propertyType is TypeBeanOrUnderlying)
{
var eventType = ((TypeBeanOrUnderlying)propertyType).EventType;
Func <DataInputOutputSerdeForgeParameterizedVars, CodegenExpression> func = vars =>
ResolveTypeCodegenGivenResolver(eventType, vars.OptionalEventTypeResolver);
forge = new DataInputOutputSerdeForgeEventSerde("NullableEventOrUnderlying", func);
return(new SerdeEventPropertyDesc(forge, Collections.SingletonSet(eventType)));
}
else if (propertyType is TypeBeanOrUnderlying[])
{
var eventType = ((TypeBeanOrUnderlying[])propertyType)[0].EventType;
Func <DataInputOutputSerdeForgeParameterizedVars, CodegenExpression> func = vars =>
ResolveTypeCodegenGivenResolver(eventType, vars.OptionalEventTypeResolver);
forge = new DataInputOutputSerdeForgeEventSerde("NullableEventArrayOrUnderlying", func);
return(new SerdeEventPropertyDesc(forge, Collections.SingletonSet(eventType)));
}
else if (propertyType is IDictionary <string, object> keyValueProperties)
{
var keys = new string[keyValueProperties.Count];
var serdes = new DataInputOutputSerdeForge[keyValueProperties.Count];
var index = 0;
var nestedTypes = new LinkedHashSet <EventType>();
// Rewrite all properties where the value is a string. First, gather all instances that need
// to be rewritten into the class that matches the type.
keyValueProperties
.Where(entry => entry.Value is string)
.ToList()
.ForEach(
entry => {
var value = entry.Value.ToString()?.Trim();
var clazz = TypeHelper.GetPrimitiveTypeForName(value);
if (clazz != null)
{
keyValueProperties[entry.Key] = clazz;
}
});
foreach (var entry in keyValueProperties)
{
keys[index] = entry.Key;
var desc = ForgeForEventProperty(eventTypeSerde, entry.Key, entry.Value, raw, resolver);
nestedTypes.AddAll(desc.NestedTypes);
serdes[index] = desc.Forge;
index++;
}
var functions = new Func <DataInputOutputSerdeForgeParameterizedVars, CodegenExpression> [2];
functions[0] = vars => Constant(keys);
functions[1] = vars => DataInputOutputSerdeForgeExtensions.CodegenArray(serdes, vars.Method, vars.Scope, vars.OptionalEventTypeResolver);
forge = new DataInputOutputSerdeForgeParameterized(typeof(DIOMapPropertySerde).Name, functions);
return(new SerdeEventPropertyDesc(forge, nestedTypes));
}
else
{
throw new EPException(
"Failed to determine serde for unrecognized property value type '" +
propertyType +
"' for property '" +
propertyName +
"' of type '" +
eventTypeSerde.Name +
"'");
}
}
