コード例 #1
0
        /// <summary> A search implementation allowing sorting which spans a new thread for each
        /// Searchable, waits for each search to complete and merges
        /// the results back together.
        /// </summary>
        public override TopFieldDocs Search(Weight weight, Filter filter, int nDocs, Sort sort)
        {
            if (sort == null)
            {
                throw new ArgumentNullException("sort");
            }

            FieldDocSortedHitQueue hq = new FieldDocSortedHitQueue(nDocs);
            object lockObj            = new object();


            TopFieldDocs[] results = new TopFieldDocs[searchables.Length];

            Parallel.For(0, searchables.Length, (i) => results[i] = MultiSearcherCallableWithSort(ThreadLock.MonitorLock, lockObj, searchables[i], weight, filter, nDocs, hq, sort, i, starts));


            int   totalHits = 0;
            float maxScore  = float.NegativeInfinity;

            foreach (TopFieldDocs topFieldDocs in results)
            {
                totalHits += topFieldDocs.TotalHits;
                maxScore   = Math.Max(maxScore, topFieldDocs.MaxScore);
            }

            ScoreDoc[] scoreDocs = new ScoreDoc[hq.Size()];
            for (int i = hq.Size() - 1; i >= 0; i--)
            {
                scoreDocs[i] = hq.Pop();
            }

            return(new TopFieldDocs(totalHits, scoreDocs, hq.GetFields(), maxScore));
        }
コード例 #2
0
ファイル: MultiSearcher.cs プロジェクト: ravendb/lucenenet
        public override TopFieldDocs Search(Weight weight, Filter filter, int n, Sort sort, IState state)
        {
            var hq        = new FieldDocSortedHitQueue(n);
            int totalHits = 0;

            float maxScore = System.Single.NegativeInfinity;

            var lockObj = new object();

            for (int i = 0; i < searchables.Length; i++)
            {
                // search each searcher
                // use NullLock, we don't care about synchronization for these
                TopFieldDocs docs = MultiSearcherCallableWithSort(ThreadLock.NullLock, lockObj, searchables[i], weight, filter, n, hq, sort,
                                                                  i, starts, state);
                totalHits += docs.TotalHits;
                maxScore   = System.Math.Max(maxScore, docs.MaxScore);
            }

            ScoreDoc[] scoreDocs2 = new ScoreDoc[hq.Size()];
            for (int i = hq.Size() - 1; i >= 0; i--)
            {
                // put docs in array
                scoreDocs2[i] = hq.Pop();
            }

            return(new TopFieldDocs(totalHits, scoreDocs2, hq.GetFields(), maxScore));
        }
コード例 #3
0
        public override TopFieldDocs Search(Weight weight, Filter filter, int n, Sort sort)
        {
            FieldDocSortedHitQueue hq = null;
            int totalHits             = 0;

            float maxScore = System.Single.NegativeInfinity;

            for (int i = 0; i < searchables.Length; i++)
            {
                // search each searcher
                TopFieldDocs docs = searchables[i].Search(weight, filter, n, sort);
                // If one of the Sort fields is FIELD_DOC, need to fix its values, so that
                // it will break ties by doc Id properly. Otherwise, it will compare to
                // 'relative' doc Ids, that belong to two different searchers.
                for (int j = 0; j < docs.fields.Length; j++)
                {
                    if (docs.fields[j].GetType() == SortField.DOC)
                    {
                        // iterate over the score docs and change their fields value
                        for (int j2 = 0; j2 < docs.scoreDocs.Length; j2++)
                        {
                            FieldDoc fd = (FieldDoc)docs.scoreDocs[j2];
                            fd.fields[j] = (System.Int32)(((System.Int32)fd.fields[j]) + starts[i]);
                        }
                        break;
                    }
                }
                if (hq == null)
                {
                    hq = new FieldDocSortedHitQueue(docs.fields, n);
                }
                totalHits += docs.totalHits;                 // update totalHits
                maxScore   = System.Math.Max(maxScore, docs.GetMaxScore());
                ScoreDoc[] scoreDocs = docs.scoreDocs;
                for (int j = 0; j < scoreDocs.Length; j++)
                {
                    // merge scoreDocs into hq
                    ScoreDoc scoreDoc = scoreDocs[j];
                    scoreDoc.doc += starts[i];                     // convert doc
                    if (!hq.Insert(scoreDoc))
                    {
                        break;                         // no more scores > minScore
                    }
                }
            }

            ScoreDoc[] scoreDocs2 = new ScoreDoc[hq.Size()];
            for (int i = hq.Size() - 1; i >= 0; i--)
            {
                // put docs in array
                scoreDocs2[i] = (ScoreDoc)hq.Pop();
            }

            return(new TopFieldDocs(totalHits, scoreDocs2, hq.GetFields(), maxScore));
        }
