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
149
|
/**
* Test unacknowledged write commands.
*
* Cannot implicitly shard accessed collections because of following errmsg: A single
* update/delete on a sharded collection must contain an exact match on _id or contain the shard
* key.
*
* @tags: [
* assumes_unsharded_collection,
* assumes_write_concern_unchanged,
* requires_non_retryable_writes,
* ]
*/
function countEventually(collection, n) {
assert.soon(
function() {
return collection.count() === n;
},
function() {
return "unacknowledged write timed out";
});
}
var coll = db.getCollection("batch_write_w0");
coll.drop();
//
// Ensures that mongod respects the batch write protocols for delete
//
assert(coll.getDB().getMongo().useWriteCommands(), "test is not running with write commands");
// EACH TEST BELOW SHOULD BE SELF-CONTAINED, FOR EASIER DEBUGGING
//
// Single document insert, w:0 write concern specified, missing ordered
coll.remove({});
request = {
insert: coll.getName(),
documents: [{a: 1}],
writeConcern: {w: 0}
};
result = coll.runCommand(request);
assert.eq({ok: 1}, result);
countEventually(coll, 1);
//
// Single document upsert, write concern 0 specified, ordered = true
coll.remove({});
request = {
update: coll.getName(),
updates: [{q: {a: 1}, u: {$set: {a: 1}}, upsert: true}],
writeConcern: {w: 0},
ordered: true
};
result = coll.runCommand(request);
assert.eq({ok: 1}, result);
countEventually(coll, 1);
//
// Two document upsert, write concern 0 specified, ordered = true
coll.remove({});
request = {
update: coll.getName(),
updates: [
{q: {a: 2}, u: {$set: {a: 1}}, upsert: true},
{q: {a: 2}, u: {$set: {a: 2}}, upsert: true}
],
writeConcern: {w: 0},
ordered: true
};
result = coll.runCommand(request);
assert.eq({ok: 1}, result);
countEventually(coll, 2);
//
// Upsert fail due to duplicate key index, w:0, ordered:true
coll.remove({});
coll.ensureIndex({a: 1}, {unique: true});
request = {
update: coll.getName(),
updates: [
{q: {b: 1}, u: {$set: {b: 1, a: 1}}, upsert: true},
{q: {b: 2}, u: {$set: {b: 2, a: 1}}, upsert: true}
],
writeConcern: {w: 0},
ordered: true
};
result = coll.runCommand(request);
assert.eq({ok: 1}, result);
countEventually(coll, 1);
// Remove unique index
coll.drop();
//
// Single document delete, w:0 write concern specified
coll.remove({});
coll.insert({a: 1});
request = {
delete: coll.getName(),
deletes: [{q: {a: 1}, limit: 1}],
writeConcern: {w: 0}
};
result = coll.runCommand(request);
assert.eq({ok: 1}, result);
countEventually(coll, 0);
//
// Cause remove error using ordered:false and w:0
coll.remove({});
coll.insert({a: 1});
request = {
delete: coll.getName(),
deletes: [{q: {$set: {a: 1}}, limit: 0}, {q: {$set: {a: 1}}, limit: 0}, {q: {a: 1}, limit: 0}],
writeConcern: {w: 0},
ordered: false
};
result = coll.runCommand(request);
assert.eq({ok: 1}, result);
countEventually(coll, 0);
//
// Cause remove error using ordered:true and w:0 - $set isn't a valid delete filter
coll.remove({});
coll.insert({a: 1});
request = {
delete: coll.getName(),
deletes: [{q: {$set: {a: 1}}, limit: 0}, {q: {$set: {a: 1}}, limit: 0}, {q: {a: 1}, limit: 1}],
writeConcern: {w: 0},
ordered: true
};
result = coll.runCommand(request);
assert.eq({ok: 1}, result);
assert.eq(coll.count(), 1);
//
// When limit is not 0 and 1
coll.remove({});
coll.insert({a: 1});
request = {
delete: coll.getName(),
deletes: [{q: {a: 1}, limit: 2}],
writeConcern: {w: 0},
ordered: false
};
result = coll.runCommand(request);
// Unacknowledged writes are always OK
assert.eq({ok: 1}, result);
|
