/// <summary> /// Builds the query. /// </summary> /// <param name="node">The query node.</param> /// <param name="query">The query.</param> protected virtual void BuildQuery(QueryNode node, StringBuilder query) { if (node == null) { return; } if (node.Element is Query) { Query subQuery = node.Element as Query; if (!string.IsNullOrEmpty(subQuery.SearchRoot)) { query.AppendFormat(" {0}//*", subQuery.SearchRoot); } if (subQuery.FirstNode != null) { query.Append("("); this.BuildQuery(subQuery.FirstNode, query); query.Append(")"); } } else if (node.Element is Condition) { Condition condition = node.Element as Condition; query.AppendFormat(" {0} ", condition.QueryCondition.ToString().ToLower()); } else if (node.Element is AttributeQuery) { query.Append(this.BuildAttributeSubQuery(node.Element as AttributeQuery)); } else if (node.Element is FieldQuery) { query.Append(this.BuildFieldSubQuery(node.Element as FieldQuery)); } if (node.NextNode != null) { this.BuildQuery(node.NextNode, query); } }
/// <summary> /// Builds the query. /// </summary> /// <param name="query">The result query.</param> /// <param name="node">The query node.</param> protected virtual void BuildQuery(LuceneSearch.BooleanQuery query, QueryNode node) { Query subQuery = node.Element as Query; if (subQuery != null && !subQuery.IsEmpty()) { LuceneSearch.BooleanQuery booleanQuery = new LuceneSearch.BooleanQuery(); if (!string.IsNullOrEmpty(subQuery.SearchRoot)) { this.AddSearchRoot(booleanQuery, subQuery.SearchRoot); } this.BuildQuery(booleanQuery, subQuery.FirstNode); LuceneSearch.Occur occurance = LuceneSearch.Occur.MUST; if (node.IsFirst) { if (!node.IsLast && (node.NextNode.Element is Condition)) { occurance = this.GetOccur(((Condition)node.NextNode.Element).QueryCondition); } } else { if (!node.IsFirst && (node.PreviousNode.Element is Condition)) { occurance = this.GetOccur(((Condition)node.PreviousNode.Element).QueryCondition); } } query.Add(booleanQuery, occurance); } else if (node.Element is AttributeQuery || node.Element is FieldQuery) { QueryCondition condition = QueryCondition.And; if (node.IsFirst) { if (!node.IsLast && (node.NextNode.Element is Condition)) { condition = ((Condition)node.NextNode.Element).QueryCondition; } } else { if (!node.IsFirst && (node.PreviousNode.Element is Condition)) { condition = ((Condition)node.PreviousNode.Element).QueryCondition; } } this.AddSubQuery(query, node.Element as SubQuery, condition); } if (!node.IsLast) { this.BuildQuery(query, node.NextNode); } this.resultQuery = query; }
/// <summary> /// Appends the subquery. /// </summary> /// <param name="query">The query.</param> public void AppendSubquery(Query query) { QueryNode node = new QueryNode(query); this.AddNode(node); }
/// <summary> /// Adds the condition. /// </summary> /// <param name="condition">The condition.</param> public void AppendCondition(QueryCondition condition) { QueryNode node = new QueryNode(new Condition(condition)); this.AddNode(node); }
/// <summary> /// Appends the field. /// </summary> /// <param name="key">The attribute key.</param> /// <param name="value">The attribute value.</param> /// <param name="matchVariant">The match variant.</param> public void AppendField(string key, string value, MatchVariant matchVariant) { FieldQuery fldQuery = new FieldQuery(key, value, matchVariant); QueryNode node = new QueryNode(fldQuery); this.AddNode(node); }
/// <summary> /// Appends the subquery. /// </summary> /// <param name="key">The attribute key.</param> /// <param name="value">The attribute value.</param> /// <param name="matchVariant">The match variant.</param> public void AppendAttribute(string key, string value, MatchVariant matchVariant) { AttributeQuery query = new AttributeQuery(key, value, matchVariant); QueryNode node = new QueryNode(query); this.AddNode(node); }
/// <summary> /// Adds the node. /// </summary> /// <param name="node">The query node.</param> /// <exception cref="ArgumentException">Cannot add two conditions in succession</exception> protected virtual void AddNode(QueryNode node) { Query query = node.Element as Query; if (query != null && this.Equals(query)) { throw new ArgumentException("Cannot insert same query in it self"); } if (this.IsEmpty() && node.Element is Condition) { throw new ArgumentException("First argument cannot be a condition"); } if (node.IsQuery() && ((Query)node.Element).IsEmpty()) { throw new ArgumentException("Query is invalid"); } if (this.IsEmpty()) { this.FirstNode = node; this.LastNode = node; } else { if (this.LastNode.Element is Condition && node.Element is Condition) { throw new ArgumentException("Cannot add two conditions in succession"); } if (this.LastNode.Element is SubQuery && node.Element is SubQuery) { throw new ArgumentException("Cannot add two subqueries without condition"); } if (this.FirstNode.NextNode == null) { this.FirstNode.NextNode = node; } else { node.PreviousNode = this.LastNode; this.LastNode.NextNode = node; } this.LastNode = node; } }
/// <summary> /// Determines whether [contains] [the specified node]. /// </summary> /// <param name="node">The query node.</param> /// <param name="query">The query.</param> /// <returns> /// <c>true</c> if [contains] [the specified node]; otherwise, <c>false</c>. /// </returns> protected virtual bool Contains(QueryNode node, SubQuery query) { if (node.Element.Equals(query)) { return true; } if (node.IsQuery()) { return this.Contains(((Query)node.Element).FirstNode, query); } if (!node.IsLast) { return this.Contains(node.NextNode, query); } return false; }