コード例 #4
0
        /// <summary> A search implementation allowing sorting which spans a new thread for each
        /// Searchable, waits for each search to complete and merges
        /// the results back together.
        /// </summary>
        public override TopFieldDocs Search(Weight weight, Filter filter, int nDocs, Sort sort)
        {
            // don't specify the fields - we'll wait to do this until we get results
            FieldDocSortedHitQueue hq = new FieldDocSortedHitQueue(null, nDocs);
            int totalHits             = 0;

            MultiSearcherThread[] msta = new MultiSearcherThread[searchables.Length];
            for (int i = 0; i < searchables.Length; i++)
            {
                // search each searchable
                // Assume not too many searchables and cost of creating a thread is by far inferior to a search
                msta[i] = new MultiSearcherThread(searchables[i], weight, filter, nDocs, hq, sort, i, starts, "MultiSearcher thread #" + (i + 1));
                msta[i].Start();
            }

            float maxScore = System.Single.NegativeInfinity;

            for (int i = 0; i < searchables.Length; i++)
            {
                try
                {
                    msta[i].Join();
                }
                catch (System.Threading.ThreadInterruptedException ie)
                {
                    // In 3.0 we will change this to throw
                    // InterruptedException instead
                    SupportClass.ThreadClass.Current().Interrupt();
                    throw new System.SystemException(ie.Message, ie);
                }
                System.IO.IOException ioe = msta[i].GetIOException();
                if (ioe == null)
                {
                    totalHits += msta[i].Hits();
                    maxScore   = System.Math.Max(maxScore, msta[i].GetMaxScore());
                }
                else
                {
                    // if one search produced an IOException, rethrow it
                    throw ioe;
                }
            }

            ScoreDoc[] scoreDocs = new ScoreDoc[hq.Size()];
            for (int i = hq.Size() - 1; i >= 0; i--)
            {
                // put docs in array
                scoreDocs[i] = (ScoreDoc)hq.Pop();
            }

            return(new TopFieldDocs(totalHits, scoreDocs, hq.GetFields(), maxScore));
        }
コード例 #5
0
        public override TopFieldDocs Search(Weight weight, Filter filter, int n, Sort sort)
        {
            FieldDocSortedHitQueue hq = null;
            int totalHits             = 0;

            float maxScore = System.Single.NegativeInfinity;

            for (int i = 0; i < searchables.Length; i++)
            {
                // search each searcher
                TopFieldDocs docs = searchables[i].Search(weight, filter, n, sort);

                if (hq == null)
                {
                    hq = new FieldDocSortedHitQueue(docs.fields, n);
                }
                totalHits += docs.totalHits;                 // update totalHits
                maxScore   = System.Math.Max(maxScore, docs.GetMaxScore());
                ScoreDoc[] scoreDocs = docs.scoreDocs;
                for (int j = 0; j < scoreDocs.Length; j++)
                {
                    // merge scoreDocs into hq
                    ScoreDoc scoreDoc = scoreDocs[j];
                    scoreDoc.doc += starts[i];                     // convert doc
                    if (!hq.Insert(scoreDoc))
                    {
                        break;                         // no more scores > minScore
                    }
                }
            }

            ScoreDoc[] scoreDocs2 = new ScoreDoc[hq.Size()];
            for (int i = hq.Size() - 1; i >= 0; i--)
            {
                // put docs in array
                scoreDocs2[i] = (ScoreDoc)hq.Pop();
            }

            return(new TopFieldDocs(totalHits, scoreDocs2, hq.GetFields(), maxScore));
        }
