public void Expression_should_give_operation_and_or()
{
var queryable = collection.Where(dto => dto.Id == Guid.Empty && dto.Score == 10 || dto.FirstName == "lalala");
var visitor = new QueryVisitor();
visitor.Visit(queryable.Expression);
Check.That(visitor.Operation).IsInstanceOf <Or>();
var or = (Or)visitor.Operation;
var and = (And)or.First;
var first = (QueryById)and.First;
var second = (QueryByField)and.Second;
var third = (QueryByField)or.Second;
Check.That(first.Id).IsEqualTo(Guid.Empty);
Check.That(second.Name.Value).IsEqualTo("Score");
Check.That(second.FieldValue).IsEqualTo(10);
Check.That(third.Name.Value).IsEqualTo("FirstName");
Check.That(third.FieldValue).IsEqualTo("lalala");
}
public EntityCollection getFriendsAndQuotes(QueryExpression inputQE)
{
QueryVisitor qeParams = new QueryVisitor();
qeParams.Visit(inputQE);
var Parameters = qeParams.SearchKeyWords;
var WebServiceResponse = CallToWebService();
var ListFriendQuote = JsonConvert.DeserializeObject <List <FriendQuote> >(WebServiceResponse);
List <FriendQuote> FilterFriendQuotes = default;
if (Parameters.Count > 0)
{
FilterFriendQuotes = ListFriendQuote.Where(x => x.Character == Parameters.First().Value).ToList();
}
else
{
FilterFriendQuotes = ListFriendQuote;
}
EntityCollection returnEntities = new EntityCollection();
foreach (var item in FilterFriendQuotes)
{
returnEntities.Entities.Add(new Entity("erf_friendquote", CachedGuids.IDs[ListFriendQuote.FindIndex(x => x.Character == item.Character)])
{
Attributes = new AttributeCollection()
{
new KeyValuePair <string, object>("erf_friend", item.Character),
new KeyValuePair <string, object>("erf_quote", item.Quote)
}
});
}
return(returnEntities);
}
public static IList ExecuteDb <T, TResult>(Db.OeEntitySetAdapterCollection entitySetAdapters, DbContext dataContext, Expression <Func <IQueryable <T>, TResult> > expression)
{
var visitor = new QueryVisitor <T>(entitySetAdapters, dataContext);
Expression call = visitor.Visit(expression.Body);
return(new[] { visitor.Query.Provider.Execute <TResult>(call) });
}
public async Task <ICollection <T> > Find(IQueryable <T> query)
{
var expression = query.Expression;
var visitor = new QueryVisitor();
visitor.Visit(expression);
return(await visitor.Operation.Execute(this));
}
public static IList ExecuteDb <T, TResult>(DbContext dataContext, Expression <Func <IQueryable <T>, TResult> > expression)
{
IQueryable <T> query = GetQuerableDb <T>(dataContext);
var visitor = new QueryVisitor <T>(query);
Expression call = visitor.Visit(expression.Body);
return(new[] { query.Provider.Execute <TResult>(call).ToString() });
}
public object GetQueryable <TResult>(System.Linq.Expressions.Expression expression)
{
var v = new QueryVisitor();
v.Visit(expression);
var reader = new AdgangsAdresseReader <TResult>(v.Evaluate());
return(reader.AsQueryable());
}
public void TestSngExpressions(string expr, string expectedQuery)
{
Setup(expr);
CalcParser.ExpressionContext context = this._calcParser.expression();
QueryVisitor visitor = new QueryVisitor();
string query = visitor.Visit(context);
Assert.AreEqual(expectedQuery, query);
}
public void TestQueryVariablesOracle(string expr, string expectedQuery)
{
Setup(expr);
CalcParser.ExpressionContext context = this._calcParser.expression();
DbTranslator translator = new OracleTranslator();
QueryVisitor visitor = new QueryVisitor(new TestMetadataResolver(), translator);
string query = visitor.Visit(context);
Assert.AreEqual(expectedQuery, query);
}
/// <summary>
/// Parses a user query (without validating it). You practically only get the syntax tree.
/// </summary>
/// <param name="text"></param>
/// <param name="errorListener"></param>
/// <returns></returns>
public static Query ParseForSyntaxOnly(string text, IErrorListener errorListener = null)
{
var inputStream = new AntlrInputStream(text);
var speakLexer = new CQLLexer(inputStream);
var commonTokenStream = new CommonTokenStream(speakLexer);
var parser = new CQLParser(commonTokenStream);
AddErrorListener(parser, errorListener);
var parseContext = parser.query();
var visitor = new QueryVisitor();
return(visitor.Visit(parseContext));
}
public void TestNormdFirebird(string expr, string expectedQuery)
{
Setup(expr);
CalcParser.ExpressionContext context = this._calcParser.expression();
DbTranslator translator = new FirebirdTranslator();
IMetadataResolver resolver = new TestMetadataResolver();
QueryVisitor visitor = new QueryVisitor(resolver, translator);
string query = visitor.Visit(context);
Assert.AreEqual(expectedQuery, query);
}
public void TestMathConstants(string expr, string expectedQuery)
{
Setup(expr);
CalcParser.ExpressionContext context = this._calcParser.expression();
DbTranslator translator = Substitute.For <DbTranslator>();
IMetadataResolver resolver = Substitute.For <IMetadataResolver>();
QueryVisitor visitor = new QueryVisitor(resolver, translator);
string query = visitor.Visit(context);
Assert.AreEqual(expectedQuery, query);
}
public static IList ExecuteDb <T, TResult>(Db.OeDataAdapter dataAdapter, DbContext dataContext,
Expression <Func <IQueryable <T>, IQueryable <TResult> > > expression, out IReadOnlyList <EfInclude> includes)
{
var visitor = new QueryVisitor <T>(dataAdapter.EntitySetAdapters, dataContext);
Expression call = visitor.Visit(expression.Body);
var metadataProvider = new OdataToEntity.EfCore.OeEfCoreEdmModelMetadataProvider(dataContext.Model);
var includeVisitor = new IncludeVisitor(metadataProvider, dataAdapter.IsDatabaseNullHighestValue);
call = includeVisitor.Visit(call);
includes = includeVisitor.Includes;
return(visitor.Query.Provider.CreateQuery <TResult>(call).ToList());
}
public void Expression_should_give_operationById()
{
var queryable = collection.Where(dto => dto.Id == Guid.Empty);
var visitor = new QueryVisitor();
visitor.Visit(queryable.Expression);
Check.That(visitor.Operation).IsInstanceOf <QueryById>();
var queryById = (QueryById)visitor.Operation;
Check.That(queryById.Id).IsEqualTo(Guid.Empty);
}
public static IList ExecuteDb <T, TResult>(Db.OeEntitySetAdapterCollection entitySetAdapters, DbContext dataContext,
Expression <Func <IQueryable <T>, IQueryable <TResult> > > expression, out IReadOnlyList <IncludeVisitor.Include> includes)
{
var visitor = new QueryVisitor <T>(entitySetAdapters, dataContext);
Expression call = visitor.Visit(expression.Body);
var includeVisitor = new IncludeVisitor();
call = includeVisitor.Visit(call);
includes = includeVisitor.Includes;
IList fromDb = visitor.Query.Provider.CreateQuery <TResult>(call).ToList();
if (typeof(TResult) == typeof(Object))
{
fromDb = ToOpenType(fromDb);
}
return(fromDb);
}
public void testQueryVisitor()
{
// Define Condition Values
var QEcontact_firstname = "Enrique";
// Instantiate QueryExpression QEcontact
var QEcontact = new QueryExpression("contact");
QEcontact.TopCount = 50;
// Add all columns to QEcontact.ColumnSet
QEcontact.ColumnSet.AllColumns = true;
// Define filter QEcontact.Criteria
QEcontact.Criteria.AddCondition("firstname", ConditionOperator.Equal, QEcontact_firstname);
QueryVisitor qe = new QueryVisitor();
qe.Visit(QEcontact);
}
public static IList ExecuteDb <T, TResult>(DbContext dataContext, Expression <Func <IQueryable <T>, IQueryable <TResult> > > expression)
{
IQueryable <T> query = GetQuerableDb <T>(dataContext);
var visitor = new QueryVisitor <T>(query);
Expression call = visitor.Visit(expression.Body);
var includeVisitor = new IncludeVisitor();
call = includeVisitor.Visit(call);
IList fromDb = query.Provider.CreateQuery <TResult>(call).ToList();
if (typeof(TResult) == typeof(Object))
{
fromDb = SortProperty(fromDb);
}
else
{
SetNullCollection(fromDb, includeVisitor.Includes);
}
return(fromDb);
}
private static SelectQuery RemoveContextFromQuery(TableBuilder.TableContext tableContext, SelectQuery query)
{
var clonedTableSource = tableContext.SelectQuery.From.Tables[0];
while (clonedTableSource.Joins.Count > 0)
{
var join = clonedTableSource.Joins[0];
tableContext.SelectQuery.From.Tables.Add(join.Table);
clonedTableSource.Joins.RemoveAt(0);
}
tableContext.SelectQuery.From.Tables.RemoveAt(0);
var queryVisitor = new QueryVisitor();
queryVisitor.Visit(query, e =>
{
if (e is SelectQuery selectQuery && selectQuery.From.Tables.Count > 0)
{
if (selectQuery.From.Tables[0].Source is SelectQuery subSelect)
{
if (subSelect.From.Tables.Count == 0)
{
if (!subSelect.Where.IsEmpty)
{
selectQuery.Where.ConcatSearchCondition(subSelect.Where.SearchCondition);
}
selectQuery.From.Tables.RemoveAt(0);
query.Walk(new WalkOptions(), qe =>
{
if (qe is SqlColumn column && column.Parent == subSelect)
{
return(column.Expression);
}
return(qe);
});
public void TestStringFldlenExpressionsFirebird(string expr, string expectedQuery)
{
Setup(expr);
CalcParser.ExpressionContext context = this._calcParser.expression();
DbTranslator translator = new FirebirdTranslator();
IMetadataResolver resolver = Substitute.For <IMetadataResolver>();
resolver
.GetField(Arg.Any <string>())
.Returns(callinfo => new FieldInfo
{
Name = callinfo.ArgAt <string>(0),
Type = DFM_FIELD_TYPE.DFM_FT_STRING
});
QueryVisitor visitor = new QueryVisitor(resolver, translator);
string query = visitor.Visit(context);
Assert.AreEqual(expectedQuery, query);
}
/// <summary>
/// Parst den übergeben String und gibt das Ergebnis als HttpQuery Objekt mit den Ergebnissen wieder zurück.
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public static HttpQuery Query(string query)
{
AntlrInputStream input = new AntlrInputStream(query);
var lexer = new HttpQueryLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
var parser = new HttpQueryParser(tokens);
var context = parser.init();
if (context.exception == null && parser.NumberOfSyntaxErrors == 0)
{
var visitor = new QueryVisitor<object>();
visitor.Visit(context);
return visitor.GetQuery();
}
else
{
return new HttpQuery() { Exception = new Exception("Syntax Error") };
}
}
