Example #1
0
        public Task Invoke(IDictionary<string, object> env)
        {
            Response response = new Response(env);
            Stream orriginalStream = response.OutputStream;
            TriggerStream triggerStream = new TriggerStream(orriginalStream);
            response.OutputStream = triggerStream;
            FilterStream filterStream = null;
            triggerStream.OnFirstWrite = () =>
            {
                if (IsStatusWithNoNoEntityBody(response.StatusCode)
                    || response.Headers.ContainsKey("Content-Length")
                    || response.Headers.ContainsKey("Transfer-Encoding"))
                {
                    return;
                }

                // Buffer
                response.Headers.SetHeader("Transfer-Encoding", "chunked");
                filterStream = new FilterStream(orriginalStream, OnWriteFilter);
                triggerStream.InnerStream = filterStream;
            };

            env[OwinConstants.ResponseBody] = triggerStream;

            return nextApp(env).Then(() =>
            {
                if (filterStream != null)
                {
                    // Write the chunked terminator
                    return orriginalStream.WriteAsync(FinalChunk.Array, FinalChunk.Offset, FinalChunk.Count);
                }
                else if (!IsStatusWithNoNoEntityBody(response.StatusCode)
                    && !response.Headers.ContainsKey("Content-Length")
                    && !response.Headers.ContainsKey("Transfer-Encoding"))
                {
                    // There were no Writes.
                    response.Headers.SetHeader("Transfer-Encoding", "chunked");
                    return orriginalStream.WriteAsync(FinalChunk.Array, FinalChunk.Offset, FinalChunk.Count);
                }

                return TaskHelpers.Completed();
            });
        }
Example #2
0
        public void TestEveryPolicy()
        {
            SendTimer(0);
            String      stmtText = "select TheString from SupportBean.win:keepall() output after 0.0d days 0.0d hours 0.0d minutes 20.0d seconds 0.0d milliseconds every 0.0d days 0.0d hours 0.0d minutes 5.0d seconds 0.0d milliseconds";
            EPStatement stmt     = _epService.EPAdministrator.CreateEPL(stmtText);

            stmt.Events += _listener.Update;

            RunAssertion();

            var model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.Create("TheString");
            model.FromClause   = FromClause.Create(FilterStream.Create("SupportBean").AddView("win", "keepall"));
            var outputLimitClause = OutputLimitClause.Create(Expressions.TimePeriod(0.0d, 0, 0, 5, 0));

            outputLimitClause.AfterTimePeriodExpression = Expressions.TimePeriod(0.0d, 0, 0, 20, 0);
            model.OutputLimitClause = outputLimitClause;
            Assert.AreEqual(stmtText, model.ToEPL());
        }
        public void TestUnfilteredStreamPrior_OM()
        {
            var subquery = new EPStatementObjectModel();

            subquery.SelectClause = SelectClause.Create().Add(Expressions.Prior(0, "id"));
            subquery.FromClause   = FromClause.Create(FilterStream.Create("S1").AddView("win", "length", Expressions.Constant(1000)));

            var model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.Create().Add(Expressions.Subquery(subquery), "idS1");
            model.FromClause   = FromClause.Create(FilterStream.Create("S0"));
            model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);

            var stmtText = "select (select prior(0,id) from S1.win:length(1000)) as idS1 from S0";

            Assert.AreEqual(stmtText, model.ToEPL());
            var stmt = _epService.EPAdministrator.Create(model);

            RunUnfilteredStreamPrior(stmt);
        }
        private void RunAssertionOutputRateEventsAll_OM(EPServiceProvider epService)
        {
            epService.EPRuntime.SetVariableValue("var_output_limit", 3L);
            var model = new EPStatementObjectModel();

            model.SelectClause      = SelectClause.Create().Add(Expressions.CountStar(), "cnt");
            model.FromClause        = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName));
            model.OutputLimitClause = OutputLimitClause.Create(OutputLimitSelector.LAST, "var_output_limit");

            string      stmtTextSelect = "select count(*) as cnt from " + typeof(SupportBean).FullName + " output last every var_output_limit events";
            EPStatement stmtSelect     = epService.EPAdministrator.Create(model);
            var         listener       = new SupportUpdateListener();

            stmtSelect.Events += listener.Update;
            Assert.AreEqual(stmtTextSelect, model.ToEPL());

            TryAssertionOutputRateEventsAll(epService, listener);

            stmtSelect.Dispose();
        }
Example #5
0
        // This is a simple EPL only.
        // Each OM/SODA Api is tested in it's respective unit test (i.e. TestInsertInto), including ToEPL()
        //
        private void RunAssertionCreateFromOM(EPServiceProvider epService)
        {
            var model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.CreateWildcard();
            model.FromClause   = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName));
            SerializableObjectCopier.Copy(epService.Container, model);

            var stmt     = epService.EPAdministrator.Create(model, "s1");
            var listener = new SupportUpdateListener();

            stmt.Events += listener.Update;

            var theEvent = new SupportBean();

            epService.EPRuntime.SendEvent(theEvent);
            Assert.AreEqual(theEvent, listener.AssertOneGetNewAndReset().Underlying);

            stmt.Dispose();
        }
