示例#1
0
        public void TestAliasesAggregationOM()
        {
            var model = new EPStatementObjectModel();

            model.SelectClause      = SelectClause.Create("Symbol", "Volume").Add(Expressions.Sum("Price"), "mySum");
            model.FromClause        = FromClause.Create(FilterStream.Create(typeof(SupportMarketDataBean).FullName).AddView(View.Create("length", Expressions.Constant(20))));
            model.GroupByClause     = GroupByClause.Create("Symbol");
            model.OutputLimitClause = OutputLimitClause.Create(6);
            model.OrderByClause     = OrderByClause.Create(Expressions.Sum("Price")).Add("Symbol", false);
            model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);

            var statementString = "select Symbol, Volume, sum(Price) as mySum from " +
                                  typeof(SupportMarketDataBean).FullName + "#length(20) " +
                                  "group by Symbol " +
                                  "output every 6 events " +
                                  "order by sum(Price), Symbol";

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

            _testListener = new SupportUpdateListener();
            var statement = _epService.EPAdministrator.Create(model);

            statement.AddListener(_testListener);

            RunAssertionDefault();
        }
示例#2
0
        public void TestCloneGroupByClause()
        {
            GroupByClause groupByClause = new GroupByClause()
            {
                Groups = new List <GroupBy.Group>()
                {
                    new ExpressionGroup()
                    {
                        Expression = new ColumnReference()
                        {
                            Identifiers = new List <string>()
                            {
                                "c1"
                            }
                        }
                    }
                }
            };

            var clone = groupByClause.Clone() as GroupByClause;

            Assert.AreEqual(groupByClause, clone);
            Assert.IsFalse(ReferenceEquals(groupByClause, clone));
            Assert.IsFalse(ReferenceEquals(groupByClause.Groups, clone.Groups));

            for (int i = 0; i < groupByClause.Groups.Count; i++)
            {
                Assert.IsFalse(ReferenceEquals(groupByClause.Groups[i], clone.Groups[i]));
            }
        }
示例#3
0
            public void Run(RegressionEnvironment env)
            {
                var model = new EPStatementObjectModel();
                model.SelectClause = SelectClause.Create("Symbol", "Volume").Add(Expressions.Sum("Price"), "mySum");
                model.FromClause = FromClause.Create(
                    FilterStream.Create(typeof(SupportMarketDataBean).Name)
                        .AddView(View.Create("length", Expressions.Constant(20))));
                model.GroupByClause = GroupByClause.Create("Symbol");
                model.OutputLimitClause = OutputLimitClause.Create(6);
                model.OrderByClause = OrderByClause.Create(Expressions.Sum("Price")).Add("Symbol", false);
                model = env.CopyMayFail(model);

                var epl = "select Symbol, Volume, sum(Price) as mySum from " +
                          "SupportMarketDataBean#length(20) " +
                          "group by Symbol " +
                          "output every 6 events " +
                          "order by sum(Price), Symbol";
                Assert.AreEqual(epl, model.ToEPL());

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

                TryAssertionDefault(env);

                env.UndeployAll();
            }
示例#4
0
        public void TestGroupByTwo()
        {
            var actual = new GroupByClause()
            {
                Groups = new List <GroupBy.Group>()
                {
                    new ExpressionGroup()
                    {
                        Expression = new ColumnReference()
                        {
                            Identifiers = new List <string>()
                            {
                                "c1"
                            }
                        }
                    },
                    new ExpressionGroup()
                    {
                        Expression = new ColumnReference()
                        {
                            Identifiers = new List <string>()
                            {
                                "c2"
                            }
                        }
                    }
                }
            }.Print();
            var expected = "GROUP BY c1, c2";

            actual.Should().Be(expected);
        }
示例#5
0
        public override void AcceptChildren(WSqlFragmentVisitor visitor)
        {
            if (FromClause != null)
            {
                FromClause.Accept(visitor);
            }
            if (WhereClause != null)
            {
                WhereClause.Accept(visitor);
            }
            if (TopRowFilter != null)
            {
                TopRowFilter.Accept(visitor);
            }
            if (GroupByClause != null)
            {
                GroupByClause.Accept(visitor);
            }
            if (HavingClause != null)
            {
                HavingClause.Accept(visitor);
            }

            if (SelectElements != null)
            {
                var index = 0;
                for (var count = SelectElements.Count; index < count; ++index)
                {
                    SelectElements[index].Accept(visitor);
                }
            }

            base.AcceptChildren(visitor);
        }
