public static Query BuildQuery(string query, IndexQuery indexQuery, RavenPerFieldAnalyzerWrapper analyzer)
		{
			var originalQuery = query;
			try
			{
				var queryParser = new RangeQueryParser(Version.LUCENE_29, indexQuery.DefaultField ?? string.Empty, analyzer)
				{
					DefaultOperator = indexQuery.DefaultOperator == QueryOperator.Or
										? QueryParser.Operator.OR
										: QueryParser.Operator.AND,
					AllowLeadingWildcard = true
				};
				query = PreProcessComments(query);
				query = PreProcessMixedInclusiveExclusiveRangeQueries(query);
				query = PreProcessUntokenizedTerms(query, queryParser);
				query = PreProcessSearchTerms(query);
				query = PreProcessDateTerms(query, queryParser);
				var generatedQuery = queryParser.Parse(query);
				generatedQuery = HandleMethods(generatedQuery, analyzer);
				return generatedQuery;
			}
			catch (ParseException pe)
			{
				if (originalQuery == query)
					throw new ParseException("Could not parse: '" + query + "'", pe);
				throw new ParseException("Could not parse modified query: '" + query + "' original was: '" + originalQuery + "'", pe);

			}
		}
Beispiel #2
0
		private static Query HandleMethods(Query query, RavenPerFieldAnalyzerWrapper analyzer)
		{
			var termQuery = query as TermQuery;
			if (termQuery != null && termQuery.Term.Field.StartsWith("@"))
			{
				return HandleMethodsForQueryAndTerm(query, termQuery.Term);
			}
			var pharseQuery = query as PhraseQuery;
			if (pharseQuery != null)
			{
				var terms = pharseQuery.GetTerms();
				if (terms.All(x => x.Field.StartsWith("@")) == false ||
				    terms.Select(x => x.Field).Distinct().Count() != 1)
					return query;
				return HandleMethodsForQueryAndTerm(query, terms);
			}
			var wildcardQuery = query as WildcardQuery;
			if (wildcardQuery != null)
			{
				return HandleMethodsForQueryAndTerm(query, wildcardQuery.Term);
			}
			var booleanQuery = query as BooleanQuery;
			if (booleanQuery != null)
			{
				foreach (var c in booleanQuery.Clauses)
				{
					c.Query = HandleMethods(c.Query, analyzer);
				}
				if (booleanQuery.Clauses.Count == 0)
					return booleanQuery;
			
				//merge only clauses that have "OR" operator between them
				var mergeGroups = booleanQuery.Clauses.Where(clause => clause.Occur == Occur.SHOULD)
													  .Select(x=>x.Query)													  
													  .OfType<IRavenLuceneMethodQuery>()
													  .GroupBy(x => x.Field)
													  .ToArray();
				if (mergeGroups.Length == 0)
					return booleanQuery;

				foreach (var mergeGroup in mergeGroups)
				{
					var clauses = mergeGroup.ToArray();
					var first = clauses[0];
					foreach (var mergedClause in clauses.Skip(1))
					{
						booleanQuery.Clauses.RemoveAll(x => ReferenceEquals(x.Query, mergedClause));
					}
					var ravenLuceneMethodQuery = clauses.Skip(1).Aggregate(first, (methodQuery, clause) => methodQuery.Merge(clause));
					booleanQuery.Clauses.First(x => ReferenceEquals(x.Query, first)).Query = (Query)ravenLuceneMethodQuery;
				}
				if (booleanQuery.Clauses.Count == 1)
					return booleanQuery.Clauses[0].Query;
				return booleanQuery;
			}
			return query;
		}
Beispiel #3
0
 public static Query BuildQuery(string query, RavenPerFieldAnalyzerWrapper analyzer)
 {
     return(BuildQuery(query, new IndexQuery(), analyzer));
 }