Example #6
0
        private void RunAssertionObjectModelJoinAlias(EPServiceProvider epService)
        {
            var model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.Create()
                                 .AddStreamWildcard("s0")
                                 .AddStreamWildcard("s1", "s1stream")
                                 .AddWithAsProvidedName("TheString", "sym");
            model.FromClause = FromClause.Create()
                               .Add(FilterStream.Create(typeof(SupportBean).FullName, "s0").AddView("keepall"))
                               .Add(FilterStream.Create(typeof(SupportMarketDataBean).FullName, "s1").AddView("keepall"));

            EPStatement stmt         = epService.EPAdministrator.Create(model);
            var         testListener = new SupportUpdateListener();

            stmt.Events += testListener.Update;

            string epl = "select s0.*, s1.* as s1stream, TheString as sym from " + typeof(SupportBean).FullName +
                         "#keepall as s0, " +
                         typeof(SupportMarketDataBean).FullName + "#keepall as s1";

            Assert.AreEqual(epl, model.ToEPL());
            EPStatementObjectModel modelReverse = epService.EPAdministrator.CompileEPL(model.ToEPL());

            Assert.AreEqual(epl, modelReverse.ToEPL());

            EventType type = stmt.EventType;

            Assert.AreEqual(typeof(SupportMarketDataBean), type.GetPropertyType("s1stream"));
            Assert.AreEqual(typeof(Pair <object, Map>), type.UnderlyingType);

            SendBeanEvent(epService, "E1");
            Assert.IsFalse(testListener.IsInvoked);

            object    theEvent = SendMarketEvent(epService, "E1");
            EventBean outevent = testListener.AssertOneGetNewAndReset();

            Assert.AreSame(theEvent, outevent.Get("s1stream"));

            stmt.Dispose();
        }
Example #7
0
            public void Run(RegressionEnvironment env)
            {
                var subquery = new EPStatementObjectModel();
                subquery.SelectClause = SelectClause.Create().Add(Expressions.Prior(0, "Id"));
                subquery.FromClause = FromClause.Create(
                    FilterStream.Create("SupportBean_S1").AddView("length", Expressions.Constant(1000)));

                var model = new EPStatementObjectModel();
                model.SelectClause = SelectClause.Create().Add(Expressions.Subquery(subquery), "IdS1");
                model.FromClause = FromClause.Create(FilterStream.Create("SupportBean_S0"));
                model = env.CopyMayFail(model);

                var stmtText =
                    "select (select prior(0,Id) from SupportBean_S1#length(1000)) as IdS1 from SupportBean_S0";
                Assert.AreEqual(stmtText, model.ToEPL());

                model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
                env.CompileDeploy(model).AddListener("s0");
                RunUnfilteredStreamPrior(env);
                env.UndeployAll();
            }
        private void RunAssertionEveryPolicy(EPServiceProvider epService)
        {
            SendTimer(epService, 0);
            string      stmtText = "select TheString from SupportBean#keepall output after 0 days 0 hours 0 minutes 20 seconds 0 milliseconds every 0 days 0 hours 0 minutes 5 seconds 0 milliseconds";
            EPStatement stmt     = epService.EPAdministrator.CreateEPL(stmtText);
            var         listener = new SupportUpdateListener();

            stmt.Events += listener.Update;

            TryAssertionEveryPolicy(epService, listener);

            stmt.Dispose();

            var model = new EPStatementObjectModel();

            model.SelectClause      = SelectClause.Create("TheString");
            model.FromClause        = FromClause.Create(FilterStream.Create("SupportBean").AddView("keepall"));
            model.OutputLimitClause = OutputLimitClause.Create(Expressions.TimePeriod(0, 0, 0, 5, 0))
                                      .SetAfterTimePeriodExpression(Expressions.TimePeriod(0, 0, 0, 20, 0));
            Assert.AreEqual(stmtText, model.ToEPL());
        }
