public void ParseWhere_WhenSingleWhereStatement_ExpectWhereNodeBack()
{
// Arrange
var mockWhereStatementParser = new Mock <IWhereStatementParser>();
mockWhereStatementParser
.Setup(r => r.ParseStatement(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new EqualsOperator {
Statement = "name:test", Name = "name", CaseInsensitive = false, Value = "test", IsNot = false
});
var whereParser = new WhereParser(mockWhereStatementParser.Object, new ParserOptions());
// Act
var stopwatch = Stopwatch.StartNew();
var whereNode = whereParser.ParseWhere("name:test");
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
var expected = new WhereNode
{
Statement = new WhereStatement {
Value = new EqualsOperator {
Statement = "name:test", Name = "name", CaseInsensitive = false, Value = "test", IsNot = false
}, As = null,
}
};
whereNode.ShouldDeepEqual(expected);
}
/// <summary>
/// Formats the local.
/// </summary>
/// <param name="whereNode">The where node.</param>
/// <param name="paramSuffix">The parameter suffix.</param>
/// <returns>The <see cref="SqlDataResponse"/>.</returns>
private SqlDataResponse FormatLocal(WhereNode whereNode, int paramSuffix)
{
var statementValue = whereNode.Statement.Value;
if (statementValue is EqualsOperator equalsOperator)
{
return(this.equalsFormatter.Format(equalsOperator, paramSuffix));
}
if (statementValue is LessThanOperator lessThanOperator)
{
return(this.lessThanFormatter.Format(lessThanOperator, paramSuffix));
}
if (statementValue is GreaterThanOperator greaterThanOperator)
{
return(this.greaterThanFormatter.Format(greaterThanOperator, paramSuffix));
}
if (statementValue is RangeOperator rangeOperator)
{
return(this.rangeFormatter.Format(rangeOperator, paramSuffix));
}
throw new SqlParseException($"Invalid statementValue type {statementValue.GetType().Name}");
}
private CommandNode ResolveCommand(Dictionary <string, string> variables, XmlElement element)
{
var cmd = new CommandNode();
foreach (XmlNode item in element.ChildNodes)
{
if (item.NodeType == XmlNodeType.Text)
{
var text = ReplaceVariable(variables, item.Value);
cmd.Nodes.Add(new TextNode
{
Value = text
});
}
else if (item.NodeType == XmlNodeType.Element && item.Name == "where")
{
var whereNode = new WhereNode();
foreach (XmlNode iitem in item.ChildNodes)
{
if (iitem.NodeType == XmlNodeType.Text)
{
var text = ReplaceVariable(variables, iitem.Value);
whereNode.Nodes.Add(new TextNode
{
Value = text
});
}
else if (iitem.NodeType == XmlNodeType.Element && iitem.Name == "if")
{
var test = iitem.Attributes["test"].Value;
var value = string.IsNullOrEmpty(iitem.InnerText) ?
(iitem.Attributes["value"]?.Value ?? string.Empty) : iitem.InnerText;
value = ReplaceVariable(variables, value);
whereNode.Nodes.Add(new IfNode
{
Test = test,
Value = value
});
}
}
cmd.Nodes.Add(whereNode);
}
else if (item.NodeType == XmlNodeType.Element && item.Name == "if")
{
var test = item.Attributes["test"].Value;
var value = string.IsNullOrEmpty(item.InnerText) ?
(item.Attributes["value"]?.Value ?? string.Empty) : item.InnerText;
value = ReplaceVariable(variables, value);
cmd.Nodes.Add(new IfNode
{
Test = test,
Value = value
});
}
}
return(cmd);
}
void WhereClause(QueryNode parent)
{
QueryNode node, expr;
node = new WhereNode();
ExprSpec(out expr);
node.Add(expr);
parent.Add(node);
}
private CommandNode ResolveCommand(XmlElement element)
{
var cmd = new CommandNode();
foreach (XmlNode item in element.ChildNodes)
{
if (item.Name == "var" || item.NodeType == XmlNodeType.Comment)
{
continue;
}
if (item.NodeType == XmlNodeType.Text)
{
cmd.Nodes.Add(new TextNode
{
Value = item.Value
});
}
else if (item.NodeType == XmlNodeType.Element && item.Name == "where")
{
var whereNode = new WhereNode();
foreach (XmlNode iitem in item.ChildNodes)
{
if (iitem.NodeType == XmlNodeType.Text)
{
whereNode.Nodes.Add(new TextNode
{
Value = iitem.Value
});
}
else if (iitem.NodeType == XmlNodeType.Element && iitem.Name == "if")
{
var test = iitem.Attributes["test"].Value;
var value = string.IsNullOrEmpty(iitem.InnerText) ?
(iitem.Attributes["value"]?.Value ?? string.Empty) : iitem.InnerText;
whereNode.Nodes.Add(new IfNode
{
Test = test,
Value = value
});
}
}
cmd.Nodes.Add(whereNode);
}
else if (item.NodeType == XmlNodeType.Element && item.Name == "if")
{
var test = item.Attributes["test"].Value;
var value = string.IsNullOrEmpty(item.InnerText) ?
(item.Attributes["value"]?.Value ?? string.Empty) : item.InnerText;
cmd.Nodes.Add(new IfNode
{
Test = test,
Value = value
});
}
}
return(cmd);
}
public void Format_WhenSingleNode_ExpectWhereStatement()
{
// Arrange
var mockEqualsFormatter = new Mock <IWhereOperatorFormatter <EqualsOperator> >();
var mockLessThanFormatter = new Mock <IWhereOperatorFormatter <LessThanOperator> >();
var mockGreaterThanFormatter = new Mock <IWhereOperatorFormatter <GreaterThanOperator> >();
var mockRangeFormatter = new Mock <IWhereOperatorFormatter <RangeOperator> >();
mockEqualsFormatter
.Setup(r => r.Format(It.IsAny <EqualsOperator>(), It.IsAny <int>()))
.Returns(new SqlDataResponse
{
Sql = "ColumnName = @ColumnName1",
LastSuffix = 1,
Params = new List <SqlWhereParam> {
new SqlWhereParam {
Value = "bob", VarName = "ColumnName1"
}
},
});
var whereFormatter = new WhereFormatter(
mockEqualsFormatter.Object,
mockLessThanFormatter.Object,
mockGreaterThanFormatter.Object,
mockRangeFormatter.Object);
var op = new EqualsOperator
{
Name = "ColumnName",
IsNot = false,
Statement = "ColumnName:bob",
Value = "bob",
};
var whereNode = new WhereNode
{
Statement = new WhereStatement {
Value = op
},
};
// Act
var stopwatch = Stopwatch.StartNew();
var sqlDataResponse = whereFormatter.Format(whereNode);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(sqlDataResponse, Is.Not.Null);
Assert.That(sqlDataResponse.Sql, Is.EqualTo($"WHERE ColumnName = @ColumnName1{Environment.NewLine}"));
Assert.That(sqlDataResponse.Params.First(r => r.VarName == "ColumnName1").Value, Is.EqualTo("bob"));
}
public virtual void Visit(WhereNode node)
{
Expression sequence = _visitor.Nodes.Peek();
this._visitor.ScopedParamters.Push(Expression.Parameter(sequence.GetElementType(), "item_" + sequence.GetElementType().Name));
this._visitor.ScopedParamters.Push(Expression.Parameter(typeof(int), "item_i"));
SetQueryPart(QueryPart.Where);
node.Expression.Accept(this);
node.Accept(_visitor);
}
public void Format_WhenBinaryNode_ExpectWhereStatement()
{
// Arrange
var equalsFormatter = new EqualsFormatter();
var lessThanFormatter = new LessThanFormatter();
var greaterThanFormatter = new GreaterThanFormatter();
var rangeFormatter = new RangeFormatter();
var whereFormatter = new WhereFormatter(
equalsFormatter,
lessThanFormatter,
greaterThanFormatter,
rangeFormatter);
var whereNode2 = new WhereNode
{
Statement = new WhereStatement
{
Value = new EqualsOperator
{
Name = "FirstName",
IsNot = false,
Statement = "FirstName:asd",
Value = "asd",
},
},
};
var whereNode = new WhereNode
{
Statement = new WhereStatement
{
Value = new EqualsOperator
{
Name = "ColumnName",
IsNot = false,
Statement = "ColumnName:bob",
Value = "bob",
},
},
Conjunctive = Conjunctives.And,
Next = whereNode2,
};
// Act
var stopwatch = Stopwatch.StartNew();
var sqlDataResponse = whereFormatter.Format(whereNode);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Console.WriteLine(sqlDataResponse.Sql);
}
/// <inheritdoc />
public IQuery Where(WhereNode node)
{
if (node == null)
{
return(this);
}
node.Next = this.WhereNode;
this.WhereNode = node;
return(this);
}
public override AbstractNode VisitWhere([NotNull] GiraphParser.WhereContext context)
{
WhereNode WNode = new WhereNode(context.Start.Line, context.Start.Column);
WNode.AdoptChildren(Visit(context.simpleBoolCompOrExp()));
/*foreach (var Child in context.boolComparisons().children)
* {
* WNode.AdoptChildren(Visit(Child));
* }*/
return(WNode);
}
protected WhereNode AddWhereNode(WhereNode left, WhereNode right)
{
if (left == null)
{
return(right);
}
if (right == null)
{
return(left);
}
return(left && right);
}
public void ParseWhere_WhenAndStatementWithAs_ExpectWhereNodesBack()
{
// Arrange
var mockWhereStatementParser = new Mock <IWhereStatementParser>();
mockWhereStatementParser
.SetupSequence(r => r.ParseStatement(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new EqualsOperator {
Statement = "name:test", Name = "name", CaseInsensitive = false, Value = "test", IsNot = false
})
.Returns(new EqualsOperator {
Statement = "name2:test2", Name = "name2", CaseInsensitive = false, Value = "test2", IsNot = false
});
var whereParser = new WhereParser(mockWhereStatementParser.Object, new ParserOptions());
// Act
var stopwatch = Stopwatch.StartNew();
var whereNode = whereParser.ParseWhere("name:test as string and name2:test2");
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
var expected1 = new WhereNode
{
Statement = new WhereStatement {
Value = new EqualsOperator {
Statement = "name2:test2", Name = "name2", CaseInsensitive = false, Value = "test2", IsNot = false
}, As = null,
}
};
var expected2 = new WhereNode
{
Statement = new WhereStatement {
Value = new EqualsOperator {
Statement = "name:test", Name = "name", CaseInsensitive = false, Value = "test", IsNot = false
}, As = "string",
},
Conjunctive = Conjunctives.And,
Next = expected1,
};
whereNode.ShouldDeepEqual(expected2);
}
protected QueryBase VisitWhere(WhereNode node, ElasticQueryMapperState state)
{
var query1 = Visit(node.PredicateNode, state);
var query2 = Visit(node.SourceNode, state);
if (query1 is IMatchAllQuery && query2 is IMatchAllQuery)
{
return(query1);
}
// If one of them is not MatchAll, then return that one
if (query1 is IMatchAllQuery || query2 is IMatchAllQuery)
{
return(query1 is IMatchAllQuery ? query2 : query1);
}
return(query1 && query2);
}
public void ParseWhere_WhenTwoParts_ExpectBinaryNode()
{
// Arrange
var rangeParser = new RangeParser();
var equalsParser = new EqualsParser();
var entityParser = new EntityParser <CustomEntity>();
var typeSplitter = new TypeSplitter();
var whereStatementParser = new WhereStatementParser <CustomEntity>(rangeParser, equalsParser, entityParser, typeSplitter);
var whereParser = new WhereParser(whereStatementParser, new ParserOptions());
// Act
var stopwatch = Stopwatch.StartNew();
var whereNode = whereParser.ParseWhere("testKey:testValue and testKey2:[23,2]");
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
var next1 = new WhereNode
{
Conjunctive = Conjunctives.None,
Next = null,
Statement = new WhereStatement {
As = null, Value = new RangeOperator {
Statement = "testKey2:[23,2]", Name = "testKey2", Lower = 23, LowerInclusive = false, Upper = 2, UpperInclusive = false
}
}
};
var expected = new WhereNode
{
Conjunctive = Conjunctives.And,
Next = next1,
Statement = new WhereStatement {
As = null, Value = new EqualsOperator {
Statement = "testKey:testValue", Name = "testKey", CaseInsensitive = false, Value = "testValue", IsNot = false
}
}
};
whereNode.ShouldDeepEqual(expected);
}
protected virtual QueryNode VisitWhere(WhereNode node, ElasticSearchQueryOptimizerState state)
{
var node2 = Visit(node.SourceNode, state);
var node3 = Visit(node.PredicateNode, state);
var boolValue = GetBoolValue(node3);
if (!boolValue.HasValue)
{
if (node2 is MatchAllNode)
{
return(node3);
}
if (node2 is MatchNoneNode)
{
return(node2);
}
return(new WhereNode(node3, node2));
}
return(boolValue.Value ? node2 : new MatchNoneNode());
}
/// <summary>
/// Formats the specified where node.
/// </summary>
/// <param name="whereNode">The where node.</param>
/// <returns>The <see cref="SqlDataResponse" />.</returns>
public SqlDataResponse Format(WhereNode whereNode)
{
if (whereNode == null)
{
return(null);
}
var sb = new StringBuilder();
var index = 0;
var node = whereNode;
var paramList = new List <SqlWhereParam>();
do
{
var sqlDataResponse = this.FormatLocal(node, index);
sb.AppendFormat("{0}\r\n", sqlDataResponse.Sql);
paramList = paramList.Concat(sqlDataResponse.Params).ToList();
if (node.Next != null)
{
sb.AppendFormat(" {0} ", node.Conjunctive);
}
index = sqlDataResponse.LastSuffix + 1;
node = node.Next;
}while (node != null);
if (sb.Length == 0)
{
return(null);
}
sb.Insert(0, "WHERE ");
return(new SqlDataResponse
{
Sql = sb.ToString(),
Params = paramList,
LastSuffix = index,
});
}
public override void Visit(WhereNode node)
{
// Where node is very special, because, it expects it AttributeClass to be set
// This is done because it needs to know what Class val should be.
SymbolTable.SetCurrentNode(node);
SymbolTable.OpenScope(BlockType.WhereStatement);
// Adds val to the symbol table.
SymbolTable.EnterSymbol("val", node.AttributeClass, IgnoreReserved: true);
// Opens val as a new scope, since this will fix bugs later
// This is very much a ugly hack, but it was simple to implement and it works
SymbolTable.OpenScope("val");
// Adds all variables from the class val is, if its a class, else its ignored later
SymbolTable.AddClassVariablesToScope(node.AttributeClass);
// Close the newly created val scope. Since its only needed for the val expressions.
SymbolTable.CloseScope();
// Visit the children if the where condition, this involves all the differnet bool comparison.
// These can now use the val, and all the attributes on the val node assiociated with the val class
// Seems very complex, and it is... Ask Thue....
VisitChildren(node);
SymbolTable.CloseScope();
}
protected virtual BaseQuery HandleWhere(WhereNode node, ElasticSearchQueryMapperState state)
{
var query1 = Handle(node.PredicateNode, state);
var query2 = Handle(node.SourceNode, state);
if (query1 == Query.MatchAll() && query2 == Query.MatchAll())
{
return(query1);
}
if (query1 == Query.MatchAll() || query2 == Query.MatchAll())
{
if (query1 != Query.MatchAll())
{
return(query1);
}
if (query2 != Query.MatchAll())
{
return(query2);
}
}
return(query1 & query2);
}
/// <summary>
/// Parses the statements.
/// </summary>
/// <param name="last">The last.</param>
/// <param name="statements">The statements.</param>
/// <param name="index">The index.</param>
/// <returns>The <see cref="WhereNode"/>.</returns>
private WhereNode ParseStatements(WhereNode last, List <string> statements, int index)
{
var whereStatement = this.ParseLocal(statements, index);
index = whereStatement.index;
if (index == statements.Count)
{
return(new WhereNode {
Conjunctive = Conjunctives.None, Next = null, Statement = whereStatement.where
});
}
if (statements[index] == "and")
{
if (!this.parserOptions.AllowAnd)
{
throw new ParseException("where:: operator 'and' is not permitted on this query.");
}
last.Conjunctive = Conjunctives.And;
}
if (statements[index] == "or")
{
if (!this.parserOptions.AllowOr)
{
throw new ParseException("where:: operator 'or' is not permitted on this query.");
}
last.Conjunctive = Conjunctives.Or;
}
last.Statement = whereStatement.where;
last.Next = this.ParseStatements(new WhereNode(), statements, index + 1);
return(last);
}
protected virtual QueryNode VisitWhere(WhereNode node, AzureQueryOptimizerState state)
{
QueryNode sourceNode = this.Visit(node.SourceNode, state);
QueryNode queryNode = this.Visit(node.PredicateNode, state);
bool? booleanValue = this.GetBooleanValue(queryNode);
if (!booleanValue.HasValue)
{
if (sourceNode is MatchAllNode)
{
return(queryNode);
}
if (sourceNode is MatchNoneNode)
{
return(sourceNode);
}
return((QueryNode) new WhereNode(sourceNode, queryNode));
}
if (booleanValue.Value)
{
return(sourceNode);
}
return((QueryNode) new MatchNoneNode());
}
public void ParseWhere_WhenSimpleQuery_ExpectNodeBack()
{
// Arrange
var rangeParser = new RangeParser();
var equalsParser = new EqualsParser();
var entityParser = new EntityParser <CustomEntity>();
var typeSplitter = new TypeSplitter();
var whereStatementParser = new WhereStatementParser <CustomEntity>(rangeParser, equalsParser, entityParser, typeSplitter);
var whereParser = new WhereParser(whereStatementParser, new ParserOptions());
// Act
var stopwatch = Stopwatch.StartNew();
var whereNode = whereParser.ParseWhere("testKey:testValue");
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
var equalsOperator = whereNode;
Assert.That(equalsOperator, Is.Not.Null);
var expected = new WhereNode
{
Conjunctive = Conjunctives.None,
Next = null,
Statement = new WhereStatement {
As = null, Value = new EqualsOperator {
Statement = "testKey:testValue", Name = "testKey", CaseInsensitive = false, Value = "testValue", IsNot = false
}
}
};
whereNode.ShouldDeepEqual(expected);
}
public void Visit(WhereNode node)
{
Nodes.Push(new WhereNode(Nodes.Pop()));
}
public virtual void Visit(WhereNode node)
{
SetQueryPart(QueryPart.Where);
node.Expression.Accept(this);
node.Accept(_visitor);
}
public override void Visit(WhereNode node)
{
Debug.Print("WhereNode");
ProgramCode.Append(" WHERE ");
VisitChildren(node);
}
public virtual void Visit(WhereNode node)
{
node.Expression.Accept(this);
node.Accept(Visitor);
}
public DetailedQueryNode(SelectNode select, FromNode from, WhereNode where, GroupByNode groupBy,
OrderByNode orderBy, SkipNode skip, TakeNode take, string returnVariableName)
: base(select, from, where, groupBy, orderBy, skip, take)
{
ReturnVariableName = returnVariableName;
}
public void Visit(WhereNode node)
{
}
public override void Visit(WhereNode node)
{
_symbolTable.SetCurrentNode(node);
VisitChildrenNewScope(node, BlockType.WhereStatement);
}
public abstract void Visit(WhereNode node);
public override void Visit(WhereNode node)
{
Where = new WhereNode(Nodes.Pop());
}