示例#6
0
        private void RunAssertionAliasesAggregationOM(EPServiceProvider epService)
        {
            var model = new EPStatementObjectModel();

            model.SelectClause      = SelectClause.Create("symbol", "volume").Add(Expressions.Sum("price"), "mySum");
            model.FromClause        = FromClause.Create(FilterStream.Create(typeof(SupportMarketDataBean).FullName).AddView(View.Create("length", Expressions.Constant(20))));
            model.GroupByClause     = GroupByClause.Create("symbol");
            model.OutputLimitClause = OutputLimitClause.Create(6);
            model.OrderByClause     = OrderByClause.Create(Expressions.Sum("price")).Add("symbol", false);
            model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);

            string statementString = "select symbol, volume, sum(price) as mySum from " +
                                     typeof(SupportMarketDataBean).FullName + "#length(20) " +
                                     "group by symbol " +
                                     "output every 6 events " +
                                     "order by sum(price), symbol";

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

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

            statement.Events += testListener.Update;

            TryAssertionDefault(epService, testListener);

            statement.Dispose();
        }
        public void CreateGroupByClause()
        {
            Column        column        = new Column("Column1");
            GroupByClause groupByClause = new GroupByClause(column);

            Assert.AreEqual(column, groupByClause.Column);
        }
示例#8
0
        public void TestCountOneViewOM()
        {
            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).FullName).AddView("win", "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(model);

            var viewExpr = "select irstream Symbol, " +
                           "count(*) as countAll, " +
                           "count(distinct volume) as countDistVol, " +
                           "count(volume) as countVol" +
                           " from " + typeof(SupportMarketDataBean).FullName + ".win:length(3) " +
                           "where Symbol=\"DELL\" or Symbol=\"IBM\" or Symbol=\"GE\" " +
                           "group by Symbol";

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

            _selectTestView = _epService.EPAdministrator.Create(model);
            _selectTestView.AddListener(_testListener);

            RunAssertion();
        }
示例#9
0
			public void Run(RegressionEnvironment env)
			{
				string textOne = "@Name('s0') select irstream CONCATSTRING(TheString) as val from SupportBean#length(10) group by IntPrimitive";
				TryGrouped(env, textOne, null);

				string textTwo = "@Name('s0') select irstream concatstring(TheString) as val from SupportBean#win:length(10) group by IntPrimitive";
				TryGrouped(env, textTwo, null);

				string textThree = "@Name('s0') select irstream concatstring(TheString) as val from SupportBean#length(10) group by IntPrimitive";
				EPStatementObjectModel model = env.EplToModel(textThree);
				SerializableObjectCopier.CopyMayFail(env.Container, model);
				Assert.AreEqual(textThree, model.ToEPL());
				TryGrouped(env, null, model);

				string textFour = "select irstream concatstring(TheString) as val from SupportBean#length(10) group by IntPrimitive";
				EPStatementObjectModel modelTwo = new EPStatementObjectModel();
				modelTwo.SelectClause = SelectClause
					.Create(StreamSelector.RSTREAM_ISTREAM_BOTH)
					.Add(Expressions.PlugInAggregation("concatstring", Expressions.Property("TheString")), "val");
				modelTwo.FromClause = FromClause.Create(FilterStream.Create("SupportBean").AddView(null, "length", Expressions.Constant(10)));
				modelTwo.GroupByClause = GroupByClause.Create("IntPrimitive");
				Assert.AreEqual(textFour, modelTwo.ToEPL());
				SerializableObjectCopier.CopyMayFail(env.Container, modelTwo);
				modelTwo.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
				TryGrouped(env, null, modelTwo);

				env.UndeployAll();
			}
示例#10
0
        public void RenderOrderByClause()
        {
            Column        column        = new Column("Column1");
            GroupByClause groupByClause = new GroupByClause(column);

            Assert.AreEqual("[Column1]", sqlClientRenderer.Render(groupByClause));
        }
