コード例 #1
0
        public override int HandleMap(IndexItem indexItem, IEnumerable mapResults, Lazy <IndexWriteOperation> writer, TransactionOperationContext indexContext, IndexingStatsScope stats)
        {
            EnsureValidStats(stats);

            bool mustDelete;

            using (_stats.BloomStats.Start())
            {
                mustDelete = _filters.Add(indexItem.LowerId) == false;
            }

            if (indexItem.SkipLuceneDelete == false && mustDelete)
            {
                writer.Value.Delete(indexItem.LowerId, stats);
            }

            var numberOfOutputs = 0;

            foreach (var mapResult in mapResults)
            {
                writer.Value.IndexDocument(indexItem.LowerId, indexItem.LowerSourceDocumentId, mapResult, stats, indexContext);

                numberOfOutputs++;
            }

            HandleIndexOutputsPerDocument(indexItem.Id ?? indexItem.LowerId, numberOfOutputs, stats);

            DocumentDatabase.Metrics.MapIndexes.IndexedPerSec.Mark(numberOfOutputs);

            return(numberOfOutputs);
        }
コード例 #2
0
        public override int HandleMap(LazyStringValue key, IEnumerable mapResults, IndexWriteOperation writer, TransactionOperationContext indexContext, IndexingStatsScope stats)
        {
            EnsureValidStats(stats);

            bool mustDelete;

            using (_stats.BloomStats.Start())
            {
                mustDelete = _filter.Add(key) == false;
            }

            if (mustDelete)
            {
                writer.Delete(key, stats);
            }

            var numberOfOutputs = 0;

            foreach (var mapResult in mapResults)
            {
                writer.IndexDocument(key, mapResult, stats, indexContext);
                numberOfOutputs++;
            }

            HandleIndexOutputsPerDocument(key, numberOfOutputs, stats);

            DocumentDatabase.Metrics.IndexedPerSecond.Mark();
            return(numberOfOutputs);
        }
コード例 #3
0
 public override void HandleDelete(Tombstone tombstone, string collection, Lazy <IndexWriteOperation> writer, TransactionOperationContext indexContext, IndexingStatsScope stats)
 {
     writer.Value.Delete(tombstone.LowerId, stats);
 }
コード例 #4
0
        public static void HandleDeleteBySourceDocumentId(MapReduceIndex index, HandleReferences handleReferences, HandleCompareExchangeReferences handleCompareExchangeReferences, Tombstone tombstone, string collection, Lazy<IndexWriteOperation> writer, TransactionOperationContext indexContext, IndexingStatsScope stats)
        {
            HandleReferencesDelete(handleReferences, handleCompareExchangeReferences, tombstone, collection, writer, indexContext, stats);

            using (ToPrefixKey(tombstone.LowerId, indexContext, out var prefixKey))
            {
                var toDelete = new List<Slice>();

                using (var it = index.MapReduceWorkContext.MapPhaseTree.Iterate(prefetch: false))
                {
                    it.SetRequiredPrefix(prefixKey);

                    if (it.Seek(prefixKey) == false)
                        return;

                    do
                    {
                        toDelete.Add(it.CurrentKey.Clone(indexContext.Allocator));
                    } while (it.MoveNext());
                }

                foreach (var key in toDelete)
                {
                    index.MapReduceWorkContext.DocumentMapEntries.RepurposeInstance(key, clone: false);

                    if (index.MapReduceWorkContext.DocumentMapEntries.NumberOfEntries == 0)
                        continue;

                    foreach (var mapEntry in MapReduceIndex.GetMapEntries(index.MapReduceWorkContext.DocumentMapEntries))
                    {
                        var store = index.GetResultsStore(mapEntry.ReduceKeyHash, indexContext, create: false);

                        store.Delete(mapEntry.Id);
                    }

                    index.MapReduceWorkContext.MapPhaseTree.DeleteFixedTreeFor(key, sizeof(ulong));
                }
            }