public TableSelectExpression()
{
Columns = new List<SelectColumn>();
CompositeFunction = CompositeFunction.None;
Into = new SelectIntoClause();
From = new FromClause();
GroupBy = new List<ByColumn>();
}
public SelectStatement (FromClause from)
{
if (from == null)
throw new ArgumentNullException ("from");
From = from;
this.columns = new List<IdentifierExpression> ();
this.columns.Add (new IdentifierExpression ());
}
public void Visit(FromClause from_clause)
{
_Query.Append("FROM ");
foreach(TableSource table in from_clause)
{
table.Accept(this);
if ( from_clause.IndexOf(table) != from_clause.Count - 1 )
_Query.Append(", ");
}
}
public SelectStatement (FromClause from, IEnumerable<IdentifierExpression> columns)
{
if (from == null)
throw new ArgumentNullException ("from");
if (columns == null)
throw new ArgumentNullException ("columns");
From = from;
this.columns = new List<IdentifierExpression> ();
this.columns.AddRange (columns);
}
/// <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;
}
static void Main(string[] args)
{
SqlQuery query = new SqlQuery();
var select = new SelectClause().AddColumns("NodeId", "DocumentId", "DocumentName");
var from = new FromClause().AddReference("View_CMS_Tree_Joined");
var where = new WhereClause();
query.AppendRange(select, from);
Console.WriteLine(query.Evaluate());
Console.WriteLine();
Console.ReadKey();
}
private static void SetManyToManyFrom(ObjectInfo oi, string unmappedMainTableName, IEnumerable <MemberHandler> fields)
{
foreach (MemberHandler member in fields)
{
if (member.Is.HasAndBelongsToMany)
{
var modelType = member.MemberType.GetGenericArguments()[0];
var fromClause = GetObjectFromClause(modelType);
var mainOriginTableName = fromClause.MainModelName;
var name = GetCrossTableName(member, unmappedMainTableName, mainOriginTableName);
var fkMainOriginTableName = mainOriginTableName + "_Id";
var from = new FromClause(new[] { new JoinClause(name, fkMainOriginTableName, fromClause.MainTableName, "Id", CompareOpration.Equal, JoinMode.Inner) });
var handleType = member.MemberType.GetGenericArguments()[0];
oi.CrossTables[handleType] = new CrossTable(handleType, from, name,
oi.From.MainTableName, unmappedMainTableName + "_Id", fromClause.MainTableName, fkMainOriginTableName);
}
}
}
/// <summary>
/// Creates a query view from the service provider.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="stream">The stream.</param>
/// <param name="asName">The name of the stream.</param>
/// <returns></returns>
public static EsperQuery <T> FromStreamAs <T>(
this EPServiceProvider serviceProvider,
string stream,
string asName)
{
var selectClause = SelectClause.Create();
selectClause.AddWildcard();
var objectModel = new EPStatementObjectModel();
objectModel.SelectClause = selectClause;
objectModel.FromClause = FromClause.Create();
objectModel.FromClause.Add(FilterStream.Create(stream, asName));
objectModel.MakeIterableUnbound();
return(new EsperQuery <T>(serviceProvider, objectModel));
}
public void TestSingleParameterOM()
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().Add(Expressions.StaticMethod("com.espertech.esper.support.util.BitWriter", "Write", 7), "value");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportMarketDataBean).FullName).AddView("win", "length", Expressions.Constant(5)));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
_statementText = "select com.espertech.esper.support.util.BitWriter.Write(7) as value" + _stream;
Assert.AreEqual(_statementText.Trim(), model.ToEPL());
var statement = _epService.EPAdministrator.Create(model);
_listener = new SupportUpdateListener();
statement.Events += _listener.Update;
SendEvent("IBM", 10d, 4l);
Assert.AreEqual(BitWriter.Write(7), _listener.AssertOneGetNewAndReset().Get("value"));
}
public void Run(RegressionEnvironment env)
{
env.Runtime.VariableService.SetVariableValue(null, "var_output_limit", 3L);
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().Add(Expressions.CountStar(), "cnt");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).Name));
model.OutputLimitClause = OutputLimitClause.Create(OutputLimitSelector.LAST, "var_output_limit");
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
var stmtTextSelect =
"@Name('s0') select count(*) as cnt from SupportBean output last every var_output_limit events";
Assert.AreEqual(stmtTextSelect, model.ToEPL());
env.CompileDeploy(model, new RegressionPath()).AddListener("s0");
TryAssertionOutputRateEventsAll(env);
env.UndeployAll();
}
public void TestOutputRateEventsAll_OM()
{
_epService.EPAdministrator.Configuration.AddVariable("var_output_limit", typeof(long), "3");
EPStatementObjectModel 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);
stmtSelect.Events += _listener.Update;
Assert.AreEqual(stmtTextSelect, model.ToEPL());
RunAssertionOutputRateEventsAll();
}
public void Run(RegressionEnvironment env)
{
var stmtText = "select exists(item?.IntBoxed) as t0 from SupportMarkerInterface";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().Add(Expressions.ExistsProperty("item?.IntBoxed"), "t0");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportMarkerInterface).Name));
model = SerializableObjectCopier.GetInstance(env.Container).Copy(model);
Assert.AreEqual(stmtText, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
AssertStringAndNull(env);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("var1OM", "var2OM", "Id");
model.FromClause = FromClause.Create(FilterStream.Create("SupportBean_A"));
var path = new RegressionPath();
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model, path);
var stmtText = "@Name('s0') select var1OM, var2OM, Id from SupportBean_A";
Assert.AreEqual(stmtText, model.ToEPL());
env.AddListener("s0");
var fieldsSelect = new string[] { "var1OM", "var2OM", "Id" };
SendSupportBean_A(env, "E1");
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fieldsSelect, new object[] { 10d, 11L, "E1" });
model = new EPStatementObjectModel();
model.OnExpr = OnClause.CreateOnSet(Expressions.Eq(Expressions.Property("var1OM"), Expressions.Property("IntPrimitive")))
.AddAssignment(Expressions.Eq(Expressions.Property("var2OM"), Expressions.Property("IntBoxed")));
model.FromClause = FromClause.Create(FilterStream.Create(nameof(SupportBean)));
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("set"));
var stmtTextSet = "@Name('set') on SupportBean set var1OM=IntPrimitive, var2OM=IntBoxed";
env.CompileDeploy(model, path).AddListener("set");
Assert.AreEqual(stmtTextSet, model.ToEPL());
var typeSet = env.Statement("set").EventType;
Assert.AreEqual(typeof(double?), typeSet.GetPropertyType("var1OM"));
Assert.AreEqual(typeof(long?), typeSet.GetPropertyType("var2OM"));
Assert.AreEqual(typeof(IDictionary <string, object>), typeSet.UnderlyingType);
var fieldsVar = new string[] { "var1OM", "var2OM" };
EPAssertionUtil.AssertEqualsAnyOrder(fieldsVar, typeSet.PropertyNames);
EPAssertionUtil.AssertPropsPerRow(env.GetEnumerator("set"), fieldsVar, new object[][] { new object[] { 10d, 11L } });
SendSupportBean(env, "S1", 3, 4);
EPAssertionUtil.AssertProps(env.Listener("set").AssertOneGetNewAndReset(), fieldsVar, new object[] { 3d, 4L });
EPAssertionUtil.AssertPropsPerRow(env.GetEnumerator("set"), fieldsVar, new object[][] { new object[] { 3d, 4L } });
SendSupportBean_A(env, "E2");
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fieldsSelect, new object[] { 3d, 4L, "E2" });
env.UndeployModuleContaining("set");
env.UndeployModuleContaining("s0");
}
public void TestDirectNumberOfEvents()
{
var stmtText = "select TheString from SupportBean.win:keepall() output after 3 events";
var stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.AddListener(_listener);
SendEvent("E1");
SendEvent("E2");
SendEvent("E3");
Assert.IsFalse(_listener.IsInvoked);
SendEvent("E4");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), _fields, new object[] { "E4" });
SendEvent("E5");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), _fields, new object[] { "E5" });
stmt.Dispose();
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("TheString");
model.FromClause = FromClause.Create(FilterStream.Create("SupportBean").AddView("win", "keepall"));
model.OutputLimitClause = OutputLimitClause.CreateAfter(3);
Assert.AreEqual("select TheString from SupportBean.win:keepall() output after 3 events ", model.ToEPL());
stmt = _epService.EPAdministrator.Create(model);
stmt.AddListener(_listener);
SendEvent("E1");
SendEvent("E2");
SendEvent("E3");
Assert.IsFalse(_listener.IsInvoked);
SendEvent("E4");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), _fields, new object[] { "E4" });
SendEvent("E5");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), _fields, new object[] { "E5" });
model = _epService.EPAdministrator.CompileEPL("select TheString from SupportBean.win:keepall() output after 3 events");
Assert.AreEqual("select TheString from SupportBean.win:keepall() output after 3 events ", model.ToEPL());
}
public void TestOp()
{
var events = EventCollectionFactory.GetEventSetOne(0, 1000);
var testCaseList = new CaseList();
var testCase = new EventExpressionCase("a=A -> (every b=B) while(b.Id != 'B2')");
testCase.Add("B1", "a", events.GetEvent("A1"), "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("a=A -> (every b=B) while(b.Id != 'B3')");
testCase.Add("B1", "a", events.GetEvent("A1"), "b", events.GetEvent("B1"));
testCase.Add("B2", "a", events.GetEvent("A1"), "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=B) while(b.Id != 'B3')");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
String text = "select * from pattern [(every b=" + EVENT_B_CLASS + ") while (b.Id!=\"B3\")]";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Expression guardExpr = Expressions.Neq("b.Id", "B3");
PatternExpr every = Patterns.Every(Patterns.Filter(Filter.Create(EVENT_B_CLASS), "b"));
PatternExpr patternGuarded = Patterns.WhileGuard(every, guardExpr);
model.FromClause = FromClause.Create(PatternStream.Create(patternGuarded));
Assert.AreEqual(text, model.ToEPL());
testCase = new EventExpressionCase(model);
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=B) while(b.Id != 'B1')");
testCaseList.AddTest(testCase);
var util = new PatternTestHarness(events, testCaseList, GetType(), GetType().FullName);
util.RunTest();
}
/// <summary>
/// Generates the SQL text for the whole query.
/// </summary>
/// <param name="sb">The SQL text formatter.</param>
public void RenderSql(SqlBuilderContext sb)
{
SelectClause.RenderSql(sb);
FromClause.RenderSql(sb);
WhereClause.RenderSql(sb, this);
GroupByClause.RenderSql(sb);
HavingClause.RenderSql(sb);
OrderClause.RenderSql(sb);
if (!string.IsNullOrEmpty(ForClause))
{
sb.AppendOnNewLine(ForClause);
}
}
/// <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 (int ii = 0; ii < streamNames.Length; ii++)
{
objectModel.FromClause.Add(FilterStream.Create(streamNames[ii]));
}
return(new EsperQuery <T>(serviceProvider, objectModel));
}
public void TestVariantOneOMToStmt()
{
var model = new EPStatementObjectModel();
model.InsertInto = InsertIntoClause.Create("Event_1", "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("win", "length", Expressions.Constant(100))));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
var stmt = RunAsserts(null, model);
var epl = "insert into Event_1(delta, product) " +
"select IntPrimitive-IntBoxed as deltaTag, IntPrimitive*IntBoxed as productTag " +
"from " + typeof(SupportBean).FullName + ".win:length(100)";
Assert.AreEqual(epl, model.ToEPL());
Assert.AreEqual(epl, stmt.Text);
}
public void HiveQueryCacheKeyToFromJson()
{
var guid = Guid.NewGuid();
var guid2 = Guid.NewGuid();
var guid3 = Guid.NewGuid();
var resultFilterClause = new ResultFilterClause(typeof(string), ResultFilterType.Any, 0);
var hiveId = new HiveId(guid);
var expected = new HiveId(guid2);
var fullHiveId = new HiveId(new Uri("content://blah/"), "nhibernate", new HiveIdValue(guid3));
var scopeStartId = new HiveId(Guid.NewGuid());
var fromClause = new FromClause(scopeStartId.AsEnumerableOfOne(), HierarchyScope.AncestorsOrSelf, FixedStatusTypes.Published, "default-type", new[] { hiveId, expected, fullHiveId });
var fieldPredicateExpression = new FieldPredicateExpression("title", ValuePredicateType.Equal, "blah");
var fieldPredicateExpression2 = new FieldPredicateExpression("title", ValuePredicateType.Equal, "blah");
var binary = Expression.MakeBinary(ExpressionType.ExclusiveOr, fieldPredicateExpression, fieldPredicateExpression2);
var aSortClause = new SortClause(new FieldSelectorExpression("tag"), SortDirection.Descending, 2);
//var key = new HiveQueryCacheKey(new QueryDescription(resultFilterClause, fromClause, fieldPredicateExpression, Enumerable.Empty<SortClause>()));
var key = CacheKey.Create(new HiveQueryCacheKey(new QueryDescription(resultFilterClause, fromClause, fieldPredicateExpression, aSortClause.AsEnumerableOfOne())));
var keyJson = key.ToJson();
var keyBack = (CacheKey <HiveQueryCacheKey>)keyJson;
// var keyJsonTwice = keyBack.ToJson();
Assert.That(keyBack, Is.Not.Null);
//Assert.That(keyJson, Is.EqualTo(keyJsonTwice));
//NOTE: Criteria does not deserialize at the moment, but caching implementation should find matching keys OK still if it maintains an inner collection of original key objects if (key.Original.Criteria != null) Assert.That(keyBack.Original.Criteria, Is.Not.Null);
Assert.True(keyBack.Original.ResultFilters.Any());
Assert.That(keyBack.Original.ResultFilters.First().ResultType, Is.EqualTo(typeof(string)));
Assert.That(keyBack.Original.SortClauses.Count(), Is.EqualTo(key.Original.SortClauses.Count()));
Assert.That(keyBack.Original.SortClauses.FirstOrDefault().Direction, Is.EqualTo(SortDirection.Descending));
Assert.That(keyBack.Original.SortClauses.FirstOrDefault().Priority, Is.EqualTo(2));
Assert.That(keyBack.Original.From.HierarchyScope, Is.EqualTo(key.Original.From.HierarchyScope));
Assert.That(keyBack.Original.From.RequiredEntityIds.Count(), Is.EqualTo(3));
Assert.That(keyBack.Original.From.RequiredEntityIds.FirstOrDefault(), Is.EqualTo(hiveId));
Assert.That(keyBack.Original.From.RequiredEntityIds.FirstOrDefault().Value.Type, Is.EqualTo(HiveIdValueTypes.Guid));
Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(1), Is.EqualTo(expected));
Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(1).Value.Type, Is.EqualTo(HiveIdValueTypes.Guid));
Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(2), Is.EqualTo(fullHiveId));
Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(2).Value.Type, Is.EqualTo(HiveIdValueTypes.Guid));
Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(2).ProviderId, Is.EqualTo("nhibernate"));
Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(2).ProviderGroupRoot.ToString(), Is.EqualTo(fullHiveId.ProviderGroupRoot.ToString()));
}
public void TestInStringExprOM()
{
String 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(
model, caseExpr, new String[]
{
"0", "a", "b", "c", "d", null
}
, new bool?[]
{
false, true, true, true, false, null
}
);
caseExpr = "select TheString not in (\"a\", \"b\", \"c\") as result from "
+ typeof(SupportBean).FullName;
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(model);
TryString(
"TheString not in ('a', 'b', 'c')", new String[]
{
"0", "a", "b", "c", "d", null
}
, new bool?[]
{
true, false, false, false, true, null
}
);
}
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 Run(RegressionEnvironment env)
{
EPStatementObjectModel model = new EPStatementObjectModel();
model.SetInsertInto(InsertIntoClause.Create("ReadyStreamAvg", "line", "avgAge"));
model.SetSelect(SelectClause.Create().Add("line").Add(Expressions.Avg("age"), "avgAge"));
Filter filter = Filter.Create(typeof(SupportBean).FullName, Expressions.In("line", 1, 8, 10));
model.SetFrom(FromClause.Create(FilterStream.Create(filter, "RS").AddView("time", Expressions.Constant(10))));
model.SetWhere(Expressions.IsNotNull("waverId"));
model.SetGroupBy(GroupByClause.Create("line"));
model.SetHaving(Expressions.Lt(Expressions.Avg("age"), Expressions.Constant(0)));
model.SetOutputLimit(OutputLimitClause.Create(Expressions.TimePeriod(null, null, null, 10, null)));
model.SetOrderBy(OrderByClause.Create("line"));
Assert.AreEqual(
"insert into ReadyStreamAvg(line, avgAge) select line, avg(age) as avgAge from " +
typeof(SupportBean).CleanName() +
"(line in (1,8,10))#time(10) as RS where waverId is not null group by line having avg(age)<0 output every 10.0d seconds order by line",
model.ToEPL());
SerializableObjectCopier.CopyMayFail(env.Container, model);
}
// 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();
}
public void Run(RegressionEnvironment env)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create(new[] {"S0.Id", " S0.P00", " S0.P01", " S1.Id", " S1.P10", " S1.P11"});
var fromClause = FromClause.Create(
FilterStream.Create(typeof(SupportBean_S0).Name, "S0").AddView("keepall"),
FilterStream.Create(typeof(SupportBean_S1).Name, "S1").AddView("keepall"));
fromClause.Add(OuterJoinQualifier.Create("S0.P00", OuterJoinType.LEFT, "S1.P10").Add("S1.P11", "S0.P01"));
model.FromClause = fromClause;
model = env.CopyMayFail(model);
var stmtText =
"select S0.Id, S0.P00, S0.P01, S1.Id, S1.P10, S1.P11 from SupportBean_S0#keepall as S0 left outer join SupportBean_S1#keepall as S1 on S0.P00 = S1.P10 and S1.P11 = S0.P01";
Assert.AreEqual(stmtText, model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
AssertMultiColumnLeft(env);
var modelReverse = env.EplToModel(stmtText);
Assert.AreEqual(stmtText, modelReverse.ToEPL());
env.UndeployAll();
}
public void TestCreateFromOMComplete()
{
var model = new EPStatementObjectModel();
model.InsertInto = InsertIntoClause.Create("ReadyStreamAvg", "line", "avgAge");
model.SelectClause = SelectClause.Create()
.Add("line")
.Add(Expressions.Avg("age"), "avgAge");
var filter = Filter.Create(typeof(SupportBean).FullName, Expressions.In("line", 1, 8, 10));
model.FromClause = FromClause.Create(FilterStream.Create(filter, "RS").AddView("win", "time", Expressions.Constant(10)));
model.WhereClause = Expressions.IsNotNull("waverId");
model.GroupByClause = GroupByClause.Create("line");
model.HavingClause = Expressions.Lt(Expressions.Avg("age"), Expressions.Constant(0));
model.OutputLimitClause = OutputLimitClause.Create(Expressions.TimePeriod(null, null, null, 10, null));
model.OrderByClause = OrderByClause.Create("line");
Assert.AreEqual("insert into ReadyStreamAvg(line, avgAge) select line, avg(age) as avgAge from com.espertech.esper.support.bean.SupportBean(line in (1,8,10)).win:time(10) as RS where waverId is not null group by line having avg(age)<0 output every 10 seconds order by line", model.ToEPL());
SerializableObjectCopier.Copy(model);
}
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);
}
public SingleSeriesSelectStatement(
SelectClause select,
FromClause from,
WhereClause where = null,
GroupByClause groupBy = null,
FillClause fill = null,
OrderByClause orderBy = null,
LimitClause limit = null,
OffsetClause offset = null
)
{
Select = select ?? throw new ArgumentNullException(nameof(select));
From = from ?? throw new ArgumentNullException(nameof(from));
Where = where;
GroupBy = groupBy;
Fill = fill;
OrderBy = orderBy;
Limit = limit;
Offset = offset;
}
private void RunAssertionSingleParameterOM(EPServiceProvider epService)
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().Add(Expressions.StaticMethod(Name.Clean <BitWriter>(), "Write", 7), "value");
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportMarketDataBean).FullName).AddView("length", Expressions.Constant(5)));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);
var statementText = "select " + Name.Clean <BitWriter>() + ".Write(7) as value" + STREAM_MDB_LEN5;
Assert.AreEqual(statementText.Trim(), model.ToEPL());
var statement = epService.EPAdministrator.Create(model);
var listener = new SupportUpdateListener();
statement.Events += listener.Update;
SendEvent(epService, "IBM", 10d, 4L);
Assert.AreEqual(BitWriter.Write(7), listener.AssertOneGetNewAndReset().Get("value"));
statement.Dispose();
}
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();
}
public void ProcessJoins(IRestrictableStatement query)
{
FromClause fromClause = query.FromClause;
var supportRootAlias = !(query is DeleteStatement || query is UpdateStatement);
IList <FromElement> fromElements;
if (DotNode.UseThetaStyleImplicitJoins)
{
// for regression testing against output from the old parser...
// found it easiest to simply reorder the FromElements here into ascending order
// in terms of injecting them into the resulting sql ast in orders relative to those
// expected by the old parser; this is definitely another of those "only needed
// for regression purposes". The SyntheticAndFactory, then, simply injects them as it
// encounters them.
fromElements = new List <FromElement>();
var t = fromClause.GetFromElementsTyped();
for (int i = t.Count - 1; i >= 0; i--)
{
fromElements.Add(t[i]);
}
}
else
{
fromElements = fromClause.GetFromElementsTyped();
}
// Iterate through the alias,JoinSequence pairs and generate SQL token nodes.
foreach (FromElement fromElement in fromElements)
{
JoinSequence join = fromElement.JoinSequence;
join.SetSelector(new JoinSequenceSelector(_walker, fromClause, fromElement));
// the delete and update statements created here will never be executed when IsMultiTable is true,
// only the where clause will be used by MultiTableUpdateExecutor/MultiTableDeleteExecutor. In that case
// we have to use the alias from the persister.
AddJoinNodes(query, join, fromElement, supportRootAlias || fromElement.Queryable.IsMultiTable);
}
}
internal override string ToString(string indent)
{
var sb = new StringBuilder();
sb.AppendFormat("{0}UPDATE", indent);
if (TopRowFilter != null)
{
sb.Append(TopRowFilter.ToString(indent));
}
sb.AppendFormat(" {0} SET \r\n", Target.ToString(indent));
var first = true;
if (SetClauses != null)
{
foreach (var setclause in SetClauses)
{
if (first)
{
first = false;
sb.AppendFormat("{0}{1}", indent, setclause.ToString(indent));
}
else
{
sb.AppendFormat(", {0}", setclause.ToString(indent));
}
}
}
if (FromClause != null)
{
sb.AppendFormat("\r\n{0}{1}", indent, FromClause.ToString(indent));
}
if (WhereClause != null && WhereClause.SearchCondition != null)
{
sb.AppendFormat("\r\n{0}{1}", indent, WhereClause.ToString(indent));
}
sb.Append("\r\n");
return(sb.ToString());
}
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();
}
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);
}
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);
}
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 });
}
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();
}
/// <summary>
/// Renders SQL FROM clause.
/// </summary>
/// <param name="from">FROM clause.</param>
/// <param name="dbms">Target DBMS:</param>
/// <param name="output">StringBuilder to which SQL is appended.</param>
public void Render(FromClause from, DbmsType dbms, StringBuilder output)
{
AppendFromFirstTableNameAndAlias(from.FromTable, dbms, output);
foreach (JoinClause join in from.Joins)
RenderJoinTable(dbms, output, join.Relation, join.JoinedTable, join.IsLeftOuterJoin);
}
/// <summary>
/// Renders the terms of a from clause
/// </summary>
/// <param name="builder"></param>
/// <param name="fromClause"></param>
/// <param name="tableSpace">Common prefix for all tables in the clause</param>
protected virtual void FromClause(StringBuilder builder, FromClause fromClause, string tableSpace)
{
From(builder);
RenderFromTerm(builder, fromClause.BaseTable, tableSpace);
}
public void ProcessFromClause(FromClause fromClause)
{
if (fromClause == null) return;
foreach (var tableRef in fromClause.TableReferences)
{
ProcessTableReference(tableRef);
}
}
public override void Visit(FromClause node) { this.action(node); }
public void Process(FromClause FromClause, WithCtesAndXmlNamespaces cte)
{
foreach (TableReference TableRef in FromClause.TableReferences)
{
ProcessTableReference(TableRef, cte);
}
}
public FromClause Prepare(IExpressionPreparer preparer)
{
var clause = new FromClause();
clause.JoinSet = JoinSet.Prepare(preparer);
// Prepare the StatementTree sub-queries in the from tables
foreach (FromTable table in fromTableList) {
clause.fromTableList.Add(table.Prepare(preparer));
}
return clause;
}
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.MemberExpression item)
{
NLinq.Expressions.Expression target = Visit(item.Previous);
TableAlias entityAlias = currentAlias;
NLinq.Expressions.Expression statement = Visit(item.Statement);
if (statement.ExpressionType==NLinq.Expressions.ExpressionTypes.Identifier)
{
string propertyName = ((Evaluant.NLinq.Expressions.Identifier)statement).Text;
if (inFrom && currentEntity.References.ContainsKey(propertyName))
{
Mapping.Reference reference = currentEntity.References[propertyName];
TableAlias newTableAlias;
IAliasedExpression join = mapping.Mapper.Join(reference, out newTableAlias);
//registeredAliasedExpression.Add(join, newTableAlias);
lastAliasDefined = ((JoinedTableExpression)join).RightTable.Alias;
loadedReferences.Add(referencePath.ToString(), lastAliasDefined);
AliasesMapping.Add(newTableAlias, entityAlias);
return (NLinq.Expressions.Expression)join;
}
else
{
string targetReferencePath = referencePath.ToString().Substring(0, referencePath.Length - propertyName.Length);
//If this is not a reference leave the treatment to another visitor
if (currentEntity != null && currentEntity.References.ContainsKey(propertyName))
{
bool exists = currentFrom == null;
Mapping.Reference reference = currentEntity.References[propertyName];
if (!loadedReferences.ContainsKey(referencePath.ToString()))
{
currentEntity = reference.Target;
TableAlias newTableAlias;
//New target to reduce the already processed tree
target = (NLinq.Expressions.Expression)mapping.Mapper.Join(reference, out newTableAlias);
if (reference.IsComposite || loadedReferences.ContainsKey(targetReferencePath))
{
target = new LazyAliasResolver(new Dictionary<TableAlias, TableAlias>() { { newTableAlias, currentAlias } }).Visit(target);
newTableAlias = currentAlias;
//AliasesMapping[loadedReferences[targetReferencePath]] = target.Alias;
}
//Add JoinedTableExpression to load reference in query
if (!exists)
target = ((JoinedTableExpression)target).Replace(newTableAlias, currentFrom[0]);
else
{
//Case of Exists in where clause
Evaluant.NLinq.Expressions.Expression constraint;
target = (NLinq.Expressions.Expression)((JoinedTableExpression)target).Replace(newTableAlias, loadedReferences[targetReferencePath], out constraint);
if (this.constraint == null)
this.constraint = constraint;
else
this.constraint = new NLinq.Expressions.BinaryExpression(NLinq.Expressions.BinaryExpressionType.And, this.constraint, constraint);
}
//if (target == null)
// throw new NotSupportedException("The alias specified could not be found");
if (loadedReferences.ContainsKey(targetReferencePath))
target = new LazyAliasResolver(new Dictionary<TableAlias, TableAlias>() { { loadedReferences[targetReferencePath], newTableAlias } }).Visit(target);
currentFrom = new FromClause((IAliasedExpression)target);
lastAliasDefined = ((JoinedTableExpression)target).RightTable.Alias;
loadedReferences.Add(referencePath.ToString(), lastAliasDefined);
}
else
{
if (!inFrom)
lastAliasDefined = loadedReferences[referencePath.ToString()];
}
if (exists)
{
var constraint = this.constraint;
this.constraint = null;
return constraint;
}
return new EntityExpression(lastAliasDefined) { Type = reference.Target.Type };
}
//else
//{
// if (!loadedReferences.ContainsKey(targetReferencePath))
// return updater.Update(item, target, statement);
// //return new ComplexColumnExpression(currentAlias, target is SelectStatement ? new EntityIdentifier(propertyName, currentEntityExpression) : new Evaluant.NLinq.Expressions.Identifier(propertyName));
// return updater.Update(item, target, statement);
// //return new ComplexColumnExpression(currentAlias, target is SelectStatement ? new EntityIdentifier(propertyName, new EntityExpression(loadedReferences[targetReferencePath]) { Type = currentEntity.Type }) : new Evaluant.NLinq.Expressions.Identifier(propertyName));
// //return updater.Update(item, target, target is SelectStatement ? new EntityIdentifier(propertyName, new EntityExpression(loadedReferences[targetReferencePath]) { Type = currentEntity.Type }) : new Evaluant.NLinq.Expressions.Identifier(propertyName));
//}
}
}
return updater.Update(item, target, statement);
}
public override FromClause Visit(FromClause item)
{
bool wasInFrom = inFrom;
inFrom = true;
currentFrom = base.Visit(item);
inFrom = wasInFrom;
return currentFrom;
}
public JoinClause(FromClause parent, SqlJoin join)
: base(parent)
{
_from = parent;
_join = join;
}
public static FromClause Deserialize(BinaryReader reader)
{
var fromClause = new FromClause();
var tableNameCount = reader.ReadInt32();
for (int i = 0; i < tableNameCount; i++) {
fromClause.tableNames.Add(reader.ReadString());
}
var tableCount = reader.ReadInt32();
for (int i = 0; i < tableCount; i++) {
fromClause.fromTables.Add(FromTable.Deserialize(reader));
}
var joinCount = reader.ReadInt32();
for (int i = 0; i < joinCount; i++) {
fromClause.joinParts.Add(JoinPart.Deserialize(reader));
}
return fromClause;
}
object IPreparable.Prepare(IExpressionPreparer preparer)
{
var clause = new FromClause();
// Prepare expressions in the JoiningSet first
int size = joinParts.Count;
for (int i = 0; i < size; ++i) {
var part = joinParts[i];
var exp = part.OnExpression;
if (exp != null) {
exp = exp.Prepare(preparer);
if (part.SubQuery != null) {
part = new JoinPart(part.JoinType, part.SubQuery, exp);
} else {
part = new JoinPart(part.JoinType, part.TableName, exp);
}
}
clause.joinParts.Add(part);
}
// Prepare the StatementTree sub-queries in the from tables
for (int i = 0; i < fromTables.Count; i++) {
var table = fromTables[i];
var preparedTable = (FromTable) ((IPreparable) table).Prepare(preparer);
var tableAlias = tableNames[i];
clause.tableNames.Insert(i, tableAlias);
clause.fromTables.Insert(i, preparedTable);
}
return clause;
}
public static void Serialize(FromClause clause, BinaryWriter writer)
{
var tableNamesCount = clause.tableNames.Count;
writer.Write(tableNamesCount);
for (int i = 0; i < tableNamesCount; i++) {
writer.Write(clause.tableNames[0]);
}
var tableCount = clause.fromTables.Count;
writer.Write(tableCount);
for (int i = 0; i < tableCount; i++) {
FromTable.Serialize(clause.fromTables[i], writer);
}
var joinCount = clause.joinParts.Count;
writer.Write(joinCount);
for (int i = 0; i < joinCount; i++) {
JoinPart.Serialize(clause.joinParts[i], writer);
}
}
public DeleteStatement (FromClause from)
{
From = from;
}
public void FromClauseExample2TestMethod()
{
FromClause _fc = new FromClause();
Assert.AreEqual<string>("grape", _fc.FromClauseExample2());
}
public void FromClauseExample3TestMethod()
{
FromClause _fc = new FromClause();
Assert.AreEqual<string>("Name1:11000,00;Name3:130000,00", _fc.FromClauseExample3());
}
public override void ExplicitVisit(FromClause fragment)
{
_fragments.Add(fragment);
}
private void CreateSelectForFunctionUnderTest(ObjectIdentifier name)
{
var select = new QuerySpecification();
select.SelectElements.Add(new SelectStarExpression());
var from = new FromClause();
var reference = new SchemaObjectFunctionTableReference();
foreach (var p in _parameters)
{
reference.Parameters.Add(new VariableReference(){Name = p.Name});
}
reference.SchemaObject = name.ToSchemaObjectName();
from.TableReferences.Add(reference);
select.FromClause = from;
_functionSelect.QueryExpression = select;
}
