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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/**
* Tests basic support for sampling nested aggregate queries (i.e. ones inside $lookup,
* $graphLookup, $unionWith) against a sharded collection on a sharded cluster.
*
* @tags: [requires_fcv_70]
*/
(function() {
"use strict";
load("jstests/sharding/analyze_shard_key/libs/sample_nested_agg_queries_common.js");
load("jstests/sharding/analyze_shard_key/libs/query_sampling_util.js");
const st = new ShardingTest({
shards: 3,
rs: {
nodes: 2,
setParameter: {
queryAnalysisSamplerConfigurationRefreshSecs,
queryAnalysisWriterIntervalSecs,
logComponentVerbosity: tojson({sharding: 2})
}
},
// Disable query sampling on mongos to verify that the nested aggregate queries are sampled by
// the shard that routes them.
mongosOptions:
{setParameter: {"failpoint.disableQueryAnalysisSampler": tojson({mode: "alwaysOn"})}}
});
const dbName = "testDb";
const localCollName = "testLocalColl";
const foreignCollName = "testForeignColl";
const foreignNs = dbName + "." + foreignCollName;
const mongosDB = st.s.getDB(dbName);
// Set up the local collection. It needs to have at least one document. Otherwise, no nested
// aggregate queries would be issued.
assert.commandWorked(mongosDB.getCollection(localCollName).insert([{a: 0}]));
// Set up the foreign collection. Make it have three chunks:
// shard0: [MinKey, 0]
// shard1: [0, 1000]
// shard1: [1000, MaxKey]
assert.commandWorked(st.s.adminCommand({enableSharding: dbName}));
st.ensurePrimaryShard(dbName, st.shard0.name);
assert.commandWorked(st.s.adminCommand({shardCollection: foreignNs, key: {x: 1}}));
assert.commandWorked(st.s.adminCommand({split: foreignNs, middle: {x: 0}}));
assert.commandWorked(st.s.adminCommand({split: foreignNs, middle: {x: 1000}}));
assert.commandWorked(
st.s.adminCommand({moveChunk: foreignNs, find: {x: 0}, to: st.shard1.shardName}));
assert.commandWorked(
st.s.adminCommand({moveChunk: foreignNs, find: {x: 1000}, to: st.shard2.name}));
assert.commandWorked(
st.s.adminCommand({configureQueryAnalyzer: foreignNs, mode: "full", sampleRate: 1000}));
const foreignCollUUid = QuerySamplingUtil.getCollectionUuid(mongosDB, foreignCollName);
QuerySamplingUtil.waitForActiveSamplingShardedCluster(
st, foreignNs, foreignCollUUid, {skipMongoses: true});
for (let {name,
makeOuterPipelineFunc,
requireShardToRouteFunc,
supportCustomPipeline} of outerAggTestCases) {
const requireShardToRoute =
requireShardToRouteFunc(mongosDB, foreignCollName, true /* isShardedColl */);
if (supportCustomPipeline) {
for (let {makeInnerPipelineFunc, containInitialFilter} of innerAggTestCases) {
const filter0 = {x: 1, name};
// If the aggregation doesn't have an initial filter, it would be routed to all shards.
const shardNames0 =
containInitialFilter ? [st.rs1.name] : [st.rs0.name, st.rs1.name, st.rs2.name];
testCustomInnerPipeline(makeOuterPipelineFunc,
makeInnerPipelineFunc,
containInitialFilter,
st,
dbName,
localCollName,
foreignCollName,
filter0,
shardNames0,
false /* explain */,
requireShardToRoute);
const filter1 = {x: {$gte: 2}, name};
// If the aggregation doesn't have an initial filter, it would be routed to all shards.
const shardNames1 = containInitialFilter ? [st.rs1.name, st.rs2.name]
: [st.rs0.name, st.rs1.name, st.rs2.name];
testCustomInnerPipeline(makeOuterPipelineFunc,
makeInnerPipelineFunc,
containInitialFilter,
st,
dbName,
localCollName,
foreignCollName,
filter1,
shardNames1,
false /* explain */,
requireShardToRoute);
const filter2 = {x: 3, name};
const shardNames2 = [];
testCustomInnerPipeline(makeOuterPipelineFunc,
makeInnerPipelineFunc,
containInitialFilter,
st,
dbName,
localCollName,
foreignCollName,
filter2,
shardNames2,
true /* explain */,
requireShardToRoute);
const filter3 = {x: {$gte: 4}, name};
const shardNames3 = [];
testCustomInnerPipeline(makeOuterPipelineFunc,
makeInnerPipelineFunc,
containInitialFilter,
st,
dbName,
localCollName,
foreignCollName,
filter3,
shardNames3,
true /* explain */,
requireShardToRoute);
}
} else {
testNoCustomInnerPipeline(makeOuterPipelineFunc,
st,
dbName,
localCollName,
foreignCollName,
false /* explain */,
requireShardToRoute);
testNoCustomInnerPipeline(makeOuterPipelineFunc,
st,
dbName,
localCollName,
foreignCollName,
true /* explain */,
requireShardToRoute);
}
}
assert.commandWorked(st.s.adminCommand({configureQueryAnalyzer: foreignNs, mode: "off"}));
st.stop();
})();
|
