protected override ISqlNode OnChildNode(ISqlNode node)
        {
            if (node is IExpressionNode)
                Password = (IExpressionNode) node;

            return base.OnChildNode(node);
        }

 public MemberExpressionNode(IExpressionNode target, [NotNull] string member)
     : base(ExpressionNodeType.Member)
 {
     Should.NotBeNull(member, nameof(member));
     _target = target;
     _member = member;
 }

 private QueryModel ApplyAllNodes(IExpressionNode node, ClauseGenerationContext clauseGenerationContext)
 {
     QueryModel queryModel = null;
     if (node.Source != null)
         queryModel = ApplyAllNodes(node.Source, clauseGenerationContext);
     return node.Apply(queryModel, clauseGenerationContext);
 }

        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 UnaryExressionNode([NotNull] IExpressionNode operand, TokenType token)
     : base(ExpressionNodeType.Unary)
 {
     Should.NotBeNull(operand, "operand");
     _operand = operand;
     _token = token;
 }

        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);
        }

 /// <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;
 }

        /// <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.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 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);
    }

 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;
 }

        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 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));
     }
 }

    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;
    }

 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);
 }

        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 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;
    }

        protected override ISqlNode OnChildNode(ISqlNode node)
        {
            if (node is IExpressionNode) {
                if (VariableReference == null) {
                    VariableReference = (IExpressionNode) node;
                } else {
                    ValueExpression = (IExpressionNode) node;
                }
            }

            return base.OnChildNode(node);
        }