private ExprAggMultiFunctionSortedMinMaxByNodeFactory HandleCreateTable( ExprValidationContext validationContext) { if (PositionalParams.Length == 0) throw new ExprValidationException("Missing the sort criteria expression"); var message = "For tables columns, the aggregation function requires the 'sorted(*)' declaration"; if (!_sortedwin && !_ever) throw new ExprValidationException(message); if (validationContext.StreamTypeService.StreamNames.Length == 0) throw new ExprValidationException("'Sorted' requires that the event type is provided"); var containedType = validationContext.StreamTypeService.EventTypes[0]; var componentType = containedType.UnderlyingType; var criteriaExpressions = CriteriaExpressions; var accessorResultType = componentType; AggregationAccessor accessor; if (!_sortedwin) { accessor = new AggregationAccessorMinMaxByNonTable(IsMax); } else { accessor = new AggregationAccessorSortedNonTable(IsMax, componentType); accessorResultType = TypeHelper.GetArrayType(accessorResultType); } var stateFactoryFactory = new SortedAggregationStateFactoryFactory(validationContext.EngineImportService, validationContext.StatementExtensionSvcContext, ExprNodeUtility.GetEvaluators(criteriaExpressions.First), criteriaExpressions.Second, _ever, 0, this, null); return new ExprAggMultiFunctionSortedMinMaxByNodeFactory(this, accessor, accessorResultType, containedType, null, stateFactoryFactory, null); }
private ExprAggMultiFunctionSortedMinMaxByNodeFactory HandleIntoTable(ExprValidationContext validationContext) { int streamNum; var positionalParams = PositionalParams; if (positionalParams.Length == 0 || (positionalParams.Length == 1 && positionalParams[0] is ExprWildcard)) { ExprAggMultiFunctionUtil.ValidateWildcardStreamNumbers( validationContext.StreamTypeService, AggregationFunctionName); streamNum = 0; } else if (positionalParams.Length == 1 && positionalParams[0] is ExprStreamUnderlyingNode) { streamNum = ExprAggMultiFunctionUtil.ValidateStreamWildcardGetStreamNum(positionalParams[0]); } else if (positionalParams.Length > 0) { throw new ExprValidationException("When specifying into-table a sort expression cannot be provided"); } else { streamNum = 0; } var containedType = validationContext.StreamTypeService.EventTypes[streamNum]; var componentType = containedType.UnderlyingType; var accessorResultType = componentType; AggregationAccessor accessor; if (!_sortedwin) { accessor = new AggregationAccessorMinMaxByNonTable(_max); } else { accessor = new AggregationAccessorSortedNonTable(_max, componentType); accessorResultType = TypeHelper.GetArrayType(accessorResultType); } AggregationAgent agent = AggregationAgentDefault.INSTANCE; if (streamNum != 0) { agent = new AggregationAgentRewriteStream(streamNum); } return(new ExprAggMultiFunctionSortedMinMaxByNodeFactory( this, accessor, accessorResultType, containedType, null, null, agent)); }
private AggregationForgeFactoryAccessSorted HandleCreateTable(ExprValidationContext validationContext) { if (positionalParams.Length == 0) { throw new ExprValidationException("Missing the sort criteria expression"); } var message = "For tables columns, the aggregation function requires the 'sorted(*)' declaration"; if (!sortedwin && !ever) { throw new ExprValidationException(message); } if (validationContext.StreamTypeService.StreamNames.Length == 0) { throw new ExprValidationException("'Sorted' requires that the event type is provided"); } var containedType = validationContext.StreamTypeService.EventTypes[0]; var componentType = containedType.UnderlyingType; var criteriaExpressions = CriteriaExpressions; var accessorResultType = componentType; AggregationAccessorForge accessor; if (!sortedwin) { accessor = new AggregationAccessorMinMaxByNonTable(IsMax); } else { accessor = new AggregationAccessorSortedNonTable(IsMax, componentType); accessorResultType = TypeHelper.GetArrayType(accessorResultType); } var criteriaTypes = ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions.First); var stateDesc = new SortedAggregationStateDesc( IsMax, validationContext.ImportService, criteriaExpressions.First, criteriaTypes, criteriaExpressions.Second, ever, 0, this, null, containedType); return new AggregationForgeFactoryAccessSorted( this, accessor, accessorResultType, containedType, null, stateDesc, null); }
private AggregationForgeFactoryAccessSorted HandleIntoTable(ExprValidationContext validationContext) { int streamNum; if (positionalParams.Length == 0 || positionalParams.Length == 1 && positionalParams[0] is ExprWildcard) { ExprAggMultiFunctionUtil.ValidateWildcardStreamNumbers( validationContext.StreamTypeService, AggregationFunctionName); streamNum = 0; } else if (positionalParams.Length == 1 && positionalParams[0] is ExprStreamUnderlyingNode) { streamNum = ExprAggMultiFunctionUtil.ValidateStreamWildcardGetStreamNum(positionalParams[0]); } else if (positionalParams.Length > 0) { throw new ExprValidationException("When specifying into-table a sort expression cannot be provided"); } else { streamNum = 0; } var containedType = validationContext.StreamTypeService.EventTypes[streamNum]; var componentType = containedType.UnderlyingType; var accessorResultType = componentType; AggregationAccessorForge accessor; if (!sortedwin) { accessor = new AggregationAccessorMinMaxByNonTable(IsMax); } else { accessor = new AggregationAccessorSortedNonTable(IsMax, componentType); accessorResultType = TypeHelper.GetArrayType(accessorResultType); } AggregationAgentForge agent = AggregationAgentForgeFactory.Make( streamNum, optionalFilter, validationContext.ImportService, validationContext.StreamTypeService.IsOnDemandStreams, validationContext.StatementName); return new AggregationForgeFactoryAccessSorted( this, accessor, accessorResultType, containedType, null, null, agent); }
private ExprAggMultiFunctionSortedMinMaxByNodeFactory HandleTableAccess(TableMetadataColumnAggregation tableAccess) { var factory = (ExprAggMultiFunctionSortedMinMaxByNodeFactory)tableAccess.Factory; AggregationAccessor accessor; var componentType = factory.ContainedEventType.UnderlyingType; var accessorResultType = componentType; if (!_sortedwin) { accessor = new AggregationAccessorMinMaxByNonTable(_max); } else { accessor = new AggregationAccessorSortedNonTable(_max, componentType); accessorResultType = TypeHelper.GetArrayType(accessorResultType); } return(new ExprAggMultiFunctionSortedMinMaxByNodeFactory(this, accessor, accessorResultType, factory.ContainedEventType, null, null, null)); }
private ExprAggMultiFunctionSortedMinMaxByNodeFactory 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 = ExprNodeUtility.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 var forceEver = false; if (!_ever && ExprAggMultiFunctionLinearAccessNode.GetIstreamOnly(validationContext.StreamTypeService, streamNum)) { if (_sortedwin) { throw new ExprValidationException(ErrorPrefix + " requires that a data window is declared for the stream"); } forceEver = true; } // determine typing and evaluation _containedType = validationContext.StreamTypeService.EventTypes[streamNum]; var componentType = _containedType.UnderlyingType; var accessorResultType = componentType; AggregationAccessor accessor; TableMetadata tableMetadata = validationContext.TableService.GetTableMetadataFromEventType(_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; } var stateKey = new AggregationStateKeyWStream(streamNum, _containedType, type, criteriaExpressions.First); var stateFactoryFactory = new SortedAggregationStateFactoryFactory(validationContext.MethodResolutionService, ExprNodeUtility.GetEvaluators(criteriaExpressions.First), criteriaExpressions.Second, _ever, streamNum, this); return(new ExprAggMultiFunctionSortedMinMaxByNodeFactory(this, accessor, accessorResultType, _containedType, stateKey, stateFactoryFactory, 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 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 ExprAggMultiFunctionSortedMinMaxByNodeFactory HandleNonTable(ExprValidationContext validationContext) { var positionalParams = PositionalParams; 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 = ExprNodeUtility.GetIdentStreamNumbers(positionalParams[0]); if (streams.Count > 1 || streams.IsEmpty()) throw new ExprValidationException( GetErrorPrefix() + " 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( GetErrorPrefix() + " 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; AggregationAccessor accessor; var tableMetadata = validationContext.TableService.GetTableMetadataFromEventType(_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 optionalFilter = OptionalFilter; var stateKey = new AggregationStateKeyWStream( streamNum, _containedType, type, criteriaExpressions.First, optionalFilter); var optionalFilterEval = optionalFilter?.ExprEvaluator; var stateFactoryFactory = new SortedAggregationStateFactoryFactory(validationContext.EngineImportService, validationContext.StatementExtensionSvcContext, ExprNodeUtility.GetEvaluators(criteriaExpressions.First), criteriaExpressions.Second, _ever, streamNum, this, optionalFilterEval); return new ExprAggMultiFunctionSortedMinMaxByNodeFactory(this, accessor, accessorResultType, _containedType, stateKey, stateFactoryFactory, 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)); }
private AggregationForgeFactoryAccessSorted HandleCreateTable(ExprValidationContext validationContext) { if (positionalParams.Length == 0) { throw new ExprValidationException("Missing the sort criteria expression"); } string message = "For tables columns, the aggregation function requires the 'sorted(*)' declaration"; if (!_sortedwin && !_ever) { throw new ExprValidationException(message); } if (validationContext.StreamTypeService.StreamNames.Length == 0) { throw new ExprValidationException("'Sorted' requires that the event type is provided"); } EventType containedType = validationContext.StreamTypeService.EventTypes[0]; Type componentType = containedType.UnderlyingType; Pair <ExprNode[], bool[]> criteriaExpressions = CriteriaExpressions; Type accessorResultType = componentType; AggregationAccessorForge accessor; if (!_sortedwin) { accessor = new AggregationAccessorMinMaxByNonTable(_max); } else { accessor = new AggregationAccessorSortedNonTable(_max, componentType); accessorResultType = TypeHelper.GetArrayType(accessorResultType); } 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 stateDesc = new SortedAggregationStateDesc( _max, validationContext.ImportService, criteriaExpressions.First, criteriaTypes, criteriaSerdes, criteriaExpressions.Second, _ever, 0, this, null, containedType); IList <StmtClassForgeableFactory> serdeForgables = SerdeEventTypeUtility.Plan( containedType, validationContext.StatementRawInfo, validationContext.SerdeEventTypeRegistry, validationContext.SerdeResolver); validationContext.AdditionalForgeables.AddAll(serdeForgables); return(new AggregationForgeFactoryAccessSorted(this, accessor, accessorResultType, containedType, null, stateDesc, null)); }