1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
/**
* Copyright (C) 2013 10gen Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "mongo/db/exec/collection_scan.h"
#include "mongo/db/database.h"
#include "mongo/db/exec/collection_scan_common.h"
#include "mongo/db/exec/filter.h"
#include "mongo/db/exec/working_set.h"
#include "mongo/db/structure/collection.h"
#include "mongo/db/structure/collection_iterator.h"
#include "mongo/db/client.h" // XXX-ERH
#include "mongo/db/pdfile.h" // XXX-ERH/ACM
namespace mongo {
CollectionScan::CollectionScan(const CollectionScanParams& params,
WorkingSet* workingSet,
const MatchExpression* filter)
: _workingSet(workingSet), _filter(filter), _params(params), _nsDropped(false) { }
PlanStage::StageState CollectionScan::work(WorkingSetID* out) {
++_commonStats.works;
if (_nsDropped) { return PlanStage::IS_EOF; }
if (NULL == _iter) {
CollectionTemp* collection = cc().database()->getCollectionTemp( _params.ns );
if ( collection == NULL ) {
_nsDropped = true;
return PlanStage::IS_EOF;
}
_iter.reset( collection->getIterator( _params.start,
_params.tailable,
_params.direction ) );
++_commonStats.needTime;
return PlanStage::NEED_TIME;
}
DiskLoc nextLoc;
// Should we try getNext() on the underlying _iter if we're EOF? Yes, if we're tailable.
if (isEOF()) {
if (!_params.tailable) {
return PlanStage::IS_EOF;
}
else {
// See if _iter gives us anything new.
nextLoc = _iter->getNext();
if (nextLoc.isNull()) {
// Nope, still EOF.
return PlanStage::IS_EOF;
}
}
}
else {
nextLoc = _iter->getNext();
}
WorkingSetID id = _workingSet->allocate();
WorkingSetMember* member = _workingSet->get(id);
member->loc = nextLoc;
member->obj = member->loc.obj();
member->state = WorkingSetMember::LOC_AND_UNOWNED_OBJ;
if (Filter::passes(member, _filter)) {
*out = id;
++_commonStats.advanced;
return PlanStage::ADVANCED;
}
else {
_workingSet->free(id);
++_commonStats.needTime;
return PlanStage::NEED_TIME;
}
}
bool CollectionScan::isEOF() {
if (_nsDropped) { return true; }
if (NULL == _iter) { return false; }
return _iter->isEOF();
}
void CollectionScan::invalidate(const DiskLoc& dl) {
++_commonStats.invalidates;
if (NULL != _iter) {
_iter->invalidate(dl);
}
}
void CollectionScan::prepareToYield() {
++_commonStats.yields;
if (NULL != _iter) {
_iter->prepareToYield();
}
}
void CollectionScan::recoverFromYield() {
++_commonStats.unyields;
if (NULL != _iter) {
if (!_iter->recoverFromYield()) {
_nsDropped = true;
}
}
}
PlanStageStats* CollectionScan::getStats() {
_commonStats.isEOF = isEOF();
return new PlanStageStats(_commonStats);
}
} // namespace mongo
|
