public NotationValue(string notation, int index, int end)
        {
            value = 1;
            op = Op.Add;
            type = NotationType.Value;

            switch (notation[index])
            {
                case '+': { index++; break; }
                case '-': { op = Op.Sub; index++; break; }
                case '*': { op = Op.Mul; index++; break; }
                case '/': { op = Op.Div; index++; break; }
                case '^': { op = Op.Mod; index++; break; }
            }

            if (index <= end && char.IsDigit(notation[index]))
            {
                int i = index + 1;
                while (i <= end && char.IsDigit(notation[i])) i++;
                value = int.Parse(notation.Substring(index, i - index));
                index = i;
            }

            if (index <= end && char.IsLetter(notation[index]))
            {
                Enum.TryParse<NotationType>(notation.Substring(index, end - index + 1), out type);
            }
        }

        /// <summary>
        /// 创建查询条件片段。
        /// </summary>
        /// <param name="propertyName">属性名</param>
        /// <param name="op">查询操作</param>
        /// <returns>2元组：结果一、查询条件片段；结果二、查询参数</returns>
        protected override Tuple<string, string> CreateFragment(string propertyName, Op op)
        {
            var criteria = string.Empty;
            var parameterName = string.Empty;

            switch (op)
            {
                case Op.Eq:
                case Op.Gt:
                case Op.Ge:
                case Op.Lt:
                case Op.Le:
                    parameterName = propertyName + (this._parameterIndex++);
                    criteria = string.Format(CriteriaFormat, propertyName, Operations[(int)op], parameterName);

                    break;
                case Op.Like:
                    parameterName = propertyName + (this._parameterIndex++);
                    criteria = $"\"{propertyName}\" LIKE '%'||:{parameterName}||'%'";

                    break;
                case Op.IsNull:
                    criteria = $"\"{propertyName}\" IS NULL";

                    break;
                case Op.IsNotNull:
                    criteria = $"\"{propertyName}\" IS NOT NULL";

                    break;
            }

            return new Tuple<string, string>(criteria, parameterName);
        }

  static void Main() 
  {
    Op.sanity_check();
    {
      Op op = new Op(100);
      Op opNew = op++;
      if (op.i != 101) throw new Exception("operator++ postfix failed (op)");
      if (opNew.i != 100) throw new Exception("operator++ postfix failed (opNew)");
    }
    {
      Op op = new Op(100);
      Op opNew = op--;
      if (op.i != 99) throw new Exception("operator-- postfix failed (op)");
      if (opNew.i != 100) throw new Exception("operator-- postfix failed (opNew)");
    }
    {
      Op op = new Op(100);
      Op opNew = ++op;
      if (op.i != 101) throw new Exception("operator++ prefix failed (op)");
      if (opNew.i != 101) throw new Exception("operator++ prefix failed (opNew)");
    }
    {
      Op op = new Op(100);
      Op opNew = --op;
      if (op.i != 99) throw new Exception("operator-- prefix failed (op)");
      if (opNew.i != 99) throw new Exception("operator-- prefix failed (opNew)");
    }

    // overloaded operator class
    Op k = new OpDerived(3);
    int check_k = k.IntCast();
    Assert(check_k == 6);
  }

 private BinaryTerm(RiakFluentSearch search, string field, Op op, Term left)
     : base(search, field)
 {
     _op = op;
     _left = left;
     left.Owner = this;
 }

 /// <summary>
 /// 构造方法。
 /// </summary>
 /// <param name="column">属性</param>
 /// <param name="op">操作</param>
 /// <param name="value">值</param>
 internal Condition(string column, Op op, object value)
 {
     this.Op = op;
     this.Value = value;
     this.JoinType = "AND";
     this.PropertyName = column;
 }

 public object Operator(Op op, params object[] args)
 {
     if (binaryOps.ContainsKey(op))
         return binaryOps[op]((bool)args[0], (bool)args[1]);
     if (op == Op.Not)
         return !(bool)args[0];
     throw new NotImplementedException();
 }

 public ActionCopyMoveRename(Op operation, FileInfo from, FileInfo to, ProcessedEpisode ep)
 {
     this.PercentDone = 0;
     this.Episode = ep;
     this.Operation = operation;
     this.From = from;
     this.To = to;
 }

 /// <summary>
 /// Two CostantBaseOps are equivalent if they are of the same 
 /// derived type and have the same type and value. 
 /// </summary>
 /// <param name="other">the other Op</param>
 /// <returns>true, if these are equivalent (not a strict equality test)</returns>
 internal override bool IsEquivalent(Op other)
 {
     var otherConstant = other as ConstantBaseOp;
     return
         otherConstant != null &&
         OpType == other.OpType &&
         otherConstant.Type.EdmEquals(Type) &&
         ((otherConstant.Value == null && Value == null) || otherConstant.Value.Equals(Value));
 }

 internal void Emit(Op op, Label label)
 {
     if (!label.IsEmpty())
     {
         fixups.Add(ops.Count);
         Emit(op, label.GetIndex());
     }
     else
         Emit(op, 0);
 }

		private bool ignore;	// ignore case

		private void Compile (string pattern)
		{
			if (pattern == null || pattern.IndexOfAny (InvalidChars) >= 0)
				throw new ArgumentException ("Invalid search pattern.");

			if (pattern == "*") {	// common case
				ops = new Op (OpCode.True);
				return;
			}

			ops = null;

			int ptr = 0;
			Op last_op = null;
			while (ptr < pattern.Length) {
				Op op;
			
				switch (pattern [ptr]) {
				case '?':
					op = new Op (OpCode.AnyChar);
					++ ptr;
					break;

				case '*':
					op = new Op (OpCode.AnyString);
					++ ptr;
					break;
					
				default:
					op = new Op (OpCode.ExactString);
					int end = pattern.IndexOfAny (WildcardChars, ptr);
					if (end < 0)
						end = pattern.Length;

					op.Argument = pattern.Substring (ptr, end - ptr);
					if (ignore)
						op.Argument = op.Argument.ToLowerInvariant ();

					ptr = end;
					break;
				}

				if (last_op == null)
					ops = op;
				else
					last_op.Next = op;

				last_op = op;
			}

			if (last_op == null)
				ops = new Op (OpCode.End);
			else
				last_op.Next = new Op (OpCode.End);
		}

 static Operator()
 {
     Op[] opArray = new Op[9];
     opArray[3] = Op.EQ;
     opArray[4] = Op.NE;
     opArray[5] = Op.GT;
     opArray[6] = Op.GE;
     opArray[7] = Op.LT;
     opArray[8] = Op.LE;
     invertOp = opArray;
 }

        /// <summary>
        
        /// </summary>
        
        
        
        public Expression(string attrbuteName, Op op, string attrbuteValue)
        {
            if (op == Op.Exists || op == Op.NotExists)
                throw new ArgumentException("op");

            if (String.IsNullOrEmpty(attrbuteName))
                throw new ArgumentException("attrbuteName");

            _op = op;
            _attributeName = attrbuteName;
            _attributeValue = attrbuteValue;
        }

 public Binary(Op op, string symbol = "")
 {
     _op = op;
     Left = new Lambda();
     Right = new Lambda();
     if (symbol == "") {
         StringBuilder sb = new StringBuilder();
         sb.Append('[').Append(_opCount.ToString()).Append(']');
         _symbol = sb.ToString();
         _opCount++;
     }
     else {
         _symbol = symbol;
     }
 }

 private static bool IsTypeTransitive(Op op)
 {
     switch (op)
     {
         case Op.Add:
         case Op.Subtract:
         case Op.Multiply:
         case Op.Remainder:
         case Op.Divide:
         case Op.AndAnd:
         case Op.OrOr:
         case Op.And:
         case Op.Or:
         case Op.ExclusiveOr:
         case Op.LeftShift:
         case Op.RightShift:
             return true;
     }
     return false;
 }

        private void AddArg(Op op, ICollection<Node> argList)
        {
            if (TokType == TokenType.Identifer)
            {

                if (_reg16.ContainsKey(Keyword))
                {
                    argList.Add(_reg16[Keyword]);
                    NextToken();
                }
                else if (_reg8.ContainsKey(Keyword))
                {
                    argList.Add(_reg8[Keyword]);
                    NextToken();
                }
                else if (_specReg.ContainsKey(Keyword))
                {
                    argList.Add(_specReg[Keyword]);
                    NextToken();
                }
                else if (argList.Count == 0)
                {
                    if (op == Op.Jr && _jrCond.ContainsKey(Keyword))
                    {
                        argList.Add(_jrCond[Keyword]);
                        NextToken();
                    }
                    else if ((op == Op.Jp || op == Op.Ret || op == Op.Call) && _cond.ContainsKey(Keyword))
                    {
                        argList.Add(_cond[Keyword]);
                        NextToken();
                    }
                    else
                        argList.Add(Expression());
                }
                else
                    argList.Add(Expression());
            }
            else
                argList.Add(Expression());
        }

 public static int GetArity(Op op)
 {
     switch (op)
     {
         case Op.Not:
         case Op.Negate:
         case Op.OnesComplement:
         case Op.Int32:
         case Op.UInt32:
         case Op.Int64:
         case Op.UInt64:
         case Op.BigInteger:
         case Op.Double:
         case Op.Complex:
         case Op.Rational:
         case Op.Random:
             return 1;
         case Op.New:
         case Op.NullCoalescing:
             return 0;
         default:
             return 2;
     }
 }

		/// <summary>
		/// Add a simple IL instruction
		/// </summary>
		/// <param name="inst">the IL instruction</param>
		public void Inst(Op inst) 
		{
			AddToBuffer(new Instr((int)inst));
		}

        // <summary>
        // ApplyOp/JoinOp common processing
        // </summary>
        // <remarks>
        // If one of the inputs to any JoinOp/ApplyOp is a NestOp, then the NestOp
        // can be pulled above the join/apply if every input to the join/apply has
        // a key(s). The keys of the NestOp are augmented with the keys of the
        // other join inputs:
        // JoinOp/ApplyOp(NestOp(X, ...), Y) => NestOp(JoinOp/ApplyOp(X, Y), ...)
        // In addition, if the NestOp is on a 'nullable' side of a join (i.e. right side of
        // LeftOuterJoin/OuterApply or either side of FullOuterJoin), the driving node
        // of that NestOp (X) is capped with a project with a null sentinel and
        // the dependant collection nodes (the rest of the NestOp children)
        // are filtered based on that sentinel:
        // LOJ/OA/FOJ (X, NestOp(Y, Z1, Z2, ..ZN))  =>  NestOp( LOJ/OA/FOJ (X, PROJECT (Y, v = 1)), FILTER(Z1, v!=null), FILTER(Z2, v!=null), ... FILTER(ZN, v!=null))
        // FOJ (NestOp(Y, Z1, Z2, ..ZN), X)  =>  NestOp( LOJ/OA/FOJ (PROJECT (Y, v = 1), X), FILTER(Z1, v!=null), FILTER(Z2, v!=null), ... FILTER(ZN, v!=null))
        // Also, FILTER(Zi, v != null) may be transformed to push the filter below any NestOps.
        // The definitions for collection vars corresponding to the filtered collection nodes (in m_definingNodeMap)
        // are also updated to filter based on the sentinel.
        // Requires: Every input to the join/apply must have a key.
        // </remarks>
        private Node ApplyOpJoinOp(Op op, Node n)
        {
            // First, visit my children
            VisitChildren(n);

            // Now determine if any of the input nodes are a nestOp.
            var countOfNestInputs = 0;

            foreach (var chi in n.Children)
            {
                var nestOp = chi.Op as NestBaseOp;
                if (null != nestOp)
                {
                    countOfNestInputs++;

                    if (OpType.SingleStreamNest
                        == chi.Op.OpType)
                    {
                        // There should not be a SingleStreamNest in the tree, because we made a decision
                        // that in essence means the only way to get a SingleStreamNest is to have a
                        // PhysicalProject over something with an underlying NestOp.   Having
                        //
                        //      Project(Collect(PhysicalProject(...)))
                        //
                        // isn’t good enough, because that will get converted to a MultiStreamNest, with
                        // the SingleStreamNest as the input to the MultiStreamNest.
                        throw new InvalidOperationException(
                            Strings.ADP_InternalProviderError((int)EntityUtil.InternalErrorCode.JoinOverSingleStreamNest));
                    }
                }
            }

            // If none of the inputs are a nest, then we don't really need to do anything.
            if (0 == countOfNestInputs)
            {
                return n;
            }

            // We can only pull the nest over a Join/Apply if it has keys, so
            // we can order things; if it doesn't have keys, we throw a NotSupported
            // exception.
            foreach (var chi in n.Children)
            {
                if (op.OpType != OpType.MultiStreamNest
                    && chi.Op.IsRelOp)
                {
                    var keys = Command.PullupKeys(chi);

                    if (null == keys
                        || keys.NoKeys)
                    {
                        throw new NotSupportedException(Strings.ADP_KeysRequiredForJoinOverNest(op.OpType.ToString()));
                    }
                }
            }

            // Alright, we're OK to pull the nestOp over the joinOp/applyOp.
            //
            // That means:
            //
            // (1) build a new list of children for the nestOp and for the joinOp/applyOp
            // (2) build the new list of collectionInfos for the new nestOp.
            var newNestChildren = new List<Node>();
            var newJoinApplyChildren = new List<Node>();
            var newCollectionInfoList = new List<CollectionInfo>();

            foreach (var chi in n.Children)
            {
                if (chi.Op.OpType
                    == OpType.MultiStreamNest)
                {
                    newCollectionInfoList.AddRange(((MultiStreamNestOp)chi.Op).CollectionInfo);

                    // SQLBUDT #615513: If the nest op is on a 'nullable' side of join 
                    // (i.e. right side of LeftOuterJoin/OuterApply or either side of FullOuterJoin)
                    // the driving node of that nest operation needs to be capped with a project with 
                    // a null sentinel and the dependant collection nodes need to be filtered based on that sentinel.
                    //
                    //  LOJ/OA/FOJ (X, MSN(Y, Z1, Z2, ..ZN))  =>  MSN( LOJ/OA/FOJ (X, PROJECT (Y, v = 1)), FILTER(Z1, v!=null), FILTER(Z2, v!=null), ... FILTER(ZN, v!=null))
//.........这里部分代码省略.........

        // <summary>
        // Not Supported common processing
        // For all those cases where we don't intend to support
        // a nest operation as a child, we have this routine to
        // do the work.
        // </summary>
        private Node NestingNotSupported(Op op, Node n)
        {
            // First, visit my children
            VisitChildren(n);
            m_varRemapper.RemapNode(n);

            // Make sure we don't have a child that is a nest op.
            foreach (var chi in n.Children)
            {
                if (IsNestOpNode(chi))
                {
                    throw new NotSupportedException(Strings.ADP_NestingNotSupported(op.OpType.ToString(), chi.Op.OpType.ToString()));
                }
            }
            return n;
        }

        private Node VisitPropertyOp(Op op, Node n, PropertyRef propertyRef, bool throwIfMissing)
        {
            PlanCompiler.Assert(
                op.OpType == OpType.Property || op.OpType == OpType.RelProperty,
                "Unexpected optype: " + op.OpType);

            var inputType = n.Child0.Op.Type;
            var outputType = op.Type;

            // First visit all my children
            VisitChildren(n);

            Node newNode = null;
            var inputTypeInfo = m_typeInfo.GetTypeInfo(inputType);

            if (TypeUtils.IsStructuredType(outputType))
            {
                var outputTypeInfo = m_typeInfo.GetTypeInfo(outputType);
                var fieldTypes = new List<md.EdmProperty>();
                var fieldValues = new List<Node>();
                var expectedProperties = m_nodePropertyMap[n];

                foreach (var npr in outputTypeInfo.PropertyRefList)
                {
                    // Is this a property that's desired by my consumers?
                    if (expectedProperties.Contains(npr))
                    {
                        var newPropRef = npr.CreateNestedPropertyRef(propertyRef);
                        md.EdmProperty newNestedProp;

                        if (inputTypeInfo.TryGetNewProperty(newPropRef, throwIfMissing, out newNestedProp))
                        {
                            var outputNestedProp = outputTypeInfo.GetNewProperty(npr);
                            var field = BuildAccessor(n.Child0, newNestedProp);
                            if (null != field)
                            {
                                fieldTypes.Add(outputNestedProp);
                                fieldValues.Add(field);
                            }
                        }
                    }
                }
                Op newRecordOp = m_command.CreateNewRecordOp(outputTypeInfo.FlattenedTypeUsage, fieldTypes);
                newNode = m_command.CreateNode(newRecordOp, fieldValues);
            }
            else
            {
                var newProp = inputTypeInfo.GetNewProperty(propertyRef);
                // Build an accessor over the new property
                newNode = BuildAccessorWithNulls(n.Child0, newProp);
            }
            return newNode;
        }