Example #9
0
        /// <summary>
        ///     Creates a query view from the service provider.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="serviceProvider">The service provider.</param>
        /// <param name="streamNames">The stream names.</param>
        /// <returns></returns>
        public static EsperQuery <T> From <T>(
            this EPServiceProvider serviceProvider,
            params string[] streamNames)
        {
            var selectClause = SelectClause.Create();

            selectClause.AddWildcard();

            var objectModel = new EPStatementObjectModel();

            objectModel.SelectClause = selectClause;
            objectModel.FromClause   = FromClause.Create();
            objectModel.MakeIterableUnbound();

            for (var ii = 0; ii < streamNames.Length; ii++)
            {
                objectModel.FromClause.Add(FilterStream.Create(streamNames[ii]));
            }

            return(new EsperQuery <T>(serviceProvider, objectModel));
        }
            public void Run(RegressionEnvironment env)
            {
                var model = new EPStatementObjectModel();

                model.SelectClause = SelectClause.Create()
                                     .Add(Expressions.BinaryAnd().Add("BytePrimitive").Add("ByteBoxed"), "myFirstProperty")
                                     .Add(Expressions.BinaryOr().Add("ShortPrimitive").Add("ShortBoxed"), "mySecondProperty")
                                     .Add(Expressions.BinaryOr().Add("IntPrimitive").Add("IntBoxed"), "myThirdProperty")
                                     .Add(Expressions.BinaryXor().Add("LongPrimitive").Add("LongBoxed"), "myFourthProperty")
                                     .Add(Expressions.BinaryAnd().Add("BoolPrimitive").Add("BoolBoxed"), "myFifthProperty");

                model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).Name));
                model            = SerializableObjectCopier.GetInstance(env.Container).Copy(model);
                Assert.AreEqual(EPL, model.ToEPL());

                env.CompileDeploy("@Name('s0')  " + EPL).AddListener("s0");

                RunBitWiseOperators(env);

                env.UndeployAll();
            }
Example #11
0
        public void Test2TableFullOuterJoinOM()
        {
            EPStatementObjectModel model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.Create("Symbol", "Volume", "TheString", "IntPrimitive");
            model.FromClause   = FromClause.Create(FilterStream.Create(typeof(SupportMarketDataBean).FullName).Unidirectional(true));
            model.FromClause.Add(FilterStream.Create(typeof(SupportBean).FullName).AddView("win", "keepall"));
            model.FromClause.Add(OuterJoinQualifier.Create("TheString", OuterJoinType.FULL, "Symbol"));

            String stmtText = "select Symbol, Volume, TheString, IntPrimitive " +
                              "from " + typeof(SupportMarketDataBean).FullName + " unidirectional " +
                              "full outer join " +
                              typeof(SupportBean).FullName +
                              ".win:keepall() on TheString = Symbol";

            Assert.AreEqual(stmtText, model.ToEPL());

            EPStatement stmt = _epService.EPAdministrator.Create(model);

            TryFullOuterPassive2Stream(stmt);
        }
Example #12
0
        public void TestSumOneViewOM()
        {
            var model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.Create("Symbol", "Price").SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH).Add(Expressions.Avg("Price"), "avgPrice");
            model.FromClause   = FromClause.Create(FilterStream.Create(typeof(SupportMarketDataBean).FullName).AddView("win", "length", Expressions.Constant(5)));
            model.HavingClause = Expressions.Lt(Expressions.Property("Price"), Expressions.Avg("Price"));
            model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);

            var viewExpr = "select irstream Symbol, Price, avg(Price) as avgPrice " +
                           "from " + typeof(SupportMarketDataBean).FullName + ".win:length(5) " +
                           "having Price<avg(Price)";

            Assert.AreEqual(viewExpr, model.ToEPL());

            var selectTestView = _epService.EPAdministrator.Create(model);

            selectTestView.AddListener(_listener);

            RunAssertion(selectTestView);
        }
Example #13
0
        private void RunAssertionVariantOneOMToStmt(EPServiceProvider epService)
        {
            var model = new EPStatementObjectModel();

            model.InsertInto   = InsertIntoClause.Create("Event_1_OMS", "delta", "product");
            model.SelectClause = SelectClause.Create().Add(Expressions.Minus("IntPrimitive", "IntBoxed"), "deltaTag")
                                 .Add(Expressions.Multiply("IntPrimitive", "IntBoxed"), "productTag");
            model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName).AddView(View.Create("length", Expressions.Constant(100))));
            model            = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);

            EPStatement stmt = TryAssertsVariant(epService, null, model, "Event_1_OMS");

            string epl = "insert into Event_1_OMS(delta, product) " +
                         "select IntPrimitive-IntBoxed as deltaTag, IntPrimitive*IntBoxed as productTag " +
                         "from " + typeof(SupportBean).FullName + "#length(100)";

            Assert.AreEqual(epl, model.ToEPL());
            Assert.AreEqual(epl, stmt.Text);

            stmt.Dispose();
        }
Example #14
0
            public void Run(RegressionEnvironment env)
            {
                var model = new EPStatementObjectModel();

                model.SelectClause = SelectClause.Create()
                                     .Add(Expressions.Max("LongBoxed", "IntBoxed"), "myMax")
                                     .Add(Expressions.Max(Expressions.Property("LongBoxed"), Expressions.Property("IntBoxed"), Expressions.Property("ShortBoxed")), "myMaxEx")
                                     .Add(Expressions.Min("LongBoxed", "IntBoxed"), "myMin")
                                     .Add(Expressions.Min(Expressions.Property("LongBoxed"), Expressions.Property("IntBoxed"), Expressions.Property("ShortBoxed")), "myMinEx");

                model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).Name).AddView("length", Expressions.Constant(3)));
                model            = SerializableObjectCopier.GetInstance(env.Container).Copy(model);
                Assert.AreEqual(EPL, model.ToEPL());

                model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
                env.CompileDeploy(model).AddListener("s0");

                TryMinMaxWindowStats(env);

                env.UndeployAll();
            }
