255 lines
12 KiB
JavaScript
255 lines
12 KiB
JavaScript
/**
|
|
* This test ensures that bit test query operators work.
|
|
* @tags: [
|
|
* assumes_read_concern_local,
|
|
* ]
|
|
*/
|
|
import {getWinningPlanFromExplain, isCollscan} from "jstests/libs/query/analyze_plan.js";
|
|
|
|
var coll = db.jstests_bitwise;
|
|
|
|
function assertQueryCorrect(query, count) {
|
|
var explain = coll.find(query).explain("executionStats");
|
|
assert(isCollscan(db, getWinningPlanFromExplain(explain)),
|
|
"expected bit test query plan to be COLLSCAN");
|
|
assert.eq(
|
|
count, explain.executionStats.nReturned, "bit test query not returning correct documents");
|
|
}
|
|
|
|
// Tests on numbers.
|
|
|
|
coll.drop();
|
|
assert.commandWorked(coll.insert({a: 0}));
|
|
assert.commandWorked(coll.insert({a: 1}));
|
|
assert.commandWorked(coll.insert({a: 54}));
|
|
assert.commandWorked(coll.insert({a: 88}));
|
|
assert.commandWorked(coll.insert({a: 255}));
|
|
assert.commandWorked(coll.insert({a: 1e18}));
|
|
assert.commandWorked(coll.createIndex({a: 1}));
|
|
|
|
// Tests with bitmask.
|
|
assertQueryCorrect({a: {$bitsAllSet: 0}}, 6);
|
|
assertQueryCorrect({a: {$bitsAllSet: 1}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: 16}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllSet: 54}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: 55}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllSet: 88}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: 255}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllClear: 0}}, 6);
|
|
assertQueryCorrect({a: {$bitsAllClear: 1}}, 4);
|
|
assertQueryCorrect({a: {$bitsAllClear: 16}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllClear: 129}}, 4);
|
|
assertQueryCorrect({a: {$bitsAllClear: 255}}, 2);
|
|
assertQueryCorrect({a: {$bitsAnySet: 0}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnySet: 9}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnySet: 255}}, 4);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 0}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 18}}, 4);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 24}}, 4);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 255}}, 5);
|
|
|
|
// Tests with array of bit positions.
|
|
assertQueryCorrect({a: {$bitsAllSet: []}}, 6);
|
|
assertQueryCorrect({a: {$bitsAllSet: [0]}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: [4]}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllSet: [1, 2, 4, 5]}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: [0, 1, 2, 4, 5]}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllSet: [3, 4, 6]}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: [0, 1, 2, 3, 4, 5, 6, 7]}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllClear: []}}, 6);
|
|
assertQueryCorrect({a: {$bitsAllClear: [0]}}, 4);
|
|
assertQueryCorrect({a: {$bitsAllClear: [4]}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllClear: [1, 7]}}, 4);
|
|
assertQueryCorrect({a: {$bitsAllClear: [0, 1, 2, 3, 4, 5, 6, 7]}}, 2);
|
|
assertQueryCorrect({a: {$bitsAnySet: []}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnySet: [1, 3]}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnySet: [0, 1, 2, 3, 4, 5, 6, 7]}}, 4);
|
|
assertQueryCorrect({a: {$bitsAnyClear: []}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnyClear: [1, 4]}}, 4);
|
|
assertQueryCorrect({a: {$bitsAnyClear: [3, 4]}}, 4);
|
|
assertQueryCorrect({a: {$bitsAnyClear: [0, 1, 2, 3, 4, 5, 6, 7]}}, 5);
|
|
|
|
// Tests with multiple predicates.
|
|
assertQueryCorrect({a: {$bitsAllSet: 54, $bitsAllClear: 201}}, 1);
|
|
|
|
coll.drop();
|
|
|
|
assert.commandWorked(coll.insert({a: 0}));
|
|
assert.commandWorked(coll.insert({a: 1}));
|
|
assert.commandWorked(coll.insert({a: NumberLong('+9223372036854775807')}));
|
|
assert.commandWorked(coll.insert({a: NumberLong('+6917529027641081856')}));
|
|
assert.commandWorked(coll.insert({a: NumberLong('+2305843009213693952')}));
|
|
assert.commandWorked(coll.createIndex({a: 1}));
|
|
|
|
// Tests with `NumberLongs` as arguments to bitwise expressions
|
|
assertQueryCorrect({a: {$bitsAllSet: 0}}, 5);
|
|
assertQueryCorrect({a: {$bitsAllSet: 1}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: NumberLong('+9223372036854775807')}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllSet: NumberLong('+6917529027641081856')}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: NumberLong('+2305843009213693952')}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllClear: 0}}, 5);
|
|
assertQueryCorrect({a: {$bitsAllClear: 1}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllClear: NumberLong('+9223372036854775807')}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllClear: NumberLong('+6917529027641081856')}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllClear: NumberLong('+2305843009213693952')}}, 2);
|
|
assertQueryCorrect({a: {$bitsAnySet: 0}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnySet: 1}}, 2);
|
|
assertQueryCorrect({a: {$bitsAnySet: NumberLong('+9223372036854775807')}}, 4);
|
|
assertQueryCorrect({a: {$bitsAnySet: NumberLong('+6917529027641081856')}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnySet: NumberLong('+2305843009213693952')}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 0}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 1}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnyClear: NumberLong('+9223372036854775807')}}, 4);
|
|
assertQueryCorrect({a: {$bitsAnyClear: NumberLong('+6917529027641081856')}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnyClear: NumberLong('+2305843009213693952')}}, 2);
|
|
|
|
// Tests on negative numbers.
|
|
coll.drop();
|
|
assert.commandWorked(coll.insert({a: -0}));
|
|
assert.commandWorked(coll.insert({a: -1}));
|
|
assert.commandWorked(coll.insert({a: -54}));
|
|
assert.commandWorked(coll.insert({a: -1e18}));
|
|
|
|
// Tests with bitmask.
|
|
assertQueryCorrect({a: {$bitsAllSet: 0}}, 4);
|
|
assertQueryCorrect({a: {$bitsAllSet: 2}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: 127}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllSet: 74}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllClear: 0}}, 4);
|
|
assertQueryCorrect({a: {$bitsAllClear: 53}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllClear: 127}}, 2);
|
|
assertQueryCorrect({a: {$bitsAnySet: 0}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnySet: 2}}, 2);
|
|
assertQueryCorrect({a: {$bitsAnySet: 127}}, 2);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 0}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 53}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 127}}, 3);
|
|
|
|
// Tests with array of bit positions.
|
|
var allPositions = [];
|
|
for (var i = 0; i < 64; i++) {
|
|
allPositions.push(i);
|
|
}
|
|
assertQueryCorrect({a: {$bitsAllSet: []}}, 4);
|
|
assertQueryCorrect({a: {$bitsAllSet: [1]}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: allPositions}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllSet: [1, 7, 6, 3, 100]}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllClear: []}}, 4);
|
|
assertQueryCorrect({a: {$bitsAllClear: [5, 4, 2, 0]}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllClear: allPositions}}, 1);
|
|
assertQueryCorrect({a: {$bitsAnySet: []}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnySet: [1]}}, 2);
|
|
assertQueryCorrect({a: {$bitsAnySet: allPositions}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnyClear: []}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnyClear: [0, 2, 4, 5, 100]}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnyClear: allPositions}}, 3);
|
|
|
|
// Tests with multiple predicates.
|
|
assertQueryCorrect({a: {$bitsAllSet: 74, $bitsAllClear: 53}}, 1);
|
|
|
|
// Tests on BinData.
|
|
|
|
coll.drop();
|
|
assert.commandWorked(coll.insert({a: BinData(0, "AAAAAAAAAAAAAAAAAAAAAAAAAAAA")}));
|
|
assert.commandWorked(coll.insert({a: BinData(0, "AANgAAAAAAAAAAAAAAAAAAAAAAAA")}));
|
|
assert.commandWorked(coll.insert({a: BinData(0, "JANgqwetkqwklEWRbWERKKJREtbq")}));
|
|
assert.commandWorked(coll.insert({a: BinData(0, "////////////////////////////")}));
|
|
assert.commandWorked(coll.createIndex({a: 1}));
|
|
|
|
// Tests with binary string bitmask.
|
|
assertQueryCorrect({a: {$bitsAllSet: BinData(0, "AAAAAAAAAAAAAAAAAAAAAAAAAAAA")}}, 4);
|
|
assertQueryCorrect({a: {$bitsAllSet: BinData(0, "AANgAAAAAAAAAAAAAAAAAAAAAAAA")}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllSet: BinData(0, "JANgqwetkqwklEWRbWERKKJREtbq")}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: BinData(0, "////////////////////////////")}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllClear: BinData(0, "AAAAAAAAAAAAAAAAAAAAAAAAAAAA")}}, 4);
|
|
assertQueryCorrect({a: {$bitsAllClear: BinData(0, "AAyfAAAAAAAAAAAAAAAAAAAAAAAA")}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllClear: BinData(0, "JAyfqwetkqwklEWRbWERKKJREtbq")}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllClear: BinData(0, "////////////////////////////")}}, 1);
|
|
assertQueryCorrect({a: {$bitsAnySet: BinData(0, "AAAAAAAAAAAAAAAAAAAAAAAAAAAA")}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnySet: BinData(0, "AAyfAAAAAAAAAAAAAAAAAAAAAAAA")}}, 1);
|
|
assertQueryCorrect({a: {$bitsAnySet: BinData(0, "JAyfqwetkqwklEWRbWERKKJREtbq")}}, 2);
|
|
assertQueryCorrect({a: {$bitsAnySet: BinData(0, "////////////////////////////")}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnyClear: BinData(0, "AAAAAAAAAAAAAAAAAAAAAAAAAAAA")}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnyClear: BinData(0, "AANgAAAAAAAAAAAAAAAAAAAAAAAA")}}, 1);
|
|
assertQueryCorrect({a: {$bitsAnyClear: BinData(0, "JANgqwetkqwklEWRbWERKKJREtbq")}}, 2);
|
|
assertQueryCorrect({a: {$bitsAnyClear: BinData(0, "////////////////////////////")}}, 3);
|
|
|
|
// Tests with multiple predicates.
|
|
assertQueryCorrect({
|
|
a: {
|
|
$bitsAllSet: BinData(0, "AANgAAAAAAAAAAAAAAAAAAAAAAAA"),
|
|
$bitsAllClear: BinData(0, "//yf////////////////////////")
|
|
}
|
|
},
|
|
1);
|
|
|
|
coll.drop();
|
|
|
|
// Test that NaNs and non-integral ints are filtered out.
|
|
assert.commandWorked(coll.insert({a: 0}));
|
|
assert.commandWorked(coll.insert({a: 1}));
|
|
assert.commandWorked(coll.insert({a: [1.1, 54]}));
|
|
assert.commandWorked(coll.insert({a: 88}));
|
|
assert.commandWorked(coll.insert({a: 255}));
|
|
assert.commandWorked(coll.insert({a: NaN}));
|
|
assert.commandWorked(coll.insert({a: 1.1}));
|
|
assert.commandWorked(coll.insert({a: -1.1}));
|
|
assert.commandWorked(coll.insert({a: -Infinity}));
|
|
assert.commandWorked(coll.insert({a: +Infinity}));
|
|
assert.commandWorked(coll.insert({a: NumberDecimal("Infinity")}));
|
|
assert.commandWorked(coll.insert({a: NumberDecimal("-Infinity")}));
|
|
assert.commandWorked(coll.insert({a: NumberDecimal("NaN")}));
|
|
assert.commandWorked(coll.insert({a: NumberDecimal(Number.MAX_SAFE_LONG + 1)}));
|
|
assert.commandWorked(coll.insert({a: NumberDecimal(Number.MIN_SAFE_LONG - 1)}));
|
|
assert.commandWorked(coll.insert({a: NumberDecimal(1.1)}));
|
|
assert.commandWorked(coll.insert({a: NumberDecimal(-1.1)}));
|
|
assert.commandWorked(coll.createIndex({a: 1}));
|
|
|
|
assertQueryCorrect({a: {$bitsAllSet: 0}}, 5);
|
|
assertQueryCorrect({a: {$bitsAllSet: 1}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: 16}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllSet: 54}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: 55}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllSet: 88}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: 255}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllClear: 0}}, 5);
|
|
assertQueryCorrect({a: {$bitsAllClear: 1}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllClear: 16}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllClear: 129}}, 3);
|
|
assertQueryCorrect({a: {$bitsAllClear: 255}}, 1);
|
|
assertQueryCorrect({a: {$bitsAnySet: 0}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnySet: 9}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnySet: 255}}, 4);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 0}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 18}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 24}}, 3);
|
|
assertQueryCorrect({a: {$bitsAnyClear: 255}}, 4);
|
|
assert(coll.drop());
|
|
|
|
// Test variable length binary bitmasks.
|
|
assert.commandWorked(coll.insert({a: BinData(0, "ZG9n")}));
|
|
assert.commandWorked(coll.insert({a: BinData(0, "JA4A8gAxqTwciCuF5GGzAA==")}));
|
|
assert.commandWorked(coll.insert({a: BinData(1, "JA4A8gAxqTwciCuF5GGzAA==")}));
|
|
assert.commandWorked(
|
|
coll.insert({a: BinData(0, "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw==")}));
|
|
assert.commandWorked(coll.insert({a: BinData(2, "BAAAADEyMzQ=")}));
|
|
|
|
assertQueryCorrect({a: {$bitsAllSet: BinData(0, "ZG9n")}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllSet: BinData(0, "JA4A8gAxqTwciCuF5GGzAA==")}}, 2);
|
|
assertQueryCorrect({a: {$bitsAllSet: BinData(2, "BAAAADEyMzQ=")}}, 1);
|
|
assertQueryCorrect(
|
|
{a: {$bitsAllSet: BinData(0, "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw==")}},
|
|
1);
|
|
assertQueryCorrect({a: {$bitsAllSet: BinData(2, "BAAAADEyMzQ=")}}, 1);
|
|
assertQueryCorrect({a: {$bitsAllClear: BinData(0, "AAAAAAAAAAAAAAAAAAAAAAAAAAAA")}}, 5);
|
|
assertQueryCorrect({a: {$bitsAllClear: BinData(0, "JA4A8gAxqTwciCuF5GGzAA==")}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnySet: BinData(0, "AAAAAAAAAAAAAAAAAAAAAAAAAAAA")}}, 0);
|
|
assertQueryCorrect({a: {$bitsAnySet: BinData(0, "JA4A8gAxqTwciCuF5GGzAA==")}}, 5);
|
|
assertQueryCorrect({a: {$bitsAnyClear: BinData(0, "AAAAAAAAAAAAAAAAAAAAAAAAAAAA")}}, 0);
|
|
assertQueryCorrect({
|
|
a: {$bitsAnyClear: BinData(0, "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw==")}
|
|
},
|
|
4);
|
|
|
|
assert(coll.drop());
|