/// <summary>Renders the clause in textual representation. </summary> /// <param name="writer">to output to</param> /// <param name="formatter">for NewLine-whitespace formatting</param> public void ToEPL( TextWriter writer, EPStatementFormatter formatter) { foreach (OnInsertSplitStreamItem item in Items) { item.InsertInto.ToEPL(writer, formatter, true); item.SelectClause.ToEPL(writer, formatter, true, false); if (item.PropertySelects != null) { writer.Write(" from "); ContainedEventSelect.ToEPL(writer, formatter, item.PropertySelects); if (item.PropertySelectsStreamName != null) { writer.Write(" as "); writer.Write(item.PropertySelectsStreamName); } } if (item.WhereClause != null) { writer.Write(" where "); item.WhereClause.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); } } if (!IsFirst) { writer.Write(" output all"); } }
/// <summary> /// Renders the clause in EPL. /// </summary> /// <param name="writer">to output to</param> /// <param name="formatter">for NewLine-whitespace formatting</param> public void ToEPL( TextWriter writer, EPStatementFormatter formatter) { formatter.BeginOnSet(writer); UpdateClause.RenderEPLAssignments(writer, Assignments); }
/// <summary> /// Renders the clause in textual representation. /// </summary> /// <param name="writer">to output to</param> /// <param name="formatter"></param> public override void ToEPLStream( TextWriter writer, EPStatementFormatter formatter) { ToEPLProjectedStream(writer, formatter); ToEPLViews(writer, Views); }
/// <summary> /// Rendering using the provided formatter. /// </summary> /// <param name="formatter">to use</param> /// <returns>rendered string</returns> public string ToEPL(EPStatementFormatter formatter) { var writer = new StringWriter(); ToEPL(formatter, writer); return(writer.ToString()); }
public override void ToPrecedenceFreeEPL( TextWriter writer, EPStatementFormatter formatter) { string delimiter = ""; int childNum = 0; foreach (PatternExpr child in Children) { writer.Write(delimiter); child.ToEPL(writer, Precedence, formatter); delimiter = " -> "; if (OptionalMaxPerSubexpression != null && OptionalMaxPerSubexpression.Count > childNum) { var maxExpr = OptionalMaxPerSubexpression[childNum]; if (maxExpr != null) { var inner = new StringWriter(); maxExpr.ToEPL(inner, ExpressionPrecedenceEnum.MINIMUM); delimiter = " -[" + inner.ToString() + "]> "; } } childNum++; } }
/// <summary>Renders the clause in textual representation. </summary> /// <param name="writer">to output to</param> /// <param name="formatter">for NewLine-whitespace formatting</param> public void ToEPL( TextWriter writer, EPStatementFormatter formatter) { formatter.BeginMergeWhenMatched(writer); if (IsMatched) { writer.Write("when matched"); } else { writer.Write("when not matched"); } if (OptionalCondition != null) { writer.Write(" and "); OptionalCondition.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); } foreach (OnMergeMatchedAction action in Actions) { formatter.BeginMergeAction(writer); action.ToEPL(writer); } }
/// <summary> /// Renders the clause in textual representation. /// </summary> /// <param name="writer">to output to</param> /// <param name="optionalWhereClause">where clause if present, or null</param> /// <param name="formatter">for newline-whitespace formatting</param> public void ToEPL( TextWriter writer, Expression optionalWhereClause, EPStatementFormatter formatter) { formatter.BeginMerge(writer); writer.Write("merge "); writer.Write(WindowName); if (OptionalAsName != null) { writer.Write(" as "); writer.Write(OptionalAsName); } if (InsertNoMatch != null) { writer.Write(" "); InsertNoMatch.ToEPL(writer); } else { if (optionalWhereClause != null) { formatter.BeginMergeWhere(writer); writer.Write("where "); optionalWhereClause.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); } foreach (var item in MatchItems) { item.ToEPL(writer, formatter); } } }
/// <summary>Renders the clause in textual representation. </summary> /// <param name="writer">to output to</param> /// <param name="formatter">for NewLine-whitespace formatting</param> /// <param name="isTopLevel">to indicate if this insert-into-clause is inside other clauses.</param> public void ToEPL( TextWriter writer, EPStatementFormatter formatter, bool isTopLevel) { formatter.BeginInsertInto(writer, isTopLevel); writer.Write("insert "); if (StreamSelector != StreamSelector.ISTREAM_ONLY) { writer.Write(StreamSelector.GetEPL()); writer.Write(" "); } writer.Write("into "); writer.Write(StreamName); if (ColumnNames.Count > 0) { writer.Write("("); string delimiter = ""; foreach (var name in ColumnNames) { writer.Write(delimiter); writer.Write(name); delimiter = ", "; } writer.Write(")"); } }
public override void ToPrecedenceFreeEPL( TextWriter writer, EPStatementFormatter formatter) { writer.Write("not "); Children[0].ToEPL(writer, Precedence, formatter); }
public void ToEPL( TextWriter writer, EPStatementFormatter formatter) { HashFunction?.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); writer.Write(" from "); Filter.ToEPL(writer, formatter); }
/// <summary>RenderAny as EPL. </summary> /// <param name="writer">to output to</param> /// <param name="formatter">formatter</param> public void ToEPL( TextWriter writer, EPStatementFormatter formatter) { writer.Write("create context "); writer.Write(ContextName); writer.Write(" as "); Descriptor.ToEPL(writer, formatter); }
public void ToEPL( TextWriter writer, EPStatementFormatter formatter) { writer.Write("group "); Expression.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); writer.Write(" as "); writer.Write(Label); }
public void ToEPL( TextWriter writer, EPStatementFormatter formatter) { Filter.ToEPL(writer, formatter); if (OptionalAsName != null) { writer.Write(" as "); writer.Write(OptionalAsName); } }
public void ToEPL( TextWriter writer, EPStatementFormatter formatter) { if (IsNow) { writer.Write("@now and"); } writer.Write("after "); TimePeriod.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); }
public override void ToPrecedenceFreeEPL( TextWriter writer, EPStatementFormatter formatter) { string delimiter = ""; foreach (PatternExpr child in Children) { writer.Write(delimiter); child.ToEPL(writer, Precedence, formatter); delimiter = " or "; } }
public override void ToPrecedenceFreeEPL( TextWriter writer, EPStatementFormatter formatter) { if ((Children == null) || (Children.Count == 0)) { return; } PatternExpr patternExpr = Children[0]; patternExpr?.ToEPL(writer, Precedence, formatter); }
public override void ToPrecedenceFreeEPL( TextWriter writer, EPStatementFormatter formatter) { if (Single != null) { writer.Write("["); Single.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); writer.Write("]"); } else { if (Low != null || High != null) { writer.Write("["); if ((Low != null) && (High != null)) { Low.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); writer.Write(":"); High.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); } else if (Low != null) { Low.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); writer.Write(":"); } else { writer.Write(":"); High.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); } writer.Write("] "); } } PatternExprPrecedenceEnum precedence = Precedence; if (Children[0] is PatternMatchUntilExpr) { precedence = PatternExprPrecedenceEnum.MAXIMIM; } Children[0].ToEPL(writer, precedence, formatter); if (Children.Count > 1) { writer.Write(" until "); Children[1].ToEPL(writer, Precedence, formatter); } }
public override void ToPrecedenceFreeEPL( TextWriter writer, EPStatementFormatter formatter) { writer.Write("every "); PatternExprPrecedenceEnum precedence = Precedence; if (Children[0] is PatternEveryExpr) { precedence = PatternExprPrecedenceEnum.MAXIMIM; } Children[0].ToEPL(writer, precedence, formatter); }
public virtual void ToEPL( TextWriter writer, PatternExprPrecedenceEnum parentPrecedence, EPStatementFormatter formatter) { if (Precedence.GetLevel() < parentPrecedence.GetLevel()) { writer.Write("("); ToPrecedenceFreeEPL(writer, formatter); writer.Write(")"); } else { ToPrecedenceFreeEPL(writer, formatter); } }
public void ToEPL( TextWriter writer, EPStatementFormatter formatter) { string delimiter = ""; foreach (CreateContextClause context in Contexts) { writer.Write(delimiter); writer.Write("context "); writer.Write(context.ContextName); writer.Write(" as "); context.Descriptor.ToEPL(writer, formatter); delimiter = ", "; } }
public void ToEPL( TextWriter writer, EPStatementFormatter formatter) { string delimiter = ""; foreach (ContextDescriptorCategoryItem item in Items) { writer.Write(delimiter); item.ToEPL(writer, formatter); delimiter = ", "; } writer.Write(" from "); Filter.ToEPL(writer, formatter); }
/// <summary> /// Renders the clause in textual representation. /// </summary> /// <param name="writer">to output to</param> /// <param name="formatter">for NewLine-whitespace formatting</param> /// <param name="isTopLevel">to indicate if this select-clause is inside other clauses.</param> /// <param name="andDelete">indicator whether select and delete.</param> public void ToEPL( TextWriter writer, EPStatementFormatter formatter, bool isTopLevel, bool andDelete) { formatter.BeginSelect(writer, isTopLevel); writer.Write("select "); if (andDelete) { writer.Write("and delete "); } if (IsDistinct) { writer.Write("distinct "); } if (_streamSelector == StreamSelector.ISTREAM_ONLY) { // the default, no action } else if (_streamSelector == StreamSelector.RSTREAM_ONLY) { writer.Write("rstream "); } else if (_streamSelector == StreamSelector.RSTREAM_ISTREAM_BOTH) { writer.Write("irstream "); } if (_selectList != null && !_selectList.IsEmpty()) { string delimiter = ""; foreach (SelectClauseElement element in _selectList) { writer.Write(delimiter); element.ToEPLElement(writer); delimiter = ", "; } } else { writer.Write('*'); } }
public override void ToPrecedenceFreeEPL( TextWriter writer, EPStatementFormatter formatter) { writer.Write("every-distinct("); string delimiter = ""; foreach (Expression expr in Expressions) { writer.Write(delimiter); expr.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); delimiter = ","; } writer.Write(") "); Children[0].ToEPL(writer, Precedence, formatter); }
public void ToEPL( TextWriter writer, EPStatementFormatter formatter) { if (IsNow) { writer.Write("@now and"); } writer.Write("pattern ["); Pattern?.ToEPL(writer, PatternExprPrecedenceEnum.MINIMUM, formatter); writer.Write("]"); if (IsInclusive) { writer.Write("@Inclusive"); } }
/// <summary> /// Print. /// </summary> /// <param name="writer">to print to</param> /// <param name="annotations">annotations</param> /// <param name="formatter">for newline-whitespace formatting</param> public static void ToEPL( TextWriter writer, IList<AnnotationPart> annotations, EPStatementFormatter formatter) { if (annotations == null || annotations.IsEmpty()) { return; } foreach (var part in annotations) { if (part.Name == null) { continue; } formatter.BeginAnnotation(writer); part.ToEPL(writer); } }
/// <summary> /// Print. /// </summary> /// <param name="writer">to print to</param> /// <param name="scripts">scripts</param> /// <param name="formatter">for newline-whitespace formatting</param> public static void ToEPL( TextWriter writer, IList<ScriptExpression> scripts, EPStatementFormatter formatter) { if ((scripts == null) || (scripts.IsEmpty())) { return; } foreach (ScriptExpression part in scripts) { if (part.Name == null) { continue; } formatter.BeginExpressionDecl(writer); part.ToEPL(writer); } }
public void ToEPL( TextWriter writer, EPStatementFormatter formatter) { writer.Write("coalesce "); string delimiter = ""; foreach (ContextDescriptorHashSegmentedItem item in Items) { writer.Write(delimiter); item.ToEPL(writer, formatter); delimiter = ", "; } writer.Write(" granularity "); writer.Write(Convert.ToString(Granularity)); if (IsPreallocate) { writer.Write(" preallocate"); } }
/// <summary> /// Print. /// </summary> /// <param name="writer">to print to</param> /// <param name="expressionDeclarations">expression declarations</param> /// <param name="formatter">for newline-whitespace formatting</param> public static void ToEPL( TextWriter writer, IList <ExpressionDeclaration> expressionDeclarations, EPStatementFormatter formatter) { if ((expressionDeclarations == null) || (expressionDeclarations.IsEmpty())) { return; } foreach (var part in expressionDeclarations) { if (part.Name == null) { continue; } formatter.BeginExpressionDecl(writer); part.ToEPL(writer); } }
public override void ToPrecedenceFreeEPL( TextWriter writer, EPStatementFormatter formatter) { if (TagName != null) { writer.Write(TagName); writer.Write('='); } Filter.ToEPL(writer, formatter); if (OptionalConsumptionLevel != null) { writer.Write("@consume"); if (OptionalConsumptionLevel != 1) { writer.Write("("); writer.Write(Convert.ToString(OptionalConsumptionLevel)); writer.Write(")"); } } }
/// <summary> /// Renders the object model in it's EPL syntax textual representation, using a whitespace-formatter as provided. /// </summary> /// <param name="formatter">the formatter to use</param> /// <param name="writer">writer to use</param> /// <throws>IllegalStateException if required clauses do not exist</throws> public void ToEPL( EPStatementFormatter formatter, TextWriter writer) { AnnotationPart.ToEPL(writer, Annotations, formatter); ExpressionDeclaration.ToEPL(writer, ExpressionDeclarations, formatter); ScriptExpression.ToEPL(writer, ScriptExpressions, formatter); ClassProvidedExpression.ToEPL(writer, ClassProvidedExpressions, formatter); if (ContextName != null) { formatter.BeginContext(writer); writer.Write("context "); writer.Write(ContextName); } if (CreateIndex != null) { formatter.BeginCreateIndex(writer); CreateIndex.ToEPL(writer); return; } if (CreateSchema != null) { formatter.BeginCreateSchema(writer); CreateSchema.ToEPL(writer); return; } if (CreateExpression != null) { formatter.BeginCreateExpression(writer); CreateExpression.ToEPL(writer); return; } if (CreateClass != null) { formatter.BeginCreateExpression(writer); CreateClass.ToEPL(writer); return; } if (CreateContext != null) { formatter.BeginCreateContext(writer); CreateContext.ToEPL(writer, formatter); return; } if (CreateWindow != null) { formatter.BeginCreateWindow(writer); CreateWindow.ToEPL(writer); writer.Write(" as "); if (SelectClause == null || SelectClause.SelectList.IsEmpty() && !CreateWindow.Columns.IsEmpty()) { CreateWindow.ToEPLCreateTablePart(writer); } else { SelectClause.ToEPL(writer, formatter, false, false); if (CreateWindow.AsEventTypeName != null) { writer.Write(" from "); writer.Write(CreateWindow.AsEventTypeName); } CreateWindow.ToEPLInsertPart(writer); } return; } if (CreateVariable != null) { formatter.BeginCreateVariable(writer); CreateVariable.ToEPL(writer); return; } if (CreateTable != null) { formatter.BeginCreateTable(writer); CreateTable.ToEPL(writer); return; } if (CreateDataFlow != null) { formatter.BeginCreateDataFlow(writer); CreateDataFlow.ToEPL(writer, formatter); return; } var displayWhereClause = true; if (UpdateClause != null) { formatter.BeginUpdate(writer); UpdateClause.ToEPL(writer); } else if (OnExpr != null) { formatter.BeginOnTrigger(writer); writer.Write("on "); FromClause.Streams[0].ToEPL(writer, formatter); if (OnExpr is OnDeleteClause onDeleteClause) { formatter.BeginOnDelete(writer); writer.Write("delete from "); onDeleteClause.ToEPL(writer); } else if (OnExpr is OnUpdateClause onUpdateClause) { formatter.BeginOnUpdate(writer); writer.Write("update "); onUpdateClause.ToEPL(writer); } else if (OnExpr is OnSelectClause onSelectClause) { InsertInto?.ToEPL(writer, formatter, true); SelectClause.ToEPL(writer, formatter, true, onSelectClause.IsDeleteAndSelect); writer.Write(" from "); onSelectClause.ToEPL(writer); } else if (OnExpr is OnSetClause onSetClause) { onSetClause.ToEPL(writer, formatter); } else if (OnExpr is OnMergeClause onMergeClause) { onMergeClause.ToEPL(writer, WhereClause, formatter); displayWhereClause = false; } else { var split = (OnInsertSplitStreamClause)OnExpr; InsertInto.ToEPL(writer, formatter, true); SelectClause.ToEPL(writer, formatter, true, false); if (WhereClause != null) { writer.Write(" where "); WhereClause.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); } split.ToEPL(writer, formatter); displayWhereClause = false; } } else { IntoTableClause?.ToEPL(writer); if (SelectClause == null) { throw new IllegalStateException("Select-clause has not been defined"); } if (FromClause == null) { throw new IllegalStateException("From-clause has not been defined"); } if (FireAndForgetClause is FireAndForgetUpdate fireAndForgetUpdate) { writer.Write("update "); FromClause.ToEPLOptions(writer, formatter, false); writer.Write(" "); UpdateClause.RenderEPLAssignments(writer, fireAndForgetUpdate.Assignments); } else if (FireAndForgetClause is FireAndForgetInsert fireAndForgetInsert) { InsertInto.ToEPL(writer, formatter, true); if (fireAndForgetInsert.IsUseValuesKeyword) { writer.Write(" values ("); var delimiter = ""; foreach (var element in SelectClause.SelectList) { writer.Write(delimiter); element.ToEPLElement(writer); delimiter = ", "; } writer.Write(")"); } else { SelectClause.ToEPL(writer, formatter, true, false); } } else if (FireAndForgetClause is FireAndForgetDelete) { writer.Write("delete "); FromClause.ToEPLOptions(writer, formatter, true); } else { InsertInto?.ToEPL(writer, formatter, true); SelectClause.ToEPL(writer, formatter, true, false); FromClause.ToEPLOptions(writer, formatter, true); } } MatchRecognizeClause?.ToEPL(writer); if (WhereClause != null && displayWhereClause) { formatter.BeginWhere(writer); writer.Write("where "); WhereClause.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); } if (GroupByClause != null) { formatter.BeginGroupBy(writer); writer.Write("group by "); GroupByClause.ToEPL(writer); } if (HavingClause != null) { formatter.BeginHaving(writer); writer.Write("having "); HavingClause.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM); } if (OutputLimitClause != null) { formatter.BeginOutput(writer); writer.Write("output "); OutputLimitClause.ToEPL(writer); } if (OrderByClause != null) { formatter.BeginOrderBy(writer); writer.Write("order by "); OrderByClause.ToEPL(writer); } if (RowLimitClause != null) { formatter.BeginLimit(writer); writer.Write("limit "); RowLimitClause.ToEPL(writer); } if (ForClause != null) { formatter.BeginFor(writer); ForClause.ToEPL(writer); } }