Example #15
0
        /// <summary>
        /// Creates a query view from the service provider.
        /// </summary>
        /// <param name="serviceProvider">The service provider.</param>
        /// <param name="typeList">The type list.</param>
        /// <returns></returns>
        public static EsperQuery <T> From <T>(this EPServiceProvider serviceProvider, params Type[] typeList)
        {
            var selectClause = SelectClause.Create();

            selectClause.AddWildcard();

            var objectModel = new EPStatementObjectModel();

            objectModel.SelectClause = selectClause;
            objectModel.FromClause   = FromClause.Create();
            objectModel.MakeIterableUnbound();

            for (int ii = 0; ii < typeList.Length; ii++)
            {
                var type       = typeList[ii];
                var streamName = String.Format("s{0}", ii);
                objectModel.FromClause.Add(FilterStream.Create(type.FullName, streamName));
            }

            return(new EsperQuery <T>(serviceProvider, objectModel));
        }
Example #16
0
            public void Run(RegressionEnvironment env)
            {
                var model = new EPStatementObjectModel();
                model.SelectClause = SelectClause.Create()
                    .Add(Expressions.StaticMethod<BitWriter>("Write", 7), "value");
                model.FromClause = FromClause.Create(
                    FilterStream.Create("SupportMarketDataBean").AddView("length", Expressions.Constant(5)));
                model = env.CopyMayFail(model);
                model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));

                var bitWriter = typeof(BitWriter).CleanName();
                var statementText = $"@Name('s0') select {bitWriter}.Write(7) as value" + STREAM_MDB_LEN5;

                Assert.AreEqual(statementText.Trim(), model.ToEPL());
                env.CompileDeploy(model).AddListener("s0");

                SendEvent(env, "IBM", 10d, 4L);
                Assert.AreEqual(BitWriter.Write(7), env.Listener("s0").AssertOneGetNewAndReset().Get("value"));

                env.UndeployAll();
            }
Example #17
0
        private void RunAssertionInStringExprOM(EPServiceProvider epService)
        {
            var caseExpr = "select TheString in (\"a\",\"b\",\"c\") as result from " + typeof(SupportBean).FullName;
            var model    = new EPStatementObjectModel();

            model.SelectClause = SelectClause.Create().Add(Expressions.In("TheString", "a", "b", "c"), "result");
            model.FromClause   = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName));

            TryString(epService, model, caseExpr,
                      new string[] { "0", "a", "b", "c", "d", null },
                      new bool?[] { false, true, true, true, false, null });

            model = new EPStatementObjectModel();
            model.SelectClause = SelectClause.Create().Add(Expressions.NotIn("TheString", "a", "b", "c"), "result");
            model.FromClause   = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName));
            model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);

            TryString(epService, "TheString not in ('a', 'b', 'c')",
                      new string[] { "0", "a", "b", "c", "d", null },
                      new bool?[] { true, false, false, false, true, null });
        }
Example #18
0
        private void RunAssertionLikeRegexStringAndNull_OM(EPServiceProvider epService)
        {
            var stmtText = "select p00 like p01 as r1, " +
                           "p00 like p01 escape \"!\" as r2, " +
                           "p02 regexp p03 as r3 " +
                           "from " + typeof(SupportBean_S0).FullName;

            var model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.Create()
                                 .Add(Expressions.Like(Expressions.Property("p00"), Expressions.Property("p01")), "r1")
                                 .Add(Expressions.Like(Expressions.Property("p00"), Expressions.Property("p01"), Expressions.Constant("!")), "r2")
                                 .Add(Expressions.Regexp(Expressions.Property("p02"), Expressions.Property("p03")), "r3");

            model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean_S0).FullName));
            model            = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);
            Assert.AreEqual(stmtText, model.ToEPL());

            var stmt         = epService.EPAdministrator.Create(model);
            var testListener = new SupportUpdateListener();

            stmt.Events += testListener.Update;

            RunLikeRegexStringAndNull(epService, testListener);

            stmt.Dispose();

            var epl       = "select * from " + typeof(SupportBean).FullName + "(TheString not like \"foo%\")";
            var eps       = epService.EPAdministrator.PrepareEPL(epl);
            var statement = epService.EPAdministrator.Create(eps);

            Assert.AreEqual(epl, statement.Text);
            statement.Dispose();

            epl       = "select * from " + typeof(SupportBean).FullName + "(TheString not regexp \"foo\")";
            eps       = epService.EPAdministrator.PrepareEPL(epl);
            statement = epService.EPAdministrator.Create(eps);
            Assert.AreEqual(epl, statement.Text);
            statement.Dispose();
        }
