private bool TryApplySelectClause(SelectClause clause, QueryCommand cmd)
{
if (cmd.Columns.Any())
return false;
cmd.Columns.AddRange(clause.Columns);
return true;
}
public SelectClauseHandler(SelectClause clause)
{
_references = clause.Columns.ToList();
_resolvers = _references.Select(ValueResolver.Create).ToList();
if (_resolvers.OfType<AggregateValueResolver>().Any())
{
_groupingHandler =
new GroupingHandler(
_references.Where(ReferenceIsNotAggregateFunction).Select(r => r.GetAliasOrName()).ToArray());
}
}
/// <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;
}
public void SetUp()
{
_generator = new UniqueIdentifierGenerator();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_defaultStage = new DefaultSqlPreparationStage(
CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), _generator);
_mainFromClause = ExpressionHelper.CreateMainFromClause <Cook>();
_selectClause = ExpressionHelper.CreateSelectClause(_mainFromClause);
_orderByClause = ExpressionHelper.CreateOrderByClause();
_queryModel = new QueryModel(_mainFromClause, _selectClause);
_stageMock = MockRepository.GenerateStrictMock <ISqlPreparationStage>();
_visitor = new TestableSqlPreparationQueryModelVisitor(_context, _stageMock);
_visitorPartialMock = MockRepository.GeneratePartialMock <TestableSqlPreparationQueryModelVisitor> (_context, _stageMock);
}
public override void VisitSelectClause(SelectClause selectClause, QueryModel queryModel)
{
var joins = LeftJoinDetector.Detect(selectClause.Selector, new NameGenerator(queryModel), _sessionFactory);
if (joins.Joins.Count > 0)
{
selectClause.Selector = joins.Selector;
queryModel.TransformExpressions(e => ExpressionSwapper.Swap(e, joins.ExpressionMap));
foreach (var join in joins.Joins)
{
queryModel.BodyClauses.Add(join);
}
}
}
protected virtual void ParseSelectClause(SelectClause clause)
{
Builder.Append("SELECT ");
bool flag = false;
foreach (var element in clause.Elements)
{
if (flag)
{
Builder.Append(", ");
}
flag = true;
ParseSelectElement(element);
}
}
public override void VisitSelectClause(SelectClause selectClause, QueryModel queryModel)
{
var joins = LeftJoinDetector.Detect(selectClause.Selector, new NameGenerator(queryModel), _sessionFactory);
if (joins.Joins.Count > 0)
{
selectClause.Selector = joins.Selector;
queryModel.TransformExpressions(e => ExpressionSwapper.Swap(e, joins.ExpressionMap));
foreach (var join in joins.Joins)
{
queryModel.BodyClauses.Add(join);
}
}
}
/// <summary>
/// Initializes a new instance of <see cref="QueryModel" />
/// </summary>
/// <param name="mainFromClause">
/// The <see cref="Clauses.MainFromClause" /> of the query. This is the starting point of the query, generating items
/// that are filtered and projected by the query.
/// </param>
/// <param name="selectClause">
/// The <see cref="SelectClause" /> of the query. This is the end point of
/// the query, it defines what is actually returned for each of the items coming from the <see cref="MainFromClause" />
/// and passing the
/// <see cref="BodyClauses" />. After it, only the <see cref="ResultOperators" /> modify the result of the query.
/// </param>
public QueryModel(MainFromClause mainFromClause, SelectClause selectClause)
{
ArgumentUtility.CheckNotNull("mainFromClause", mainFromClause);
ArgumentUtility.CheckNotNull("selectClause", selectClause);
_uniqueIdentifierGenerator = new UniqueIdentifierGenerator();
MainFromClause = mainFromClause;
SelectClause = selectClause;
BodyClauses = new ObservableCollection <IBodyClause>();
BodyClauses.CollectionChanged += BodyClauses_CollectionChanged;
ResultOperators = new ObservableCollection <ResultOperatorBase>();
ResultOperators.CollectionChanged += ResultOperators_CollectionChanged;
}
private IColumnSource RewriteTableIfNeeded(TableDeclarationClause declaration)
{
var queryRoot = queryEntityTree.Get(declaration);
var subqueryRequired = queryRoot.subqueryRequired ||
queryRoot.additionalFields != null;
if (!subqueryRequired)
{
declaration.Name = queryRoot.entity.mapping.DbTableName;
return(declaration);
}
var stripResult = Strip(queryRoot.entity);
var selectClause = new SelectClause
{
Source = queryEntityTree.GetTableDeclaration(queryRoot.entity)
};
if (stripResult == StripResult.HasNoReferences)
{
selectClause.IsSelectAll = true;
}
else
{
AddJoinClauses(queryRoot.entity, selectClause);
AddColumns(queryRoot, selectClause);
if (queryRoot.additionalFields != null)
{
foreach (var c in queryRoot.additionalFields)
{
selectClause.Fields.Add(c);
}
}
}
return(new SubqueryTable
{
Alias = declaration.Alias ?? nameGenerator.GenerateSubqueryName(),
Query = new SubqueryClause
{
Query = new SqlQuery
{
Unions = { new UnionClause {
SelectClause = selectClause
} }
}
}
});
}
private SelectQuery(ISelectQuery clone, Dictionary <ICloneableElement, ICloneableElement> objectTree,
Predicate <ICloneableElement> doClone)
{
objectTree.Add(clone, this);
SourceID = Interlocked.Increment(ref SourceIDCounter);
ICloneableElement parentClone;
if (clone.ParentSelect != null)
{
ParentSelect = objectTree.TryGetValue(clone.ParentSelect, out parentClone)
? (ISelectQuery)parentClone
: clone.ParentSelect;
}
EQueryType = clone.EQueryType;
if (IsInsert)
{
Insert = (IInsertClause)clone.Insert.Clone(objectTree, doClone);
}
if (IsUpdate)
{
Update = (IUpdateClause)clone.Update.Clone(objectTree, doClone);
}
if (IsDelete)
{
Delete = (IDeleteClause)clone.Delete.Clone(objectTree, doClone);
}
Select = new SelectClause(this, clone.Select, objectTree, doClone);
From = new FromClause(this, clone.From, objectTree, doClone);
Where = new WhereClause(this, clone.Where, objectTree, doClone);
GroupBy = new GroupByClause(this, clone.GroupBy, objectTree, doClone);
Having = new WhereClause(this, clone.Having, objectTree, doClone);
OrderBy = new OrderByClause(this, clone.OrderBy, objectTree, doClone);
Parameters.AddRange(clone.Parameters.Select(p => (ISqlParameter)p.Clone(objectTree, doClone)));
IsParameterDependent = clone.IsParameterDependent;
foreach (var query in QueryVisitor.FindOnce <ISelectQuery>(this).Where(sq => sq.ParentSelect == clone))
{
query.ParentSelect = this;
}
}
public void TestDirectNumberOfEvents()
{
String stmtText = "select TheString from SupportBean.win:keepall() output after 3 events";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.Events += _listener.Update;
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.Events += _listener.Update;
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 TestCreateFromOM()
{
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName));
SerializableObjectCopier.Copy(model);
EPStatement stmt = _epService.EPAdministrator.Create(model, "s1");
stmt.Events += _listener.Update;
Object theEvent = new SupportBean();
_epService.EPRuntime.SendEvent(theEvent);
Assert.AreEqual(theEvent, _listener.AssertOneGetNewAndReset().Underlying);
}
public static void WriteArray(
Utf8JsonWriter writer,
IEnumerable resultItems,
IOpenApiType itemType,
SelectClause selectClause,
IOpenApiTypeHandler typeHandler,
JsonSerializerOptions options)
{
writer.WriteStartArray();
foreach (var item in resultItems)
{
WriteValue(writer, itemType, item, selectClause, typeHandler, options);
}
writer.WriteEndArray();
}
public void TestWhere_OM()
{
EPStatementObjectModel model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create().AddWithAsProvidedName("s0.id", "idS0").AddWithAsProvidedName("s1.id", "idS1");
PatternExpr pattern = Patterns.Or()
.Add(Patterns.EveryFilter(typeof(SupportBean_S0).FullName, "s0"))
.Add(Patterns.EveryFilter(typeof(SupportBean_S1).FullName, "s1")
);
model.FromClause = FromClause.Create(PatternStream.Create(pattern));
model.WhereClause = Expressions.Or()
.Add(Expressions.And()
.Add(Expressions.IsNotNull("s0.id"))
.Add(Expressions.Lt("s0.id", 100))
)
.Add(Expressions.And()
.Add(Expressions.IsNotNull("s1.id"))
.Add(Expressions.Ge("s1.id", 100))
);
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
String reverse = model.ToEPL();
String stmtText = "select s0.id as idS0, s1.id as idS1 " +
"from pattern [every s0=" + typeof(SupportBean_S0).FullName +
" or every s1=" + typeof(SupportBean_S1).FullName + "] " +
"where s0.id is not null and s0.id<100 or s1.id is not null and s1.id>=100";
Assert.AreEqual(stmtText, reverse);
EPStatement statement = _epService.EPAdministrator.Create(model);
statement.Events += _updateListener.Update;
SendEventS0(1);
AssertEventIds(1, null);
SendEventS0(101);
Assert.IsFalse(_updateListener.IsInvoked);
SendEventS1(1);
Assert.IsFalse(_updateListener.IsInvoked);
SendEventS1(100);
AssertEventIds(null, 100);
}
public void TestEveryPolicy()
{
SendTimer(0);
var stmtText = "select TheString from SupportBean.win:keepall() output after 0 days 0 hours 0 minutes 20 seconds 0 milliseconds every 0 days 0 hours 0 minutes 5 seconds 0 milliseconds";
var stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.AddListener(_listener);
RunAssertion();
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("TheString");
model.FromClause = FromClause.Create(FilterStream.Create("SupportBean").AddView("win", "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());
}
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();
}
public QueryModel Apply(QueryModel queryModel, ClauseGenerationContext clauseGenerationContext)
{
if (queryModel != null)
{
throw new ArgumentException(
"QueryModel has to be null because MainSourceExpressionNode marks the start of a query.",
"queryModel");
}
var mainFromClause = CreateMainFromClause(clauseGenerationContext);
var defaultSelectClause = new SelectClause(new QuerySourceReferenceExpression(mainFromClause));
return(new QueryModel(mainFromClause, defaultSelectClause)
{
ResultTypeOverride = QuerySourceType
});
}
/// <summary>
/// Creates a query view from the service provider.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="asName">As name.</param>
/// <returns></returns>
public static EsperQuery <T> FromTypeAs <T>(
this EPServiceProvider serviceProvider,
string asName)
{
var selectClause = SelectClause.Create();
selectClause.AddWildcard();
var objectModel = new EPStatementObjectModel();
objectModel.SelectClause = selectClause;
objectModel.FromClause = FromClause.Create();
objectModel.FromClause.Add(FilterStream.Create(typeof(T).FullName, asName));
objectModel.MakeIterableUnbound();
return(new EsperQuery <T>(serviceProvider, objectModel));
}
public override void VisitSelectClause(SelectClause selectClause, QueryModel queryModel)
{
CurrentEvaluationType = selectClause.GetOutputDataInfo();
var visitor = new SelectClauseVisitor(typeof(object[]), VisitorParameters);
visitor.Visit(selectClause.Selector);
if (visitor.ProjectionExpression != null)
{
_hqlTree.AddItemTransformer(visitor.ProjectionExpression);
}
_hqlTree.AddSelectClause(_hqlTree.TreeBuilder.Select(visitor.GetHqlNodes()));
base.VisitSelectClause(selectClause, queryModel);
}
public void NestedSelectProjection_MemberAccess_ToANewExpression_WithMemberNotInitialized()
{
var mainFromClause = new MainFromClause("k", typeof(Kitchen), Expression.Constant(Kitchens));
var querySourceReferenceExpression = new QuerySourceReferenceExpression(mainFromClause);
var constructorInfo = TypeForNewExpression.GetConstructor(typeof(int), typeof(int));
Trace.Assert(constructorInfo != null);
var newExpression = Expression.New(
constructorInfo,
new[] { MemberExpression.MakeMemberAccess(querySourceReferenceExpression, typeof(Kitchen).GetProperty("ID")),
MemberExpression.MakeMemberAccess(querySourceReferenceExpression, typeof(Kitchen).GetProperty("RoomNumber")) },
new MemberInfo[] { typeof(TypeForNewExpression).GetProperty("A"), typeof(TypeForNewExpression).GetProperty("B") });
var selectClause = new SelectClause(MemberExpression.MakeMemberAccess(newExpression, typeof(TypeForNewExpression).GetField("C")));
var queryModel = new QueryModel(mainFromClause, selectClause);
CheckQuery(queryModel, "");
}
public static void WriteObject(
Utf8JsonWriter writer,
IOpenApiType itemType,
object item,
SelectClause selectClause,
IOpenApiTypeHandler typeHandler,
JsonSerializerOptions options)
{
if (item == null)
{
writer.WriteNullValue();
}
else
{
writer.WriteStartObject();
var actualType = typeHandler.ResolveType(item.GetType());
var needsType = itemType == null || !itemType.Equals(actualType);
if (needsType)
{
writer.WriteString("@odata.type", actualType.JsonName);
}
foreach (var property in actualType.Properties)
{
SelectClause subClause = null;
if (selectClause == null ||
selectClause.SelectClauses?.TryGetValue(property.ClrProperty, out subClause) == true ||
selectClause.IsStarSelect)
{
var key = options.PropertyNamingPolicy.ConvertName(property.JsonName);
writer.WritePropertyName(JsonEncodedText.Encode(key));
WriteValue(writer,
typeHandler.ResolveType(property.ClrProperty.PropertyType),
property.GetValue(item),
subClause,
typeHandler,
options);
}
}
writer.WriteEndObject();
}
}
static void Main(string[] args)
{
SelectClause select = Select(("c".Col("t")).As("a"), "co".Col(), QueryBuilderExtensions.Col("cl").As("col"), "Now".Call().As("Date"));
// SELECT (t.c) AS a, co, (cl) AS col, (Now()) AS Date
Console.WriteLine(select.GetQuery());
FromClause from = From(Table("t").LeftOuterJoin(Table("lo"), "x".Col("t").Eq("y".Col("lo")).And("y".Col("t").Neq("x".Col("lo")))));
// FROM t LEFT OUTER JOIN lo ON ((t.x = lo.y) And (t.y != lo.x))
Console.WriteLine(from.GetQuery());
WhereClause where = Where("c".Col("t").Eq(Val("v")).And(Val(2.0).LtEq(Val(1)).Or(Val(-1).Neq("NOW".Call()))));
// WHERE (s.f = 'v') And ((2 <= 1) Or (-1 != NOW()))
Console.WriteLine(where.GetQuery());
OrderByClause orderBy = OrderBy("c".Col("t"), "co".Col());
// ORDER BY t.c, co
Console.WriteLine(orderBy.GetQuery());
CreateClause create = Create("Table", true, "FieldA".ColDefinition(BaseType.Integer, 2), "FieldB".ColDefinition(BaseType.Text, 10));
// CREATE TABLE IF NOT EXISTS Table (FieldA Integer, FieldB Text)
Console.WriteLine(create.GetQuery());
DB DbObject = new DB(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Oxcha/Oxcha.db").ToString());
Dao <UserAuthKey> firenduserAuthTable = new Dao <UserAuthKey>(DbObject);
firenduserAuthTable.CreateTable();
string directory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Oxcha").ToString();
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
Client client = AuthenticateLogin(args);
if (client != null)
{
EntryHandler(client);
}
}
public static IVirtualDataReader GetReader <TResult>(SelectClause <TResult> select)
{
//data cache
var cache = DataSourceCache.Instance;
try
{
//locate reader
return(cache.GetReader(select));
}
//silent but logged - cache lookup fail
catch (Exception e)
{
log.Error("Cache lookup fail");
log.Error(e);
return(new VirtualDbReader(select));
}
}
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 override Statement UseAsEndOfTempTableAndClone(IncludeIdentitySelectorStatement includeIdentitySelectorStatement)
{
includeIdentitySelectorStatement.IncludeDataInTempTable = true;
var clone = new JsonStatement(SelectClause, Fields)
{
SelectClause = SelectClause.As <IScalarSelectClause>().CloneToOtherTable(includeIdentitySelectorStatement.ExportName),
Orderings = Orderings,
Mode = StatementMode.Select,
ExportName = ExportName
};
SelectClause = includeIdentitySelectorStatement;
Limit = Offset = 0;
return(clone);
}
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 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"));
}
/// <summary>
/// Transforms all the expressions in this <see cref="QueryModel"/>'s clauses via the given <paramref name="transformation"/> delegate.
/// </summary>
/// <param name="transformation">The transformation object. This delegate is called for each <see cref="Expression"/> within this
/// <see cref="QueryModel"/>, and those expressions will be replaced with what the delegate returns.</param>
public void TransformExpressions(Func <Expression, Expression> transformation)
{
ArgumentUtility.CheckNotNull("transformation", transformation);
MainFromClause.TransformExpressions(transformation);
foreach (var bodyClause in BodyClauses)
{
bodyClause.TransformExpressions(transformation);
}
SelectClause.TransformExpressions(transformation);
foreach (var resultOperator in ResultOperators)
{
resultOperator.TransformExpressions(transformation);
}
}
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 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();
}
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");
}
/// <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 override SelectClause VisitSelect(SelectClause clause)
{
builder.Append("select");
if (clause.IsDistinct)
{
builder.AppendFormat(" distinct");
}
builder.Append("\r\n\t");
if (clause.IsSelectAll)
{
builder.Append("*");
}
else
{
VisitEnumerable(clause.Fields, ",\r\n\t");
}
builder.Append("\r\nfrom ");
Visit(clause.Source);
if (clause.JoinClauses.Count > 0)
{
builder.Append("\r\n");
VisitEnumerable(clause.JoinClauses, "\r\n");
}
if (clause.WhereExpression != null)
{
builder.Append("\r\nwhere ");
Visit(clause.WhereExpression);
}
if (clause.GroupBy != null)
{
Visit(clause.GroupBy);
}
if (clause.Having != null)
{
builder.Append("\r\nhaving ");
Visit(clause.Having);
}
if (clause.Top.HasValue)
{
builder.AppendFormat("\r\nlimit {0}", clause.Top.Value);
}
return(clause);
}
/// <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);
}
}
public void SelectShouldRestrictColumnList()
{
var tableRef = new ObjectReference("FooTable");
var selectClause = new SelectClause(new SimpleReference[] { new ObjectReference("Id", tableRef), new ObjectReference("Name", tableRef) });
var runner = new DictionaryQueryRunner(SelectSource(), selectClause);
var actual = runner.Run().ToList();
Assert.AreEqual(4, actual.Count);
Assert.AreEqual(2, actual[0].Count);
Assert.AreEqual(1, actual[0]["Id"]);
Assert.AreEqual("Alice", actual[0]["Name"]);
Assert.AreEqual(2, actual[1].Count);
Assert.AreEqual(2, actual[1]["Id"]);
Assert.AreEqual("Bob", actual[1]["Name"]);
Assert.AreEqual(2, actual[2].Count);
Assert.AreEqual(3, actual[2]["Id"]);
Assert.AreEqual("Charlie", actual[2]["Name"]);
Assert.AreEqual(2, actual[3].Count);
Assert.AreEqual(4, actual[3]["Id"]);
Assert.AreEqual("David", actual[3]["Name"]);
}
public override void VisitSelectClause(SelectClause selectClause, QueryModel queryModel)
{
selectClause.TransformExpressions(e => MergeAggregatingResultsInExpressionRewriter.Rewrite(e, new NameGenerator(queryModel)));
}
public override void VisitSelectClause(SelectClause selectClause, QueryModel queryModel)
{
selectClause.Selector = JoinReplacer(queryModel, selectClause.Selector);
}
private bool TryApplySelectClause(SelectClause clause)
{
if(_columns.Any())
return false;
_columns.AddRange(clause.Columns);
return true;
}
public void SelectLengthShouldUseLengthFunction()
{
var tableRef = new ObjectReference("FooTable");
var function = new FunctionReference("Length", new ObjectReference("Name", tableRef)).As("NameLength");
var selectClause = new SelectClause(new SimpleReference[] { new ObjectReference("Name", tableRef), function });
var runner = new DictionaryQueryRunner(SelectSource(), selectClause);
var actual = runner.Run().ToList();
Assert.AreEqual(4, actual.Count);
Assert.AreEqual(2, actual[0].Count);
Assert.AreEqual("Alice", actual[0]["Name"]);
Assert.AreEqual(5, actual[0]["NameLength"]);
Assert.AreEqual(2, actual[1].Count);
Assert.AreEqual("Bob", actual[1]["Name"]);
Assert.AreEqual(3, actual[1]["NameLength"]);
Assert.AreEqual(2, actual[2].Count);
Assert.AreEqual("Charlie", actual[2]["Name"]);
Assert.AreEqual(7, actual[2]["NameLength"]);
Assert.AreEqual(2, actual[3].Count);
Assert.AreEqual("David", actual[3]["Name"]);
Assert.AreEqual(5, actual[3]["NameLength"]);
}
/// <summary>
/// Visits the select clause.
/// </summary>
/// <param name="selectClause">The select clause.</param>
/// <param name="queryModel">The query model.</param>
public override void VisitSelectClause(SelectClause selectClause, QueryModel queryModel)
{
this.querySpec.Projection = ProjectionBuilder.Build(this.mongoSession.MappingStore, selectClause.Selector);
}
public override void VisitSelectClause(SelectClause selectClause, QueryModel queryModel)
{
selectClause.TransformExpressions(MergeAggregatingResultsInExpressionRewriter.Rewrite);
}
public override void VisitSelectClause(SelectClause selectClause, QueryModel queryModel)
{
if (_selectClause != null)
{
return;
}
var visitor = new ProjectionEvaluator(_parameterAggregator, typeof(object[]), CanBeEvaluatedInHqlSelectStatement);
visitor.Visit(selectClause.Selector);
if (visitor.ProjectionExpression != null)
{
_itemTransformers.Add(visitor.ProjectionExpression);
}
_selectClause = _hqlTreeBuilder.Select(visitor.GetAstBuilderNode());
base.VisitSelectClause(selectClause, queryModel);
}
