private AggregationForgeFactoryAccessSorted HandleNonTable(ExprValidationContext validationContext)
{
if (positionalParams.Length == 0) {
throw new ExprValidationException("Missing the sort criteria expression");
}
// validate that the streams referenced in the criteria are a single stream's
var streams = ExprNodeUtilityQuery.GetIdentStreamNumbers(positionalParams[0]);
if (streams.Count > 1 || streams.IsEmpty()) {
throw new ExprValidationException(
ErrorPrefix + " requires that any parameter expressions evaluate properties of the same stream");
}
var streamNum = streams.First();
// validate that there is a remove stream, use "ever" if not
if (!ever &&
ExprAggMultiFunctionLinearAccessNode.GetIstreamOnly(
validationContext.StreamTypeService,
streamNum)) {
if (sortedwin) {
throw new ExprValidationException(
ErrorPrefix + " requires that a data window is declared for the stream");
}
}
// determine typing and evaluation
containedType = validationContext.StreamTypeService.EventTypes[streamNum];
var componentType = containedType.UnderlyingType;
var accessorResultType = componentType;
AggregationAccessorForge accessor;
var tableMetadata = validationContext.TableCompileTimeResolver.ResolveTableFromEventType(containedType);
if (!sortedwin) {
if (tableMetadata != null) {
accessor = new AggregationAccessorMinMaxByTable(IsMax, tableMetadata);
}
else {
accessor = new AggregationAccessorMinMaxByNonTable(IsMax);
}
}
else {
if (tableMetadata != null) {
accessor = new AggregationAccessorSortedTable(IsMax, componentType, tableMetadata);
}
else {
accessor = new AggregationAccessorSortedNonTable(IsMax, componentType);
}
accessorResultType = TypeHelper.GetArrayType(accessorResultType);
}
var criteriaExpressions = CriteriaExpressions;
AggregationStateTypeWStream type;
if (ever) {
type = IsMax ? AggregationStateTypeWStream.MAXEVER : AggregationStateTypeWStream.MINEVER;
}
else {
type = AggregationStateTypeWStream.SORTED;
}
var stateKey = new AggregationStateKeyWStream(
streamNum,
containedType,
type,
criteriaExpressions.First,
optionalFilter);
var optionalFilterForge = optionalFilter == null ? null : optionalFilter.Forge;
var streamEventType = validationContext.StreamTypeService.EventTypes[streamNum];
var criteriaTypes = ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions.First);
var sortedDesc = new
SortedAggregationStateDesc(
IsMax,
validationContext.ImportService,
criteriaExpressions.First,
criteriaTypes,
criteriaExpressions.Second,
ever,
streamNum,
this,
optionalFilterForge,
streamEventType);
return new AggregationForgeFactoryAccessSorted(
this,
accessor,
accessorResultType,
containedType,
stateKey,
sortedDesc,
AggregationAgentDefault.INSTANCE);
}
private AggregationForgeFactoryAccessSorted HandleNonTable(ExprValidationContext validationContext)
{
if (positionalParams.Length == 0)
{
throw new ExprValidationException("Missing the sort criteria expression");
}
// validate that the streams referenced in the criteria are a single stream's
ISet <int> streams = ExprNodeUtilityQuery.GetIdentStreamNumbers(positionalParams[0]);
if (streams.Count > 1 || streams.IsEmpty())
{
throw new ExprValidationException(ErrorPrefix + " requires that any parameter expressions evaluate properties of the same stream");
}
int streamNum = streams.First();
// validate that there is a remove stream, use "ever" if not
if (!_ever && ExprAggMultiFunctionLinearAccessNode.GetIstreamOnly(validationContext.StreamTypeService, streamNum))
{
if (_sortedwin)
{
throw new ExprValidationException(ErrorPrefix + " requires that a data window is declared for the stream");
}
}
// determine typing and evaluation
_containedType = validationContext.StreamTypeService.EventTypes[streamNum];
Type componentType = _containedType.UnderlyingType;
Type accessorResultType = componentType;
AggregationAccessorForge accessor;
TableMetaData tableMetadata = validationContext.TableCompileTimeResolver.ResolveTableFromEventType(_containedType);
if (!_sortedwin)
{
if (tableMetadata != null)
{
accessor = new AggregationAccessorMinMaxByTable(_max, tableMetadata);
}
else
{
accessor = new AggregationAccessorMinMaxByNonTable(_max);
}
}
else
{
if (tableMetadata != null)
{
accessor = new AggregationAccessorSortedTable(_max, componentType, tableMetadata);
}
else
{
accessor = new AggregationAccessorSortedNonTable(_max, componentType);
}
accessorResultType = TypeHelper.GetArrayType(accessorResultType);
}
Pair <ExprNode[], bool[]> criteriaExpressions = CriteriaExpressions;
AggregationStateTypeWStream type;
if (_ever)
{
type = _max ? AggregationStateTypeWStream.MAXEVER : AggregationStateTypeWStream.MINEVER;
}
else
{
type = AggregationStateTypeWStream.SORTED;
}
AggregationStateKeyWStream stateKey = new AggregationStateKeyWStream(streamNum, _containedType, type, criteriaExpressions.First, optionalFilter);
ExprForge optionalFilterForge = optionalFilter == null ? null : optionalFilter.Forge;
EventType streamEventType = validationContext.StreamTypeService.EventTypes[streamNum];
Type[] criteriaTypes = ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions.First);
DataInputOutputSerdeForge[] criteriaSerdes = new DataInputOutputSerdeForge[criteriaTypes.Length];
for (int i = 0; i < criteriaTypes.Length; i++)
{
criteriaSerdes[i] = validationContext.SerdeResolver.SerdeForAggregation(criteriaTypes[i], validationContext.StatementRawInfo);
}
SortedAggregationStateDesc sortedDesc = new
SortedAggregationStateDesc(
_max,
validationContext.ImportService,
criteriaExpressions.First,
criteriaTypes,
criteriaSerdes,
criteriaExpressions.Second,
_ever,
streamNum,
this,
optionalFilterForge,
streamEventType);
IList <StmtClassForgeableFactory> serdeForgables = SerdeEventTypeUtility.Plan(
_containedType,
validationContext.StatementRawInfo,
validationContext.SerdeEventTypeRegistry,
validationContext.SerdeResolver);
validationContext.AdditionalForgeables.AddAll(serdeForgables);
return(new AggregationForgeFactoryAccessSorted(
this,
accessor,
accessorResultType,
_containedType,
stateKey,
sortedDesc,
AggregationAgentDefault.INSTANCE));
}