Example #19
0
        private void RunAssertion2SplitNoDefaultOutputFirst(EPServiceProvider epService)
        {
            var stmtOrigText = "@Audit on SupportBean " +
                               "insert into AStream2SP select * where IntPrimitive=1 " +
                               "insert into BStream2SP select * where IntPrimitive=1 or IntPrimitive=2";
            var stmtOrig = epService.EPAdministrator.CreateEPL(stmtOrigText);

            TryAssertion(epService, stmtOrig);

            // statement object model
            var model = new EPStatementObjectModel();

            model.Annotations  = Collections.SingletonList(new AnnotationPart("Audit"));
            model.FromClause   = FromClause.Create(FilterStream.Create("SupportBean"));
            model.InsertInto   = InsertIntoClause.Create("AStream2SP");
            model.SelectClause = SelectClause.CreateWildcard();
            model.WhereClause  = Expressions.Eq("IntPrimitive", 1);
            var clause = OnClause.CreateOnInsertSplitStream();

            model.OnExpr = clause;
            var item = OnInsertSplitStreamItem.Create(
                InsertIntoClause.Create("BStream2SP"),
                SelectClause.CreateWildcard(),
                Expressions.Or(Expressions.Eq("IntPrimitive", 1), Expressions.Eq("IntPrimitive", 2)));

            clause.AddItem(item);
            Assert.AreEqual(stmtOrigText, model.ToEPL());
            stmtOrig = epService.EPAdministrator.Create(model);
            TryAssertion(epService, stmtOrig);

            var newModel = epService.EPAdministrator.CompileEPL(stmtOrigText);

            stmtOrig = epService.EPAdministrator.Create(newModel);
            Assert.AreEqual(stmtOrigText, newModel.ToEPL());
            TryAssertion(epService, stmtOrig);

            SupportModelHelper.CompileCreate(epService, stmtOrigText + " output all");

            epService.EPAdministrator.DestroyAllStatements();
        }
            public void Run(RegressionEnvironment env)
            {
                var model = new EPStatementObjectModel();
                model.SelectClause = SelectClause.Create("Symbol", "Volume", "TheString", "IntPrimitive");
                model.FromClause = FromClause.Create(
                    FilterStream.Create(typeof(SupportMarketDataBean).Name).Unidirectional(true));
                model.FromClause.Add(FilterStream.Create(typeof(SupportBean).Name).AddView("keepall"));
                model.FromClause.Add(OuterJoinQualifier.Create("TheString", OuterJoinType.FULL, "Symbol"));

                var stmtText = "select Symbol, Volume, TheString, IntPrimitive " +
                               "from SupportMarketDataBean unidirectional " +
                               "full outer join SupportBean" +
                               "#keepall on TheString = Symbol";
                Assert.AreEqual(stmtText, model.ToEPL());

                model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
                env.CompileDeploy(model).AddListener("s0");

                TryFullOuterPassive2Stream(env);

                env.UndeployAll();
            }
Example #21
0
            public void Run(RegressionEnvironment env)
            {
                var model = new EPStatementObjectModel();
                model.SelectClause = SelectClause.CreateWildcard();
                model.SelectClause.StreamSelector = StreamSelector.RSTREAM_ISTREAM_BOTH;
                model.FromClause = FromClause.Create(
                    FilterStream.Create("SupportBean").AddView("length_batch", Expressions.Constant(3)));
                model.RowLimitClause = RowLimitClause.Create(1);

                var epl = "select irstream * from SupportBean#length_batch(3) limit 1";
                Assert.AreEqual(epl, model.ToEPL());

                model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
                env.CompileDeploy(model).AddListener("s0");

                TryAssertion(env);
                env.UndeployAll();

                env.EplToModelCompileDeploy("@Name('s0') " + epl).AddListener("s0");
                TryAssertion(env);
                env.UndeployAll();
            }
Example #22
0
        private void RunAssertionCastDoubleAndNull_OM(EPServiceProvider epService)
        {
            var stmtText = "select cast(item?,double) as t0 " +
                           "from " + typeof(SupportMarkerInterface).FullName;

            var model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.Create().Add(Expressions.Cast("item?", "double"), "t0");
            model.FromClause   = FromClause.Create(FilterStream.Create(typeof(SupportMarkerInterface).FullName));
            model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);
            Assert.AreEqual(stmtText, model.ToEPL());

            var selectTestCase = epService.EPAdministrator.Create(model);
            var listener       = new SupportUpdateListener();

            selectTestCase.Events += listener.Update;

            Assert.AreEqual(typeof(double?), selectTestCase.EventType.GetPropertyType("t0"));

            epService.EPRuntime.SendEvent(new SupportBeanDynRoot(100));
            Assert.AreEqual(100d, listener.AssertOneGetNewAndReset().Get("t0"));

            epService.EPRuntime.SendEvent(new SupportBeanDynRoot((byte)2));
            Assert.AreEqual(2d, listener.AssertOneGetNewAndReset().Get("t0"));

            epService.EPRuntime.SendEvent(new SupportBeanDynRoot(77.7777));
            Assert.AreEqual(77.7777d, listener.AssertOneGetNewAndReset().Get("t0"));

            epService.EPRuntime.SendEvent(new SupportBeanDynRoot(6L));
            Assert.AreEqual(6d, listener.AssertOneGetNewAndReset().Get("t0"));

            epService.EPRuntime.SendEvent(new SupportBeanDynRoot(null));
            Assert.AreEqual(null, listener.AssertOneGetNewAndReset().Get("t0"));

            epService.EPRuntime.SendEvent(new SupportBeanDynRoot("abc"));
            Assert.AreEqual(null, listener.AssertOneGetNewAndReset().Get("t0"));

            selectTestCase.Dispose();
        }
