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 SerdeEventPropertyDesc(
DataInputOutputSerdeForge forge,
ISet<EventType> nestedTypes)
{
Forge = forge;
NestedTypes = nestedTypes;
}
public SerdeAndForgeables(
DataInputOutputSerdeForge forge,
IList <StmtClassForgeableFactory> additionalForgeables)
{
this.forge = forge;
this.additionalForgeables = additionalForgeables;
}
private static List<StmtClassForgeableFactory> PlanMultikeys(
QueryPlanIndexForge[] indexSpecs,
StatementRawInfo raw,
StatementCompileTimeServices compileTimeServices)
{
List<StmtClassForgeableFactory> multiKeyForgeables = new List<StmtClassForgeableFactory>();
foreach (QueryPlanIndexForge spec in indexSpecs) {
if (spec == null) {
continue;
}
foreach (var entry in spec.Items) {
QueryPlanIndexItemForge forge = entry.Value;
MultiKeyPlan plan = MultiKeyPlanner.PlanMultiKey(
forge.HashTypes, false, raw, compileTimeServices.SerdeResolver);
multiKeyForgeables.AddAll(plan.MultiKeyForgeables);
forge.HashMultiKeyClasses = plan.ClassRef;
DataInputOutputSerdeForge[] rangeSerdes = new DataInputOutputSerdeForge[forge.RangeTypes.Length];
for (int i = 0; i < forge.RangeTypes.Length; i++) {
rangeSerdes[i] = compileTimeServices.SerdeResolver.SerdeForIndexBtree(forge.RangeTypes[i], raw);
}
forge.RangeSerdes = rangeSerdes;
}
}
return multiKeyForgeables;
}
public MultiKeyClassRefWSerde(
DataInputOutputSerdeForge forge,
Type[] types)
{
this.forge = forge;
this.types = types;
}
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 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 AggregationForgeFactoryAvg(ExprAvgNode parent, Type childType, DataInputOutputSerdeForge distinctSerde, MathContext optionalMathContext)
{
this.parent = parent;
this.childType = childType;
this.distinctSerde = distinctSerde;
this.resultType = GetAvgAggregatorType(childType);
this.optionalMathContext = optionalMathContext;
}
public void AddSerdeFor(
EventType eventType,
DataInputOutputSerdeForge forge)
{
if (IsTargetHA) {
EventTypes.Put(eventType, forge);
}
}
public AggregationForgeFactoryStddev(
ExprStddevNode parent,
Type aggregatedValueType,
DataInputOutputSerdeForge distinctSerde)
{
this._parent = parent;
this._aggregatedValueType = aggregatedValueType;
this._distinctSerde = distinctSerde;
}
public MultiKeyClassRefPredetermined(
Type clazzMK,
Type[] mkTypes,
DataInputOutputSerdeForge serdeForge)
{
_clazzMK = clazzMK;
MKTypes = mkTypes;
_serdeForge = serdeForge;
}
public AggregationForgeFactoryMedian(
ExprMedianNode parent,
Type aggregatedValueType,
DataInputOutputSerdeForge distinctSerde)
{
_parent = parent;
_aggregatedValueType = aggregatedValueType;
_distinctSerde = distinctSerde;
}
private DataInputOutputSerdeForge[] Noop(Type[] types)
{
DataInputOutputSerdeForge[] forges = new DataInputOutputSerdeForge[types.Length];
for (int i = 0; i < forges.Length; i++)
{
forges[i] = Noop();
}
return(forges);
}
public AggregationForgeFactorySum(
ExprSumNode parent,
Type inputValueType,
DataInputOutputSerdeForge distinctSerde)
{
_parent = parent;
_inputValueType = inputValueType;
_distinctSerde = distinctSerde;
_resultType = GetSumAggregatorType(inputValueType);
}
public CodegenSharableSerdeClassTyped(
CodegenSharableSerdeName name,
Type valueType,
DataInputOutputSerdeForge forge,
CodegenClassScope classScope)
{
this._name = name;
this._valueType = valueType;
this._forge = forge;
this._classScope = classScope;
}
public AggregationForgeFactoryCount(
ExprCountNode parent,
bool ignoreNulls,
Type countedValueType,
DataInputOutputSerdeForge distinctValueSerde)
{
this._parent = parent;
this._ignoreNulls = ignoreNulls;
this._countedValueType = countedValueType;
this._distinctValueSerde = distinctValueSerde;
}
public AggregationForgeFactoryAvedev(
ExprAvedevNode parent,
Type aggregatedValueType,
DataInputOutputSerdeForge distinctSerde,
ExprNode[] positionalParameters)
{
_parent = parent;
_aggregatedValueType = aggregatedValueType;
_distinctSerde = distinctSerde;
_positionalParameters = positionalParameters;
}
public AggregationForgeFactoryFirstLastUnbound(
ExprAggMultiFunctionLinearAccessNode parent,
Type resultType,
bool hasFilter,
DataInputOutputSerdeForge serde)
{
this.parent = parent;
this.resultType = resultType;
this.hasFilter = hasFilter;
this.serde = serde;
}
public AggregationForgeFactoryCountEver(
ExprCountEverNode parent,
bool ignoreNulls,
Type childType,
DataInputOutputSerdeForge distinctSerde)
{
this._parent = parent;
this._ignoreNulls = ignoreNulls;
this._childType = childType;
this._distinctSerde = distinctSerde;
}
private DataInputOutputSerdeForge[] SerdeForClasses(
Type[] sortCriteriaExpressions,
SerdeProviderAdditionalInfo additionalInfo)
{
DataInputOutputSerdeForge[] forges = new DataInputOutputSerdeForge[sortCriteriaExpressions.Length];
for (int i = 0; i < sortCriteriaExpressions.Length; i++)
{
forges[i] = SerdeForClass(sortCriteriaExpressions[i], additionalInfo);
}
return(forges);
}
public StmtClassForgeableAIFactoryProviderCreateVariable(
string className,
CodegenNamespaceScope namespaceScope,
StatementAgentInstanceFactoryCreateVariableForge forge,
string variableName,
DataInputOutputSerdeForge serde)
: base(className, namespaceScope)
{
_forge = forge;
_variableName = variableName;
_serde = serde;
}
public AggregationForgeFactoryPlugin(
ExprPlugInAggNode parent,
AggregationFunctionForge aggregationFunctionForge,
AggregationFunctionMode mode,
Type aggregatedValueType,
DataInputOutputSerdeForge distinctSerde)
{
this.parent = parent;
this.aggregationFunctionForge = aggregationFunctionForge;
this.mode = mode;
this.aggregatedValueType = aggregatedValueType;
this.distinctSerde = distinctSerde;
}
public AggregationForgeFactoryMinMax(
ExprMinMaxAggrNode parent,
Type type,
bool hasDataWindows,
DataInputOutputSerdeForge serde,
DataInputOutputSerdeForge distinctSerde)
{
this.parent = parent;
this.type = type;
this.hasDataWindows = hasDataWindows;
this.serde = serde;
this.distinctSerde = distinctSerde;
}
public AggregationForgeFactoryNth(
ExprNthAggNode parent,
Type childType,
DataInputOutputSerdeForge serde,
DataInputOutputSerdeForge distinctSerde,
int size)
{
this.parent = parent;
this.childType = childType;
this.serde = serde;
this.distinctSerde = distinctSerde;
this.size = size;
}
private static SerdeAndForgeables PlanBaseNestable(
BaseNestableEventType eventType,
StatementRawInfo raw,
SerdeCompileTimeResolver resolver)
{
string className;
if (eventType is JsonEventType)
{
var classNameFull = ((JsonEventType)eventType).Detail.SerdeClassName;
var lastDotIndex = classNameFull.LastIndexOf('.');
className = lastDotIndex == -1 ? classNameFull : classNameFull.Substring(lastDotIndex + 1);
}
else
{
var uuid = GenerateClassNameUUID();
className = GenerateClassNameWithUUID(typeof(DataInputOutputSerde), eventType.Metadata.Name, uuid);
}
var optionalApplicationSerde = resolver.SerdeForEventTypeExternalProvider(eventType, raw);
if (optionalApplicationSerde != null)
{
return(new SerdeAndForgeables(optionalApplicationSerde, EmptyList <StmtClassForgeableFactory> .Instance));
}
var forges = new DataInputOutputSerdeForge[eventType.Types.Count];
var count = 0;
foreach (var property in eventType.Types)
{
var desc = ForgeForEventProperty(eventType, property.Key, property.Value, raw, resolver);
forges[count] = desc.Forge;
count++;
}
StmtClassForgeableFactory forgeable = new ProxyStmtClassForgeableFactory()
{
ProcMake = (
namespaceScope,
classPostfix) => {
return(new StmtClassForgeableBaseNestableEventTypeSerde(className, namespaceScope, eventType, forges));
},
};
var forge = new DataInputOutputSerdeForgeForClassName(className);
return(new SerdeAndForgeables(forge, Collections.SingletonList(forgeable)));
}
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;
}
public PropertySortedFactoryFactoryForge(
int indexedStreamNum,
int? subqueryNum,
bool isFireAndForget,
string indexedProp,
EventType eventType,
CoercionDesc coercionDesc,
DataInputOutputSerdeForge serde)
: base(indexedStreamNum, subqueryNum, isFireAndForget)
{
this.indexedProp = indexedProp;
this.eventType = eventType;
this.coercionDesc = coercionDesc;
this.serde = serde;
}
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 ExprFilterSpecLookupableForge(
string expression,
ExprEventEvaluatorForge optionalEventEvalForge,
ExprForge optionalExprForge,
Type returnType,
bool isNonPropertyGetter,
DataInputOutputSerdeForge valueSerde)
{
// prefixing the expression ensures the expression resolves to either the event-eval or the expr-eval
_expression = optionalExprForge != null ? "." + expression : expression;
_optionalEventEvalForge = optionalEventEvalForge;
_optionalExprForge = optionalExprForge;
_returnType = Boxing.GetBoxedType(returnType); // For type consistency for recovery and serde define as boxed type
_isNonPropertyGetter = isNonPropertyGetter;
_valueSerde = valueSerde;
}
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");
}
