public void ValidateIntoTableCompatible(AggregationMethodFactory intoTableAgg)
{
AggregationMethodFactoryUtil.ValidateAggregationType(this, intoTableAgg);
var other = (ExprAggMultiFunctionLinearAccessNodeFactoryAccess)intoTableAgg;
AggregationMethodFactoryUtil.ValidateEventType(_containedEventType, other.ContainedEventType);
}
public void ValidateIntoTableCompatible(AggregationMethodFactory intoTableAgg)
{
AggregationMethodFactoryUtil.ValidateAggregationType(this, intoTableAgg);
ExprFirstEverNodeFactory that = (ExprFirstEverNodeFactory)intoTableAgg;
AggregationMethodFactoryUtil.ValidateAggregationInputType(_childType, that._childType);
AggregationMethodFactoryUtil.ValidateAggregationFilter(_parent.HasFilter, that._parent.HasFilter);
}
public AggregationMethod Make()
{
if (_parent.StateType == AggregationStateType.FIRST)
return AggregationMethodFactoryUtil.MakeFirstEver(_hasFilter);
if (_parent.StateType == AggregationStateType.LAST)
return AggregationMethodFactoryUtil.MakeLastEver(_hasFilter);
throw new EPRuntimeException("Window aggregation function is not available");
}
public void ValidateIntoTableCompatible(AggregationMethodFactory intoTableAgg)
{
AggregationMethodFactoryUtil.ValidateAggregationType(this, intoTableAgg);
var other = (ExprAggMultiFunctionSortedMinMaxByNodeFactory)intoTableAgg;
AggregationMethodFactoryUtil.ValidateEventType(_containedEventType, other.ContainedEventType);
AggregationMethodFactoryUtil.ValidateAggFuncName(_parent.AggregationFunctionName, other.Parent.AggregationFunctionName);
}
public void ValidateIntoTableCompatible(AggregationMethodFactory intoTableAgg)
{
AggregationMethodFactoryUtil.ValidateAggregationType(this, intoTableAgg);
var that = (ExprPlugInAggMultiFunctionNodeFactory)intoTableAgg;
if (!GetAggregationStateKey(false).Equals(that.GetAggregationStateKey(false)))
{
throw new ExprValidationException("Mismatched state key");
}
}
public void ValidateIntoTableCompatible(AggregationMethodFactory intoTableAgg)
{
AggregationMethodFactoryUtil.ValidateAggregationType(this, intoTableAgg);
ExprRateAggNodeFactory that = (ExprRateAggNodeFactory)intoTableAgg;
if (_intervalMSec != that._intervalMSec)
{
throw new ExprValidationException("The size is " +
_intervalMSec +
" and provided is " +
that._intervalMSec);
}
AggregationMethodFactoryUtil.ValidateAggregationUnbound(!_isEver, !that._isEver);
}
public void ValidateIntoTableCompatible(AggregationMethodFactory intoTableAgg)
{
AggregationMethodFactoryUtil.ValidateAggregationType(this, intoTableAgg);
ExprNthAggNodeFactory that = (ExprNthAggNodeFactory)intoTableAgg;
AggregationMethodFactoryUtil.ValidateAggregationInputType(_childType, that._childType);
if (_size != that._size)
{
throw new ExprValidationException("The size is " +
_size +
" and provided is " +
that._size);
}
}
public void ValidateIntoTableCompatible(AggregationMethodFactory intoTableAgg)
{
AggregationMethodFactoryUtil.ValidateAggregationType(this, intoTableAgg);
ExprCountEverNodeFactory that = (ExprCountEverNodeFactory)intoTableAgg;
if (that._ignoreNulls != _ignoreNulls)
{
throw new ExprValidationException("The aggregation declares " +
(_ignoreNulls ? "ignore-nulls" : "no-ignore-nulls") +
" and provided is " +
(that._ignoreNulls ? "ignore-nulls" : "no-ignore-nulls"));
}
AggregationMethodFactoryUtil.ValidateAggregationFilter(_parent.HasFilter, that._parent.HasFilter);
}
public void ValidateIntoTableCompatible(AggregationMethodFactory intoTableAgg)
{
AggregationMethodFactoryUtil.ValidateAggregationType(this, intoTableAgg);
var that = (ExprAggMultiFunctionLinearAccessNodeFactoryMethod)intoTableAgg;
AggregationMethodFactoryUtil.ValidateStreamNumZero(that._streamNum);
if (_collectionEventType != null)
{
AggregationMethodFactoryUtil.ValidateEventType(_collectionEventType, that._collectionEventType);
}
else
{
AggregationMethodFactoryUtil.ValidateAggregationInputType(_resultType, that._resultType);
}
}
public void ValidateIntoTableCompatible(AggregationMethodFactory intoTableAgg)
{
AggregationMethodFactoryUtil.ValidateAggregationType(this, intoTableAgg);
var that = (ExprMinMaxAggrNodeFactory)intoTableAgg;
AggregationMethodFactoryUtil.ValidateAggregationInputType(_type, that._type);
AggregationMethodFactoryUtil.ValidateAggregationFilter(_parent.HasFilter, that._parent.HasFilter);
if (_parent.MinMaxTypeEnum != that._parent.MinMaxTypeEnum)
{
throw new ExprValidationException(
string.Format(
"The aggregation declares {0} and provided is {1}",
this._parent.MinMaxTypeEnum.GetExpressionText(),
that._parent.MinMaxTypeEnum.GetExpressionText()));
}
AggregationMethodFactoryUtil.ValidateAggregationUnbound(_hasDataWindows, that._hasDataWindows);
}
public void ValidateIntoTableCompatible(AggregationMethodFactory intoTableAgg)
{
AggregationMethodFactoryUtil.ValidateAggregationType(this, intoTableAgg);
ExprCountNodeFactory that = (ExprCountNodeFactory)intoTableAgg;
AggregationMethodFactoryUtil.ValidateAggregationFilter(_parent.HasFilter, that._parent.HasFilter);
if (_parent.IsDistinct)
{
AggregationMethodFactoryUtil.ValidateAggregationInputType(_countedValueType, that._countedValueType);
}
if (_ignoreNulls != that._ignoreNulls)
{
throw new ExprValidationException("The aggregation declares" +
(_ignoreNulls ? "" : " no") +
" ignore nulls and provided is" +
(that._ignoreNulls ? "" : " no") +
" ignore nulls");
}
}
public void ValidateIntoTableCompatible(AggregationMethodFactory intoTableAgg)
{
AggregationMethodFactoryUtil.ValidateAggregationType(this, intoTableAgg);
}