示例#11
0
 internal GroupBy(SelectClause select, FromClause from, TimeSpan timeInterval, WhereClause where = null)
 {
     this.select  = select;
     this.from    = from;
     this.where   = where;
     this.groupBy = new GroupByClause(new DurationLiteral(timeInterval), new MeasurementTag[0]);
 }
示例#12
0
        public string ReBuild(bool reparse)
        {
            string sql = "SELECT \r\n\t";

            for (int i = 0; i < SelectList.Count; i++)
            {
                sql += SelectList[i];
                if (AsList[i] != null && !string.IsNullOrEmpty(AsList[i]))
                {
                    sql += " \tAS " + "\"" + AsList[i] + "\"";
                }
                if (i < SelectList.Count - 1)
                {
                    sql += ",\r\n\t";
                }
            }
            sql += "\r\n";

            sql += " FROM " + FromClause.TrimEnd() + "\r\n";
#if WHAT_WRONG
            if (string.IsNullOrEmpty(WhereClause) == false)
            {
                sql += " WHERE " + WhereClause.Trim() + "\r\n";
            }

            string groupby = GroupByClause.Trim().ToString();
            if (!string.IsNullOrEmpty(groupby))
            {
                sql += " GROUP BY " + groupby.TrimEnd() + "\r\n";
            }

            string orderby = OrderByClause.Trim().ToString();
            if (!string.IsNullOrEmpty(orderby))
            {
                sql += " ORDER BY " + orderby.TrimEnd() + "\r\n";
            }
            if (reparse)
            {
                Parse(sql);
            }
            return(sql.TrimEnd());
#else
            sql += " WHERE " + WhereClause.TrimEnd() + "\r\n";
            string groupby = GroupByClause.ToString();
            if (!string.IsNullOrEmpty(groupby))
            {
                sql += " GROUP BY " + groupby.TrimEnd() + "\r\n";
            }
            string orderby = OrderByClause.ToString();
            if (!string.IsNullOrEmpty(orderby))
            {
                sql += " ORDER BY " + orderby.TrimEnd() + "\r\n";
            }
            if (reparse)
            {
                Parse(sql);
            }
            return(sql.TrimEnd());
#endif
        }
示例#13
0
        public void TestGrouped()
        {
            var textOne = "select irstream CONCATSTRING(TheString) as val from " + typeof(SupportBean).FullName + "#length(10) group by IntPrimitive";

            TryGrouped(textOne, null);

            var textTwo = "select irstream concatstring(TheString) as val from " + typeof(SupportBean).FullName + "#win:length(10) group by IntPrimitive";

            TryGrouped(textTwo, null);

            var textThree = "select irstream concatstring(TheString) as val from " + typeof(SupportBean).FullName + "#length(10) group by IntPrimitive";
            var model     = _epService.EPAdministrator.CompileEPL(textThree);

            SerializableObjectCopier.Copy(model);
            Assert.AreEqual(textThree, model.ToEPL());
            TryGrouped(null, model);

            var textFour = "select irstream concatstring(TheString) as val from " + typeof(SupportBean).FullName + "#length(10) group by IntPrimitive";
            var modelTwo = new EPStatementObjectModel();

            modelTwo.SelectClause = SelectClause.Create().SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH)
                                    .Add(Expressions.PlugInAggregation("concatstring", Expressions.Property("TheString")), "val");
            modelTwo.FromClause    = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName).AddView(null, "length", Expressions.Constant(10)));
            modelTwo.GroupByClause = GroupByClause.Create("IntPrimitive");
            Assert.AreEqual(textFour, modelTwo.ToEPL());
            SerializableObjectCopier.Copy(modelTwo);
            TryGrouped(null, modelTwo);

            var textFive = "select irstream concatstringTwo(TheString) as val from " + typeof(SupportBean).FullName + "#length(10) group by IntPrimitive";

            TryGrouped(textFive, null);
        }
