コード例 #1
0
        protected override Expression VisitMethodCall(MethodCallExpression node)
        {
            var call_object = (node.Object) as MemberExpression;

            if (call_object == null)
            {
                goto method_call_cleanup;
            }

            var    member_string = _get_member_string(call_object);
            string index_access_method;

            if (m_index_access_table.TryGetValue(member_string, out index_access_method) &&
                index_access_method == node.Method.Name)
            {
                if (node.Arguments.Count != 1)
                {
                    goto method_call_cleanup;
                }

                var    arg          = node.Arguments[0];
                string query_string = null;

                if (arg.NodeType == ExpressionType.Constant)
                {
                    query_string = (string)(arg as ConstantExpression).Value;
                }
                else
                {
                    query_string = _evaluate_expression <string>(arg);

                    /* We have to update the expression to avoid re-entering the expression */
                    node = node.Update(
                        node.Object,
                        new List <Expression> {
                        Expression.Constant(query_string, s_string_type)
                    });
                }

                if (query_string == null)
                {
                    goto method_call_cleanup;
                }

                /*
                 * @note    Gotcha. It's an index query method call!
                 */
                m_current_node             = new IndexQueryTreeNode(IndexQueryTreeNode.NodeType.QUERY);
                m_current_node.queryTarget = member_string;
                m_current_node.queryString = query_string;
            }

            /*
             * @note    We don't have to go deeper into the rabbit hole,
             *          as we cannot evaluate the method call.
             */
method_call_cleanup:
            return(node);
        }
コード例 #2
0
        void UnaryBuildTree(IndexQueryTreeNode.NodeType type, UnaryExpression node)
        {
            IndexQueryTreeNode query_node = new IndexQueryTreeNode {
                type = type, children = new List <IndexQueryTreeNode>()
            };

            VisitChildren(query_node.children, node.Operand);

            if (query_node.children.Count != 0)
            {
                m_current_node = query_node;
            }
        }
コード例 #3
0
        IndexQueryTreeNode VisitChild(Expression child)
        {
            IndexQueryTreeNode original_node = m_current_node;

            Visit(child);
            if (m_current_node != original_node)
            {
                var ret = m_current_node;
                m_current_node = original_node;
                return(ret);
            }
            else
            {
                return(null);
            }
        }
コード例 #4
0
        internal HashSet <long> Execute(IndexQueryTreeNode node)
        {
            if (node == null)
            {
                return(null);
            }

            HashSet <long> ret;

            switch (node.type)
            {
            case IndexQueryTreeNode.NodeType.AND:
                ret = Execute(node.children[0]);
                foreach (var child in node.children.Skip(1))
                {
                    ret.IntersectWith(Execute(child));
                }
                break;

            case IndexQueryTreeNode.NodeType.OR:
                ret = Execute(node.children[0]);
                foreach (var child in node.children.Skip(1))
                {
                    foreach (var id in Execute(child))
                    {
                        ret.Add(id);
                    }
                }
                break;

            case IndexQueryTreeNode.NodeType.QUERY:
                if (node.queryString != null)
                {
                    ret = new HashSet <long>(m_substring_query[node.queryTarget](node.queryString));
                }
                else
                {
                    ret = new HashSet <long>(m_substring_query_wildcard[node.queryTarget](node.wildcard_query));
                }
                break;

            default:
                throw new NotImplementedException("Internal error T5012.");
            }
            return(ret);
        }
