RavenDB-803 WhereIn when using an index

ravendb · Jan 5, 2013 · b6b80ba · b6b80ba
1 parent 1c6abff
commit b6b80ba
Show file tree

Hide file tree

Showing 10 changed files with 139 additions and 37 deletions.
diff --git a/Raven.Database/Indexing/Index.cs b/Raven.Database/Indexing/Index.cs
@@ -414,7 +414,7 @@ private void WriteTempIndexToDiskIfNeeded(WorkContext context)
 			CreateIndexWriter();
 		}
 
-		public PerFieldAnalyzerWrapper CreateAnalyzer(Analyzer defaultAnalyzer, ICollection<Action> toDispose, bool forQuerying = false)
+		public RavenPerFieldAnalyzerWrapper CreateAnalyzer(Analyzer defaultAnalyzer, ICollection<Action> toDispose, bool forQuerying = false)
 		{
 			toDispose.Add(defaultAnalyzer.Close);
 
@@ -424,7 +424,7 @@ public PerFieldAnalyzerWrapper CreateAnalyzer(Analyzer defaultAnalyzer, ICollect
 				defaultAnalyzer = IndexingExtensions.CreateAnalyzerInstance(Constants.AllFields, value);
 				toDispose.Add(defaultAnalyzer.Close);
 			}
-			var perFieldAnalyzerWrapper = new PerFieldAnalyzerWrapper(defaultAnalyzer);
+			var perFieldAnalyzerWrapper = new RavenPerFieldAnalyzerWrapper(defaultAnalyzer);
 			foreach (var analyzer in indexDefinition.Analyzers)
 			{
 				Analyzer analyzerInstance = IndexingExtensions.CreateAnalyzerInstance(analyzer.Key, analyzer.Value);
@@ -1020,7 +1020,7 @@ private Query GetLuceneQuery(string query, IndexQuery indexQuery)
 				{
 					logQuerying.Debug("Issuing query on index {0} for: {1}", parent.name, query);
 					var toDispose = new List<Action>();
-					PerFieldAnalyzerWrapper searchAnalyzer = null;
+					RavenPerFieldAnalyzerWrapper searchAnalyzer = null;
 					try
 					{
 						searchAnalyzer = parent.CreateAnalyzer(new LowerCaseKeywordAnalyzer(), toDispose, true);
@@ -1043,7 +1043,7 @@ private Query GetLuceneQuery(string query, IndexQuery indexQuery)
 				return luceneQuery;
 			}
 
-			private static void DisposeAnalyzerAndFriends(List<Action> toDispose, PerFieldAnalyzerWrapper analyzer)
+			private static void DisposeAnalyzerAndFriends(List<Action> toDispose, RavenPerFieldAnalyzerWrapper analyzer)
 			{
 				if (analyzer != null)
 					analyzer.Close();

diff --git a/Raven.Database/Indexing/LuceneIntegration/TermsMatchQuery.cs b/Raven.Database/Indexing/LuceneIntegration/TermsMatchQuery.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.Tokenattributes;
 using Lucene.Net.Index;
 using Lucene.Net.Search;
@@ -28,7 +27,7 @@ public string Field
 			get { return field; }
 		}
 
-		public TermsMatchQuery(string field, IEnumerable<string> matches, PerFieldAnalyzerWrapper analyzer)
+		public TermsMatchQuery(string field, IEnumerable<string> matches, RavenPerFieldAnalyzerWrapper analyzer)
 		{
 			this.field = field;
 			this.matches = new List<string>();

diff --git a/Raven.Database/Indexing/QueryBuilder.cs b/Raven.Database/Indexing/QueryBuilder.cs
@@ -25,18 +25,18 @@ public static class QueryBuilder
 		static readonly Regex searchQuery = new Regex(@"([\w\d_]+?):\s*(\<\<.+?\>\>)(^[\d.]+)?", RegexOptions.Compiled | RegexOptions.Singleline);
 		static readonly Regex dateQuery = new Regex(@"([\w\d_]+?):\s*(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{7}Z?)", RegexOptions.Compiled);
 
-		private static readonly Dictionary<string, Func<string, List<string>, PerFieldAnalyzerWrapper, Query>> queryMethods = new Dictionary<string, Func<string, List<string>, PerFieldAnalyzerWrapper, Query>>(StringComparer.InvariantCultureIgnoreCase)
+		private static readonly Dictionary<string, Func<string, List<string>, RavenPerFieldAnalyzerWrapper, Query>> queryMethods = new Dictionary<string, Func<string, List<string>, RavenPerFieldAnalyzerWrapper, Query>>(StringComparer.InvariantCultureIgnoreCase)
 		{
 			{"in", (field, args, analyzer) => new TermsMatchQuery(field, args, analyzer)},
 			{"emptyIn", (field, args, analyzer) => new TermsMatchQuery(field, Enumerable.Empty<string>(), analyzer)}
 		};
 
-		public static Query BuildQuery(string query, PerFieldAnalyzerWrapper analyzer)
+		public static Query BuildQuery(string query, RavenPerFieldAnalyzerWrapper analyzer)
 		{
 			return BuildQuery(query, new IndexQuery(), analyzer);
 		}
 
-		public static Query BuildQuery(string query, IndexQuery indexQuery, PerFieldAnalyzerWrapper analyzer)
+		public static Query BuildQuery(string query, IndexQuery indexQuery, RavenPerFieldAnalyzerWrapper analyzer)
 		{
 			var originalQuery = query;
 			try
@@ -64,7 +64,7 @@ public static Query BuildQuery(string query, IndexQuery indexQuery, PerFieldAnal
 			}
 		}
 
-		private static Query HandleMethods(Query query, PerFieldAnalyzerWrapper analyzer)
+		private static Query HandleMethods(Query query, RavenPerFieldAnalyzerWrapper analyzer)
 		{
 			var termQuery = query as TermQuery;
 			if (termQuery != null && termQuery.Term.Field.StartsWith("@"))
@@ -110,9 +110,9 @@ private static Query HandleMethods(Query query, PerFieldAnalyzerWrapper analyzer
 
 		private static Regex unescapedSplitter = new Regex("(?<!`),(?!`)", RegexOptions.Compiled);
 
-		private static Query HandleMethodsForQueryAndTerm(Query query, Term term, PerFieldAnalyzerWrapper analyzer)
+		private static Query HandleMethodsForQueryAndTerm(Query query, Term term, RavenPerFieldAnalyzerWrapper analyzer)
 		{
-			Func<string, List<string>, PerFieldAnalyzerWrapper, Query> value;
+			Func<string, List<string>, RavenPerFieldAnalyzerWrapper, Query> value;
 			var indexOfFieldStart = term.Field.IndexOf('<');
 			var indexOfFieldEnd = term.Field.LastIndexOf('>');
 			if (indexOfFieldStart == -1 || indexOfFieldEnd == -1)

diff --git a/Raven.Database/Indexing/RavenPerFieldAnalyzerWrapper.cs b/Raven.Database/Indexing/RavenPerFieldAnalyzerWrapper.cs
@@ -0,0 +1,69 @@
+// -----------------------------------------------------------------------
+//  <copyright file="RavenPerFieldAnalyzerWrapper.cs" company="Hibernating Rhinos LTD">
+//      Copyright (c) Hibernating Rhinos LTD. All rights reserved.
+//  </copyright>
+// -----------------------------------------------------------------------
+using System.Collections.Generic;
+using Lucene.Net.Analysis;
+using Lucene.Net.Documents;
+using System.Linq;
+
+namespace Raven.Database.Indexing
+{
+	public sealed class RavenPerFieldAnalyzerWrapper : Analyzer
+	{
+		private readonly Analyzer defaultAnalyzer;
+		private readonly IDictionary<string, Analyzer> analyzerMap = new Dictionary<string, Analyzer>();
+
+		public RavenPerFieldAnalyzerWrapper(Analyzer defaultAnalyzer)
+		{
+			this.defaultAnalyzer = defaultAnalyzer;
+		}
+
+		public void AddAnalyzer(System.String fieldName, Analyzer analyzer)
+		{
+			analyzerMap[fieldName] = analyzer;
+		}
+
+		public override TokenStream TokenStream(System.String fieldName, System.IO.TextReader reader)
+		{
+			return GetAnalyzer(fieldName).TokenStream(fieldName, reader);
+		}
+
+		private Analyzer GetAnalyzer(string fieldName)
+		{
+			if (fieldName.StartsWith("@"))
+			{
+				var indexOfFieldStart = fieldName.IndexOf('<');
+				var indexOfFieldEnd = fieldName.LastIndexOf('>');
+				if (indexOfFieldStart != -1 && indexOfFieldEnd != -1)
+				{
+					fieldName = fieldName.Substring(indexOfFieldStart + 1, indexOfFieldEnd - indexOfFieldStart - 1);
+				}
+			}
+			Analyzer value;
+			analyzerMap.TryGetValue(fieldName, out value);
+			return value ?? defaultAnalyzer;
+		}
+
+		public override TokenStream ReusableTokenStream(string fieldName, System.IO.TextReader reader)
+		{
+			return GetAnalyzer(fieldName).ReusableTokenStream(fieldName, reader);
+		}
+
+		public override int GetPositionIncrementGap(string fieldName)
+		{
+			return GetAnalyzer(fieldName).GetPositionIncrementGap(fieldName);
+		}
+
+		public override int GetOffsetGap(IFieldable field)
+		{
+			return GetAnalyzer(field.Name).GetOffsetGap(field);
+		}
+
+		public override System.String ToString()
+		{
+			return "PerFieldAnalyzerWrapper(" + string.Join(",", analyzerMap.Select(x => x.Key + " -> " + x.Value)) + ", default=" + defaultAnalyzer + ")";
+		}
+	}
+}
diff --git a/Raven.Database/Indexing/SimpleQueryParser.cs b/Raven.Database/Indexing/SimpleQueryParser.cs
@@ -19,7 +19,7 @@ namespace Raven.Database.Indexing
 {
 	public class SimpleQueryParser
 	{
-		static readonly PerFieldAnalyzerWrapper perFieldAnalyzerWrapper = new PerFieldAnalyzerWrapper(new KeywordAnalyzer());
+		static readonly RavenPerFieldAnalyzerWrapper perFieldAnalyzerWrapper = new RavenPerFieldAnalyzerWrapper(new KeywordAnalyzer());
 
 		public static HashSet<string> GetFields(IndexQuery query)
 		{

diff --git a/Raven.Database/Queries/MoreLikeThisQueryRunner.cs b/Raven.Database/Queries/MoreLikeThisQueryRunner.cs
@@ -90,7 +90,7 @@ public MoreLikeThisQueryResult ExecuteMoreLikeThisQuery(MoreLikeThisQuery query,
 				mlt.SetFieldNames(fieldNames);
 
 				var toDispose = new List<Action>();
-				PerFieldAnalyzerWrapper perFieldAnalyzerWrapper = null;
+				RavenPerFieldAnalyzerWrapper perFieldAnalyzerWrapper = null;
 				try
 				{
 					perFieldAnalyzerWrapper = index.CreateAnalyzer(new LowerCaseKeywordAnalyzer(), toDispose, true);

diff --git a/Raven.Database/Raven.Database.csproj b/Raven.Database/Raven.Database.csproj
@@ -200,6 +200,7 @@
     <Compile Include="Indexing\LowerCaseWhitespaceTokenizer.cs" />
     <Compile Include="Indexing\LuceneIntegration\TermsMatchQuery.cs" />
     <Compile Include="Indexing\PrefetchingBehavior.cs" />
+    <Compile Include="Indexing\RavenPerFieldAnalyzerWrapper.cs" />
     <Compile Include="Indexing\Spatial\RecursivePrefixTreeStrategyThatSupportsWithin.cs" />
     <Compile Include="Json\ScriptsCache.cs" />
     <Compile Include="Linq\Ast\ThrowOnInvalidMethodCallsForTransformResults.cs" />