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 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 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 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)
{
_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 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 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 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 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)
{
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;
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;
}
}