public override void Attach(
EventType parentEventType,
int streamNumber,
ViewForgeEnv viewForgeEnv)
{
var windowName = ViewName;
var validated = ViewForgeSupport.Validate(
windowName,
parentEventType,
viewParameters,
true,
viewForgeEnv,
streamNumber);
if (viewParameters.Count < 2 || viewParameters.Count > 3) {
throw new ViewParameterException(ViewParamMessage);
}
// validate first parameter: timestamp expression
if (!validated[0].Forge.EvaluationType.IsNumeric()) {
throw new ViewParameterException(ViewParamMessage);
}
timestampExpression = validated[0];
ViewForgeSupport.AssertReturnsNonConstant(windowName, validated[0], 0);
timePeriodComputeForge = ViewFactoryTimePeriodHelper.ValidateAndEvaluateTimeDeltaFactory(
ViewName,
viewParameters[1],
ViewParamMessage,
1,
viewForgeEnv,
streamNumber);
// validate optional parameters
if (validated.Length == 3) {
var constant = ViewForgeSupport.ValidateAndEvaluate(
windowName,
validated[2],
viewForgeEnv,
streamNumber);
if (!constant.IsNumber() || constant.IsFloatingPointNumber()) {
throw new ViewParameterException(
"Externally-timed batch view requires a Long-typed reference point in msec as a third parameter");
}
optionalReferencePoint = constant.AsInt64();
}
eventType = parentEventType;
}
public static object ValidateAndEvaluate(
string viewName,
ExprNode expression,
ViewForgeEnv viewForgeEnv,
int streamNumber)
{
return ValidateAndEvaluateExpr(
viewName,
expression,
new StreamTypeServiceImpl(false),
viewForgeEnv,
0,
streamNumber);
}
public override void Attach(
EventType parentEventType,
int streamNumber,
ViewForgeEnv viewForgeEnv)
{
var validated = ViewForgeSupport.Validate(
ViewName,
parentEventType,
viewParameters,
true,
viewForgeEnv,
streamNumber);
additionalProps = StatViewAdditionalPropsForge.Make(validated, 0, parentEventType, streamNumber, viewForgeEnv);
eventType = SizeView.CreateEventType(viewForgeEnv, additionalProps, streamNumber);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="eventType">the event type that the named window is declared to hold.</param>
/// <param name="parameters">the parameters passed when declaring the named window, for example "create window ABC.my:vdw("10.0.0.1")" passes one paramater here.</param>
/// <param name="namedWindowName">the name of the named window</param>
/// <param name="parameterExpressions">parameter expressions passed to the virtual data window</param>
/// <param name="customConfiguration">additional configuration</param>
/// <param name="viewForgeEnv">view forge environment</param>
public VirtualDataWindowForgeContext(
EventType eventType,
object[] parameters,
ExprNode[] parameterExpressions,
string namedWindowName,
ViewForgeEnv viewForgeEnv,
object customConfiguration)
{
this.eventType = eventType;
this.parameters = parameters;
this.parameterExpressions = parameterExpressions;
this.namedWindowName = namedWindowName;
this.viewForgeEnv = viewForgeEnv;
this.customConfiguration = customConfiguration;
}
public void Attach(
EventType parentEventType,
int streamNumber,
ViewForgeEnv viewForgeEnv)
{
EventType = parentEventType;
_validatedParameterExpressions = ViewForgeSupport.Validate(
ViewName,
parentEventType,
_parameters,
true,
viewForgeEnv,
streamNumber);
_parameterValues = new object[_validatedParameterExpressions.Length];
for (var i = 0; i < _validatedParameterExpressions.Length; i++) {
try {
_parameterValues[i] = ViewForgeSupport.EvaluateAssertNoProperties(
ViewName,
_validatedParameterExpressions[i],
i);
}
catch (Exception) {
// expected
}
}
// initialize
try {
_forge.Initialize(
new VirtualDataWindowForgeContext(
parentEventType,
_parameterValues,
_validatedParameterExpressions,
_namedWindowName,
viewForgeEnv,
_customConfigs));
}
//catch (EPException) {
// throw;
//}
catch (Exception ex) {
throw new ViewParameterException(
"Validation exception initializing virtual data window '" + _namedWindowName + "': " + ex.Message,
ex);
}
}
public override void SetViewParameters(
IList<ExprNode> parameters,
ViewForgeEnv viewForgeEnv,
int streamNumber)
{
if (parameters.Count != 1) {
throw new ViewParameterException(ViewParamMessage);
}
timePeriodCompute = ViewFactoryTimePeriodHelper.ValidateAndEvaluateTimeDeltaFactory(
ViewName,
parameters[0],
ViewParamMessage,
0,
viewForgeEnv,
streamNumber);
}
public override void SetViewParameters(
IList<ExprNode> parameters,
ViewForgeEnv viewForgeEnv,
int streamNumber)
{
if (parameters.Count != 1 && parameters.Count != 2) {
var errorMessage =
ViewName + " view requires a single expression as a parameter, or an expression and boolean flag";
throw new ViewParameterException(errorMessage);
}
ExpiryExpression = parameters[0];
if (parameters.Count > 1) {
var result = ViewForgeSupport.EvaluateAssertNoProperties(ViewName, parameters[1], 1);
includeTriggeringEvent = (bool) result;
}
}
public override void Attach(
EventType parentEventType,
int streamNumber,
ViewForgeEnv viewForgeEnv)
{
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 = ViewForgeSupport.Validate(
NAME + " window",
parentEventType,
viewParameters,
true,
viewForgeEnv,
streamNumber);
for (var i = 1; i < validated.Length; i++) {
ViewForgeSupport.AssertReturnsNonConstant(NAME + " window", validated[i], i);
}
ViewForgeSupport.ValidateNoProperties(ViewName, validated[0], 0);
sizeForge = ViewForgeSupport.ValidateSizeParam(ViewName, 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];
}
}
sortSerdes = viewForgeEnv.SerdeResolver.SerdeForDataWindowSortCriteria(
ExprNodeUtilityQuery.GetExprResultTypes(sortCriteriaExpressions),
viewForgeEnv.StatementRawInfo);
}
public override void Attach(
EventType parentEventType,
int streamNumber,
ViewForgeEnv viewForgeEnv)
{
_criteriaExpressions = ViewForgeSupport.Validate(
ViewName,
parentEventType,
_viewParameters,
false,
viewForgeEnv,
streamNumber);
if (_criteriaExpressions.Length == 0) {
var errorMessage =
ViewName + " view requires a one or more expressions providing unique values as parameters";
throw new ViewParameterException(errorMessage);
}
this.eventType = parentEventType;
}
public static ExprNode[] Validate(
string viewName,
IList<ExprNode> expressions,
ViewForgeEnv viewForgeEnv,
int streamNumber)
{
var results = new ExprNode[expressions.Count];
var expressionNumber = 0;
StreamTypeService streamTypeService = new StreamTypeServiceImpl(false);
foreach (var expr in expressions) {
results[expressionNumber] = ValidateExpr(
viewName,
expr,
streamTypeService,
viewForgeEnv,
expressionNumber,
streamNumber);
expressionNumber++;
}
return results;
}
public override void Attach(
EventType parentEventType,
int streamNumber,
ViewForgeEnv viewForgeEnv)
{
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 = ViewForgeSupport.Validate(
NAME,
parentEventType,
viewParameters,
true,
viewForgeEnv,
streamNumber);
// find size-parameter index
var indexNumericSize = -1;
for (var 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 (var i = 0; i < indexNumericSize; i++) {
ViewForgeSupport.AssertReturnsNonConstant(NAME, validated[i], i);
}
for (var i = indexNumericSize + 1; i < validated.Length; i++) {
ViewForgeSupport.AssertReturnsNonConstant(NAME, validated[i], i);
}
// get sort size
ViewForgeSupport.ValidateNoProperties(ViewName, validated[indexNumericSize], indexNumericSize);
sizeForge = ViewForgeSupport.ValidateSizeParam(ViewName, validated[indexNumericSize], indexNumericSize);
// compile unique expressions
criteriaExpressions = new ExprNode[indexNumericSize];
Array.Copy(validated, 0, criteriaExpressions, 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++;
}
sortSerdes = viewForgeEnv.SerdeResolver.SerdeForDataWindowSortCriteria(
ExprNodeUtilityQuery.GetExprResultTypes(sortCriteriaExpressions),
viewForgeEnv.StatementRawInfo);
}
public override void SetViewParameters(
IList<ExprNode> parameters,
ViewForgeEnv viewForgeEnv,
int streamNumber)
{
}
public override void Attach(
EventType parentEventType,
int streamNumber,
ViewForgeEnv viewForgeEnv)
{
}
public virtual IList<StmtClassForgeableFactory> InitAdditionalForgeables(ViewForgeEnv viewForgeEnv)
{
return EmptyList<StmtClassForgeableFactory>.Instance;
}
public IList<StmtClassForgeableFactory> InitAdditionalForgeables(ViewForgeEnv viewForgeEnv) =>
EmptyList<StmtClassForgeableFactory>.Instance;
public override IList<StmtClassForgeableFactory> InitAdditionalForgeables(ViewForgeEnv viewForgeEnv)
{
MultiKeyPlan desc = MultiKeyPlanner.PlanMultiKey(criteriaExpressions, false, viewForgeEnv.StatementRawInfo, viewForgeEnv.SerdeResolver);
multiKeyClassNames = desc.ClassRef;
return desc.MultiKeyForgeables;
}