コード例 #6
0
        /// <summary> A search implementation allowing sorting which spans a new thread for each
        /// Searchable, waits for each search to complete and merges
        /// the results back together.
        /// </summary>
        public override TopFieldDocs Search(Weight weight, Filter filter, int nDocs, Sort sort, IState state)
        {
            if (sort == null)
            {
                throw new ArgumentNullException("sort");
            }

            FieldDocSortedHitQueue hq = new FieldDocSortedHitQueue(nDocs);
            object lockObj            = new object();

            Task <TopFieldDocs>[] tasks = new Task <TopFieldDocs> [searchables.Length];
            for (int i = 0; i < searchables.Length; i++) // search each searchable
            {
                int cur = i;
                tasks[i] =
                    Task <TopFieldDocs> .Factory.StartNew(
                        () => MultiSearcherCallableWithSort(ThreadLock.MonitorLock, lockObj, searchables[cur], weight, filter, nDocs, hq, sort, cur,
                                                            starts, state));
            }

            int   totalHits = 0;
            float maxScore  = float.NegativeInfinity;

            Task.WaitAll(tasks);
            foreach (TopFieldDocs topFieldDocs in tasks.Select(x => x.Result))
            {
                totalHits += topFieldDocs.TotalHits;
                maxScore   = Math.Max(maxScore, topFieldDocs.MaxScore);
            }

            ScoreDoc[] scoreDocs = new ScoreDoc[hq.Size()];
            for (int i = hq.Size() - 1; i >= 0; i--)
            {
                scoreDocs[i] = hq.Pop();
            }

            return(new TopFieldDocs(totalHits, scoreDocs, hq.GetFields(), maxScore));
        }
コード例 #7
0
ファイル: MultiSearcher.cs プロジェクト: sinsay/SSE
        public override TopFieldDocs Search(Weight weight, Filter filter, int n, Sort sort)
        {
            FieldDocSortedHitQueue hq = null;
            int totalHits = 0;

            float maxScore = System.Single.NegativeInfinity;

            for (int i = 0; i < searchables.Length; i++)
            {
                // search each searcher
                TopFieldDocs docs = searchables[i].Search(weight, filter, n, sort);
                // If one of the Sort fields is FIELD_DOC, need to fix its values, so that
                // it will break ties by doc Id properly. Otherwise, it will compare to
                // 'relative' doc Ids, that belong to two different searchers.
                for (int j = 0; j < docs.fields.Length; j++)
                {
                    if (docs.fields[j].GetType() == SortField.DOC)
                    {
                        // iterate over the score docs and change their fields value
                        for (int j2 = 0; j2 < docs.ScoreDocs.Length; j2++)
                        {
                            FieldDoc fd = (FieldDoc) docs.ScoreDocs[j2];
                            fd.fields[j] = (System.Int32) (((System.Int32) fd.fields[j]) + starts[i]);
                        }
                        break;
                    }
                }
                if (hq == null)
                    hq = new FieldDocSortedHitQueue(docs.fields, n);
                totalHits += docs.TotalHits; // update totalHits
                maxScore = System.Math.Max(maxScore, docs.GetMaxScore());
                ScoreDoc[] scoreDocs = docs.ScoreDocs;
                for (int j = 0; j < scoreDocs.Length; j++)
                {
                    // merge scoreDocs into hq
                    ScoreDoc scoreDoc = scoreDocs[j];
                    scoreDoc.doc += starts[i]; // convert doc
                    if (!hq.Insert(scoreDoc))
                        break; // no more scores > minScore
                }
            }

            ScoreDoc[] scoreDocs2 = new ScoreDoc[hq.Size()];
            for (int i = hq.Size() - 1; i >= 0; i--)
            // put docs in array
                scoreDocs2[i] = (ScoreDoc) hq.Pop();

            return new TopFieldDocs(totalHits, scoreDocs2, hq.GetFields(), maxScore);
        }
