public ExprDotNodeForgeRootChild( ExprDotNodeImpl parent, FilterExprAnalyzerAffector filterExprAnalyzerAffector, int? streamNumReferenced, string rootPropertyName, bool hasEnumerationMethod, ExprForge rootNodeForge, ExprEnumerationForge rootLambdaEvaluator, EPType typeInfo, ExprDotForge[] forgesIteratorEventBean, ExprDotForge[] forgesUnpacking, bool checkedUnpackEvent) { Parent = parent; FilterExprAnalyzerAffector = filterExprAnalyzerAffector; StreamNumReferenced = streamNumReferenced; RootPropertyName = rootPropertyName; if (rootLambdaEvaluator != null) { if (typeInfo is EventMultiValuedEPType eventMultiValuedEpType) { innerForge = new InnerDotEnumerableEventCollectionForge( rootLambdaEvaluator, eventMultiValuedEpType.Component); } else if (typeInfo is EventEPType eventEpType) { innerForge = new InnerDotEnumerableEventBeanForge( rootLambdaEvaluator, eventEpType.EventType); } else { innerForge = new InnerDotEnumerableScalarCollectionForge( rootLambdaEvaluator, ((ClassMultiValuedEPType) typeInfo).Component); } } else { if (checkedUnpackEvent) { innerForge = new InnerDotScalarUnpackEventForge(rootNodeForge); } else { var returnType = rootNodeForge.EvaluationType; if (hasEnumerationMethod && returnType.IsArray) { if (returnType.GetElementType().CanNotBeNull()) { innerForge = new InnerDotArrPrimitiveToCollForge(rootNodeForge); } else { innerForge = new InnerDotArrObjectToCollForge(rootNodeForge); } } else if (hasEnumerationMethod && returnType.IsGenericCollection()) { innerForge = new InnerDotCollForge(rootNodeForge); } else { innerForge = new InnerDotScalarForge(rootNodeForge); } } } this.forgesUnpacking = forgesUnpacking; this.forgesIteratorEventBean = forgesIteratorEventBean; }
internal InstanceManufacturerForgeNonArray( Type returnType, ExprForge innerForge) { EvaluationType = returnType; this.innerForge = innerForge; }
public ExprForgeProxy( string expressionToString, ExprForge forge) { this.expressionToString = expressionToString; this.forge = forge; }
public StatementAgentInstanceFactorySelectForge( string[] streamNames, ViewableActivatorForge[] viewableActivatorForges, string resultSetProcessorProviderClassName, IList<ViewFactoryForge>[] views, ViewResourceDelegateDesc[] viewResourceDelegates, ExprForge whereClauseForge, JoinSetComposerPrototypeForge joinSetComposerPrototypeForge, string outputProcessViewProviderClassName, IDictionary<ExprSubselectNode, SubSelectFactoryForge> subselects, IDictionary<ExprTableAccessNode, ExprTableEvalStrategyFactoryForge> tableAccesses, bool orderByWithoutOutputRateLimit, bool unidirectionalJoin) { _streamNames = streamNames; _viewableActivatorForges = viewableActivatorForges; _resultSetProcessorProviderClassName = resultSetProcessorProviderClassName; _views = views; _viewResourceDelegates = viewResourceDelegates; _whereClauseForge = whereClauseForge; _joinSetComposerPrototypeForge = joinSetComposerPrototypeForge; _outputProcessViewProviderClassName = outputProcessViewProviderClassName; _subselects = subselects; _tableAccesses = tableAccesses; _orderByWithoutOutputRateLimit = orderByWithoutOutputRateLimit; _unidirectionalJoin = unidirectionalJoin; }
public static void AsDoubleNullReturnNull( CodegenBlock block, string variable, ExprForge forge, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { var type = forge.EvaluationType; if (type == typeof(double)) { block.DeclareVar( type, variable, forge.EvaluateCodegen(type, codegenMethodScope, exprSymbol, codegenClassScope)); return; } string holder = variable + "_"; block.DeclareVar( type, holder, forge.EvaluateCodegen(type, codegenMethodScope, exprSymbol, codegenClassScope)); if (type.CanBeNull()) { block.IfRefNullReturnNull(holder); } block.DeclareVar<double>( variable, SimpleNumberCoercerFactory.CoercerDouble.CodegenDouble(Ref(holder), type)); }
public ExprDotNodeForgeTransposeAsStream( ExprDotNodeImpl parent, ExprForge inner) { ExprForgeRenderable = parent; this.inner = inner; }
public AggregationAgentCountMinSketchForge( ExprForge stringEvaluator, ExprForge optionalFilterForge) { this.stringEvaluator = stringEvaluator; this.optionalFilterForge = optionalFilterForge; }
public ResultSetProcessorRowPerGroupForge( EventType resultEventType, EventType[] typesPerStream, ExprNode[] groupKeyNodeExpressions, ExprForge optionalHavingNode, bool isSelectRStream, bool isUnidirectional, OutputLimitSpec outputLimitSpec, bool isSorting, bool isHistoricalOnly, ResultSetProcessorOutputConditionType? outputConditionType, EventType[] eventTypes, OutputConditionPolledFactoryForge optionalOutputFirstConditionFactory, MultiKeyClassRef multiKeyClassRef, bool unboundedProcessor) { ResultEventType = resultEventType; this.typesPerStream = typesPerStream; GroupKeyNodeExpressions = groupKeyNodeExpressions; OptionalHavingNode = optionalHavingNode; IsSorting = isSorting; IsSelectRStream = isSelectRStream; IsUnidirectional = isUnidirectional; OutputLimitSpec = outputLimitSpec; IsHistoricalOnly = isHistoricalOnly; OutputConditionType = outputConditionType; EventTypes = eventTypes; OptionalOutputFirstConditionFactory = optionalOutputFirstConditionFactory; groupKeyTypes = ExprNodeUtilityQuery.GetExprResultTypes(groupKeyNodeExpressions); this.multiKeyClassRef = multiKeyClassRef; this.unboundedProcessor = unboundedProcessor; }
private static void CheckEvaluationType(ExprForge forge) { var evaluationType = forge.EvaluationType; if (evaluationType != typeof(bool) && evaluationType != typeof(bool?)) { throw new IllegalStateException("Invalid non-boolean expression"); } }
public SubordTableLookupStrategyFactoryQuadTreeForge GetSubordinateLookupStrategy( string operationName, IDictionary<int, ExprNode> positionalExpressions, bool isNWOnTrigger, int numOuterstreams) { ExprForge x = positionalExpressions.Get(0).Forge; ExprForge y = positionalExpressions.Get(1).Forge; ExprForge width = positionalExpressions.Get(2).Forge; ExprForge height = positionalExpressions.Get(3).Forge; string[] expressions = new string[positionalExpressions.Count]; foreach (KeyValuePair<int, ExprNode> entry in positionalExpressions) { expressions[entry.Key] = ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(entry.Value); } LookupStrategyDesc lookupStrategyDesc = new LookupStrategyDesc(LookupStrategyType.ADVANCED, expressions); return new SubordTableLookupStrategyFactoryQuadTreeForge( x, y, width, height, isNWOnTrigger, numOuterstreams, lookupStrategyDesc); }
public static void SortingCode <T>( CodegenBlock block, Type innerBoxedType, ExprForge innerExpression, CodegenMethod methodNode, ExprForgeCodegenSymbol scope, CodegenClassScope codegenClassScope) { var componentType = typeof(T); var collectionType = typeof(ICollection <>).MakeGenericType(componentType); var dequeType = typeof(ArrayDeque <>).MakeGenericType(componentType); block .DeclareVar(innerBoxedType, "value", innerExpression.EvaluateCodegen(innerBoxedType, methodNode, scope, codegenClassScope)) .DeclareVar(collectionType, "entry", ExprDotMethod(Ref("sort"), "Get", Ref("value"))) .IfCondition(EqualsNull(Ref("entry"))) .AssignRef("entry", NewInstance(dequeType)) .ExprDotMethod(Ref("entry"), "Add", Ref("next")) .Expression(ExprDotMethod(Ref("sort"), "Put", Ref("value"), Ref("entry"))) .BlockContinue() .ExprDotMethod(Ref("entry"), "Add", Ref("next")) .BlockEnd(); }
public static AggregationAgentForge Make( int streamNum, ExprNode optionalFilter, ImportService importService, bool isFireAndForget, string statementName) { ExprForge evaluator = optionalFilter == null ? null : optionalFilter.Forge; if (streamNum == 0) { if (optionalFilter == null) { return AggregationAgentDefault.INSTANCE; } else { return new AggregationAgentDefaultWFilterForge(evaluator); } } else { if (optionalFilter == null) { return new AggregationAgentRewriteStreamForge(streamNum); } else { return new AggregationAgentRewriteStreamWFilterForge(streamNum, evaluator); } } }
public static ExcludePlanHint GetHint( string[] streamNames, StatementRawInfo rawInfo, StatementCompileTimeServices services) { IList<string> hints = HintEnum.EXCLUDE_PLAN.GetHintAssignedValues(rawInfo.Annotations); if (hints == null) { return null; } IList<ExprEvaluator> filters = new List<ExprEvaluator>(); foreach (string hint in hints) { if (string.IsNullOrWhiteSpace(hint)) { continue; } ExprForge forge = ExcludePlanHintExprUtil.ToExpression(hint, rawInfo, services); if (Boxing.GetBoxedType(forge.EvaluationType) != typeof(bool?)) { throw new ExprValidationException( "Expression provided for hint " + HintEnum.EXCLUDE_PLAN + " must return a boolean value"); } filters.Add(forge.ExprEvaluator); } return new ExcludePlanHint(streamNames, filters, services); }
public EnumTakeWhileLastIndexEventsForge( ExprForge innerExpression, int streamNumLambda, ObjectArrayEventType indexEventType) : base(innerExpression, streamNumLambda, indexEventType) { }
public static ExprForge[] CrontabScheduleValidate( ExprNodeOrigin origin, IList<ExprNode> scheduleSpecExpressionList, bool allowBindingConsumption, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { // Validate the expressions ExprForge[] expressions = new ExprForge[scheduleSpecExpressionList.Count]; int count = 0; ExprValidationContext validationContext = new ExprValidationContextBuilder(new StreamTypeServiceImpl(false), statementRawInfo, services) .WithAllowBindingConsumption(allowBindingConsumption) .Build(); foreach (ExprNode parameters in scheduleSpecExpressionList) { ExprNode node = ExprNodeUtilityValidate.GetValidatedSubtree(origin, parameters, validationContext); expressions[count++] = node.Forge; } if (expressions.Length <= 4 || expressions.Length >= 8) { throw new ExprValidationException( "Invalid schedule specification: " + ScheduleSpecUtil.GetExpressionCountException(expressions.Length)); } return expressions; }
public static CodegenMethod CodegenExpression( ExprForge forge, CodegenMethod parent, CodegenClassScope classScope) { return CodegenExpression(forge, parent, classScope, true); }
public ExprDotForgeGetArray( ExprForge index, Type componentType) { IndexExpression = index; TypeInfo = EPTypeHelper.SingleValue(componentType); }
public static CodegenMethod CodegenExpression( ExprForge forge, CodegenMethod parent, CodegenClassScope classScope, bool returnMissingValueAsNull) { var evaluationType = forge.EvaluationType; if (returnMissingValueAsNull) { evaluationType = evaluationType.GetBoxedType(); } var exprSymbol = new ExprForgeCodegenSymbol(true, null); var exprMethod = parent .MakeChildWithScope(evaluationType, typeof(CodegenLegoMethodExpression), exprSymbol, classScope) .AddParam(ExprForgeCodegenNames.PARAMS); exprMethod.Block.DebugStack(); var expression = forge.EvaluateCodegen(evaluationType, exprMethod, exprSymbol, classScope); exprSymbol.DerivedSymbolsCodegen(parent, exprMethod.Block, classScope); if (evaluationType != typeof(void)) { exprMethod.Block.MethodReturn(expression); //CodegenLegoCast.CastSafeFromObjectType(evaluationType, expression); } else { exprMethod.Block.Expression(expression); } return exprMethod; }
public EnumAverageEventsForge( ExprForge innerExpression, int streamCountIncoming) : base(innerExpression, streamCountIncoming) { }
private static CodegenMethod CodegenBooleanExpressionBoxedToPrimitive( ExprForge forge, CodegenMethod parent, CodegenClassScope classScope) { var evaluationType = forge.EvaluationType; var exprSymbol = new ExprForgeCodegenSymbol(true, null); var exprMethod = parent .MakeChildWithScope(typeof(bool), typeof(CodegenLegoMethodExpression), exprSymbol, classScope) .AddParam(ExprForgeCodegenNames.PARAMS); var expression = forge.EvaluateCodegen(evaluationType, exprMethod, exprSymbol, classScope); exprSymbol.DerivedSymbolsCodegen(parent, exprMethod.Block, classScope); if (evaluationType.CanNotBeNull()) { exprMethod.Block.MethodReturn(expression); } else { exprMethod.Block .DeclareVar(evaluationType, PASS_NAME, expression) .IfRefNull(PASS_NAME) .BlockReturn(ConstantFalse()) .MethodReturn(ExprDotName(Ref(PASS_NAME), "Value")); } return exprMethod; }
public SelectEvalStreamWUnderlying( SelectExprForgeContext selectExprForgeContext, EventType resultEventType, IList<SelectClauseStreamCompiledSpec> namedStreams, bool usingWildcard, IList<SelectExprStreamDesc> unnamedStreams, bool singleStreamWrapper, bool underlyingIsFragmentEvent, int underlyingStreamNumber, EventPropertyGetterSPI underlyingPropertyEventGetter, ExprForge underlyingExprForge, TableMetaData tableMetadata, EventType[] eventTypes) : base(selectExprForgeContext, resultEventType, namedStreams, usingWildcard) { wrapperEventType = (WrapperEventType) resultEventType; this.unnamedStreams = unnamedStreams; this.singleStreamWrapper = singleStreamWrapper; this.underlyingIsFragmentEvent = underlyingIsFragmentEvent; this.underlyingStreamNumber = underlyingStreamNumber; this.underlyingPropertyEventGetter = underlyingPropertyEventGetter; this.underlyingExprForge = underlyingExprForge; this.tableMetadata = tableMetadata; this.eventTypes = eventTypes; }
public TimePeriodComputeNCGivenExprForge( ExprForge secondsEvaluator, TimeAbacus timeAbacus) { _secondsEvaluator = secondsEvaluator; _timeAbacus = timeAbacus; }
/// <summary> /// Ctor. /// </summary> /// <param name="whenExpressionNode">the expression to evaluate, returning true when to output</param> /// <param name="assignments">is the optional then-clause variable assignments, or null or empty if none</param> /// <param name="statementName">the statement name</param> /// <param name="services">services</param> /// <throws>ExprValidationException when validation fails</throws> public OutputConditionPolledExpressionFactoryForge( ExprNode whenExpressionNode, IList<OnTriggerSetAssignment> assignments, string statementName, StatementCompileTimeServices services) { this.whenExpressionNode = whenExpressionNode.Forge; // determine if using properties isUsingBuiltinProperties = false; if (ContainsBuiltinProperties(whenExpressionNode)) { isUsingBuiltinProperties = true; } else { if (assignments != null) { foreach (var assignment in assignments) { if (ContainsBuiltinProperties(assignment.Expression)) { isUsingBuiltinProperties = true; } } } } if (assignments != null) { variableReadWritePackage = new VariableReadWritePackageForge(assignments, statementName, services); } else { variableReadWritePackage = null; } }
public EnumAnyOfScalarForge( ExprForge innerExpression, int streamCountIncoming, ObjectArrayEventType type) : base(innerExpression, streamCountIncoming, type) { }
internal InstanceManufacturerForgeArray( Type componentReturnType, ExprForge innerForge) { this.componentReturnType = componentReturnType; this.innerForge = innerForge; }
public SortedAggregationStateDesc( bool max, ImportServiceCompileTime importService, ExprNode[] criteria, Type[] criteriaTypes, DataInputOutputSerdeForge[] criteriaSerdes, bool[] sortDescending, bool ever, int streamNum, ExprAggMultiFunctionSortedMinMaxByNode parent, ExprForge optionalFilter, EventType streamEventType) { IsMax = max; ImportService = importService; Criteria = criteria; CriteriaTypes = criteriaTypes; SortDescending = sortDescending; IsEver = ever; StreamNum = streamNum; Parent = parent; OptionalFilter = optionalFilter; StreamEventType = streamEventType; CriteriaSerdes = criteriaSerdes; }
public override void SetViewParameters( IList<ExprNode> parameters, ViewForgeEnv viewForgeEnv, int streamNumber) { sizeForge = ViewForgeSupport.ValidateSizeSingleParam(ViewName, parameters, viewForgeEnv, streamNumber); }
public ReformatBetweenNonConstantParamsForge(IList<ExprNode> parameters) { _start = parameters[0]; _startCoercer = DatetimeLongCoercerFactory.GetCoercer(_start.Forge.EvaluationType); _end = parameters[1]; _secondCoercer = DatetimeLongCoercerFactory.GetCoercer(_end.Forge.EvaluationType); if (parameters.Count == 2) { _includeBoth = true; _includeLow = true; _includeHigh = true; } else { if (parameters[2].Forge.ForgeConstantType.IsCompileTimeConstant) { _includeLow = GetBooleanValue(parameters[2]); } else { _forgeIncludeLow = parameters[2].Forge; } if (parameters[3].Forge.ForgeConstantType.IsCompileTimeConstant) { _includeHigh = GetBooleanValue(parameters[3]); } else { _forgeIncludeHigh = parameters[3].Forge; } if (_includeLow.GetValueOrDefault(false) && _includeHigh.GetValueOrDefault(false)) { _includeBoth = true; } } }
public static ExprForge NewInstance( string expressionToString, ExprForge forge) { return generator.CreateInterfaceProxyWithTarget<ExprForge>( forge, new ExprForgeProxy(expressionToString, forge)); }
/// <summary> /// Ctor. /// </summary> /// <param name="streamNum">stream id</param> /// <param name="childNode">expression</param> public AggregationAccessorFirstWEvalForge( int streamNum, ExprForge childNode) { StreamNum = streamNum; ChildNode = childNode; }