示例#14
0
        public void TestMinMaxView_OM()
        {
            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("win", "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(model);

            String viewExpr = "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 + ".win:length(3) " +
                              "where Symbol=\"DELL\" or Symbol=\"IBM\" or Symbol=\"GE\" " +
                              "group by Symbol";

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

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

            selectTestView.Events += _testListener.Update;

            RunAssertion(selectTestView);
        }
示例#15
0
        public void TestGroupByClauseAccept()
        {
            Mock <KoraliumSqlVisitor> mock          = new Mock <KoraliumSqlVisitor>();
            GroupByClause             groupByClause = new GroupByClause();

            groupByClause.Accept(mock.Object);
            mock.Verify(x => x.VisitGroupByClause(groupByClause));
        }
示例#16
0
        public override string Render(GroupByClause groupByClause)
        {
            StringBuilder text = new StringBuilder();

            text.AppendFormat("{0} ", groupByClause.Column.Render(this));

            return(text.ToString().Trim());
        }
 public Query()
 {
     _selectClause  = new SelectClause(this);
     _fromClause    = new FromClause(this);
     _whereClause   = new FilterClause(this, AbstractQueryClause <FilterItem> .PREFIX_WHERE);
     _groupByClause = new GroupByClause(this);
     _havingClause  = new FilterClause(this, AbstractQueryClause <FilterItem> .PREFIX_HAVING);
     _orderByClause = new OrderByClause(this);
 } // constructor
 public GroupByClause <TEntity> GroupBy()
 {
     if (GroupByClause == null)
     {
         GroupByClause = new GroupByClause <TEntity>(_builder);
     }
     GroupByClause.Init();
     return(GroupByClause);
 }
示例#19
0
        public void RenderGroupByClauses()
        {
            Column         column1        = new Column("Column1");
            Column         column2        = new Column("Column2");
            GroupByClause  groupByClause1 = new GroupByClause(column1);
            GroupByClause  groupByClause2 = new GroupByClause(column2);
            GroupByClauses groupByClauses = new GroupByClauses(groupByClause1, groupByClause2);

            Assert.AreEqual("[Column1], [Column2]", sqlClientRenderer.Render(groupByClauses));
        }
示例#20
0
        public void GroupByClause(string result, params string[] exprs)
        {
            var clause = new GroupByClause(exprs);

            var sql = clause.ToString();

            Output.WriteLine(sql);

            sql.ShouldBeEquivalentTo(result);
        }
示例#21
0
 /// <summary>
 /// 创建Sql语句
 /// </summary>
 protected virtual void CreateSql(StringBuilder result)
 {
     AppendSelect(result);
     AppendFrom(result);
     AppendSql(result, JoinClause.ToSql());
     AppendSql(result, GetWhere());
     AppendSql(result, GroupByClause.ToSql());
     AppendSql(result, OrderByClause.ToSql());
     AppendLimit(result);
 }
 /// <summary>
 /// 创建Sql语句
 /// </summary>
 protected void CreateSqlByNoUnion(StringBuilder result)
 {
     AppendSelect(result);
     AppendFrom(result);
     AppendSql(result, JoinClause.ToSql());
     AppendSql(result, WhereClause.ToSql());
     AppendSql(result, GroupByClause.ToSql());
     AppendSql(result, OrderByClause.ToSql());
     AppendLimit(result);
 }
示例#23
0
        public override object VisitGroupByClause([NotNull] PostgresParser.GroupByClauseContext context)
        {
            var res = new GroupByClause();

            foreach (var groupByItem in context.groupByItem())
            {
                res.GroupColumns.Add((ColumnRef)Visit(groupByItem));
            }
            return(res);
        }
示例#24
0
        public void CreateOrderByClauses()
        {
            Column         column1        = new Column("Column1");
            Column         column2        = new Column("Column2");
            GroupByClause  groupByClause1 = new GroupByClause(column1);
            GroupByClause  groupByClause2 = new GroupByClause(column2);
            GroupByClauses groupByClauses = new GroupByClauses(groupByClause1, groupByClause2);

            Assert.AreEqual(groupByClause1, groupByClauses.LeftClause);
            Assert.AreEqual(groupByClause2, groupByClauses.RightClause);
        }
示例#25
0
        public SelectQuery()
        {
            SourceID = Interlocked.Increment(ref SourceIDCounter);

            Select  = new SelectClause(this);
            From    = new FromClause(this);
            Where   = new WhereClause(this);
            GroupBy = new GroupByClause(this);
            Having  = new WhereClause(this);
            OrderBy = new OrderByClause(this);
        }
示例#26
0
 protected PostgresQueryBase(IServiceProvider serviceProvider)
     : base(serviceProvider)
 {
     fromClause    = serviceProvider.GetRequiredService <FromClause>();
     joinClause    = serviceProvider.GetRequiredService <JoinClause>();
     whereClause   = serviceProvider.GetRequiredService <WhereClause>();
     groupByClause = serviceProvider.GetRequiredService <GroupByClause>();
     havingClause  = serviceProvider.GetRequiredService <HavingClause>();
     unionClause   = serviceProvider.GetRequiredService <UnionClause>();
     orderByClause = serviceProvider.GetRequiredService <OrderByClause>();
 }
示例#27
0
 public LambdaQueryBuilder(ILambdaResolver parser, INameResolver nameResolver)
 {
     _parser       = parser;
     _nameResolver = nameResolver;
     _select       = new SelectClause();
     _from         = new FromClause();
     _where        = new PredicateClause();
     _groupBy      = new GroupByClause();
     _having       = new PredicateClause();
     _orderBy      = new OrderByClause();
 }
示例#28
0
 public SqlServerQueryBase(IServiceProvider serviceProvider)
     : base(serviceProvider)
 {
     fromClause    = serviceProvider.GetRequiredService <FromClause>();
     joinClause    = serviceProvider.GetRequiredService <JoinClause>();
     whereClause   = serviceProvider.GetRequiredService <WhereClause>();
     groupByClause = serviceProvider.GetRequiredService <GroupByClause>();
     havingClause  = serviceProvider.GetRequiredService <HavingClause>();
     unionClause   = serviceProvider.GetRequiredService <UnionClause>();
     orderByClause = serviceProvider.GetRequiredService <OrderByClause>();
     forClause     = serviceProvider.GetRequiredService <SqlServerForClause>();
 }
        private void RunAssertionStmtJoin_OM(EPServiceProvider epService)
        {
            var model = new EPStatementObjectModel();

            model.SelectClause = SelectClause.Create("symbol")
                                 .Add(Expressions.Median("price"), "myMedian")
                                 .Add(Expressions.MedianDistinct("price"), "myDistMedian")
                                 .Add(Expressions.Stddev("price"), "myStdev")
                                 .Add(Expressions.Avedev("price"), "myAvedev")
                                 .SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH);

            FromClause fromClause = FromClause.Create(
                FilterStream.Create(typeof(SupportBeanString).FullName, "one").AddView(View.Create("length", Expressions.Constant(100))),
                FilterStream.Create(typeof(SupportMarketDataBean).FullName, "two").AddView(View.Create("length", Expressions.Constant(5))));

            model.FromClause  = fromClause;
            model.WhereClause = Expressions.And().Add(
                Expressions.Or()
                .Add(Expressions.Eq("symbol", "DELL"))
                .Add(Expressions.Eq("symbol", "IBM"))
                .Add(Expressions.Eq("symbol", "GE"))
                )
                                .Add(Expressions.EqProperty("one.TheString", "two.symbol"));

            model.GroupByClause = GroupByClause.Create("symbol");
            model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);

            string epl = "select irstream symbol, " +
                         "median(price) as myMedian, " +
                         "median(distinct price) as myDistMedian, " +
                         "stddev(price) as myStdev, " +
                         "avedev(price) as myAvedev " +
                         "from " + typeof(SupportBeanString).FullName + "#length(100) as one, " +
                         typeof(SupportMarketDataBean).FullName + "#length(5) as two " +
                         "where (symbol=\"DELL\" or symbol=\"IBM\" or symbol=\"GE\") " +
                         "and one.TheString=two.symbol " +
                         "group by symbol";

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

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

            stmt.Events += listener.Update;

            epService.EPRuntime.SendEvent(new SupportBeanString(SYMBOL_DELL));
            epService.EPRuntime.SendEvent(new SupportBeanString(SYMBOL_IBM));
            epService.EPRuntime.SendEvent(new SupportBeanString("AAA"));

            TryAssertionStmt(epService, listener, stmt);

            stmt.Dispose();
        }