コード例 #8
0
ファイル: MultiSearcher.cs プロジェクト: zweib730/beagrep
		public override TopFieldDocs Search(Weight weight, Filter filter, int n, Sort sort)
		{
			FieldDocSortedHitQueue hq = null;
			int totalHits = 0;
			
			float maxScore = System.Single.NegativeInfinity;
			
			for (int i = 0; i < searchables.Length; i++)
			{
				// search each searcher
				TopFieldDocs docs = searchables[i].Search(weight, filter, n, sort);
				
				if (hq == null)
					hq = new FieldDocSortedHitQueue(docs.fields, n);
				totalHits += docs.totalHits; // update totalHits
				maxScore = System.Math.Max(maxScore, docs.GetMaxScore());
				ScoreDoc[] scoreDocs = docs.scoreDocs;
				for (int j = 0; j < scoreDocs.Length; j++)
				{
					// merge scoreDocs into hq
					ScoreDoc scoreDoc = scoreDocs[j];
					scoreDoc.doc += starts[i]; // convert doc
					if (!hq.Insert(scoreDoc))
						break; // no more scores > minScore
				}
			}
			
			ScoreDoc[] scoreDocs2 = new ScoreDoc[hq.Size()];
			for (int i = hq.Size() - 1; i >= 0; i--)
				// put docs in array
				scoreDocs2[i] = (ScoreDoc) hq.Pop();
			
			return new TopFieldDocs(totalHits, scoreDocs2, hq.GetFields(), maxScore);
		}
コード例 #9
0
 public MultiSearcherThread(Lucene.Net.Search.Searchable searchable, Weight weight, Filter filter, int nDocs, FieldDocSortedHitQueue hq, Sort sort, int i, int[] starts, System.String name) : base(name)
 {
     this.searchable = searchable;
     this.weight     = weight;
     this.filter     = filter;
     this.nDocs      = nDocs;
     this.hq         = hq;
     this.i          = i;
     this.starts     = starts;
     this.sort       = sort;
 }
コード例 #10
0
 public MultiSearcherThread(Searchable searchable, Weight weight, Filter filter, int nDocs, FieldDocSortedHitQueue hq, Sort sort, int i, int[] starts, System.String name)
     : base(name)
 {
     this.searchable = searchable;
     this.weight = weight;
     this.filter = filter;
     this.nDocs = nDocs;
     this.hq = hq;
     this.i = i;
     this.starts = starts;
     this.sort = sort;
 }
コード例 #11
0
        /// <summary> A search implementation allowing sorting which spans a new thread for each
        /// Searchable, waits for each search to complete and merges
        /// the results back together.
        /// </summary>
        public override TopFieldDocs Search(Weight weight, Filter filter, int nDocs, Sort sort)
        {
            // don't specify the fields - we'll wait to do this until we get results
            FieldDocSortedHitQueue hq = new FieldDocSortedHitQueue(null, nDocs);
            int totalHits = 0;
            MultiSearcherThread[] msta = new MultiSearcherThread[searchables.Length];
            for (int i = 0; i < searchables.Length; i++)
            {
                // search each searchable
                // Assume not too many searchables and cost of creating a thread is by far inferior to a search
                msta[i] = new MultiSearcherThread(searchables[i], weight, filter, nDocs, hq, sort, i, starts, "MultiSearcher thread #" + (i + 1));
                msta[i].Start();
            }

            float maxScore = System.Single.NegativeInfinity;

            for (int i = 0; i < searchables.Length; i++)
            {
                try
                {
                    msta[i].Join();
                }
                catch (System.Threading.ThreadInterruptedException ie)
                {
                    // In 3.0 we will change this to throw
                    // InterruptedException instead
                    SupportClass.ThreadClass.Current().Interrupt();
                    throw new System.SystemException(ie.Message, ie);
                }
                System.IO.IOException ioe = msta[i].GetIOException();
                if (ioe == null)
                {
                    totalHits += msta[i].Hits();
                    maxScore = System.Math.Max(maxScore, msta[i].GetMaxScore());
                }
                else
                {
                    // if one search produced an IOException, rethrow it
                    throw ioe;
                }
            }

            ScoreDoc[] scoreDocs = new ScoreDoc[hq.Size()];
            for (int i = hq.Size() - 1; i >= 0; i--)
            // put docs in array
                scoreDocs[i] = (ScoreDoc) hq.Pop();

            return new TopFieldDocs(totalHits, scoreDocs, hq.GetFields(), maxScore);
        }
