protected override CodegenExpression Make(
CodegenMethodScope parent,
ModuleTableInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(TableMetadataColumnAggregation), GetType(), classScope);
method.Block.DeclareVar<TableMetadataColumnAggregation>(
"col",
NewInstance(typeof(TableMetadataColumnAggregation)));
base.MakeSettersInline(Ref("col"), method.Block);
method.Block
.SetProperty(Ref("col"), "Column", Constant(Column))
.SetProperty(
Ref("col"),
"AggregationPortableValidation",
AggregationPortableValidation.Make(method, symbols, classScope))
.SetProperty(Ref("col"), "AggregationExpression", Constant(AggregationExpression))
.SetProperty(Ref("col"), "IsMethodAgg", Constant(IsMethodAgg))
.SetProperty(
Ref("col"),
"OptionalEnumerationType",
OptionalEnumerationType == null
? ConstantNull()
: OptionalEnumerationType.Codegen(method, classScope, symbols.GetAddInitSvc(method)))
.MethodReturn(Ref("col"));
return LocalMethod(method);
}
protected override void ValidateIntoTableWFilterWInputType(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
}
public void ValidateIntoTableCompatible(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
AggregationValidationUtil.ValidateAggregationType(this, tableExpression, intoTableAgg, intoExpression);
}
public ExprDotNodeAggregationMethodForgeLocal(
ExprDotNodeImpl parent,
string aggregationMethodName,
ExprNode[] parameters,
AggregationPortableValidation validation,
ExprAggMultiFunctionNode agg)
: base(parent, aggregationMethodName, parameters, validation)
{
this.agg = agg;
}
public void ValidateIntoTableCompatible(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
AggregationValidationUtil.ValidateAggregationType(this, tableExpression, intoTableAgg, intoExpression);
var other = (AggregationPortableValidationLinear) intoTableAgg;
AggregationValidationUtil.ValidateEventType(ContainedEventType, other.ContainedEventType);
}
public void ValidateIntoTableCompatible(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
AggregationValidationUtil.ValidateAggregationType(this, tableExpression, intoTableAgg, intoExpression);
var that = (AggregationPortableValidationBase) intoTableAgg;
AggregationValidationUtil.ValidateDistinct(IsDistinct, that.IsDistinct);
ValidateIntoTable(tableExpression, intoTableAgg, intoExpression, factory);
}
protected override void ValidateIntoTable(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
var that = (AggregationPortableValidationWFilterWInputType) intoTableAgg;
AggregationValidationUtil.ValidateAggregationInputType(InputValueType, that.InputValueType);
AggregationValidationUtil.ValidateAggregationFilter(HasFilter, that.HasFilter);
ValidateIntoTableWFilterWInputType(tableExpression, intoTableAgg, intoExpression, factory);
}
public ExprDotNodeAggregationMethodForge(
ExprDotNodeImpl parent,
string aggregationMethodName,
ExprNode[] parameters,
AggregationPortableValidation validation)
{
this.parent = parent;
this.aggregationMethodName = aggregationMethodName;
this.parameters = parameters;
this.validation = validation;
}
public ExprDotNodeAggregationMethodForgeTableAccess(
ExprDotNodeImpl parent,
string aggregationMethodName,
ExprNode[] parameters,
AggregationPortableValidation validation,
ExprTableAccessNodeSubprop subprop,
TableMetadataColumnAggregation column)
: base(parent, aggregationMethodName, parameters, validation)
{
this.subprop = subprop;
this.column = column;
}
public ExprDotNodeAggregationMethodForgeTableReset(
ExprDotNodeImpl parent,
string aggregationMethodName,
ExprNode[] parameters,
AggregationPortableValidation validation,
ExprTableIdentNode identNode,
TableMetadataColumnAggregation column)
: base(parent, aggregationMethodName, parameters, validation)
{
this.identNode = identNode;
this.column = column;
}
protected override void ValidateIntoTable(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
AggregationPortableValidationPlugin that = (AggregationPortableValidationPlugin) intoTableAgg;
if (!_functionName.Equals(that._functionName))
{
throw new ExprValidationException(
"The aggregation declares '" + _functionName + "' and provided is '" + that._functionName + "'");
}
}
public static void ValidateAggregationType(
AggregationPortableValidation tableDeclared,
string tableExpression,
AggregationPortableValidation intoTableDeclared,
string intoExpression)
{
if (tableDeclared.GetType() != intoTableDeclared.GetType()) {
throw new ExprValidationException(
"The table declares '" +
tableExpression +
"' and provided is '" +
intoExpression +
"'");
}
}
protected override void ValidateIntoTableWFilterWInputType(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
AggregationPortableValidationNth that = (AggregationPortableValidationNth) intoTableAgg;
if (Size != that.Size) {
throw new ExprValidationException(
"The size is " +
Size +
" and provided is " +
that.Size);
}
}
protected override void ValidateIntoTableWFilterWInputType(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
var that = (AggregationPortableValidationFirstLastEver) intoTableAgg;
if (IsFirst != that.IsFirst) {
throw new ExprValidationException(
"The aggregation declares " +
(IsFirst ? "firstever" : "lastever") +
" and provided is " +
(that.IsFirst ? "firstever" : "lastever"));
}
}
protected override void ValidateIntoTableWFilterWInputType(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
var that = (AggregationPortableValidationRate) intoTableAgg;
if (IntervalTime != that.IntervalTime) {
throw new ExprValidationException(
"The interval-time is " +
IntervalTime +
" and provided is " +
that.IntervalTime);
}
}
public TableMetadataColumnAggregation(
string columnName,
bool key,
int column,
AggregationPortableValidation aggregationPortableValidation,
string aggregationExpression,
bool methodAgg,
EPType optionalEnumerationType)
: base(columnName, key)
{
Column = column;
AggregationPortableValidation = aggregationPortableValidation;
AggregationExpression = aggregationExpression;
IsMethodAgg = methodAgg;
OptionalEnumerationType = optionalEnumerationType;
}
protected override void ValidateIntoTableWFilterWInputType(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory)
{
var that = (AggregationPortableValidationMinMax) intoTableAgg;
if (MinMax != that.MinMax) {
throw new ExprValidationException(
"The aggregation declares " +
MinMax.GetExpressionText() +
" and provided is " +
that.MinMax.GetExpressionText());
}
AggregationValidationUtil.ValidateAggregationUnbound(IsUnbound, that.IsUnbound);
}
protected abstract void ValidateIntoTable(
string tableExpression,
AggregationPortableValidation intoTableAgg,
string intoExpression,
AggregationForgeFactory factory);
