public string ParseExpression(QueryTree.FunctionExpression expression)
{
switch (expression.Name.ToLower())
{
case "charindexof":
return
$"(CHARINDEXOF({_parser.ParseExpression(expression.Arguments[0])}, {_parser.ParseExpression(expression.Arguments[1])}) > -1)";
}
throw new UnknownFunctionException();
}
private void AssertTree(QueryTree queryTree, params QueryMember[][] exptectedMembers)
{
var members = queryTree.GetEnumerator();
foreach (var expectedMember in exptectedMembers)
{
Assert.True(members.MoveNext());
AssertMembers(members.Current, expectedMember);
}
Assert.False(members.MoveNext());
}
public void QueryExpressionToStringTests_Simple()
{
var visitor = new QueryDebugger();
var type = typeof(int);
var lambdaAbstraction = DefaultQueryExpressionFactory.Instance.LambdaAbstraction(Expression.Lambda(Expression.Default(typeof(IEnumerable <int>))));
var lambdaAbstractionPredicate = DefaultQueryExpressionFactory.Instance.LambdaAbstraction((Expression <Func <Func <int, bool> > >)(() => _ => true));
var lambdaAbstractionSelector = DefaultQueryExpressionFactory.Instance.LambdaAbstraction((Expression <Func <Func <int, int> > >)(() => _ => _));
var lambdaAbstractionCount = DefaultQueryExpressionFactory.Instance.LambdaAbstraction((Expression <Func <int> >)(() => 42));
var monadMember = (MonadMember) new MonadAbstraction(type, lambdaAbstraction);
{
var op = new FirstOperator(type, monadMember);
Assert.AreEqual("@First(@MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1))))", visitor.Visit(op));
}
{
var op = new FirstPredicateOperator(type, monadMember, lambdaAbstractionPredicate);
Assert.AreEqual("@First(@MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1))), @LambdaAbstraction(() => _ => True))", visitor.Visit(op));
}
{
var op = new SelectOperator(type, type, monadMember, lambdaAbstractionSelector);
Assert.AreEqual("@Select(@MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1))), @LambdaAbstraction(() => _ => _))", visitor.Visit(op));
}
{
var op = new TakeOperator(type, monadMember, lambdaAbstractionCount);
Assert.AreEqual("@Take(@MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1))), @LambdaAbstraction(() => 42))", visitor.Visit(op));
}
{
var op = new WhereOperator(type, monadMember, lambdaAbstractionPredicate);
Assert.AreEqual("@Where(@MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1))), @LambdaAbstraction(() => _ => True))", visitor.Visit(op));
}
{
var ma = new MonadAbstraction(type, lambdaAbstraction);
Assert.AreEqual("@MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1)))", visitor.Visit(ma));
}
{
var lambda = Expression.Lambda(Expression.Default(typeof(int)), Expression.Parameter(typeof(IEnumerable <int>), "p"));
var parameters = new QueryTree[] { monadMember }.ToReadOnly();
var la = new LambdaAbstraction(lambda, parameters);
Assert.AreEqual("@LambdaAbstraction(p => default(Int32), @MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1))))", visitor.Visit(la));
}
}
private void PredicateCondition(QueryTree queryTree)
{
var predicate = new PredicateModel();
if (_lookaheadFirst.Value == null)
{
throw new ApplicationException("Illegal query detected, enclose strings with a beginning ' and ending '");
}
predicate.Field = _lookaheadFirst.Value;
DiscardToken();
predicate.Operator = GetOperator(_lookaheadFirst);
DiscardToken();
predicate.Value = _lookaheadFirst.Value;
DiscardToken();
queryTree.Insert(predicate);
}
private static bool ShouldTryAutoJoin(IQueryableColumn current, QueryTree queryTree)
{
if (!SchemaCompare.TablesAreSame(current.Table, queryTree.Table))
{
foreach (JoinPredicate join in queryTree.Joins)
{
if (SchemaCompare.TablesAreSame(join.ToColumn.Table, current.Table))
{
return(false);
}
}
return(true);
}
return(false);
}
public IDbCommand Process(QueryTree.Expression expression, IEnumerable<QueryTree.ConstantExpression> parameters, IMascisSession session)
{
var queryText = ParseExpression(expression);
var command = new SqlCommand(queryText) { CommandType = CommandType.Text };
foreach (var parameter in parameters)
{
command.Parameters.Add(new SqlParameter
{
Value = parameter.Value,
ParameterName = parameter.ParameterName
});
}
return command;
}
private void SubQueryCondition(QueryTree queryTree)
{
PredicateCondition(queryTree);
if (_lookaheadFirst.TokenType == TokenType.And)
{
queryTree.Insert(FilterQueryLogicalOperator.and);
DiscardToken();
SubQueryCondition(queryTree);
}
if (_lookaheadFirst.TokenType == TokenType.Or)
{
queryTree.Insert(FilterQueryLogicalOperator.or);
DiscardToken();
SubQueryCondition(queryTree);
}
}
public void SELECT1()
{
Database DB = new Database(@"C:\Users\Moataz\Workspace\Software\Database Architect\Active Code\DatabaseArchitect\Southwind\Database.db.txt");
DB.Read();
foreach (Table T in DB.Tables)
{
T.ReadRecords();
}
Query Q = new Query("SELECT Rating,Name,Rating FROM Projects WHERE Rating=90 or Name=\"Software Architect\" or Name=\"DatabaseArchitect\";");
QueryScanner QS = new QueryScanner(Q);
Q = QS.Scan();
QueryParser QP = new QueryParser(Q);
QueryTree QT = QP.Reorder();
QueryExecutioner QE = new QueryExecutioner(QT, DB, null);
Table Ti = QE.ExecuteQuery();
}
public void RightJoinTest()
{
Database DB = new Database(@"C:\Users\Moataz\Workspace\Software\Database Architect\Active Code\DatabaseArchitect\Southwind\Database.db.txt");
DB.Read();
foreach (Table T in DB.Tables)
{
T.ReadRecords();
}
Query Q = new Query("SELECT * FROM Projects RIGHT JOIN Grades ON GradeID=ID;");
QueryScanner QS = new QueryScanner(Q);
Q = QS.Scan();
QueryParser QP = new QueryParser(Q);
QueryTree QT = QP.Reorder();
QueryExecutioner QE = new QueryExecutioner(QT, DB, null);
Table Ti = QE.ExecuteQuery();
}
public QueryTree Parse(List <Token> tokens)
{
LoadSequenceStack(tokens);
PrepareLookaheads();
_queryTree = new List <QueryTree>();
Find();
DiscardToken(TokenType.SequenceTerminator);
var qtToReturn = new QueryTree();
foreach (var qt in _queryTree)
{
qtToReturn.Insert(qt.GetRoot());
}
return(qtToReturn);
}
static object ProcessQuery(Request Qr)
{
if (!(Qr.Attachment is string))
{
return("Invalid Query");
}
string Qs = Qr.Attachment as string;
Query Q = new Query(Qs);
try
{
QueryScanner QS = new QueryScanner(Q);
Q = QS.Scan();
QueryParser QP = new QueryParser(Q);
QueryTree Qt = QP.Reorder();
QueryExecutioner Qexec = new QueryExecutioner(Qt, Server.Database, ServerReaders.ReadRecords);
Table Ti = Qexec.ExecuteQuery();
if (Qexec.AfterEffect[0])
{
Server.Database.Write();
}
if (Qexec.AfterEffect[1])
{
Qexec.Tables.Last().Write();
}
if (Qexec.AfterEffect[2])
{
Qexec.Tables.Last().WriteRecords();
}
if (Ti == null)
{
return(Qexec.Result);
}
return(Ti);
}
catch (Exception Ex)
{
return(Ex.Message);
}
}
public void DeleteTest()
{
TokenType[] Tokens = { TokenType.DELETE_cmd, TokenType.FROM_KW, TokenType.Identifier_Table,
TokenType.WHERE_KW, TokenType.Identifier_Key, TokenType.LessThan, TokenType.Immediate_value, TokenType.SemiColon };
Query Q = new Query("Delete FROM Projects WHERE Rating<50;");
QueryScanner QS = new QueryScanner(Q);
Q = QS.Scan();
Assert.AreEqual(Q.QueryTokens.Count, Tokens.Count());
for (int i = 0; i < Q.QueryTokens.Count; i++)
{
if (Q.QueryTokens[i].Type != Tokens[i])
{
throw new Exception("Scanner logic failure, Expected " + Tokens[i].ToString() + "recieved " + Q.QueryTokens[i].Type.ToString());
}
}
QueryParser QP = new QueryParser(Q);
QueryTree QT = QP.Reorder();
}
public void UpdateTest()
{
Database DB = new Database(@"C:\Users\Moataz\Workspace\Software\Database Architect\Active Code\DatabaseArchitect\Southwind\Database.db.txt");
DB.Read();
foreach (Table T in DB.Tables)
{
T.ReadRecords();
}
Query Q = new Query("UPDATE Projects SET ID=1, Name=\"Database Architect\", Rating=100 WHERE ID=1;");
QueryScanner QS = new QueryScanner(Q);
Q = QS.Scan();
QueryParser QP = new QueryParser(Q);
QueryTree QT = QP.Reorder();
QueryExecutioner QE = new QueryExecutioner(QT, DB, null);
QE.ExecuteQuery();
}
public void CreateTest2()
{
TokenType[] Tokens = { TokenType.CREATE_cmd, TokenType.TABLE_KW, TokenType.Identifier_Table, TokenType.LBracket, TokenType.Identifier_Key,
TokenType.DATATYPE, TokenType.Comma, TokenType.Identifier_Key, TokenType.DATATYPE, TokenType.Comma, TokenType.Identifier_Key,
TokenType.DATATYPE, TokenType.RBracket, TokenType.SemiColon };
Query Q = new Query("CREATE TABLE Projects(ID int32,Name string,Rating int32);");
QueryScanner QS = new QueryScanner(Q);
Q = QS.Scan();
Assert.AreEqual(Q.QueryTokens.Count, Tokens.Count());
for (int i = 0; i < Q.QueryTokens.Count; i++)
{
if (Q.QueryTokens[i].Type != Tokens[i])
{
throw new Exception("Scanner logic failure, Expected " + Tokens[i].ToString() + "recieved " + Q.QueryTokens[i].Type.ToString());
}
}
QueryParser QP = new QueryParser(Q);
QueryTree QT = QP.Reorder();
}
private QueryTree GetAttributes(Type type, int depth, string rootName)
{
QueryTree result = new QueryTree(type, rootName);
try
{
foreach (var prop in type.GetProperties())
{
if (mRecordNames.Contains(prop.PropertyType))
{
if (depth == 0)
{
result.Add(GetAttributes(prop.PropertyType, depth + 1, prop.Name));
}
}
else if (prop.PropertyType.Name.Contains("ICollection"))
{
if (depth == 0)
{
result.Add(
GetAttributes(
prop.PropertyType.GenericTypeArguments.First(),
depth + 1,
prop.Name
)
);
}
}
else
{
result.Add(prop.PropertyType, prop.Name);
}
}
}
catch (TypeLoadException)
{
throw;
}
return(result);
}
public NoDataQuery(
IQueryable <TDto> source,
Parameters parameters,
IClassCache cache,
IEnumerable <ITuple <PathToProperty, SortDirection> > orderBy,
Expression selectExpandExpression,
Expression filterExpression,
ParameterExpression dtoParameterExpression,
QueryTree selectionTree)
{
Source = source;
Parameters = parameters;
SelectionTree = selectionTree;
SelectExpandExpression = selectExpandExpression;
DtoExpression = dtoParameterExpression;
FilterExpression = filterExpression;
OrderByPath = orderBy;
Cache = cache;
}
public void CheckQuerySemantic(QueryTree queryTree, Database databaseMetamodel)
{
Environment environment = new Environment {
classList = databaseMetamodel.classes,
parent = null,
section = Section.Target,
labelList = new List <string>(),
fields = new Dictionary <string, string>()
};
List <SemanticExceptionItem> exceptions = analize(queryTree, environment);
if (exceptions.Count > 0)
{
throw new SemanticException
{
exceptionList = exceptions
}
}
;
}
private static CommandBuilder GetSelectBuilder(QueryTree queryTree, ConstraintType constraintType)
{
SqlServerCommandBuilder commandBuilder = new SqlServerCommandBuilder(queryTree)
{
Distinct = queryTree.SelectWithDistinct
};
if (queryTree.Localized)
{
commandBuilder.JoinInWhereClause = false;
}
commandBuilder.Constrain(queryTree.SelectWithPaging ? Constraint.Page(queryTree.StartIndex, queryTree.PageSize) : queryTree.ResultConstraint);
for (QueryTree current = queryTree; current != null; current = current.Next)
{
if (constraintType != ConstraintType.Count)
{
commandBuilder.AppendSelect(current.RetrieveQueryColumns());
}
commandBuilder.AppendFrom(current.Table);
foreach (JoinPredicate joinPredicate in current.Joins)
{
commandBuilder.AppendWhere(joinPredicate);
}
foreach (ColumnPredicate columnPredicate in current.WherePredicates)
{
commandBuilder.AppendWhere(columnPredicate);
}
foreach (ColumnPredicate columnPredicate in current.HavingPredicates)
{
commandBuilder.AppendHaving((columnPredicate));
}
commandBuilder.AppendGroupBy(current.RetrieveGroupByColumns());
commandBuilder.AppendOrderBy(current.RetrieveOrderByColumns());
}
return(commandBuilder);
}
/// <summary>
/// Constructor</summary>
public DomNodeSearchToolStrip() : base()
{
// Define query tree, which defines the layout of the search toolstrip GUI
m_rootNode = new DomNodeQueryRoot();
QueryTree.AddLabel(m_rootNode, "Find node(s)");
// Add option to search DomNodes on either their name, or parameters
QueryOption searchNameOrParam = QueryTree.AddOption(m_rootNode);
QueryTreeDomNode.AddDomNodeNameQuery(QueryTree.AddOptionItem(searchNameOrParam, "whose name", 0), true);
QueryTreeDomNode.AddDomNodePropertyQuery(QueryTree.AddOptionItem(searchNameOrParam, "with a parameter", 0));
QueryTree.AddSeparator(m_rootNode);
m_rootNode.RegisterSearchButtonPress(QueryTree.AddButton(m_rootNode, "Search"));
// Entering text into the toolstrip will trigger a search, changing an option rebuilds the toolstrip GUI
m_rootNode.SearchTextEntered += searchSubStrip_SearchTextEntered;
m_rootNode.OptionChanged += searchSubStrip_OptionsChanged;
//
// Build toolStrip GUI by retrieving toolstrip item list from tree, and adding
// them to ToolStrip.Items
//
SuspendLayout();
List <ToolStripItem> toolStripItems = new List <ToolStripItem>();
m_rootNode.GetToolStripItems(toolStripItems);
Items.AddRange(toolStripItems.ToArray());
// Initialize ToolStrip
Location = new System.Drawing.Point(0, 0);
Name = "Event Sequence Document Search";
Size = new System.Drawing.Size(292, 25);
TabIndex = 0;
Text = "Event Sequence Document Search";
GripStyle = ToolStripGripStyle.Hidden;
// Done
ResumeLayout(false);
}
public void UpdateTest2()
{
TokenType[] Tokens = { TokenType.UPDATE_cmd, TokenType.Identifier_Table, TokenType.SET_cmd,
TokenType.Identifier_Key, TokenType.Equal, TokenType.Immediate_value,
TokenType.Comma, TokenType.Identifier_Key, TokenType.Equal,
TokenType.Immediate_value, TokenType.Comma, TokenType.Identifier_Key,
TokenType.Equal, TokenType.Immediate_value, TokenType.SemiColon };
Query Q = new Query("UPDATE Projects SET ID=1, Name=\"Database Architect\", Rating=100;");
QueryScanner QS = new QueryScanner(Q);
Q = QS.Scan();
Assert.AreEqual(Q.QueryTokens.Count, Tokens.Count());
for (int i = 0; i < Q.QueryTokens.Count; i++)
{
if (Q.QueryTokens[i].Type != Tokens[i])
{
throw new Exception("Scanner logic failure");
}
}
QueryParser QP = new QueryParser(Q);
QueryTree QT = QP.Reorder();
}
/// <summary>
/// Constructor</summary>
public DomNodeReplaceToolStrip()
{
// Define query tree, which defines the layout of the search toolstrip GUI
m_rootNode = new DomNodeQueryRoot();
QueryTree.AddLabel(m_rootNode, "Replace with");
m_replaceTextInput = QueryTree.AddReplaceTextInput(m_rootNode, null, false);
QueryTree.AddSeparator(m_rootNode);
m_rootNode.RegisterReplaceButtonPress(QueryTree.AddButton(m_rootNode, "Replace"));
// Entering text into the toolstrip will trigger a search, changing an option rebuilds the toolstrip GUI
m_rootNode.ReplaceTextEntered += replaceSubStrip_ReplaceTextEntered;
//
// Build toolStrip GUI by retrieving toolstrip item list from tree, and adding
// them to ToolStrip.Items
//
SuspendLayout();
List <ToolStripItem> toolStripItems = new List <ToolStripItem>();
m_rootNode.GetToolStripItems(toolStripItems);
Items.AddRange(toolStripItems.ToArray());
// Initialize ToolStrip
Location = new System.Drawing.Point(0, 0);
Name = "Event Sequence Document Replace";
Size = new System.Drawing.Size(292, 25);
TabIndex = 0;
Text = "Event Sequence Document Replace";
GripStyle = ToolStripGripStyle.Hidden;
// Done
ResumeLayout(false);
if (UIChanged != null)
{
}
}
private void AppendQueryOperand(QueryOperand operand)
{
_lastUnaryModifier = null;
if (_queryTree == null)
{
_queryTree = new QueryTree(operand);
_lastOperandNode = _queryTree.Root;
return;
}
if (_lastOperandNode.Left == null)
{
_lastOperandNode = _lastOperandNode.SetLeft(operand);
return;
}
if (_lastOperandNode.Right == null)
{
_lastOperandNode = _lastOperandNode.SetRight(operand);
return;
}
}
private void FindCondition()
{
var queryTree = new QueryTree();
if (_lookaheadFirst.TokenType == TokenType.OpenParenthesis)
{
DiscardToken();
SubQueryCondition(queryTree);
DiscardToken();
_queryTree.Add(queryTree);
}
var op = GetLogicalOperator(_lookaheadFirst);
if (op != null)
{
var singleNodeQT = new QueryTree();
singleNodeQT.Insert(op.Value);
_queryTree.Add(singleNodeQT);
DiscardToken();
FindCondition();
}
}
public string ParseExpression(QueryTree.Expression expression)
{
return ParseExpression(expression as QueryTree.FunctionExpression);
}
public string ParseExpression(QueryTree.AliasReferenceExpression expression)
{
return $"[{expression.TableAlias}].[{expression.Alias}]";
}
public string ParseExpression(QueryTree.Expression expression)
{
var parser = _parsers[expression.GetType()];
return parser.ParseExpression(expression);
}
public List <T> Query <T>(DbSet <T> set, QueryTree root) where T : class
{
List <T> result = new List <T>();
List <Func <object, bool> > checks = new List <Func <object, bool> >();
foreach (var a in root.Children)
{
if (a.HasChildren)
{
foreach (var b in a.Children)
{
if (b.Criterium != string.Empty)
{
bool foldLambda(object x)
{
object criterium = Convert.ChangeType(b.Criterium, b.ActualType);
var collection = x.GetType().GetProperty(a.Name).GetValue(x) as IEnumerable;
bool ok = false;
foreach (var inner in collection)
{
ok = b.CompareEquals
? criterium.Equals(x)
: !criterium.Equals(x);
if (ok)
{
break;
}
}
return(ok);
/*return a.CompareEquals
* ? collection.Any(item => criterium.Equals(x))
* : collection.Any(item => !criterium.Equals(x));*/
}
checks.Add(foldLambda);
}
}
}
else if (a.Criterium != string.Empty)
{
bool lambda(object x)
{
object criterium = Convert.ChangeType(a.Criterium, a.ActualType);
var val = x.GetType().GetProperty(a.Name).GetValue(x);
return(a.CompareEquals
? criterium.Equals(val)
: !criterium.Equals(val));
}
checks.Add(lambda);
}
}
foreach (var v in set)
{
bool ok = true;
foreach (var p in checks)
{
if (!p(v))
{
ok = false;
break;
}
}
if (ok)
{
result.Add(v);
}
}
return(result);
}
private string ParseExpression(QueryTree.AliasedExpression expression)
{
return $"{_parser.ParseExpression(expression.Expression)} [{expression.Alias}]";
}
public string ParseExpression(QueryTree.ColumnExpression expression)
{
return $"[{expression.TableAlias}].[{expression.Column}]";
}
private string ParseExpression(QueryTree.UpdateExpression expression)
{
var sb = new StringBuilder();
sb.Append("UPDATE " + _parser.ParseExpression(expression.Update));
sb.Append(" SET ");
sb.Append(string.Join(", ",
expression.Set.Select(x => $"{_parser.ParseExpression(x.Key)} = {_parser.ParseExpression(x.Value)}")
.ToArray()));
sb.Append(" WHERE ");
sb.Append(string.Join(" AND ", expression.Where.Select(x => _parser.ParseExpression(x))));
return sb.ToString();
}
public static string Run(string query, GraphQlSchema schema)
{
ParsedQuery parsedQuery = GraphQlParser.ParseQuery(query);
var schemaCursor = new GraphQlSchemaCursor(schema);
var queryTree = new QueryTree();
var queryTreeCursor = new QueryTreeCursor(queryTree);
var visitorLookup = new ParsedQueryNodeVisitorLookup();
visitorLookup.RegisterForNode<ParsedQuery>(new NullQueryParsedQueryNodeVisitor());
visitorLookup.RegisterForNode<ParsedField>(new FieldSelectionVisitor(schemaCursor, queryTreeCursor));
ParsedQueryTraverser.Traverse(parsedQuery, visitorLookup);
}
public string ParseExpression(QueryTree.TableExpression expression)
{
return $"[{expression.Table}] [{expression.TableAlias}]";
}
private string ParseExpression(QueryTree.InsertExpression expression)
{
var qb = new StringBuilder();
qb.Append("INSERT INTO ");
qb.Append(_parser.ParseExpression(expression.Into));
qb.Append("(");
qb.Append(string.Join(",", expression.Columns.Select(x => _parser.ParseExpression(x)).ToArray()));
qb.Append(")");
qb.Append(_parser.ParseExpression(expression.From));
return qb.ToString();
}
/// <summary>
/// Creates a representation of a select query expression operator.
/// </summary>
/// <param name="elementType">The element type of the resulting monad.</param>
/// <param name="inputElementType">The input type of the source monad.</param>
/// <param name="source">The source to map from.</param>
/// <param name="selector">The projection function used to map from the source.</param>
protected internal SelectOperator(Type elementType, Type inputElementType, MonadMember source, QueryTree selector)
: base(elementType)
{
InputElementType = inputElementType;
Source = source;
Selector = selector;
}
private string ParseExpression(QueryTree.UnAliasedTableExpression expression)
{
return $"[{expression.Table}]";
}
private string ParseExpression(QueryTree.UnAliasedColumnExpression expression)
{
return $"[{expression.Column}]";
}
private string ParseExpression(QueryTree.ConstantExpression expression)
{
if (expression.Value == null)
{
return "NULL";
}
return $"@{expression.ParameterName}";
}
private string ParseExpression(QueryTree.ValueGroupExpression expression)
{
return $"VALUES ({string.Join(",", expression.Values.Select(x => _parser.ParseExpression(x)).ToArray())})";
}
public string ParseExpression(QueryTree.Expression expression)
{
return ParseExpression(expression as QueryTree.ConstantExpression);
}
public SqlServerCommandBuilder(QueryTree query) : base(query)
{
}
public QueryTreeCursor(QueryTree queryTree)
{
Current = queryTree;
}
public string ParseExpression(QueryTree.FromExpression expression)
{
return $"FROM {_parser.ParseExpression(expression.Table)} ";
}
public string ParseExpression(QueryTree.Expression expression)
{
return ParseExpression(expression as QueryTree.AliasedExpression);
}
private string ParseExpression(QueryTree.SelectExpression expression)
{
var qb = new StringBuilder();
qb.Append("SELECT ");
foreach (var column in expression.Values)
{
qb.Append(_parser.ParseExpression(column));
qb.Append(expression.Values.IndexOf(column) + 1 < expression.Values.Count ? ", " : " ");
}
if (expression.From != null)
{
qb.Append(_parser.ParseExpression(expression.From));
foreach (var join in expression.Join)
{
qb.Append(_parser.ParseExpression(join));
}
if (expression.Where.Any())
{
qb.Append("WHERE ");
foreach (var where in expression.Where)
{
qb.Append(_parser.ParseExpression(where));
qb.Append(expression.Where.IndexOf(@where) + 1 < expression.Where.Count ? " AND " : " ");
}
}
}
return qb.ToString();
}
public QueryTree Optimize(QueryTree queryTree) => _optimize(queryTree);
private string ParseExpression(QueryTree.BinaryExpression expression)
{
string op;
switch (expression.Operator)
{
case QueryTree.BooleanOperator.Add:
op = " + ";
break;
case QueryTree.BooleanOperator.And:
op = " AND ";
break;
case QueryTree.BooleanOperator.Equal:
op = " = ";
break;
case QueryTree.BooleanOperator.GreaterThan:
op = " > ";
break;
case QueryTree.BooleanOperator.GreaterThanOrEqualTo:
op = " >= ";
break;
case QueryTree.BooleanOperator.LessThan:
op = " < ";
break;
case QueryTree.BooleanOperator.LessThanOrEqualTo:
op = " <= ";
break;
case QueryTree.BooleanOperator.Or:
op = " OR ";
break;
default:
throw new UnknownOperatorException();
}
return $"({_parser.ParseExpression(expression.Left)} {op} {_parser.ParseExpression(expression.Right)})";
}
public void Add(QueryTree node)
{
Children.Add(node);
}
public string ParseExpression(QueryTree.Expression expression)
{
return ParseExpression(expression as QueryTree.BinaryExpression);
}
/// <summary>
/// Creates a representation of a first query expression operator with a predicate.
/// </summary>
/// <param name="elementType">The element type of the resulting monad.</param>
/// <param name="source">The source on which to filter.</param>
/// <param name="predicate">The function used to filter.</param>
protected internal FirstPredicateOperator(Type elementType, MonadMember source, QueryTree predicate)
: base(elementType)
{
Source = source;
Predicate = predicate;
}
public string ParseExpression(QueryTree.Expression expression)
{
return ParseExpression(expression as QueryTree.ValueGroupExpression);
}
/// <summary>
/// Appends a new <see cref="EntitySet{T}"/> to the end of this instance.
/// </summary>
/// <remarks>
/// <para>
/// <see cref="EntitySet{T}"/> objects appended to this instance will be returned as additional results when
/// using <see cref="CommandBase{T}.FetchReader"/> and additional <see cref="DataTable"/> objects in the
/// <see cref="DataSet"/> returned from <see cref="CommandBase{T}.FetchDataSet"/></para>
/// <para>
/// Use <see cref="IDataReader.NextResult"/> to access the result of the batched queries.</para>
/// </remarks>
/// <param name="entitySet">The <see cref="EntitySet{T}"/> to append to this instance.</param>
public void Append <TNext>(EntitySet <TNext> entitySet) where TNext : DataRecord <TNext>, new()
{
QueryTree.AppendQuery(entitySet.QueryTree);
}
public string ParseExpression(QueryTree.Expression expression)
{
return ParseExpression(expression as QueryTree.UpdateExpression);
}
public UtilsDef(ref QueryTree view, int ID_USER)
{
Class_ManageSettingInstance v_s = new Class_ManageSettingInstance();
List <SettingIRPClass> Las_NameCat = Class_ManageSettingInstance.GetSettingWebQuery("XWEB_QUERY");
string Role = v_s.GetRoleUser(ID_USER != ConnectDB.NullI ? ID_USER : -1) != "" ? v_s.GetRoleUser(ID_USER != ConnectDB.NullI ? ID_USER : -1) : RolesUsers.Guest.ToString();
view.Root = new QueryTreeNode();
view.Style = new QueryTreeStyle();
view.Root.Name = MAIN_MENU_ROOT;
view.Root.Description = "";
view.Root.Title = MAIN_MENU_ROOT;
List <QueryTreeNode> L_Categ = new List <QueryTreeNode>();
QueryTreeNode Tnode_PUBLIC_VIEW_SPECTRUM_MANAGEMENT = AddCategoryNode(ref view, MAIN_MENU_PUBLIC_VIEW_SPECTRUM_MANAGEMENT, MAIN_MENU_PUBLIC_VIEW_SPECTRUM_MANAGEMENT, ""); L_Categ.Add(Tnode_PUBLIC_VIEW_SPECTRUM_MANAGEMENT);
QueryTreeNode Tnode_USER_CUST_STATION_LIST = AddCategoryNode(ref view, MAIN_MENU_AUTH_USER_CUST_STATION_LIST, MAIN_MENU_AUTH_USER_CUST_STATION_LIST, ""); L_Categ.Add(Tnode_USER_CUST_STATION_LIST);
QueryTreeNode Tnode_USER_DELEG_STATION_LIST = AddCategoryNode(ref view, MAIN_MENU_AUTH_USER_DELEG_STATION_LIST, MAIN_MENU_AUTH_USER_DELEG_STATION_LIST, ""); L_Categ.Add(Tnode_USER_DELEG_STATION_LIST);
QueryTreeNode Tnode_CUST_STATION_LIST1 = AddCategoryNode(ref view, MAIN_MENU_AUTH_USER_LT1, MAIN_MENU_AUTH_USER_LT1, ""); L_Categ.Add(Tnode_CUST_STATION_LIST1);
QueryTreeNode Tnode_CUST_STATION_LIST2 = AddCategoryNode(ref view, MAIN_MENU_AUTH_USER_LT2, MAIN_MENU_AUTH_USER_LT2, ""); L_Categ.Add(Tnode_CUST_STATION_LIST2);
QueryTreeNode Tnode_AUTH_USER_ISV = AddCategoryNode(ref view, MAIN_MENU_AUTH_USER_ISV, MAIN_MENU_AUTH_USER_ISV, ""); L_Categ.Add(Tnode_AUTH_USER_ISV);
QueryTreeNode Tnode_AUTH_HEALTH_CARE = AddCategoryNode(ref view, MAIN_MENU_AUTH_HEALTH_CARE, MAIN_MENU_AUTH_HEALTH_CARE, ""); L_Categ.Add(Tnode_AUTH_HEALTH_CARE);
if (Las_NameCat != null)
{
foreach (SettingIRPClass item in Las_NameCat)
{
if ((item.IS_TESTING_REQUEST) && (RolesUsers.Admin.ToString() != Role))
{
continue;
}
if ((RolesUsers.Admin.ToString() == Role) || (RolesUsers.Provider.ToString() == Role) || (RolesUsers.Provider_Government.ToString() == Role) || (RolesUsers.Provider_Healthcare.ToString() == Role))
{
if (TypeStatus.LT1 == item.STATUS_)
{
AddNode(ref view, item.STATUS_.ToString(), item.ID, item.NAME, item.NAME, item.DESCRIPTION, ref Tnode_CUST_STATION_LIST1.ChildNodes);
}
}
if ((RolesUsers.Admin.ToString() == Role) || (RolesUsers.Provider.ToString() == Role) || (RolesUsers.Provider_Government.ToString() == Role) || (RolesUsers.Provider_Healthcare.ToString() == Role))
{
if (TypeStatus.LT2 == item.STATUS_)
{
AddNode(ref view, item.STATUS_.ToString(), item.ID, item.NAME, item.NAME, item.DESCRIPTION, ref Tnode_CUST_STATION_LIST2.ChildNodes);
}
}
if ((RolesUsers.Admin.ToString() == Role) || (RolesUsers.Provider.ToString() == Role) || (RolesUsers.Government.ToString() == Role) || (RolesUsers.HealthCare.ToString() == Role) || (RolesUsers.Guest.ToString() == Role) || (RolesUsers.Government_Healthcare.ToString() == Role) || (RolesUsers.Provider_Government.ToString() == Role) || (RolesUsers.Provider_Healthcare.ToString() == Role))
{
if (TypeStatus.PUB == item.STATUS_)
{
AddNode(ref view, item.STATUS_.ToString(), item.ID, item.NAME, item.NAME, item.DESCRIPTION, ref Tnode_PUBLIC_VIEW_SPECTRUM_MANAGEMENT.ChildNodes);
}
}
if ((RolesUsers.Admin.ToString() == Role) || (RolesUsers.Provider.ToString() == Role) || (RolesUsers.Provider_Government.ToString() == Role) || (RolesUsers.Provider_Healthcare.ToString() == Role))
{
if (TypeStatus.CUS == item.STATUS_)
{
AddNode(ref view, item.STATUS_.ToString(), item.ID, item.NAME, item.NAME, item.DESCRIPTION, ref Tnode_USER_CUST_STATION_LIST.ChildNodes);
}
}
if ((RolesUsers.Admin.ToString() == Role) || (RolesUsers.Provider.ToString() == Role) || (RolesUsers.Provider_Government.ToString() == Role) || (RolesUsers.Provider_Healthcare.ToString() == Role))
{
if (TypeStatus.DSL == item.STATUS_)
{
AddNode(ref view, item.STATUS_.ToString(), item.ID, item.NAME, item.NAME, item.DESCRIPTION, ref Tnode_USER_DELEG_STATION_LIST.ChildNodes);
}
}
if ((RolesUsers.Admin.ToString() == Role) || (RolesUsers.Government.ToString() == Role) || (RolesUsers.Provider_Government.ToString() == Role) || (RolesUsers.Government_Healthcare.ToString() == Role))
{
if (TypeStatus.ISV == item.STATUS_)
{
AddNode(ref view, item.STATUS_.ToString(), item.ID, item.NAME, item.NAME, item.DESCRIPTION, ref Tnode_AUTH_USER_ISV.ChildNodes);
}
}
if ((RolesUsers.Admin.ToString() == Role) || (RolesUsers.HealthCare.ToString() == Role) || (RolesUsers.Provider_Healthcare.ToString() == Role) || (RolesUsers.Government_Healthcare.ToString() == Role))
{
if (TypeStatus.HCC == item.STATUS_)
{
AddNode(ref view, item.STATUS_.ToString(), item.ID, item.NAME, item.NAME, item.DESCRIPTION, ref Tnode_AUTH_HEALTH_CARE.ChildNodes);
}
}
}
}
view.Root.ChildNodes = L_Categ.ToArray();
}
public string ParseExpression(QueryTree.Expression expression)
{
return ParseExpression(expression as QueryTree.SelectExpression);
}
public void QueryExpressionEqualityComparer_Simple()
{
var type1 = typeof(int);
var type2 = typeof(bool);
var monadMember1 = (MonadMember) new MonadAbstraction(type1, inner: null);
var monadMember2 = (MonadMember) new MonadAbstraction(type2, inner: null);
var lambdaAbstraction1 = new LambdaAbstraction(Expression.Lambda(Expression.Constant(42)), EmptyReadOnlyCollection <QueryTree> .Instance);
var lambdaAbstraction2 = new LambdaAbstraction(Expression.Lambda(Expression.Empty()), EmptyReadOnlyCollection <QueryTree> .Instance);
foreach (dynamic comparer in new object[] {
new QueryExpressionEqualityComparer(),
new QueryExpressionEqualityComparator(),
new QueryTreeDerivedClassEqualityComparer()
})
{
{
var op = new FirstOperator(type1, monadMember1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new FirstOperator(type1, monadMember1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new FirstOperator(type2, monadMember1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new FirstOperator(type1, monadMember2);
Assert.IsFalse(comparer.Equals(op, op4));
}
{
var op = new FirstPredicateOperator(type1, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new FirstPredicateOperator(type1, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new FirstPredicateOperator(type2, monadMember1, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new FirstPredicateOperator(type1, monadMember2, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op4));
var op5 = new FirstPredicateOperator(type1, monadMember1, lambdaAbstraction2);
Assert.IsFalse(comparer.Equals(op, op5));
}
{
var type3 = typeof(long);
var type4 = typeof(double);
var op = new SelectOperator(type1, type3, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new SelectOperator(type1, type3, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new SelectOperator(type2, type3, monadMember1, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new SelectOperator(type2, type4, monadMember1, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op4));
var op5 = new SelectOperator(type1, type3, monadMember2, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op5));
var op6 = new SelectOperator(type1, type3, monadMember1, lambdaAbstraction2);
Assert.IsFalse(comparer.Equals(op, op6));
}
{
var op = new TakeOperator(type1, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new TakeOperator(type1, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new TakeOperator(type2, monadMember1, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new TakeOperator(type1, monadMember2, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op4));
var op5 = new TakeOperator(type1, monadMember1, lambdaAbstraction2);
Assert.IsFalse(comparer.Equals(op, op5));
}
{
var op = new WhereOperator(type1, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new WhereOperator(type1, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new WhereOperator(type2, monadMember1, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new WhereOperator(type1, monadMember2, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op4));
var op5 = new WhereOperator(type1, monadMember1, lambdaAbstraction2);
Assert.IsFalse(comparer.Equals(op, op5));
}
{
var op = new MonadAbstraction(type1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new MonadAbstraction(type1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new MonadAbstraction(type2, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new MonadAbstraction(type1, lambdaAbstraction2);
Assert.IsFalse(comparer.Equals(op, op4));
}
{
var p1 = Expression.Parameter(type1);
var p2 = Expression.Parameter(type2);
var lambda1 = Expression.Lambda(p1, p1);
var lambda2 = Expression.Lambda(Expression.Constant(41), p2);
var lambda3 = Expression.Lambda(p2, p2);
var parameters1 = new QueryTree[] { monadMember1 }.ToReadOnly();
var parameters2 = new QueryTree[] { monadMember2 }.ToReadOnly();
var op = new LambdaAbstraction(lambda1, parameters1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new LambdaAbstraction(lambda1, parameters1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new LambdaAbstraction(lambda2, parameters1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new LambdaAbstraction(lambda1, parameters2);
Assert.IsFalse(comparer.Equals(op, op4));
var op5 = new LambdaAbstraction(lambda3, parameters1);
Assert.IsTrue(comparer.Equals(op, op5));
}
{
var op = new FirstOperator(type1, monadMember1);
Assert.IsFalse(comparer.Equals(op, lambdaAbstraction1));
}
}
}
public string ParseExpression(QueryTree.JoinExpression expression)
{
var includeAlias = expression.Table is QueryTree.SelectExpression;
var alias = includeAlias ? _parser.ParseExpression(expression.Alias) : null;
return
$"JOIN {_parser.ParseExpression(expression.Table)} {alias} ON {_parser.ParseExpression(expression.On)} ";
}