コード例 #12
0
ファイル: MultiSearcher.cs プロジェクト: Cefa68000/lucenenet
        public override TopFieldDocs Search(Weight weight, Filter filter, int n, Sort sort)
        {
            var hq = new FieldDocSortedHitQueue(n);
            int totalHits = 0;
            
            float maxScore = System.Single.NegativeInfinity;

            var lockObj = new object();
            for (int i = 0; i < searchables.Length; i++)
            {
                // search each searcher
                // use NullLock, we don't care about synchronization for these
                TopFieldDocs docs = MultiSearcherCallableWithSort(ThreadLock.NullLock, lockObj, searchables[i], weight, filter, n, hq, sort,
                                                      i, starts);
                totalHits += docs.TotalHits;
                maxScore = System.Math.Max(maxScore, docs.MaxScore);
            }
            
            ScoreDoc[] scoreDocs2 = new ScoreDoc[hq.Size()];
            for (int i = hq.Size() - 1; i >= 0; i--)
            // put docs in array
                scoreDocs2[i] = hq.Pop();
            
            return new TopFieldDocs(totalHits, scoreDocs2, hq.GetFields(), maxScore);
        }
コード例 #13
0
		/// <summary> A search implementation allowing sorting which spans a new thread for each
		/// Searchable, waits for each search to complete and merges
		/// the results back together.
		/// </summary>
		public override TopFieldDocs Search(Weight weight, Filter filter, int nDocs, Sort sort)
		{
            if (sort == null) throw new ArgumentNullException("sort");

		    FieldDocSortedHitQueue hq = new FieldDocSortedHitQueue(nDocs);
            object lockObj = new object();

            Task<TopFieldDocs>[] tasks = new Task<TopFieldDocs>[searchables.Length];
            for (int i = 0; i < searchables.Length; i++) // search each searchable
            {
                int cur = i;
                tasks[i] =
                    Task<TopFieldDocs>.Factory.StartNew(
                        () => MultiSearcherCallableWithSort(ThreadLock.MonitorLock, lockObj, searchables[cur], weight, filter, nDocs, hq, sort, cur,
                                                      starts));
            }

		    int totalHits = 0;
		    float maxScore = float.NegativeInfinity;

            Task.WaitAll(tasks);
            foreach (TopFieldDocs topFieldDocs in tasks.Select(x => x.Result))
            {
                totalHits += topFieldDocs.TotalHits;
                maxScore = Math.Max(maxScore, topFieldDocs.MaxScore);
            }

            ScoreDoc[] scoreDocs = new ScoreDoc[hq.Size()];
            for (int i = hq.Size() - 1; i >= 0; i--)
                scoreDocs[i] = hq.Pop();

		    return new TopFieldDocs(totalHits, scoreDocs, hq.GetFields(), maxScore);
		}
コード例 #14
0
        /// <summary> A search implementation allowing sorting which spans a new thread for each
        /// Searchable, waits for each search to complete and merges
        /// the results back together.
        /// </summary>
        public override TopFieldDocs Search(Weight weight, Filter filter, int nDocs, Sort sort)
        {
            if (sort == null) throw new ArgumentNullException("sort");

            FieldDocSortedHitQueue hq = new FieldDocSortedHitQueue(nDocs);
            object lockObj = new object();

            TopFieldDocs[] results = new TopFieldDocs[searchables.Length];

            Parallel.For(0, searchables.Length, (i) => results[i] = MultiSearcherCallableWithSort(ThreadLock.MonitorLock, lockObj, searchables[i], weight, filter, nDocs, hq, sort, i, starts));

            int totalHits = 0;
            float maxScore = float.NegativeInfinity;

            foreach (TopFieldDocs topFieldDocs in results)
            {
                totalHits += topFieldDocs.TotalHits;
                maxScore = Math.Max(maxScore, topFieldDocs.MaxScore);
            }

            ScoreDoc[] scoreDocs = new ScoreDoc[hq.Size()];
            for (int i = hq.Size() - 1; i >= 0; i--)
                scoreDocs[i] = hq.Pop();

            return new TopFieldDocs(totalHits, scoreDocs, hq.GetFields(), maxScore);
        }