Beispiel #1
0
        /// <summary>
        /// Ctor.
        /// </summary>
        /// <param name="eventType">the name of the type to Update</param>
        /// <param name="expression">expression returning a value to write</param>
        /// <returns>Update clause</returns>
        public static UpdateClause Create(String eventType, Expression expression)
        {
            var clause = new UpdateClause(eventType, null);

            clause.AddAssignment(expression);
            return(clause);
        }
Beispiel #2
0
 public void ToEPL(TextWriter writer)
 {
     writer.Write("then update ");
     UpdateClause.RenderEPLAssignments(writer, Assignments);
     if (WhereClause != null)
     {
         writer.Write(" where ");
         WhereClause.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
     }
 }
Beispiel #3
0
        /// <summary>
        /// Renders the clause in textual representation.
        /// </summary>
        /// <param name="writer">to output to</param>
        public void ToEPL(TextWriter writer)
        {
            writer.Write(WindowName);
            if (OptionalAsName != null)
            {
                writer.Write(" as ");
                writer.Write(OptionalAsName);
            }

            writer.Write(" ");
            UpdateClause.RenderEPLAssignments(writer, Assignments);
        }
Beispiel #4
0
 private void WriteThenAssignments(TextWriter writer, IList <Assignment> thenAssignments)
 {
     writer.Write(" then ");
     UpdateClause.RenderEPLAssignments(writer, thenAssignments);
 }
Beispiel #5
0
 /// <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 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);

            if (ContextName != null)
            {
                formatter.BeginContext(writer);
                writer.Write("context ");
                writer.Write(ContextName);
            }

            if (CreateIndex != null)
            {
                formatter.BeginCreateIndex(writer);
                CreateIndex.ToEPL(writer);
                return;
            }
            else if (CreateSchema != null)
            {
                formatter.BeginCreateSchema(writer);
                CreateSchema.ToEPL(writer);
                return;
            }
            else if (CreateExpression != null)
            {
                formatter.BeginCreateExpression(writer);
                CreateExpression.ToEPL(writer);
                return;
            }
            else if (CreateContext != null)
            {
                formatter.BeginCreateContext(writer);
                CreateContext.ToEPL(writer, formatter);
                return;
            }
            else if (CreateWindow != null)
            {
                formatter.BeginCreateWindow(writer);
                CreateWindow.ToEPL(writer);

                if (FromClause != null)
                {
                    var fs = (FilterStream)FromClause.Streams[0];
                    if (fs.IsRetainUnion)
                    {
                        writer.Write(" retain-union");
                    }
                }

                writer.Write(" as ");
                if ((SelectClause == null) || (SelectClause.SelectList.IsEmpty()) && !CreateWindow.Columns.IsEmpty())
                {
                    CreateWindow.ToEPLCreateTablePart(writer);
                }
                else
                {
                    SelectClause.ToEPL(writer, formatter, false, false);
                    FromClause.ToEPL(writer, formatter);
                    CreateWindow.ToEPLInsertPart(writer);
                }
                return;
            }
            else if (CreateVariable != null)
            {
                formatter.BeginCreateVariable(writer);
                CreateVariable.ToEPL(writer);
                return;
            }
            else if (CreateTable != null)
            {
                formatter.BeginCreateTable(writer);
                CreateTable.ToEPL(writer);
                return;
            }
            else 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)
                {
                    formatter.BeginOnDelete(writer);
                    writer.Write("delete from ");
                    ((OnDeleteClause)OnExpr).ToEPL(writer);
                }
                else if (OnExpr is OnUpdateClause)
                {
                    formatter.BeginOnUpdate(writer);
                    writer.Write("update ");
                    ((OnUpdateClause)OnExpr).ToEPL(writer);
                }
                else if (OnExpr is OnSelectClause)
                {
                    var onSelect = (OnSelectClause)OnExpr;
                    if (InsertInto != null)
                    {
                        InsertInto.ToEPL(writer, formatter, true);
                    }
                    SelectClause.ToEPL(writer, formatter, true, onSelect.IsDeleteAndSelect);
                    writer.Write(" from ");
                    onSelect.ToEPL(writer);
                }
                else if (OnExpr is OnSetClause)
                {
                    var onSet = (OnSetClause)OnExpr;
                    onSet.ToEPL(writer, formatter);
                }
                else if (OnExpr is OnMergeClause)
                {
                    var merge = (OnMergeClause)OnExpr;
                    merge.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
            {
                if (IntoTableClause != null)
                {
                    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)
                {
                    var update = (FireAndForgetUpdate)FireAndForgetClause;
                    writer.Write("update ");
                    FromClause.ToEPLOptions(writer, formatter, false);
                    writer.Write(" ");
                    UpdateClause.RenderEPLAssignments(writer, update.Assignments);
                }
                else if (FireAndForgetClause is FireAndForgetInsert)
                {
                    var insert = (FireAndForgetInsert)FireAndForgetClause;
                    InsertInto.ToEPL(writer, formatter, true);
                    if (insert.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
                {
                    if (InsertInto != null)
                    {
                        InsertInto.ToEPL(writer, formatter, true);
                    }
                    SelectClause.ToEPL(writer, formatter, true, false);
                    FromClause.ToEPLOptions(writer, formatter, true);
                }
            }

            if (MatchRecognizeClause != null)
            {
                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);
            }
        }