Example #23
0
        public void TestLeftOuterJoin_root_s0_OM()
        {
            EPStatementObjectModel model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.CreateWildcard();
            FromClause fromClause = FromClause.Create(
                FilterStream.Create(EVENT_S0, "s0").AddView("keepall"),
                FilterStream.Create(EVENT_S1, "s1").AddView("keepall"),
                FilterStream.Create(EVENT_S2, "s2").AddView("keepall"));

            fromClause.Add(OuterJoinQualifier.Create("s0.p00", OuterJoinType.LEFT, "s1.p10"));
            fromClause.Add(OuterJoinQualifier.Create("s0.p00", OuterJoinType.LEFT, "s2.p20"));
            model.FromClause = fromClause;
            model            = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);

            Assert.AreEqual("select * from " + typeof(SupportBean_S0).FullName + "#keepall as s0 left outer join " + typeof(SupportBean_S1).FullName + "#keepall as s1 on s0.p00 = s1.p10 left outer join " + typeof(SupportBean_S2).FullName + "#keepall as s2 on s0.p00 = s2.p20", model.ToEPL());
            EPStatement joinView = _epService.EPAdministrator.Create(model);

            joinView.AddListener(_updateListener);

            RunAsserts();
        }
        private void RunAssertionMinMax_OM(EPServiceProvider epService)
        {
            var model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.Create()
                                 .SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH)
                                 .Add("symbol")
                                 .Add(Expressions.Min("volume"), "minVol")
                                 .Add(Expressions.Max("volume"), "maxVol")
                                 .Add(Expressions.MinDistinct("volume"), "minDistVol")
                                 .Add(Expressions.MaxDistinct("volume"), "maxDistVol");
            model.FromClause  = FromClause.Create(FilterStream.Create(typeof(SupportMarketDataBean).FullName).AddView("length", Expressions.Constant(3)));
            model.WhereClause = Expressions.Or()
                                .Add(Expressions.Eq("symbol", "DELL"))
                                .Add(Expressions.Eq("symbol", "IBM"))
                                .Add(Expressions.Eq("symbol", "GE"));
            model.GroupByClause = GroupByClause.Create("symbol");
            model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);

            string epl = "select irstream symbol, " +
                         "min(volume) as minVol, " +
                         "max(volume) as maxVol, " +
                         "min(distinct volume) as minDistVol, " +
                         "max(distinct volume) as maxDistVol " +
                         "from " + typeof(SupportMarketDataBean).FullName + "#length(3) " +
                         "where symbol=\"DELL\" or symbol=\"IBM\" or symbol=\"GE\" " +
                         "group by symbol";

            Assert.AreEqual(epl, model.ToEPL());

            EPStatement stmt     = epService.EPAdministrator.Create(model);
            var         listener = new SupportUpdateListener();

            stmt.Events += listener.Update;

            TryAssertionMinMax(epService, listener, stmt);

            stmt.Dispose();
        }
Example #25
0
        private void RunAssertionUnfilteredStreamPrior_OM(EPServiceProvider epService)
        {
            var subquery = new EPStatementObjectModel();

            subquery.SelectClause = SelectClause.Create().Add(Expressions.Prior(0, "id"));
            subquery.FromClause   = FromClause.Create(
                FilterStream.Create("S1").AddView("length", Expressions.Constant(1000)));

            var model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.Create().Add(Expressions.Subquery(subquery), "idS1");
            model.FromClause   = FromClause.Create(FilterStream.Create("S0"));
            model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);

            string stmtText = "select (select prior(0,id) from S1#length(1000)) as idS1 from S0";

            Assert.AreEqual(stmtText, model.ToEPL());
            EPStatement stmt = epService.EPAdministrator.Create(model);

            RunUnfilteredStreamPrior(epService, stmt);
            stmt.Dispose();
        }
