queryimpl.cs

Perst开源实时数据库

        protected static bool ArrayEquals(Array a, Array b) 
        {
#if COMPACT_NET_FRAMEWORK
            for (int i = 0, n = a.Length; i < n; i++) 
            { 
                object ai = a.GetValue(i);
                object bi = b.GetValue(i);
                if ((ai == null && bi != null) || (ai != null && !ai.Equals(bi))) 
                {
                    return false;
                }
            }
            return true;
#else
            return Array.Equals(a, b);
#endif
        }

        public  override bool Equals(object o)
        {
            return o is Node && ((Node) o).tag == tag && ((Node) o).type == type;
        }
		
        internal static bool equalObjects(object a, object b)
        {
            return a == b || (a != null && a.Equals(b));
        }
		
		
        internal static NodeType getNodeType(Type type)
        {
            if (type.Equals(typeof(sbyte)) || type.Equals(typeof(short)) || type.Equals(typeof(int)) || type.Equals(typeof(long))
                || type.Equals(typeof(byte)) || type.Equals(typeof(ushort)) || type.Equals(typeof(uint)) || type.Equals(typeof(ulong)))
            {
                return NodeType.tpInt;
            }
            else if (type.Equals(typeof(double)) || type.Equals(typeof(float)))
            {
                return NodeType.tpReal;
            }
            else if (type.Equals(typeof(string)))
            {
                return NodeType.tpStr;
            }
            else if (type.Equals(typeof(bool[])))
            {
                return NodeType.tpArrayBool;
            }
            else if (type.Equals(typeof(sbyte[])))
            {
                return NodeType.tpArrayInt1;
            }
            else if (type.Equals(typeof(byte[])))
            {
                return NodeType.tpArrayUInt1;
            }
            else if (type.Equals(typeof(short[])))
            {
                return NodeType.tpArrayInt2;
            }
            else if (type.Equals(typeof(ushort[])))
            {
                return NodeType.tpArrayUInt2;
            }
            else if (type.Equals(typeof(char[])))
            {
                return NodeType.tpArrayChar;
            }
            else if (type.Equals(typeof(int[])))
            {
                return NodeType.tpArrayInt4;
            }
            else if (type.Equals(typeof(uint[])))
            {
                return NodeType.tpArrayUInt4;
            }
            else if (type.Equals(typeof(long[])))
            {
                return NodeType.tpArrayInt8;
            }
            else if (type.Equals(typeof(ulong[])))
            {
                return NodeType.tpArrayUInt8;
            }
            else if (type.Equals(typeof(float[])))
            {
                return NodeType.tpArrayReal4;
            }
            else if (type.Equals(typeof(double[])))
            {
                return NodeType.tpArrayReal8;
            }
            else if (type.Equals(typeof(string[])))
            {
                return NodeType.tpArrayStr;
            }
            else if (typeof(ICollection).IsAssignableFrom(type))
            {
                return NodeType.tpCollection;
            }
            else if (type.IsArray)
            {
                return NodeType.tpArrayObj;
            }
            else if (type.Equals(typeof(object)))
            {
                return NodeType.tpAny;
            }
            else
            {
                return NodeType.tpObj;
            }
        }
		
		
        internal virtual bool evaluateBool(FilterIterator t)
        {
            throw new InvalidOperationException();
        }
        internal virtual long evaluateInt(FilterIterator t)
        {
            throw new InvalidOperationException();
        }
        internal virtual double evaluateReal(FilterIterator t)
        {
            throw new InvalidOperationException();
        }
        internal virtual string evaluateStr(FilterIterator t)
        {
            return (string) evaluateObj(t);
        }
        internal virtual object evaluateObj(FilterIterator t)
        {
            switch (type)
            {
				
                case NodeType.tpStr: 
                    return evaluateStr(t);
				
                case NodeType.tpInt: 
                    return evaluateInt(t);
				
                case NodeType.tpReal: 
                    return evaluateReal(t);
				
                case NodeType.tpBool: 
                    return evaluateBool(t)?true:false;
				
                default: 
                    throw new InvalidOperationException();
				
            }
        }
		
        public override string ToString()
        {
            return "Node tag=" + tag + ", type=" + type;
        }
		
        internal Node(NodeType type, NodeTag tag)
        {
            this.type = type;
            this.tag = tag;
        }
    }
	
    class EmptyNode:Node
    {
        internal override bool evaluateBool(FilterIterator t)
        {
            return true;
        }
		
        internal EmptyNode():base(NodeType.tpBool, NodeTag.opTrue)
        {
        }
    }
	
    abstract class LiteralNode:Node
    {
        internal abstract object Value{get;}
 		
        internal override object evaluateObj(FilterIterator t)
        {
            return Value;
        }
		
		
        internal LiteralNode(NodeType type, NodeTag tag):base(type, tag)
        {
        }
    }
	
    class IntLiteralNode:LiteralNode
    {
        override internal object Value
        {
            get
            {
                return val;
            }
			
        }
        internal long val;
		
        public  override bool Equals(object o)
        {
            return o is IntLiteralNode && ((IntLiteralNode) o).val == val;
        }
		
		
        internal override long evaluateInt(FilterIterator t)
        {
            return val;
        }
		
        internal IntLiteralNode(long val):base(NodeType.tpInt, NodeTag.opIntConst)
        {
            this.val = val;
        }
    }
	
	
    class RealLiteralNode:LiteralNode
    {
        override internal object Value
        {
            get
            {
                return val;
            }
			
        }
        internal double val;
		
        public  override bool Equals(object o)
        {
            return o is RealLiteralNode && ((RealLiteralNode) o).val == val;
        }
		
		
        internal override double evaluateReal(FilterIterator t)
        {
            return val;
        }
		
        internal RealLiteralNode(double val):base(NodeType.tpReal, NodeTag.opRealConst)
        {
            this.val = val;
        }
    }
	
    class StrLiteralNode:LiteralNode
    {
        override internal object Value
        {
            get
            {
                return val;
            }
			
        }
        internal string val;
		
        public  override bool Equals(object o)
        {
            return o is StrLiteralNode && ((StrLiteralNode) o).val.Equals(val);
        }
		
		
        internal override string evaluateStr(FilterIterator t)
        {
            return val;
        }
		
        internal StrLiteralNode(string val):base(NodeType.tpStr, NodeTag.opStrConst)
        {
            this.val = val;
        }
    }
	
	
    class CurrentNode:Node
    {
        override internal Type Type
        {
            get
            {
                return cls;
            }
			
        }
		
        internal override object evaluateObj(FilterIterator t)
        {
            return t.currObj;
        }
		
        internal CurrentNode(Type cls):base(NodeType.tpObj, NodeTag.opCurrent)
        {
            this.cls = cls;
        }
        internal Type cls;
    }
	
    class ConstantNode:LiteralNode
    {
        override internal object Value
        {
            get
            {
                switch (tag)
                {
					
                    case NodeTag.opNull: 
                        return null;
					
                    case NodeTag.opFalse: 
                        return false;
					
                    case NodeTag.opTrue: 
                        return true;
					
                    default: 
                        throw new System.ApplicationException("Invalid tag " + tag);
					
                }
            }
			
        }
		
        internal override bool evaluateBool(FilterIterator t)
        {
            return tag != NodeTag.opFalse;
        }
		
        internal ConstantNode(NodeType type, NodeTag tag):base(type, tag)
        {
        }
    }
	
    class IndexOutOfRangeError:System.ApplicationException
    {
        internal int loopId;
		
        internal IndexOutOfRangeError(int loop)
        {
            loopId = loop;
        }
    }
	
    class ExistsNode:Node
    {
        internal Node expr;
        internal int loopId;
		
        public  override bool Equals(object o)
        {
            return o is ExistsNode && ((ExistsNode) o).expr.Equals(expr) && ((ExistsNode) o).loopId == loopId;
        }
		
        internal override bool evaluateBool(FilterIterator t)
        {
            t.indexVar[loopId] = 0;
            try
            {
                while (!expr.evaluateBool(t))
                {
                    t.indexVar[loopId] += 1;
                }
                return true;
            }
            catch (IndexOutOfRangeError x)
            {
                if (x.loopId != loopId)
                {
                    throw x;
                }
                return false;
            }
        }
		
        internal ExistsNode(Node expr, int loopId):base(NodeType.tpBool, NodeTag.opExists)
        {
            this.expr = expr;
            this.loopId = loopId;
        }
    }
	
	
    class IndexNode:Node
    {
        internal int loopId;
		
        public  override bool Equals(object o)
        {
            return o is IndexNode && ((IndexNode) o).loopId == loopId;
        }
		
        internal override long evaluateInt(FilterIterator t)
        {
            return t.indexVar[loopId];
        }
		
        internal IndexNode(int loop):base(NodeType.tpInt, NodeTag.opIndexVar)
        {
            loopId = loop;
        }
    }
	
    class GetAtNode:Node
    {
        internal Node left;
        internal Node right;
		
        public  override bool Equals(object o)
        {
            return o is GetAtNode && ((GetAtNode) o).left.Equals(left) && ((GetAtNode) o).right.Equals(right);
        }
		
        internal override long evaluateInt(FilterIterator t)
        {
            object arr = left.evaluateObj(t);
            long idx = right.evaluateInt(t);
			
            if (right.tag == NodeTag.opIndexVar)
            {
                if (idx >= ((Array) arr).Length)
                {
                    throw new IndexOutOfRangeError(((IndexNode) right).loopId);
                }
            }
            int index = (int) idx;
            switch (tag)
            {				
                case NodeTag.opGetAtInt1: 
                    return ((sbyte[]) arr)[index];
				
                case NodeTag.opGetAtInt2: 
                    return ((short[]) arr)[index];
				
                case NodeTag.opGetAtInt4: 
                    return ((int[]) arr)[index];