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
|
// Cannot implicitly shard accessed collections because queries on a sharded collection are not
// able to be covered when they aren't on the shard key since the document needs to be fetched in
// order to apply the SHARDING_FILTER stage.
// @tags: [assumes_unsharded_collection]
/**
* Tests for returnKey.
*/
load("jstests/libs/analyze_plan.js");
(function() {
'use strict';
var results;
var explain;
var coll = db.jstests_returnkey;
coll.drop();
assert.writeOK(coll.insert({a: 1, b: 3}));
assert.writeOK(coll.insert({a: 2, b: 2}));
assert.writeOK(coll.insert({a: 3, b: 1}));
assert.commandWorked(coll.ensureIndex({a: 1}));
assert.commandWorked(coll.ensureIndex({b: 1}));
// Basic returnKey.
results = coll.find().hint({a: 1}).sort({a: 1}).returnKey().toArray();
assert.eq(results, [{a: 1}, {a: 2}, {a: 3}]);
results = coll.find().hint({a: 1}).sort({a: -1}).returnKey().toArray();
assert.eq(results, [{a: 3}, {a: 2}, {a: 1}]);
// Check that the plan is covered.
explain = coll.find().hint({a: 1}).sort({a: 1}).returnKey().explain();
assert(isIndexOnly(db, explain.queryPlanner.winningPlan));
explain = coll.find().hint({a: 1}).sort({a: -1}).returnKey().explain();
assert(isIndexOnly(db, explain.queryPlanner.winningPlan));
// returnKey with an in-memory sort.
results = coll.find().hint({a: 1}).sort({b: 1}).returnKey().toArray();
assert.eq(results, [{a: 3}, {a: 2}, {a: 1}]);
results = coll.find().hint({a: 1}).sort({b: -1}).returnKey().toArray();
assert.eq(results, [{a: 1}, {a: 2}, {a: 3}]);
// Check that the plan is not covered.
explain = coll.find().hint({a: 1}).sort({b: 1}).returnKey().explain();
assert(!isIndexOnly(db, explain.queryPlanner.winningPlan));
explain = coll.find().hint({a: 1}).sort({b: -1}).returnKey().explain();
assert(!isIndexOnly(db, explain.queryPlanner.winningPlan));
// returnKey takes precedence over other a regular inclusion projection. Should still be
// covered.
results = coll.find({}, {b: 1}).hint({a: 1}).sort({a: -1}).returnKey().toArray();
assert.eq(results, [{a: 3}, {a: 2}, {a: 1}]);
explain = coll.find({}, {b: 1}).hint({a: 1}).sort({a: -1}).returnKey().explain();
assert(isIndexOnly(db, explain.queryPlanner.winningPlan));
// returnKey takes precedence over other a regular exclusion projection. Should still be
// covered.
results = coll.find({}, {a: 0}).hint({a: 1}).sort({a: -1}).returnKey().toArray();
assert.eq(results, [{a: 3}, {a: 2}, {a: 1}]);
explain = coll.find({}, {a: 0}).hint({a: 1}).sort({a: -1}).returnKey().explain();
assert(isIndexOnly(db, explain.queryPlanner.winningPlan));
// Unlike other projections, sortKey meta-projection can co-exist with returnKey.
results = coll.find({}, {c: {$meta: 'sortKey'}}).hint({a: 1}).sort({a: -1}).returnKey().toArray();
assert.eq(results, [{a: 3, c: {'': 3}}, {a: 2, c: {'': 2}}, {a: 1, c: {'': 1}}]);
// returnKey with sortKey $meta where there is an in-memory sort.
results = coll.find({}, {c: {$meta: 'sortKey'}}).hint({a: 1}).sort({b: 1}).returnKey().toArray();
assert.eq(results, [{a: 3, c: {'': 1}}, {a: 2, c: {'': 2}}, {a: 1, c: {'': 3}}]);
// returnKey with multiple sortKey $meta projections.
results = coll.find({}, {c: {$meta: 'sortKey'}, d: {$meta: 'sortKey'}})
.hint({a: 1})
.sort({b: 1})
.returnKey()
.toArray();
assert.eq(results, [
{a: 3, c: {'': 1}, d: {'': 1}},
{a: 2, c: {'': 2}, d: {'': 2}},
{a: 1, c: {'': 3}, d: {'': 3}}
]);
})();
|
