public void Init(
ViewFactoryContext viewFactoryContext,
EPStatementInitServices services)
{
try {
eventBeanFactory = EventTypeUtility.GetFactoryForType(
EventType,
services.EventBeanTypedEventFactory,
services.EventTypeAvroHandler);
var factoryContext = new VirtualDataWindowFactoryContext(
EventType,
Parameters,
ParameterExpressions,
NamedWindowName,
CompileTimeConfiguration,
viewFactoryContext,
services);
Factory.Initialize(factoryContext);
}
catch (Exception ex) {
throw new EPException(
"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 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 SetUp()
{
_container = SupportContainer.Reset();
_factory = new GroupByViewFactory();
_viewFactoryContext = new ViewFactoryContext(
SupportStatementContextFactory.MakeContext(_container), 1, null, null, false, -1, false);
}
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 static PriorEventViewFactory GetPriorEventViewFactory(
StatementContext statementContext,
int streamNum,
bool unboundStream,
bool isSubquery,
int subqueryNumber)
{
try
{
var @namespace = ViewEnum.PRIOR_EVENT_VIEW.GetNamespace();
var name = ViewEnum.PRIOR_EVENT_VIEW.GetName();
var factory = statementContext.ViewResolutionService.Create(@namespace, name);
var context = new ViewFactoryContext(statementContext, streamNum, @namespace, name, isSubquery, subqueryNumber, false);
factory.SetViewParameters(context, ((ExprNode) new ExprConstantNodeImpl(unboundStream)).AsSingleton());
return((PriorEventViewFactory)factory);
}
catch (ViewProcessingException ex)
{
const string text = "Exception creating prior event view factory";
throw new EPException(text, ex);
}
catch (ViewParameterException ex)
{
var text = "Exception creating prior event view factory";
throw new EPException(text, ex);
}
}
public void Init(
ViewFactoryContext viewFactoryContext,
EPStatementInitServices services)
{
foreach (ViewFactory factory in unioned) {
factory.Init(viewFactoryContext, services);
}
}
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 Init(
ViewFactoryContext viewFactoryContext,
EPStatementInitServices services)
{
if (eventType == null) {
throw new IllegalStateException("Event type not provided");
}
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
if (expressionParameters.Count != 1)
{
throw new ViewParameterException(ViewParamMessage);
}
_timeDeltaComputation = ViewFactoryTimePeriodHelper.ValidateAndEvaluateTimeDelta(ViewName, viewFactoryContext.StatementContext, expressionParameters[0], ViewParamMessage, 0);
}
public override void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
if (expressionParameters.Count != 1)
{
string errorMessage = ViewName + " view requires a single expression as a parameter";
throw new ViewParameterException(errorMessage);
}
ExpiryExpression = expressionParameters[0];
}
public void Init(
ViewFactoryContext viewFactoryContext,
EPStatementInitServices services)
{
Comparer = ExprNodeUtilityMake.GetComparatorHashableMultiKeys(
SortCriteriaTypes,
IsUseCollatorSort,
IsDescendingValues); // hashable-key comparator since we may remove sort keys
}
/// <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="eventFactory">factory for converting row objects to EventBean instances</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="viewFactoryContext">context of services</param>
/// <param name="customConfiguration">additional configuration</param>
public VirtualDataWindowFactoryContext(EventType eventType, Object[] parameters, ExprNode[] parameterExpressions, EventBeanFactory eventFactory, String namedWindowName, ViewFactoryContext viewFactoryContext, object customConfiguration)
{
_eventType = eventType;
_parameters = parameters;
_parameterExpressions = parameterExpressions;
_eventFactory = eventFactory;
_namedWindowName = namedWindowName;
_viewFactoryContext = viewFactoryContext;
_customConfiguration = customConfiguration;
}
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 void Init(
ViewFactoryContext viewFactoryContext,
EPStatementInitServices services)
{
if (Groupeds == null) {
throw new IllegalStateException("Grouped views not provided");
}
foreach (var grouped in Groupeds) {
grouped.Init(viewFactoryContext, services);
}
}
public void SetUp()
{
_container = SupportContainer.Reset();
_factory = new MergeViewFactory();
_viewFactoryContext = new ViewFactoryContext(SupportStatementContextFactory.MakeContext(_container), 1, null, null, false, -1, false);
_parents = new List <ViewFactory>();
GroupByViewFactory groupByView = new GroupByViewFactory();
groupByView.SetViewParameters(_viewFactoryContext, TestViewSupport.ToExprListMD(new Object[] { "Symbol", "Feed" }));
groupByView.Attach(SupportEventTypeFactory.CreateBeanType(typeof(SupportMarketDataBean)), SupportStatementContextFactory.MakeContext(_container), null, null);
_parents.Add(groupByView);
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
ViewParameters = expressionParameters;
var reclaimGroupAged = HintEnum.RECLAIM_GROUP_AGED.GetHint(viewFactoryContext.StatementContext.Annotations);
if (reclaimGroupAged != null)
{
_isReclaimAged = true;
String hintValueMaxAge = HintEnum.RECLAIM_GROUP_AGED.GetHintAssignedValue(reclaimGroupAged);
if (hintValueMaxAge == null)
{
throw new ViewParameterException("Required hint value for hint '" + HintEnum.RECLAIM_GROUP_AGED + "' has not been provided");
}
try
{
_reclaimMaxAge = Double.Parse(hintValueMaxAge);
}
catch (Exception)
{
throw new ViewParameterException("Required hint value for hint '" + HintEnum.RECLAIM_GROUP_AGED + "' value '" + hintValueMaxAge + "' could not be parsed as a double value");
}
String hintValueFrequency = HintEnum.RECLAIM_GROUP_FREQ.GetHintAssignedValue(reclaimGroupAged);
if (hintValueFrequency == null)
{
_reclaimFrequency = _reclaimMaxAge;
}
else
{
try
{
_reclaimFrequency = Double.Parse(hintValueFrequency);
}
catch (Exception)
{
throw new ViewParameterException("Required hint value for hint '" + HintEnum.RECLAIM_GROUP_FREQ + "' value '" + hintValueFrequency + "' could not be parsed as a double value");
}
}
if (_reclaimMaxAge < 0.100)
{
Log.Warn("Reclaim max age parameter is less then 100 milliseconds, are your sure?");
}
if (Log.IsDebugEnabled)
{
Log.Debug("Using reclaim-aged strategy for group-window age " + _reclaimMaxAge + " frequency " + _reclaimFrequency);
}
}
}
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();
}
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="eventType">event type</param>
/// <param name="parameters">parameter values</param>
/// <param name="parameterExpressions">parameter expressions</param>
/// <param name="namedWindowName">named window name</param>
/// <param name="customConfiguration">custom configuration object that is passed along</param>
/// <param name="viewFactoryContext">view context</param>
/// <param name="services">services</param>
public VirtualDataWindowFactoryContext(
EventType eventType,
object[] parameters,
ExprEvaluator[] parameterExpressions,
string namedWindowName,
object customConfiguration,
ViewFactoryContext viewFactoryContext,
EPStatementInitServices services)
{
EventType = eventType;
Parameters = parameters;
ParameterExpressions = parameterExpressions;
NamedWindowName = namedWindowName;
CustomConfiguration = customConfiguration;
ViewFactoryContext = viewFactoryContext;
Services = services;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="agentInstanceContext">statement services and statement information such as statement name, statement id, EPL expression</param>
/// <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="parameterExpressions">parameter expressions passed to the virtual data window</param>
/// <param name="eventFactory">factory for converting row objects to EventBean instances</param>
/// <param name="outputStream">forward the input and output stream received from the Update method here</param>
/// <param name="namedWindowName">the name of the named window</param>
/// <param name="viewFactoryContext">context of services</param>
/// <param name="customConfiguration">additional configuration</param>
public VirtualDataWindowContext(AgentInstanceContext agentInstanceContext,
EventType eventType,
Object[] parameters,
ExprNode[] parameterExpressions,
EventBeanFactory eventFactory,
VirtualDataWindowOutStream outputStream,
String namedWindowName,
ViewFactoryContext viewFactoryContext,
Object customConfiguration)
{
AgentInstanceContext = agentInstanceContext;
EventType = eventType;
Parameters = parameters;
ParameterExpressions = parameterExpressions;
EventFactory = eventFactory;
OutputStream = outputStream;
NamedWindowName = namedWindowName;
ViewFactoryContext = viewFactoryContext;
CustomConfiguration = customConfiguration;
}
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 void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
_viewParameters = expressionParameters;
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList<ExprNode> expressionParameters)
{
ViewFactorySupport.ValidateNoParameters(ViewName, expressionParameters);
}
public void Init(
ViewFactoryContext viewFactoryContext,
EPStatementInitServices services)
{
}
public override void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> viewParameters)
{
this._viewParameters = viewParameters;
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList<ExprNode> expressionParameters)
{
_sizeEvaluator = ViewFactorySupport.ValidateSizeSingleParam(
ViewName, viewFactoryContext, expressionParameters);
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> viewParameters)
{
}
public void SetViewParameters(ViewFactoryContext viewFactoryContext, IList <ExprNode> expressionParameters)
{
_viewParameters = expressionParameters;
_streamNumber = viewFactoryContext.StreamNum;
}