コード例 #5
0
        private void _equality_build_tree(BinaryExpression node, bool is_equal)
        {
            if (node.Left.Type != s_bool_type || node.Right.Type != s_bool_type)
            {
                return;
            }

            bool?constant = null;
            List <Expression>       exp           = new List <Expression>();
            Func <bool, bool, bool> _equal_helper = (lhs, rhs) => is_equal? lhs == rhs : lhs != rhs;

            bool?lconstant = _constant_boolean_exp_eval(node.Left);
            bool?rconstant = _constant_boolean_exp_eval(node.Right);

            if (lconstant.HasValue)
            {
                constant = lconstant;
            }
            else
            {
                exp.Add(node.Left);
            }
            if (rconstant.HasValue)
            {
                constant = rconstant;
            }
            else
            {
                exp.Add(node.Right);
            }

            if (lconstant.HasValue && rconstant.HasValue)
            {
                m_current_node = new IndexQueryTreeNode(
                    _equal_helper(lconstant.Value, rconstant.Value)?
                    IndexQueryTreeNode.NodeType.UNIVERSE:IndexQueryTreeNode.NodeType.EMPTY);
                return;
            }

            IndexQueryTreeNode query_node;
            IndexQueryTreeNode child_node;

            if (constant.HasValue)
            {
                child_node = VisitChild(exp[0]);
                if (child_node == null)
                {
                    m_current_node = new IndexQueryTreeNode(
                        _equal_helper(constant.Value, true)?
                        IndexQueryTreeNode.NodeType.UNIVERSE: IndexQueryTreeNode.NodeType.EMPTY);
                }
                else
                {
                    if (_equal_helper(constant.Value, true))
                    { /* keep m_current_node as is */
                    }
                    else
                    {
                        query_node = new IndexQueryTreeNode(IndexQueryTreeNode.NodeType.NOT)
                        {
                            children = new List <IndexQueryTreeNode> {
                                child_node
                            }
                        };
                        m_current_node = query_node;
                    }
                }
            }
            else
            {
                query_node = new IndexQueryTreeNode(
                    _equal_helper(true, true)? IndexQueryTreeNode.NodeType.XNOR:IndexQueryTreeNode.NodeType.XOR)
                {
                    children = new List <IndexQueryTreeNode>()
                };

                VisitChildren(query_node.children, node.Left, node.Right);

                switch (query_node.children.Count)
                {
                case 0:
                case 1:
                    /* no index query actions, as we cannot analyse the semantics */
                    break;

                case 2:
                    /* we have query actions on both sides */
                    m_current_node = query_node;
                    break;

                default:
                    throw new Exception("Internal error T5010");
                }
            }
        }
コード例 #6
0
        internal IndexQueryTreeNode Optimize()
        {
            if (children != null)
            {
                List <IndexQueryTreeNode> new_child_list = new List <IndexQueryTreeNode>();
                foreach (var child in children)
                {
                    var new_child = child.Optimize();
                    if (new_child != null)
                    {
                        new_child_list.Add(new_child);
                    }
                }
                this.children = new_child_list;
            }

            if (type == NodeType.QUERY || type == NodeType.UNIVERSE || type == NodeType.EMPTY)
            {
                return(this);
            }

            if (children.Count == 0)
            {
                return(null);
            }

            IndexQueryTreeNode universe = null;
            IndexQueryTreeNode empty    = null;
            IndexQueryTreeNode normal   = null;

            foreach (var child in children)
            {
                if (child.type == NodeType.EMPTY)
                {
                    empty = child;
                }
                else if (child.type == NodeType.UNIVERSE)
                {
                    universe = child;
                }
                else
                {
                    normal = child;
                }
            }

            switch (type)
            {
            case NodeType.NOT:
                /* Drop NOT queries */
                if (children[0].type == NodeType.NOT)
                {
                    return(children[0].children[0]);
                }
                else
                {
                    return(null);
                }

            case NodeType.XNOR:
            case NodeType.XOR:
                /* Not implemented. */
                return(null);

            case NodeType.AND:
            {
                if (empty != null)
                {
                    return(empty);
                }
                if (universe != null)
                {
                    return(normal);
                }
                if (children.Count == 1)
                {
                    return(children[0]);
                }
                else
                {
                    return(this);
                }
            }

            case NodeType.OR:
            {
                if (empty != null)
                {
                    return(normal);
                }
                if (universe != null)
                {
                    return(universe);
                }
                if (children.Count == 1)
                {
                    return(children[0]);
                }
                else
                {
                    return(this);
                }
            }

            default:
                throw new Exception("Internal error T5011.");
            }
        }