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 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 override void InitMethodForge(
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope)
{
if (parent.IsFirst) {
aggregator = new AggregatorFirstEver(
this,
col,
rowCtor,
membersColumnized,
classScope,
null,
parent.HasFilter,
parent.OptionalFilter,
childType);
}
else {
aggregator = new AggregatorLastEver(
this,
col,
rowCtor,
membersColumnized,
classScope,
null,
parent.HasFilter,
parent.OptionalFilter,
childType);
}
}
public AggregatorSumNonBig(
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,
sumType)
{
var typeSet = Collections.Set(
typeof(decimal?),
typeof(double?),
typeof(long?),
typeof(int?),
typeof(float?));
if (!typeSet.Contains(sumType)) {
throw new ArgumentException("Invalid sum type " + sumType);
}
}
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 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 void InitAccessForge(
int col,
bool join,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope)
{
if (!join) {
AggregatorLinear = new AggregatorAccessLinearNonJoin(
this,
col,
rowCtor,
membersColumnized,
classScope,
expr.OptionalFilter);
}
else {
AggregatorLinear = new AggregatorAccessLinearJoin(
this,
col,
rowCtor,
membersColumnized,
classScope,
expr.OptionalFilter);
}
}
public override void InitMethodForge(
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope)
{
if (isEver) {
aggregator = new AggregatorRateEver(
this,
col,
rowCtor,
membersColumnized,
classScope,
null,
false,
parent.OptionalFilter);
}
else {
aggregator = new AggregatorRate(
this,
col,
rowCtor,
membersColumnized,
classScope,
null,
false,
parent.OptionalFilter);
}
}
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 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 override void InitMethodForge(
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope)
{
var distinctValueType = !parent.IsDistinct ? null : childType;
if (resultType.IsBigInteger()) {
_aggregator = new AggregatorAvgBig(
this,
col,
rowCtor,
membersColumnized,
classScope,
distinctValueType,
parent.HasFilter,
parent.OptionalFilter);
}
else {
_aggregator = new AggregatorAvgNonBig(
this,
col,
rowCtor,
membersColumnized,
classScope,
distinctValueType,
parent.HasFilter,
parent.OptionalFilter,
childType.GetBoxedType());
}
}
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 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 AggregatorSumBig(
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,
sumType)
{
if (sumType != typeof(BigInteger)) {
throw new ArgumentException("Invalid type " + sumType);
}
}
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 AggregatorLeaving(
AggregationFactoryMethodLeaving factory,
int col,
CodegenMemberCol membersColumnized)
{
this.factory = factory;
leaving = membersColumnized.AddMember(col, typeof(bool), "leaving");
}
public override void InitMethodForge(
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope)
{
throw new UnsupportedOperationException("Not supported");
}
public AggregatorLeaving(
AggregationForgeFactoryLeaving factory,
int col,
CodegenMemberCol membersColumnized)
{
_factory = factory;
_leaving = membersColumnized.AddMember(col, typeof(bool), "leaving");
}
public override void InitMethodForge(
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope)
{
forge = new AggregatorLeaving(this, col, membersColumnized);
}
public virtual void InitMethodForge(
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope)
{
throw new IllegalStateException("Not applicable for access-aggregations");
}
public void InitAccessForge(
int col,
bool join,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope)
{
aggregator = new AggregatorAccessCountMinSketch(this, col, rowCtor, membersColumnized, classScope);
}
public override void InitMethodForge(
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope)
{
Type distinctValueType = !parent.IsDistinct ? null : childType;
aggregator = new AggregatorNth(this, col, rowCtor, membersColumnized, classScope, distinctValueType, distinctSerde, false, parent.OptionalFilter);
}
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 AggregatorMethodFactoryContext(
int col,
CodegenCtor rowCtor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope)
{
this.col = col;
this.rowCtor = rowCtor;
this.membersColumnized = membersColumnized;
this.classScope = classScope;
}
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 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 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 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 AggregatorAvgNumeric(
AggregationForgeFactoryAvg 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, sumType)
{
_factoryMethodAvg = factory;
}
