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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
// SERVER-29425 added a new expression, $sortArray, which consumes an array or a nullish value
// and produces either the sorted version of that array, or null. In this test file, we check the
// behavior and error cases.
load("jstests/libs/sbe_assert_error_override.js"); // Override error-code-checking APIs.
load("jstests/aggregation/extras/utils.js"); // For assertErrorCode.
(function() {
"use strict";
let coll = db.sortArray;
coll.drop();
assert.commandWorked(coll.insert({
nullField: null,
undefField: undefined,
embedded: [[1, 2], [3, 4]],
singleElem: [1],
normal: [1, 2, 3],
num: 1,
empty: [],
normalSingleObjs: [{a: 1}, {a: 2}, {a: 3}],
mismatchedSingleObjs: [{a: 1}, {b: 2}, {c: 3}],
normalMultiObjs: [{a: 1, b: 3, c: 1}, {a: 2, b: 2, c: 2}, {a: 3, b: 1, c: 3}],
tiesMultiObjs: [{a: 1, b: 2, c: 1}, {a: 1, b: 3, c: 4}, {a: 1, b: 3, c: 5}],
nestedObjs: [{a: 1, b: {c: 2}}, {a: 1, b: {c: 1}}],
mismatchedTypes: [1, [1], {a: 1}, "1"],
moreMismatchedTypes: [2, 1, "hello", {a: 6}, {a: "hello"}, {a: -1}, null],
mismatchedNumberTypes: [[NumberDecimal(4)], [1, 9, 8]],
collatorTestField: ["2", "10"],
collatorObjectTestField: [{a: "2"}, {a: "10"}],
}));
let assertDBOutputEquals = (expected, output) => {
output = output.toArray();
assert.eq(1, output.length);
assert.eq(expected, output[0].sorted);
};
assertErrorCode(coll, [{$project: {sorted: {$sortArray: 1}}}], 2942500);
assertErrorCode(coll, [{$project: {sorted: {$sortArray: "$num"}}}], 2942500);
assertDBOutputEquals([1, 2, 3], coll.aggregate([
{$project: {sorted: {$sortArray: {input: {$literal: [1, 2, 3]}, sortBy: 1}}}}
]));
assertDBOutputEquals(
[3, 2, 1],
coll.aggregate([{$project: {sorted: {$sortArray: {input: "$normal", sortBy: -1}}}}]));
assertDBOutputEquals([1, 2, 3], coll.aggregate([
{$project: {sorted: {$sortArray: {input: {$literal: [3, 2, 1]}, sortBy: 1}}}}
]));
assertDBOutputEquals([3, 2, 1], coll.aggregate([
{$project: {sorted: {$sortArray: {input: {$literal: [3, 2, 1]}, sortBy: -1}}}}
]));
assertDBOutputEquals(
null, coll.aggregate([{$project: {sorted: {$sortArray: {input: "$notAField", sortBy: 1}}}}]));
assertDBOutputEquals([[1, 2], [3, 4]], coll.aggregate([
{$project: {sorted: {$sortArray: {input: {$literal: [[1, 2], [3, 4]]}, sortBy: 1}}}}
]));
assertDBOutputEquals(
[[3, 4], [1, 2]],
coll.aggregate([{$project: {sorted: {$sortArray: {input: "$embedded", sortBy: -1}}}}]));
assertDBOutputEquals(
null,
coll.aggregate([{$project: {sorted: {$sortArray: {input: {$literal: null}, sortBy: 1}}}}]));
assertDBOutputEquals(
null, coll.aggregate([{$project: {sorted: {$sortArray: {input: "$nullField", sortBy: -1}}}}]));
assertDBOutputEquals(null, coll.aggregate([
{$project: {sorted: {$sortArray: {input: {$literal: undefined}, sortBy: 1}}}}
]));
assertDBOutputEquals(
null, coll.aggregate([{$project: {sorted: {$sortArray: {input: "$undefField", sortBy: -1}}}}]));
assertDBOutputEquals(
[1], coll.aggregate([{$project: {sorted: {$sortArray: {input: {$literal: [1]}, sortBy: 1}}}}]));
assertDBOutputEquals(
[1], coll.aggregate([{$project: {sorted: {$sortArray: {input: "$singleElem", sortBy: -1}}}}]));
assertDBOutputEquals(
[], coll.aggregate([{$project: {sorted: {$sortArray: {input: {$literal: []}, sortBy: 1}}}}]));
assertDBOutputEquals(
[], coll.aggregate([{$project: {sorted: {$sortArray: {input: "$empty", sortBy: -1}}}}]));
/* ------------------------ Object Array Tests ------------------------ */
// Test that we handle the case of satisfying "Compare" requirements with -1 sort (SERVER-61941).
assertDBOutputEquals([[], [], {}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: {$literal: [{}, [], []]}, sortBy: -1}}}}
]));
assertDBOutputEquals([{}, {}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: {$literal: [{}, {}]}, sortBy: -1}}}}
]));
assertDBOutputEquals([{a: 1}, {a: 2}, {a: 3}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$normalSingleObjs", sortBy: {a: 1}}}}}
]));
assertDBOutputEquals([{a: 3}, {a: 2}, {a: 1}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$normalSingleObjs", sortBy: {a: -1}}}}}
]));
assertDBOutputEquals([{a: 1}, {a: 2}, {a: 3}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$normalSingleObjs", sortBy: {b: 1}}}}}
]));
assertDBOutputEquals([{a: 1}, {a: 2}, {a: 3}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$normalSingleObjs", sortBy: {b: -1}}}}}
]));
assertDBOutputEquals(
[{a: 1}, {a: 2}, {a: 3}],
coll.aggregate([{$project: {sorted: {$sortArray: {input: "$normalSingleObjs", sortBy: 1}}}}]));
assertDBOutputEquals(
[{a: 3}, {a: 2}, {a: 1}],
coll.aggregate([{$project: {sorted: {$sortArray: {input: "$normalSingleObjs", sortBy: -1}}}}]));
assertDBOutputEquals([{a: 1}, {b: 2}, {c: 3}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$mismatchedSingleObjs", sortBy: 1}}}}
]));
assertDBOutputEquals([{c: 3}, {b: 2}, {a: 1}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$mismatchedSingleObjs", sortBy: -1}}}}
]));
assertDBOutputEquals([{b: 2}, {c: 3}, {a: 1}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$mismatchedSingleObjs", sortBy: {a: 1}}}}}
]));
assertDBOutputEquals([{a: 1}, {c: 3}, {b: 2}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$mismatchedSingleObjs", sortBy: {b: 1}}}}}
]));
assertDBOutputEquals([{a: 1}, {b: 2}, {c: 3}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$mismatchedSingleObjs", sortBy: {c: 1}}}}}
]));
assertDBOutputEquals([{a: 3, b: 1, c: 3}, {a: 2, b: 2, c: 2}, {a: 1, b: 3, c: 1}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$normalMultiObjs", sortBy: {b: 1, a: 1}}}}}
]));
assertDBOutputEquals([{a: 1, b: 3, c: 1}, {a: 2, b: 2, c: 2}, {a: 3, b: 1, c: 3}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$normalMultiObjs", sortBy: {b: -1, a: 1}}}}}
]));
assertDBOutputEquals([{a: 1, b: 2, c: 1}, {a: 1, b: 3, c: 4}, {a: 1, b: 3, c: 5}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$tiesMultiObjs", sortBy: {a: 1, b: 1, c: 1}}}}}
]));
assertDBOutputEquals([{a: 1, b: 2, c: 1}, {a: 1, b: 3, c: 5}, {a: 1, b: 3, c: 4}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$tiesMultiObjs", sortBy: {a: 1, b: 1, c: -1}}}}}
]));
/* ------------------------ Nested Objects Tests ------------------------ */
assertDBOutputEquals([{a: 1, b: {c: 1}}, {a: 1, b: {c: 2}}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$nestedObjs", sortBy: {"b.c": 1}}}}}
]));
assertDBOutputEquals([{a: 1, b: {c: 2}}, {a: 1, b: {c: 1}}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$nestedObjs", sortBy: {"b.c": -1}}}}}
]));
/* ------------------------ Mismatched Types Tests ------------------------ */
assertDBOutputEquals(
[1, "1", {a: 1}, [1]],
coll.aggregate([{$project: {sorted: {$sortArray: {input: "$mismatchedTypes", sortBy: 1}}}}]));
assertDBOutputEquals([null, 1, 2, "hello", {a: -1}, {a: 6}, {a: "hello"}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$moreMismatchedTypes", sortBy: 1}}}}
]));
assertDBOutputEquals([[1, 9, 8], [NumberDecimal(4)]], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$mismatchedNumberTypes", sortBy: 1}}}}
]));
/* ------------------------ Collator Tests ------------------------ */
assertDBOutputEquals(
["10", "2"],
coll.aggregate([{$project: {sorted: {$sortArray: {input: "$collatorTestField", sortBy: 1}}}}]));
assertDBOutputEquals(
["2", "10"],
coll.aggregate([{$project: {sorted: {$sortArray: {input: "$collatorTestField", sortBy: 1}}}}],
{collation: {locale: "en", numericOrdering: true}}));
assertDBOutputEquals([{a: "10"}, {a: "2"}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$collatorObjectTestField", sortBy: 1}}}}
]));
assertDBOutputEquals(
[{a: "2"}, {a: "10"}],
coll.aggregate(
[{$project: {sorted: {$sortArray: {input: "$collatorObjectTestField", sortBy: 1}}}}],
{collation: {locale: "en", numericOrdering: true}}));
assertDBOutputEquals([{a: "10"}, {a: "2"}], coll.aggregate([
{$project: {sorted: {$sortArray: {input: "$collatorObjectTestField", sortBy: {a: 1}}}}}
]));
assertDBOutputEquals(
[{a: "2"}, {a: "10"}],
coll.aggregate(
[{$project: {sorted: {$sortArray: {input: "$collatorObjectTestField", sortBy: {a: 1}}}}}],
{collation: {locale: "en", numericOrdering: true}}));
}());
|
