public AggregatorLastEver(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter,
Type childType,
DataInputOutputSerdeForge serde)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
_childType = childType.GetBoxedType();
// NOTE: we had originally set the value of the member to childType which seems correct an
// appropriate. However, the code is not doing proper type checking and cast conversion
// elsewhere which makes assignment problematic. Revisit this problem when we have more
// time.
_lastValue = membersColumnized.AddMember(col, typeof(object), "lastValue");
this._serde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeClassTyped(
CodegenSharableSerdeClassTyped.CodegenSharableSerdeName.VALUE_NULLABLE,
childType,
serde,
classScope));
}
public static Consumer<CodegenBlock> ReadLong(
CodegenExpressionRef row,
CodegenExpressionMember member,
CodegenExpression input)
{
return block => block.AssignRef(RowDotMember(row, member), ExprDotMethod(input, "ReadLong"));
}
public static Consumer<CodegenBlock> WriteDecimal(
CodegenExpressionRef output,
CodegenExpressionRef row,
CodegenExpressionMember member)
{
return block => block.ExprDotMethod(output, "WriteDecimal", RowDotMember(row, member));
}
public AggregatorAccessSortedMinMaxByEver(
AggregationStateMinMaxByEverForge forge,
int col,
CodegenCtor ctor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
ExprNode optionalFilter)
: base(optionalFilter)
{
this._forge = forge;
_currentMinMaxBean = membersColumnized.AddMember(col, typeof(EventBean), "currentMinMaxBean");
_currentMinMaxBeanSerde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeEventTyped(
CodegenSharableSerdeEventTyped.CodegenSharableSerdeName.NULLABLEEVENTMAYCOLLATE,
forge.Spec.StreamEventType));
_currentMinMax = membersColumnized.AddMember(col, typeof(object), "currentMinMax");
if (forge.Spec.Criteria.Length == 1)
{
_currentMinMaxSerde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeClassTyped(VALUE_NULLABLE, forge.Spec.CriteriaTypes[0], forge.Spec.CriteriaSerdes[0], classScope));
}
else
{
_currentMinMaxSerde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeClassArrayTyped(OBJECTARRAYMAYNULLNULL, forge.Spec.CriteriaTypes, forge.Spec.CriteriaSerdes, classScope));
}
_comparator = classScope.AddOrGetDefaultFieldSharable(
new CodegenFieldSharableComparator(
COMPARATOROBJECTARRAYNONHASHABLE,
forge.Spec.CriteriaTypes,
forge.Spec.IsSortUsingCollator,
forge.Spec.SortDescending));
}
public AggregatorMethodWDistinctWFilterBase(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter)
{
this.optionalDistinctValueType = optionalDistinctValueType;
this.optionalFilter = optionalFilter;
this.hasFilter = hasFilter;
if (optionalDistinctValueType != null) {
distinct = membersColumnized.AddMember(col, typeof(RefCountedSet<object>), "distinctSet");
rowCtor.Block.AssignRef(distinct, NewInstance(typeof(RefCountedSet<object>)));
distinctSerde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeClassTyped(
CodegenSharableSerdeClassTyped.CodegenSharableSerdeName.REFCOUNTEDSET,
optionalDistinctValueType,
optionalDistinctSerde,
classScope));
}
else {
distinct = null;
distinctSerde = null;
}
}
public AggregatorAvedev(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
optionalDistinctSerde,
hasFilter,
optionalFilter)
{
valueSet = membersColumnized.AddMember(col, typeof(RefCountedSet<double>), "valueSet");
sum = membersColumnized.AddMember(col, typeof(double), "sum");
rowCtor.Block.AssignRef(valueSet, NewInstance(typeof(RefCountedSet<double>)));
}
public AggregatorLeaving(
AggregationForgeFactoryLeaving factory,
int col,
CodegenMemberCol membersColumnized)
{
_factory = factory;
_leaving = membersColumnized.AddMember(col, typeof(bool), "leaving");
}
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 AggregatorAccessLinearNonJoin(
AggregationStateLinearForge forge,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
ExprNode optionalFilter)
: base(optionalFilter)
{
_forge = forge;
_events = membersColumnized.AddMember(col, typeof(IList<EventBean>), "events");
rowCtor.Block.AssignRef(_events, NewInstance(typeof(List<EventBean>)));
}
public AggregatorAccessLinearJoin(
AggregationStateLinearForge forge,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
ExprNode optionalFilter)
: base(optionalFilter)
{
_forge = forge;
_refSet = membersColumnized.AddMember(col, typeof(LinkedHashMap<EventBean, object>), "refSet");
_array = membersColumnized.AddMember(col, typeof(EventBean[]), "array");
rowCtor.Block.AssignRef(_refSet, NewInstance(typeof(LinkedHashMap<EventBean, object>)));
}
public AggregatorAccessCountMinSketch(
AggregationStateCountMinSketchForge forge,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope)
{
this.forge = forge;
state = membersColumnized.AddMember(col, typeof(CountMinSketchAggState), "state");
spec = classScope.NamespaceScope.AddDefaultFieldUnshared(
true,
typeof(CountMinSketchSpec),
forge.specification.CodegenMake(classScope.NamespaceScope.InitMethod, classScope));
rowCtor.Block.AssignRef(state, ExprDotMethod(spec, "MakeAggState"));
}
public AggregatorMedian(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
_vector = membersColumnized.AddMember(col, typeof(SortedDoubleVector), "vector");
rowCtor.Block.AssignRef(_vector, NewInstance(typeof(SortedDoubleVector)));
}
public AggregatorCount(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter,
bool isEver)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
_isEver = isEver;
_cnt = membersColumnized.AddMember(col, typeof(long), "cnt");
}
public AggregatorRateEver(
AggregationForgeFactoryRate factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
_factory = factory;
_points = membersColumnized.AddMember(col, typeof(Deque<long>), "points");
_hasLeave = membersColumnized.AddMember(col, typeof(bool), "hasLeave");
rowCtor.Block.AssignRef(_points, NewInstance(typeof(ArrayDeque<long>)));
}
private static CodegenMethod GetComparableWObjectArrayKeyCodegen(
ExprNode[] criteria,
CodegenExpressionMember member,
CodegenNamedMethods namedMethods,
CodegenClassScope classScope)
{
var methodName = "GetComparable_" + member.Ref;
Consumer <CodegenMethod> code = method => {
if (criteria.Length == 1)
{
method.Block.MethodReturn(
LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(criteria[0].Forge, method, classScope),
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(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 AggregatorAvgBig(
AggregationForgeFactoryAvg factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
_factory = factory;
_sum = membersColumnized.AddMember(col, typeof(BigInteger), "sum");
_cnt = membersColumnized.AddMember(col, typeof(long), "cnt");
rowCtor.Block.AssignRef(_sum, EnumValue(typeof(BigInteger), "Zero"));
}
public AggregatorRate(
AggregationForgeFactoryRate factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
_factory = factory;
_accumulator = membersColumnized.AddMember(col, typeof(double), "accumulator");
_latest = membersColumnized.AddMember(col, typeof(long), "latest");
_oldest = membersColumnized.AddMember(col, typeof(long), "oldest");
_isSet = membersColumnized.AddMember(col, typeof(bool), "isSet");
}
public AggregatorSumBase(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter,
Type sumType)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
cnt = membersColumnized.AddMember(col, typeof(long), "cnt");
sum = membersColumnized.AddMember(col, sumType.GetPrimitiveType(), "sum");
this.sumType = sumType;
rowCtor.Block.AssignRef(sum, InitOfSum());
}
public AggregatorPlugInMultiParam(
AggregationForgeFactoryPlugin factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
AggregationFunctionModeMultiParam mode)
{
this.mode = mode;
var injectionStrategy =
(InjectionStrategyClassNewInstance) mode.InjectionStrategyAggregationFunctionFactory;
var factoryField = classScope.AddDefaultFieldUnshared<AggregationFunctionFactory>(
true,
injectionStrategy.GetInitializationExpression(classScope));
plugin = membersColumnized.AddMember(col, typeof(AggregationFunction), "plugin");
rowCtor.Block.AssignRef(plugin, ExprDotMethod(factoryField, "NewAggregator", ConstantNull()));
}
public AggregatorAccessPlugin(
int col,
bool join,
CodegenCtor ctor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
ExprNode optionalFilter,
AggregationMultiFunctionStateModeManaged mode)
: base(optionalFilter)
{
state = membersColumnized.AddMember(col, typeof(AggregationMultiFunctionState), "state");
this.mode = mode;
var injectionStrategy = (InjectionStrategyClassNewInstance) mode.InjectionStrategyAggregationStateFactory;
var factoryField = classScope.AddDefaultFieldUnshared(
true,
typeof(AggregationMultiFunctionStateFactory),
injectionStrategy.GetInitializationExpression(classScope));
ctor.Block.AssignRef(state, ExprDotMethod(factoryField, "NewState", ConstantNull()));
}
public AggregatorMinMax(
AggregationForgeFactoryMinMax factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
this._factory = factory;
_refSet = membersColumnized.AddMember(col, typeof(SortedRefCountedSet<object>), "refSet");
_serde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeClassTyped(
CodegenSharableSerdeClassTyped.CodegenSharableSerdeName.SORTEDREFCOUNTEDSET,
factory.ResultType,
factory.Serde,
classScope));
rowCtor.Block.AssignRef(_refSet, NewInstance(typeof(SortedRefCountedSet<object>)));
}
public AggregatorMinMaxEver(
AggregationForgeFactoryMinMax factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter,
DataInputOutputSerdeForge serde)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
_factory = factory;
_currentMinMax = membersColumnized.AddMember(col, typeof(IComparable), "currentMinMax");
_serde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeClassTyped(
CodegenSharableSerdeClassTyped.CodegenSharableSerdeName.VALUE_NULLABLE,
factory.ResultType,
serde,
classScope));
}
public AggregatorNth(
AggregationForgeFactoryNth factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
this._factory = factory;
_circularBuffer = membersColumnized.AddMember(col, typeof(object[]), "buf");
_currentBufferElementPointer = membersColumnized.AddMember(col, typeof(int), "cbep");
_numDataPoints = membersColumnized.AddMember(col, typeof(long), "cnt");
_serdeValue = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeClassTyped(
CodegenSharableSerdeClassTyped.CodegenSharableSerdeName.VALUE_NULLABLE,
factory.ChildType,
factory.Serde,
classScope));
}
public AggregatorPlugInManaged(
AggregationForgeFactoryPlugin factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
DataInputOutputSerdeForge optionalDistinctSerde,
bool hasFilter,
ExprNode optionalFilter,
AggregationFunctionModeManaged mode)
: base(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, optionalDistinctSerde, hasFilter, optionalFilter)
{
this.mode = mode;
var injectionStrategy =
(InjectionStrategyClassNewInstance) mode.InjectionStrategyAggregationFunctionFactory;
var factoryField = classScope.AddDefaultFieldUnshared<AggregationFunctionFactory>(
true,
injectionStrategy.GetInitializationExpression(classScope));
plugin = membersColumnized.AddMember(col, typeof(AggregationFunction), "plugin");
rowCtor.Block.AssignRef(plugin, ExprDotMethod(factoryField, "NewAggregator", ConstantNull()));
}
public SupportConcatWCodegenAggregatorMethod(AggregatorMethodFactoryContext context)
{
builder = context.MembersColumnized.AddMember(context.Col, typeof(StringBuilder), "buf");
context.RowCtor.Block.AssignRef(builder, NewInstance(typeof(StringBuilder)));
}
public static CodegenExpression RowDotMember(
CodegenExpressionRef row,
CodegenExpressionMember member)
{
return Ref(row.Ref + "." + member.Ref);
}
