C# SqlGenerators.VisitedExpression类代码示例

 internal void And(VisitedExpression andAlso)
 {
     _where = OperatorExpression.Build(Operator.And, _where, andAlso);
 }

 public IsNullExpression(VisitedExpression argument)
 {
     _argument = argument;
 }

 public LimitExpression(VisitedExpression arg)
 {
     _arg = arg;
 }

 internal void AddArgument(VisitedExpression visitedExpression)
 {
     _args.Add(visitedExpression);
 }

 public void AppendTarget(VisitedExpression target)
 {
     Append(target);
 }

 public void AppendFrom(VisitedExpression from)
 {
     Append(from);
 }

 public ExistsExpression(VisitedExpression argument)
 {
     _argument = argument;
 }

 public NegatableBooleanExpression(DbExpressionKind booleanOperator, VisitedExpression left, VisitedExpression right)
 {
     _booleanOperator = booleanOperator;
     _left = left;
     _right = right;
 }

 public NegateExpression(VisitedExpression argument)
 {
     _argument = argument;
     Negated = true;
 }

 public static OperatorExpression Build(Operator op, VisitedExpression exp)
 {
     if (op.UnaryType == Operator.UnaryTypes.Prefix)
     {
         return new OperatorExpression(op, null, exp);
     }
     else if (op.UnaryType == Operator.UnaryTypes.Postfix)
     {
         return new OperatorExpression(op, exp, null);
     }
     else
     {
         throw new InvalidOperationException("Binary operator with one operand");
     }
 }

        /// <summary>
        /// Negates an expression.
        /// If possible, replaces the operator of exp if exp is a negatable OperatorExpression,
        /// else return a new OperatorExpression of type Not that wraps exp.
        /// </summary>
        public static VisitedExpression Negate(VisitedExpression exp)
        {
            OperatorExpression expOp = exp as OperatorExpression;
            if (expOp != null)
            {
                Operator op = expOp.op;
                Operator newOp = null;
                if (Operator.NegateDict.TryGetValue(op, out newOp))
                {
                    expOp.op = newOp;
                    return expOp;
                }
                if (expOp.op == Operator.Not)
                {
                    return expOp.right;
                }
            }

            return OperatorExpression.Build(Operator.Not, exp);
        }

 private OperatorExpression(Operator op, VisitedExpression left, VisitedExpression right)
 {
     this.op = op;
     this.left = left;
     this.right = right;
 }

 internal FunctionExpression AddArgument(VisitedExpression visitedExpression)
 {
     _args.Add(visitedExpression);
     return this;
 }

 public ColumnExpression(VisitedExpression column, string columnName, TypeUsage columnType)
 {
     _column = column;
     _columnName = columnName;
     _columnType = columnType;
 }

 public CastExpression(VisitedExpression value, string type)
 {
     _value = value;
     _type = type;
 }