private static ExprNode HandleVariable(
IList <Chainable> chain,
VariableMetaData variable,
StatementSpecMapContext mapContext,
Func <IList <Chainable>, ExprDotNodeImpl> dotNodeFunction)
{
var message = VariableUtil.CheckVariableContextName(mapContext.ContextName, variable);
if (message != null)
{
throw new ValidationException(message);
}
ExprNode rootNode = new ExprVariableNodeImpl(variable, null);
if (chain.Count == 1)
{
return(rootNode);
}
// Handle simple-subproperty by means of variable node
if (chain.Count == 2 && chain[1] is ChainableName)
{
return(new ExprVariableNodeImpl(variable, chain[1].GetRootNameOrEmptyString()));
}
var subchain = chain.SubList(1, chain.Count);
ExprDotNode dot = dotNodeFunction.Invoke(subchain);
dot.AddChildNode(rootNode);
return(dot);
}
private static AggSvcGroupByReclaimAgedEvalFuncFactoryForge GetEvaluationFunction(
VariableCompileTimeResolver variableCompileTimeResolver,
string hintValue,
string optionalContextName)
{
var variableMetaData = variableCompileTimeResolver.Resolve(hintValue);
if (variableMetaData != null) {
if (!variableMetaData.Type.IsNumeric()) {
throw new ExprValidationException(
"Variable type of variable '" + variableMetaData.VariableName + "' is not numeric");
}
var message = VariableUtil.CheckVariableContextName(optionalContextName, variableMetaData);
if (message != null) {
throw new ExprValidationException(message);
}
return new AggSvcGroupByReclaimAgedEvalFuncFactoryVariableForge(variableMetaData);
}
double valueDouble;
try {
valueDouble = Double.Parse(hintValue);
}
catch (EPException) {
throw;
}
catch (Exception) {
throw new ExprValidationException(
"Failed to parse hint parameter value '" +
hintValue +
"' as a double-typed seconds value or variable name");
}
if (valueDouble <= 0) {
throw new ExprValidationException(
"Hint parameter value '" +
hintValue +
"' is an invalid value, expecting a double-typed seconds value or variable name");
}
return new AggSvcGroupByReclaimAgedEvalFuncFactoryConstForge(valueDouble);
}
public static ExprNode ResolvePropertyOrVariableIdentifier(
string identifier,
VariableCompileTimeResolver variableCompileTimeResolver,
StatementSpecRaw spec)
{
VariableMetaData metaData = variableCompileTimeResolver.Resolve(identifier);
if (metaData != null)
{
ExprVariableNodeImpl exprNode = new ExprVariableNodeImpl(metaData, null);
spec.ReferencedVariables.Add(metaData.VariableName);
string message = VariableUtil.CheckVariableContextName(spec.OptionalContextName, metaData);
if (message != null)
{
throw ASTWalkException.From(message);
}
return exprNode;
}
return new ExprIdentNodeImpl(identifier);
}
public static OutputConditionFactoryForge CreateCondition(
OutputLimitSpec outputLimitSpec,
bool isGrouped,
bool isWithHavingClause,
bool isStartConditionOnCreation,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
if (outputLimitSpec == null) {
return OutputConditionNullFactoryForge.INSTANCE;
}
// Check if a variable is present
VariableMetaData variableMetaData = null;
if (outputLimitSpec.VariableName != null) {
variableMetaData = services.VariableCompileTimeResolver.Resolve(outputLimitSpec.VariableName);
if (variableMetaData == null) {
throw new ExprValidationException(
"Variable named '" + outputLimitSpec.VariableName + "' has not been declared");
}
var message = VariableUtil.CheckVariableContextName(statementRawInfo.ContextName, variableMetaData);
if (message != null) {
throw new ExprValidationException(message);
}
}
if (outputLimitSpec.DisplayLimit == OutputLimitLimitType.FIRST && isGrouped) {
return OutputConditionNullFactoryForge.INSTANCE;
}
if (outputLimitSpec.RateType == OutputLimitRateType.CRONTAB) {
return new OutputConditionCrontabForge(
outputLimitSpec.CrontabAtSchedule,
isStartConditionOnCreation,
statementRawInfo,
services);
}
if (outputLimitSpec.RateType == OutputLimitRateType.WHEN_EXPRESSION) {
return new OutputConditionExpressionForge(
outputLimitSpec.WhenExpressionNode,
outputLimitSpec.ThenExpressions,
outputLimitSpec.AndAfterTerminateExpr,
outputLimitSpec.AndAfterTerminateThenExpressions,
isStartConditionOnCreation,
statementRawInfo,
services);
}
if (outputLimitSpec.RateType == OutputLimitRateType.EVENTS) {
if (variableMetaData != null && !variableMetaData.Type.IsNumericNonFP()) {
throw new ArgumentException(
"Variable named '" + outputLimitSpec.VariableName + "' must be type integer, long or short");
}
var rate = -1;
if (outputLimitSpec.Rate != null) {
rate = outputLimitSpec.Rate.AsInt32();
}
return new OutputConditionCountForge(rate, variableMetaData);
}
if (outputLimitSpec.RateType == OutputLimitRateType.TERM) {
if (outputLimitSpec.AndAfterTerminateExpr == null &&
(outputLimitSpec.AndAfterTerminateThenExpressions == null ||
outputLimitSpec.AndAfterTerminateThenExpressions.IsEmpty())) {
return new OutputConditionTermFactoryForge();
}
return new OutputConditionExpressionForge(
new ExprConstantNodeImpl(false),
Collections.GetEmptyList<OnTriggerSetAssignment>(),
outputLimitSpec.AndAfterTerminateExpr,
outputLimitSpec.AndAfterTerminateThenExpressions,
isStartConditionOnCreation,
statementRawInfo,
services);
}
if (Log.IsDebugEnabled) {
Log.Debug(".createCondition creating OutputConditionTime with interval length " + outputLimitSpec.Rate);
}
if (variableMetaData != null && !variableMetaData.Type.IsNumeric()) {
throw new ArgumentException(
"Variable named '" + outputLimitSpec.VariableName + "' must be of numeric type");
}
return new OutputConditionTimeForge(outputLimitSpec.TimePeriodExpr, isStartConditionOnCreation);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="rowLimitSpec">specification for row limit, or null if no row limit is defined</param>
/// <param name="variableCompileTimeResolver">for retrieving variable state for use with row limiting</param>
/// <param name="optionalContextName">context name</param>
/// <throws>ExprValidationException exception</throws>
public RowLimitProcessorFactoryForge(
RowLimitSpec rowLimitSpec,
VariableCompileTimeResolver variableCompileTimeResolver,
string optionalContextName)
{
if (rowLimitSpec.NumRowsVariable != null) {
numRowsVariableMetaData = variableCompileTimeResolver.Resolve(rowLimitSpec.NumRowsVariable);
if (numRowsVariableMetaData == null) {
throw new ExprValidationException(
"Limit clause variable by name '" + rowLimitSpec.NumRowsVariable + "' has not been declared");
}
string message = VariableUtil.CheckVariableContextName(optionalContextName, numRowsVariableMetaData);
if (message != null) {
throw new ExprValidationException(message);
}
if (!TypeHelper.IsNumeric(numRowsVariableMetaData.Type)) {
throw new ExprValidationException("Limit clause requires a variable of numeric type");
}
}
else {
numRowsVariableMetaData = null;
currentRowLimit = rowLimitSpec.NumRows.GetValueOrDefault(Int32.MaxValue);
if (currentRowLimit < 0) {
currentRowLimit = Int32.MaxValue;
}
}
if (rowLimitSpec.OptionalOffsetVariable != null) {
offsetVariableMetaData = variableCompileTimeResolver.Resolve(rowLimitSpec.OptionalOffsetVariable);
if (offsetVariableMetaData == null) {
throw new ExprValidationException(
"Limit clause variable by name '" +
rowLimitSpec.OptionalOffsetVariable +
"' has not been declared");
}
string message = VariableUtil.CheckVariableContextName(optionalContextName, offsetVariableMetaData);
if (message != null) {
throw new ExprValidationException(message);
}
if (!TypeHelper.IsNumeric(offsetVariableMetaData.Type)) {
throw new ExprValidationException("Limit clause requires a variable of numeric type");
}
}
else {
offsetVariableMetaData = null;
if (rowLimitSpec.OptionalOffset != null) {
if (rowLimitSpec.OptionalOffset.Value <= 0) {
throw new ExprValidationException("Limit clause requires a positive offset");
}
currentOffset = rowLimitSpec.OptionalOffset.Value;
}
else {
currentOffset = 0;
}
}
}
