// --------------------------------------------------------------------------------
public CodegenExpressionInstanceField AddOrGetDefaultFieldWellKnown(
CodegenFieldName fieldName,
Type type)
{
CodegenExpression instance = Ref("statementFields");
CodegenExpressionField fieldExpression = AddOrGetFieldWellKnown(fieldName, type);
return InstanceField(instance, fieldExpression.Field);
}
public ExprAggregateNodeGroupKey(
int numGroupKeys,
int groupKeyIndex,
Type returnType,
CodegenFieldName aggregationResultFutureMemberName)
{
this.numGroupKeys = numGroupKeys;
this.groupKeyIndex = groupKeyIndex;
this.returnType = returnType;
this.aggregationResultFutureMemberName = aggregationResultFutureMemberName;
}
private static void Generate(
CodegenExpression init,
CodegenFieldName name,
CodegenMethod assign,
CodegenMethod unassign,
bool generateUnassign)
{
assign.Block.AssignRef(name.Name, init);
// Table strategies are not unassigned since they do not hold on to the table instance
if (generateUnassign) {
unassign.Block.AssignRef(name.Name, ConstantNull());
}
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
ValidatePositionals(validationContext);
aggregationMethodFactory = ValidateAggregationChild(validationContext);
if (!validationContext.IsAggregationFutureNameAlreadySet) {
aggregationResultFutureMemberName = validationContext.MemberNames.AggregationResultFutureRef();
}
else {
if (aggregationResultFutureMemberName == null) {
throw new ExprValidationException("Aggregation future not set");
}
}
return null;
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
if (ChildNodes.Length != 2) {
throw new ExprValidationException("Prior node must have 2 parameters");
}
if (!ChildNodes[0].Forge.ForgeConstantType.IsCompileTimeConstant) {
throw new ExprValidationException(
"Prior function requires a constant-value integer-typed index expression as the first parameter");
}
// Child identifier nodes receive optional event
ExprNodeUtilityMake.SetChildIdentNodesOptionalEvent(this);
var constantNode = ChildNodes[0];
var constantNodeType = constantNode.Forge.EvaluationType;
if (constantNodeType != typeof(int?) && constantNodeType != typeof(int)) {
throw new ExprValidationException("Prior function requires an integer index parameter");
}
var value = constantNode.Forge.ExprEvaluator.Evaluate(null, false, null);
ConstantIndexNumber = value.AsInt32();
InnerForge = ChildNodes[1].Forge;
// Determine stream number
if (ChildNodes[1] is ExprIdentNode) {
var identNode = (ExprIdentNode) ChildNodes[1];
StreamNumber = identNode.StreamId;
EvaluationType = InnerForge.EvaluationType.GetBoxedType();
}
else if (ChildNodes[1] is ExprStreamUnderlyingNode) {
var streamNode = (ExprStreamUnderlyingNode) ChildNodes[1];
StreamNumber = streamNode.StreamId;
EvaluationType = InnerForge.EvaluationType.GetBoxedType();
}
else {
throw new ExprValidationException("Previous function requires an event property as parameter");
}
// add request
if (validationContext.ViewResourceDelegate == null) {
throw new ExprValidationException("Prior function cannot be used in this context");
}
validationContext.ViewResourceDelegate.AddPriorNodeRequest(this);
priorStrategyFieldName = validationContext.MemberNames.PriorStrategy(StreamNumber);
return null;
}
public CodegenExpressionField AddOrGetFieldWellKnown(
CodegenFieldName fieldName,
Type type)
{
var existing = _fieldsNamed.Get(fieldName);
if (existing != null) {
if (existing.Type != type) {
throw new IllegalStateException(
"Field '" +
fieldName +
"' already registered with a different type, registered with " +
existing.Type.GetSimpleName() +
" but provided " +
type.GetSimpleName());
}
return Field(existing);
}
var field = new CodegenField(FieldsClassName, fieldName.Name, type, null, false);
_fieldsNamed.Put(fieldName, field);
return Field(field);
}
public CodegenExpressionField AddOrGetFieldWellKnown(
CodegenFieldName fieldName,
Type type)
{
return NamespaceScope.AddOrGetFieldWellKnown(fieldName, type);
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
if (ChildNodes.Length > 2 || ChildNodes.Length == 0) {
throw new ExprValidationException("Previous node must have 1 or 2 parameters");
}
// add constant of 1 for previous index
if (ChildNodes.Length == 1) {
if (PreviousType == ExprPreviousNodePreviousType.PREV) {
AddChildNodeToFront(new ExprConstantNodeImpl(1));
}
else {
AddChildNodeToFront(new ExprConstantNodeImpl(0));
}
}
// the row recognition patterns allows "prev(prop, index)", we switch index the first position
if (ExprNodeUtilityQuery.IsConstant(ChildNodes[1])) {
var first = ChildNodes[0];
var second = ChildNodes[1];
ChildNodes = new[] {second, first};
}
// Determine if the index is a constant value or an expression to evaluate
if (ChildNodes[0].Forge.ForgeConstantType.IsCompileTimeConstant) {
var constantNode = ChildNodes[0];
var value = constantNode.Forge.ExprEvaluator.Evaluate(null, false, null);
if (!value.IsNumber()) {
throw new ExprValidationException(
"Previous function requires an integer index parameter or expression");
}
var valueNumber = value;
if (valueNumber.IsFloatingPointNumber()) {
throw new ExprValidationException(
"Previous function requires an integer index parameter or expression");
}
ConstantIndexNumber = valueNumber.AsInt32();
IsConstantIndex = true;
}
// Determine stream number
if (ChildNodes[1] is ExprIdentNode) {
var identNode = (ExprIdentNode) ChildNodes[1];
StreamNumber = identNode.StreamId;
ResultType = ChildNodes[1].Forge.EvaluationType.GetBoxedType();
}
else if (ChildNodes[1] is ExprStreamUnderlyingNode) {
var streamNode = (ExprStreamUnderlyingNode) ChildNodes[1];
StreamNumber = streamNode.StreamId;
ResultType = ChildNodes[1].Forge.EvaluationType.GetBoxedType();
_enumerationMethodType = validationContext.StreamTypeService.EventTypes[streamNode.StreamId];
}
else {
throw new ExprValidationException("Previous function requires an event property as parameter");
}
if (PreviousType == ExprPreviousNodePreviousType.PREVCOUNT) {
ResultType = typeof(long?);
}
if (PreviousType == ExprPreviousNodePreviousType.PREVWINDOW) {
ResultType = TypeHelper.GetArrayType(ResultType);
}
if (validationContext.ViewResourceDelegate == null) {
throw new ExprValidationException("Previous function cannot be used in this context");
}
validationContext.ViewResourceDelegate.AddPreviousRequest(this);
_previousStrategyFieldName = validationContext.MemberNames.PreviousStrategy(StreamNumber);
return null;
}