コード例 #1
0
        private void parseHavingClause(Query query, String havingClause)
        {
            // only parse "AND" delimitors, since "OR" will be taken care of as
            // compound filter items at 2nd level parsing
            QueryPartParser clauseParser = new QueryPartParser(new HavingItemParser(query), havingClause, " AND ");

            clauseParser.parse();
        }
コード例 #2
0
        } // constructor

        public void parse()
        {
            if (_clause.IsEmpty())
            {
                return;
            }

            int  parenthesisCount       = 0;
            int  offset                 = 0;
            bool singleOuterParenthesis = _clause[0] == '(' && _clause[_clause.Length - 1] == ')';

            String          previousDelim       = null;
            DelimOccurrence nextDelimOccurrence = getNextDelim(0);

            if (nextDelimOccurrence != null)
            {
                for (int i = 0; i < _clause.Length; i++)
                {
                    char c = _clause[i];
                    if (c == '(')
                    {
                        parenthesisCount++;
                    }
                    else if (c == ')')
                    {
                        parenthesisCount--;
                        if (singleOuterParenthesis && parenthesisCount == 0 && i != _clause.Length - 1)
                        {
                            singleOuterParenthesis = false;
                        }
                    }
                    if (i == nextDelimOccurrence.index)
                    {
                        if (parenthesisCount == 0)
                        {
                            // token bounds has been identified
                            String itemToken = _clause.Substring(offset, i);
                            parseItem(previousDelim, itemToken);
                            offset        = i + nextDelimOccurrence.delim.Length;
                            previousDelim = nextDelimOccurrence.delim;
                        }
                        nextDelimOccurrence = getNextDelim(nextDelimOccurrence.index + 1);
                        if (nextDelimOccurrence == null)
                        {
                            break;
                        }
                    }
                }
            }

            if (singleOuterParenthesis)
            {
                String newClause = _clause.Substring(1, _clause.Length - 1);
                // re-run based on new clause
                QueryPartParser newParser = new QueryPartParser(_processor, newClause, _ItemDelims);
                newParser.parse();
                return;
            }

            // last token will occur outside loop
            if (offset != _clause.Length)
            {
                String token = _clause.Substring(offset);
                parseItem(previousDelim, token);
            }
        }
コード例 #3
0
        private void parseOrderByClause(Query query, String orderByClause)
        {
            QueryPartParser clauseParser = new QueryPartParser(new OrderByItemParser(query), orderByClause, ",");

            clauseParser.parse();
        }
コード例 #4
0
        private void parseGroupByClause(Query query, String groupByClause)
        {
            QueryPartParser clauseParser = new QueryPartParser(new GroupByItemParser(query), groupByClause, ",");

            clauseParser.parse();
        }
コード例 #5
0
        private void parseSelectClause(Query query, String selectClause)
        {
            QueryPartParser clauseParser = new QueryPartParser(new SelectItemParser(query, false), selectClause, ",");

            clauseParser.parse();
        }
コード例 #6
0
        } // parse()

        private void parseFromClause(Query query, String fromClause)
        {
            QueryPartParser clauseParser = new QueryPartParser(new FromItemParser(_dataContext, query), fromClause, ",");

            clauseParser.parse();
        }