public AggregatorRate(
AggregationFactoryMethodRate factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
hasFilter,
optionalFilter)
{
this.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 AggregatorNth(
AggregationFactoryMethodNth factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
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(VALUE_NULLABLE, factory.childType));
}
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 AggregatorFirstEver(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter,
Type childType)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
hasFilter,
optionalFilter)
{
_childType = childType.GetBoxedType();
_isSet = membersColumnized.AddMember(col, typeof(bool), "isSet");
// 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.
_firstValue = membersColumnized.AddMember(col, typeof(object), "firstValue");
_serde = classScope.AddOrGetDefaultFieldSharable(new CodegenSharableSerdeClassTyped(VALUE_NULLABLE, childType));
}
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 AggregatorSumBase(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter,
Type sumType)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
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 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 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(OrderedDictionary<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(typeof(OrderedDictionary<object, object>), comparator));
sortedSerde = classScope.AddOrGetDefaultFieldSharable(
new ProxyCodegenFieldSharable {
ProcType = () => { return typeof(DIOSerdeTreeMapEventsMayDeque); },
ProcInitCtorScoped = () => {
var type = EventTypeUtility.ResolveTypeCodegen(
forge.Spec.StreamEventType,
EPStatementInitServicesConstants.REF);
return ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(EPStatementInitServicesConstants.DATAINPUTOUTPUTSERDEPROVIDER)
.Add(
"TreeMapEventsMayDeque",
Constant(forge.Spec.CriteriaTypes),
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 AggregatorAccessLinearJoin(
AggregationStateLinearForge forge,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
ExprNode optionalFilter)
: base(optionalFilter)
{
this.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 AggregatorMethodWDistinctWFilterBase(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
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(REFCOUNTEDSET, optionalDistinctValueType));
}
else {
distinct = null;
distinctSerde = null;
}
}
public AggregatorMinMax(
AggregationFactoryMethodMinMax factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
hasFilter,
optionalFilter)
{
this.factory = factory;
refSet = membersColumnized.AddMember(col, typeof(SortedRefCountedSet<object>), "refSet");
serde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeClassTyped(SORTEDREFCOUNTEDSET, factory.ResultType));
rowCtor.Block.AssignRef(refSet, NewInstance(typeof(SortedRefCountedSet<object>)));
}
public AggregatorPlugInManaged(
AggregationMethodFactoryPluginMethod factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter,
AggregationFunctionModeManaged mode)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
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 AggregatorStddev(
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)
{
_mean = membersColumnized.AddMember(col, typeof(double), "mean");
_qn = membersColumnized.AddMember(col, typeof(double), "qn");
_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>)));
}
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 AggregatorLeaving(
AggregationFactoryMethodLeaving factory,
int col,
CodegenMemberCol membersColumnized)
{
this.factory = factory;
leaving = membersColumnized.AddMember(col, typeof(bool), "leaving");
}
public AggregatorLeaving(
AggregationForgeFactoryLeaving factory,
int col,
CodegenMemberCol membersColumnized)
{
_factory = factory;
_leaving = membersColumnized.AddMember(col, typeof(bool), "leaving");
}
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 AggregatorAccessLinearNonJoin(
AggregationStateLinearForge forge,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
ExprNode optionalFilter)
: base(optionalFilter)
{
this.forge = forge;
events = membersColumnized.AddMember(col, typeof(IList<EventBean>), "events");
rowCtor.Block.AssignRef(events, NewInstance(typeof(List<EventBean>)));
}
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 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 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 AggregatorCount(
AggregationForgeFactory factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter,
bool isEver)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
hasFilter,
optionalFilter)
{
this.isEver = isEver;
cnt = membersColumnized.AddMember(col, typeof(long), "cnt");
}
public AggregatorMinMaxEver(
AggregationFactoryMethodMinMax factory,
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
Type optionalDistinctValueType,
bool hasFilter,
ExprNode optionalFilter)
: base(
factory,
col,
rowCtor,
membersColumnized,
classScope,
optionalDistinctValueType,
hasFilter,
optionalFilter)
{
this.factory = factory;
currentMinMax = membersColumnized.AddMember(col, typeof(IComparable), "currentMinMax");
serde = classScope.AddOrGetDefaultFieldSharable(new CodegenSharableSerdeClassTyped(VALUE_NULLABLE, factory.ResultType));
}