Example #26
0
        public void TestLeftOuterJoin_root_s0_OM()
        {
            EPStatementObjectModel model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.CreateWildcard();
            FromClause fromClause = FromClause.Create(
                FilterStream.Create(EVENT_S0, "s0").AddView("win", "keepall"),
                FilterStream.Create(EVENT_S1, "s1").AddView("win", "keepall"),
                FilterStream.Create(EVENT_S2, "s2").AddView("win", "keepall"));

            fromClause.Add(OuterJoinQualifier.Create("s0.P00", OuterJoinType.LEFT, "s1.p10"));
            fromClause.Add(OuterJoinQualifier.Create("s0.P00", OuterJoinType.LEFT, "s2.p20"));
            model.FromClause = fromClause;
            model            = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);

            Assert.AreEqual("select * from com.espertech.esper.support.bean.SupportBean_S0.win:keepall() as s0 left outer join com.espertech.esper.support.bean.SupportBean_S1.win:keepall() as s1 on s0.P00 = s1.p10 left outer join com.espertech.esper.support.bean.SupportBean_S2.win:keepall() as s2 on s0.P00 = s2.p20", model.ToEPL());
            EPStatement joinView = epService.EPAdministrator.Create(model);

            joinView.Events += updateListener.Update;

            RunAsserts();
        }
Example #27
0
            public void Run(RegressionEnvironment env)
            {
                var model = new EPStatementObjectModel();
                model.SelectClause = SelectClause.Create()
                    .SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH)
                    .Add("Symbol")
                    .Add(Expressions.CountStar(), "countAll")
                    .Add(Expressions.CountDistinct("Volume"), "countDistVol")
                    .Add(Expressions.Count("Volume"), "countVol");
                model.FromClause = FromClause
                    .Create(
                        FilterStream.Create(typeof(SupportMarketDataBean).Name)
                            .AddView("length", Expressions.Constant(3)));
                model.WhereClause = Expressions.Or()
                    .Add(Expressions.Eq("Symbol", "DELL"))
                    .Add(Expressions.Eq("Symbol", "IBM"))
                    .Add(Expressions.Eq("Symbol", "GE"));
                model.GroupByClause = GroupByClause.Create("Symbol");
                model = env.CopyMayFail(model);

                var epl = "select irstream Symbol, " +
                          "count(*) as countAll, " +
                          "count(distinct Volume) as countDistVol, " +
                          "count(Volume) as countVol" +
                          " from " +
                          typeof(SupportMarketDataBean).Name +
                          "#length(3) " +
                          "where Symbol=\"DELL\" or Symbol=\"IBM\" or Symbol=\"GE\" " +
                          "group by Symbol";
                Assert.That(model.ToEPL(), Is.EqualTo(epl));

                model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
                env.CompileDeploy(model).AddListener("s0");

                TryAssertionCount(env);

                env.UndeployAll();
            }
        public void TestObjectModelJoinAlias()
        {
            var model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.Create().AddStreamWildcard("s0").AddStreamWildcard("s1", "s1stream").AddWithAsProvidedName(
                "TheString", "sym");
            model.FromClause = FromClause.Create().Add(FilterStream.Create(typeof(SupportBean).FullName, "s0").AddView("win", "keepall")).Add(
                FilterStream.Create(typeof(SupportMarketDataBean).FullName, "s1").AddView(
                    "win", "keepall"));

            var selectTestView = _epService.EPAdministrator.Create(model);

            selectTestView.Events += _testListener.Update;

            var viewExpr = "select s0.*, s1.* as s1stream, TheString as sym from "
                           + typeof(SupportBean).FullName + ".win:keepall() as s0, "
                           + typeof(SupportMarketDataBean).FullName + ".win:keepall() as s1";

            Assert.AreEqual(viewExpr, model.ToEPL());
            var modelReverse = _epService.EPAdministrator.CompileEPL(
                model.ToEPL());

            Assert.AreEqual(viewExpr, modelReverse.ToEPL());

            var type = selectTestView.EventType;

            Assert.AreEqual(typeof(SupportMarketDataBean),
                            type.GetPropertyType("s1stream"));
            Assert.AreEqual(typeof(Pair <string, object>), type.UnderlyingType);

            SendBeanEvent("E1");
            Assert.IsFalse(_testListener.IsInvoked);

            Object theEvent = SendMarketEvent("E1");
            var    outevent = _testListener.AssertOneGetNewAndReset();

            Assert.AreSame(theEvent, outevent.Get("s1stream"));
        }
Example #29
0
        public void TestWherePreviousOM()
        {
            EPStatementObjectModel subquery = new EPStatementObjectModel();

            subquery.SelectClause = SelectClause.Create().Add(Expressions.Previous(1, "id"));
            subquery.FromClause   = FromClause.Create(FilterStream.Create("S1").AddView(View.Create("win", "length", Expressions.Constant(1000))));
            subquery.WhereClause  = Expressions.EqProperty("id", "s0.id");

            EPStatementObjectModel model = new EPStatementObjectModel();

            model.FromClause   = FromClause.Create(FilterStream.Create("S0", "s0"));
            model.SelectClause = SelectClause.Create().Add(Expressions.Subquery(subquery), "value");
            model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);

            String stmtText = "select (select prev(1,id) from S1.win:length(1000) where id=s0.id) as value from S0 as s0";

            Assert.AreEqual(stmtText, model.ToEPL());

            EPStatement stmt = _epService.EPAdministrator.Create(model);

            stmt.Events += _listener.Update;
            RunWherePrevious();
        }
