mirror of https://github.com/mongodb/mongo
216 lines
10 KiB
JavaScript
216 lines
10 KiB
JavaScript
/**
|
|
* Tests basic functionality of the $getField expression.
|
|
* @tags: [
|
|
* ]
|
|
*/
|
|
(function() {
|
|
"use strict";
|
|
|
|
load("jstests/aggregation/extras/utils.js"); // For assertArrayEq.
|
|
|
|
const coll = db.expression_get_field;
|
|
coll.drop();
|
|
|
|
// Test that $getField fails with the provided 'code' for invalid arguments 'getFieldArgs'.
|
|
function assertGetFieldFailedWithCode(getFieldArgs, code) {
|
|
const error =
|
|
assert.throws(() => coll.aggregate([{$project: {test: {$getField: getFieldArgs}}}]));
|
|
assert.commandFailedWithCode(error, code);
|
|
}
|
|
|
|
// Test that $getField returns the 'expected' results for the given arguments 'getFieldArgs'.
|
|
function assertGetFieldResultsEq(getFieldArgs, expected) {
|
|
assertPipelineResultsEq([{$project: {_id: 1, test: {$getField: getFieldArgs}}}], expected);
|
|
}
|
|
|
|
// Test the given 'pipeline' returns the 'expected' results.
|
|
function assertPipelineResultsEq(pipeline, expected) {
|
|
const actual = coll.aggregate(pipeline).toArray();
|
|
assertArrayEq({actual, expected});
|
|
}
|
|
|
|
for (let i = 0; i < 2; i++) {
|
|
assert.commandWorked(coll.insert({
|
|
_id: i,
|
|
x: i,
|
|
y: "c",
|
|
"a$b": "foo",
|
|
"a.b": "bar",
|
|
"a.$b": 5,
|
|
".xy": i,
|
|
".$xz": i,
|
|
"..zz": i,
|
|
"$a": 10,
|
|
"$x.$y": 20,
|
|
"$x..$y": {"$a": 1, "$b..$c": 2},
|
|
c: {d: "x"},
|
|
e: {"$f": 30},
|
|
f: [{"$a": 41}, {"$b..": 42}],
|
|
"$v..": null
|
|
}));
|
|
}
|
|
|
|
// Test that $getField fails with a document missing named arguments.
|
|
assertGetFieldFailedWithCode({input: {a: "b"}}, 3041702);
|
|
assertGetFieldFailedWithCode({field: "a"}, 3041703);
|
|
|
|
// Test that $getField fails with a document with one or more arguments of incorrect type.
|
|
assertGetFieldFailedWithCode({field: true, input: {a: "b"}}, 5654602);
|
|
assertGetFieldFailedWithCode({field: {"a": 1}, input: {"a": 1}}, 5654601);
|
|
assertGetFieldFailedWithCode(5, 5654602);
|
|
assertGetFieldFailedWithCode(true, 5654602);
|
|
assertGetFieldFailedWithCode({field: null, input: {"a": 1}}, 5654602);
|
|
|
|
// Test that $getField fails with a document with invalid arguments.
|
|
assertGetFieldFailedWithCode({field: "a", input: {a: "b"}, unknown: true}, 3041701);
|
|
|
|
// Test that $getField fails when 'field' argument is a field reference.
|
|
assertGetFieldFailedWithCode({field: "$a", input: {a: "b"}}, 5654600);
|
|
assertGetFieldFailedWithCode({field: "$a.b", input: {a: "b"}}, 5654600);
|
|
assertGetFieldFailedWithCode({field: "$$CURRENT.a", input: {a: "b"}}, 5654600);
|
|
|
|
// Test that $getField fails when 'field' argument is an arbitrary expression other than '$const'
|
|
// String.
|
|
assertGetFieldFailedWithCode({$add: [2, 3]}, 5654601);
|
|
assertGetFieldFailedWithCode({field: {$concat: ["a", "b"]}, input: {"a": 1}}, 5654601);
|
|
assertGetFieldFailedWithCode({field: {$cond: [false, null, "x"]}, input: {"a": 1}}, 5654601);
|
|
assertGetFieldFailedWithCode({$const: true}, 5654602);
|
|
assertGetFieldFailedWithCode({$const: {"a": 1}}, 5654602);
|
|
assertGetFieldFailedWithCode({field: {$const: []}, input: {"a": 1}}, 5654602);
|
|
|
|
// Test that $getField returns the correct value from the provided object.
|
|
assertGetFieldResultsEq({field: "a", input: {a: "b"}}, [{_id: 0, test: "b"}, {_id: 1, test: "b"}]);
|
|
|
|
// Test that $getField returns the correct value from the $$CURRENT object.
|
|
assertGetFieldResultsEq("a", [{_id: 0}, {_id: 1}]); // The test field should evaluate to missing.
|
|
assertGetFieldResultsEq("a$b", [{_id: 0, test: "foo"}, {_id: 1, test: "foo"}]);
|
|
assertGetFieldResultsEq("a.b", [{_id: 0, test: "bar"}, {_id: 1, test: "bar"}]);
|
|
assertGetFieldResultsEq("x", [{_id: 0, test: 0}, {_id: 1, test: 1}]);
|
|
assertGetFieldResultsEq("a.$b", [{_id: 0, test: 5}, {_id: 1, test: 5}]);
|
|
assertGetFieldResultsEq(".xy", [{_id: 0, test: 0}, {_id: 1, test: 1}]);
|
|
assertGetFieldResultsEq(".$xz", [{_id: 0, test: 0}, {_id: 1, test: 1}]);
|
|
assertGetFieldResultsEq("..zz", [{_id: 0, test: 0}, {_id: 1, test: 1}]);
|
|
assertGetFieldResultsEq({$const: "$a"}, [{_id: 0, test: 10}, {_id: 1, test: 10}]);
|
|
assertGetFieldResultsEq({$const: "$x.$y"}, [{_id: 0, test: 20}, {_id: 1, test: 20}]);
|
|
assertGetFieldResultsEq(
|
|
{$const: "$x..$y"},
|
|
[{_id: 0, test: {"$a": 1, "$b..$c": 2}}, {_id: 1, test: {"$a": 1, "$b..$c": 2}}]);
|
|
assertGetFieldResultsEq({field: {$const: "$f"}, input: "$e"},
|
|
[{_id: 0, test: 30}, {_id: 1, test: 30}]);
|
|
|
|
// Test that $getField treats dotted fields as key literals instead of field paths. Note that it is
|
|
// necessary to use $const in places, otherwise object field validation would reject some of these
|
|
// field names.
|
|
assertGetFieldResultsEq({field: "a.b", input: {$const: {"a.b": "b"}}},
|
|
[{_id: 0, test: "b"}, {_id: 1, test: "b"}]);
|
|
assertGetFieldResultsEq({field: ".ab", input: {$const: {".ab": "b"}}},
|
|
[{_id: 0, test: "b"}, {_id: 1, test: "b"}]);
|
|
assertGetFieldResultsEq({field: "ab.", input: {$const: {"ab.": "b"}}},
|
|
[{_id: 0, test: "b"}, {_id: 1, test: "b"}]);
|
|
assertGetFieldResultsEq({field: "a.b.c", input: {$const: {"a.b.c": 5}}},
|
|
[{_id: 0, test: 5}, {_id: 1, test: 5}]);
|
|
assertGetFieldResultsEq({field: "a.b.c", input: {a: {b: {c: 5}}}},
|
|
[{_id: 0}, {_id: 1}]); // The test field should evaluate to missing.
|
|
assertGetFieldResultsEq({field: "d", input: {$getField: "c"}},
|
|
[{_id: 0, "test": "x"}, {_id: 1, "test": "x"}]);
|
|
|
|
// Test that $getField works with fields that contain '$'.
|
|
assertGetFieldResultsEq({field: "a$b", input: {"a$b": "b"}},
|
|
[{_id: 0, test: "b"}, {_id: 1, test: "b"}]);
|
|
assertGetFieldResultsEq({field: "a$b.b", input: {$const: {"a$b.b": 5}}},
|
|
[{_id: 0, test: 5}, {_id: 1, test: 5}]);
|
|
assertGetFieldResultsEq({field: {$const: "a$b.b"}, input: {$const: {"a$b.b": 5}}},
|
|
[{_id: 0, test: 5}, {_id: 1, test: 5}]);
|
|
assertGetFieldResultsEq({field: {$const: "$b.b"}, input: {$const: {"$b.b": 5}}},
|
|
[{_id: 0, test: 5}, {_id: 1, test: 5}]);
|
|
assertGetFieldResultsEq({field: {$const: "$b"}, input: {$const: {"$b": 5}}},
|
|
[{_id: 0, test: 5}, {_id: 1, test: 5}]);
|
|
assertGetFieldResultsEq({field: {$const: "$.ab"}, input: {$const: {"$.ab": 5}}},
|
|
[{_id: 0, test: 5}, {_id: 1, test: 5}]);
|
|
assertGetFieldResultsEq({field: {$const: "$$xz"}, input: {$const: {"$$xz": 5}}},
|
|
[{_id: 0, test: 5}, {_id: 1, test: 5}]);
|
|
|
|
// Test null and missing cases.
|
|
assertGetFieldResultsEq({field: "a", input: null}, [{_id: 0, test: null}, {_id: 1, test: null}]);
|
|
assertGetFieldResultsEq({field: "a", input: {b: 2, c: 3}},
|
|
[{_id: 0}, {_id: 1}]); // The test field should evaluate to missing.
|
|
assertGetFieldResultsEq({field: "a", input: {a: null, b: 2, c: 3}},
|
|
[{_id: 0, test: null}, {_id: 1, test: null}]);
|
|
assertGetFieldResultsEq({field: {$const: "$a"}, input: {$const: {"$a": null, b: 2, c: 3}}},
|
|
[{_id: 0, test: null}, {_id: 1, test: null}]);
|
|
assertGetFieldResultsEq({field: "a", input: {}},
|
|
[{_id: 0}, {_id: 1}]); // The test field should evaluate to missing.
|
|
assertGetFieldResultsEq({$const: "$v.."}, [{_id: 0, test: null}, {_id: 1, test: null}]);
|
|
assertGetFieldResultsEq({$const: "$u.."},
|
|
[{_id: 0}, {_id: 1}]); // The test field should evaluate to missing.
|
|
assertGetFieldResultsEq({field: "doesNotExist2", input: {$getField: "doesNotExist1"}},
|
|
[{_id: 0}, {_id: 1}]);
|
|
assertGetFieldResultsEq({field: "x", input: {$getField: "doesNotExist"}}, [{_id: 0}, {_id: 1}]);
|
|
assertGetFieldResultsEq({field: "a", input: true}, [{_id: 0}, {_id: 1}]);
|
|
|
|
// Test case where $getField stages are nested.
|
|
assertGetFieldResultsEq(
|
|
{field: "a", input: {$getField: {field: "b.c", input: {$const: {"b.c": {a: 5}}}}}},
|
|
[{_id: 0, test: 5}, {_id: 1, test: 5}]);
|
|
assertGetFieldResultsEq(
|
|
{field: "x", input: {$getField: {field: "b.c", input: {$const: {"b.c": {a: 5}}}}}},
|
|
[{_id: 0}, {_id: 1}]);
|
|
assertGetFieldResultsEq(
|
|
{field: "a", input: {$getField: {field: "b.d", input: {$const: {"b.c": {a: 5}}}}}},
|
|
[{_id: 0}, {_id: 1}]);
|
|
assertGetFieldResultsEq({field: {$const: "$a"}, input: {$getField: {$const: "$x..$y"}}},
|
|
[{_id: 0, test: 1}, {_id: 1, test: 1}]);
|
|
assertGetFieldResultsEq({field: {$const: "$b..$c"}, input: {$getField: {$const: "$x..$y"}}},
|
|
[{_id: 0, test: 2}, {_id: 1, test: 2}]);
|
|
|
|
// Test case when a dotted/dollar path is within an array.
|
|
assertGetFieldResultsEq({
|
|
field: {$const: "a$b"},
|
|
input: {$arrayElemAt: [[{$const: {"a$b": 1}}, {$const: {"a$b": 2}}], 0]}
|
|
},
|
|
[{_id: 0, test: 1}, {_id: 1, test: 1}]);
|
|
assertGetFieldResultsEq({
|
|
field: {$const: "a.."},
|
|
input: {$arrayElemAt: [[{$const: {"a..": 1}}, {$const: {"a..": 2}}], 1]}
|
|
},
|
|
[{_id: 0, test: 2}, {_id: 1, test: 2}]);
|
|
assertGetFieldResultsEq({field: {$const: "$a"}, input: {$arrayElemAt: ["$f", 0]}},
|
|
[{_id: 0, test: 41}, {_id: 1, test: 41}]);
|
|
assertGetFieldResultsEq({field: {$const: "$b.."}, input: {$arrayElemAt: ["$f", 1]}},
|
|
[{_id: 0, test: 42}, {_id: 1, test: 42}]);
|
|
|
|
// Test $getField expression with other pipeline stages.
|
|
|
|
assertPipelineResultsEq(
|
|
[
|
|
{$match: {$expr: {$eq: [{$getField: "_id"}, {$getField: ".$xz"}]}}},
|
|
{$project: {aa: {$getField: ".$xz"}, "_id": 1}},
|
|
],
|
|
[{_id: 0, aa: 0}, {_id: 1, aa: 1}]);
|
|
|
|
assertPipelineResultsEq([{$match: {$expr: {$ne: [{$getField: "_id"}, {$getField: ".$xz"}]}}}], []);
|
|
assertPipelineResultsEq(
|
|
[
|
|
{$match: {$expr: {$ne: [{$getField: "_id"}, {$getField: "a.b"}]}}},
|
|
{$project: {"a": {$getField: "x"}, "b": {$getField: {$const: "a.b"}}}}
|
|
],
|
|
[{_id: 0, a: 0, b: "bar"}, {_id: 1, a: 1, b: "bar"}]);
|
|
|
|
assertPipelineResultsEq(
|
|
[
|
|
{$addFields: {aa: {$getField: {$const: "a.b"}}}},
|
|
{$project: {aa: 1, _id: 1}},
|
|
],
|
|
[{_id: 0, aa: "bar"}, {_id: 1, aa: "bar"}]);
|
|
|
|
assertPipelineResultsEq(
|
|
[
|
|
{$bucket: {groupBy: {$getField: {$const: "a.b"}}, boundaries: ["aaa", "bar", "zzz"]}}
|
|
], // We should get one bucket here ("bar") with two documents.
|
|
[{_id: "bar", count: 2}]);
|
|
assertPipelineResultsEq([{
|
|
$bucket: {groupBy: {$getField: "x"}, boundaries: [0, 1, 2, 3, 4]}
|
|
}], // We should get two buckets here for the two possible values of x.
|
|
[{_id: 0, count: 1}, {_id: 1, count: 1}]);
|
|
})();
|