示例#30
0
            public void Run(RegressionEnvironment env)
            {
                var model = new EPStatementObjectModel();
                model.SelectClause = SelectClause.Create("Symbol")
                    .Add(Expressions.Median("Price"), "myMedian")
                    .Add(Expressions.MedianDistinct("Price"), "myDistMedian")
                    .Add(Expressions.Stddev("Price"), "myStdev")
                    .Add(Expressions.Avedev("Price"), "myAvedev")
                    .SetStreamSelector(StreamSelector.RSTREAM_ISTREAM_BOTH);

                var fromClause = FromClause.Create(
                    FilterStream
                        .Create(typeof(SupportBeanString).Name, "one")
                        .AddView(View.Create("length", Expressions.Constant(100))),
                    FilterStream
                        .Create(typeof(SupportMarketDataBean).Name, "two")
                        .AddView(View.Create("length", Expressions.Constant(5))));
                model.FromClause = fromClause;
                model.WhereClause = Expressions.And()
                    .Add(
                        Expressions.Or()
                            .Add(Expressions.Eq("Symbol", "DELL"))
                            .Add(Expressions.Eq("Symbol", "IBM"))
                            .Add(Expressions.Eq("Symbol", "GE"))
                    )
                    .Add(Expressions.EqProperty("one.TheString", "two.Symbol"));
                model.GroupByClause = GroupByClause.Create("Symbol");
                model = env.CopyMayFail(model);

                var epl = "select irstream Symbol, " +
                          "median(Price) as myMedian, " +
                          "median(distinct Price) as myDistMedian, " +
                          "stddev(Price) as myStdev, " +
                          "avedev(Price) as myAvedev " +
                          "from SupportBeanString#length(100) as one, " +
                          "SupportMarketDataBean#length(5) as two " +
                          "where (Symbol=\"DELL\" or Symbol=\"IBM\" or Symbol=\"GE\") " +
                          "and one.TheString=two.Symbol " +
                          "group by Symbol";
                Assert.AreEqual(epl, model.ToEPL());

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

                env.SendEventBean(new SupportBeanString(SYMBOL_DELL));
                env.SendEventBean(new SupportBeanString(SYMBOL_IBM));
                env.SendEventBean(new SupportBeanString("AAA"));

                TryAssertionStmt(env, new AtomicLong());

                env.UndeployAll();
            }
