protected BaseAxisQuery(Query qyInput)
 {
     _name = string.Empty;
     _prefix = string.Empty;
     _nsUri = string.Empty;
     this.qyInput = qyInput;
 }

 public UnionExpr(Query query1, Query query2)
 {
     this.qy1 = query1;
     this.qy2 = query2;
     _advance1 = true;
     _advance2 = true;
 }

 public static void AssertQuery(Query query)
 {
     if (!(query is FunctionQuery))
     {
         XPathNavigator navigator2;
         query = Clone(query);
         XPathNavigator l = null;
         int count = query.Clone().Count;
         for (int i = 0; (navigator2 = query.Advance()) != null; i++)
         {
             if (navigator2.GetType().ToString() == "Microsoft.VisualStudio.Modeling.StoreNavigator")
             {
                 return;
             }
             if (navigator2.GetType().ToString() == "System.Xml.DataDocumentXPathNavigator")
             {
                 return;
             }
             if ((l != null) && ((l.NodeType != XPathNodeType.Namespace) || (navigator2.NodeType != XPathNodeType.Namespace)))
             {
                 CompareNodes(l, navigator2);
             }
             l = navigator2.Clone();
         }
     }
 }

 public override void AddSort(object expr, IComparer comparer)
 {
     // sort makes sense only when we are dealing with a query that
     // returns a nodeset.
     Query evalExpr;
     string query = expr as string;
     if (query != null)
     {
         evalExpr = new QueryBuilder().Build(query, out _needContext); // this will throw if expr is invalid
     }
     else
     {
         CompiledXpathExpr xpathExpr = expr as CompiledXpathExpr;
         if (xpathExpr != null)
         {
             evalExpr = xpathExpr.QueryTree;
         }
         else
         {
             throw XPathException.Create(SR.Xp_BadQueryObject);
         }
     }
     SortQuery sortQuery = _query as SortQuery;
     if (sortQuery == null)
     {
         _query = sortQuery = new SortQuery(_query);
     }
     sortQuery.AddSort(evalExpr, comparer);
 }

 private SortQuery(SortQuery other) : base(other)
 {
     this.results = new List<SortKey>(other.results);
     this.comparer = other.comparer.Clone();
     this.qyInput = Query.Clone(other.qyInput);
     base.count = 0;
 }

 // ----------------- Helper methods -------------
 public static Query Clone(Query input)
 {
     if (input != null)
     {
         return (Query)input.Clone();
     }
     return null;
 }

 private bool CanBeNumber(Query q)
 {
     if (q.StaticType != XPathResultType.Any)
     {
         return (q.StaticType == XPathResultType.Number);
     }
     return true;
 }

 protected BaseAxisQuery(Query qyInput, string name, string prefix, XPathNodeType typeTest)
 {
     this.qyInput = qyInput;
     this.name = name;
     this.prefix = prefix;
     this.typeTest = typeTest;
     this.nameTest = (prefix.Length != 0) || (name.Length != 0);
     this.nsUri = string.Empty;
 }

 private StringFunctions(StringFunctions other) : base(other) {
     this.funcType = other.funcType;
     Query[] tmp = new Query[other.argList.Count]; {                
         for (int i = 0; i < tmp.Length; i ++) {
             tmp[i] = Clone(other.argList[i]);
         }
     }
     this.argList = tmp; 
 }

 protected BaseAxisQuery(Query qyInput, string name, string prefix, XPathNodeType typeTest) {
     Debug.Assert(qyInput != null);
     this.qyInput  = qyInput;
     this.name     = name;
     this.prefix   = prefix;
     this.typeTest = typeTest;
     this.nameTest = prefix.Length != 0 || name.Length != 0;
     this.nsUri    = string.Empty;
 }

 private StringFunctions(StringFunctions other) : base(other)
 {
     this.funcType = other.funcType;
     Query[] queryArray = new Query[other.argList.Count];
     for (int i = 0; i < queryArray.Length; i++)
     {
         queryArray[i] = Query.Clone(other.argList[i]);
     }
     this.argList = queryArray;
 }

 private FunctionQuery(FunctionQuery other) : base(other) {
     this.function = other.function;
     Query[] tmp = new Query[other.args.Count]; {                
         for (int i = 0; i < tmp.Length; i ++) {
             tmp[i] = Clone(other.args[i]);
         }
         args = tmp;
     }
     this.args = tmp;
 }

 public LogicalExpr(Operator.Op op, Query  opnd1, Query  opnd2) {
     Debug.Assert(
         Operator.Op.LT == op || Operator.Op.GT == op ||
         Operator.Op.LE == op || Operator.Op.GE == op ||
         Operator.Op.EQ == op || Operator.Op.NE == op
     );
     this.op    = op;
     this.opnd1 = opnd1;
     this.opnd2 = opnd2;
 }

 private FunctionQuery(FunctionQuery other) : base(other)
 {
     this.function = other.function;
     Query[] queryArray = new Query[other.args.Count];
     for (int i = 0; i < queryArray.Length; i++)
     {
         queryArray[i] = Query.Clone(other.args[i]);
     }
     this.args = queryArray;
     this.args = queryArray;
 }

 public BooleanExpr(Operator.Op op, Query opnd1, Query opnd2) {
     Debug.Assert(op == Operator.Op.AND || op == Operator.Op.OR);
     Debug.Assert(opnd1 != null && opnd2 != null);
     if (opnd1.StaticType != XPathResultType.Boolean) {
         opnd1 = new BooleanFunctions(Function.FunctionType.FuncBoolean, opnd1);
     }
     if (opnd2.StaticType != XPathResultType.Boolean) {
         opnd2 = new BooleanFunctions(Function.FunctionType.FuncBoolean, opnd2);
     }
     this.opnd1 = opnd1;
     this.opnd2 = opnd2;
     isOr = (op == Operator.Op.OR);
 }

 public NumericExpr(Operator.Op op, Query opnd1, Query opnd2)
 {
     if (opnd1.StaticType != XPathResultType.Number)
     {
         opnd1 = new NumberFunctions(Function.FunctionType.FuncNumber, opnd1);
     }
     if (opnd2.StaticType != XPathResultType.Number)
     {
         opnd2 = new NumberFunctions(Function.FunctionType.FuncNumber, opnd2);
     }
     this.op = op;
     this.opnd1 = opnd1;
     this.opnd2 = opnd2;
 }

 public NumericExpr(Operator.Op op, Query opnd1, Query  opnd2) {
     Debug.Assert(
         op == Operator.Op.PLUS || op == Operator.Op.MINUS || 
         op == Operator.Op.MUL  || op == Operator.Op.DIV ||
         op == Operator.Op.MOD
     );
     Debug.Assert(opnd1 != null && opnd2 != null);
     if (opnd1.StaticType != XPathResultType.Number) {
         opnd1 = new NumberFunctions(Function.FunctionType.FuncNumber, opnd1);
     }
     if (opnd2.StaticType != XPathResultType.Number) {
         opnd2 = new NumberFunctions(Function.FunctionType.FuncNumber, opnd2);
     }
     this.op = op;
     this.opnd1 = opnd1;
     this.opnd2 = opnd2;
 }

        public override void AddSort(object expr, IComparer comparer) {
            // sort makes sense only when we are dealing with a query that
            // returns a nodeset.
	        Query evalExpr;
            if (expr is string) {
                evalExpr = new QueryBuilder().Build((string)expr, out needContext); // this will throw if expr is invalid
            } else if (expr is CompiledXpathExpr) {
                evalExpr = ((CompiledXpathExpr)expr).QueryTree;
	        } else {
                throw XPathException.Create(Res.Xp_BadQueryObject);
            }
            SortQuery sortQuery = query as SortQuery;
            if (sortQuery == null) {
                query = sortQuery = new SortQuery(query);
            }
            sortQuery.AddSort(evalExpr, comparer);
        }

 public override void AddSort(object expr, IComparer comparer)
 {
     Query queryTree;
     if (expr is string)
     {
         queryTree = new QueryBuilder().Build((string) expr, out this.needContext);
     }
     else
     {
         if (!(expr is CompiledXpathExpr))
         {
             throw XPathException.Create("Xp_BadQueryObject");
         }
         queryTree = ((CompiledXpathExpr) expr).QueryTree;
     }
     SortQuery query2 = this.query as SortQuery;
     if (query2 == null)
     {
         this.query = query2 = new SortQuery(this.query);
     }
     query2.AddSort(queryTree, comparer);
 }

 public FollowingQuery(Query qyInput, string name, string prefix, XPathNodeType typeTest) : base(qyInput, name, prefix, typeTest) {}