protected override ISqlNode OnChildNode(ISqlNode node)
{
if (node is IExpressionNode)
Password = (IExpressionNode) node;
return base.OnChildNode(node);
}
public override void SetUp ()
{
base.SetUp();
_unresolvedLambda = ExpressionHelper.CreateLambdaExpression<int, bool> (i => i > 5);
_currentNode = new TestMethodCallExpressionNode (CreateParseInfo (), null);
_expressionResolver = new ExpressionResolver (_currentNode);
}
private QueryModel ApplyAllNodes(IExpressionNode node, ClauseGenerationContext clauseGenerationContext)
{
QueryModel queryModel = null;
if (node.Source != null)
queryModel = ApplyAllNodes(node.Source, clauseGenerationContext);
return node.Apply(queryModel, clauseGenerationContext);
}
protected override void Deserialize(StringReader reader)
{
base.Deserialize(reader);
Left = PExpressionUtility.DeserializeNode(reader);
Right = PExpressionUtility.DeserializeNode(reader);
}
protected virtual void Deserialize(StringReader reader)
{
Children = new IExpressionNode[int.Parse(reader.ReadLine())];
for (int i = 0; i < Children.Length; i++)
Children[i] = PExpressionUtility.DeserializeNode(reader);
}
public static SqlExpression Build(IExpressionNode node)
{
if (node is SqlVariableRefExpressionNode)
return VisitVariableRefExpression((SqlVariableRefExpressionNode) node);
if (node is SqlExpressionTupleNode)
return VisitTupleExpression((SqlExpressionTupleNode) node);
if (node is SqlQueryExpressionNode)
return VisitQueryExpression((SqlQueryExpressionNode) node);
if (node is SqlCaseExpressionNode)
return VisitCaseExpression((SqlCaseExpressionNode) node);
if (node is SqlConstantExpressionNode)
return VisitConstantExpression((SqlConstantExpressionNode) node);
if (node is SqlFunctionCallExpressionNode)
return VisitFunctionCall((SqlFunctionCallExpressionNode) node);
if (node is SqlReferenceExpressionNode)
return VisitReferenceExpression((SqlReferenceExpressionNode) node);
if (node is SqlBinaryExpressionNode)
return VisitBinaryExpression((SqlBinaryExpressionNode) node);
if (node is SqlUnaryExpressionNode)
return VisitUnaryExpression((SqlUnaryExpressionNode) node);
if (node is SqlBetweenExpressionNode)
return VisitBetweenExpression((SqlBetweenExpressionNode) node);
throw new NotSupportedException();
}
public MemberExpressionNode(IExpressionNode target, [NotNull] string member)
: base(ExpressionNodeType.Member)
{
Should.NotBeNull(member, nameof(member));
_target = target;
_member = member;
}
public UnaryExressionNode([NotNull] IExpressionNode operand, TokenType token)
: base(ExpressionNodeType.Unary)
{
Should.NotBeNull(operand, "operand");
_operand = operand;
_token = token;
}
protected MethodCallExpressionNodeBase (MethodCallExpressionParseInfo parseInfo)
{
if (parseInfo.AssociatedIdentifier == null)
throw new ArgumentException ("Unitialized struct.", "parseInfo");
_associatedIdentifier = parseInfo.AssociatedIdentifier;
_source = parseInfo.Source;
_nodeResultType = parseInfo.ParsedExpression.Type;
}
protected override void AcceptInternal(IExpressionVisitor visitor)
{
if (Target != null)
_target = AcceptWithCheck(visitor, Target, false);
for (int index = 0; index < _arguments.Count; index++)
{
_arguments[index] = AcceptWithCheck(visitor, _arguments[index], true);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BinaryExpressionNode" /> class.
/// </summary>
public BinaryExpressionNode([NotNull] IExpressionNode left, [NotNull] IExpressionNode right, TokenType token)
: base(ExpressionNodeType.Binary)
{
Should.NotBeNull(left, "left");
Should.NotBeNull(right, "right");
_left = left;
_right = right;
_token = token;
}
public static void SerializeNode(IExpressionNode node, StringWriter writer)
{
if (node == null)
writer.WriteLine((int)ExpressionTypes.Null);
else
{
writer.WriteLine((int)node.Type);
writer.WriteLine(JsonUtility.ToJson(node));
}
}
/// <inheritdoc/>
protected override ISqlNode OnChildNode(ISqlNode node)
{
if (node.NodeName == "sql_expression_list") {
GetGroupExpressions(node);
} else if (node.NodeName == "having_clause_opt") {
HavingExpression = node.ChildNodes.FirstOrDefault() as IExpressionNode;
}
return base.OnChildNode(node);
}
protected override ISqlNode OnChildNode(ISqlNode node)
{
if (node is IdentifierNode) {
ColumnName = ((IdentifierNode) node).Text;
} else if (node is IExpressionNode) {
Expression = (IExpressionNode) node;
}
return base.OnChildNode(node);
}
public LambdaExpressionNode([NotNull] IExpressionNode expression, [CanBeNull] IEnumerable<string> parameters)
: base(ExpressionNodeType.Lambda)
{
Should.NotBeNull(expression, "expression");
_expression = expression;
_parameters = parameters == null
? Empty.Array<string>()
: parameters.ToArray();
BindingExtensions.CheckDuplicateLambdaParameter(Parameters);
}
public ArgumentData(IExpressionNode node, Expression expression, Type type, bool isTypeAccess)
{
Should.NotBeNull(node, "node");
_node = node;
_expression = expression;
if (type == null && expression != null)
type = expression.Type;
_type = type;
_isTypeAccess = isTypeAccess;
}
public static SelectManyExpressionNode CreateSelectMany (IExpressionNode source)
{
var p1 = Expression.Parameter (typeof (Cook), "s");
var p2 = Expression.Parameter (typeof (Kitchen), "sd");
var resultSelector = Expression.Lambda (Expression.Constant (null), p1, p2);
var collectionSelector = Expression.Lambda (Expression.Constant (null), p1);
var parseInfo = new MethodCallExpressionParseInfo ("trans", source, ExpressionHelper.CreateMethodCallExpression<Cook> ());
return new SelectManyExpressionNode (parseInfo, collectionSelector, resultSelector);
}
protected override ISqlNode OnChildNode(ISqlNode node)
{
if (node.NodeName.Equals("label_opt")) {
Label = node.FindNode<IdentifierNode>().Text;
} else if (node.NodeName.Equals("when_opt")) {
WhenExpression = node.FindNode<IExpressionNode>();
}
return base.OnChildNode(node);
}
public object GetContextInfo (IExpressionNode node)
{
ArgumentUtility.CheckNotNull ("node", node);
object contextInfo;
if (!_lookup.TryGetValue (node, out contextInfo))
throw new KeyNotFoundException ("Node has no associated context info.");
return contextInfo;
}
protected override ISqlNode OnChildNode(ISqlNode node)
{
if (node.NodeName.Equals("label_opt")) {
Label = node.FindNode<StringLiteralNode>().Value;
} else if (node.NodeName.Equals("when_opt")) {
WhenExpression = node.FindNode<IExpressionNode>();
}
return base.OnChildNode(node);
}
public IExpressionNode Parse (
string associatedIdentifier, IExpressionNode source, IEnumerable<Expression> arguments, MethodCallExpression expressionToParse)
{
ArgumentUtility.CheckNotNull ("expressionToParse", expressionToParse);
Type nodeType = GetNodeType (expressionToParse);
var additionalConstructorParameters = arguments.Select (expr => ProcessArgumentExpression (expr)).ToArray();
var parseInfo = new MethodCallExpressionParseInfo (associatedIdentifier, source, expressionToParse);
return CreateExpressionNode (nodeType, parseInfo, additionalConstructorParameters);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConditionExpressionNode" /> class.
/// </summary>
public ConditionExpressionNode([NotNull] IExpressionNode condition, [NotNull] IExpressionNode ifTrue,
[NotNull] IExpressionNode ifFalse)
: base(ExpressionNodeType.Condition)
{
Should.NotBeNull(condition, "condition");
Should.NotBeNull(ifTrue, "ifTrue");
Should.NotBeNull(ifFalse, "ifFalse");
_condition = condition;
_ifTrue = ifTrue;
_ifFalse = ifFalse;
}
public MethodCallExpressionParseInfo (string associatedIdentifier, IExpressionNode source, MethodCallExpression parsedExpression)
: this()
{
ArgumentUtility.CheckNotNullOrEmpty ("associatedIdentifier", associatedIdentifier);
ArgumentUtility.CheckNotNull ("source", source);
ArgumentUtility.CheckNotNull ("parsedExpression", parsedExpression);
AssociatedIdentifier = associatedIdentifier;
Source = source;
ParsedExpression = parsedExpression;
}
/// <inheritdoc/>
protected override ISqlNode OnChildNode(ISqlNode node)
{
if (node.NodeName == "sql_reference_expression") {
Expression = (IExpressionNode) node;
} else if (node.NodeName == "sql_expression") {
Expression = (IExpressionNode) node;
} else if (node.NodeName == "sort_order") {
GetOrder(node);
}
return base.OnChildNode(node);
}
public MethodCallExpressionNode(IExpressionNode target, [NotNull] string methodName,
[CanBeNull] IList<IExpressionNode> args, [CanBeNull] IList<string> typeArgs)
: base(ExpressionNodeType.MethodCall)
{
Should.NotBeNull(methodName, nameof(methodName));
_target = target;
_method = methodName;
_typeArgs = typeArgs == null
? Empty.Array<string>()
: typeArgs.ToArrayEx();
_arguments = args == null ? Empty.Array<IExpressionNode>() : args.ToArrayEx();
}
protected override ISqlNode OnChildNode(ISqlNode node)
{
if (node is IExpressionNode) {
if (VariableReference == null) {
VariableReference = (IExpressionNode) node;
} else {
ValueExpression = (IExpressionNode) node;
}
}
return base.OnChildNode(node);
}
/// <inheritdoc/>
protected override ISqlNode OnChildNode(ISqlNode node)
{
if (node is SqlKeyNode && ((SqlKeyNode) node).Text == "WHEN") {
whenFound = true;
} else if (node is IExpressionNode) {
if (whenFound) {
WhenExpression = (IExpressionNode) node;
} else {
ThenExpression = (IExpressionNode) node;
}
}
return base.OnChildNode(node);
}
public void AddContextInfo (IExpressionNode node, object contextInfo)
{
ArgumentUtility.CheckNotNull ("node", node);
ArgumentUtility.CheckNotNull ("contextInfo", contextInfo);
try
{
_lookup.Add (node, contextInfo);
}
catch (ArgumentException)
{
throw new InvalidOperationException ("Node already has associated context info.");
}
}
public IExpressionNode Visit(IExpressionNode node)
{
var lambdaNode = node as ILambdaExpressionNode;
if (lambdaNode != null && !_ignoreLambda)
return VisitLambda(lambdaNode);
var methodCall = node as IMethodCallExpressionNode;
if (methodCall != null)
return VisitMethodCall(methodCall);
var relativeSource = node as IRelativeSourceExpressionNode;
if (relativeSource != null)
return VisitRelativeSource(relativeSource);
return VisitExpression(node);
}
protected override ISqlNode OnChildNode(ISqlNode node)
{
if (node is ObjectNameNode) {
TableName = ((ObjectNameNode) node).Name;
} else if (node.NodeName == "column_set_list") {
Columns = node.FindNodes<UpdateColumnNode>();
} else if (node.NodeName == "update_where") {
WhereExpression = node.FindNode<IExpressionNode>();
} else if (node.NodeName == "limit_opt") {
var child = node.FindNode<IntegerLiteralNode>();
if (child != null)
Limit = (int) child.Value;
}
return base.OnChildNode(node);
}
protected MethodCallExpressionParseInfo CreateParseInfo(IExpressionNode source)
{
return(CreateParseInfo(source, "x"));
}
public CompareInequalityBinOpNode(IExpressionNode lhs, IExpressionNode rhs) : base(lhs, rhs)
{
}
public ReturnNode(IExpressionNode rhs)
{
RHS = rhs;
}
public void VisitUnknown(IExpressionNode node)
{
UnknownVisitor?.Visit(node);
}
/// <summary>
/// Gets the evaluation of an expression.
/// </summary>
/// <returns>The evaluation.</returns>
/// <param name="expressions">Expressions.</param>
private IProperty getEvaluation(IExpressionNode expression)
{
IProperty evaluatedType = expression.Accept(this).asProperty();
return(evaluatedType);
}
/// <summary>
/// Creates a new if command node
/// </summary>
/// <param name="expression">The condition expression</param>
/// <param name="thenCommand">The then branch command</param>
/// <param name="position">The position in the code where the content associated with the node begins</param>
public IfCommandNode(IExpressionNode expression, ICommandNode thenCommand, Position position)
{
Expression = expression;
ThenCommand = thenCommand;
Position = position;
}
public int GetCount([NotNull] IExpressionNode node)
{
_count = 0;
node.Accept(this);
return(_count);
}
protected MethodCallExpressionParseInfo CreateParseInfo(IExpressionNode source, string associatedIdentifier)
{
return(new MethodCallExpressionParseInfo(associatedIdentifier, source, ExpressionHelper.CreateMethodCallExpression <Cook>()));
}
public ExpressionResolver(IExpressionNode currentNode)
{
ArgumentUtility.CheckNotNull("currentNode", currentNode);
CurrentNode = currentNode;
}
public TextNode(IExpressionNode parent, string buff) : base(parent)
{
_buff.Append(buff);
}
public UnaryExpression(IExpressionNode rhs, Func <double, double> operation)
{
_rhs = rhs;
_operation = operation;
}
public Equation(string id, IExpressionNode expression, VariableSource outputVariableSource)
{
OutputVariableSource = outputVariableSource;
Id = id;
Expression = expression;
}
public BerLengthNode(IExpressionNode parent) : base(parent)
{
}
/// <summary>
/// Dispatches the expression.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified; otherwise, returns the original expression.</returns>
IExpressionNode IExpressionVisitor.Visit(IExpressionNode node)
{
_count++;
return(node);
}
public GoNode(IExpressionNode expression)
{
this.expression = expression;
}
public void SetUp()
{
_source = ExpressionNodeObjectMother.CreateMainSource();
_parseInfo = new MethodCallExpressionParseInfo("foo", _source, ExpressionHelper.CreateMethodCallExpression <Cook>());
}
private IExpressionNode makeComparison(IExpressionNode leftSide, string operatorSymbol, IExpressionNode rightSide, double tolerance)
{
IExpressionNode result = new Constant(double.NaN);
switch (operatorSymbol)
{
case "=":
result = new Equality(leftSide, rightSide, tolerance);
break;
case "<>":
case "≠":
result = new Inequality(leftSide, rightSide, tolerance);
break;
case "<":
result = new LessThen(leftSide, rightSide, tolerance, true);
break;
case "<=":
case "≤":
result = new LessThen(leftSide, rightSide, tolerance, false);
break;
case ">":
result = new GreaterThen(leftSide, rightSide, tolerance, true);
break;
case ">=":
case "≥":
result = new GreaterThen(leftSide, rightSide, tolerance, false);
break;
}
return(result.Simplified());
}
protected override void AcceptInternal(IExpressionVisitor visitor)
{
_operand = AcceptWithCheck(visitor, Operand, true);
}
private void InsertCastNode(IExpressionNode binaryNode, int child)
{
CastFromIntegerExpression cast = new CastFromIntegerExpression(binaryNode.Children[child], 0, 0);
binaryNode.Children[child] = cast;
}
protected override void AcceptInternal(IExpressionVisitor visitor)
{
_condition = AcceptWithCheck(visitor, Condition, true);
_ifTrue = AcceptWithCheck(visitor, IfTrue, true);
_ifFalse = AcceptWithCheck(visitor, IfFalse, true);
}
public virtual void visit(IExpressionNode value)
{
}
public IfNode(IStatementNode statement, IExpressionNode expression, IStatementNode thenNode)
: this(statement, expression, thenNode, null)
{
}
public VariableNode(IExpressionNode parent, Func <string, string> resolver) : base(parent)
{
_resolver = resolver;
}
public IfNode(IExpressionNode expression, IStatementNode block)
: this(null, expression, block)
{
}
public VarNode(string name, TypeInfo typeinfo, IExpressionNode expression)
: base(name, typeinfo, expression)
{
}
public void LinkExpressionToLocalBuilder(IExpressionNode expr, LocalBuilder lb)
{
memoized_exprs[expr] = lb;
}
public LocalBuilder GetLocalBuilderForExpression(IExpressionNode expr)
{
return(memoized_exprs[expr] as LocalBuilder);
}
public AddExpression(IExpressionNode leftExpression, IExpressionNode rightExpression)
{
_leftExpression = leftExpression;
_rightExpression = rightExpression;
}
public TextNode(IExpressionNode parent) : base(parent)
{
}
internal static Exception UnexpectedExpressionNode(IExpressionNode node)
{
return(new InvalidOperationException($"Unexpected expression node type: '{node.NodeType}', node: '{node}'"));
}