Beispiel #4
0
        private static Query HandleMethods(Query query, RavenPerFieldAnalyzerWrapper analyzer)
        {
            var termQuery = query as TermQuery;

            if (termQuery != null && termQuery.Term.Field.StartsWith("@"))
            {
                return(HandleMethodsForQueryAndTerm(query, termQuery.Term));
            }
            var pharseQuery = query as PhraseQuery;

            if (pharseQuery != null)
            {
                var terms = pharseQuery.GetTerms();
                if (terms.All(x => x.Field.StartsWith("@")) == false ||
                    terms.Select(x => x.Field).Distinct().Count() != 1)
                {
                    return(query);
                }
                return(HandleMethodsForQueryAndTerm(query, terms));
            }
            var wildcardQuery = query as WildcardQuery;

            if (wildcardQuery != null)
            {
                return(HandleMethodsForQueryAndTerm(query, wildcardQuery.Term));
            }
            var booleanQuery = query as BooleanQuery;

            if (booleanQuery != null)
            {
                foreach (var c in booleanQuery.Clauses)
                {
                    c.Query = HandleMethods(c.Query, analyzer);
                }
                if (booleanQuery.Clauses.Count == 0)
                {
                    return(booleanQuery);
                }

                //merge only clauses that have "OR" operator between them
                var mergeGroups = booleanQuery.Clauses.Where(clause => clause.Occur == Occur.SHOULD)
                                  .Select(x => x.Query)
                                  .OfType <IRavenLuceneMethodQuery>()
                                  .GroupBy(x => x.Field)
                                  .ToArray();
                if (mergeGroups.Length == 0)
                {
                    return(booleanQuery);
                }

                foreach (var mergeGroup in mergeGroups)
                {
                    var clauses = mergeGroup.ToArray();
                    var first   = clauses[0];
                    foreach (var mergedClause in clauses.Skip(1))
                    {
                        booleanQuery.Clauses.RemoveAll(x => ReferenceEquals(x.Query, mergedClause));
                    }
                    var ravenLuceneMethodQuery = clauses.Skip(1).Aggregate(first, (methodQuery, clause) => methodQuery.Merge(clause));
                    booleanQuery.Clauses.First(x => ReferenceEquals(x.Query, first)).Query = (Query)ravenLuceneMethodQuery;
                }
                if (booleanQuery.Clauses.Count == 1)
                {
                    return(booleanQuery.Clauses[0].Query);
                }
                return(booleanQuery);
            }
            return(query);
        }
Beispiel #5
0
		public RavenPerFieldAnalyzerWrapper CreateAnalyzer(Analyzer defaultAnalyzer, ICollection<Action> toDispose, bool forQuerying = false)
		{
			toDispose.Add(defaultAnalyzer.Close);

			string value;
			if (indexDefinition.Analyzers.TryGetValue(Constants.AllFields, out value))
			{
				defaultAnalyzer = IndexingExtensions.CreateAnalyzerInstance(Constants.AllFields, value);
				toDispose.Add(defaultAnalyzer.Close);
			}
			var perFieldAnalyzerWrapper = new RavenPerFieldAnalyzerWrapper(defaultAnalyzer);
			foreach (var analyzer in indexDefinition.Analyzers)
			{
				Analyzer analyzerInstance = IndexingExtensions.CreateAnalyzerInstance(analyzer.Key, analyzer.Value);
				toDispose.Add(analyzerInstance.Close);

				if (forQuerying)
				{
					var customAttributes = analyzerInstance.GetType().GetCustomAttributes(typeof(NotForQueryingAttribute), false);
					if (customAttributes.Length > 0)
						continue;
				}

				perFieldAnalyzerWrapper.AddAnalyzer(analyzer.Key, analyzerInstance);
			}
			StandardAnalyzer standardAnalyzer = null;
			KeywordAnalyzer keywordAnalyzer = null;
			foreach (var fieldIndexing in indexDefinition.Indexes)
			{
				switch (fieldIndexing.Value)
				{
					case FieldIndexing.NotAnalyzed:
						if (keywordAnalyzer == null)
						{
							keywordAnalyzer = new KeywordAnalyzer();
							toDispose.Add(keywordAnalyzer.Close);
						}
						perFieldAnalyzerWrapper.AddAnalyzer(fieldIndexing.Key, keywordAnalyzer);
						break;
					case FieldIndexing.Analyzed:
						if (indexDefinition.Analyzers.ContainsKey(fieldIndexing.Key))
							continue;
						if (standardAnalyzer == null)
						{
							standardAnalyzer = new StandardAnalyzer(Version.LUCENE_29);
							toDispose.Add(standardAnalyzer.Close);
						}
						perFieldAnalyzerWrapper.AddAnalyzer(fieldIndexing.Key, standardAnalyzer);
						break;
				}
			}
			return perFieldAnalyzerWrapper;
		}
Beispiel #6
0
			private static void DisposeAnalyzerAndFriends(List<Action> toDispose, RavenPerFieldAnalyzerWrapper analyzer)
			{
				if (analyzer != null)
					analyzer.Close();
				foreach (Action dispose in toDispose)
				{
					dispose();
				}
				toDispose.Clear();
			}
		public static Query BuildQuery(string query, RavenPerFieldAnalyzerWrapper analyzer)
		{
			return BuildQuery(query, new IndexQuery(), analyzer);
		}
Beispiel #8
0
		private static Query Parse(string q)
		{
			using (var defaultAnalyzer = new KeywordAnalyzer())
			using (var perFieldAnalyzerWrapper = new RavenPerFieldAnalyzerWrapper(defaultAnalyzer))
				return QueryBuilder.BuildQuery(q, perFieldAnalyzerWrapper);
		}
		public SimpleFilesQueryParser(Analyzer analyzer)
            : base(Version.LUCENE_29, string.Empty, analyzer)
		{
            fieldAnalyzer = new RavenPerFieldAnalyzerWrapper(fieldAnalyzer);
		}