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;
}
