public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
{
_parentEventType = parentEventType;
var validatedNodes = ViewFactorySupport.Validate(_viewFactoryContext.ViewName, parentEventType, _viewFactoryContext.StatementContext, _viewParameters, true);
_viewParameterArr = new Object[validatedNodes.Length];
var evaluatorContextStmt = new ExprEvaluatorContextStatement(_viewFactoryContext.StatementContext, false);
for (var i = 0; i < validatedNodes.Length; i++)
{
try {
_viewParameterArr[i] = ViewFactorySupport.EvaluateAssertNoProperties(_viewFactoryContext.ViewName, validatedNodes[i], i, evaluatorContextStmt);
}
catch (Exception) {
// expected
}
}
_viewParameterExp = ViewFactorySupport.Validate(_viewFactoryContext.ViewName, parentEventType, _viewFactoryContext.StatementContext, _viewParameters, true);
// initialize
try {
_eventBeanFactory = EventAdapterServiceHelper.GetFactoryForType(parentEventType, statementContext.EventAdapterService);
_virtualDataWindowFactory.Initialize(new VirtualDataWindowFactoryContext(parentEventType, _viewParameterArr, _viewParameterExp, _eventBeanFactory, _namedWindowName, _viewFactoryContext, _customConfiguration));
}
catch (Exception ex) {
throw new ViewParameterException("Validation exception initializing virtual data window '" + _namedWindowName + "': " + ex.Message, ex);
}
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
var validated = ViewFactorySupport.Validate(
ViewName, viewFactoryContext.StatementContext, expressionParameters);
var errorMessage = ViewName +
" view requires a numeric or time period parameter as a time interval size, and an integer parameter as a maximal number-of-events, and an optional list of control keywords as a string parameter (please see the documentation)";
if ((validated.Length != 2) && (validated.Length != 3))
{
throw new ViewParameterException(errorMessage);
}
timeDeltaComputationFactory = ViewFactoryTimePeriodHelper.ValidateAndEvaluateTimeDeltaFactory(
ViewName, viewFactoryContext.StatementContext, expressionParameters[0], errorMessage, 0);
_sizeEvaluator = ViewFactorySupport.ValidateSizeParam(
ViewName, viewFactoryContext.StatementContext, validated[1], 1);
if (validated.Length > 2)
{
var keywords = ViewFactorySupport.Evaluate(
validated[2].ExprEvaluator, 2, ViewName, viewFactoryContext.StatementContext);
ProcessKeywords(keywords, errorMessage);
}
}
public View MakeView(AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
int sortWindowSize = ViewFactorySupport.EvaluateSizeParam(ViewName, _sizeEvaluator, agentInstanceViewFactoryContext.AgentInstanceContext);
IStreamSortRankRandomAccess rankedRandomAccess = agentInstanceViewFactoryContext.StatementContext.ViewServicePreviousFactory.GetOptPreviousExprSortedRankedAccess(agentInstanceViewFactoryContext);
return(new RankWindowView(this, _uniqueCriteriaExpressions, _uniqueEvals, _sortCriteriaExpressions, _sortEvals, _isDescendingValues, sortWindowSize, rankedRandomAccess, _useCollatorSort, agentInstanceViewFactoryContext));
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
IList <Object> viewParameters = ViewFactorySupport.ValidateAndEvaluate(ViewName, viewFactoryContext.StatementContext, expressionParameters);
if (viewParameters.Count != 1)
{
throw new ViewParameterException(ViewParamMessage);
}
Object parameter = viewParameters[0];
if (!(parameter.IsNumber()))
{
throw new ViewParameterException(ViewParamMessage);
}
var numParam = parameter;
if ((numParam.IsFloatingPointNumber()) ||
(numParam.IsLongNumber()))
{
throw new ViewParameterException(ViewParamMessage);
}
Size = numParam.AsInt();
if (Size <= 0)
{
throw new ViewParameterException(ViewName + " view requires a positive number");
}
}
public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
{
String windowName = ViewName;
ExprNode[] validated = ViewFactorySupport.Validate(windowName, parentEventType, statementContext, _viewParameters, true);
if (_viewParameters.Count < 2 || _viewParameters.Count > 3)
{
throw new ViewParameterException(ViewParamMessage);
}
// validate first parameter: timestamp expression
if (!validated[0].ExprEvaluator.ReturnType.IsNumeric())
{
throw new ViewParameterException(ViewParamMessage);
}
TimestampExpression = validated[0];
TimestampExpressionEval = TimestampExpression.ExprEvaluator;
ViewFactorySupport.AssertReturnsNonConstant(windowName, validated[0], 0);
TimeDeltaComputation = ViewFactoryTimePeriodHelper.ValidateAndEvaluateTimeDelta(ViewName, statementContext, _viewParameters[1], ViewParamMessage, 1);
// validate optional parameters
if (validated.Length == 3)
{
Object constant = ViewFactorySupport.ValidateAndEvaluate(windowName, statementContext, validated[2]);
if ((!constant.IsNumber()) || (TypeHelper.IsFloatingPointNumber(constant)))
{
throw new ViewParameterException("Externally-timed batch view requires a Long-typed reference point in msec as a third parameter");
}
OptionalReferencePoint = constant.AsLong();
}
this._eventType = parentEventType;
}
public void Attach(
EventType parentEventType,
StatementContext statementContext,
ViewFactory optionalParentFactory,
IList <ViewFactory> parentViewFactories)
{
var validated = ViewFactorySupport.Validate(
ViewName, parentEventType, statementContext, _viewParameters, true);
if (_viewParameters.Count != 2)
{
throw new ViewParameterException(ViewParamMessage);
}
if (!validated[0].ExprEvaluator.ReturnType.IsNumeric())
{
throw new ViewParameterException(ViewParamMessage);
}
_timestampExpression = validated[0];
_timestampExpressionEval = _timestampExpression.ExprEvaluator;
ViewFactorySupport.AssertReturnsNonConstant(ViewName, validated[0], 0);
_timeDeltaComputationFactory = ViewFactoryTimePeriodHelper.ValidateAndEvaluateTimeDeltaFactory(
ViewName, statementContext, _viewParameters[1], ViewParamMessage, 1);
_eventType = parentEventType;
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
var viewParameters = new Object[expressionParameters.Count];
for (var i = 1; i < expressionParameters.Count; i++)
{
viewParameters[i] = ViewFactorySupport.ValidateAndEvaluate(
ViewName, viewFactoryContext.StatementContext, expressionParameters[i]);
}
var errorMessage = ViewName +
" view requires a numeric or time period parameter as a time interval size, and an integer parameter as a maximal number-of-events, and an optional list of control keywords as a string parameter (please see the documentation)";
if ((viewParameters.Length != 2) && (viewParameters.Length != 3))
{
throw new ViewParameterException(errorMessage);
}
TimeDeltaComputation = ViewFactoryTimePeriodHelper.ValidateAndEvaluateTimeDelta(
ViewName, viewFactoryContext.StatementContext, expressionParameters[0], errorMessage, 0);
// parameter 2
var parameter = viewParameters[1];
if (!(parameter.IsNumber()) || (TypeHelper.IsFloatingPointNumber(parameter)))
{
throw new ViewParameterException(errorMessage);
}
_numberOfEvents = parameter.AsLong();
if (viewParameters.Length > 2)
{
ProcessKeywords(viewParameters[2], errorMessage);
}
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
if (expressionParameters.Count != 1)
{
throw new ViewParameterException("View requires a single parameter indicating unbound or not");
}
_isUnbound = (bool)ViewFactorySupport.ValidateAndEvaluate(ViewName, viewFactoryContext.StatementContext, expressionParameters[0]);
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
var viewParameters = ViewFactorySupport.ValidateAndEvaluate(ViewName, viewFactoryContext.StatementContext, expressionParameters);
if (viewParameters.Count != 0)
{
String errorMessage = ViewName + " view requires an empty parameter list";
throw new ViewParameterException(errorMessage);
}
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
IList <Object> viewParameters = ViewFactorySupport.ValidateAndEvaluate(ViewName, viewFactoryContext.StatementContext, expressionParameters);
if (viewParameters.IsNotEmpty())
{
String errorMessage = ViewName + " view does not take any parameters";
throw new ViewParameterException(errorMessage);
}
}
public bool CanReuse(View view, AgentInstanceContext agentInstanceContext)
{
if (!(view is FirstLengthWindowView))
{
return false;
}
var myView = (FirstLengthWindowView) view;
int size = ViewFactorySupport.EvaluateSizeParam(ViewName, _sizeEvaluator, agentInstanceContext);
return myView.Size == size && myView.IsEmpty();
}
public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
{
_criteriaExpressions = ViewFactorySupport.Validate(ViewName, parentEventType, statementContext, ViewParameters, false);
if (_criteriaExpressions.Length == 0)
{
String errorMessage = ViewName + " view requires a one or more expressions provinding unique values as parameters";
throw new ViewParameterException(errorMessage);
}
_eventType = parentEventType;
}
public View MakeView(AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
var timeDeltaComputation = timeDeltaComputationFactory.Make(
ViewName, "view", agentInstanceViewFactoryContext.AgentInstanceContext);
var size = ViewFactorySupport.EvaluateSizeParam(
ViewName, _sizeEvaluator, agentInstanceViewFactoryContext.AgentInstanceContext);
var viewUpdatedCollection =
agentInstanceViewFactoryContext.StatementContext.ViewServicePreviousFactory
.GetOptPreviousExprRelativeAccess(agentInstanceViewFactoryContext);
return(new TimeLengthBatchView(
this, agentInstanceViewFactoryContext, timeDeltaComputation, size, IsForceUpdate, IsStartEager,
viewUpdatedCollection));
}
public override void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
if (expressionParameters.Count != 1 && expressionParameters.Count != 2)
{
var errorMessage = ViewName + " view requires a single expression as a parameter, or an expression and bool flag";
throw new ViewParameterException(errorMessage);
}
ExpiryExpression = expressionParameters[0];
if (expressionParameters.Count > 1)
{
var result = ViewFactorySupport.EvaluateAssertNoProperties(ViewName, expressionParameters[1], 1, new ExprEvaluatorContextStatement(viewFactoryContext.StatementContext, false));
_includeTriggeringEvent = result.AsBoolean();
}
}
public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
{
EventType = parentEventType;
var message = NAME + " window requires a numeric size parameter and a list of expressions providing sort keys";
if (_viewParameters.Count < 2)
{
throw new ViewParameterException(message);
}
var validated = ViewFactorySupport.Validate(NAME + " window", parentEventType, statementContext, _viewParameters, true);
for (var i = 1; i < validated.Length; i++)
{
ViewFactorySupport.AssertReturnsNonConstant(NAME + " window", validated[i], i);
}
var exprEvaluatorContext = new ExprEvaluatorContextStatement(statementContext, false);
var sortSize = ViewFactorySupport.EvaluateAssertNoProperties(NAME + " window", validated[0], 0, exprEvaluatorContext);
if ((sortSize == null) || (!sortSize.IsNumber()))
{
throw new ViewParameterException(message);
}
SortWindowSize = sortSize.AsInt();
sortCriteriaExpressions = new ExprNode[validated.Length - 1];
IsDescendingValues = new bool[sortCriteriaExpressions.Length];
for (var i = 1; i < validated.Length; i++)
{
if (validated[i] is ExprOrderedExpr)
{
IsDescendingValues[i - 1] = ((ExprOrderedExpr)validated[i]).IsDescending;
sortCriteriaExpressions[i - 1] = validated[i].ChildNodes[0];
}
else
{
sortCriteriaExpressions[i - 1] = validated[i];
}
}
SortCriteriaEvaluators = ExprNodeUtility.GetEvaluators(sortCriteriaExpressions);
if (statementContext.ConfigSnapshot != null)
{
IsUseCollatorSort = statementContext.ConfigSnapshot.EngineDefaults.LanguageConfig.IsSortUsingCollator;
}
}
public void Attach(
EventType parentEventType,
StatementContext statementContext,
ViewFactory optionalParentFactory,
IList <ViewFactory> parentViewFactories)
{
_eventType = parentEventType;
const string message =
NAME + " window requires a numeric size parameter and a list of expressions providing sort keys";
if (_viewParameters.Count < 2)
{
throw new ViewParameterException(message);
}
var validated = ViewFactorySupport.Validate(
NAME + " window", parentEventType, statementContext, _viewParameters, true);
for (var i = 1; i < validated.Length; i++)
{
ViewFactorySupport.AssertReturnsNonConstant(NAME + " window", validated[i], i);
}
ViewFactorySupport.ValidateNoProperties(ViewName, validated[0], 0);
_sizeEvaluator = ViewFactorySupport.ValidateSizeParam(ViewName, statementContext, validated[0], 0);
_sortCriteriaExpressions = new ExprNode[validated.Length - 1];
_isDescendingValues = new bool[_sortCriteriaExpressions.Length];
for (var i = 1; i < validated.Length; i++)
{
if (validated[i] is ExprOrderedExpr)
{
_isDescendingValues[i - 1] = ((ExprOrderedExpr)validated[i]).IsDescending;
_sortCriteriaExpressions[i - 1] = validated[i].ChildNodes[0];
}
else
{
_sortCriteriaExpressions[i - 1] = validated[i];
}
}
_sortCriteriaEvaluators = ExprNodeUtility.GetEvaluators(_sortCriteriaExpressions);
if (statementContext.ConfigSnapshot != null)
{
_useCollatorSort = statementContext.ConfigSnapshot.EngineDefaults.Language.IsSortUsingCollator;
}
}
public View MakeView(AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
int size = ViewFactorySupport.EvaluateSizeParam(
ViewName, _sizeEvaluator, agentInstanceViewFactoryContext.AgentInstanceContext);
ViewUpdatedCollection viewUpdatedCollection =
agentInstanceViewFactoryContext.StatementContext.ViewServicePreviousFactory
.GetOptPreviousExprRelativeAccess(agentInstanceViewFactoryContext);
if (agentInstanceViewFactoryContext.IsRemoveStream)
{
return new LengthBatchViewRStream(agentInstanceViewFactoryContext, this, size);
}
else
{
return new LengthBatchView(agentInstanceViewFactoryContext, this, size, viewUpdatedCollection);
}
}
public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
{
ExprNode[] validated = ViewFactorySupport.Validate(ViewName, parentEventType, statementContext, _viewParameters, true);
if (validated.Length < 1)
{
throw new ViewParameterException(ViewParamMessage);
}
if (!validated[0].ExprEvaluator.ReturnType.IsNumeric())
{
throw new ViewParameterException(ViewParamMessage);
}
_fieldExpression = validated[0];
_additionalProps = StatViewAdditionalProps.Make(validated, 1, parentEventType);
_eventType = UnivariateStatisticsView.CreateEventType(statementContext, _additionalProps, _streamNumber);
}
public bool CanReuse(View view, AgentInstanceContext agentInstanceContext)
{
if (!(view is SortWindowView))
{
return(false);
}
SortWindowView other = (SortWindowView)view;
int sortWindowSize = ViewFactorySupport.EvaluateSizeParam(ViewName, _sizeEvaluator, agentInstanceContext);
if ((other.SortWindowSize != sortWindowSize) ||
(!Compare(other.IsDescendingValues, _isDescendingValues)) ||
(!ExprNodeUtility.DeepEquals(other.SortCriteriaExpressions, _sortCriteriaExpressions)))
{
return(false);
}
return(other.IsEmpty());
}
public void Attach(
EventType parentEventType,
StatementContext statementContext,
ViewFactory optionalParentFactory,
IList<ViewFactory> parentViewFactories)
{
ExprNode[] validated = ViewFactorySupport.Validate(ViewName, parentEventType, statementContext, _viewParameters, true);
if (_viewParameters.Count != 1)
{
throw new ViewParameterException(GetViewParamMessage());
}
if (validated[0].ExprEvaluator.ReturnType.GetBoxedType() != typeof(long?))
{
throw new ViewParameterException(GetViewParamMessage());
}
_timestampExpression = validated[0];
_eventType = parentEventType;
_timestampExpressionEvaluator = _timestampExpression.ExprEvaluator;
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
if ((expressionParameters.Count < 1) || (expressionParameters.Count > 3))
{
throw new ViewParameterException(ViewParamMessage);
}
var viewParamValues = new Object[expressionParameters.Count];
for (int i = 1; i < viewParamValues.Length; i++)
{
viewParamValues[i] = ViewFactorySupport.ValidateAndEvaluate(
ViewName, viewFactoryContext.StatementContext, expressionParameters[i]);
}
TimeDeltaComputation = ViewFactoryTimePeriodHelper.ValidateAndEvaluateTimeDelta(
ViewName, viewFactoryContext.StatementContext, expressionParameters[0],
ViewParamMessage, 0);
if ((viewParamValues.Length == 2) && (viewParamValues[1] is String))
{
ProcessKeywords(viewParamValues[1], ViewParamMessage);
}
else
{
if (viewParamValues.Length >= 2)
{
Object paramRef = viewParamValues[1];
if ((!(paramRef.IsNumber())) || (paramRef.IsFloatingPointNumber()))
{
throw new ViewParameterException(
ViewName + " view requires a Long-typed reference point in msec as a second parameter");
}
OptionalReferencePoint = paramRef.AsLong();
}
if (viewParamValues.Length == 3)
{
ProcessKeywords(viewParamValues[2], ViewParamMessage);
}
}
}
public bool CanReuse(View view, AgentInstanceContext agentInstanceContext)
{
if (!(view is TimeLengthBatchView))
{
return(false);
}
var myView = (TimeLengthBatchView)view;
var timeDeltaComputation = timeDeltaComputationFactory.Make(
ViewName, "view", agentInstanceContext);
if (!timeDeltaComputation.EqualsTimePeriod(myView.TimeDeltaComputation))
{
return(false);
}
var size = ViewFactorySupport.EvaluateSizeParam(ViewName, _sizeEvaluator, agentInstanceContext);
if (myView.NumberOfEvents != size)
{
return(false);
}
if (myView.IsForceOutput != IsForceUpdate)
{
return(false);
}
if (myView.IsStartEager)
{
// since it's already started
return(false);
}
return(myView.IsEmpty());
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList<ExprNode> expressionParameters)
{
ViewFactorySupport.ValidateNoParameters(ViewName, expressionParameters);
}
public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
{
EventType = parentEventType;
var message = NAME + " view requires a list of expressions providing unique keys, a numeric size parameter and a list of expressions providing sort keys";
if (_viewParameters.Count < 3)
{
throw new ViewParameterException(message);
}
// validate
var validated = ViewFactorySupport.Validate(NAME, parentEventType, statementContext, _viewParameters, true);
// find size-parameter index
var indexNumericSize = -1;
for (var i = 0; i < validated.Length; i++)
{
if (validated[i] is ExprConstantNode)
{
indexNumericSize = i;
break;
}
}
if (indexNumericSize == -1)
{
throw new ViewParameterException("Failed to find constant value for the numeric size parameter");
}
if (indexNumericSize == 0)
{
throw new ViewParameterException("Failed to find unique value expressions that are expected to occur before the numeric size parameter");
}
if (indexNumericSize == validated.Length - 1)
{
throw new ViewParameterException("Failed to find sort key expressions after the numeric size parameter");
}
// validate non-constant for unique-keys and sort-keys
for (var i = 0; i < indexNumericSize; i++)
{
ViewFactorySupport.AssertReturnsNonConstant(NAME, validated[i], i);
}
for (var i = indexNumericSize + 1; i < validated.Length; i++)
{
ViewFactorySupport.AssertReturnsNonConstant(NAME, validated[i], i);
}
// get sort size
var exprEvaluatorContext = new ExprEvaluatorContextStatement(statementContext, false);
var sortSize = ViewFactorySupport.EvaluateAssertNoProperties(NAME, validated[indexNumericSize], indexNumericSize, exprEvaluatorContext);
if ((sortSize == null) || (!sortSize.IsNumber()))
{
throw new ViewParameterException(message);
}
SortWindowSize = sortSize.AsInt();
// compile unique expressions
uniqueCriteriaExpressions = new ExprNode[indexNumericSize];
Array.Copy(validated, 0, uniqueCriteriaExpressions, 0, indexNumericSize);
// compile sort expressions
sortCriteriaExpressions = new ExprNode[validated.Length - indexNumericSize - 1];
IsDescendingValues = new bool[sortCriteriaExpressions.Length];
var count = 0;
for (var i = indexNumericSize + 1; i < validated.Length; i++)
{
if (validated[i] is ExprOrderedExpr)
{
IsDescendingValues[count] = ((ExprOrderedExpr)validated[i]).IsDescending;
sortCriteriaExpressions[count] = validated[i].ChildNodes[0];
}
else
{
sortCriteriaExpressions[count] = validated[i];
}
count++;
}
UniqueEvals = ExprNodeUtility.GetEvaluators(uniqueCriteriaExpressions);
SortEvals = ExprNodeUtility.GetEvaluators(sortCriteriaExpressions);
if (statementContext.ConfigSnapshot != null)
{
IsUseCollatorSort = statementContext.ConfigSnapshot.EngineDefaults.LanguageConfig.IsSortUsingCollator;
}
}
public View MakeView(AgentInstanceViewFactoryChainContext agentInstanceViewFactoryContext)
{
int size = ViewFactorySupport.EvaluateSizeParam(
ViewName, _sizeEvaluator, agentInstanceViewFactoryContext.AgentInstanceContext);
return new FirstLengthWindowView(agentInstanceViewFactoryContext, this, size);
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList<ExprNode> expressionParameters)
{
_sizeEvaluator = ViewFactorySupport.ValidateSizeSingleParam(
ViewName, viewFactoryContext, expressionParameters);
}
public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
{
ExprNode[] validated = ViewFactorySupport.Validate(ViewName, parentEventType, statementContext, _viewParameters, true);
_additionalProps = StatViewAdditionalProps.Make(validated, 0, parentEventType);
_eventType = SizeView.CreateEventType(statementContext, _additionalProps, _streamNumber);
}
public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
{
_eventType = parentEventType;
const string message = NAME + " view requires a list of expressions providing unique keys, a numeric size parameter and a list of expressions providing sort keys";
if (_viewParameters.Count < 3)
{
throw new ViewParameterException(message);
}
// validate
ExprNode[] validated = ViewFactorySupport.Validate(NAME, parentEventType, statementContext, _viewParameters, true);
// find size-parameter index
int indexNumericSize = -1;
for (int i = 0; i < validated.Length; i++)
{
if (validated[i] is ExprConstantNode || validated[i] is ExprContextPropertyNode)
{
indexNumericSize = i;
break;
}
}
if (indexNumericSize == -1)
{
throw new ViewParameterException("Failed to find constant value for the numeric size parameter");
}
if (indexNumericSize == 0)
{
throw new ViewParameterException("Failed to find unique value expressions that are expected to occur before the numeric size parameter");
}
if (indexNumericSize == validated.Length - 1)
{
throw new ViewParameterException("Failed to find sort key expressions after the numeric size parameter");
}
// validate non-constant for unique-keys and sort-keys
for (int i = 0; i < indexNumericSize; i++)
{
ViewFactorySupport.AssertReturnsNonConstant(NAME, validated[i], i);
}
for (int i = indexNumericSize + 1; i < validated.Length; i++)
{
ViewFactorySupport.AssertReturnsNonConstant(NAME, validated[i], i);
}
// get sort size
ViewFactorySupport.ValidateNoProperties(ViewName, validated[indexNumericSize], indexNumericSize);
_sizeEvaluator = ViewFactorySupport.ValidateSizeParam(ViewName, statementContext, validated[indexNumericSize], indexNumericSize);
// compile unique expressions
_uniqueCriteriaExpressions = new ExprNode[indexNumericSize];
Array.Copy(validated, 0, _uniqueCriteriaExpressions, 0, indexNumericSize);
// compile sort expressions
_sortCriteriaExpressions = new ExprNode[validated.Length - indexNumericSize - 1];
_isDescendingValues = new bool[_sortCriteriaExpressions.Length];
int count = 0;
for (int i = indexNumericSize + 1; i < validated.Length; i++)
{
if (validated[i] is ExprOrderedExpr)
{
_isDescendingValues[count] = ((ExprOrderedExpr)validated[i]).IsDescending;
_sortCriteriaExpressions[count] = validated[i].ChildNodes[0];
}
else
{
_sortCriteriaExpressions[count] = validated[i];
}
count++;
}
_uniqueEvals = ExprNodeUtility.GetEvaluators(_uniqueCriteriaExpressions);
_sortEvals = ExprNodeUtility.GetEvaluators(_sortCriteriaExpressions);
if (statementContext.ConfigSnapshot != null)
{
_useCollatorSort = statementContext.ConfigSnapshot.EngineDefaults.Language.IsSortUsingCollator;
}
}
public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
{
_eventType = parentEventType;
// define built-in fields
var builtinTypeDef = ExpressionViewOAFieldEnumExtensions.AsMapOfTypes(_eventType);
_builtinMapType = statementContext.EventAdapterService.CreateAnonymousObjectArrayType(
statementContext.StatementId + "_exprview", builtinTypeDef);
StreamTypeService streamTypeService = new StreamTypeServiceImpl(new EventType[] { _eventType, _builtinMapType }, new String[2], new bool[2], statementContext.EngineURI, false);
// validate expression
ExpiryExpression = ViewFactorySupport.ValidateExpr(ViewName, statementContext, ExpiryExpression, streamTypeService, 0);
var summaryVisitor = new ExprNodeSummaryVisitor();
ExpiryExpression.Accept(summaryVisitor);
if (summaryVisitor.HasSubselect || summaryVisitor.HasStreamSelect || summaryVisitor.HasPreviousPrior)
{
throw new ViewParameterException("Invalid expiry expression: Sub-select, previous or prior functions are not supported in this context");
}
var returnType = ExpiryExpression.ExprEvaluator.ReturnType;
if (returnType.GetBoxedType() != typeof(bool?))
{
throw new ViewParameterException("Invalid return value for expiry expression, expected a bool return value but received " + returnType.GetParameterAsString());
}
// determine variables used, if any
var visitor = new ExprNodeVariableVisitor();
ExpiryExpression.Accept(visitor);
VariableNames = visitor.VariableNames;
// determine aggregation nodes, if any
var aggregateNodes = new List <ExprAggregateNode>();
ExprAggregateNodeUtil.GetAggregatesBottomUp(ExpiryExpression, aggregateNodes);
if (aggregateNodes.IsNotEmpty())
{
try {
AggregationServiceFactoryDesc = AggregationServiceFactoryFactory.GetService(
Collections.GetEmptyList <ExprAggregateNode>(),
Collections.GetEmptyMap <ExprNode, String>(),
Collections.GetEmptyList <ExprDeclaredNode>(),
null, aggregateNodes,
Collections.GetEmptyList <ExprAggregateNode>(),
Collections.GetEmptyList <ExprAggregateNodeGroupKey>(), false,
statementContext.Annotations,
statementContext.VariableService, false, false, null, null,
AggregationServiceFactoryServiceImpl.DEFAULT_FACTORY,
streamTypeService.EventTypes,
statementContext.MethodResolutionService, null,
statementContext.ContextName,
null, null);
}
catch (ExprValidationException ex) {
throw new ViewParameterException(ex.Message, ex);
}
}
}