示例#31
0
 /// <summary>
 /// Initializes a query expression ast node.
 /// </summary>
 /// <param name="selectClause">select clause</param>
 /// <param name="fromClause">from clasuse</param>
 /// <param name="whereClause">optional where clause</param>
 /// <param name="groupByClause">optional group by clause</param>
 /// <param name="havingClause">optional having clause</param>
 /// <param name="orderByClause">optional order by clause</param>
 internal QueryExpr(
     SelectClause selectClause,
     FromClause fromClause,
     Node whereClause,
     GroupByClause groupByClause,
     HavingClause havingClause,
     OrderByClause orderByClause)
 {
     _selectClause = selectClause;
     _fromClause = fromClause;
     _whereClause = whereClause;
     _groupByClause = groupByClause;
     _havingClause = havingClause;
     _orderByClause = orderByClause;
 }
示例#32
0
        private WGroupByClause ParseGroupbyClause(GroupByClause groupbyExpr)
        {
            if (groupbyExpr == null)
            {
                return null;
            }

            var wgc = new WGroupByClause
            {
                FirstTokenIndex = groupbyExpr.FirstTokenIndex,
                LastTokenIndex = groupbyExpr.LastTokenIndex,
                GroupingSpecifications = new List<WGroupingSpecification>(groupbyExpr.GroupingSpecifications.Count)
            };

            foreach (var gs in groupbyExpr.GroupingSpecifications)
            {
                //if (!(gs is ExpressionGroupingSpecification))
                //    continue;
                var egs = gs as ExpressionGroupingSpecification;
                if (egs == null) continue;
                var pspec = new WExpressionGroupingSpec
                {
                    Expression = ParseScalarExpression(egs.Expression),
                    FirstTokenIndex = egs.FirstTokenIndex,
                    LastTokenIndex = egs.LastTokenIndex,
                };

                wgc.GroupingSpecifications.Add(pspec);
            }

            return wgc;
        }
 public override void ExplicitVisit(GroupByClause fragment)
 {
     _fragments.Add(fragment);
 }
示例#34
0
		protected virtual string GetClauseSql (GroupByClause clause)
		{
			throw new NotImplementedException ();
		}
示例#35
0
 public override void Visit(GroupByClause node) { this.action(node); }