Example #30
0
        private void RunAssertionLeftOuterJoin_root_s0_OM(EPServiceProvider epService)
        {
            var model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.CreateWildcard();
            FromClause fromClause = FromClause.Create(
                FilterStream.Create(EVENT_S0, "s0").AddView("keepall"),
                FilterStream.Create(EVENT_S1, "s1").AddView("keepall"),
                FilterStream.Create(EVENT_S2, "s2").AddView("keepall"));

            fromClause.Add(OuterJoinQualifier.Create("s0.p00", OuterJoinType.LEFT, "s1.p10"));
            fromClause.Add(OuterJoinQualifier.Create("s0.p00", OuterJoinType.LEFT, "s2.p20"));
            model.FromClause = fromClause;
            model            = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);

            Assert.AreEqual("select * from " + typeof(SupportBean_S0).FullName + "#keepall as s0 left outer join " + typeof(SupportBean_S1).FullName + "#keepall as s1 on s0.p00 = s1.p10 left outer join " + typeof(SupportBean_S2).FullName + "#keepall as s2 on s0.p00 = s2.p20", model.ToEPL());
            EPStatement stmt     = epService.EPAdministrator.Create(model);
            var         listener = new SupportUpdateListener();

            stmt.Events += listener.Update;

            TryAssertion(epService, listener);
        }
Example #31
0
        public void TestInSelectOM()
        {
            EPStatementObjectModel subquery = new EPStatementObjectModel();

            subquery.SelectClause = SelectClause.Create("id");
            subquery.FromClause   = FromClause.Create(FilterStream.Create("S1").AddView(View.Create("length", Expressions.Constant(1000))));

            EPStatementObjectModel model = new EPStatementObjectModel();

            model.FromClause   = FromClause.Create(FilterStream.Create("S0"));
            model.SelectClause = SelectClause.Create().Add(Expressions.SubqueryIn("id", subquery), "value");
            model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);

            String stmtText = "select id in (select id from S1#length(1000)) as value from S0";

            Assert.AreEqual(stmtText, model.ToEPL());

            EPStatement stmt = _epService.EPAdministrator.Create(model);

            stmt.Events += _listener.Update;

            RunTestInSelect();
        }
Example #32
0
        public Task Invoke(IDictionary<string, object> env)
        {
            Request request = new Request(env);
            Response response = new Response(env);
            Stream orriginalStream = response.OutputStream;
            TriggerStream triggerStream = new TriggerStream(orriginalStream);
            response.OutputStream = triggerStream;
            FilterStream filterStream = null;
            bool finalizeHeadersExecuted = false;

            Action finalizeHeaders = () =>
            {
                finalizeHeadersExecuted = true;
                if (IsStatusWithNoNoEntityBody(response.StatusCode)
                    || response.Headers.ContainsKey("Content-Length")
                    || response.Headers.ContainsKey("Transfer-Encoding"))
                {
                    return;
                }

                // Buffer
                response.Headers.SetHeader("Transfer-Encoding", "chunked");

                if ("HEAD".Equals(request.Method, StringComparison.OrdinalIgnoreCase))
                {
                    // Someone tried to write a body for a HEAD request. Suppress it.
                    triggerStream.InnerStream = Stream.Null;
                }
                else
                {
                    filterStream = new FilterStream(orriginalStream, OnWriteFilter);
                    triggerStream.InnerStream = filterStream;
                }
            };

            // Hook first write
            triggerStream.OnFirstWrite = finalizeHeaders;
            env[OwinConstants.ResponseBody] = triggerStream;

            // Hook SendFileFunc
            SendFileFunc sendFile = env.Get<SendFileFunc>("sendfile.Func");
            if (sendFile != null)
            {
                SendFileFunc sendFileChunked = (name, offset, count) =>
                {
                    if (!finalizeHeadersExecuted)
                    {
                        finalizeHeaders();
                    }

                    if (filterStream == null)
                    {
                        // Due to headers we are not doing chunked, just pass through.
                        return sendFile(name, offset, count);
                    }

                    count = count ?? new FileInfo(name).Length - offset;

                    // Insert chunking around the file body
                    ArraySegment<byte> prefix = ChunkPrefix((uint)count);
                    return orriginalStream.WriteAsync(prefix.Array, prefix.Offset, prefix.Count)
                        .Then(() => orriginalStream.FlushAsync()) // Flush to ensure the data hits the wire before sendFile.
                        .Then(() => sendFile(name, offset, count))
                        .Then(() => orriginalStream.WriteAsync(EndOfChunk.Array, EndOfChunk.Offset, EndOfChunk.Count));
                };
                env["sendfile.Func"] = sendFileChunked;
            }

            return nextApp(env).Then(() =>
            {
                if (!finalizeHeadersExecuted)
                {
                    finalizeHeaders();
                }

                if (filterStream != null)
                {
                    // Write the chunked terminator
                    return orriginalStream.WriteAsync(FinalChunk.Array, FinalChunk.Offset, FinalChunk.Count);
                }

                return TaskHelpers.Completed();
            });
        }