diff options
87 files changed, 1234 insertions, 2283 deletions
diff --git a/src/mongo/db/exec/collection_scan.cpp b/src/mongo/db/exec/collection_scan.cpp index 168428779f7..a0cff1a7e81 100644 --- a/src/mongo/db/exec/collection_scan.cpp +++ b/src/mongo/db/exec/collection_scan.cpp @@ -72,9 +72,8 @@ CollectionScan::CollectionScan(OperationContext* opCtx, if (params.maxTs) { _endConditionBSON = BSON("$gte" << *(params.maxTs)); - _endCondition = stdx::make_unique<GTEMatchExpression>(); - invariantOK(_endCondition->init(repl::OpTime::kTimestampFieldName, - _endConditionBSON.firstElement())); + _endCondition = stdx::make_unique<GTEMatchExpression>(repl::OpTime::kTimestampFieldName, + _endConditionBSON.firstElement()); } } diff --git a/src/mongo/db/exec/geo_near.cpp b/src/mongo/db/exec/geo_near.cpp index 9da6af59370..d906efebc76 100644 --- a/src/mongo/db/exec/geo_near.cpp +++ b/src/mongo/db/exec/geo_near.cpp @@ -505,9 +505,7 @@ namespace { class TwoDPtInAnnulusExpression : public LeafMatchExpression { public: TwoDPtInAnnulusExpression(const R2Annulus& annulus, StringData twoDPath) - : LeafMatchExpression(INTERNAL_2D_POINT_IN_ANNULUS), _annulus(annulus) { - setPath(twoDPath).transitional_ignore(); - } + : LeafMatchExpression(INTERNAL_2D_POINT_IN_ANNULUS, twoDPath), _annulus(annulus) {} void serialize(BSONObjBuilder* out) const final { out->append("TwoDPtInAnnulusExpression", true); diff --git a/src/mongo/db/exec/oplogstart.cpp b/src/mongo/db/exec/oplogstart.cpp index 9b7659b3a13..4cb85047051 100644 --- a/src/mongo/db/exec/oplogstart.cpp +++ b/src/mongo/db/exec/oplogstart.cpp @@ -55,9 +55,8 @@ OplogStart::OplogStart(OperationContext* opCtx, _done(false), _collection(collection), _workingSet(ws), - _filterBSON(BSON("$lte" << timestamp)) { - invariantOK(_filter.init(repl::OpTime::kTimestampFieldName, _filterBSON.firstElement())); -} + _filterBSON(BSON("$lte" << timestamp)), + _filter(repl::OpTime::kTimestampFieldName, _filterBSON.firstElement()) {} PlanStage::StageState OplogStart::doWork(WorkingSetID* out) { // We do our (heavy) init in a work(), where work is expected. diff --git a/src/mongo/db/matcher/expression_algo.cpp b/src/mongo/db/matcher/expression_algo.cpp index 44791145805..e0575431de8 100644 --- a/src/mongo/db/matcher/expression_algo.cpp +++ b/src/mongo/db/matcher/expression_algo.cpp @@ -153,8 +153,7 @@ bool _isSubsetOf(const MatchExpression* lhs, const ComparisonMatchExpression* rh } for (BSONElement elem : ime->getEqualities()) { // Each element in the $in-array represents an equality predicate. - EqualityMatchExpression equality; - equality.init(lhs->path(), elem).transitional_ignore(); + EqualityMatchExpression equality(lhs->path(), elem); equality.setCollator(ime->getCollator()); if (!_isSubsetOf(&equality, rhs)) { return false; @@ -179,7 +178,7 @@ bool _isSubsetOf(const MatchExpression* lhs, const ExistsMatchExpression* rhs) { if (ComparisonMatchExpression::isComparisonMatchExpression(lhs)) { const ComparisonMatchExpression* cme = static_cast<const ComparisonMatchExpression*>(lhs); - // CompareMatchExpression::init() prohibits creating a match expression with EOO or + // The CompareMatchExpression constructor prohibits creating a match expression with EOO or // Undefined types, so only need to ensure that the value is not of type jstNULL. return cme->getData().type() != jstNULL; } diff --git a/src/mongo/db/matcher/expression_algo_test.cpp b/src/mongo/db/matcher/expression_algo_test.cpp index d1ec11137dd..49198f799dc 100644 --- a/src/mongo/db/matcher/expression_algo_test.cpp +++ b/src/mongo/db/matcher/expression_algo_test.cpp @@ -70,8 +70,8 @@ private: }; TEST(ExpressionAlgoIsSubsetOf, NullAndOmittedField) { - // Verify that ComparisonMatchExpression::init() prohibits creating a match expression with - // an Undefined type. + // Verify that the ComparisonMatchExpression constructor prohibits creating a match expression + // with an Undefined type. BSONObj undefined = fromjson("{a: undefined}"); boost::intrusive_ptr<ExpressionContextForTest> expCtx(new ExpressionContextForTest()); ASSERT_EQUALS(ErrorCodes::BadValue, diff --git a/src/mongo/db/matcher/expression_arity.h b/src/mongo/db/matcher/expression_arity.h index e6f71395941..a2b5734c1e1 100644 --- a/src/mongo/db/matcher/expression_arity.h +++ b/src/mongo/db/matcher/expression_arity.h @@ -93,13 +93,6 @@ public: } /** - * Takes ownership of the MatchExpressions in 'expressions'. - */ - void init(std::array<std::unique_ptr<MatchExpression>, nargs> expressions) { - _expressions = std::move(expressions); - } - - /** * The name of this MatchExpression. */ virtual StringData name() const = 0; @@ -121,7 +114,6 @@ public: * Clones this MatchExpression by recursively cloning each sub-expression. */ std::unique_ptr<MatchExpression> shallowClone() const final { - std::unique_ptr<T> clone = stdx::make_unique<T>(); std::array<std::unique_ptr<MatchExpression>, nargs> clonedExpressions; std::transform(_expressions.begin(), _expressions.end(), @@ -130,7 +122,7 @@ public: return orig ? orig->shallowClone() : std::unique_ptr<MatchExpression>(nullptr); }); - clone->_expressions = std::move(clonedExpressions); + std::unique_ptr<T> clone = stdx::make_unique<T>(std::move(clonedExpressions)); if (getTag()) { clone->setTag(getTag()->clone()); @@ -140,7 +132,12 @@ public: } protected: - explicit FixedArityMatchExpression(MatchType type) : MatchExpression(type) {} + /** + * Takes ownership of the MatchExpressions in 'expressions'. + */ + explicit FixedArityMatchExpression( + MatchType type, std::array<std::unique_ptr<MatchExpression>, nargs> expressions) + : MatchExpression(type), _expressions(std::move(expressions)) {} const auto& expressions() const { return _expressions; diff --git a/src/mongo/db/matcher/expression_array.cpp b/src/mongo/db/matcher/expression_array.cpp index 84c544df2bf..e4c9af9a024 100644 --- a/src/mongo/db/matcher/expression_array.cpp +++ b/src/mongo/db/matcher/expression_array.cpp @@ -67,10 +67,9 @@ bool ArrayMatchingMatchExpression::equivalent(const MatchExpression* other) cons // ------- -Status ElemMatchObjectMatchExpression::init(StringData path, MatchExpression* sub) { - _sub.reset(sub); - return setPath(path); -} +ElemMatchObjectMatchExpression::ElemMatchObjectMatchExpression(StringData path, + MatchExpression* sub) + : ArrayMatchingMatchExpression(ELEM_MATCH_OBJECT, path), _sub(sub) {} bool ElemMatchObjectMatchExpression::matchesArray(const BSONObj& anArray, MatchDetails* details) const { @@ -119,23 +118,20 @@ MatchExpression::ExpressionOptimizerFunc ElemMatchObjectMatchExpression::getOpti // ------- +ElemMatchValueMatchExpression::ElemMatchValueMatchExpression(StringData path, MatchExpression* sub) + : ArrayMatchingMatchExpression(ELEM_MATCH_VALUE, path) { + add(sub); +} + +ElemMatchValueMatchExpression::ElemMatchValueMatchExpression(StringData path) + : ArrayMatchingMatchExpression(ELEM_MATCH_VALUE, path) {} + ElemMatchValueMatchExpression::~ElemMatchValueMatchExpression() { for (unsigned i = 0; i < _subs.size(); i++) delete _subs[i]; _subs.clear(); } -Status ElemMatchValueMatchExpression::init(StringData path, MatchExpression* sub) { - init(path).transitional_ignore(); - add(sub); - return Status::OK(); -} - -Status ElemMatchValueMatchExpression::init(StringData path) { - return setPath(path); -} - - void ElemMatchValueMatchExpression::add(MatchExpression* sub) { verify(sub); _subs.push_back(sub); @@ -208,10 +204,8 @@ MatchExpression::ExpressionOptimizerFunc ElemMatchValueMatchExpression::getOptim // --------- -Status SizeMatchExpression::init(StringData path, int size) { - _size = size; - return setPath(path); -} +SizeMatchExpression::SizeMatchExpression(StringData path, int size) + : ArrayMatchingMatchExpression(SIZE, path), _size(size) {} bool SizeMatchExpression::matchesArray(const BSONObj& anArray, MatchDetails* details) const { if (_size < 0) diff --git a/src/mongo/db/matcher/expression_array.h b/src/mongo/db/matcher/expression_array.h index f4090c0a8b0..4cf54f43677 100644 --- a/src/mongo/db/matcher/expression_array.h +++ b/src/mongo/db/matcher/expression_array.h @@ -45,7 +45,10 @@ namespace mongo { */ class ArrayMatchingMatchExpression : public PathMatchExpression { public: - ArrayMatchingMatchExpression(MatchType matchType) : PathMatchExpression(matchType) {} + ArrayMatchingMatchExpression(MatchType matchType, StringData path) + : PathMatchExpression(matchType, path) { + setTraverseLeafArray(); + } virtual ~ArrayMatchingMatchExpression() {} @@ -71,15 +74,14 @@ public: class ElemMatchObjectMatchExpression : public ArrayMatchingMatchExpression { public: - ElemMatchObjectMatchExpression() : ArrayMatchingMatchExpression(ELEM_MATCH_OBJECT) {} - Status init(StringData path, MatchExpression* sub); + ElemMatchObjectMatchExpression(StringData path, MatchExpression* sub); bool matchesArray(const BSONObj& anArray, MatchDetails* details) const; virtual std::unique_ptr<MatchExpression> shallowClone() const { std::unique_ptr<ElemMatchObjectMatchExpression> e = - stdx::make_unique<ElemMatchObjectMatchExpression>(); - e->init(path(), _sub->shallowClone().release()).transitional_ignore(); + stdx::make_unique<ElemMatchObjectMatchExpression>(path(), + _sub->shallowClone().release()); if (getTag()) { e->setTag(getTag()->clone()); } @@ -118,19 +120,20 @@ private: class ElemMatchValueMatchExpression : public ArrayMatchingMatchExpression { public: - ElemMatchValueMatchExpression() : ArrayMatchingMatchExpression(ELEM_MATCH_VALUE) {} + /** + * This constructor takes ownership of 'sub.' + */ + ElemMatchValueMatchExpression(StringData path, MatchExpression* sub); + explicit ElemMatchValueMatchExpression(StringData path); virtual ~ElemMatchValueMatchExpression(); - Status init(StringData path); - Status init(StringData path, MatchExpression* sub); void add(MatchExpression* sub); bool matchesArray(const BSONObj& anArray, MatchDetails* details) const; virtual std::unique_ptr<MatchExpression> shallowClone() const { std::unique_ptr<ElemMatchValueMatchExpression> e = - stdx::make_unique<ElemMatchValueMatchExpression>(); - e->init(path()).transitional_ignore(); + stdx::make_unique<ElemMatchValueMatchExpression>(path()); for (size_t i = 0; i < _subs.size(); ++i) { e->add(_subs[i]->shallowClone().release()); } @@ -166,12 +169,11 @@ private: class SizeMatchExpression : public ArrayMatchingMatchExpression { public: - SizeMatchExpression() : ArrayMatchingMatchExpression(SIZE) {} - Status init(StringData path, int size); + SizeMatchExpression(StringData path, int size); virtual std::unique_ptr<MatchExpression> shallowClone() const { - std::unique_ptr<SizeMatchExpression> e = stdx::make_unique<SizeMatchExpression>(); - e->init(path(), _size).transitional_ignore(); + std::unique_ptr<SizeMatchExpression> e = + stdx::make_unique<SizeMatchExpression>(path(), _size); if (getTag()) { e->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/expression_array_test.cpp b/src/mongo/db/matcher/expression_array_test.cpp index 6b7d0c9a851..4d014818c2d 100644 --- a/src/mongo/db/matcher/expression_array_test.cpp +++ b/src/mongo/db/matcher/expression_array_test.cpp @@ -45,10 +45,8 @@ TEST(ElemMatchObjectMatchExpression, MatchesElementSingle) { BSONObj baseOperand = BSON("b" << 5); BSONObj match = BSON("a" << BSON_ARRAY(BSON("b" << 5.0))); BSONObj notMatch = BSON("a" << BSON_ARRAY(BSON("b" << 6))); - unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression()); - ASSERT(eq->init("b", baseOperand["b"]).isOK()); - ElemMatchObjectMatchExpression op; - ASSERT(op.init("a", eq.release()).isOK()); + unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression("b", baseOperand["b"])); + ElemMatchObjectMatchExpression op("a", eq.release()); ASSERT(op.matchesSingleElement(match["a"])); ASSERT(!op.matchesSingleElement(notMatch["a"])); } @@ -57,10 +55,8 @@ TEST(ElemMatchObjectMatchExpression, MatchesElementArray) { BSONObj baseOperand = BSON("1" << 5); BSONObj match = BSON("a" << BSON_ARRAY(BSON_ARRAY('s' << 5.0))); BSONObj notMatch = BSON("a" << BSON_ARRAY(BSON_ARRAY(5 << 6))); - unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression()); - ASSERT(eq->init("1", baseOperand["1"]).isOK()); - ElemMatchObjectMatchExpression op; - ASSERT(op.init("a", eq.release()).isOK()); + unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression("1", baseOperand["1"])); + ElemMatchObjectMatchExpression op("a", eq.release()); ASSERT(op.matchesSingleElement(match["a"])); ASSERT(!op.matchesSingleElement(notMatch["a"])); } @@ -73,20 +69,16 @@ TEST(ElemMatchObjectMatchExpression, MatchesElementMultiple) { BSONObj notMatch2 = BSON("a" << BSON_ARRAY(BSON("b" << 6 << "c" << 7))); BSONObj notMatch3 = BSON("a" << BSON_ARRAY(BSON("b" << BSON_ARRAY(5 << 6)))); BSONObj match = BSON("a" << BSON_ARRAY(BSON("b" << BSON_ARRAY(5 << 6) << "c" << 7))); - unique_ptr<ComparisonMatchExpression> eq1(new EqualityMatchExpression()); - ASSERT(eq1->init("b", baseOperand1["b"]).isOK()); - unique_ptr<ComparisonMatchExpression> eq2(new EqualityMatchExpression()); - ASSERT(eq2->init("b", baseOperand2["b"]).isOK()); - unique_ptr<ComparisonMatchExpression> eq3(new EqualityMatchExpression()); - ASSERT(eq3->init("c", baseOperand3["c"]).isOK()); + unique_ptr<ComparisonMatchExpression> eq1(new EqualityMatchExpression("b", baseOperand1["b"])); + unique_ptr<ComparisonMatchExpression> eq2(new EqualityMatchExpression("b", baseOperand2["b"])); + unique_ptr<ComparisonMatchExpression> eq3(new EqualityMatchExpression("c", baseOperand3["c"])); unique_ptr<AndMatchExpression> andOp(new AndMatchExpression()); andOp->add(eq1.release()); andOp->add(eq2.release()); andOp->add(eq3.release()); - ElemMatchObjectMatchExpression op; - ASSERT(op.init("a", andOp.release()).isOK()); + ElemMatchObjectMatchExpression op("a", andOp.release()); ASSERT(!op.matchesSingleElement(notMatch1["a"])); ASSERT(!op.matchesSingleElement(notMatch2["a"])); ASSERT(!op.matchesSingleElement(notMatch3["a"])); @@ -95,10 +87,8 @@ TEST(ElemMatchObjectMatchExpression, MatchesElementMultiple) { TEST(ElemMatchObjectMatchExpression, MatchesNonArray) { BSONObj baseOperand = BSON("b" << 5); - unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression()); - ASSERT(eq->init("b", baseOperand["b"]).isOK()); - ElemMatchObjectMatchExpression op; - ASSERT(op.init("a", eq.release()).isOK()); + unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression("b", baseOperand["b"])); + ElemMatchObjectMatchExpression op("a", eq.release()); // Directly nested objects are not matched with $elemMatch. An intervening array is // required. ASSERT(!op.matchesBSON(BSON("a" << BSON("b" << 5)), NULL)); @@ -108,10 +98,8 @@ TEST(ElemMatchObjectMatchExpression, MatchesNonArray) { TEST(ElemMatchObjectMatchExpression, MatchesArrayObject) { BSONObj baseOperand = BSON("b" << 5); - unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression()); - ASSERT(eq->init("b", baseOperand["b"]).isOK()); - ElemMatchObjectMatchExpression op; - ASSERT(op.init("a", eq.release()).isOK()); + unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression("b", baseOperand["b"])); + ElemMatchObjectMatchExpression op("a", eq.release()); ASSERT(op.matchesBSON(BSON("a" << BSON_ARRAY(BSON("b" << 5))), NULL)); ASSERT(op.matchesBSON(BSON("a" << BSON_ARRAY(4 << BSON("b" << 5))), NULL)); ASSERT(op.matchesBSON(BSON("a" << BSON_ARRAY(BSONObj() << BSON("b" << 5))), NULL)); @@ -120,10 +108,8 @@ TEST(ElemMatchObjectMatchExpression, MatchesArrayObject) { TEST(ElemMatchObjectMatchExpression, MatchesMultipleNamedValues) { BSONObj baseOperand = BSON("c" << 5); - unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression()); - ASSERT(eq->init("c", baseOperand["c"]).isOK()); - ElemMatchObjectMatchExpression op; - ASSERT(op.init("a.b", eq.release()).isOK()); + unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression("c", baseOperand["c"])); + ElemMatchObjectMatchExpression op("a.b", eq.release()); ASSERT(op.matchesBSON(BSON("a" << BSON_ARRAY(BSON("b" << BSON_ARRAY(BSON("c" << 5))))), NULL)); ASSERT(op.matchesBSON(BSON("a" << BSON_ARRAY(BSON("b" << BSON_ARRAY(BSON("c" << 1))) << BSON("b" << BSON_ARRAY(BSON("c" << 5))))), @@ -132,10 +118,8 @@ TEST(ElemMatchObjectMatchExpression, MatchesMultipleNamedValues) { TEST(ElemMatchObjectMatchExpression, ElemMatchKey) { BSONObj baseOperand = BSON("c" << 6); - unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression()); - ASSERT(eq->init("c", baseOperand["c"]).isOK()); - ElemMatchObjectMatchExpression op; - ASSERT(op.init("a.b", eq.release()).isOK()); + unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression("c", baseOperand["c"])); + ElemMatchObjectMatchExpression op("a.b", eq.release()); MatchDetails details; details.requestElemMatchKey(); ASSERT(!op.matchesBSON(BSONObj(), &details)); @@ -161,10 +145,8 @@ TEST(ElemMatchObjectMatchExpression, Collation) { << "string"))); BSONObj notMatch = BSON("a" << BSON_ARRAY(BSON("b" << "string2"))); - unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression()); - ASSERT(eq->init("b", baseOperand["b"]).isOK()); - ElemMatchObjectMatchExpression op; - ASSERT(op.init("a", eq.release()).isOK()); + unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression("b", baseOperand["b"])); + ElemMatchObjectMatchExpression op("a", eq.release()); CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual); op.setCollator(&collator); ASSERT(op.matchesSingleElement(match["a"])); @@ -189,10 +171,8 @@ TEST(ElemMatchValueMatchExpression, MatchesElementSingle) { BSONObj baseOperand = BSON("$gt" << 5); BSONObj match = BSON("a" << BSON_ARRAY(6)); BSONObj notMatch = BSON("a" << BSON_ARRAY(4)); - unique_ptr<ComparisonMatchExpression> gt(new GTMatchExpression()); - ASSERT(gt->init("", baseOperand["$gt"]).isOK()); - ElemMatchValueMatchExpression op; - ASSERT(op.init("a", gt.release()).isOK()); + unique_ptr<ComparisonMatchExpression> gt(new GTMatchExpression("", baseOperand["$gt"])); + ElemMatchValueMatchExpression op("a", gt.release()); ASSERT(op.matchesSingleElement(match["a"])); ASSERT(!op.matchesSingleElement(notMatch["a"])); } @@ -203,13 +183,10 @@ TEST(ElemMatchValueMatchExpression, MatchesElementMultiple) { BSONObj notMatch1 = BSON("a" << BSON_ARRAY(0 << 1)); BSONObj notMatch2 = BSON("a" << BSON_ARRAY(10 << 11)); BSONObj match = BSON("a" << BSON_ARRAY(0 << 5 << 11)); - unique_ptr<ComparisonMatchExpression> gt(new GTMatchExpression()); - ASSERT(gt->init("", baseOperand1["$gt"]).isOK()); - unique_ptr<ComparisonMatchExpression> lt(new LTMatchExpression()); - ASSERT(lt->init("", baseOperand2["$lt"]).isOK()); + unique_ptr<ComparisonMatchExpression> gt(new GTMatchExpression("", baseOperand1["$gt"])); + unique_ptr<ComparisonMatchExpression> lt(new LTMatchExpression("", baseOperand2["$lt"])); - ElemMatchValueMatchExpression op; - ASSERT(op.init("a").isOK()); + ElemMatchValueMatchExpression op("a"); op.add(gt.release()); op.add(lt.release()); @@ -220,10 +197,8 @@ TEST(ElemMatchValueMatchExpression, MatchesElementMultiple) { TEST(ElemMatchValueMatchExpression, MatchesNonArray) { BSONObj baseOperand = BSON("$gt" << 5); - unique_ptr<ComparisonMatchExpression> gt(new GTMatchExpression()); - ASSERT(gt->init("", baseOperand["$gt"]).isOK()); - ElemMatchObjectMatchExpression op; - ASSERT(op.init("a", gt.release()).isOK()); + unique_ptr<ComparisonMatchExpression> gt(new GTMatchExpression("", baseOperand["$gt"])); + ElemMatchObjectMatchExpression op("a", gt.release()); // Directly nested objects are not matched with $elemMatch. An intervening array is // required. ASSERT(!op.matchesBSON(BSON("a" << 6), NULL)); @@ -232,10 +207,8 @@ TEST(ElemMatchValueMatchExpression, MatchesNonArray) { TEST(ElemMatchValueMatchExpression, MatchesArrayScalar) { BSONObj baseOperand = BSON("$gt" << 5); - unique_ptr<ComparisonMatchExpression> gt(new GTMatchExpression()); - ASSERT(gt->init("", baseOperand["$gt"]).isOK()); - ElemMatchValueMatchExpression op; - ASSERT(op.init("a", gt.release()).isOK()); + unique_ptr<ComparisonMatchExpression> gt(new GTMatchExpression("", baseOperand["$gt"])); + ElemMatchValueMatchExpression op("a", gt.release()); ASSERT(op.matchesBSON(BSON("a" << BSON_ARRAY(6)), NULL)); ASSERT(op.matchesBSON(BSON("a" << BSON_ARRAY(4 << 6)), NULL)); ASSERT(op.matchesBSON(BSON("a" << BSON_ARRAY(BSONObj() << 7)), NULL)); @@ -243,10 +216,8 @@ TEST(ElemMatchValueMatchExpression, MatchesArrayScalar) { TEST(ElemMatchValueMatchExpression, MatchesMultipleNamedValues) { BSONObj baseOperand = BSON("$gt" << 5); - unique_ptr<ComparisonMatchExpression> gt(new GTMatchExpression()); - ASSERT(gt->init("", baseOperand["$gt"]).isOK()); - ElemMatchValueMatchExpression op; - ASSERT(op.init("a.b", gt.release()).isOK()); + unique_ptr<ComparisonMatchExpression> gt(new GTMatchExpression("", baseOperand["$gt"])); + ElemMatchValueMatchExpression op("a.b", gt.release()); ASSERT(op.matchesBSON(BSON("a" << BSON_ARRAY(BSON("b" << BSON_ARRAY(6)))), NULL)); ASSERT(op.matchesBSON( BSON("a" << BSON_ARRAY(BSON("b" << BSON_ARRAY(4)) << BSON("b" << BSON_ARRAY(4 << 6)))), @@ -255,10 +226,8 @@ TEST(ElemMatchValueMatchExpression, MatchesMultipleNamedValues) { TEST(ElemMatchValueMatchExpression, ElemMatchKey) { BSONObj baseOperand = BSON("$gt" << 6); - unique_ptr<ComparisonMatchExpression> gt(new GTMatchExpression()); - ASSERT(gt->init("", baseOperand["$gt"]).isOK()); - ElemMatchValueMatchExpression op; - ASSERT(op.init("a.b", gt.release()).isOK()); + unique_ptr<ComparisonMatchExpression> gt(new GTMatchExpression("", baseOperand["$gt"])); + ElemMatchValueMatchExpression op("a.b", gt.release()); MatchDetails details; details.requestElemMatchKey(); ASSERT(!op.matchesBSON(BSONObj(), &details)); @@ -292,37 +261,37 @@ TEST( ElemMatchValueMatchExpression, MatchesIndexKey ) { TEST(AndOfElemMatch, MatchesElement) { BSONObj baseOperanda1 = BSON("a" << 1); - unique_ptr<ComparisonMatchExpression> eqa1(new EqualityMatchExpression()); - ASSERT(eqa1->init("a", baseOperanda1["a"]).isOK()); + unique_ptr<ComparisonMatchExpression> eqa1( + new EqualityMatchExpression("a", baseOperanda1["a"])); BSONObj baseOperandb1 = BSON("b" << 1); - unique_ptr<ComparisonMatchExpression> eqb1(new EqualityMatchExpression()); - ASSERT(eqb1->init("b", baseOperandb1["b"]).isOK()); + unique_ptr<ComparisonMatchExpression> eqb1( + new EqualityMatchExpression("b", baseOperandb1["b"])); unique_ptr<AndMatchExpression> and1(new AndMatchExpression()); and1->add(eqa1.release()); and1->add(eqb1.release()); // and1 = { a : 1, b : 1 } - unique_ptr<ElemMatchObjectMatchExpression> elemMatch1(new ElemMatchObjectMatchExpression()); - elemMatch1->init("x", and1.release()).transitional_ignore(); + unique_ptr<ElemMatchObjectMatchExpression> elemMatch1( + new ElemMatchObjectMatchExpression("x", and1.release())); // elemMatch1 = { x : { $elemMatch : { a : 1, b : 1 } } } BSONObj baseOperanda2 = BSON("a" << 2); - unique_ptr<ComparisonMatchExpression> eqa2(new EqualityMatchExpression()); - ASSERT(eqa2->init("a", baseOperanda2["a"]).isOK()); + unique_ptr<ComparisonMatchExpression> eqa2( + new EqualityMatchExpression("a", baseOperanda2["a"])); BSONObj baseOperandb2 = BSON("b" << 2); - unique_ptr<ComparisonMatchExpression> eqb2(new EqualityMatchExpression()); - ASSERT(eqb2->init("b", baseOperandb2["b"]).isOK()); + unique_ptr<ComparisonMatchExpression> eqb2( + new EqualityMatchExpression("b", baseOperandb2["b"])); unique_ptr<AndMatchExpression> and2(new AndMatchExpression()); and2->add(eqa2.release()); and2->add(eqb2.release()); // and2 = { a : 2, b : 2 } - unique_ptr<ElemMatchObjectMatchExpression> elemMatch2(new ElemMatchObjectMatchExpression()); - elemMatch2->init("x", and2.release()).transitional_ignore(); + unique_ptr<ElemMatchObjectMatchExpression> elemMatch2( + new ElemMatchObjectMatchExpression("x", and2.release())); // elemMatch2 = { x : { $elemMatch : { a : 2, b : 2 } } } unique_ptr<AndMatchExpression> andOfEM(new AndMatchExpression()); @@ -349,29 +318,23 @@ TEST(AndOfElemMatch, MatchesElement) { TEST(AndOfElemMatch, Matches) { BSONObj baseOperandgt1 = BSON("$gt" << 1); - unique_ptr<ComparisonMatchExpression> gt1(new GTMatchExpression()); - ASSERT(gt1->init("", baseOperandgt1["$gt"]).isOK()); + unique_ptr<ComparisonMatchExpression> gt1(new GTMatchExpression("", baseOperandgt1["$gt"])); BSONObj baseOperandlt1 = BSON("$lt" << 10); - unique_ptr<ComparisonMatchExpression> lt1(new LTMatchExpression()); - ASSERT(lt1->init("", baseOperandlt1["$lt"]).isOK()); + unique_ptr<ComparisonMatchExpression> lt1(new LTMatchExpression("", baseOperandlt1["$lt"])); - unique_ptr<ElemMatchValueMatchExpression> elemMatch1(new ElemMatchValueMatchExpression()); - elemMatch1->init("x").transitional_ignore(); + unique_ptr<ElemMatchValueMatchExpression> elemMatch1(new ElemMatchValueMatchExpression("x")); elemMatch1->add(gt1.release()); elemMatch1->add(lt1.release()); // elemMatch1 = { x : { $elemMatch : { $gt : 1 , $lt : 10 } } } BSONObj baseOperandgt2 = BSON("$gt" << 101); - unique_ptr<ComparisonMatchExpression> gt2(new GTMatchExpression()); - ASSERT(gt2->init("", baseOperandgt2["$gt"]).isOK()); + unique_ptr<ComparisonMatchExpression> gt2(new GTMatchExpression("", baseOperandgt2["$gt"])); BSONObj baseOperandlt2 = BSON("$lt" << 110); - unique_ptr<ComparisonMatchExpression> lt2(new LTMatchExpression()); - ASSERT(lt2->init("", baseOperandlt2["$lt"]).isOK()); + unique_ptr<ComparisonMatchExpression> lt2(new LTMatchExpression("", baseOperandlt2["$lt"])); - unique_ptr<ElemMatchValueMatchExpression> elemMatch2(new ElemMatchValueMatchExpression()); - elemMatch2->init("x").transitional_ignore(); + unique_ptr<ElemMatchValueMatchExpression> elemMatch2(new ElemMatchValueMatchExpression("x")); elemMatch2->add(gt2.release()); elemMatch2->add(lt2.release()); // elemMatch2 = { x : { $elemMatch : { $gt : 101 , $lt : 110 } } } @@ -399,8 +362,7 @@ TEST(AndOfElemMatch, Matches) { TEST(SizeMatchExpression, MatchesElement) { BSONObj match = BSON("a" << BSON_ARRAY(5 << 6)); BSONObj notMatch = BSON("a" << BSON_ARRAY(5)); - SizeMatchExpression size; - ASSERT(size.init("", 2).isOK()); + SizeMatchExpression size("", 2); ASSERT(size.matchesSingleElement(match.firstElement())); ASSERT(!size.matchesSingleElement(notMatch.firstElement())); } @@ -411,31 +373,27 @@ TEST(SizeMatchExpression, MatchesNonArray) { << "z"); BSONObj numberValue = BSON("a" << 0); BSONObj arrayValue = BSON("a" << BSONArray()); - SizeMatchExpression size; - ASSERT(size.init("", 0).isOK()); + SizeMatchExpression size("", 0); ASSERT(!size.matchesSingleElement(stringValue.firstElement())); ASSERT(!size.matchesSingleElement(numberValue.firstElement())); ASSERT(size.matchesSingleElement(arrayValue.firstElement())); } TEST(SizeMatchExpression, MatchesArray) { - SizeMatchExpression size; - ASSERT(size.init("a", 2).isOK()); + SizeMatchExpression size("a", 2); ASSERT(size.matchesBSON(BSON("a" << BSON_ARRAY(4 << 5.5)), NULL)); // Arrays are not unwound to look for matching subarrays. ASSERT(!size.matchesBSON(BSON("a" << BSON_ARRAY(4 << 5.5 << BSON_ARRAY(1 << 2))), NULL)); } TEST(SizeMatchExpression, MatchesNestedArray) { - SizeMatchExpression size; - ASSERT(size.init("a.2", 2).isOK()); + SizeMatchExpression size("a.2", 2); // A numerically referenced nested array is matched. ASSERT(size.matchesBSON(BSON("a" << BSON_ARRAY(4 << 5.5 << BSON_ARRAY(1 << 2))), NULL)); } TEST(SizeMatchExpression, ElemMatchKey) { - SizeMatchExpression size; - ASSERT(size.init("a.b", 3).isOK()); + SizeMatchExpression size("a.b", 3); MatchDetails details; details.requestElemMatchKey(); ASSERT(!size.matchesBSON(BSON("a" << 1), &details)); @@ -449,13 +407,9 @@ TEST(SizeMatchExpression, ElemMatchKey) { } TEST(SizeMatchExpression, Equivalent) { - SizeMatchExpression e1; - SizeMatchExpression e2; - SizeMatchExpression e3; - - e1.init("a", 5).transitional_ignore(); - e2.init("a", 6).transitional_ignore(); - e3.init("v", 5).transitional_ignore(); + SizeMatchExpression e1("a", 5); + SizeMatchExpression e2("a", 6); + SizeMatchExpression e3("v", 5); ASSERT(e1.equivalent(&e1)); ASSERT(!e1.equivalent(&e2)); diff --git a/src/mongo/db/matcher/expression_geo.cpp b/src/mongo/db/matcher/expression_geo.cpp index 90ed78ecaa7..5cab016b9b9 100644 --- a/src/mongo/db/matcher/expression_geo.cpp +++ b/src/mongo/db/matcher/expression_geo.cpp @@ -329,13 +329,21 @@ Status GeoNearExpression::parseFrom(const BSONObj& obj) { // Geo queries we don't need an index to answer: geoWithin and geoIntersects // -Status GeoMatchExpression::init(StringData path, - const GeoExpression* query, - const BSONObj& rawObj) { - _query.reset(query); - _rawObj = rawObj; - return setPath(path); -} +/** +* Takes ownership of the passed-in GeoExpression. +*/ +GeoMatchExpression::GeoMatchExpression(StringData path, + const GeoExpression* query, + const BSONObj& rawObj) + : LeafMatchExpression(GEO, path), _rawObj(rawObj), _query(query), _canSkipValidation(false) {} + +/** +* Takes shared ownership of the passed-in GeoExpression. +*/ +GeoMatchExpression::GeoMatchExpression(StringData path, + std::shared_ptr<const GeoExpression> query, + const BSONObj& rawObj) + : LeafMatchExpression(GEO, path), _rawObj(rawObj), _query(query), _canSkipValidation(false) {} bool GeoMatchExpression::matchesSingleElement(const BSONElement& e, MatchDetails* details) const { if (!e.isABSONObj()) @@ -398,9 +406,8 @@ bool GeoMatchExpression::equivalent(const MatchExpression* other) const { } std::unique_ptr<MatchExpression> GeoMatchExpression::shallowClone() const { - std::unique_ptr<GeoMatchExpression> next = stdx::make_unique<GeoMatchExpression>(); - next->init(path(), NULL, _rawObj).transitional_ignore(); - next->_query = _query; + std::unique_ptr<GeoMatchExpression> next = + stdx::make_unique<GeoMatchExpression>(path(), _query, _rawObj); next->_canSkipValidation = _canSkipValidation; if (getTag()) { next->setTag(getTag()->clone()); @@ -412,13 +419,15 @@ std::unique_ptr<MatchExpression> GeoMatchExpression::shallowClone() const { // Parse-only geo expressions: geoNear (formerly known as near). // -Status GeoNearMatchExpression::init(StringData path, - const GeoNearExpression* query, - const BSONObj& rawObj) { - _query.reset(query); - _rawObj = rawObj; - return setPath(path); -} +GeoNearMatchExpression::GeoNearMatchExpression(StringData path, + const GeoNearExpression* query, + const BSONObj& rawObj) + : LeafMatchExpression(GEO_NEAR, path), _rawObj(rawObj), _query(query) {} + +GeoNearMatchExpression::GeoNearMatchExpression(StringData path, + std::shared_ptr<const GeoNearExpression> query, + const BSONObj& rawObj) + : LeafMatchExpression(GEO_NEAR, path), _rawObj(rawObj), _query(query) {} bool GeoNearMatchExpression::matchesSingleElement(const BSONElement& e, MatchDetails* details) const { @@ -455,9 +464,8 @@ bool GeoNearMatchExpression::equivalent(const MatchExpression* other) const { } std::unique_ptr<MatchExpression> GeoNearMatchExpression::shallowClone() const { - std::unique_ptr<GeoNearMatchExpression> next = stdx::make_unique<GeoNearMatchExpression>(); - next->init(path(), NULL, _rawObj).transitional_ignore(); - next->_query = _query; + std::unique_ptr<GeoNearMatchExpression> next = + stdx::make_unique<GeoNearMatchExpression>(path(), _query, _rawObj); if (getTag()) { next->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/expression_geo.h b/src/mongo/db/matcher/expression_geo.h index 87b9624a5be..34b015484e6 100644 --- a/src/mongo/db/matcher/expression_geo.h +++ b/src/mongo/db/matcher/expression_geo.h @@ -78,15 +78,13 @@ private: class GeoMatchExpression : public LeafMatchExpression { public: - GeoMatchExpression() : LeafMatchExpression(GEO), _canSkipValidation(false) {} + GeoMatchExpression(StringData path, const GeoExpression* query, const BSONObj& rawObj); + GeoMatchExpression(StringData path, + std::shared_ptr<const GeoExpression> query, + const BSONObj& rawObj); virtual ~GeoMatchExpression() {} - /** - * Takes ownership of the passed-in GeoExpression. - */ - Status init(StringData path, const GeoExpression* query, const BSONObj& rawObj); - bool matchesSingleElement(const BSONElement&, MatchDetails* details = nullptr) const final; virtual void debugString(StringBuilder& debug, int level = 0) const; @@ -167,10 +165,12 @@ private: class GeoNearMatchExpression : public LeafMatchExpression { public: - GeoNearMatchExpression() : LeafMatchExpression(GEO_NEAR) {} - virtual ~GeoNearMatchExpression() {} + GeoNearMatchExpression(StringData path, const GeoNearExpression* query, const BSONObj& rawObj); + GeoNearMatchExpression(StringData path, + std::shared_ptr<const GeoNearExpression> query, + const BSONObj& rawObj); - Status init(StringData path, const GeoNearExpression* query, const BSONObj& rawObj); + virtual ~GeoNearMatchExpression() {} /** * Stub implementation that should never be called, since geoNear execution requires an diff --git a/src/mongo/db/matcher/expression_geo_test.cpp b/src/mongo/db/matcher/expression_geo_test.cpp index de7bd773c8a..082bcef790d 100644 --- a/src/mongo/db/matcher/expression_geo_test.cpp +++ b/src/mongo/db/matcher/expression_geo_test.cpp @@ -46,8 +46,7 @@ TEST(ExpressionGeoTest, Geo1) { std::unique_ptr<GeoExpression> gq(new GeoExpression); ASSERT_OK(gq->parseFrom(query["loc"].Obj())); - GeoMatchExpression ge; - ASSERT(ge.init("a", gq.release(), query).isOK()); + GeoMatchExpression ge("a", gq.release(), query); ASSERT(!ge.matchesBSON(fromjson("{a: [3,4]}"))); ASSERT(ge.matchesBSON(fromjson("{a: [4,4]}"))); @@ -63,8 +62,7 @@ TEST(ExpressionGeoTest, GeoNear1) { std::unique_ptr<GeoNearExpression> nq(new GeoNearExpression); ASSERT_OK(nq->parseFrom(query["loc"].Obj())); - GeoNearMatchExpression gne; - ASSERT(gne.init("a", nq.release(), query).isOK()); + GeoNearMatchExpression gne("a", nq.release(), query); // We can't match the data but we can make sure it was parsed OK. ASSERT_EQUALS(gne.getData().centroid->crs, SPHERE); @@ -76,8 +74,8 @@ std::unique_ptr<GeoMatchExpression> makeGeoMatchExpression(const BSONObj& locQue std::unique_ptr<GeoExpression> gq(new GeoExpression); ASSERT_OK(gq->parseFrom(locQuery)); - std::unique_ptr<GeoMatchExpression> ge = stdx::make_unique<GeoMatchExpression>(); - ASSERT_OK(ge->init("a", gq.release(), locQuery)); + std::unique_ptr<GeoMatchExpression> ge = + stdx::make_unique<GeoMatchExpression>("a", gq.release(), locQuery); return ge; } @@ -86,8 +84,8 @@ std::unique_ptr<GeoNearMatchExpression> makeGeoNearMatchExpression(const BSONObj std::unique_ptr<GeoNearExpression> nq(new GeoNearExpression); ASSERT_OK(nq->parseFrom(locQuery)); - std::unique_ptr<GeoNearMatchExpression> gne = stdx::make_unique<GeoNearMatchExpression>(); - ASSERT_OK(gne->init("a", nq.release(), locQuery)); + std::unique_ptr<GeoNearMatchExpression> gne = + stdx::make_unique<GeoNearMatchExpression>("a", nq.release(), locQuery); return gne; } diff --git a/src/mongo/db/matcher/expression_leaf.cpp b/src/mongo/db/matcher/expression_leaf.cpp index ba0244b98a0..bde6be92d7d 100644 --- a/src/mongo/db/matcher/expression_leaf.cpp +++ b/src/mongo/db/matcher/expression_leaf.cpp @@ -47,29 +47,14 @@ namespace mongo { -bool ComparisonMatchExpression::equivalent(const MatchExpression* other) const { - if (other->matchType() != matchType()) - return false; - const ComparisonMatchExpression* realOther = - static_cast<const ComparisonMatchExpression*>(other); - - if (!CollatorInterface::collatorsMatch(_collator, realOther->_collator)) { - return false; - } - - const StringData::ComparatorInterface* stringComparator = nullptr; - BSONElementComparator eltCmp(BSONElementComparator::FieldNamesMode::kIgnore, stringComparator); - return path() == realOther->path() && eltCmp.evaluate(_rhs == realOther->_rhs); -} - -Status ComparisonMatchExpression::init(StringData path, const BSONElement& rhs) { - _rhs = rhs; - +ComparisonMatchExpression::ComparisonMatchExpression(MatchType type, + StringData path, + const BSONElement& rhs) + : LeafMatchExpression(type, path), _rhs(rhs) { invariant(_rhs); - if (_rhs.type() == BSONType::Undefined) { - return Status(ErrorCodes::BadValue, "cannot compare to undefined"); - } + uassert( + ErrorCodes::BadValue, "cannot compare to undefined", _rhs.type() != BSONType::Undefined); switch (matchType()) { case LT: @@ -79,10 +64,23 @@ Status ComparisonMatchExpression::init(StringData path, const BSONElement& rhs) case GTE: break; default: - return Status(ErrorCodes::BadValue, "bad match type for ComparisonMatchExpression"); + uasserted(ErrorCodes::BadValue, "bad match type for ComparisonMatchExpression"); } +} - return setPath(path); +bool ComparisonMatchExpression::equivalent(const MatchExpression* other) const { + if (other->matchType() != matchType()) + return false; + const ComparisonMatchExpression* realOther = + static_cast<const ComparisonMatchExpression*>(other); + + if (!CollatorInterface::collatorsMatch(_collator, realOther->_collator)) { + return false; + } + + const StringData::ComparatorInterface* stringComparator = nullptr; + BSONElementComparator eltCmp(BSONElementComparator::FieldNamesMode::kIgnore, stringComparator); + return path() == realOther->path() && eltCmp.evaluate(_rhs == realOther->_rhs); } bool ComparisonMatchExpression::matchesSingleElement(const BSONElement& e, @@ -221,7 +219,36 @@ inline pcrecpp::RE_Options flags2options(const char* flags) { return options; } -RegexMatchExpression::RegexMatchExpression() : LeafMatchExpression(REGEX) {} +RegexMatchExpression::RegexMatchExpression(StringData path, const BSONElement& e) + : LeafMatchExpression(REGEX, path), + _regex(e.regex()), + _flags(e.regexFlags()), + _re(new pcrecpp::RE(_regex.c_str(), flags2options(_flags.c_str()))) { + uassert(ErrorCodes::BadValue, "regex not a regex", e.type() == RegEx); + _init(); +} + +RegexMatchExpression::RegexMatchExpression(StringData path, StringData regex, StringData options) + : LeafMatchExpression(REGEX, path), + _regex(regex.toString()), + _flags(options.toString()), + _re(new pcrecpp::RE(_regex.c_str(), flags2options(_flags.c_str()))) { + _init(); +} + +void RegexMatchExpression::_init() { + uassert(ErrorCodes::BadValue, + "Regular expression cannot contain an embedded null byte", + _regex.find('\0') == std::string::npos); + + uassert(ErrorCodes::BadValue, + "Regular expression options string cannot contain an embedded null byte", + _flags.find('\0') == std::string::npos); + + uassert(ErrorCodes::BadValue, + str::stream() << "Regular expression is invalid: " << _re->error(), + _re->error().empty()); +} RegexMatchExpression::~RegexMatchExpression() {} @@ -234,37 +261,6 @@ bool RegexMatchExpression::equivalent(const MatchExpression* other) const { _flags == realOther->_flags; } - -Status RegexMatchExpression::init(StringData path, const BSONElement& e) { - if (e.type() != RegEx) - return Status(ErrorCodes::BadValue, "regex not a regex"); - return init(path, e.regex(), e.regexFlags()); -} - - -Status RegexMatchExpression::init(StringData path, StringData regex, StringData options) { - if (regex.find('\0') != std::string::npos) { - return Status(ErrorCodes::BadValue, - "Regular expression cannot contain an embedded null byte"); - } - - if (options.find('\0') != std::string::npos) { - return Status(ErrorCodes::BadValue, - "Regular expression options string cannot contain an embedded null byte"); - } - - _regex = regex.toString(); - _flags = options.toString(); - _re.reset(new pcrecpp::RE(_regex.c_str(), flags2options(_flags.c_str()))); - - if (!_re->error().empty()) { - return Status(ErrorCodes::BadValue, - str::stream() << "Regular expression is invalid: " << _re->error()); - } - - return setPath(path); -} - bool RegexMatchExpression::matchesSingleElement(const BSONElement& e, MatchDetails* details) const { switch (e.type()) { case String: @@ -315,12 +311,9 @@ void RegexMatchExpression::shortDebugString(StringBuilder& debug) const { // --------- -Status ModMatchExpression::init(StringData path, int divisor, int remainder) { - if (divisor == 0) - return Status(ErrorCodes::BadValue, "divisor cannot be 0"); - _divisor = divisor; - _remainder = remainder; - return setPath(path); +ModMatchExpression::ModMatchExpression(StringData path, int divisor, int remainder) + : LeafMatchExpression(MOD, path), _divisor(divisor), _remainder(remainder) { + uassert(ErrorCodes::BadValue, "divisor cannot be 0", divisor != 0); } bool ModMatchExpression::matchesSingleElement(const BSONElement& e, MatchDetails* details) const { @@ -356,9 +349,7 @@ bool ModMatchExpression::equivalent(const MatchExpression* other) const { // ------------------ -Status ExistsMatchExpression::init(StringData path) { - return setPath(path); -} +ExistsMatchExpression::ExistsMatchExpression(StringData path) : LeafMatchExpression(EXISTS, path) {} bool ExistsMatchExpression::matchesSingleElement(const BSONElement& e, MatchDetails* details) const { @@ -391,13 +382,13 @@ bool ExistsMatchExpression::equivalent(const MatchExpression* other) const { // ---- -Status InMatchExpression::init(StringData path) { - return setPath(path); -} +InMatchExpression::InMatchExpression(StringData path) + : LeafMatchExpression(MATCH_IN, path), + _eltCmp(BSONElementComparator::FieldNamesMode::kIgnore, _collator), + _equalitySet(_eltCmp.makeBSONEltFlatSet(_originalEqualityVector)) {} std::unique_ptr<MatchExpression> InMatchExpression::shallowClone() const { - auto next = stdx::make_unique<InMatchExpression>(); - next->init(path()).transitional_ignore(); + auto next = stdx::make_unique<InMatchExpression>(path()); next->setCollator(_collator); if (getTag()) { next->setTag(getTag()->clone()); @@ -552,18 +543,16 @@ MatchExpression::ExpressionOptimizerFunc InMatchExpression::getOptimizer() const auto& childRe = regexList.front(); invariant(!childRe->getTag()); - auto simplifiedExpression = stdx::make_unique<RegexMatchExpression>(); - invariantOK(simplifiedExpression->init( - expression->path(), childRe->getString(), childRe->getFlags())); + auto simplifiedExpression = stdx::make_unique<RegexMatchExpression>( + expression->path(), childRe->getString(), childRe->getFlags()); if (expression->getTag()) { simplifiedExpression->setTag(expression->getTag()->clone()); } - return std::move(simplifiedExpression); } else if (equalitySet.size() == 1 && regexList.empty()) { // Simplify IN of exactly one equality to be an EqualityMatchExpression. - auto simplifiedExpression = stdx::make_unique<EqualityMatchExpression>(); - invariantOK(simplifiedExpression->init(expression->path(), *(equalitySet.begin()))); + auto simplifiedExpression = stdx::make_unique<EqualityMatchExpression>( + expression->path(), *(equalitySet.begin())); simplifiedExpression->setCollator(collator); if (expression->getTag()) { simplifiedExpression->setTag(expression->getTag()->clone()); @@ -578,9 +567,10 @@ MatchExpression::ExpressionOptimizerFunc InMatchExpression::getOptimizer() const // ----------- -Status BitTestMatchExpression::init(StringData path, std::vector<uint32_t> bitPositions) { - _bitPositions = std::move(bitPositions); - +BitTestMatchExpression::BitTestMatchExpression(MatchType type, + StringData path, + std::vector<uint32_t> bitPositions) + : LeafMatchExpression(type, path), _bitPositions(std::move(bitPositions)) { // Process bit positions into bitmask. for (auto bitPosition : _bitPositions) { // Checking bits > 63 is just checking the sign bit, since we sign-extend numbers. For @@ -589,26 +579,23 @@ Status BitTestMatchExpression::init(StringData path, std::vector<uint32_t> bitPo bitPosition = std::min(bitPosition, 63U); _bitMask |= 1ULL << bitPosition; } - - return setPath(path); } -Status BitTestMatchExpression::init(StringData path, uint64_t bitMask) { - _bitMask = bitMask; - +BitTestMatchExpression::BitTestMatchExpression(MatchType type, StringData path, uint64_t bitMask) + : LeafMatchExpression(type, path), _bitMask(bitMask) { // Process bitmask into bit positions. for (int bit = 0; bit < 64; bit++) { if (_bitMask & (1ULL << bit)) { _bitPositions.push_back(bit); } } - - return setPath(path); } -Status BitTestMatchExpression::init(StringData path, - const char* bitMaskBinary, - uint32_t bitMaskLen) { +BitTestMatchExpression::BitTestMatchExpression(MatchType type, + StringData path, + const char* bitMaskBinary, + uint32_t bitMaskLen) + : LeafMatchExpression(type, path) { for (uint32_t byte = 0; byte < bitMaskLen; byte++) { char byteAt = bitMaskBinary[byte]; if (!byteAt) { @@ -631,8 +618,6 @@ Status BitTestMatchExpression::init(StringData path, } } } - - return setPath(path); } bool BitTestMatchExpression::needFurtherBitTests(bool isBitSet) const { diff --git a/src/mongo/db/matcher/expression_leaf.h b/src/mongo/db/matcher/expression_leaf.h index dd225c57763..77123742849 100644 --- a/src/mongo/db/matcher/expression_leaf.h +++ b/src/mongo/db/matcher/expression_leaf.h @@ -47,7 +47,10 @@ class CollatorInterface; class LeafMatchExpression : public PathMatchExpression { public: - explicit LeafMatchExpression(MatchType matchType) : PathMatchExpression(matchType) {} + explicit LeafMatchExpression(MatchType matchType, StringData path) + : PathMatchExpression(matchType, path) { + setTraverseLeafArray(); + } virtual ~LeafMatchExpression() {} @@ -77,9 +80,7 @@ public: */ class ComparisonMatchExpression : public LeafMatchExpression { public: - explicit ComparisonMatchExpression(MatchType type) : LeafMatchExpression(type) {} - - Status init(StringData path, const BSONElement& rhs); + explicit ComparisonMatchExpression(MatchType type, StringData path, const BSONElement& rhs); virtual ~ComparisonMatchExpression() {} @@ -136,10 +137,12 @@ private: class EqualityMatchExpression : public ComparisonMatchExpression { public: - EqualityMatchExpression() : ComparisonMatchExpression(EQ) {} + EqualityMatchExpression(StringData path, const BSONElement& rhs) + : ComparisonMatchExpression(EQ, path, rhs) {} + virtual std::unique_ptr<MatchExpression> shallowClone() const { - std::unique_ptr<ComparisonMatchExpression> e = stdx::make_unique<EqualityMatchExpression>(); - invariantOK(e->init(path(), _rhs)); + std::unique_ptr<ComparisonMatchExpression> e = + stdx::make_unique<EqualityMatchExpression>(path(), _rhs); if (getTag()) { e->setTag(getTag()->clone()); } @@ -150,10 +153,12 @@ public: class LTEMatchExpression : public ComparisonMatchExpression { public: - LTEMatchExpression() : ComparisonMatchExpression(LTE) {} + LTEMatchExpression(StringData path, const BSONElement& rhs) + : ComparisonMatchExpression(LTE, path, rhs) {} + virtual std::unique_ptr<MatchExpression> shallowClone() const { - std::unique_ptr<ComparisonMatchExpression> e = stdx::make_unique<LTEMatchExpression>(); - invariantOK(e->init(path(), _rhs)); + std::unique_ptr<ComparisonMatchExpression> e = + stdx::make_unique<LTEMatchExpression>(path(), _rhs); if (getTag()) { e->setTag(getTag()->clone()); } @@ -164,10 +169,12 @@ public: class LTMatchExpression : public ComparisonMatchExpression { public: - LTMatchExpression() : ComparisonMatchExpression(LT) {} + LTMatchExpression(StringData path, const BSONElement& rhs) + : ComparisonMatchExpression(LT, path, rhs) {} + virtual std::unique_ptr<MatchExpression> shallowClone() const { - std::unique_ptr<ComparisonMatchExpression> e = stdx::make_unique<LTMatchExpression>(); - invariantOK(e->init(path(), _rhs)); + std::unique_ptr<ComparisonMatchExpression> e = + stdx::make_unique<LTMatchExpression>(path(), _rhs); if (getTag()) { e->setTag(getTag()->clone()); } @@ -178,10 +185,12 @@ public: class GTMatchExpression : public ComparisonMatchExpression { public: - GTMatchExpression() : ComparisonMatchExpression(GT) {} + GTMatchExpression(StringData path, const BSONElement& rhs) + : ComparisonMatchExpression(GT, path, rhs) {} + virtual std::unique_ptr<MatchExpression> shallowClone() const { - std::unique_ptr<ComparisonMatchExpression> e = stdx::make_unique<GTMatchExpression>(); - invariantOK(e->init(path(), _rhs)); + std::unique_ptr<ComparisonMatchExpression> e = + stdx::make_unique<GTMatchExpression>(path(), _rhs); if (getTag()) { e->setTag(getTag()->clone()); } @@ -192,10 +201,12 @@ public: class GTEMatchExpression : public ComparisonMatchExpression { public: - GTEMatchExpression() : ComparisonMatchExpression(GTE) {} + GTEMatchExpression(StringData path, const BSONElement& rhs) + : ComparisonMatchExpression(GTE, path, rhs) {} + virtual std::unique_ptr<MatchExpression> shallowClone() const { - std::unique_ptr<ComparisonMatchExpression> e = stdx::make_unique<GTEMatchExpression>(); - invariantOK(e->init(path(), _rhs)); + std::unique_ptr<ComparisonMatchExpression> e = + stdx::make_unique<GTEMatchExpression>(path(), _rhs); if (getTag()) { e->setTag(getTag()->clone()); } @@ -206,15 +217,13 @@ public: class RegexMatchExpression : public LeafMatchExpression { public: - RegexMatchExpression(); + RegexMatchExpression(StringData path, const BSONElement& e); + RegexMatchExpression(StringData path, StringData regex, StringData options); ~RegexMatchExpression(); - Status init(StringData path, StringData regex, StringData options); - Status init(StringData path, const BSONElement& e); - virtual std::unique_ptr<MatchExpression> shallowClone() const { - std::unique_ptr<RegexMatchExpression> e = stdx::make_unique<RegexMatchExpression>(); - invariantOK(e->init(path(), _regex, _flags)); + std::unique_ptr<RegexMatchExpression> e = + stdx::make_unique<RegexMatchExpression>(path(), _regex, _flags); if (getTag()) { e->setTag(getTag()->clone()); } @@ -245,6 +254,8 @@ private: return [](std::unique_ptr<MatchExpression> expression) { return expression; }; } + void _init(); + std::string _regex; std::string _flags; std::unique_ptr<pcrecpp::RE> _re; @@ -252,13 +263,11 @@ private: class ModMatchExpression : public LeafMatchExpression { public: - ModMatchExpression() : LeafMatchExpression(MOD) {} - - Status init(StringData path, int divisor, int remainder); + ModMatchExpression(StringData path, int divisor, int remainder); virtual std::unique_ptr<MatchExpression> shallowClone() const { - std::unique_ptr<ModMatchExpression> m = stdx::make_unique<ModMatchExpression>(); - invariantOK(m->init(path(), _divisor, _remainder)); + std::unique_ptr<ModMatchExpression> m = + stdx::make_unique<ModMatchExpression>(path(), _divisor, _remainder); if (getTag()) { m->setTag(getTag()->clone()); } @@ -291,13 +300,10 @@ private: class ExistsMatchExpression : public LeafMatchExpression { public: - ExistsMatchExpression() : LeafMatchExpression(EXISTS) {} - - Status init(StringData path); + explicit ExistsMatchExpression(StringData path); virtual std::unique_ptr<MatchExpression> shallowClone() const { - std::unique_ptr<ExistsMatchExpression> e = stdx::make_unique<ExistsMatchExpression>(); - invariantOK(e->init(path())); + std::unique_ptr<ExistsMatchExpression> e = stdx::make_unique<ExistsMatchExpression>(path()); if (getTag()) { e->setTag(getTag()->clone()); } @@ -323,12 +329,7 @@ private: */ class InMatchExpression : public LeafMatchExpression { public: - InMatchExpression() - : LeafMatchExpression(MATCH_IN), - _eltCmp(BSONElementComparator::FieldNamesMode::kIgnore, _collator), - _equalitySet(_eltCmp.makeBSONEltFlatSet(_originalEqualityVector)) {} - - Status init(StringData path); + explicit InMatchExpression(StringData path); virtual std::unique_ptr<MatchExpression> shallowClone() const; @@ -401,16 +402,19 @@ private: */ class BitTestMatchExpression : public LeafMatchExpression { public: - explicit BitTestMatchExpression(MatchType type) : LeafMatchExpression(type) {} - virtual ~BitTestMatchExpression() {} - /** - * Initialize with either bit positions, a 64-bit numeric bitmask, or a char array + * Construct with either bit positions, a 64-bit numeric bitmask, or a char array * bitmask. */ - Status init(StringData path, std::vector<uint32_t> bitPositions); - Status init(StringData path, uint64_t bitMask); - Status init(StringData path, const char* bitMaskBinary, uint32_t bitMaskLen); + explicit BitTestMatchExpression(MatchType type, + StringData path, + std::vector<uint32_t> bitPositions); + explicit BitTestMatchExpression(MatchType type, StringData path, uint64_t bitMask); + explicit BitTestMatchExpression(MatchType type, + StringData path, + const char* bitMaskBinary, + uint32_t bitMaskLen); + virtual ~BitTestMatchExpression() {} bool matchesSingleElement(const BSONElement&, MatchDetails* details = nullptr) const final; @@ -428,18 +432,6 @@ public: return _bitPositions; } -protected: - /** - * Used to copy this match expression to another BitTestMatchExpression. Does not take - * ownership. - */ - void initClone(BitTestMatchExpression* clone) const { - invariantOK(clone->init(path(), _bitPositions)); - if (getTag()) { - clone->setTag(getTag()->clone()); - } - } - private: ExpressionOptimizerFunc getOptimizer() const final { return [](std::unique_ptr<MatchExpression> expression) { return expression; }; @@ -475,44 +467,84 @@ private: class BitsAllSetMatchExpression : public BitTestMatchExpression { public: - BitsAllSetMatchExpression() : BitTestMatchExpression(BITS_ALL_SET) {} + BitsAllSetMatchExpression(StringData path, std::vector<uint32_t> bitPositions) + : BitTestMatchExpression(BITS_ALL_SET, path, bitPositions) {} + + BitsAllSetMatchExpression(StringData path, uint64_t bitMask) + : BitTestMatchExpression(BITS_ALL_SET, path, bitMask) {} + + BitsAllSetMatchExpression(StringData path, const char* bitMaskBinary, uint32_t bitMaskLen) + : BitTestMatchExpression(BITS_ALL_SET, path, bitMaskBinary, bitMaskLen) {} + virtual std::unique_ptr<MatchExpression> shallowClone() const { std::unique_ptr<BitTestMatchExpression> bitTestMatchExpression = - stdx::make_unique<BitsAllSetMatchExpression>(); - initClone(bitTestMatchExpression.get()); + stdx::make_unique<BitsAllSetMatchExpression>(path(), getBitPositions()); + if (getTag()) { + bitTestMatchExpression->setTag(getTag()->clone()); + } return std::move(bitTestMatchExpression); } }; class BitsAllClearMatchExpression : public BitTestMatchExpression { public: - BitsAllClearMatchExpression() : BitTestMatchExpression(BITS_ALL_CLEAR) {} + BitsAllClearMatchExpression(StringData path, std::vector<uint32_t> bitPositions) + : BitTestMatchExpression(BITS_ALL_CLEAR, path, bitPositions) {} + + BitsAllClearMatchExpression(StringData path, uint64_t bitMask) + : BitTestMatchExpression(BITS_ALL_CLEAR, path, bitMask) {} + + BitsAllClearMatchExpression(StringData path, const char* bitMaskBinary, uint32_t bitMaskLen) + : BitTestMatchExpression(BITS_ALL_CLEAR, path, bitMaskBinary, bitMaskLen) {} + virtual std::unique_ptr<MatchExpression> shallowClone() const { std::unique_ptr<BitTestMatchExpression> bitTestMatchExpression = - stdx::make_unique<BitsAllClearMatchExpression>(); - initClone(bitTestMatchExpression.get()); + stdx::make_unique<BitsAllClearMatchExpression>(path(), getBitPositions()); + if (getTag()) { + bitTestMatchExpression->setTag(getTag()->clone()); + } return std::move(bitTestMatchExpression); } }; class BitsAnySetMatchExpression : public BitTestMatchExpression { public: - BitsAnySetMatchExpression() : BitTestMatchExpression(BITS_ANY_SET) {} + BitsAnySetMatchExpression(StringData path, std::vector<uint32_t> bitPositions) + : BitTestMatchExpression(BITS_ANY_SET, path, bitPositions) {} + + BitsAnySetMatchExpression(StringData path, uint64_t bitMask) + : BitTestMatchExpression(BITS_ANY_SET, path, bitMask) {} + + BitsAnySetMatchExpression(StringData path, const char* bitMaskBinary, uint32_t bitMaskLen) + : BitTestMatchExpression(BITS_ANY_SET, path, bitMaskBinary, bitMaskLen) {} + virtual std::unique_ptr<MatchExpression> shallowClone() const { std::unique_ptr<BitTestMatchExpression> bitTestMatchExpression = - stdx::make_unique<BitsAnySetMatchExpression>(); - initClone(bitTestMatchExpression.get()); + stdx::make_unique<BitsAnySetMatchExpression>(path(), getBitPositions()); + if (getTag()) { + bitTestMatchExpression->setTag(getTag()->clone()); + } return std::move(bitTestMatchExpression); } }; class BitsAnyClearMatchExpression : public BitTestMatchExpression { public: - BitsAnyClearMatchExpression() : BitTestMatchExpression(BITS_ANY_CLEAR) {} + BitsAnyClearMatchExpression(StringData path, std::vector<uint32_t> bitPositions) + : BitTestMatchExpression(BITS_ANY_CLEAR, path, bitPositions) {} + + BitsAnyClearMatchExpression(StringData path, uint64_t bitMask) + : BitTestMatchExpression(BITS_ANY_CLEAR, path, bitMask) {} + + BitsAnyClearMatchExpression(StringData path, const char* bitMaskBinary, uint32_t bitMaskLen) + : BitTestMatchExpression(BITS_ANY_CLEAR, path, bitMaskBinary, bitMaskLen) {} + virtual std::unique_ptr<MatchExpression> shallowClone() const { std::unique_ptr<BitTestMatchExpression> bitTestMatchExpression = - stdx::make_unique<BitsAnyClearMatchExpression>(); - initClone(bitTestMatchExpression.get()); + stdx::make_unique<BitsAnyClearMatchExpression>(path(), getBitPositions()); + if (getTag()) { + bitTestMatchExpression->setTag(getTag()->clone()); + } return std::move(bitTestMatchExpression); } }; diff --git a/src/mongo/db/matcher/expression_leaf_test.cpp b/src/mongo/db/matcher/expression_leaf_test.cpp index ca527fd846b..dde4439d517 100644 --- a/src/mongo/db/matcher/expression_leaf_test.cpp +++ b/src/mongo/db/matcher/expression_leaf_test.cpp @@ -43,21 +43,23 @@ namespace mongo { using std::string; TEST(ComparisonMatchExpression, ComparisonMatchExpressionsWithUnequalCollatorsAreUnequal) { + BSONObj operand = BSON("a" << 5); CollatorInterfaceMock collator1(CollatorInterfaceMock::MockType::kReverseString); - EqualityMatchExpression eq1; + EqualityMatchExpression eq1("a", operand["a"]); eq1.setCollator(&collator1); CollatorInterfaceMock collator2(CollatorInterfaceMock::MockType::kAlwaysEqual); - EqualityMatchExpression eq2; + EqualityMatchExpression eq2("a", operand["a"]); eq2.setCollator(&collator2); ASSERT(!eq1.equivalent(&eq2)); } TEST(ComparisonMatchExpression, ComparisonMatchExpressionsWithEqualCollatorsAreEqual) { + BSONObj operand = BSON("a" << 5); CollatorInterfaceMock collator1(CollatorInterfaceMock::MockType::kAlwaysEqual); - EqualityMatchExpression eq1; + EqualityMatchExpression eq1("a", operand["a"]); eq1.setCollator(&collator1); CollatorInterfaceMock collator2(CollatorInterfaceMock::MockType::kAlwaysEqual); - EqualityMatchExpression eq2; + EqualityMatchExpression eq2("a", operand["a"]); eq2.setCollator(&collator2); ASSERT(eq1.equivalent(&eq2)); } @@ -65,8 +67,7 @@ TEST(ComparisonMatchExpression, ComparisonMatchExpressionsWithEqualCollatorsAreE TEST(ComparisonMatchExpression, StringMatchingWithNullCollatorUsesBinaryComparison) { BSONObj operand = BSON("a" << "string"); - EqualityMatchExpression eq; - ASSERT(eq.init("a", operand["a"]).isOK()); + EqualityMatchExpression eq("a", operand["a"]); ASSERT(!eq.matchesBSON(BSON("a" << "string2"), NULL)); @@ -76,9 +77,8 @@ TEST(ComparisonMatchExpression, StringMatchingRespectsCollation) { BSONObj operand = BSON("a" << "string"); CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual); - EqualityMatchExpression eq; + EqualityMatchExpression eq("a", operand["a"]); eq.setCollator(&collator); - ASSERT(eq.init("a", operand["a"]).isOK()); ASSERT(eq.matchesBSON(BSON("a" << "string2"), NULL)); @@ -89,8 +89,7 @@ TEST(EqOp, MatchesElement) { BSONObj match = BSON("a" << 5.0); BSONObj notMatch = BSON("a" << 6); - EqualityMatchExpression eq; - eq.init("", operand["a"]).transitional_ignore(); + EqualityMatchExpression eq("", operand["a"]); ASSERT(eq.matchesSingleElement(match.firstElement())); ASSERT(!eq.matchesSingleElement(notMatch.firstElement())); @@ -99,30 +98,26 @@ TEST(EqOp, MatchesElement) { DEATH_TEST(EqOp, InvalidEooOperand, "Invariant failure _rhs") { BSONObj operand; - EqualityMatchExpression eq; - eq.init("", operand.firstElement()).ignore(); + EqualityMatchExpression eq("", operand.firstElement()); } TEST(EqOp, MatchesScalar) { BSONObj operand = BSON("a" << 5); - EqualityMatchExpression eq; - eq.init("a", operand["a"]).transitional_ignore(); + EqualityMatchExpression eq("a", operand["a"]); ASSERT(eq.matchesBSON(BSON("a" << 5.0), NULL)); ASSERT(!eq.matchesBSON(BSON("a" << 4), NULL)); } TEST(EqOp, MatchesArrayValue) { BSONObj operand = BSON("a" << 5); - EqualityMatchExpression eq; - eq.init("a", operand["a"]).transitional_ignore(); + EqualityMatchExpression eq("a", operand["a"]); ASSERT(eq.matchesBSON(BSON("a" << BSON_ARRAY(5.0 << 6)), NULL)); ASSERT(!eq.matchesBSON(BSON("a" << BSON_ARRAY(6 << 7)), NULL)); } TEST(EqOp, MatchesReferencedObjectValue) { BSONObj operand = BSON("a.b" << 5); - EqualityMatchExpression eq; - eq.init("a.b", operand["a.b"]).transitional_ignore(); + EqualityMatchExpression eq("a.b", operand["a.b"]); ASSERT(eq.matchesBSON(BSON("a" << BSON("b" << 5)), NULL)); ASSERT(eq.matchesBSON(BSON("a" << BSON("b" << BSON_ARRAY(5))), NULL)); ASSERT(eq.matchesBSON(BSON("a" << BSON_ARRAY(BSON("b" << 5))), NULL)); @@ -130,16 +125,14 @@ TEST(EqOp, MatchesReferencedObjectValue) { TEST(EqOp, MatchesReferencedArrayValue) { BSONObj operand = BSON("a.0" << 5); - EqualityMatchExpression eq; - eq.init("a.0", operand["a.0"]).transitional_ignore(); + EqualityMatchExpression eq("a.0", operand["a.0"]); ASSERT(eq.matchesBSON(BSON("a" << BSON_ARRAY(5)), NULL)); ASSERT(!eq.matchesBSON(BSON("a" << BSON_ARRAY(BSON_ARRAY(5))), NULL)); } TEST(EqOp, MatchesNull) { BSONObj operand = BSON("a" << BSONNULL); - EqualityMatchExpression eq; - eq.init("a", operand["a"]).transitional_ignore(); + EqualityMatchExpression eq("a", operand["a"]); ASSERT(eq.matchesBSON(BSONObj(), NULL)); ASSERT(eq.matchesBSON(BSON("a" << BSONNULL), NULL)); ASSERT(!eq.matchesBSON(BSON("a" << 4), NULL)); @@ -151,8 +144,7 @@ TEST(EqOp, MatchesNull) { // not necessarily how it should work ideally. TEST(EqOp, MatchesNestedNull) { BSONObj operand = BSON("a.b" << BSONNULL); - EqualityMatchExpression eq; - eq.init("a.b", operand["a.b"]).transitional_ignore(); + EqualityMatchExpression eq("a.b", operand["a.b"]); // null matches any empty object that is on a subpath of a.b ASSERT(eq.matchesBSON(BSONObj(), NULL)); ASSERT(eq.matchesBSON(BSON("a" << BSONObj()), NULL)); @@ -171,8 +163,7 @@ TEST(EqOp, MatchesNestedNull) { TEST(EqOp, MatchesMinKey) { BSONObj operand = BSON("a" << MinKey); - EqualityMatchExpression eq; - eq.init("a", operand["a"]).transitional_ignore(); + EqualityMatchExpression eq("a", operand["a"]); ASSERT(eq.matchesBSON(BSON("a" << MinKey), NULL)); ASSERT(!eq.matchesBSON(BSON("a" << MaxKey), NULL)); ASSERT(!eq.matchesBSON(BSON("a" << 4), NULL)); @@ -181,8 +172,7 @@ TEST(EqOp, MatchesMinKey) { TEST(EqOp, MatchesMaxKey) { BSONObj operand = BSON("a" << MaxKey); - EqualityMatchExpression eq; - ASSERT(eq.init("a", operand["a"]).isOK()); + EqualityMatchExpression eq("a", operand["a"]); ASSERT(eq.matchesBSON(BSON("a" << MaxKey), NULL)); ASSERT(!eq.matchesBSON(BSON("a" << MinKey), NULL)); ASSERT(!eq.matchesBSON(BSON("a" << 4), NULL)); @@ -190,8 +180,7 @@ TEST(EqOp, MatchesMaxKey) { TEST(EqOp, MatchesFullArray) { BSONObj operand = BSON("a" << BSON_ARRAY(1 << 2)); - EqualityMatchExpression eq; - ASSERT(eq.init("a", operand["a"]).isOK()); + EqualityMatchExpression eq("a", operand["a"]); ASSERT(eq.matchesBSON(BSON("a" << BSON_ARRAY(1 << 2)), NULL)); ASSERT(!eq.matchesBSON(BSON("a" << BSON_ARRAY(1 << 2 << 3)), NULL)); ASSERT(!eq.matchesBSON(BSON("a" << BSON_ARRAY(1)), NULL)); @@ -200,16 +189,14 @@ TEST(EqOp, MatchesFullArray) { TEST(EqOp, MatchesThroughNestedArray) { BSONObj operand = BSON("a.b.c.d" << 3); - EqualityMatchExpression eq; - eq.init("a.b.c.d", operand["a.b.c.d"]).transitional_ignore(); + EqualityMatchExpression eq("a.b.c.d", operand["a.b.c.d"]); BSONObj obj = fromjson("{a:{b:[{c:[{d:1},{d:2}]},{c:[{d:3}]}]}}"); ASSERT(eq.matchesBSON(obj, NULL)); } TEST(EqOp, ElemMatchKey) { BSONObj operand = BSON("a" << 5); - EqualityMatchExpression eq; - ASSERT(eq.init("a", operand["a"]).isOK()); + EqualityMatchExpression eq("a", operand["a"]); MatchDetails details; details.requestElemMatchKey(); ASSERT(!eq.matchesBSON(BSON("a" << 4), &details)); @@ -227,8 +214,7 @@ TEST(EqOp, ElemMatchKey) { TEST(EqOp, ElemMatchKeyWithImplicitAndExplicitTraversal) { BSONObj operand = BSON("a.0.b" << 3); BSONElement operandFirstElt = operand.firstElement(); - EqualityMatchExpression eq; - ASSERT(eq.init(operandFirstElt.fieldName(), operandFirstElt).isOK()); + EqualityMatchExpression eq(operandFirstElt.fieldName(), operandFirstElt); MatchDetails details; details.requestElemMatchKey(); BSONObj obj = fromjson("{a: [{b: [2, 3]}, {b: [4, 5]}]}"); @@ -238,71 +224,16 @@ TEST(EqOp, ElemMatchKeyWithImplicitAndExplicitTraversal) { } TEST(EqOp, Equality1) { - EqualityMatchExpression eq1; - EqualityMatchExpression eq2; - EqualityMatchExpression eq3; - BSONObj operand = BSON("a" << 5 << "b" << 5 << "c" << 4); - - eq1.init("a", operand["a"]).transitional_ignore(); - eq2.init("a", operand["b"]).transitional_ignore(); - eq3.init("c", operand["c"]).transitional_ignore(); + EqualityMatchExpression eq1("a", operand["a"]); + EqualityMatchExpression eq2("a", operand["b"]); + EqualityMatchExpression eq3("c", operand["c"]); ASSERT(eq1.equivalent(&eq1)); ASSERT(eq1.equivalent(&eq2)); ASSERT(!eq1.equivalent(&eq3)); } -/** - TEST( EqOp, MatchesIndexKeyScalar ) { - BSONObj operand = BSON( "a" << 6 ); - EqualityMatchExpression eq; - ASSERT( eq.init( "a", operand[ "a" ] ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - eq.matchesIndexKey( BSON( "" << 6 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - eq.matchesIndexKey( BSON( "" << 4 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - eq.matchesIndexKey( BSON( "" << BSON_ARRAY( 6 ) ), indexSpec ) ); - } - - TEST( EqOp, MatchesIndexKeyMissing ) { - BSONObj operand = BSON( "a" << 6 ); - EqualityMatchExpression eq; - ASSERT( eq.init( "a", operand[ "a" ] ).isOK() ); - IndexSpec indexSpec( BSON( "b" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - eq.matchesIndexKey( BSON( "" << 6 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - eq.matchesIndexKey( BSON( "" << 4 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - eq.matchesIndexKey( BSON( "" << BSON_ARRAY( 8 << 6 ) ), indexSpec ) ); - } - - TEST( EqOp, MatchesIndexKeyArray ) { - BSONObj operand = BSON( "a" << BSON_ARRAY( 4 << 5 ) ); - ComparisonMatchExpression eq - ASSERT( eq.init( "a", operand[ "a" ] ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - eq.matchesIndexKey( BSON( "" << 4 ), indexSpec ) ); - } - - TEST( EqOp, MatchesIndexKeyArrayValue ) { - BSONObj operand = BSON( "a" << 6 ); - ComparisonMatchExpression eq - ASSERT( eq.init( "a", operand[ "a" ] ).isOK() ); - IndexSpec indexSpec( BSON( "loc" << "mockarrayvalue" << "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - eq.matchesIndexKey( BSON( "" << "dummygeohash" << "" << 6 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - eq.matchesIndexKey( BSON( "" << "dummygeohash" << "" << 4 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - eq.matchesIndexKey( BSON( "" << "dummygeohash" << - "" << BSON_ARRAY( 8 << 6 ) ), indexSpec ) ); - } -*/ TEST(LtOp, MatchesElement) { BSONObj operand = BSON("$lt" << 5); BSONObj match = BSON("a" << 4.5); @@ -310,8 +241,7 @@ TEST(LtOp, MatchesElement) { BSONObj notMatchEqual = BSON("a" << 5); BSONObj notMatchWrongType = BSON("a" << "foo"); - LTMatchExpression lt; - ASSERT(lt.init("", operand["$lt"]).isOK()); + LTMatchExpression lt("", operand["$lt"]); ASSERT(lt.matchesSingleElement(match.firstElement())); ASSERT(!lt.matchesSingleElement(notMatch.firstElement())); ASSERT(!lt.matchesSingleElement(notMatchEqual.firstElement())); @@ -320,38 +250,33 @@ TEST(LtOp, MatchesElement) { DEATH_TEST(LtOp, InvalidEooOperand, "Invariant failure _rhs") { BSONObj operand; - LTMatchExpression lt; - lt.init("", operand.firstElement()).ignore(); + LTMatchExpression lt("", operand.firstElement()); } TEST(LtOp, MatchesScalar) { BSONObj operand = BSON("$lt" << 5); - LTMatchExpression lt; - ASSERT(lt.init("a", operand["$lt"]).isOK()); + LTMatchExpression lt("a", operand["$lt"]); ASSERT(lt.matchesBSON(BSON("a" << 4.5), NULL)); ASSERT(!lt.matchesBSON(BSON("a" << 6), NULL)); } TEST(LtOp, MatchesScalarEmptyKey) { BSONObj operand = BSON("$lt" << 5); - LTMatchExpression lt; - ASSERT(lt.init("", operand["$lt"]).isOK()); + LTMatchExpression lt("", operand["$lt"]); ASSERT(lt.matchesBSON(BSON("" << 4.5), NULL)); ASSERT(!lt.matchesBSON(BSON("" << 6), NULL)); } TEST(LtOp, MatchesArrayValue) { BSONObj operand = BSON("$lt" << 5); - LTMatchExpression lt; - ASSERT(lt.init("a", operand["$lt"]).isOK()); + LTMatchExpression lt("a", operand["$lt"]); ASSERT(lt.matchesBSON(BSON("a" << BSON_ARRAY(6 << 4.5)), NULL)); ASSERT(!lt.matchesBSON(BSON("a" << BSON_ARRAY(6 << 7)), NULL)); } TEST(LtOp, MatchesWholeArray) { BSONObj operand = BSON("$lt" << BSON_ARRAY(5)); - LTMatchExpression lt; - ASSERT(lt.init("a", operand["$lt"]).isOK()); + LTMatchExpression lt("a", operand["$lt"]); ASSERT(lt.matchesBSON(BSON("a" << BSON_ARRAY(4)), NULL)); ASSERT(!lt.matchesBSON(BSON("a" << BSON_ARRAY(5)), NULL)); ASSERT(!lt.matchesBSON(BSON("a" << BSON_ARRAY(6)), NULL)); @@ -363,8 +288,7 @@ TEST(LtOp, MatchesWholeArray) { TEST(LtOp, MatchesNull) { BSONObj operand = BSON("$lt" << BSONNULL); - LTMatchExpression lt; - ASSERT(lt.init("a", operand["$lt"]).isOK()); + LTMatchExpression lt("a", operand["$lt"]); ASSERT(!lt.matchesBSON(BSONObj(), NULL)); ASSERT(!lt.matchesBSON(BSON("a" << BSONNULL), NULL)); ASSERT(!lt.matchesBSON(BSON("a" << 4), NULL)); @@ -374,8 +298,7 @@ TEST(LtOp, MatchesNull) { TEST(LtOp, MatchesDotNotationNull) { BSONObj operand = BSON("$lt" << BSONNULL); - LTMatchExpression lt; - ASSERT(lt.init("a.b", operand["$lt"]).isOK()); + LTMatchExpression lt("a.b", operand["$lt"]); ASSERT(!lt.matchesBSON(BSONObj(), NULL)); ASSERT(!lt.matchesBSON(BSON("a" << BSONNULL), NULL)); ASSERT(!lt.matchesBSON(BSON("a" << 4), NULL)); @@ -388,8 +311,7 @@ TEST(LtOp, MatchesDotNotationNull) { TEST(LtOp, MatchesMinKey) { BSONObj operand = BSON("a" << MinKey); - LTMatchExpression lt; - ASSERT(lt.init("a", operand["a"]).isOK()); + LTMatchExpression lt("a", operand["a"]); ASSERT(!lt.matchesBSON(BSON("a" << MinKey), NULL)); ASSERT(!lt.matchesBSON(BSON("a" << MaxKey), NULL)); ASSERT(!lt.matchesBSON(BSON("a" << 4), NULL)); @@ -397,8 +319,7 @@ TEST(LtOp, MatchesMinKey) { TEST(LtOp, MatchesMaxKey) { BSONObj operand = BSON("a" << MaxKey); - LTMatchExpression lt; - ASSERT(lt.init("a", operand["a"]).isOK()); + LTMatchExpression lt("a", operand["a"]); ASSERT(!lt.matchesBSON(BSON("a" << MaxKey), NULL)); ASSERT(lt.matchesBSON(BSON("a" << MinKey), NULL)); ASSERT(lt.matchesBSON(BSON("a" << 4), NULL)); @@ -406,8 +327,7 @@ TEST(LtOp, MatchesMaxKey) { TEST(LtOp, ElemMatchKey) { BSONObj operand = BSON("$lt" << 5); - LTMatchExpression lt; - ASSERT(lt.init("a", operand["$lt"]).isOK()); + LTMatchExpression lt("a", operand["$lt"]); MatchDetails details; details.requestElemMatchKey(); ASSERT(!lt.matchesBSON(BSON("a" << 6), &details)); @@ -419,56 +339,6 @@ TEST(LtOp, ElemMatchKey) { ASSERT_EQUALS("1", details.elemMatchKey()); } -/** - TEST( LtOp, MatchesIndexKeyScalar ) { - BSONObj operand = BSON( "$lt" << 6 ); - LtOp lt; - ASSERT( lt.init( "a", operand[ "$lt" ] ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - lt.matchesIndexKey( BSON( "" << 3 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - lt.matchesIndexKey( BSON( "" << 6 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - lt.matchesIndexKey( BSON( "" << BSON_ARRAY( 5 ) ), indexSpec ) ); - } - - TEST( LtOp, MatchesIndexKeyMissing ) { - BSONObj operand = BSON( "$lt" << 6 ); - LtOp lt; - ASSERT( lt.init( "a", operand[ "$lt" ] ).isOK() ); - IndexSpec indexSpec( BSON( "b" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - lt.matchesIndexKey( BSON( "" << 6 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - lt.matchesIndexKey( BSON( "" << 4 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - lt.matchesIndexKey( BSON( "" << BSON_ARRAY( 8 << 6 ) ), indexSpec ) ); - } - - TEST( LtOp, MatchesIndexKeyArray ) { - BSONObj operand = BSON( "$lt" << BSON_ARRAY( 4 << 5 ) ); - LtOp lt; - ASSERT( lt.init( "a", operand[ "$lt" ] ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - lt.matchesIndexKey( BSON( "" << 3 ), indexSpec ) ); - } - - TEST( LtOp, MatchesIndexKeyArrayValue ) { - BSONObj operand = BSON( "$lt" << 6 ); - LtOp lt; - ASSERT( lt.init( "a", operand[ "$lt" ] ).isOK() ); - IndexSpec indexSpec( BSON( "loc" << "mockarrayvalue" << "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - lt.matchesIndexKey( BSON( "" << "dummygeohash" << "" << 3 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - lt.matchesIndexKey( BSON( "" << "dummygeohash" << "" << 6 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - lt.matchesIndexKey( BSON( "" << "dummygeohash" << - "" << BSON_ARRAY( 8 << 6 << 4 ) ), indexSpec ) ); - } -*/ TEST(LteOp, MatchesElement) { BSONObj operand = BSON("$lte" << 5); BSONObj match = BSON("a" << 4.5); @@ -476,8 +346,7 @@ TEST(LteOp, MatchesElement) { BSONObj notMatch = BSON("a" << 6); BSONObj notMatchWrongType = BSON("a" << "foo"); - LTEMatchExpression lte; - ASSERT(lte.init("", operand["$lte"]).isOK()); + LTEMatchExpression lte("", operand["$lte"]); ASSERT(lte.matchesSingleElement(match.firstElement())); ASSERT(lte.matchesSingleElement(equalMatch.firstElement())); ASSERT(!lte.matchesSingleElement(notMatch.firstElement())); @@ -486,30 +355,26 @@ TEST(LteOp, MatchesElement) { DEATH_TEST(LteOp, InvalidEooOperand, "Invariant failure _rhs") { BSONObj operand; - LTEMatchExpression lte; - lte.init("", operand.firstElement()).ignore(); + LTEMatchExpression lte("", operand.firstElement()); } TEST(LteOp, MatchesScalar) { BSONObj operand = BSON("$lte" << 5); - LTEMatchExpression lte; - ASSERT(lte.init("a", operand["$lte"]).isOK()); + LTEMatchExpression lte("a", operand["$lte"]); ASSERT(lte.matchesBSON(BSON("a" << 4.5), NULL)); ASSERT(!lte.matchesBSON(BSON("a" << 6), NULL)); } TEST(LteOp, MatchesArrayValue) { BSONObj operand = BSON("$lte" << 5); - LTEMatchExpression lte; - ASSERT(lte.init("a", operand["$lte"]).isOK()); + LTEMatchExpression lte("a", operand["$lte"]); ASSERT(lte.matchesBSON(BSON("a" << BSON_ARRAY(6 << 4.5)), NULL)); ASSERT(!lte.matchesBSON(BSON("a" << BSON_ARRAY(6 << 7)), NULL)); } TEST(LteOp, MatchesWholeArray) { BSONObj operand = BSON("$lte" << BSON_ARRAY(5)); - LTEMatchExpression lte; - ASSERT(lte.init("a", operand["$lte"]).isOK()); + LTEMatchExpression lte("a", operand["$lte"]); ASSERT(lte.matchesBSON(BSON("a" << BSON_ARRAY(4)), NULL)); ASSERT(lte.matchesBSON(BSON("a" << BSON_ARRAY(5)), NULL)); ASSERT(!lte.matchesBSON(BSON("a" << BSON_ARRAY(6)), NULL)); @@ -521,8 +386,7 @@ TEST(LteOp, MatchesWholeArray) { TEST(LteOp, MatchesNull) { BSONObj operand = BSON("$lte" << BSONNULL); - LTEMatchExpression lte; - ASSERT(lte.init("a", operand["$lte"]).isOK()); + LTEMatchExpression lte("a", operand["$lte"]); ASSERT(lte.matchesBSON(BSONObj(), NULL)); ASSERT(lte.matchesBSON(BSON("a" << BSONNULL), NULL)); ASSERT(!lte.matchesBSON(BSON("a" << 4), NULL)); @@ -532,8 +396,7 @@ TEST(LteOp, MatchesNull) { TEST(LteOp, MatchesDotNotationNull) { BSONObj operand = BSON("$lte" << BSONNULL); - LTEMatchExpression lte; - ASSERT(lte.init("a.b", operand["$lte"]).isOK()); + LTEMatchExpression lte("a.b", operand["$lte"]); ASSERT(lte.matchesBSON(BSONObj(), NULL)); ASSERT(lte.matchesBSON(BSON("a" << BSONNULL), NULL)); ASSERT(lte.matchesBSON(BSON("a" << 4), NULL)); @@ -546,8 +409,7 @@ TEST(LteOp, MatchesDotNotationNull) { TEST(LteOp, MatchesMinKey) { BSONObj operand = BSON("a" << MinKey); - LTEMatchExpression lte; - ASSERT(lte.init("a", operand["a"]).isOK()); + LTEMatchExpression lte("a", operand["a"]); ASSERT(lte.matchesBSON(BSON("a" << MinKey), NULL)); ASSERT(!lte.matchesBSON(BSON("a" << MaxKey), NULL)); ASSERT(!lte.matchesBSON(BSON("a" << 4), NULL)); @@ -555,8 +417,7 @@ TEST(LteOp, MatchesMinKey) { TEST(LteOp, MatchesMaxKey) { BSONObj operand = BSON("a" << MaxKey); - LTEMatchExpression lte; - ASSERT(lte.init("a", operand["a"]).isOK()); + LTEMatchExpression lte("a", operand["a"]); ASSERT(lte.matchesBSON(BSON("a" << MaxKey), NULL)); ASSERT(lte.matchesBSON(BSON("a" << MinKey), NULL)); ASSERT(lte.matchesBSON(BSON("a" << 4), NULL)); @@ -565,8 +426,7 @@ TEST(LteOp, MatchesMaxKey) { TEST(LteOp, ElemMatchKey) { BSONObj operand = BSON("$lte" << 5); - LTEMatchExpression lte; - ASSERT(lte.init("a", operand["$lte"]).isOK()); + LTEMatchExpression lte("a", operand["$lte"]); MatchDetails details; details.requestElemMatchKey(); ASSERT(!lte.matchesBSON(BSON("a" << 6), &details)); @@ -578,97 +438,28 @@ TEST(LteOp, ElemMatchKey) { ASSERT_EQUALS("1", details.elemMatchKey()); } -/** - TEST( LteOp, MatchesIndexKeyScalar ) { - BSONObj operand = BSON( "$lte" << 6 ); - LteOp lte; - ASSERT( lte.init( "a", operand[ "$lte" ] ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - lte.matchesIndexKey( BSON( "" << 6 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - lte.matchesIndexKey( BSON( "" << 7 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - lte.matchesIndexKey( BSON( "" << BSON_ARRAY( 5 ) ), indexSpec ) ); - } - - TEST( LteOp, MatchesIndexKeyMissing ) { - BSONObj operand = BSON( "$lte" << 6 ); - LteOp lte; - ASSERT( lte.init( "a", operand[ "$lte" ] ).isOK() ); - IndexSpec indexSpec( BSON( "b" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - lte.matchesIndexKey( BSON( "" << 7 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - lte.matchesIndexKey( BSON( "" << 4 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - lte.matchesIndexKey( BSON( "" << BSON_ARRAY( 8 << 6 ) ), indexSpec ) ); - } - - TEST( LteOp, MatchesIndexKeyArray ) { - BSONObj operand = BSON( "$lte" << BSON_ARRAY( 4 << 5 ) ); - LteOp lte; - ASSERT( lte.init( "a", operand[ "$lte" ] ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - lte.matchesIndexKey( BSON( "" << 3 ), indexSpec ) ); - } - - TEST( LteOp, MatchesIndexKeyArrayValue ) { - BSONObj operand = BSON( "$lte" << 6 ); - LteOp lte; - ASSERT( lte.init( "a", operand[ "$lte" ] ).isOK() ); - IndexSpec indexSpec( BSON( "loc" << "mockarrayvalue" << "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - lte.matchesIndexKey( BSON( "" << "dummygeohash" << "" << 3 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - lte.matchesIndexKey( BSON( "" << "dummygeohash" << "" << 7 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - lte.matchesIndexKey( BSON( "" << "dummygeohash" << - "" << BSON_ARRAY( 8 << 6 << 4 ) ), indexSpec ) ); - } - - TEST( GtOp, MatchesElement ) { - BSONObj operand = BSON( "$gt" << 5 ); - BSONObj match = BSON( "a" << 5.5 ); - BSONObj notMatch = BSON( "a" << 4 ); - BSONObj notMatchEqual = BSON( "a" << 5 ); - BSONObj notMatchWrongType = BSON( "a" << "foo" ); - GtOp gt; - ASSERT( gt.init( "", operand[ "$gt" ] ).isOK() ); - ASSERT( gt.matchesSingleElement( match.firstElement() ) ); - ASSERT( !gt.matchesSingleElement( notMatch.firstElement() ) ); - ASSERT( !gt.matchesSingleElement( notMatchEqual.firstElement() ) ); - ASSERT( !gt.matchesSingleElement( notMatchWrongType.firstElement() ) ); - } -*/ - DEATH_TEST(GtOp, InvalidEooOperand, "Invariant failure _rhs") { BSONObj operand; - GTMatchExpression gt; - gt.init("", operand.firstElement()).ignore(); + GTMatchExpression gt("", operand.firstElement()); } TEST(GtOp, MatchesScalar) { BSONObj operand = BSON("$gt" << 5); - GTMatchExpression gt; - ASSERT(gt.init("a", operand["$gt"]).isOK()); + GTMatchExpression gt("a", operand["$gt"]); ASSERT(gt.matchesBSON(BSON("a" << 5.5), NULL)); ASSERT(!gt.matchesBSON(BSON("a" << 4), NULL)); } TEST(GtOp, MatchesArrayValue) { BSONObj operand = BSON("$gt" << 5); - GTMatchExpression gt; - ASSERT(gt.init("a", operand["$gt"]).isOK()); + GTMatchExpression gt("a", operand["$gt"]); ASSERT(gt.matchesBSON(BSON("a" << BSON_ARRAY(3 << 5.5)), NULL)); ASSERT(!gt.matchesBSON(BSON("a" << BSON_ARRAY(2 << 4)), NULL)); } TEST(GtOp, MatchesWholeArray) { BSONObj operand = BSON("$gt" << BSON_ARRAY(5)); - GTMatchExpression gt; - ASSERT(gt.init("a", operand["$gt"]).isOK()); + GTMatchExpression gt("a", operand["$gt"]); ASSERT(!gt.matchesBSON(BSON("a" << BSON_ARRAY(4)), NULL)); ASSERT(!gt.matchesBSON(BSON("a" << BSON_ARRAY(5)), NULL)); ASSERT(gt.matchesBSON(BSON("a" << BSON_ARRAY(6)), NULL)); @@ -682,8 +473,7 @@ TEST(GtOp, MatchesWholeArray) { TEST(GtOp, MatchesNull) { BSONObj operand = BSON("$gt" << BSONNULL); - GTMatchExpression gt; - ASSERT(gt.init("a", operand["$gt"]).isOK()); + GTMatchExpression gt("a", operand["$gt"]); ASSERT(!gt.matchesBSON(BSONObj(), NULL)); ASSERT(!gt.matchesBSON(BSON("a" << BSONNULL), NULL)); ASSERT(!gt.matchesBSON(BSON("a" << 4), NULL)); @@ -693,8 +483,7 @@ TEST(GtOp, MatchesNull) { TEST(GtOp, MatchesDotNotationNull) { BSONObj operand = BSON("$gt" << BSONNULL); - GTMatchExpression gt; - ASSERT(gt.init("a.b", operand["$gt"]).isOK()); + GTMatchExpression gt("a.b", operand["$gt"]); ASSERT(!gt.matchesBSON(BSONObj(), NULL)); ASSERT(!gt.matchesBSON(BSON("a" << BSONNULL), NULL)); ASSERT(!gt.matchesBSON(BSON("a" << 4), NULL)); @@ -707,8 +496,7 @@ TEST(GtOp, MatchesDotNotationNull) { TEST(GtOp, MatchesMinKey) { BSONObj operand = BSON("a" << MinKey); - GTMatchExpression gt; - ASSERT(gt.init("a", operand["a"]).isOK()); + GTMatchExpression gt("a", operand["a"]); ASSERT(!gt.matchesBSON(BSON("a" << MinKey), NULL)); ASSERT(gt.matchesBSON(BSON("a" << MaxKey), NULL)); ASSERT(gt.matchesBSON(BSON("a" << 4), NULL)); @@ -716,8 +504,7 @@ TEST(GtOp, MatchesMinKey) { TEST(GtOp, MatchesMaxKey) { BSONObj operand = BSON("a" << MaxKey); - GTMatchExpression gt; - ASSERT(gt.init("a", operand["a"]).isOK()); + GTMatchExpression gt("a", operand["a"]); ASSERT(!gt.matchesBSON(BSON("a" << MaxKey), NULL)); ASSERT(!gt.matchesBSON(BSON("a" << MinKey), NULL)); ASSERT(!gt.matchesBSON(BSON("a" << 4), NULL)); @@ -725,8 +512,7 @@ TEST(GtOp, MatchesMaxKey) { TEST(GtOp, ElemMatchKey) { BSONObj operand = BSON("$gt" << 5); - GTMatchExpression gt; - ASSERT(gt.init("a", operand["$gt"]).isOK()); + GTMatchExpression gt("a", operand["$gt"]); MatchDetails details; details.requestElemMatchKey(); ASSERT(!gt.matchesBSON(BSON("a" << 4), &details)); @@ -738,57 +524,6 @@ TEST(GtOp, ElemMatchKey) { ASSERT_EQUALS("1", details.elemMatchKey()); } -/** - TEST( GtOp, MatchesIndexKeyScalar ) { - BSONObj operand = BSON( "$gt" << 6 ); - GtOp gt; - ASSERT( gt.init( "a", operand[ "$gt" ] ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - gt.matchesIndexKey( BSON( "" << 7 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - gt.matchesIndexKey( BSON( "" << 6 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - gt.matchesIndexKey( BSON( "" << BSON_ARRAY( 9 ) ), indexSpec ) ); - } - - TEST( GtOp, MatchesIndexKeyMissing ) { - BSONObj operand = BSON( "$gt" << 6 ); - GtOp gt; - ASSERT( gt.init( "a", operand[ "$gt" ] ).isOK() ); - IndexSpec indexSpec( BSON( "b" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - gt.matchesIndexKey( BSON( "" << 7 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - gt.matchesIndexKey( BSON( "" << 4 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - gt.matchesIndexKey( BSON( "" << BSON_ARRAY( 8 << 6 ) ), indexSpec ) ); - } - - TEST( GtOp, MatchesIndexKeyArray ) { - BSONObj operand = BSON( "$gt" << BSON_ARRAY( 4 << 5 ) ); - GtOp gt; - ASSERT( gt.init( "a", operand[ "$gt" ] ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - gt.matchesIndexKey( BSON( "" << 8 ), indexSpec ) ); - } - - TEST( GtOp, MatchesIndexKeyArrayValue ) { - BSONObj operand = BSON( "$gt" << 6 ); - GtOp gt; - ASSERT( gt.init( "a", operand[ "$gt" ] ).isOK() ); - IndexSpec indexSpec( BSON( "loc" << "mockarrayvalue" << "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - gt.matchesIndexKey( BSON( "" << "dummygeohash" << "" << 7 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - gt.matchesIndexKey( BSON( "" << "dummygeohash" << "" << 3 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - gt.matchesIndexKey( BSON( "" << "dummygeohash" << - "" << BSON_ARRAY( 8 << 6 << 4 ) ), indexSpec ) ); - } -*/ - TEST(GteOp, MatchesElement) { BSONObj operand = BSON("$gte" << 5); BSONObj match = BSON("a" << 5.5); @@ -796,8 +531,7 @@ TEST(GteOp, MatchesElement) { BSONObj notMatch = BSON("a" << 4); BSONObj notMatchWrongType = BSON("a" << "foo"); - GTEMatchExpression gte; - ASSERT(gte.init("", operand["$gte"]).isOK()); + GTEMatchExpression gte("", operand["$gte"]); ASSERT(gte.matchesSingleElement(match.firstElement())); ASSERT(gte.matchesSingleElement(equalMatch.firstElement())); ASSERT(!gte.matchesSingleElement(notMatch.firstElement())); @@ -806,30 +540,26 @@ TEST(GteOp, MatchesElement) { DEATH_TEST(GteOp, InvalidEooOperand, "Invariant failure _rhs") { BSONObj operand; - GTEMatchExpression gte; - gte.init("", operand.firstElement()).ignore(); + GTEMatchExpression gte("", operand.firstElement()); } TEST(GteOp, MatchesScalar) { BSONObj operand = BSON("$gte" << 5); - GTEMatchExpression gte; - ASSERT(gte.init("a", operand["$gte"]).isOK()); + GTEMatchExpression gte("a", operand["$gte"]); ASSERT(gte.matchesBSON(BSON("a" << 5.5), NULL)); ASSERT(!gte.matchesBSON(BSON("a" << 4), NULL)); } TEST(GteOp, MatchesArrayValue) { BSONObj operand = BSON("$gte" << 5); - GTEMatchExpression gte; - ASSERT(gte.init("a", operand["$gte"]).isOK()); + GTEMatchExpression gte("a", operand["$gte"]); ASSERT(gte.matchesBSON(BSON("a" << BSON_ARRAY(4 << 5.5)), NULL)); ASSERT(!gte.matchesBSON(BSON("a" << BSON_ARRAY(1 << 2)), NULL)); } TEST(GteOp, MatchesWholeArray) { BSONObj operand = BSON("$gte" << BSON_ARRAY(5)); - GTEMatchExpression gte; - ASSERT(gte.init("a", operand["$gte"]).isOK()); + GTEMatchExpression gte("a", operand["$gte"]); ASSERT(!gte.matchesBSON(BSON("a" << BSON_ARRAY(4)), NULL)); ASSERT(gte.matchesBSON(BSON("a" << BSON_ARRAY(5)), NULL)); ASSERT(gte.matchesBSON(BSON("a" << BSON_ARRAY(6)), NULL)); @@ -842,8 +572,7 @@ TEST(GteOp, MatchesWholeArray) { TEST(GteOp, MatchesNull) { BSONObj operand = BSON("$gte" << BSONNULL); - GTEMatchExpression gte; - ASSERT(gte.init("a", operand["$gte"]).isOK()); + GTEMatchExpression gte("a", operand["$gte"]); ASSERT(gte.matchesBSON(BSONObj(), NULL)); ASSERT(gte.matchesBSON(BSON("a" << BSONNULL), NULL)); ASSERT(!gte.matchesBSON(BSON("a" << 4), NULL)); @@ -853,8 +582,7 @@ TEST(GteOp, MatchesNull) { TEST(GteOp, MatchesDotNotationNull) { BSONObj operand = BSON("$gte" << BSONNULL); - GTEMatchExpression gte; - ASSERT(gte.init("a.b", operand["$gte"]).isOK()); + GTEMatchExpression gte("a.b", operand["$gte"]); ASSERT(gte.matchesBSON(BSONObj(), NULL)); ASSERT(gte.matchesBSON(BSON("a" << BSONNULL), NULL)); ASSERT(gte.matchesBSON(BSON("a" << 4), NULL)); @@ -867,8 +595,7 @@ TEST(GteOp, MatchesDotNotationNull) { TEST(GteOp, MatchesMinKey) { BSONObj operand = BSON("a" << MinKey); - GTEMatchExpression gte; - ASSERT(gte.init("a", operand["a"]).isOK()); + GTEMatchExpression gte("a", operand["a"]); ASSERT(gte.matchesBSON(BSON("a" << MinKey), NULL)); ASSERT(gte.matchesBSON(BSON("a" << MaxKey), NULL)); ASSERT(gte.matchesBSON(BSON("a" << 4), NULL)); @@ -876,8 +603,7 @@ TEST(GteOp, MatchesMinKey) { TEST(GteOp, MatchesMaxKey) { BSONObj operand = BSON("a" << MaxKey); - GTEMatchExpression gte; - ASSERT(gte.init("a", operand["a"]).isOK()); + GTEMatchExpression gte("a", operand["a"]); ASSERT(gte.matchesBSON(BSON("a" << MaxKey), NULL)); ASSERT(!gte.matchesBSON(BSON("a" << MinKey), NULL)); ASSERT(!gte.matchesBSON(BSON("a" << 4), NULL)); @@ -885,8 +611,7 @@ TEST(GteOp, MatchesMaxKey) { TEST(GteOp, ElemMatchKey) { BSONObj operand = BSON("$gte" << 5); - GTEMatchExpression gte; - ASSERT(gte.init("a", operand["$gte"]).isOK()); + GTEMatchExpression gte("a", operand["$gte"]); MatchDetails details; details.requestElemMatchKey(); ASSERT(!gte.matchesBSON(BSON("a" << 4), &details)); @@ -903,16 +628,16 @@ TEST(RegexMatchExpression, MatchesElementExact) { << "b"); BSONObj notMatch = BSON("a" << "c"); - RegexMatchExpression regex; - ASSERT(regex.init("", "b", "").isOK()); + RegexMatchExpression regex("", "b", ""); ASSERT(regex.matchesSingleElement(match.firstElement())); ASSERT(!regex.matchesSingleElement(notMatch.firstElement())); } TEST(RegexMatchExpression, TooLargePattern) { string tooLargePattern(50 * 1000, 'z'); - RegexMatchExpression regex; - ASSERT(!regex.init("a", tooLargePattern, "").isOK()); + ASSERT_THROWS_CODE(RegexMatchExpression regex("a", tooLargePattern, ""), + AssertionException, + ErrorCodes::BadValue); } TEST(RegexMatchExpression, MatchesElementSimplePrefix) { @@ -920,8 +645,7 @@ TEST(RegexMatchExpression, MatchesElementSimplePrefix) { << "abc"); BSONObj notMatch = BSON("x" << "adz"); - RegexMatchExpression regex; - ASSERT(regex.init("", "^ab", "").isOK()); + RegexMatchExpression regex("", "^ab", ""); ASSERT(regex.matchesSingleElement(match.firstElement())); ASSERT(!regex.matchesSingleElement(notMatch.firstElement())); } @@ -931,8 +655,7 @@ TEST(RegexMatchExpression, MatchesElementCaseSensitive) { << "abc"); BSONObj notMatch = BSON("x" << "ABC"); - RegexMatchExpression regex; - ASSERT(regex.init("", "abc", "").isOK()); + RegexMatchExpression regex("", "abc", ""); ASSERT(regex.matchesSingleElement(match.firstElement())); ASSERT(!regex.matchesSingleElement(notMatch.firstElement())); } @@ -944,8 +667,7 @@ TEST(RegexMatchExpression, MatchesElementCaseInsensitive) { << "ABC"); BSONObj notMatch = BSON("x" << "abz"); - RegexMatchExpression regex; - ASSERT(regex.init("", "abc", "i").isOK()); + RegexMatchExpression regex("", "abc", "i"); ASSERT(regex.matchesSingleElement(match.firstElement())); ASSERT(regex.matchesSingleElement(matchUppercase.firstElement())); ASSERT(!regex.matchesSingleElement(notMatch.firstElement())); @@ -956,8 +678,7 @@ TEST(RegexMatchExpression, MatchesElementMultilineOff) { << "az"); BSONObj notMatch = BSON("x" << "\naz"); - RegexMatchExpression regex; - ASSERT(regex.init("", "^a", "").isOK()); + RegexMatchExpression regex("", "^a", ""); ASSERT(regex.matchesSingleElement(match.firstElement())); ASSERT(!regex.matchesSingleElement(notMatch.firstElement())); } @@ -969,8 +690,7 @@ TEST(RegexMatchExpression, MatchesElementMultilineOn) { << "\naz"); BSONObj notMatch = BSON("x" << "\n\n"); - RegexMatchExpression regex; - ASSERT(regex.init("", "^a", "m").isOK()); + RegexMatchExpression regex("", "^a", "m"); ASSERT(regex.matchesSingleElement(match.firstElement())); ASSERT(regex.matchesSingleElement(matchMultiline.firstElement())); ASSERT(!regex.matchesSingleElement(notMatch.firstElement())); @@ -981,8 +701,7 @@ TEST(RegexMatchExpression, MatchesElementExtendedOff) { << "a b"); BSONObj notMatch = BSON("x" << "ab"); - RegexMatchExpression regex; - ASSERT(regex.init("", "a b", "").isOK()); + RegexMatchExpression regex("", "a b", ""); ASSERT(regex.matchesSingleElement(match.firstElement())); ASSERT(!regex.matchesSingleElement(notMatch.firstElement())); } @@ -992,8 +711,7 @@ TEST(RegexMatchExpression, MatchesElementExtendedOn) { << "ab"); BSONObj notMatch = BSON("x" << "a b"); - RegexMatchExpression regex; - ASSERT(regex.init("", "a b", "x").isOK()); + RegexMatchExpression regex("", "a b", "x"); ASSERT(regex.matchesSingleElement(match.firstElement())); ASSERT(!regex.matchesSingleElement(notMatch.firstElement())); } @@ -1003,8 +721,7 @@ TEST(RegexMatchExpression, MatchesElementDotAllOff) { << "a b"); BSONObj notMatch = BSON("x" << "a\nb"); - RegexMatchExpression regex; - ASSERT(regex.init("", "a.b", "").isOK()); + RegexMatchExpression regex("", "a.b", ""); ASSERT(regex.matchesSingleElement(match.firstElement())); ASSERT(!regex.matchesSingleElement(notMatch.firstElement())); } @@ -1016,8 +733,7 @@ TEST(RegexMatchExpression, MatchesElementDotAllOn) { << "a\nb"); BSONObj notMatch = BSON("x" << "ab"); - RegexMatchExpression regex; - ASSERT(regex.init("", "a.b", "s").isOK()); + RegexMatchExpression regex("", "a.b", "s"); ASSERT(regex.matchesSingleElement(match.firstElement())); ASSERT(regex.matchesSingleElement(matchDotAll.firstElement())); ASSERT(!regex.matchesSingleElement(notMatch.firstElement())); @@ -1026,8 +742,7 @@ TEST(RegexMatchExpression, MatchesElementDotAllOn) { TEST(RegexMatchExpression, MatchesElementMultipleFlags) { BSONObj matchMultilineDotAll = BSON("x" << "\na\nb"); - RegexMatchExpression regex; - ASSERT(regex.init("", "^a.b", "ms").isOK()); + RegexMatchExpression regex("", "^a.b", "ms"); ASSERT(regex.matchesSingleElement(matchMultilineDotAll.firstElement())); } @@ -1035,8 +750,7 @@ TEST(RegexMatchExpression, MatchesElementRegexType) { BSONObj match = BSONObjBuilder().appendRegex("x", "yz", "i").obj(); BSONObj notMatchPattern = BSONObjBuilder().appendRegex("x", "r", "i").obj(); BSONObj notMatchFlags = BSONObjBuilder().appendRegex("x", "yz", "s").obj(); - RegexMatchExpression regex; - ASSERT(regex.init("", "yz", "i").isOK()); + RegexMatchExpression regex("", "yz", "i"); ASSERT(regex.matchesSingleElement(match.firstElement())); ASSERT(!regex.matchesSingleElement(notMatchPattern.firstElement())); ASSERT(!regex.matchesSingleElement(notMatchFlags.firstElement())); @@ -1045,8 +759,7 @@ TEST(RegexMatchExpression, MatchesElementRegexType) { TEST(RegexMatchExpression, MatchesElementSymbolType) { BSONObj match = BSONObjBuilder().appendSymbol("x", "yz").obj(); BSONObj notMatch = BSONObjBuilder().appendSymbol("x", "gg").obj(); - RegexMatchExpression regex; - ASSERT(regex.init("", "yz", "").isOK()); + RegexMatchExpression regex("", "yz", ""); ASSERT(regex.matchesSingleElement(match.firstElement())); ASSERT(!regex.matchesSingleElement(notMatch.firstElement())); } @@ -1054,8 +767,7 @@ TEST(RegexMatchExpression, MatchesElementSymbolType) { TEST(RegexMatchExpression, MatchesElementWrongType) { BSONObj notMatchInt = BSON("x" << 1); BSONObj notMatchBool = BSON("x" << true); - RegexMatchExpression regex; - ASSERT(regex.init("", "1", "").isOK()); + RegexMatchExpression regex("", "1", ""); ASSERT(!regex.matchesSingleElement(notMatchInt.firstElement())); ASSERT(!regex.matchesSingleElement(notMatchBool.firstElement())); } @@ -1063,14 +775,12 @@ TEST(RegexMatchExpression, MatchesElementWrongType) { TEST(RegexMatchExpression, MatchesElementUtf8) { BSONObj multiByteCharacter = BSON("x" << "\xc2\xa5"); - RegexMatchExpression regex; - ASSERT(regex.init("", "^.$", "").isOK()); + RegexMatchExpression regex("", "^.$", ""); ASSERT(regex.matchesSingleElement(multiByteCharacter.firstElement())); } TEST(RegexMatchExpression, MatchesScalar) { - RegexMatchExpression regex; - ASSERT(regex.init("a", "b", "").isOK()); + RegexMatchExpression regex("a", "b", ""); ASSERT(regex.matchesBSON(BSON("a" << "b"), NULL)); @@ -1080,8 +790,7 @@ TEST(RegexMatchExpression, MatchesScalar) { } TEST(RegexMatchExpression, MatchesArrayValue) { - RegexMatchExpression regex; - ASSERT(regex.init("a", "b", "").isOK()); + RegexMatchExpression regex("a", "b", ""); ASSERT(regex.matchesBSON(BSON("a" << BSON_ARRAY("c" << "b")), NULL)); @@ -1091,15 +800,13 @@ TEST(RegexMatchExpression, MatchesArrayValue) { } TEST(RegexMatchExpression, MatchesNull) { - RegexMatchExpression regex; - ASSERT(regex.init("a", "b", "").isOK()); + RegexMatchExpression regex("a", "b", ""); ASSERT(!regex.matchesBSON(BSONObj(), NULL)); ASSERT(!regex.matchesBSON(BSON("a" << BSONNULL), NULL)); } TEST(RegexMatchExpression, ElemMatchKey) { - RegexMatchExpression regex; - ASSERT(regex.init("a", "b", "").isOK()); + RegexMatchExpression regex("a", "b", ""); MatchDetails details; details.requestElemMatchKey(); ASSERT(!regex.matchesBSON(BSON("a" @@ -1118,14 +825,10 @@ TEST(RegexMatchExpression, ElemMatchKey) { } TEST(RegexMatchExpression, Equality1) { - RegexMatchExpression r1; - RegexMatchExpression r2; - RegexMatchExpression r3; - RegexMatchExpression r4; - ASSERT(r1.init("a", "b", "").isOK()); - ASSERT(r2.init("a", "b", "x").isOK()); - ASSERT(r3.init("a", "c", "").isOK()); - ASSERT(r4.init("b", "b", "").isOK()); + RegexMatchExpression r1("a", "b", ""); + RegexMatchExpression r2("a", "b", "x"); + RegexMatchExpression r3("a", "c", ""); + RegexMatchExpression r4("b", "b", ""); ASSERT(r1.equivalent(&r1)); ASSERT(!r1.equivalent(&r2)); @@ -1134,55 +837,69 @@ TEST(RegexMatchExpression, Equality1) { } TEST(RegexMatchExpression, RegexCannotContainEmbeddedNullByte) { - RegexMatchExpression regex; { const auto embeddedNull = "a\0b"_sd; - ASSERT_NOT_OK(regex.init("path", embeddedNull, "")); + ASSERT_THROWS_CODE(RegexMatchExpression regex("path", embeddedNull, ""), + AssertionException, + ErrorCodes::BadValue); } { const auto singleNullByte = "\0"_sd; - ASSERT_NOT_OK(regex.init("path", singleNullByte, "")); + ASSERT_THROWS_CODE(RegexMatchExpression regex("path", singleNullByte, ""), + AssertionException, + ErrorCodes::BadValue); } { const auto leadingNullByte = "\0bbbb"_sd; - ASSERT_NOT_OK(regex.init("path", leadingNullByte, "")); + ASSERT_THROWS_CODE(RegexMatchExpression regex("path", leadingNullByte, ""), + AssertionException, + ErrorCodes::BadValue); } { const auto trailingNullByte = "bbbb\0"_sd; - ASSERT_NOT_OK(regex.init("path", trailingNullByte, "")); + ASSERT_THROWS_CODE(RegexMatchExpression regex("path", trailingNullByte, ""), + AssertionException, + ErrorCodes::BadValue); } } TEST(RegexMatchExpression, RegexOptionsStringCannotContainEmbeddedNullByte) { - RegexMatchExpression regex; { const auto embeddedNull = "a\0b"_sd; - ASSERT_NOT_OK(regex.init("path", "pattern", embeddedNull)); + ASSERT_THROWS_CODE(RegexMatchExpression regex("path", "pattern", embeddedNull), + AssertionException, + ErrorCodes::BadValue); } { const auto singleNullByte = "\0"_sd; - ASSERT_NOT_OK(regex.init("path", "pattern", singleNullByte)); + ASSERT_THROWS_CODE(RegexMatchExpression regex("path", "pattern", singleNullByte), + AssertionException, + ErrorCodes::BadValue); } { const auto leadingNullByte = "\0bbbb"_sd; - ASSERT_NOT_OK(regex.init("path", "pattern", leadingNullByte)); + ASSERT_THROWS_CODE(RegexMatchExpression regex("path", "pattern", leadingNullByte), + AssertionException, + ErrorCodes::BadValue); } { const auto trailingNullByte = "bbbb\0"_sd; - ASSERT_NOT_OK(regex.init("path", "pattern", trailingNullByte)); + ASSERT_THROWS_CODE(RegexMatchExpression regex("path", "pattern", trailingNullByte), + AssertionException, + ErrorCodes::BadValue); } } TEST(RegexMatchExpression, RegexCannotBeInvalid) { - RegexMatchExpression regex; const auto invalid = "["_sd; - ASSERT_NOT_OK(regex.init("path", invalid, "")); + ASSERT_THROWS_CODE( + RegexMatchExpression regex("path", invalid, ""), AssertionException, ErrorCodes::BadValue); } TEST(ModMatchExpression, MatchesElement) { @@ -1191,8 +908,7 @@ TEST(ModMatchExpression, MatchesElement) { BSONObj longLongMatch = BSON("a" << 68719476736LL); BSONObj notMatch = BSON("a" << 6); BSONObj negativeNotMatch = BSON("a" << -2); - ModMatchExpression mod; - ASSERT(mod.init("", 3, 1).isOK()); + ModMatchExpression mod("", 3, 1); ASSERT(mod.matchesSingleElement(match.firstElement())); ASSERT(mod.matchesSingleElement(largerMatch.firstElement())); ASSERT(mod.matchesSingleElement(longLongMatch.firstElement())); @@ -1201,34 +917,29 @@ TEST(ModMatchExpression, MatchesElement) { } TEST(ModMatchExpression, ZeroDivisor) { - ModMatchExpression mod; - ASSERT(!mod.init("", 0, 1).isOK()); + ASSERT_THROWS_CODE(ModMatchExpression mod("", 0, 1), AssertionException, ErrorCodes::BadValue); } TEST(ModMatchExpression, MatchesScalar) { - ModMatchExpression mod; - ASSERT(mod.init("a", 5, 2).isOK()); + ModMatchExpression mod("a", 5, 2); ASSERT(mod.matchesBSON(BSON("a" << 7.0), NULL)); ASSERT(!mod.matchesBSON(BSON("a" << 4), NULL)); } TEST(ModMatchExpression, MatchesArrayValue) { - ModMatchExpression mod; - ASSERT(mod.init("a", 5, 2).isOK()); + ModMatchExpression mod("a", 5, 2); ASSERT(mod.matchesBSON(BSON("a" << BSON_ARRAY(5 << 12LL)), NULL)); ASSERT(!mod.matchesBSON(BSON("a" << BSON_ARRAY(6 << 8)), NULL)); } TEST(ModMatchExpression, MatchesNull) { - ModMatchExpression mod; - ASSERT(mod.init("a", 5, 2).isOK()); + ModMatchExpression mod("a", 5, 2); ASSERT(!mod.matchesBSON(BSONObj(), NULL)); ASSERT(!mod.matchesBSON(BSON("a" << BSONNULL), NULL)); } TEST(ModMatchExpression, ElemMatchKey) { - ModMatchExpression mod; - ASSERT(mod.init("a", 5, 2).isOK()); + ModMatchExpression mod("a", 5, 2); MatchDetails details; details.requestElemMatchKey(); ASSERT(!mod.matchesBSON(BSON("a" << 4), &details)); @@ -1241,15 +952,10 @@ TEST(ModMatchExpression, ElemMatchKey) { } TEST(ModMatchExpression, Equality1) { - ModMatchExpression m1; - ModMatchExpression m2; - ModMatchExpression m3; - ModMatchExpression m4; - - m1.init("a", 1, 2).transitional_ignore(); - m2.init("a", 2, 2).transitional_ignore(); - m3.init("a", 1, 1).transitional_ignore(); - m4.init("b", 1, 2).transitional_ignore(); + ModMatchExpression m1("a", 1, 2); + ModMatchExpression m2("a", 2, 2); + ModMatchExpression m3("a", 1, 1); + ModMatchExpression m4("b", 1, 2); ASSERT(m1.equivalent(&m1)); ASSERT(!m1.equivalent(&m2)); @@ -1257,24 +963,11 @@ TEST(ModMatchExpression, Equality1) { ASSERT(!m1.equivalent(&m4)); } -/** - TEST( ModMatchExpression, MatchesIndexKey ) { - BSONObj operand = BSON( "$mod" << BSON_ARRAY( 2 << 1 ) ); - ModMatchExpression mod; - ASSERT( mod.init( "a", operand[ "$mod" ] ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - BSONObj indexKey = BSON( "" << 1 ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - mod.matchesIndexKey( indexKey, indexSpec ) ); - } -*/ - TEST(ExistsMatchExpression, MatchesElement) { BSONObj existsInt = BSON("a" << 5); BSONObj existsNull = BSON("a" << BSONNULL); BSONObj doesntExist = BSONObj(); - ExistsMatchExpression exists; - ASSERT(exists.init("").isOK()); + ExistsMatchExpression exists(""); ASSERT(exists.matchesSingleElement(existsInt.firstElement())); ASSERT(exists.matchesSingleElement(existsNull.firstElement())); ASSERT(!exists.matchesSingleElement(doesntExist.firstElement())); @@ -1283,29 +976,25 @@ TEST(ExistsMatchExpression, MatchesElement) { TEST(ExistsMatchExpression, MatchesElementExistsTrueValue) { BSONObj exists = BSON("a" << 5); BSONObj missing = BSONObj(); - ExistsMatchExpression existsTrueValue; - ASSERT(existsTrueValue.init("").isOK()); + ExistsMatchExpression existsTrueValue(""); ASSERT(existsTrueValue.matchesSingleElement(exists.firstElement())); ASSERT(!existsTrueValue.matchesSingleElement(missing.firstElement())); } TEST(ExistsMatchExpression, MatchesScalar) { - ExistsMatchExpression exists; - ASSERT(exists.init("a").isOK()); + ExistsMatchExpression exists("a"); ASSERT(exists.matchesBSON(BSON("a" << 1), NULL)); ASSERT(exists.matchesBSON(BSON("a" << BSONNULL), NULL)); ASSERT(!exists.matchesBSON(BSON("b" << 1), NULL)); } TEST(ExistsMatchExpression, MatchesArray) { - ExistsMatchExpression exists; - ASSERT(exists.init("a").isOK()); + ExistsMatchExpression exists("a"); ASSERT(exists.matchesBSON(BSON("a" << BSON_ARRAY(4 << 5.5)), NULL)); } TEST(ExistsMatchExpression, ElemMatchKey) { - ExistsMatchExpression exists; - ASSERT(exists.init("a.b").isOK()); + ExistsMatchExpression exists("a.b"); MatchDetails details; details.requestElemMatchKey(); ASSERT(!exists.matchesBSON(BSON("a" << 1), &details)); @@ -1318,10 +1007,8 @@ TEST(ExistsMatchExpression, ElemMatchKey) { } TEST(ExistsMatchExpression, Equivalent) { - ExistsMatchExpression e1; - ExistsMatchExpression e2; - e1.init("a").transitional_ignore(); - e2.init("b").transitional_ignore(); + ExistsMatchExpression e1("a"); + ExistsMatchExpression e2("b"); ASSERT(e1.equivalent(&e1)); ASSERT(!e1.equivalent(&e2)); @@ -1331,7 +1018,7 @@ TEST(InMatchExpression, MatchesElementSingle) { BSONArray operand = BSON_ARRAY(1); BSONObj match = BSON("a" << 1); BSONObj notMatch = BSON("a" << 2); - InMatchExpression in; + InMatchExpression in(""); std::vector<BSONElement> equalities{operand.firstElement()}; ASSERT_OK(in.setEqualities(std::move(equalities))); ASSERT(in.matchesSingleElement(match["a"])); @@ -1339,8 +1026,7 @@ TEST(InMatchExpression, MatchesElementSingle) { } TEST(InMatchExpression, MatchesEmpty) { - InMatchExpression in; - in.init("a").transitional_ignore(); + InMatchExpression in("a"); BSONObj notMatch = BSON("a" << 2); ASSERT(!in.matchesSingleElement(notMatch["a"])); @@ -1350,7 +1036,7 @@ TEST(InMatchExpression, MatchesEmpty) { TEST(InMatchExpression, MatchesElementMultiple) { BSONObj operand = BSON_ARRAY(1 << "r" << true << 1); - InMatchExpression in; + InMatchExpression in(""); std::vector<BSONElement> equalities{operand[0], operand[1], operand[2], operand[3]}; ASSERT_OK(in.setEqualities(std::move(equalities))); @@ -1368,8 +1054,7 @@ TEST(InMatchExpression, MatchesElementMultiple) { TEST(InMatchExpression, MatchesScalar) { BSONObj operand = BSON_ARRAY(5); - InMatchExpression in; - in.init("a").transitional_ignore(); + InMatchExpression in("a"); std::vector<BSONElement> equalities{operand.firstElement()}; ASSERT_OK(in.setEqualities(std::move(equalities))); @@ -1379,8 +1064,7 @@ TEST(InMatchExpression, MatchesScalar) { TEST(InMatchExpression, MatchesArrayValue) { BSONObj operand = BSON_ARRAY(5); - InMatchExpression in; - in.init("a").transitional_ignore(); + InMatchExpression in("a"); std::vector<BSONElement> equalities{operand.firstElement()}; ASSERT_OK(in.setEqualities(std::move(equalities))); @@ -1392,8 +1076,7 @@ TEST(InMatchExpression, MatchesArrayValue) { TEST(InMatchExpression, MatchesNull) { BSONObj operand = BSON_ARRAY(BSONNULL); - InMatchExpression in; - in.init("a").transitional_ignore(); + InMatchExpression in("a"); std::vector<BSONElement> equalities{operand.firstElement()}; ASSERT_OK(in.setEqualities(std::move(equalities))); @@ -1407,16 +1090,14 @@ TEST(InMatchExpression, MatchesNull) { TEST(InMatchExpression, MatchesUndefined) { BSONObj operand = BSON_ARRAY(BSONUndefined); - InMatchExpression in; - in.init("a").transitional_ignore(); + InMatchExpression in("a"); std::vector<BSONElement> equalities{operand.firstElement()}; ASSERT_NOT_OK(in.setEqualities(std::move(equalities))); } TEST(InMatchExpression, MatchesMinKey) { BSONObj operand = BSON_ARRAY(MinKey); - InMatchExpression in; - in.init("a").transitional_ignore(); + InMatchExpression in("a"); std::vector<BSONElement> equalities{operand.firstElement()}; ASSERT_OK(in.setEqualities(std::move(equalities))); @@ -1427,8 +1108,7 @@ TEST(InMatchExpression, MatchesMinKey) { TEST(InMatchExpression, MatchesMaxKey) { BSONObj operand = BSON_ARRAY(MaxKey); - InMatchExpression in; - in.init("a").transitional_ignore(); + InMatchExpression in("a"); std::vector<BSONElement> equalities{operand.firstElement()}; ASSERT_OK(in.setEqualities(std::move(equalities))); @@ -1439,8 +1119,7 @@ TEST(InMatchExpression, MatchesMaxKey) { TEST(InMatchExpression, MatchesFullArray) { BSONObj operand = BSON_ARRAY(BSON_ARRAY(1 << 2) << 4 << 5); - InMatchExpression in; - in.init("a").transitional_ignore(); + InMatchExpression in("a"); std::vector<BSONElement> equalities{operand[0], operand[1], operand[2]}; ASSERT_OK(in.setEqualities(std::move(equalities))); @@ -1452,8 +1131,7 @@ TEST(InMatchExpression, MatchesFullArray) { TEST(InMatchExpression, ElemMatchKey) { BSONObj operand = BSON_ARRAY(5 << 2); - InMatchExpression in; - in.init("a").transitional_ignore(); + InMatchExpression in("a"); std::vector<BSONElement> equalities{operand[0], operand[1]}; ASSERT_OK(in.setEqualities(std::move(equalities))); @@ -1471,8 +1149,8 @@ TEST(InMatchExpression, ElemMatchKey) { TEST(InMatchExpression, InMatchExpressionsWithDifferentNumbersOfElementsAreUnequal) { BSONObj obj = BSON("" << "string"); - InMatchExpression eq1; - InMatchExpression eq2; + InMatchExpression eq1(""); + InMatchExpression eq2(""); std::vector<BSONElement> equalities{obj.firstElement()}; ASSERT_OK(eq1.setEqualities(std::move(equalities))); ASSERT(!eq1.equivalent(&eq2)); @@ -1480,20 +1158,20 @@ TEST(InMatchExpression, InMatchExpressionsWithDifferentNumbersOfElementsAreUnequ TEST(InMatchExpression, InMatchExpressionsWithUnequalCollatorsAreUnequal) { CollatorInterfaceMock collator1(CollatorInterfaceMock::MockType::kReverseString); - InMatchExpression eq1; + InMatchExpression eq1(""); eq1.setCollator(&collator1); CollatorInterfaceMock collator2(CollatorInterfaceMock::MockType::kAlwaysEqual); - InMatchExpression eq2; + InMatchExpression eq2(""); eq2.setCollator(&collator2); ASSERT(!eq1.equivalent(&eq2)); } TEST(InMatchExpression, InMatchExpressionsWithEqualCollatorsAreEqual) { CollatorInterfaceMock collator1(CollatorInterfaceMock::MockType::kAlwaysEqual); - InMatchExpression eq1; + InMatchExpression eq1(""); eq1.setCollator(&collator1); CollatorInterfaceMock collator2(CollatorInterfaceMock::MockType::kAlwaysEqual); - InMatchExpression eq2; + InMatchExpression eq2(""); eq2.setCollator(&collator2); ASSERT(eq1.equivalent(&eq2)); } @@ -1504,10 +1182,10 @@ TEST(InMatchExpression, InMatchExpressionsWithCollationEquivalentElementsAreEqua BSONObj obj2 = BSON("" << "string2"); CollatorInterfaceMock collator1(CollatorInterfaceMock::MockType::kAlwaysEqual); - InMatchExpression eq1; + InMatchExpression eq1(""); eq1.setCollator(&collator1); CollatorInterfaceMock collator2(CollatorInterfaceMock::MockType::kAlwaysEqual); - InMatchExpression eq2; + InMatchExpression eq2(""); eq2.setCollator(&collator2); std::vector<BSONElement> equalities1{obj1.firstElement()}; @@ -1525,10 +1203,10 @@ TEST(InMatchExpression, InMatchExpressionsWithCollationNonEquivalentElementsAreU BSONObj obj2 = BSON("" << "string2"); CollatorInterfaceMock collator1(CollatorInterfaceMock::MockType::kReverseString); - InMatchExpression eq1; + InMatchExpression eq1(""); eq1.setCollator(&collator1); CollatorInterfaceMock collator2(CollatorInterfaceMock::MockType::kReverseString); - InMatchExpression eq2; + InMatchExpression eq2(""); eq2.setCollator(&collator2); std::vector<BSONElement> equalities1{obj1.firstElement()}; @@ -1544,7 +1222,7 @@ TEST(InMatchExpression, StringMatchingWithNullCollatorUsesBinaryComparison) { BSONArray operand = BSON_ARRAY("string"); BSONObj notMatch = BSON("a" << "string2"); - InMatchExpression in; + InMatchExpression in(""); std::vector<BSONElement> equalities{operand.firstElement()}; ASSERT_OK(in.setEqualities(std::move(equalities))); ASSERT(!in.matchesSingleElement(notMatch["a"])); @@ -1555,7 +1233,7 @@ TEST(InMatchExpression, StringMatchingRespectsCollation) { BSONObj match = BSON("a" << "string2"); CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual); - InMatchExpression in; + InMatchExpression in(""); in.setCollator(&collator); std::vector<BSONElement> equalities{operand.firstElement()}; ASSERT_OK(in.setEqualities(std::move(equalities))); @@ -1569,7 +1247,7 @@ TEST(InMatchExpression, ChangingCollationAfterAddingEqualitiesPreservesEqualitie << "string2"); CollatorInterfaceMock collatorAlwaysEqual(CollatorInterfaceMock::MockType::kAlwaysEqual); CollatorInterfaceMock collatorReverseString(CollatorInterfaceMock::MockType::kReverseString); - InMatchExpression in; + InMatchExpression in(""); in.setCollator(&collatorAlwaysEqual); std::vector<BSONElement> equalities{obj1.firstElement(), obj2.firstElement()}; ASSERT_OK(in.setEqualities(std::move(equalities))); @@ -1605,15 +1283,11 @@ TEST(BitTestMatchExpression, DoesNotMatchOther) { BSONObj notMatch9 = fromjson("{a: ObjectId('000000000000000000000000')}"); // OID BSONObj notMatch10 = fromjson("{a: Date(54)}"); // Date - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitPositions); + BitsAllClearMatchExpression ballc("a", bitPositions); + BitsAnySetMatchExpression banys("a", bitPositions); + BitsAnyClearMatchExpression banyc("a", bitPositions); - ASSERT_OK(balls.init("a", bitPositions)); - ASSERT_OK(ballc.init("a", bitPositions)); - ASSERT_OK(banys.init("a", bitPositions)); - ASSERT_OK(banyc.init("a", bitPositions)); ASSERT_EQ((size_t)0, balls.numBitPositions()); ASSERT_EQ((size_t)0, ballc.numBitPositions()); ASSERT_EQ((size_t)0, banys.numBitPositions()); @@ -1665,15 +1339,11 @@ TEST(BitTestMatchExpression, MatchBinaryWithLongBitMask) { BSONObj match = fromjson("{a: {$binary: 'NgAAAAAAAAAAAAAAAAAAAAAAAAAA', $type: '00'}}"); - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitMask); + BitsAllClearMatchExpression ballc("a", bitMask); + BitsAnySetMatchExpression banys("a", bitMask); + BitsAnyClearMatchExpression banyc("a", bitMask); - ASSERT_OK(balls.init("a", bitMask)); - ASSERT_OK(ballc.init("a", bitMask)); - ASSERT_OK(banys.init("a", bitMask)); - ASSERT_OK(banyc.init("a", bitMask)); std::vector<uint32_t> bitPositions = balls.getBitPositions(); ASSERT(balls.matchesSingleElement(match["a"])); ASSERT(!ballc.matchesSingleElement(match["a"])); @@ -1687,15 +1357,11 @@ TEST(BitTestMatchExpression, MatchLongWithBinaryBitMask) { BSONObj match = fromjson("{a: 54}"); - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitMaskSet, 4); + BitsAllClearMatchExpression ballc("a", bitMaskClear, 9); + BitsAnySetMatchExpression banys("a", bitMaskSet, 4); + BitsAnyClearMatchExpression banyc("a", bitMaskClear, 9); - ASSERT_OK(balls.init("a", bitMaskSet, 4)); - ASSERT_OK(ballc.init("a", bitMaskClear, 9)); - ASSERT_OK(banys.init("a", bitMaskSet, 4)); - ASSERT_OK(banyc.init("a", bitMaskClear, 9)); ASSERT(balls.matchesSingleElement(match["a"])); ASSERT(ballc.matchesSingleElement(match["a"])); ASSERT(banys.matchesSingleElement(match["a"])); @@ -1710,15 +1376,11 @@ TEST(BitTestMatchExpression, MatchesEmpty) { BSONObj match3 = fromjson("{a: 54.0}"); BSONObj match4 = fromjson("{a: {$binary: '2AAAAAAAAAAAAAAAAAAAAAAAAAAA', $type: '00'}}"); - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitPositions); + BitsAllClearMatchExpression ballc("a", bitPositions); + BitsAnySetMatchExpression banys("a", bitPositions); + BitsAnyClearMatchExpression banyc("a", bitPositions); - ASSERT_OK(balls.init("a", bitPositions)); - ASSERT_OK(ballc.init("a", bitPositions)); - ASSERT_OK(banys.init("a", bitPositions)); - ASSERT_OK(banyc.init("a", bitPositions)); ASSERT_EQ((size_t)0, balls.numBitPositions()); ASSERT_EQ((size_t)0, ballc.numBitPositions()); ASSERT_EQ((size_t)0, banys.numBitPositions()); @@ -1751,15 +1413,11 @@ TEST(BitTestMatchExpression, MatchesInteger) { BSONObj match2 = fromjson("{a: NumberLong(54)}"); BSONObj match3 = fromjson("{a: 54.0}"); - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitPositionsSet); + BitsAllClearMatchExpression ballc("a", bitPositionsClear); + BitsAnySetMatchExpression banys("a", bitPositionsSet); + BitsAnyClearMatchExpression banyc("a", bitPositionsClear); - ASSERT_OK(balls.init("a", bitPositionsSet)); - ASSERT_OK(ballc.init("a", bitPositionsClear)); - ASSERT_OK(banys.init("a", bitPositionsSet)); - ASSERT_OK(banyc.init("a", bitPositionsClear)); ASSERT_EQ((size_t)4, balls.numBitPositions()); ASSERT_EQ((size_t)3, ballc.numBitPositions()); ASSERT_EQ((size_t)4, banys.numBitPositions()); @@ -1788,15 +1446,11 @@ TEST(BitTestMatchExpression, MatchesNegativeInteger) { BSONObj match2 = fromjson("{a: NumberLong(-54)}"); BSONObj match3 = fromjson("{a: -54.0}"); - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitPositionsSet); + BitsAllClearMatchExpression ballc("a", bitPositionsClear); + BitsAnySetMatchExpression banys("a", bitPositionsSet); + BitsAnyClearMatchExpression banyc("a", bitPositionsClear); - ASSERT_OK(balls.init("a", bitPositionsSet)); - ASSERT_OK(ballc.init("a", bitPositionsClear)); - ASSERT_OK(banys.init("a", bitPositionsSet)); - ASSERT_OK(banyc.init("a", bitPositionsClear)); ASSERT_EQ((size_t)5, balls.numBitPositions()); ASSERT_EQ((size_t)4, ballc.numBitPositions()); ASSERT_EQ((size_t)5, banys.numBitPositions()); @@ -1823,15 +1477,11 @@ TEST(BitTestMatchExpression, MatchesIntegerWithBitMask) { BSONObj match2 = fromjson("{a: NumberLong(54)}"); BSONObj match3 = fromjson("{a: 54.0}"); - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitMaskSet); + BitsAllClearMatchExpression ballc("a", bitMaskClear); + BitsAnySetMatchExpression banys("a", bitMaskSet); + BitsAnyClearMatchExpression banyc("a", bitMaskClear); - ASSERT_OK(balls.init("a", bitMaskSet)); - ASSERT_OK(ballc.init("a", bitMaskClear)); - ASSERT_OK(banys.init("a", bitMaskSet)); - ASSERT_OK(banyc.init("a", bitMaskClear)); ASSERT(balls.matchesSingleElement(match1["a"])); ASSERT(balls.matchesSingleElement(match2["a"])); ASSERT(balls.matchesSingleElement(match3["a"])); @@ -1854,15 +1504,11 @@ TEST(BitTestMatchExpression, MatchesNegativeIntegerWithBitMask) { BSONObj match2 = fromjson("{a: NumberLong(-54)}"); BSONObj match3 = fromjson("{a: -54.0}"); - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitMaskSet); + BitsAllClearMatchExpression ballc("a", bitMaskClear); + BitsAnySetMatchExpression banys("a", bitMaskSet); + BitsAnyClearMatchExpression banyc("a", bitMaskClear); - ASSERT_OK(balls.init("a", bitMaskSet)); - ASSERT_OK(ballc.init("a", bitMaskClear)); - ASSERT_OK(banys.init("a", bitMaskSet)); - ASSERT_OK(banyc.init("a", bitMaskClear)); ASSERT(balls.matchesSingleElement(match1["a"])); ASSERT(balls.matchesSingleElement(match2["a"])); ASSERT(balls.matchesSingleElement(match3["a"])); @@ -1887,15 +1533,11 @@ TEST(BitTestMatchExpression, DoesNotMatchInteger) { BSONObj match2 = fromjson("{a: NumberLong(54)}"); BSONObj match3 = fromjson("{a: 54.0}"); - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitPositionsSet); + BitsAllClearMatchExpression ballc("a", bitPositionsClear); + BitsAnySetMatchExpression banys("a", bitPositionsSet); + BitsAnyClearMatchExpression banyc("a", bitPositionsClear); - ASSERT_OK(balls.init("a", bitPositionsSet)); - ASSERT_OK(ballc.init("a", bitPositionsClear)); - ASSERT_OK(banys.init("a", bitPositionsSet)); - ASSERT_OK(banyc.init("a", bitPositionsClear)); ASSERT_EQ((size_t)5, balls.numBitPositions()); ASSERT_EQ((size_t)3, ballc.numBitPositions()); ASSERT_EQ((size_t)5, banys.numBitPositions()); @@ -1922,15 +1564,11 @@ TEST(BitTestMatchExpression, DoesNotMatchIntegerWithBitMask) { BSONObj match2 = fromjson("{a: NumberLong(54)}"); BSONObj match3 = fromjson("{a: 54.0}"); - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitMaskSet); + BitsAllClearMatchExpression ballc("a", bitMaskClear); + BitsAnySetMatchExpression banys("a", bitMaskSet); + BitsAnyClearMatchExpression banyc("a", bitMaskClear); - ASSERT_OK(balls.init("a", bitMaskSet)); - ASSERT_OK(ballc.init("a", bitMaskClear)); - ASSERT_OK(banys.init("a", bitMaskSet)); - ASSERT_OK(banyc.init("a", bitMaskClear)); ASSERT(!balls.matchesSingleElement(match1["a"])); ASSERT(!balls.matchesSingleElement(match2["a"])); ASSERT(!balls.matchesSingleElement(match3["a"])); @@ -1956,15 +1594,11 @@ TEST(BitTestMatchExpression, MatchesBinary1) { BSONObj match2 = fromjson("{a: {$binary: 'NgAjqwetkqwklEWRbWERKKJREtbq', $type: '00'}}"); // Base64 to Binary: 00110110... - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitPositionsSet); + BitsAllClearMatchExpression ballc("a", bitPositionsClear); + BitsAnySetMatchExpression banys("a", bitPositionsSet); + BitsAnyClearMatchExpression banyc("a", bitPositionsClear); - ASSERT_OK(balls.init("a", bitPositionsSet)); - ASSERT_OK(ballc.init("a", bitPositionsClear)); - ASSERT_OK(banys.init("a", bitPositionsSet)); - ASSERT_OK(banyc.init("a", bitPositionsClear)); ASSERT_EQ((size_t)4, balls.numBitPositions()); ASSERT_EQ((size_t)3, ballc.numBitPositions()); ASSERT_EQ((size_t)4, banys.numBitPositions()); @@ -1990,15 +1624,11 @@ TEST(BitTestMatchExpression, MatchesBinary2) { BSONObj match2 = fromjson("{a: {$binary: 'JANgqwetkqwklEWRbWERKKJREtbq', $type: '00'}}"); // Base64 to Binary: ........ 00000011 01100000 - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitPositionsSet); + BitsAllClearMatchExpression ballc("a", bitPositionsClear); + BitsAnySetMatchExpression banys("a", bitPositionsSet); + BitsAnyClearMatchExpression banyc("a", bitPositionsClear); - ASSERT_OK(balls.init("a", bitPositionsSet)); - ASSERT_OK(ballc.init("a", bitPositionsClear)); - ASSERT_OK(banys.init("a", bitPositionsSet)); - ASSERT_OK(banyc.init("a", bitPositionsClear)); ASSERT_EQ((size_t)4, balls.numBitPositions()); ASSERT_EQ((size_t)3, ballc.numBitPositions()); ASSERT_EQ((size_t)4, banys.numBitPositions()); @@ -2022,14 +1652,11 @@ TEST(BitTestMatchExpression, MatchesBinaryWithBitMask) { BSONObj match2 = fromjson("{a: {$binary: 'JANgAwetkqwklEWRbWERKKJREtbq', $type: '00'}}"); // Base64 to Binary: ........ 00000011 01100000 - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; - ASSERT_OK(balls.init("a", bas, 21)); - ASSERT_OK(ballc.init("a", bac, 21)); - ASSERT_OK(banys.init("a", bas, 21)); - ASSERT_OK(banyc.init("a", bac, 21)); + BitsAllSetMatchExpression balls("a", bas, 21); + BitsAllClearMatchExpression ballc("a", bac, 21); + BitsAnySetMatchExpression banys("a", bas, 21); + BitsAnyClearMatchExpression banyc("a", bac, 21); + ASSERT(balls.matchesSingleElement(match1["a"])); ASSERT(balls.matchesSingleElement(match2["a"])); ASSERT(ballc.matchesSingleElement(match1["a"])); @@ -2051,15 +1678,11 @@ TEST(BitTestMatchExpression, DoesNotMatchBinary1) { BSONObj match2 = fromjson("{a: {$binary: 'NgAjqwetkqwklEWRbWERKKJREtbq', $type: '00'}}"); // Base64 to Binary: 00110110... - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitPositionsSet); + BitsAllClearMatchExpression ballc("a", bitPositionsClear); + BitsAnySetMatchExpression banys("a", bitPositionsSet); + BitsAnyClearMatchExpression banyc("a", bitPositionsClear); - ASSERT_OK(balls.init("a", bitPositionsSet)); - ASSERT_OK(ballc.init("a", bitPositionsClear)); - ASSERT_OK(banys.init("a", bitPositionsSet)); - ASSERT_OK(banyc.init("a", bitPositionsClear)); ASSERT_EQ((size_t)5, balls.numBitPositions()); ASSERT_EQ((size_t)3, ballc.numBitPositions()); ASSERT_EQ((size_t)5, banys.numBitPositions()); @@ -2085,15 +1708,11 @@ TEST(BitTestMatchExpression, DoesNotMatchBinary2) { BSONObj match2 = fromjson("{a: {$binary: 'JANgqwetkqwklEWRbWERKKJREtbq', $type: '00'}}"); // Base64 to Binary: ........ 00000011 01100000 - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; + BitsAllSetMatchExpression balls("a", bitPositionsSet); + BitsAllClearMatchExpression ballc("a", bitPositionsClear); + BitsAnySetMatchExpression banys("a", bitPositionsSet); + BitsAnyClearMatchExpression banyc("a", bitPositionsClear); - ASSERT_OK(balls.init("a", bitPositionsSet)); - ASSERT_OK(ballc.init("a", bitPositionsClear)); - ASSERT_OK(banys.init("a", bitPositionsSet)); - ASSERT_OK(banyc.init("a", bitPositionsClear)); ASSERT_EQ((size_t)5, balls.numBitPositions()); ASSERT_EQ((size_t)3, ballc.numBitPositions()); ASSERT_EQ((size_t)5, banys.numBitPositions()); @@ -2117,14 +1736,10 @@ TEST(BitTestMatchExpression, DoesNotMatchBinaryWithBitMask) { BSONObj match2 = fromjson("{a: {$binary: 'JANgAwetkqwklEWRbWERKKJREtbq', $type: '00'}}"); // Base64 to Binary: ........ 00000011 01100000 - BitsAllSetMatchExpression balls; - BitsAllClearMatchExpression ballc; - BitsAnySetMatchExpression banys; - BitsAnyClearMatchExpression banyc; - ASSERT_OK(balls.init("a", bas, 22)); - ASSERT_OK(ballc.init("a", bac, 22)); - ASSERT_OK(banys.init("a", bas, 22)); - ASSERT_OK(banyc.init("a", bac, 22)); + BitsAllSetMatchExpression balls("a", bas, 22); + BitsAllClearMatchExpression ballc("a", bac, 22); + BitsAnySetMatchExpression banys("a", bas, 22); + BitsAnyClearMatchExpression banyc("a", bac, 22); ASSERT(!balls.matchesSingleElement(match1["a"])); ASSERT(!balls.matchesSingleElement(match2["a"])); ASSERT(!ballc.matchesSingleElement(match1["a"])); diff --git a/src/mongo/db/matcher/expression_optimize_test.cpp b/src/mongo/db/matcher/expression_optimize_test.cpp index acbd7bc4ecb..93f7a49882f 100644 --- a/src/mongo/db/matcher/expression_optimize_test.cpp +++ b/src/mongo/db/matcher/expression_optimize_test.cpp @@ -339,7 +339,7 @@ TEST(ExpressionOptimizeTest, NormalizeWithInAndRegexPreservesTags) { TEST(ExpressionOptimizeTest, NormalizeWithInPreservesCollator) { CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kReverseString); BSONObj obj = fromjson("{'': 'string'}"); - auto inMatchExpression = stdx::make_unique<InMatchExpression>(); + auto inMatchExpression = stdx::make_unique<InMatchExpression>(""); inMatchExpression->setCollator(&collator); std::vector<BSONElement> equalities{obj.firstElement()}; ASSERT_OK(inMatchExpression->setEqualities(std::move(equalities))); diff --git a/src/mongo/db/matcher/expression_parser.cpp b/src/mongo/db/matcher/expression_parser.cpp index 6e7098a9b75..aad03b33342 100644 --- a/src/mongo/db/matcher/expression_parser.cpp +++ b/src/mongo/db/matcher/expression_parser.cpp @@ -218,37 +218,25 @@ StatusWithMatchExpression parseRegexElement(StringData name, BSONElement e) { if (e.type() != BSONType::RegEx) return {Status(ErrorCodes::BadValue, "not a regex")}; - auto temp = stdx::make_unique<RegexMatchExpression>(); - auto s = temp->init(name, e.regex(), e.regexFlags()); - if (!s.isOK()) - return s; - return {std::move(temp)}; + return {stdx::make_unique<RegexMatchExpression>(name, e.regex(), e.regexFlags())}; } StatusWithMatchExpression parseComparison( StringData name, - ComparisonMatchExpression* cmp, + std::unique_ptr<ComparisonMatchExpression> cmp, BSONElement e, const boost::intrusive_ptr<ExpressionContext>& expCtx, MatchExpressionParser::AllowedFeatureSet allowedFeatures) { - std::unique_ptr<ComparisonMatchExpression> temp(cmp); - // Non-equality comparison match expressions cannot have a regular expression as the argument. // (e.g. {a: {$gt: /b/}} is illegal). if (MatchExpression::EQ != cmp->matchType() && BSONType::RegEx == e.type()) { - return {Status(ErrorCodes::BadValue, - str::stream() << "Can't have RegEx as arg to predicate over field '" << name - << "'.")}; - } - - auto s = temp->init(name, e); - if (!s.isOK()) { - return s; + return {ErrorCodes::BadValue, + str::stream() << "Can't have RegEx as arg to predicate over field '" << name + << "'."}; } - temp->setCollator(expCtx->getCollator()); - - return {std::move(temp)}; + cmp->setCollator(expCtx->getCollator()); + return {std::move(cmp)}; } /** @@ -391,8 +379,12 @@ StatusWithMatchExpression parse(const BSONObj& obj, continue; } - auto eq = parseComparison( - e.fieldNameStringData(), new EqualityMatchExpression(), e, expCtx, allowedFeatures); + auto eq = + parseComparison(e.fieldNameStringData(), + stdx::make_unique<EqualityMatchExpression>(e.fieldNameStringData(), e), + e, + expCtx, + allowedFeatures); if (!eq.isOK()) return eq; @@ -467,11 +459,8 @@ StatusWithMatchExpression parseDBRef(StringData name, const ExtensionsCallback* extensionsCallback, MatchExpressionParser::AllowedFeatureSet allowedFeatures, DocumentParseLevel currentLevel) { - auto eq = stdx::make_unique<EqualityMatchExpression>(); - auto s = eq->init(elem.fieldName(), elem); - if (!s.isOK()) { - return s; - } + auto eq = stdx::make_unique<EqualityMatchExpression>(elem.fieldName(), elem); + // 'id' is collation-aware. 'ref' and 'db' are compared using binary comparison. eq->setCollator("id"_sd == name ? expCtx->getCollator() : nullptr); @@ -556,11 +545,7 @@ StatusWithMatchExpression parseMOD(StringData name, BSONElement e) { if (i.more()) return {Status(ErrorCodes::BadValue, "malformed mod, too many elements")}; - auto temp = stdx::make_unique<ModMatchExpression>(); - auto s = temp->init(name, d.numberInt(), r.numberInt()); - if (!s.isOK()) - return s; - return {std::move(temp)}; + return {stdx::make_unique<ModMatchExpression>(name, d.numberInt(), r.numberInt())}; } StatusWithMatchExpression parseRegexDocument(StringData name, const BSONObj& doc) { @@ -595,11 +580,7 @@ StatusWithMatchExpression parseRegexDocument(StringData name, const BSONObj& doc } } - auto temp = stdx::make_unique<RegexMatchExpression>(); - auto s = temp->init(name, regex, regexOptions); - if (!s.isOK()) - return s; - return {std::move(temp)}; + return {stdx::make_unique<RegexMatchExpression>(name, regex, regexOptions)}; } Status parseInExpression(InMatchExpression* inExpression, @@ -614,13 +595,10 @@ Status parseInExpression(InMatchExpression* inExpression, } if (e.type() == BSONType::RegEx) { - auto r = stdx::make_unique<RegexMatchExpression>(); - auto s = r->init("", e); - if (!s.isOK()) - return s; - s = inExpression->addRegex(std::move(r)); - if (!s.isOK()) - return s; + auto status = inExpression->addRegex(stdx::make_unique<RegexMatchExpression>(""_sd, e)); + if (!status.isOK()) { + return status; + } } else { equalities.push_back(e); } @@ -635,19 +613,12 @@ StatusWithMatchExpression parseType(StringData name, BSONElement elt) { return typeSet.getStatus(); } - auto typeExpr = stdx::make_unique<T>(); - if (typeSet.getValue().isEmpty()) { return {Status(ErrorCodes::FailedToParse, - str::stream() << typeExpr->name() << " must match at least one type")}; - } - - auto status = typeExpr->init(name, std::move(typeSet.getValue())); - if (!status.isOK()) { - return status; + str::stream() << name << " must match at least one type")}; } - return {std::move(typeExpr)}; + return {stdx::make_unique<T>(name, std::move(typeSet.getValue()))}; } /** @@ -722,41 +693,27 @@ StatusWith<std::vector<uint32_t>> parseBitPositionsArray(const BSONObj& theArray */ template <class T> StatusWithMatchExpression parseBitTest(StringData name, BSONElement e) { - auto bitTestMatchExpression = stdx::make_unique<T>(); + std::unique_ptr<BitTestMatchExpression> bitTestMatchExpression; if (e.type() == BSONType::Array) { // Array of bit positions provided as value. - auto statusWithBitPositions = parseBitPositionsArray(e.Obj()); - if (!statusWithBitPositions.isOK()) { - return statusWithBitPositions.getStatus(); - } - - std::vector<uint32_t> bitPositions = statusWithBitPositions.getValue(); - auto s = bitTestMatchExpression->init(name, bitPositions); - if (!s.isOK()) { - return s; + auto bitPositions = parseBitPositionsArray(e.Obj()); + if (!bitPositions.isOK()) { + return bitPositions.getStatus(); } + bitTestMatchExpression = stdx::make_unique<T>(name, std::move(bitPositions.getValue())); } else if (e.isNumber()) { // Integer bitmask provided as value. auto bitMask = MatchExpressionParser::parseIntegerElementToNonNegativeLong(e); if (!bitMask.isOK()) { return bitMask.getStatus(); } - - auto s = bitTestMatchExpression->init(name, bitMask.getValue()); - if (!s.isOK()) { - return s; - } + bitTestMatchExpression = stdx::make_unique<T>(name, bitMask.getValue()); } else if (e.type() == BSONType::BinData) { // Binary bitmask provided as value. - int eBinaryLen; auto eBinary = e.binData(eBinaryLen); - - auto s = bitTestMatchExpression->init(name, eBinary, eBinaryLen); - if (!s.isOK()) { - return s; - } + bitTestMatchExpression = stdx::make_unique<T>(name, eBinary, eBinaryLen); } else { return Status( ErrorCodes::BadValue, @@ -767,35 +724,36 @@ StatusWithMatchExpression parseBitTest(StringData name, BSONElement e) { } StatusWithMatchExpression parseInternalSchemaFmod(StringData name, BSONElement elem) { - auto path(name); + StringData path(name); if (elem.type() != BSONType::Array) return {ErrorCodes::BadValue, str::stream() << path << " must be an array, but got type " << elem.type()}; BSONObjIterator i(elem.embeddedObject()); - - if (!i.more()) + if (!i.more()) { return {ErrorCodes::BadValue, str::stream() << path << " does not have enough elements"}; + } auto d = i.next(); - if (!d.isNumber()) + if (!d.isNumber()) { return {ErrorCodes::TypeMismatch, str::stream() << path << " does not have a numeric divisor"}; + } - if (!i.more()) + if (!i.more()) { return {ErrorCodes::BadValue, str::stream() << path << " does not have enough elements"}; + } auto r = i.next(); - if (!d.isNumber()) + if (!d.isNumber()) { return {ErrorCodes::TypeMismatch, str::stream() << path << " does not have a numeric remainder"}; + } - if (i.more()) + if (i.more()) { return {ErrorCodes::BadValue, str::stream() << path << " has too many elements"}; + } - auto result = stdx::make_unique<InternalSchemaFmodMatchExpression>(); - auto s = result->init(name, d.numberDecimal(), r.numberDecimal()); - if (!s.isOK()) - return s; - return {std::move(result)}; + return {stdx::make_unique<InternalSchemaFmodMatchExpression>( + name, d.numberDecimal(), r.numberDecimal())}; } StatusWithMatchExpression parseInternalSchemaRootDocEq( @@ -817,8 +775,8 @@ StatusWithMatchExpression parseInternalSchemaRootDocEq( << " must be an object, found type " << elem.type())}; } - auto rootDocEq = stdx::make_unique<InternalSchemaRootDocEqMatchExpression>(); - rootDocEq->init(elem.embeddedObject()); + auto rootDocEq = + stdx::make_unique<InternalSchemaRootDocEqMatchExpression>(elem.embeddedObject()); return {std::move(rootDocEq)}; } @@ -834,13 +792,7 @@ StatusWithMatchExpression parseInternalSchemaSingleIntegerArgument(StringData na return parsedInt.getStatus(); } - auto matchExpression = stdx::make_unique<T>(); - auto status = matchExpression->init(name, parsedInt.getValue()); - if (!status.isOK()) { - return status; - } - - return {std::move(matchExpression)}; + return {stdx::make_unique<T>(name, parsedInt.getValue())}; } /** @@ -859,12 +811,7 @@ StatusWithMatchExpression parseTopLevelInternalSchemaSingleIntegerArgument( if (!parsedInt.isOK()) { return parsedInt.getStatus(); } - auto matchExpression = stdx::make_unique<T>(); - auto status = matchExpression->init(parsedInt.getValue()); - if (!status.isOK()) { - return status; - } - return {std::move(matchExpression)}; + return {stdx::make_unique<T>(parsedInt.getValue())}; } /** @@ -1102,17 +1049,11 @@ StatusWithMatchExpression parseInternalSchemaAllowedProperties( return properties.getStatus(); } - auto allowedPropertiesExpr = - stdx::make_unique<InternalSchemaAllowedPropertiesMatchExpression>(); - auto status = allowedPropertiesExpr->init(std::move(properties.getValue()), - namePlaceholder.getValue(), - std::move(patternProperties.getValue()), - std::move(otherwise.getValue())); - if (!status.isOK()) { - return status; - } - - return {std::move(allowedPropertiesExpr)}; + return {stdx::make_unique<InternalSchemaAllowedPropertiesMatchExpression>( + std::move(properties.getValue()), + namePlaceholder.getValue(), + std::move(patternProperties.getValue()), + std::move(otherwise.getValue()))}; } /** @@ -1163,13 +1104,8 @@ StatusWithMatchExpression parseInternalSchemaMatchArrayIndex( return expressionWithPlaceholder.getStatus(); } - auto matchArrayIndexExpr = stdx::make_unique<InternalSchemaMatchArrayIndexMatchExpression>(); - auto initStatus = matchArrayIndexExpr->init( - path, index.getValue(), std::move(expressionWithPlaceholder.getValue())); - if (!initStatus.isOK()) { - return initStatus; - } - return {std::move(matchArrayIndexExpr)}; + return {stdx::make_unique<InternalSchemaMatchArrayIndexMatchExpression>( + path, index.getValue(), std::move(expressionWithPlaceholder.getValue()))}; } StatusWithMatchExpression parseGeo(StringData name, @@ -1179,16 +1115,10 @@ StatusWithMatchExpression parseGeo(StringData name, if (PathAcceptingKeyword::WITHIN == type || PathAcceptingKeyword::GEO_INTERSECTS == type) { auto gq = stdx::make_unique<GeoExpression>(name.toString()); auto parseStatus = gq->parseFrom(section); - - if (!parseStatus.isOK()) - return StatusWithMatchExpression(parseStatus); - - auto e = stdx::make_unique<GeoMatchExpression>(); - - auto s = e->init(name, gq.release(), section); - if (!s.isOK()) - return StatusWithMatchExpression(s); - return {std::move(e)}; + if (!parseStatus.isOK()) { + return parseStatus; + } + return {stdx::make_unique<GeoMatchExpression>(name, gq.release(), section)}; } else { invariant(PathAcceptingKeyword::GEO_NEAR == type); @@ -1198,15 +1128,11 @@ StatusWithMatchExpression parseGeo(StringData name, } auto nq = stdx::make_unique<GeoNearExpression>(name.toString()); - auto s = nq->parseFrom(section); - if (!s.isOK()) { - return StatusWithMatchExpression(s); + auto status = nq->parseFrom(section); + if (!status.isOK()) { + return status; } - auto e = stdx::make_unique<GeoNearMatchExpression>(); - s = e->init(name, nq.release(), section); - if (!s.isOK()) - return StatusWithMatchExpression(s); - return {std::move(e)}; + return {stdx::make_unique<GeoNearMatchExpression>(name, nq.release(), section)}; } } @@ -1283,10 +1209,7 @@ StatusWithMatchExpression parseElemMatch(StringData name, if (!s.isOK()) return s; - auto temp = stdx::make_unique<ElemMatchValueMatchExpression>(); - s = temp->init(name); - if (!s.isOK()) - return s; + auto temp = stdx::make_unique<ElemMatchValueMatchExpression>(name); for (size_t i = 0; i < theAnd.numChildren(); i++) { temp->add(theAnd.getChild(i)); @@ -1314,12 +1237,7 @@ StatusWithMatchExpression parseElemMatch(StringData name, return {Status(ErrorCodes::BadValue, "$elemMatch cannot contain $where expression")}; } - auto temp = stdx::make_unique<ElemMatchObjectMatchExpression>(); - auto status = temp->init(name, sub.release()); - if (!status.isOK()) - return status; - - return {std::move(temp)}; + return {stdx::make_unique<ElemMatchObjectMatchExpression>(name, sub.release())}; } StatusWithMatchExpression parseAll(StringData name, @@ -1369,21 +1287,15 @@ StatusWithMatchExpression parseAll(StringData name, auto e = i.next(); if (e.type() == BSONType::RegEx) { - auto r = stdx::make_unique<RegexMatchExpression>(); - auto s = r->init(name, e); - if (!s.isOK()) - return s; - myAnd->add(r.release()); + auto expr = stdx::make_unique<RegexMatchExpression>(name, e); + myAnd->add(expr.release()); } else if (e.type() == BSONType::Object && MatchExpressionParser::parsePathAcceptingKeyword(e.Obj().firstElement())) { return {Status(ErrorCodes::BadValue, "no $ expressions in $all")}; } else { - auto x = stdx::make_unique<EqualityMatchExpression>(); - auto s = x->init(name, e); - if (!s.isOK()) - return s; - x->setCollator(expCtx->getCollator()); - myAnd->add(x.release()); + auto expr = stdx::make_unique<EqualityMatchExpression>(name, e); + expr->setCollator(expCtx->getCollator()); + myAnd->add(expr.release()); } } @@ -1442,9 +1354,7 @@ StatusWithMatchExpression parseInternalSchemaFixedArityArgument( ++position; } - auto parsedExpression = stdx::make_unique<T>(); - parsedExpression->init(std::move(expressions)); - return {std::move(parsedExpression)}; + return {stdx::make_unique<T>(std::move(expressions))}; } StatusWithMatchExpression parseNot(StringData name, @@ -1454,39 +1364,36 @@ StatusWithMatchExpression parseNot(StringData name, MatchExpressionParser::AllowedFeatureSet allowedFeatures, DocumentParseLevel currentLevel) { if (elem.type() == BSONType::RegEx) { - auto s = parseRegexElement(name, elem); - if (!s.isOK()) - return s; - auto n = stdx::make_unique<NotMatchExpression>(); - auto s2 = n->init(s.getValue().release()); - if (!s2.isOK()) - return StatusWithMatchExpression(s2); - return {std::move(n)}; + auto regex = parseRegexElement(name, elem); + if (!regex.isOK()) { + return regex; + } + return {stdx::make_unique<NotMatchExpression>(regex.getValue().release())}; } - if (elem.type() != BSONType::Object) - return StatusWithMatchExpression(ErrorCodes::BadValue, "$not needs a regex or a document"); + if (elem.type() != BSONType::Object) { + return {ErrorCodes::BadValue, "$not needs a regex or a document"}; + } auto notObject = elem.Obj(); - if (notObject.isEmpty()) - return StatusWithMatchExpression(ErrorCodes::BadValue, "$not cannot be empty"); + if (notObject.isEmpty()) { + return {ErrorCodes::BadValue, "$not cannot be empty"}; + } auto theAnd = stdx::make_unique<AndMatchExpression>(); - auto s = parseSub( + auto parseStatus = parseSub( name, notObject, theAnd.get(), expCtx, extensionsCallback, allowedFeatures, currentLevel); - if (!s.isOK()) - return StatusWithMatchExpression(s); - - for (size_t i = 0; i < theAnd->numChildren(); i++) - if (theAnd->getChild(i)->matchType() == MatchExpression::REGEX) - return StatusWithMatchExpression(ErrorCodes::BadValue, "$not cannot have a regex"); + if (!parseStatus.isOK()) { + return parseStatus; + } - auto theNot = stdx::make_unique<NotMatchExpression>(); - s = theNot->init(theAnd.release()); - if (!s.isOK()) - return StatusWithMatchExpression(s); + for (size_t i = 0; i < theAnd->numChildren(); i++) { + if (theAnd->getChild(i)->matchType() == MatchExpression::REGEX) { + return {ErrorCodes::BadValue, "$not cannot have a regex"}; + } + } - return {std::move(theNot)}; + return {stdx::make_unique<NotMatchExpression>(theAnd.release())}; } /** @@ -1503,7 +1410,8 @@ StatusWithMatchExpression parseSubField(const BSONObj& context, MatchExpressionParser::AllowedFeatureSet allowedFeatures, DocumentParseLevel currentLevel) { if ("$eq"_sd == e.fieldNameStringData()) { - return parseComparison(name, new EqualityMatchExpression(), e, expCtx, allowedFeatures); + return parseComparison( + name, stdx::make_unique<EqualityMatchExpression>(name, e), e, expCtx, allowedFeatures); } if ("$not"_sd == e.fieldNameStringData()) { @@ -1523,62 +1431,60 @@ StatusWithMatchExpression parseSubField(const BSONObj& context, switch (*parseExpMatchType) { case PathAcceptingKeyword::LESS_THAN: - return parseComparison(name, new LTMatchExpression(), e, expCtx, allowedFeatures); + return parseComparison( + name, stdx::make_unique<LTMatchExpression>(name, e), e, expCtx, allowedFeatures); case PathAcceptingKeyword::LESS_THAN_OR_EQUAL: - return parseComparison(name, new LTEMatchExpression(), e, expCtx, allowedFeatures); + return parseComparison( + name, stdx::make_unique<LTEMatchExpression>(name, e), e, expCtx, allowedFeatures); case PathAcceptingKeyword::GREATER_THAN: - return parseComparison(name, new GTMatchExpression(), e, expCtx, allowedFeatures); + return parseComparison( + name, stdx::make_unique<GTMatchExpression>(name, e), e, expCtx, allowedFeatures); case PathAcceptingKeyword::GREATER_THAN_OR_EQUAL: - return parseComparison(name, new GTEMatchExpression(), e, expCtx, allowedFeatures); + return parseComparison( + name, stdx::make_unique<GTEMatchExpression>(name, e), e, expCtx, allowedFeatures); case PathAcceptingKeyword::NOT_EQUAL: { if (BSONType::RegEx == e.type()) { // Just because $ne can be rewritten as the negation of an equality does not mean // that $ne of a regex is allowed. See SERVER-1705. return {Status(ErrorCodes::BadValue, "Can't have regex as arg to $ne.")}; } - auto s = - parseComparison(name, new EqualityMatchExpression(), e, expCtx, allowedFeatures); - if (!s.isOK()) - return s; - auto n = stdx::make_unique<NotMatchExpression>(); - auto s2 = n->init(s.getValue().release()); - if (!s2.isOK()) - return s2; - return {std::move(n)}; + StatusWithMatchExpression s = + parseComparison(name, + stdx::make_unique<EqualityMatchExpression>(name, e), + e, + expCtx, + allowedFeatures); + return {stdx::make_unique<NotMatchExpression>(s.getValue().release())}; } case PathAcceptingKeyword::EQUALITY: - return parseComparison(name, new EqualityMatchExpression(), e, expCtx, allowedFeatures); + return parseComparison(name, + stdx::make_unique<EqualityMatchExpression>(name, e), + e, + expCtx, + allowedFeatures); case PathAcceptingKeyword::IN_EXPR: { - if (e.type() != BSONType::Array) + if (e.type() != BSONType::Array) { return {Status(ErrorCodes::BadValue, "$in needs an array")}; - auto temp = stdx::make_unique<InMatchExpression>(); - auto s = temp->init(name); - if (!s.isOK()) - return s; - s = parseInExpression(temp.get(), e.Obj(), expCtx); - if (!s.isOK()) - return s; + } + auto temp = stdx::make_unique<InMatchExpression>(name); + auto parseStatus = parseInExpression(temp.get(), e.Obj(), expCtx); + if (!parseStatus.isOK()) { + return parseStatus; + } return {std::move(temp)}; } case PathAcceptingKeyword::NOT_IN: { - if (e.type() != BSONType::Array) + if (e.type() != Array) { return {Status(ErrorCodes::BadValue, "$nin needs an array")}; - auto temp = stdx::make_unique<InMatchExpression>(); - auto s = temp->init(name); - if (!s.isOK()) - return s; - s = parseInExpression(temp.get(), e.Obj(), expCtx); - if (!s.isOK()) - return s; - - auto temp2 = stdx::make_unique<NotMatchExpression>(); - s = temp2->init(temp.release()); - if (!s.isOK()) - return s; - - return {std::move(temp2)}; + } + auto temp = stdx::make_unique<InMatchExpression>(name); + auto parseStatus = parseInExpression(temp.get(), e.Obj(), expCtx); + if (!parseStatus.isOK()) { + return parseStatus; + } + return {stdx::make_unique<NotMatchExpression>(temp.release())}; } case PathAcceptingKeyword::SIZE: { @@ -1601,31 +1507,24 @@ StatusWithMatchExpression parseSubField(const BSONObj& context, } else { return {Status(ErrorCodes::BadValue, "$size needs a number")}; } + if (size < 0) { return {Status(ErrorCodes::BadValue, "$size may not be negative")}; } - - auto temp = stdx::make_unique<SizeMatchExpression>(); - auto s = temp->init(name, size); - if (!s.isOK()) - return s; - return {std::move(temp)}; + return {stdx::make_unique<SizeMatchExpression>(name, size)}; } case PathAcceptingKeyword::EXISTS: { - if (!e) + if (e.eoo()) { return {Status(ErrorCodes::BadValue, "$exists can't be eoo")}; - auto temp = stdx::make_unique<ExistsMatchExpression>(); - auto s = temp->init(name); - if (!s.isOK()) - return s; - if (e.trueValue()) - return {std::move(temp)}; - auto temp2 = stdx::make_unique<NotMatchExpression>(); - s = temp2->init(temp.release()); - if (!s.isOK()) - return s; - return {std::move(temp2)}; + } + + auto existsExpr = stdx::make_unique<ExistsMatchExpression>(name); + if (e.trueValue()) { + return {std::move(existsExpr)}; + } + + return {stdx::make_unique<NotMatchExpression>(existsExpr.release())}; } case PathAcceptingKeyword::TYPE: @@ -1711,12 +1610,8 @@ StatusWithMatchExpression parseSubField(const BSONObj& context, return parsedSubObjExpr; } - auto expr = stdx::make_unique<InternalSchemaObjectMatchExpression>(); - auto status = expr->init(std::move(parsedSubObjExpr.getValue()), name); - if (!status.isOK()) { - return status; - } - return {std::move(expr)}; + return {stdx::make_unique<InternalSchemaObjectMatchExpression>( + name, std::move(parsedSubObjExpr.getValue()))}; } case PathAcceptingKeyword::INTERNAL_SCHEMA_UNIQUE_ITEMS: { @@ -1725,12 +1620,7 @@ StatusWithMatchExpression parseSubField(const BSONObj& context, str::stream() << name << " must be a boolean of value true"}; } - auto expr = stdx::make_unique<InternalSchemaUniqueItemsMatchExpression>(); - auto status = expr->init(name); - if (!status.isOK()) { - return status; - } - return {std::move(expr)}; + return {stdx::make_unique<InternalSchemaUniqueItemsMatchExpression>(name)}; } case PathAcceptingKeyword::INTERNAL_SCHEMA_MIN_LENGTH: { @@ -1808,14 +1698,8 @@ StatusWithMatchExpression parseSubField(const BSONObj& context, if (!exprWithPlaceholder.isOK()) { return exprWithPlaceholder.getStatus(); } - - auto expr = stdx::make_unique<InternalSchemaAllElemMatchFromIndexMatchExpression>(); - auto status = - expr->init(name, parsedIndex.getValue(), std::move(exprWithPlaceholder.getValue())); - if (!status.isOK()) { - return status; - } - return {std::move(expr)}; + return {stdx::make_unique<InternalSchemaAllElemMatchFromIndexMatchExpression>( + name, parsedIndex.getValue(), std::move(exprWithPlaceholder.getValue()))}; } case PathAcceptingKeyword::INTERNAL_SCHEMA_TYPE: { @@ -1823,12 +1707,7 @@ StatusWithMatchExpression parseSubField(const BSONObj& context, } case PathAcceptingKeyword::INTERNAL_SCHEMA_EQ: { - auto eqExpr = stdx::make_unique<InternalSchemaEqMatchExpression>(); - auto status = eqExpr->init(name, e); - if (!status.isOK()) { - return status; - } - return {std::move(eqExpr)}; + return {stdx::make_unique<InternalSchemaEqMatchExpression>(name, e)}; } } diff --git a/src/mongo/db/matcher/expression_parser_tree.cpp b/src/mongo/db/matcher/expression_parser_tree.cpp index 04680e16532..d8632e64fad 100644 --- a/src/mongo/db/matcher/expression_parser_tree.cpp +++ b/src/mongo/db/matcher/expression_parser_tree.cpp @@ -73,19 +73,16 @@ StatusWithMatchExpression MatchExpressionParser::_parseNot( StatusWithMatchExpression s = _parseRegexElement(name, e); if (!s.isOK()) return s; - std::unique_ptr<NotMatchExpression> n = stdx::make_unique<NotMatchExpression>(); - Status s2 = n->init(s.getValue().release()); - if (!s2.isOK()) - return StatusWithMatchExpression(s2); + std::unique_ptr<NotMatchExpression> n = + stdx::make_unique<NotMatchExpression>(s.getValue().release()); return {std::move(n)}; } - if (e.type() != Object) - return StatusWithMatchExpression(ErrorCodes::BadValue, "$not needs a regex or a document"); + uassert(ErrorCodes::BadValue, "$not needs a regex or a document", e.type() == Object); BSONObj notObject = e.Obj(); - if (notObject.isEmpty()) - return StatusWithMatchExpression(ErrorCodes::BadValue, "$not cannot be empty"); + + uassert(ErrorCodes::BadValue, "$not cannot be empty", !notObject.isEmpty()); std::unique_ptr<AndMatchExpression> theAnd = stdx::make_unique<AndMatchExpression>(); Status s = _parseSub(name, notObject, theAnd.get(), expCtx, allowedFeatures, currentLevel); @@ -98,10 +95,8 @@ StatusWithMatchExpression MatchExpressionParser::_parseNot( if (theAnd->getChild(i)->matchType() == MatchExpression::REGEX) return StatusWithMatchExpression(ErrorCodes::BadValue, "$not cannot have a regex"); - std::unique_ptr<NotMatchExpression> theNot = stdx::make_unique<NotMatchExpression>(); - s = theNot->init(theAnd.release()); - if (!s.isOK()) - return StatusWithMatchExpression(s); + std::unique_ptr<NotMatchExpression> theNot = + stdx::make_unique<NotMatchExpression>(theAnd.release()); return {std::move(theNot)}; } diff --git a/src/mongo/db/matcher/expression_path.h b/src/mongo/db/matcher/expression_path.h index 4fb98d84d62..b0a1ee5354c 100644 --- a/src/mongo/db/matcher/expression_path.h +++ b/src/mongo/db/matcher/expression_path.h @@ -41,7 +41,10 @@ namespace mongo { */ class PathMatchExpression : public MatchExpression { public: - PathMatchExpression(MatchType matchType) : MatchExpression(matchType) {} + explicit PathMatchExpression(MatchType matchType, StringData path) + : MatchExpression(matchType), _path(path) { + _elementPath.init(_path); + } virtual ~PathMatchExpression() {} @@ -74,15 +77,13 @@ public: return _path; } - Status setPath(StringData path) { + void setPath(StringData path) { _path = path; - auto status = _elementPath.init(_path); - if (!status.isOK()) { - return status; - } + _elementPath.init(_path); + } + void setTraverseLeafArray() { _elementPath.setTraverseLeafArray(shouldExpandLeafArray()); - return Status::OK(); } /** @@ -98,7 +99,7 @@ public: for (auto rename : renameList) { if (rename.first == _path) { _rewrittenPath = rename.second; - invariantOK(setPath(_rewrittenPath)); + setPath(_rewrittenPath); ++renamesFound; } @@ -112,7 +113,7 @@ public: // Replace the chopped off components with the component names resulting from the // rename. _rewrittenPath = str::stream() << rename.second << "." << pathTail.toString(); - invariantOK(setPath(_rewrittenPath)); + setPath(_rewrittenPath); ++renamesFound; } diff --git a/src/mongo/db/matcher/expression_test.cpp b/src/mongo/db/matcher/expression_test.cpp index 9b65644042d..a6d8bbec44d 100644 --- a/src/mongo/db/matcher/expression_test.cpp +++ b/src/mongo/db/matcher/expression_test.cpp @@ -42,8 +42,7 @@ namespace mongo { TEST(LeafMatchExpressionTest, Equal1) { BSONObj temp = BSON("x" << 5); - EqualityMatchExpression e; - e.init("x", temp["x"]).transitional_ignore(); + EqualityMatchExpression e("x", temp["x"]); ASSERT_TRUE(e.matchesBSON(fromjson("{ x : 5 }"))); ASSERT_TRUE(e.matchesBSON(fromjson("{ x : [5] }"))); @@ -61,8 +60,7 @@ TEST(LeafMatchExpressionTest, Comp1) { BSONObj temp = BSON("x" << 5); { - LTEMatchExpression e; - e.init("x", temp["x"]).transitional_ignore(); + LTEMatchExpression e("x", temp["x"]); ASSERT_TRUE(e.matchesBSON(fromjson("{ x : 5 }"))); ASSERT_TRUE(e.matchesBSON(fromjson("{ x : 4 }"))); ASSERT_FALSE(e.matchesBSON(fromjson("{ x : 6 }"))); @@ -70,8 +68,7 @@ TEST(LeafMatchExpressionTest, Comp1) { } { - LTMatchExpression e; - e.init("x", temp["x"]).transitional_ignore(); + LTMatchExpression e("x", temp["x"]); ASSERT_FALSE(e.matchesBSON(fromjson("{ x : 5 }"))); ASSERT_TRUE(e.matchesBSON(fromjson("{ x : 4 }"))); ASSERT_FALSE(e.matchesBSON(fromjson("{ x : 6 }"))); @@ -79,8 +76,7 @@ TEST(LeafMatchExpressionTest, Comp1) { } { - GTEMatchExpression e; - e.init("x", temp["x"]).transitional_ignore(); + GTEMatchExpression e("x", temp["x"]); ASSERT_TRUE(e.matchesBSON(fromjson("{ x : 5 }"))); ASSERT_FALSE(e.matchesBSON(fromjson("{ x : 4 }"))); ASSERT_TRUE(e.matchesBSON(fromjson("{ x : 6 }"))); @@ -88,8 +84,7 @@ TEST(LeafMatchExpressionTest, Comp1) { } { - GTMatchExpression e; - e.init("x", temp["x"]).transitional_ignore(); + GTMatchExpression e("x", temp["x"]); ASSERT_FALSE(e.matchesBSON(fromjson("{ x : 5 }"))); ASSERT_FALSE(e.matchesBSON(fromjson("{ x : 4 }"))); ASSERT_TRUE(e.matchesBSON(fromjson("{ x : 6 }"))); @@ -99,8 +94,7 @@ TEST(LeafMatchExpressionTest, Comp1) { TEST(MatchesBSONElement, ScalarEquality) { auto filterObj = fromjson("{i: 5}"); - EqualityMatchExpression filter; - ASSERT_OK(filter.init("i", filterObj["i"])); + EqualityMatchExpression filter("i", filterObj["i"]); auto aFive = fromjson("{a: 5}"); auto iFive = fromjson("{i: 5}"); @@ -140,8 +134,7 @@ TEST(MatchesBSONElement, ScalarEquality) { TEST(MatchesBSONElement, DottedPathEquality) { auto filterObj = fromjson("{'i.a': 5}"); - EqualityMatchExpression filter; - ASSERT_OK(filter.init("i.a", filterObj["i.a"])); + EqualityMatchExpression filter("i.a", filterObj["i.a"]); auto aFive = fromjson("{a: 5}"); auto iFive = fromjson("{i: 5}"); @@ -191,8 +184,7 @@ TEST(MatchesBSONElement, DottedPathEquality) { TEST(MatchesBSONElement, ArrayIndexEquality) { auto filterObj = fromjson("{'i.1': 5}"); - EqualityMatchExpression filter; - ASSERT_OK(filter.init("i.1", filterObj["i.1"])); + EqualityMatchExpression filter("i.1", filterObj["i.1"]); auto aFive = fromjson("{a: 5}"); auto iFive = fromjson("{i: 5}"); @@ -237,8 +229,7 @@ TEST(MatchesBSONElement, ArrayIndexEquality) { TEST(MatchesBSONElement, ObjectEquality) { auto filterObj = fromjson("{i: {a: 5}}"); - EqualityMatchExpression filter; - ASSERT_OK(filter.init("i", filterObj["i"])); + EqualityMatchExpression filter("i", filterObj["i"]); auto aFive = fromjson("{a: 5}"); auto iFive = fromjson("{i: 5}"); @@ -288,8 +279,7 @@ TEST(MatchesBSONElement, ObjectEquality) { TEST(MatchesBSONElement, ArrayEquality) { auto filterObj = fromjson("{i: [5]}"); - EqualityMatchExpression filter; - ASSERT_OK(filter.init("i", filterObj["i"])); + EqualityMatchExpression filter("i", filterObj["i"]); auto aFive = fromjson("{a: 5}"); auto iFive = fromjson("{i: 5}"); @@ -320,10 +310,10 @@ TEST(MatchesBSONElement, ArrayEquality) { TEST(MatchesBSONElement, LogicalExpression) { auto clauseObj1 = fromjson("{i: 5}"); auto clauseObj2 = fromjson("{'i.a': 6}"); - std::unique_ptr<ComparisonMatchExpression> clause1(new EqualityMatchExpression()); - ASSERT_OK(clause1->init("i", clauseObj1["i"])); - std::unique_ptr<ComparisonMatchExpression> clause2(new EqualityMatchExpression()); - ASSERT_OK(clause2->init("i.a", clauseObj2["i.a"])); + std::unique_ptr<ComparisonMatchExpression> clause1( + new EqualityMatchExpression("i", clauseObj1["i"])); + std::unique_ptr<ComparisonMatchExpression> clause2( + new EqualityMatchExpression("i.a", clauseObj2["i.a"])); OrMatchExpression filter; filter.add(clause1.release()); diff --git a/src/mongo/db/matcher/expression_text.cpp b/src/mongo/db/matcher/expression_text.cpp index 1719cda7a21..33c388bd607 100644 --- a/src/mongo/db/matcher/expression_text.cpp +++ b/src/mongo/db/matcher/expression_text.cpp @@ -42,9 +42,13 @@ namespace mongo { -Status TextMatchExpression::init(OperationContext* opCtx, - const NamespaceString& nss, - TextParams params) { +TextMatchExpression::TextMatchExpression(fts::FTSQueryImpl ftsQuery) + : TextMatchExpressionBase("_fts"), _ftsQuery(ftsQuery) {} + +TextMatchExpression::TextMatchExpression(OperationContext* opCtx, + const NamespaceString& nss, + TextParams params) + : TextMatchExpressionBase("_fts") { _ftsQuery.setQuery(std::move(params.query)); _ftsQuery.setLanguage(std::move(params.language)); _ftsQuery.setCaseSensitive(params.caseSensitive); @@ -56,28 +60,31 @@ Status TextMatchExpression::init(OperationContext* opCtx, AutoGetDb autoDb(opCtx, nss.db(), MODE_IS); Lock::CollectionLock collLock(opCtx->lockState(), nss.ns(), MODE_IS); Database* db = autoDb.getDb(); - if (!db) { - return {ErrorCodes::IndexNotFound, - str::stream() << "text index required for $text query (no such collection '" - << nss.ns() - << "')"}; - } + + uassert(ErrorCodes::IndexNotFound, + str::stream() << "text index required for $text query (no such collection '" + << nss.ns() + << "')", + db); + Collection* collection = db->getCollection(opCtx, nss); - if (!collection) { - return {ErrorCodes::IndexNotFound, - str::stream() << "text index required for $text query (no such collection '" - << nss.ns() - << "')"}; - } + + uassert(ErrorCodes::IndexNotFound, + str::stream() << "text index required for $text query (no such collection '" + << nss.ns() + << "')", + collection); + std::vector<IndexDescriptor*> idxMatches; collection->getIndexCatalog()->findIndexByType(opCtx, IndexNames::TEXT, idxMatches); - if (idxMatches.empty()) { - return {ErrorCodes::IndexNotFound, "text index required for $text query"}; - } - if (idxMatches.size() > 1) { - return {ErrorCodes::IndexNotFound, "more than one text index found for $text query"}; - } + + uassert( + ErrorCodes::IndexNotFound, "text index required for $text query", !idxMatches.empty()); + uassert(ErrorCodes::IndexNotFound, + "more than one text index found for $text query", + idxMatches.size() < 2); invariant(idxMatches.size() == 1); + IndexDescriptor* index = idxMatches[0]; const FTSAccessMethod* fam = static_cast<FTSAccessMethod*>(collection->getIndexCatalog()->getIndex(index)); @@ -91,19 +98,14 @@ Status TextMatchExpression::init(OperationContext* opCtx, } Status parseStatus = _ftsQuery.parse(version); - if (!parseStatus.isOK()) { - return parseStatus; - } - - return setPath("_fts"); + uassertStatusOK(parseStatus); } std::unique_ptr<MatchExpression> TextMatchExpression::shallowClone() const { - auto expr = stdx::make_unique<TextMatchExpression>(); - // We initialize _ftsQuery here directly rather than calling init(), to avoid needing to examine + auto expr = stdx::make_unique<TextMatchExpression>(_ftsQuery); + // We use the query-only constructor here directly rather than using the full constructor, to + // avoid needing to examine // the index catalog. - expr->_ftsQuery = _ftsQuery; - invariantOK(expr->setPath("_fts")); if (getTag()) { expr->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/expression_text.h b/src/mongo/db/matcher/expression_text.h index 2a3ac4a3c36..1bf453906bd 100644 --- a/src/mongo/db/matcher/expression_text.h +++ b/src/mongo/db/matcher/expression_text.h @@ -41,7 +41,8 @@ class OperationContext; class TextMatchExpression : public TextMatchExpressionBase { public: - Status init(OperationContext* opCtx, const NamespaceString& nss, TextParams params); + explicit TextMatchExpression(fts::FTSQueryImpl ftsQuery); + TextMatchExpression(OperationContext* opCtx, const NamespaceString& nss, TextParams params); const fts::FTSQuery& getFTSQuery() const final { return _ftsQuery; diff --git a/src/mongo/db/matcher/expression_text_base.cpp b/src/mongo/db/matcher/expression_text_base.cpp index 625107d4aca..925d2bbb7a0 100644 --- a/src/mongo/db/matcher/expression_text_base.cpp +++ b/src/mongo/db/matcher/expression_text_base.cpp @@ -37,7 +37,8 @@ namespace mongo { const bool TextMatchExpressionBase::kCaseSensitiveDefault = false; const bool TextMatchExpressionBase::kDiacriticSensitiveDefault = false; -TextMatchExpressionBase::TextMatchExpressionBase() : LeafMatchExpression(TEXT) {} +TextMatchExpressionBase::TextMatchExpressionBase(StringData path) + : LeafMatchExpression(TEXT, path) {} void TextMatchExpressionBase::debugString(StringBuilder& debug, int level) const { const fts::FTSQuery& ftsQuery = getFTSQuery(); diff --git a/src/mongo/db/matcher/expression_text_base.h b/src/mongo/db/matcher/expression_text_base.h index ac51e137ee1..8c34126888e 100644 --- a/src/mongo/db/matcher/expression_text_base.h +++ b/src/mongo/db/matcher/expression_text_base.h @@ -51,7 +51,7 @@ public: static const bool kCaseSensitiveDefault; static const bool kDiacriticSensitiveDefault; - TextMatchExpressionBase(); + explicit TextMatchExpressionBase(StringData path); virtual ~TextMatchExpressionBase() {} /** diff --git a/src/mongo/db/matcher/expression_text_noop.cpp b/src/mongo/db/matcher/expression_text_noop.cpp index 5e6ef901b5c..a42845d4e63 100644 --- a/src/mongo/db/matcher/expression_text_noop.cpp +++ b/src/mongo/db/matcher/expression_text_noop.cpp @@ -34,13 +34,13 @@ namespace mongo { -Status TextNoOpMatchExpression::init(TextParams params) { +TextNoOpMatchExpression::TextNoOpMatchExpression(TextParams params) + : TextMatchExpressionBase("_fts") { _ftsQuery.setQuery(std::move(params.query)); _ftsQuery.setLanguage(std::move(params.language)); _ftsQuery.setCaseSensitive(params.caseSensitive); _ftsQuery.setDiacriticSensitive(params.diacriticSensitive); invariantOK(_ftsQuery.parse(fts::TEXT_INDEX_VERSION_INVALID)); - return setPath("_fts"); } std::unique_ptr<MatchExpression> TextNoOpMatchExpression::shallowClone() const { @@ -50,8 +50,7 @@ std::unique_ptr<MatchExpression> TextNoOpMatchExpression::shallowClone() const { params.caseSensitive = _ftsQuery.getCaseSensitive(); params.diacriticSensitive = _ftsQuery.getDiacriticSensitive(); - auto expr = stdx::make_unique<TextNoOpMatchExpression>(); - invariantOK(expr->init(std::move(params))); + auto expr = stdx::make_unique<TextNoOpMatchExpression>(std::move(params)); if (getTag()) { expr->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/expression_text_noop.h b/src/mongo/db/matcher/expression_text_noop.h index 429fecff05d..3c2316595a9 100644 --- a/src/mongo/db/matcher/expression_text_noop.h +++ b/src/mongo/db/matcher/expression_text_noop.h @@ -35,7 +35,7 @@ namespace mongo { class TextNoOpMatchExpression : public TextMatchExpressionBase { public: - Status init(TextParams params); + explicit TextNoOpMatchExpression(TextParams params); const fts::FTSQuery& getFTSQuery() const final { return _ftsQuery; diff --git a/src/mongo/db/matcher/expression_tree.cpp b/src/mongo/db/matcher/expression_tree.cpp index df8ab0b4012..5e1a9f5d83d 100644 --- a/src/mongo/db/matcher/expression_tree.cpp +++ b/src/mongo/db/matcher/expression_tree.cpp @@ -122,8 +122,7 @@ MatchExpression::ExpressionOptimizerFunc ListOfMatchExpression::getOptimizer() c return std::unique_ptr<MatchExpression>(simplifiedExpression); } else if (matchType == NOR) { // Simplify NOR of exactly one operand to NOT of that operand. - auto simplifiedExpression = stdx::make_unique<NotMatchExpression>(); - invariantOK(simplifiedExpression->init(children.front())); + auto simplifiedExpression = stdx::make_unique<NotMatchExpression>(children.front()); children.clear(); return std::move(simplifiedExpression); } diff --git a/src/mongo/db/matcher/expression_tree.h b/src/mongo/db/matcher/expression_tree.h index 074ed6c728a..1368567e912 100644 --- a/src/mongo/db/matcher/expression_tree.h +++ b/src/mongo/db/matcher/expression_tree.h @@ -41,7 +41,7 @@ namespace mongo { class ListOfMatchExpression : public MatchExpression { public: - ListOfMatchExpression(MatchType type) : MatchExpression(type) {} + explicit ListOfMatchExpression(MatchType type) : MatchExpression(type) {} virtual ~ListOfMatchExpression(); /** @@ -187,19 +187,11 @@ public: class NotMatchExpression final : public MatchExpression { public: - NotMatchExpression() : MatchExpression(NOT) {} - NotMatchExpression(MatchExpression* e) : MatchExpression(NOT), _exp(e) {} - /** - * @param exp - I own it, and will delete - */ - virtual Status init(MatchExpression* exp) { - _exp.reset(exp); - return Status::OK(); - } + explicit NotMatchExpression(MatchExpression* e) : MatchExpression(NOT), _exp(e) {} virtual std::unique_ptr<MatchExpression> shallowClone() const { - std::unique_ptr<NotMatchExpression> self = stdx::make_unique<NotMatchExpression>(); - self->init(_exp->shallowClone().release()).transitional_ignore(); + std::unique_ptr<NotMatchExpression> self = + stdx::make_unique<NotMatchExpression>(_exp->shallowClone().release()); if (getTag()) { self->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/expression_tree_test.cpp b/src/mongo/db/matcher/expression_tree_test.cpp index 6b65006cdd1..54e85206d75 100644 --- a/src/mongo/db/matcher/expression_tree_test.cpp +++ b/src/mongo/db/matcher/expression_tree_test.cpp @@ -43,20 +43,16 @@ using std::unique_ptr; TEST(NotMatchExpression, MatchesScalar) { BSONObj baseOperand = BSON("$lt" << 5); - unique_ptr<ComparisonMatchExpression> lt(new LTMatchExpression()); - ASSERT(lt->init("a", baseOperand["$lt"]).isOK()); - NotMatchExpression notOp; - ASSERT(notOp.init(lt.release()).isOK()); + unique_ptr<ComparisonMatchExpression> lt(new LTMatchExpression("a", baseOperand["$lt"])); + NotMatchExpression notOp(lt.release()); ASSERT(notOp.matchesBSON(BSON("a" << 6), NULL)); ASSERT(!notOp.matchesBSON(BSON("a" << 4), NULL)); } TEST(NotMatchExpression, MatchesArray) { BSONObj baseOperand = BSON("$lt" << 5); - unique_ptr<ComparisonMatchExpression> lt(new LTMatchExpression()); - ASSERT(lt->init("a", baseOperand["$lt"]).isOK()); - NotMatchExpression notOp; - ASSERT(notOp.init(lt.release()).isOK()); + unique_ptr<ComparisonMatchExpression> lt(new LTMatchExpression("a", baseOperand["$lt"])); + NotMatchExpression notOp(lt.release()); ASSERT(notOp.matchesBSON(BSON("a" << BSON_ARRAY(6)), NULL)); ASSERT(!notOp.matchesBSON(BSON("a" << BSON_ARRAY(4)), NULL)); // All array elements must match. @@ -65,10 +61,8 @@ TEST(NotMatchExpression, MatchesArray) { TEST(NotMatchExpression, ElemMatchKey) { BSONObj baseOperand = BSON("$lt" << 5); - unique_ptr<ComparisonMatchExpression> lt(new LTMatchExpression()); - ASSERT(lt->init("a", baseOperand["$lt"]).isOK()); - NotMatchExpression notOp; - ASSERT(notOp.init(lt.release()).isOK()); + unique_ptr<ComparisonMatchExpression> lt(new LTMatchExpression("a", baseOperand["$lt"])); + NotMatchExpression notOp(lt.release()); MatchDetails details; details.requestElemMatchKey(); ASSERT(!notOp.matchesBSON(BSON("a" << BSON_ARRAY(1)), &details)); @@ -83,10 +77,8 @@ TEST(NotMatchExpression, ElemMatchKey) { TEST(NotMatchExpression, SetCollatorPropagatesToChild) { BSONObj baseOperand = BSON("a" << "string"); - unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression()); - ASSERT(eq->init("a", baseOperand["a"]).isOK()); - NotMatchExpression notOp; - ASSERT(notOp.init(eq.release()).isOK()); + unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression("a", baseOperand["a"])); + NotMatchExpression notOp(eq.release()); CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual); notOp.setCollator(&collator); ASSERT(!notOp.matchesBSON(BSON("a" @@ -94,36 +86,6 @@ TEST(NotMatchExpression, SetCollatorPropagatesToChild) { nullptr)); } -/* - TEST( NotMatchExpression, MatchesIndexKey ) { - BSONObj baseOperand = BSON( "$lt" << 5 ); - unique_ptr<ComparisonMatchExpression> lt( new ComparisonMatchExpression() ); - ASSERT( lt->init( "a", baseOperand[ "$lt" ] ).isOK() ); - NotMatchExpression notOp; - ASSERT( notOp.init( lt.release() ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - BSONObj indexKey = BSON( "" << "7" ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - notOp.matchesIndexKey( indexKey, indexSpec ) ); - } -*/ - -/** -TEST( AndOp, MatchesElementSingleClause ) { - BSONObj baseOperand = BSON( "$lt" << 5 ); - BSONObj match = BSON( "a" << 4 ); - BSONObj notMatch = BSON( "a" << 5 ); - unique_ptr<ComparisonMatchExpression> lt( new ComparisonMatchExpression() ); - ASSERT( lt->init( "", baseOperand[ "$lt" ] ).isOK() ); - std::vector<std::unique_ptr<<MatchMatchExpression>> subMatchExpressions; - subMatchExpressions.mutableVector().push_back( lt.release() ); - AndOp andOp; - ASSERT( andOp.init( &subMatchExpressions ).isOK() ); - ASSERT( andOp.matchesSingleElement( match[ "a" ] ) ); - ASSERT( !andOp.matchesSingleElement( notMatch[ "a" ] ) ); -} -*/ - TEST(AndOp, NoClauses) { AndMatchExpression andMatchExpression; ASSERT(andMatchExpression.matchesBSON(BSONObj(), NULL)); @@ -143,12 +105,9 @@ TEST(AndOp, MatchesElementThreeClauses) { BSONObj notMatch3 = BSON("a" << "r"); - unique_ptr<ComparisonMatchExpression> sub1(new LTMatchExpression()); - ASSERT(sub1->init("a", baseOperand1["$lt"]).isOK()); - unique_ptr<ComparisonMatchExpression> sub2(new GTMatchExpression()); - ASSERT(sub2->init("a", baseOperand2["$gt"]).isOK()); - unique_ptr<RegexMatchExpression> sub3(new RegexMatchExpression()); - ASSERT(sub3->init("a", "1", "").isOK()); + unique_ptr<ComparisonMatchExpression> sub1(new LTMatchExpression("a", baseOperand1["$lt"])); + unique_ptr<ComparisonMatchExpression> sub2(new GTMatchExpression("a", baseOperand2["$gt"])); + unique_ptr<RegexMatchExpression> sub3(new RegexMatchExpression("a", "1", "")); AndMatchExpression andOp; andOp.add(sub1.release()); @@ -163,10 +122,8 @@ TEST(AndOp, MatchesElementThreeClauses) { TEST(AndOp, MatchesSingleClause) { BSONObj baseOperand = BSON("$ne" << 5); - unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression()); - ASSERT(eq->init("a", baseOperand["$ne"]).isOK()); - unique_ptr<NotMatchExpression> ne(new NotMatchExpression()); - ASSERT(ne->init(eq.release()).isOK()); + unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression("a", baseOperand["$ne"])); + unique_ptr<NotMatchExpression> ne(new NotMatchExpression(eq.release())); AndMatchExpression andOp; andOp.add(ne.release()); @@ -182,14 +139,9 @@ TEST(AndOp, MatchesThreeClauses) { BSONObj baseOperand2 = BSON("$lt" << 10); BSONObj baseOperand3 = BSON("$lt" << 100); - unique_ptr<ComparisonMatchExpression> sub1(new GTMatchExpression()); - ASSERT(sub1->init("a", baseOperand1["$gt"]).isOK()); - - unique_ptr<ComparisonMatchExpression> sub2(new LTMatchExpression()); - ASSERT(sub2->init("a", baseOperand2["$lt"]).isOK()); - - unique_ptr<ComparisonMatchExpression> sub3(new LTMatchExpression()); - ASSERT(sub3->init("b", baseOperand3["$lt"]).isOK()); + unique_ptr<ComparisonMatchExpression> sub1(new GTMatchExpression("a", baseOperand1["$gt"])); + unique_ptr<ComparisonMatchExpression> sub2(new LTMatchExpression("a", baseOperand2["$lt"])); + unique_ptr<ComparisonMatchExpression> sub3(new LTMatchExpression("b", baseOperand3["$lt"])); AndMatchExpression andOp; andOp.add(sub1.release()); @@ -207,11 +159,8 @@ TEST(AndOp, ElemMatchKey) { BSONObj baseOperand1 = BSON("a" << 1); BSONObj baseOperand2 = BSON("b" << 2); - unique_ptr<ComparisonMatchExpression> sub1(new EqualityMatchExpression()); - ASSERT(sub1->init("a", baseOperand1["a"]).isOK()); - - unique_ptr<ComparisonMatchExpression> sub2(new EqualityMatchExpression()); - ASSERT(sub2->init("b", baseOperand2["b"]).isOK()); + unique_ptr<ComparisonMatchExpression> sub1(new EqualityMatchExpression("a", baseOperand1["a"])); + unique_ptr<ComparisonMatchExpression> sub2(new EqualityMatchExpression("b", baseOperand2["b"])); AndMatchExpression andOp; andOp.add(sub1.release()); @@ -229,108 +178,15 @@ TEST(AndOp, ElemMatchKey) { ASSERT_EQUALS("1", details.elemMatchKey()); } -/** -TEST( AndOp, MatchesIndexKeyWithoutUnknown ) { - BSONObj baseOperand1 = BSON( "$gt" << 1 ); - BSONObj baseOperand2 = BSON( "$lt" << 5 ); - unique_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() ); - ASSERT( sub1->init( "a", baseOperand1[ "$gt" ] ).isOK() ); - unique_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() ); - ASSERT( sub2->init( "a", baseOperand2[ "$lt" ] ).isOK() ); - std::vector<std::unique_ptr<<MatchMatchExpression>> subMatchExpressions; - subMatchExpressions.mutableVector().push_back( sub1.release() ); - subMatchExpressions.mutableVector().push_back( sub2.release() ); - AndOp andOp; - ASSERT( andOp.init( &subMatchExpressions ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - andOp.matchesIndexKey( BSON( "" << 3 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - andOp.matchesIndexKey( BSON( "" << 0 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - andOp.matchesIndexKey( BSON( "" << 6 ), indexSpec ) ); -} - -TEST( AndOp, MatchesIndexKeyWithUnknown ) { - BSONObj baseOperand1 = BSON( "$gt" << 1 ); - BSONObj baseOperand2 = BSON( "$lt" << 5 ); - // This part will return PartialMatchResult_Unknown. - BSONObj baseOperand3 = BSON( "$ne" << 5 ); - unique_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() ); - ASSERT( sub1->init( "a", baseOperand1[ "$gt" ] ).isOK() ); - unique_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() ); - ASSERT( sub2->init( "a", baseOperand2[ "$lt" ] ).isOK() ); - unique_ptr<NeOp> sub3( new NeOp() ); - ASSERT( sub3->init( "a", baseOperand3[ "$ne" ] ).isOK() ); - std::vector<std::unique_ptr<<MatchMatchExpression>> subMatchExpressions; - subMatchExpressions.mutableVector().push_back( sub1.release() ); - subMatchExpressions.mutableVector().push_back( sub2.release() ); - subMatchExpressions.mutableVector().push_back( sub3.release() ); - AndOp andOp; - ASSERT( andOp.init( &subMatchExpressions ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - andOp.matchesIndexKey( BSON( "" << 3 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - andOp.matchesIndexKey( BSON( "" << 0 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - andOp.matchesIndexKey( BSON( "" << 6 ), indexSpec ) ); -} -*/ - -/** -TEST( OrOp, MatchesElementSingleClause ) { - BSONObj baseOperand = BSON( "$lt" << 5 ); - BSONObj match = BSON( "a" << 4 ); - BSONObj notMatch = BSON( "a" << 5 ); - unique_ptr<ComparisonMatchExpression> lt( new ComparisonMatchExpression() ); - ASSERT( lt->init( "a", baseOperand[ "$lt" ] ).isOK() ); - std::vector<std::unique_ptr<<MatchMatchExpression>> subMatchExpressions; - subMatchExpressions.mutableVector().push_back( lt.release() ); - OrOp orOp; - ASSERT( orOp.init( &subMatchExpressions ).isOK() ); - ASSERT( orOp.matchesSingleElement( match[ "a" ] ) ); - ASSERT( !orOp.matchesSingleElement( notMatch[ "a" ] ) ); -} -*/ - TEST(OrOp, NoClauses) { OrMatchExpression orOp; ASSERT(!orOp.matchesBSON(BSONObj(), NULL)); } -/* -TEST( OrOp, MatchesElementThreeClauses ) { - BSONObj baseOperand1 = BSON( "$lt" << 0 ); - BSONObj baseOperand2 = BSON( "$gt" << 10 ); - BSONObj baseOperand3 = BSON( "a" << 5 ); - BSONObj match1 = BSON( "a" << -1 ); - BSONObj match2 = BSON( "a" << 11 ); - BSONObj match3 = BSON( "a" << 5 ); - BSONObj notMatch = BSON( "a" << "6" ); - unique_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() ); - ASSERT( sub1->init( "a", baseOperand1[ "$lt" ] ).isOK() ); - unique_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() ); - ASSERT( sub2->init( "a", baseOperand2[ "$gt" ] ).isOK() ); - unique_ptr<ComparisonMatchExpression> sub3( new ComparisonMatchExpression() ); - ASSERT( sub3->init( "a", baseOperand3[ "a" ] ).isOK() ); - std::vector<std::unique_ptr<<MatchMatchExpression>> subMatchExpressions; - subMatchExpressions.mutableVector().push_back( sub1.release() ); - subMatchExpressions.mutableVector().push_back( sub2.release() ); - subMatchExpressions.mutableVector().push_back( sub3.release() ); - OrOp orOp; - ASSERT( orOp.init( &subMatchExpressions ).isOK() ); - ASSERT( orOp.matchesSingleElement( match1[ "a" ] ) ); - ASSERT( orOp.matchesSingleElement( match2[ "a" ] ) ); - ASSERT( orOp.matchesSingleElement( match3[ "a" ] ) ); - ASSERT( !orOp.matchesSingleElement( notMatch[ "a" ] ) ); -} -*/ + TEST(OrOp, MatchesSingleClause) { BSONObj baseOperand = BSON("$ne" << 5); - unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression()); - ASSERT(eq->init("a", baseOperand["$ne"]).isOK()); - unique_ptr<NotMatchExpression> ne(new NotMatchExpression()); - ASSERT(ne->init(eq.release()).isOK()); + unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression("a", baseOperand["$ne"])); + unique_ptr<NotMatchExpression> ne(new NotMatchExpression(eq.release())); OrMatchExpression orOp; orOp.add(ne.release()); @@ -345,12 +201,9 @@ TEST(OrOp, MatchesThreeClauses) { BSONObj baseOperand1 = BSON("$gt" << 10); BSONObj baseOperand2 = BSON("$lt" << 0); BSONObj baseOperand3 = BSON("b" << 100); - unique_ptr<ComparisonMatchExpression> sub1(new GTMatchExpression()); - ASSERT(sub1->init("a", baseOperand1["$gt"]).isOK()); - unique_ptr<ComparisonMatchExpression> sub2(new LTMatchExpression()); - ASSERT(sub2->init("a", baseOperand2["$lt"]).isOK()); - unique_ptr<ComparisonMatchExpression> sub3(new EqualityMatchExpression()); - ASSERT(sub3->init("b", baseOperand3["b"]).isOK()); + unique_ptr<ComparisonMatchExpression> sub1(new GTMatchExpression("a", baseOperand1["$gt"])); + unique_ptr<ComparisonMatchExpression> sub2(new LTMatchExpression("a", baseOperand2["$lt"])); + unique_ptr<ComparisonMatchExpression> sub3(new EqualityMatchExpression("b", baseOperand3["b"])); OrMatchExpression orOp; orOp.add(sub1.release()); @@ -369,10 +222,8 @@ TEST(OrOp, MatchesThreeClauses) { TEST(OrOp, ElemMatchKey) { BSONObj baseOperand1 = BSON("a" << 1); BSONObj baseOperand2 = BSON("b" << 2); - unique_ptr<ComparisonMatchExpression> sub1(new EqualityMatchExpression()); - ASSERT(sub1->init("a", baseOperand1["a"]).isOK()); - unique_ptr<ComparisonMatchExpression> sub2(new EqualityMatchExpression()); - ASSERT(sub2->init("b", baseOperand2["b"]).isOK()); + unique_ptr<ComparisonMatchExpression> sub1(new EqualityMatchExpression("a", baseOperand1["a"])); + unique_ptr<ComparisonMatchExpression> sub2(new EqualityMatchExpression("b", baseOperand2["b"])); OrMatchExpression orOp; orOp.add(sub1.release()); @@ -389,109 +240,15 @@ TEST(OrOp, ElemMatchKey) { ASSERT(!details.hasElemMatchKey()); } -/** -TEST( OrOp, MatchesIndexKeyWithoutUnknown ) { - BSONObj baseOperand1 = BSON( "$gt" << 5 ); - BSONObj baseOperand2 = BSON( "$lt" << 1 ); - unique_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() ); - ASSERT( sub1->init( "a", baseOperand1[ "$gt" ] ).isOK() ); - unique_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() ); - ASSERT( sub2->init( "a", baseOperand2[ "$lt" ] ).isOK() ); - std::vector<std::unique_ptr<<MatchMatchExpression>> subMatchExpressions; - subMatchExpressions.mutableVector().push_back( sub1.release() ); - subMatchExpressions.mutableVector().push_back( sub2.release() ); - OrOp orOp; - ASSERT( orOp.init( &subMatchExpressions ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_False == - orOp.matchesIndexKey( BSON( "" << 3 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - orOp.matchesIndexKey( BSON( "" << 0 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - orOp.matchesIndexKey( BSON( "" << 6 ), indexSpec ) ); -} - -TEST( OrOp, MatchesIndexKeyWithUnknown ) { - BSONObj baseOperand1 = BSON( "$gt" << 5 ); - BSONObj baseOperand2 = BSON( "$lt" << 1 ); - // This part will return PartialMatchResult_Unknown. - BSONObj baseOperand3 = BSON( "$ne" << 5 ); - unique_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() ); - ASSERT( sub1->init( "a", baseOperand1[ "$gt" ] ).isOK() ); - unique_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() ); - ASSERT( sub2->init( "a", baseOperand2[ "$lt" ] ).isOK() ); - unique_ptr<NeOp> sub3( new NeOp() ); - ASSERT( sub3->init( "a", baseOperand3[ "$ne" ] ).isOK() ); - std::vector<std::unique_ptr<<MatchMatchExpression>> subMatchExpressions; - subMatchExpressions.mutableVector().push_back( sub1.release() ); - subMatchExpressions.mutableVector().push_back( sub2.release() ); - subMatchExpressions.mutableVector().push_back( sub3.release() ); - OrOp orOp; - ASSERT( orOp.init( &subMatchExpressions ).isOK() ); - IndexSpec indexSpec( BSON( "a" << 1 ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_Unknown == - orOp.matchesIndexKey( BSON( "" << 3 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - orOp.matchesIndexKey( BSON( "" << 0 ), indexSpec ) ); - ASSERT( MatchMatchExpression::PartialMatchResult_True == - orOp.matchesIndexKey( BSON( "" << 6 ), indexSpec ) ); -} -*/ - -/** -TEST( NorOp, MatchesElementSingleClause ) { - BSONObj baseOperand = BSON( "$lt" << 5 ); - BSONObj match = BSON( "a" << 5 ); - BSONObj notMatch = BSON( "a" << 4 ); - unique_ptr<ComparisonMatchExpression> lt( new ComparisonMatchExpression() ); - ASSERT( lt->init( "a", baseOperand[ "$lt" ] ).isOK() ); - std::vector<std::unique_ptr<<MatchMatchExpression>> subMatchExpressions; - subMatchExpressions.mutableVector().push_back( lt.release() ); - NorOp norOp; - ASSERT( norOp.init( &subMatchExpressions ).isOK() ); - ASSERT( norOp.matchesSingleElement( match[ "a" ] ) ); - ASSERT( !norOp.matchesSingleElement( notMatch[ "a" ] ) ); -} -*/ - TEST(NorOp, NoClauses) { NorMatchExpression norOp; ASSERT(norOp.matchesBSON(BSONObj(), NULL)); } -/* -TEST( NorOp, MatchesElementThreeClauses ) { - BSONObj baseOperand1 = BSON( "$lt" << 0 ); - BSONObj baseOperand2 = BSON( "$gt" << 10 ); - BSONObj baseOperand3 = BSON( "a" << 5 ); - BSONObj notMatch1 = BSON( "a" << -1 ); - BSONObj notMatch2 = BSON( "a" << 11 ); - BSONObj notMatch3 = BSON( "a" << 5 ); - BSONObj match = BSON( "a" << "6" ); - unique_ptr<ComparisonMatchExpression> sub1( new ComparisonMatchExpression() ); - ASSERT( sub1->init( "a", baseOperand1[ "$lt" ] ).isOK() ); - unique_ptr<ComparisonMatchExpression> sub2( new ComparisonMatchExpression() ); - ASSERT( sub2->init( "a", baseOperand2[ "$gt" ] ).isOK() ); - unique_ptr<ComparisonMatchExpression> sub3( new ComparisonMatchExpression() ); - ASSERT( sub3->init( "a", baseOperand3[ "a" ] ).isOK() ); - std::vector<std::unique_ptr<<MatchMatchExpression>> subMatchExpressions; - subMatchExpressions.mutableVector().push_back( sub1.release() ); - subMatchExpressions.mutableVector().push_back( sub2.release() ); - subMatchExpressions.mutableVector().push_back( sub3.release() ); - NorOp norOp; - ASSERT( norOp.init( &subMatchExpressions ).isOK() ); - ASSERT( !norOp.matchesSingleElement( notMatch1[ "a" ] ) ); - ASSERT( !norOp.matchesSingleElement( notMatch2[ "a" ] ) ); - ASSERT( !norOp.matchesSingleElement( notMatch3[ "a" ] ) ); - ASSERT( norOp.matchesSingleElement( match[ "a" ] ) ); -} -*/ TEST(NorOp, MatchesSingleClause) { BSONObj baseOperand = BSON("$ne" << 5); - unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression()); - ASSERT(eq->init("a", baseOperand["$ne"]).isOK()); - unique_ptr<NotMatchExpression> ne(new NotMatchExpression()); - ASSERT(ne->init(eq.release()).isOK()); + unique_ptr<ComparisonMatchExpression> eq(new EqualityMatchExpression("a", baseOperand["$ne"])); + unique_ptr<NotMatchExpression> ne(new NotMatchExpression(eq.release())); NorMatchExpression norOp; norOp.add(ne.release()); @@ -507,12 +264,9 @@ TEST(NorOp, MatchesThreeClauses) { BSONObj baseOperand2 = BSON("$lt" << 0); BSONObj baseOperand3 = BSON("b" << 100); - unique_ptr<ComparisonMatchExpression> sub1(new GTMatchExpression()); - ASSERT(sub1->init("a", baseOperand1["$gt"]).isOK()); - unique_ptr<ComparisonMatchExpression> sub2(new LTMatchExpression()); - ASSERT(sub2->init("a", baseOperand2["$lt"]).isOK()); - unique_ptr<ComparisonMatchExpression> sub3(new EqualityMatchExpression()); - ASSERT(sub3->init("b", baseOperand3["b"]).isOK()); + unique_ptr<ComparisonMatchExpression> sub1(new GTMatchExpression("a", baseOperand1["$gt"])); + unique_ptr<ComparisonMatchExpression> sub2(new LTMatchExpression("a", baseOperand2["$lt"])); + unique_ptr<ComparisonMatchExpression> sub3(new EqualityMatchExpression("b", baseOperand3["b"])); NorMatchExpression norOp; norOp.add(sub1.release()); @@ -531,10 +285,8 @@ TEST(NorOp, MatchesThreeClauses) { TEST(NorOp, ElemMatchKey) { BSONObj baseOperand1 = BSON("a" << 1); BSONObj baseOperand2 = BSON("b" << 2); - unique_ptr<ComparisonMatchExpression> sub1(new EqualityMatchExpression()); - ASSERT(sub1->init("a", baseOperand1["a"]).isOK()); - unique_ptr<ComparisonMatchExpression> sub2(new EqualityMatchExpression()); - ASSERT(sub2->init("b", baseOperand2["b"]).isOK()); + unique_ptr<ComparisonMatchExpression> sub1(new EqualityMatchExpression("a", baseOperand1["a"])); + unique_ptr<ComparisonMatchExpression> sub2(new EqualityMatchExpression("b", baseOperand2["b"])); NorMatchExpression norOp; norOp.add(sub1.release()); @@ -555,10 +307,8 @@ TEST(NorOp, ElemMatchKey) { TEST(NorOp, Equivalent) { BSONObj baseOperand1 = BSON("a" << 1); BSONObj baseOperand2 = BSON("b" << 2); - EqualityMatchExpression sub1; - ASSERT(sub1.init("a", baseOperand1["a"]).isOK()); - EqualityMatchExpression sub2; - ASSERT(sub2.init("b", baseOperand2["b"]).isOK()); + EqualityMatchExpression sub1("a", baseOperand1["a"]); + EqualityMatchExpression sub2("b", baseOperand2["b"]); NorMatchExpression e1; e1.add(sub1.shallowClone().release()); diff --git a/src/mongo/db/matcher/expression_type.h b/src/mongo/db/matcher/expression_type.h index c9ac6a2129d..9ccdbe62b63 100644 --- a/src/mongo/db/matcher/expression_type.h +++ b/src/mongo/db/matcher/expression_type.h @@ -36,7 +36,8 @@ namespace mongo { template <class T> class TypeMatchExpressionBase : public LeafMatchExpression { public: - explicit TypeMatchExpressionBase(MatchType matchType) : LeafMatchExpression(matchType) {} + explicit TypeMatchExpressionBase(MatchType matchType, StringData path, MatcherTypeSet typeSet) + : LeafMatchExpression(matchType, path), _typeSet(std::move(typeSet)) {} virtual ~TypeMatchExpressionBase() = default; @@ -45,14 +46,8 @@ public: */ virtual StringData name() const = 0; - Status init(StringData path, MatcherTypeSet typeSet) { - _typeSet = std::move(typeSet); - return setPath(path); - } - std::unique_ptr<MatchExpression> shallowClone() const final { - auto expr = stdx::make_unique<T>(); - invariantOK(expr->init(path(), _typeSet)); + auto expr = stdx::make_unique<T>(path(), _typeSet); if (getTag()) { expr->setTag(getTag()->clone()); } @@ -117,7 +112,8 @@ class TypeMatchExpression final : public TypeMatchExpressionBase<TypeMatchExpres public: static constexpr StringData kName = "$type"_sd; - TypeMatchExpression() : TypeMatchExpressionBase(MatchExpression::TYPE_OPERATOR) {} + TypeMatchExpression(StringData path, MatcherTypeSet typeSet) + : TypeMatchExpressionBase(MatchExpression::TYPE_OPERATOR, path, typeSet) {} StringData name() const final { return kName; @@ -134,8 +130,10 @@ class InternalSchemaTypeExpression final public: static constexpr StringData kName = "$_internalSchemaType"_sd; - InternalSchemaTypeExpression() - : TypeMatchExpressionBase(MatchExpression::INTERNAL_SCHEMA_TYPE) {} + InternalSchemaTypeExpression(StringData path, MatcherTypeSet typeSet) + : TypeMatchExpressionBase(MatchExpression::INTERNAL_SCHEMA_TYPE, path, typeSet) { + setTraverseLeafArray(); + } StringData name() const final { return kName; diff --git a/src/mongo/db/matcher/expression_type_test.cpp b/src/mongo/db/matcher/expression_type_test.cpp index 91c8c7429be..e50f30b9b45 100644 --- a/src/mongo/db/matcher/expression_type_test.cpp +++ b/src/mongo/db/matcher/expression_type_test.cpp @@ -37,8 +37,7 @@ TEST(ExpressionTypeTest, MatchesElementStringType) { BSONObj match = BSON("a" << "abc"); BSONObj notMatch = BSON("a" << 5); - TypeMatchExpression type; - ASSERT(type.init("", String).isOK()); + TypeMatchExpression type("", String); ASSERT(type.matchesSingleElement(match["a"])); ASSERT(!type.matchesSingleElement(notMatch["a"])); } @@ -47,8 +46,7 @@ TEST(ExpressionTypeTest, MatchesElementNullType) { BSONObj match = BSON("a" << BSONNULL); BSONObj notMatch = BSON("a" << "abc"); - TypeMatchExpression type; - ASSERT(type.init("", jstNULL).isOK()); + TypeMatchExpression type("", jstNULL); ASSERT(type.matchesSingleElement(match["a"])); ASSERT(!type.matchesSingleElement(notMatch["a"])); } @@ -63,10 +61,10 @@ TEST(ExpressionTypeTest, MatchesElementNumber) { ASSERT_EQ(BSONType::NumberLong, match2["a"].type()); ASSERT_EQ(BSONType::NumberDouble, match3["a"].type()); - TypeMatchExpression typeExpr; MatcherTypeSet typeSet; typeSet.allNumbers = true; - ASSERT_OK(typeExpr.init("a", std::move(typeSet))); + TypeMatchExpression typeExpr("a", std::move(typeSet)); + ASSERT_EQ("a", typeExpr.path()); ASSERT_TRUE(typeExpr.matchesSingleElement(match1["a"])); ASSERT_TRUE(typeExpr.matchesSingleElement(match2["a"])); @@ -75,15 +73,13 @@ TEST(ExpressionTypeTest, MatchesElementNumber) { } TEST(ExpressionTypeTest, MatchesScalar) { - TypeMatchExpression type; - ASSERT(type.init("a", Bool).isOK()); + TypeMatchExpression type("a", Bool); ASSERT(type.matchesBSON(BSON("a" << true), NULL)); ASSERT(!type.matchesBSON(BSON("a" << 1), NULL)); } TEST(ExpressionTypeTest, MatchesArray) { - TypeMatchExpression type; - ASSERT(type.init("a", NumberInt).isOK()); + TypeMatchExpression type("a", NumberInt); ASSERT(type.matchesBSON(BSON("a" << BSON_ARRAY(4)), NULL)); ASSERT(type.matchesBSON(BSON("a" << BSON_ARRAY(4 << "a")), NULL)); ASSERT(type.matchesBSON(BSON("a" << BSON_ARRAY("a" << 4)), NULL)); @@ -92,8 +88,7 @@ TEST(ExpressionTypeTest, MatchesArray) { } TEST(ExpressionTypeTest, TypeArrayMatchesOuterAndInnerArray) { - TypeMatchExpression type; - ASSERT(type.init("a", Array).isOK()); + TypeMatchExpression type("a", Array); ASSERT(type.matchesBSON(BSON("a" << BSONArray()), nullptr)); ASSERT(type.matchesBSON(BSON("a" << BSON_ARRAY(4 << "a")), nullptr)); ASSERT(type.matchesBSON(BSON("a" << BSON_ARRAY(BSONArray() << 2)), nullptr)); @@ -103,51 +98,44 @@ TEST(ExpressionTypeTest, TypeArrayMatchesOuterAndInnerArray) { } TEST(ExpressionTypeTest, MatchesObject) { - TypeMatchExpression type; - ASSERT(type.init("a", Object).isOK()); + TypeMatchExpression type("a", Object); ASSERT(type.matchesBSON(BSON("a" << BSON("b" << 1)), NULL)); ASSERT(!type.matchesBSON(BSON("a" << 1), NULL)); } TEST(ExpressionTypeTest, MatchesDotNotationFieldObject) { - TypeMatchExpression type; - ASSERT(type.init("a.b", Object).isOK()); + TypeMatchExpression type("a.b", Object); ASSERT(type.matchesBSON(BSON("a" << BSON("b" << BSON("c" << 1))), NULL)); ASSERT(!type.matchesBSON(BSON("a" << BSON("b" << 1)), NULL)); } TEST(ExpressionTypeTest, MatchesDotNotationArrayElementArray) { - TypeMatchExpression type; - ASSERT(type.init("a.0", Array).isOK()); + TypeMatchExpression type("a.0", Array); ASSERT(type.matchesBSON(BSON("a" << BSON_ARRAY(BSON_ARRAY(1))), NULL)); ASSERT(!type.matchesBSON(BSON("a" << BSON_ARRAY("b")), NULL)); } TEST(ExpressionTypeTest, MatchesDotNotationArrayElementScalar) { - TypeMatchExpression type; - ASSERT(type.init("a.0", String).isOK()); + TypeMatchExpression type("a.0", String); ASSERT(type.matchesBSON(BSON("a" << BSON_ARRAY("b")), NULL)); ASSERT(!type.matchesBSON(BSON("a" << BSON_ARRAY(1)), NULL)); } TEST(ExpressionTypeTest, MatchesDotNotationArrayElementObject) { - TypeMatchExpression type; - ASSERT(type.init("a.0", Object).isOK()); + TypeMatchExpression type("a.0", Object); ASSERT(type.matchesBSON(BSON("a" << BSON_ARRAY(BSON("b" << 1))), NULL)); ASSERT(!type.matchesBSON(BSON("a" << BSON_ARRAY(1)), NULL)); } TEST(ExpressionTypeTest, MatchesNull) { - TypeMatchExpression type; - ASSERT(type.init("a", jstNULL).isOK()); + TypeMatchExpression type("a", jstNULL); ASSERT(type.matchesBSON(BSON("a" << BSONNULL), NULL)); ASSERT(!type.matchesBSON(BSON("a" << 4), NULL)); ASSERT(!type.matchesBSON(BSONObj(), NULL)); } TEST(ExpressionTypeTest, ElemMatchKey) { - TypeMatchExpression type; - ASSERT(type.init("a.b", String).isOK()); + TypeMatchExpression type("a.b", String); MatchDetails details; details.requestElemMatchKey(); ASSERT(!type.matchesBSON(BSON("a" << 1), &details)); @@ -166,12 +154,9 @@ TEST(ExpressionTypeTest, ElemMatchKey) { } TEST(ExpressionTypeTest, Equivalent) { - TypeMatchExpression e1; - TypeMatchExpression e2; - TypeMatchExpression e3; - ASSERT_OK(e1.init("a", BSONType::String)); - ASSERT_OK(e2.init("a", BSONType::NumberDouble)); - ASSERT_OK(e3.init("b", BSONType::String)); + TypeMatchExpression e1("a", BSONType::String); + TypeMatchExpression e2("a", BSONType::NumberDouble); + TypeMatchExpression e3("b", BSONType::String); ASSERT(e1.equivalent(&e1)); ASSERT(!e1.equivalent(&e2)); @@ -179,8 +164,7 @@ TEST(ExpressionTypeTest, Equivalent) { } TEST(ExpressionTypeTest, InternalSchemaTypeArrayOnlyMatchesArrays) { - InternalSchemaTypeExpression expr; - ASSERT_OK(expr.init("a", BSONType::Array)); + InternalSchemaTypeExpression expr("a", BSONType::Array); ASSERT_TRUE(expr.matchesBSON(fromjson("{a: []}"))); ASSERT_TRUE(expr.matchesBSON(fromjson("{a: [1]}"))); ASSERT_TRUE(expr.matchesBSON(fromjson("{a: [{b: 1}, {b: 2}]}"))); @@ -189,10 +173,9 @@ TEST(ExpressionTypeTest, InternalSchemaTypeArrayOnlyMatchesArrays) { } TEST(ExpressionTypeTest, InternalSchemaTypeNumberDoesNotMatchArrays) { - InternalSchemaTypeExpression expr; MatcherTypeSet typeSet; typeSet.allNumbers = true; - ASSERT_OK(expr.init("a", std::move(typeSet))); + InternalSchemaTypeExpression expr("a", std::move(typeSet)); ASSERT_FALSE(expr.matchesBSON(fromjson("{a: []}"))); ASSERT_FALSE(expr.matchesBSON(fromjson("{a: [1]}"))); ASSERT_FALSE(expr.matchesBSON(fromjson("{a: ['b', 2, 3]}"))); @@ -202,12 +185,11 @@ TEST(ExpressionTypeTest, InternalSchemaTypeNumberDoesNotMatchArrays) { } TEST(ExpressionTypeTest, TypeExprWithMultipleTypesMatchesAllSuchTypes) { - TypeMatchExpression expr; MatcherTypeSet typeSet; typeSet.allNumbers = true; typeSet.bsonTypes.insert(BSONType::String); typeSet.bsonTypes.insert(BSONType::Object); - ASSERT_OK(expr.init("a", std::move(typeSet))); + TypeMatchExpression expr("a", std::move(typeSet)); ASSERT_FALSE(expr.matchesBSON(fromjson("{a: []}"))); ASSERT_TRUE(expr.matchesBSON(fromjson("{a: 1}"))); @@ -219,12 +201,11 @@ TEST(ExpressionTypeTest, TypeExprWithMultipleTypesMatchesAllSuchTypes) { } TEST(ExpressionTypeTest, InternalSchemaTypeExprWithMultipleTypesMatchesAllSuchTypes) { - InternalSchemaTypeExpression expr; MatcherTypeSet typeSet; typeSet.allNumbers = true; typeSet.bsonTypes.insert(BSONType::String); typeSet.bsonTypes.insert(BSONType::Object); - ASSERT_OK(expr.init("a", std::move(typeSet))); + InternalSchemaTypeExpression expr("a", std::move(typeSet)); ASSERT_FALSE(expr.matchesBSON(fromjson("{a: []}"))); ASSERT_TRUE(expr.matchesBSON(fromjson("{a: 1}"))); diff --git a/src/mongo/db/matcher/expression_where.cpp b/src/mongo/db/matcher/expression_where.cpp index 35f53f1ac14..dea7756f923 100644 --- a/src/mongo/db/matcher/expression_where.cpp +++ b/src/mongo/db/matcher/expression_where.cpp @@ -50,38 +50,24 @@ using std::string; using std::stringstream; using stdx::make_unique; -WhereMatchExpression::WhereMatchExpression(OperationContext* opCtx, WhereParams params) - : WhereMatchExpressionBase(std::move(params)), _opCtx(opCtx) { +WhereMatchExpression::WhereMatchExpression(OperationContext* opCtx, + WhereParams params, + StringData dbName) + : WhereMatchExpressionBase(std::move(params)), _dbName(dbName.toString()), _opCtx(opCtx) { invariant(_opCtx != NULL); - _func = 0; -} - -Status WhereMatchExpression::init(StringData dbName) { - if (!getGlobalScriptEngine()) { - return Status(ErrorCodes::BadValue, "no globalScriptEngine in $where parsing"); - } + uassert( + ErrorCodes::BadValue, "no globalScriptEngine in $where parsing", getGlobalScriptEngine()); - if (dbName.size() == 0) { - return Status(ErrorCodes::BadValue, "ns for $where cannot be empty"); - } - - _dbName = dbName.toString(); + uassert(ErrorCodes::BadValue, "ns for $where cannot be empty", dbName.size() != 0); const string userToken = AuthorizationSession::get(Client::getCurrent())->getAuthenticatedUserNamesToken(); - try { - _scope = getGlobalScriptEngine()->getPooledScope(_opCtx, _dbName, "where" + userToken); - _func = _scope->createFunction(getCode().c_str()); - } catch (...) { - return exceptionToStatus(); - } - - if (!_func) - return Status(ErrorCodes::BadValue, "$where compile error"); + _scope = getGlobalScriptEngine()->getPooledScope(_opCtx, _dbName, "where" + userToken); + _func = _scope->createFunction(getCode().c_str()); - return Status::OK(); + uassert(ErrorCodes::BadValue, "$where compile error", _func); } bool WhereMatchExpression::matches(const MatchableDocument* doc, MatchDetails* details) const { @@ -113,8 +99,7 @@ unique_ptr<MatchExpression> WhereMatchExpression::shallowClone() const { params.code = getCode(); params.scope = getScope(); unique_ptr<WhereMatchExpression> e = - make_unique<WhereMatchExpression>(_opCtx, std::move(params)); - uassertStatusOK(e->init(_dbName)); + make_unique<WhereMatchExpression>(_opCtx, std::move(params), _dbName); if (getTag()) { e->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/expression_where.h b/src/mongo/db/matcher/expression_where.h index 26b55e4f2ea..50062d6583a 100644 --- a/src/mongo/db/matcher/expression_where.h +++ b/src/mongo/db/matcher/expression_where.h @@ -37,9 +37,7 @@ class OperationContext; class WhereMatchExpression final : public WhereMatchExpressionBase { public: - WhereMatchExpression(OperationContext* opCtx, WhereParams params); - - Status init(StringData dbName); + WhereMatchExpression(OperationContext* opCtx, WhereParams params, StringData dbName); bool matches(const MatchableDocument* doc, MatchDetails* details = nullptr) const final; diff --git a/src/mongo/db/matcher/expression_where_base.h b/src/mongo/db/matcher/expression_where_base.h index 32033ea675a..12e7fd86322 100644 --- a/src/mongo/db/matcher/expression_where_base.h +++ b/src/mongo/db/matcher/expression_where_base.h @@ -42,7 +42,7 @@ public: BSONObj scope; // Owned. }; - WhereMatchExpressionBase(WhereParams params); + explicit WhereMatchExpressionBase(WhereParams params); size_t numChildren() const final { return 0; diff --git a/src/mongo/db/matcher/expression_where_noop.h b/src/mongo/db/matcher/expression_where_noop.h index 10235e3176f..0ee8a835c02 100644 --- a/src/mongo/db/matcher/expression_where_noop.h +++ b/src/mongo/db/matcher/expression_where_noop.h @@ -40,7 +40,7 @@ namespace mongo { */ class WhereNoOpMatchExpression final : public WhereMatchExpressionBase { public: - WhereNoOpMatchExpression(WhereParams params); + explicit WhereNoOpMatchExpression(WhereParams params); bool matches(const MatchableDocument* doc, MatchDetails* details = nullptr) const final; diff --git a/src/mongo/db/matcher/extensions_callback_noop.cpp b/src/mongo/db/matcher/extensions_callback_noop.cpp index 10026370e64..9662559ed07 100644 --- a/src/mongo/db/matcher/extensions_callback_noop.cpp +++ b/src/mongo/db/matcher/extensions_callback_noop.cpp @@ -41,11 +41,7 @@ StatusWithMatchExpression ExtensionsCallbackNoop::parseText(BSONElement text) co return textParams.getStatus(); } - auto expr = stdx::make_unique<TextNoOpMatchExpression>(); - Status initStatus = expr->init(std::move(textParams.getValue())); - if (!initStatus.isOK()) { - return initStatus; - } + auto expr = stdx::make_unique<TextNoOpMatchExpression>(std::move(textParams.getValue())); return {std::move(expr)}; } diff --git a/src/mongo/db/matcher/extensions_callback_real.cpp b/src/mongo/db/matcher/extensions_callback_real.cpp index f61928b4e2c..a962efe386a 100644 --- a/src/mongo/db/matcher/extensions_callback_real.cpp +++ b/src/mongo/db/matcher/extensions_callback_real.cpp @@ -45,11 +45,9 @@ StatusWithMatchExpression ExtensionsCallbackReal::parseText(BSONElement text) co return textParams.getStatus(); } - auto exp = stdx::make_unique<TextMatchExpression>(); - Status status = exp->init(_opCtx, *_nss, std::move(textParams.getValue())); - if (!status.isOK()) { - return status; - } + auto exp = + stdx::make_unique<TextMatchExpression>(_opCtx, *_nss, std::move(textParams.getValue())); + return {std::move(exp)}; } @@ -59,11 +57,8 @@ StatusWithMatchExpression ExtensionsCallbackReal::parseWhere(BSONElement where) return whereParams.getStatus(); } - auto exp = stdx::make_unique<WhereMatchExpression>(_opCtx, std::move(whereParams.getValue())); - Status status = exp->init(_nss->db()); - if (!status.isOK()) { - return status; - } + auto exp = stdx::make_unique<WhereMatchExpression>( + _opCtx, std::move(whereParams.getValue()), _nss->db()); return {std::move(exp)}; } diff --git a/src/mongo/db/matcher/path.cpp b/src/mongo/db/matcher/path.cpp index a55da25879d..8ecd2a99473 100644 --- a/src/mongo/db/matcher/path.cpp +++ b/src/mongo/db/matcher/path.cpp @@ -35,11 +35,10 @@ namespace mongo { -Status ElementPath::init(StringData path) { +void ElementPath::init(StringData path) { _shouldTraverseNonleafArrays = true; _shouldTraverseLeafArray = true; _fieldRef.parse(path); - return Status::OK(); } // ----- @@ -194,10 +193,8 @@ bool BSONElementIterator::subCursorHasMore() { } _subCursorPath.reset(new ElementPath()); - _subCursorPath - ->init(_arrayIterationState.restOfPath.substr( - _arrayIterationState.nextPieceOfPath.size() + 1)) - .transitional_ignore(); + _subCursorPath->init(_arrayIterationState.restOfPath.substr( + _arrayIterationState.nextPieceOfPath.size() + 1)); _subCursorPath->setTraverseLeafArray(_path->shouldTraverseLeafArray()); // If we're here, we must be able to traverse nonleaf arrays. @@ -277,7 +274,7 @@ bool BSONElementIterator::more() { // The current array element is a subdocument. See if the subdocument generates // any elements matching the remaining subpath. _subCursorPath.reset(new ElementPath()); - _subCursorPath->init(_arrayIterationState.restOfPath).transitional_ignore(); + _subCursorPath->init(_arrayIterationState.restOfPath); _subCursorPath->setTraverseLeafArray(_path->shouldTraverseLeafArray()); _subCursor.reset(new BSONElementIterator(_subCursorPath.get(), eltInArray.Obj())); @@ -303,10 +300,8 @@ bool BSONElementIterator::more() { // The current array element is itself an array. See if the nested array // has any elements matching the remainihng. _subCursorPath.reset(new ElementPath()); - _subCursorPath - ->init(_arrayIterationState.restOfPath.substr( - _arrayIterationState.nextPieceOfPath.size() + 1)) - .transitional_ignore(); + _subCursorPath->init(_arrayIterationState.restOfPath.substr( + _arrayIterationState.nextPieceOfPath.size() + 1)); _subCursorPath->setTraverseLeafArray(_path->shouldTraverseLeafArray()); BSONElementIterator* real = new BSONElementIterator( _subCursorPath.get(), _arrayIterationState._current.Obj()); diff --git a/src/mongo/db/matcher/path.h b/src/mongo/db/matcher/path.h index cb0c5fbe40c..b769bd35c7e 100644 --- a/src/mongo/db/matcher/path.h +++ b/src/mongo/db/matcher/path.h @@ -47,7 +47,7 @@ public: // TODO: replace uses of members below with regular construction. ElementPath() {} - Status init(StringData path); + void init(StringData path); void setTraverseNonleafArrays(bool b) { _shouldTraverseNonleafArrays = b; diff --git a/src/mongo/db/matcher/path_test.cpp b/src/mongo/db/matcher/path_test.cpp index 26bbed840f9..f66b4764fad 100644 --- a/src/mongo/db/matcher/path_test.cpp +++ b/src/mongo/db/matcher/path_test.cpp @@ -41,7 +41,7 @@ using std::string; TEST(Path, Root1) { ElementPath p; - ASSERT(p.init("a").isOK()); + p.init("a"); BSONObj doc = BSON("x" << 4 << "a" << 5); @@ -55,7 +55,7 @@ TEST(Path, Root1) { TEST(Path, RootArray1) { ElementPath p; - ASSERT(p.init("a").isOK()); + p.init("a"); BSONObj doc = BSON("x" << 4 << "a" << BSON_ARRAY(5 << 6)); @@ -78,7 +78,7 @@ TEST(Path, RootArray1) { TEST(Path, RootArray2) { ElementPath p; - ASSERT(p.init("a").isOK()); + p.init("a"); p.setTraverseLeafArray(false); BSONObj doc = BSON("x" << 4 << "a" << BSON_ARRAY(5 << 6)); @@ -94,7 +94,7 @@ TEST(Path, RootArray2) { TEST(Path, Nested1) { ElementPath p; - ASSERT(p.init("a.b").isOK()); + p.init("a.b"); BSONObj doc = BSON("a" << BSON_ARRAY(BSON("b" << 5) << 3 << BSONObj() << BSON("b" << BSON_ARRAY(9 << 11)) @@ -133,7 +133,7 @@ TEST(Path, Nested1) { TEST(Path, NestedPartialMatchScalar) { ElementPath p; - ASSERT(p.init("a.b").isOK()); + p.init("a.b"); BSONObj doc = BSON("a" << 4); @@ -152,7 +152,7 @@ TEST(Path, NestedPartialMatchScalar) { // what we want ideally. TEST(Path, NestedPartialMatchArray) { ElementPath p; - ASSERT(p.init("a.b").isOK()); + p.init("a.b"); BSONObj doc = BSON("a" << BSON_ARRAY(4)); @@ -164,7 +164,7 @@ TEST(Path, NestedPartialMatchArray) { // Note that this describes existing behavior and not necessarily TEST(Path, NestedEmptyArray) { ElementPath p; - ASSERT(p.init("a.b").isOK()); + p.init("a.b"); BSONObj doc = BSON("a" << BSON("b" << BSONArray())); @@ -180,7 +180,7 @@ TEST(Path, NestedEmptyArray) { TEST(Path, NestedNoLeaf1) { ElementPath p; - ASSERT(p.init("a.b").isOK()); + p.init("a.b"); p.setTraverseLeafArray(false); BSONObj doc = @@ -213,7 +213,7 @@ TEST(Path, NestedNoLeaf1) { TEST(Path, ArrayIndex1) { ElementPath p; - ASSERT(p.init("a.1").isOK()); + p.init("a.1"); BSONObj doc = BSON("a" << BSON_ARRAY(5 << 7 << 3)); @@ -228,7 +228,7 @@ TEST(Path, ArrayIndex1) { TEST(Path, ArrayIndex2) { ElementPath p; - ASSERT(p.init("a.1").isOK()); + p.init("a.1"); BSONObj doc = BSON("a" << BSON_ARRAY(5 << BSON_ARRAY(2 << 4) << 3)); @@ -243,7 +243,7 @@ TEST(Path, ArrayIndex2) { TEST(Path, ArrayIndex3) { ElementPath p; - ASSERT(p.init("a.1").isOK()); + p.init("a.1"); BSONObj doc = BSON("a" << BSON_ARRAY(5 << BSON("1" << 4) << 3)); @@ -262,7 +262,7 @@ TEST(Path, ArrayIndex3) { TEST(Path, ArrayIndexNested1) { ElementPath p; - ASSERT(p.init("a.1.b").isOK()); + p.init("a.1.b"); BSONObj doc = BSON("a" << BSON_ARRAY(5 << BSON("b" << 4) << 3)); @@ -282,7 +282,7 @@ TEST(Path, ArrayIndexNested1) { TEST(Path, ArrayIndexNested2) { ElementPath p; - ASSERT(p.init("a.1.b").isOK()); + p.init("a.1.b"); BSONObj doc = BSON("a" << BSON_ARRAY(5 << BSON_ARRAY(BSON("b" << 4)) << 3)); @@ -300,7 +300,7 @@ TEST(Path, ArrayIndexNested2) { // array containing subdocuments with nested arrays. TEST(Path, NonMatchingLongArrayOfSubdocumentsWithNestedArrays) { ElementPath p; - ASSERT(p.init("a.b.x").isOK()); + p.init("a.b.x"); // Build the document {a: [{b: []}, {b: []}, {b: []}, ...]}. BSONObj subdoc = BSON("b" << BSONArray()); @@ -321,7 +321,7 @@ TEST(Path, NonMatchingLongArrayOfSubdocumentsWithNestedArrays) { // outermost array that is implicitly traversed. TEST(Path, NestedArrayImplicitTraversal) { ElementPath p; - ASSERT(p.init("a.b").isOK()); + p.init("a.b"); BSONObj doc = fromjson("{a: [{b: [2, 3]}, {b: [4, 5]}]}"); BSONElementIterator cursor(&p, doc); @@ -369,7 +369,7 @@ TEST(Path, NestedArrayImplicitTraversal) { // current offset of the array being implicitly traversed. TEST(Path, ArrayOffsetWithImplicitAndExplicitTraversal) { ElementPath p; - ASSERT(p.init("a.0.b").isOK()); + p.init("a.0.b"); BSONObj doc = fromjson("{a: [{b: [2, 3]}, {b: [4, 5]}]}"); BSONElementIterator cursor(&p, doc); diff --git a/src/mongo/db/matcher/rewrite_expr.cpp b/src/mongo/db/matcher/rewrite_expr.cpp index 304a850f592..655384047bf 100644 --- a/src/mongo/db/matcher/rewrite_expr.cpp +++ b/src/mongo/db/matcher/rewrite_expr.cpp @@ -150,9 +150,8 @@ std::unique_ptr<MatchExpression> RewriteExpr::_rewriteInExpression( std::vector<BSONElement> elementList; inValues.elems(elementList); - auto matchInExpr = stdx::make_unique<InMatchExpression>(); + auto matchInExpr = stdx::make_unique<InMatchExpression>(fieldPath); matchInExpr->setCollator(_collator); - uassertStatusOK(matchInExpr->init(fieldPath)); uassertStatusOK(matchInExpr->setEqualities(elementList)); return std::move(matchInExpr); @@ -226,42 +225,46 @@ std::unique_ptr<MatchExpression> RewriteExpr::_buildComparisonMatchExpression( switch (comparisonOp) { case ExpressionCompare::EQ: { - compMatchExpr = stdx::make_unique<EqualityMatchExpression>(); + compMatchExpr = stdx::make_unique<EqualityMatchExpression>(fieldAndValue.fieldName(), + fieldAndValue); break; } case ExpressionCompare::NE: { - compMatchExpr = stdx::make_unique<EqualityMatchExpression>(); - notMatchExpr = stdx::make_unique<NotMatchExpression>(); + compMatchExpr = stdx::make_unique<EqualityMatchExpression>(fieldAndValue.fieldName(), + fieldAndValue); + notMatchExpr = stdx::make_unique<NotMatchExpression>(compMatchExpr.release()); break; } case ExpressionCompare::GT: { - compMatchExpr = stdx::make_unique<GTMatchExpression>(); + compMatchExpr = + stdx::make_unique<GTMatchExpression>(fieldAndValue.fieldName(), fieldAndValue); break; } case ExpressionCompare::GTE: { - compMatchExpr = stdx::make_unique<GTEMatchExpression>(); + compMatchExpr = + stdx::make_unique<GTEMatchExpression>(fieldAndValue.fieldName(), fieldAndValue); break; } case ExpressionCompare::LT: { - compMatchExpr = stdx::make_unique<LTMatchExpression>(); + compMatchExpr = + stdx::make_unique<LTMatchExpression>(fieldAndValue.fieldName(), fieldAndValue); break; } case ExpressionCompare::LTE: { - compMatchExpr = stdx::make_unique<LTEMatchExpression>(); + compMatchExpr = + stdx::make_unique<LTEMatchExpression>(fieldAndValue.fieldName(), fieldAndValue); break; } default: MONGO_UNREACHABLE; } - uassertStatusOK(compMatchExpr->init(fieldAndValue.fieldName(), fieldAndValue)); - compMatchExpr->setCollator(_collator); - if (notMatchExpr) { - uassertStatusOK(notMatchExpr->init(compMatchExpr.release())); + notMatchExpr->setCollator(_collator); return std::move(notMatchExpr); } + compMatchExpr->setCollator(_collator); return std::move(compMatchExpr); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_all_elem_match_from_index.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_all_elem_match_from_index.cpp index 6384bebe775..f6c84c6006e 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_all_elem_match_from_index.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_all_elem_match_from_index.cpp @@ -36,10 +36,18 @@ namespace mongo { constexpr StringData InternalSchemaAllElemMatchFromIndexMatchExpression::kName; +InternalSchemaAllElemMatchFromIndexMatchExpression:: + InternalSchemaAllElemMatchFromIndexMatchExpression( + StringData path, long long index, std::unique_ptr<ExpressionWithPlaceholder> expression) + : ArrayMatchingMatchExpression(MatchExpression::INTERNAL_SCHEMA_ALL_ELEM_MATCH_FROM_INDEX, + path), + _index(index), + _expression(std::move(expression)) {} + std::unique_ptr<MatchExpression> InternalSchemaAllElemMatchFromIndexMatchExpression::shallowClone() const { - auto clone = stdx::make_unique<InternalSchemaAllElemMatchFromIndexMatchExpression>(); - invariantOK(clone->init(path(), _index, _expression->shallowClone())); + auto clone = stdx::make_unique<InternalSchemaAllElemMatchFromIndexMatchExpression>( + path(), _index, _expression->shallowClone()); if (getTag()) { clone->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_all_elem_match_from_index.h b/src/mongo/db/matcher/schema/expression_internal_schema_all_elem_match_from_index.h index 625cf025583..ecc61250317 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_all_elem_match_from_index.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_all_elem_match_from_index.h @@ -42,17 +42,8 @@ class InternalSchemaAllElemMatchFromIndexMatchExpression final public: static constexpr StringData kName = "$_internalSchemaAllElemMatchFromIndex"_sd; - InternalSchemaAllElemMatchFromIndexMatchExpression() - : ArrayMatchingMatchExpression(MatchExpression::INTERNAL_SCHEMA_ALL_ELEM_MATCH_FROM_INDEX) { - } - - Status init(StringData path, - long long index, - std::unique_ptr<ExpressionWithPlaceholder> expression) { - _index = index; - _expression = std::move(expression); - return setPath(path); - } + InternalSchemaAllElemMatchFromIndexMatchExpression( + StringData path, long long index, std::unique_ptr<ExpressionWithPlaceholder> expression); std::unique_ptr<MatchExpression> shallowClone() const final; diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_allowed_properties.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_allowed_properties.cpp index 76244991508..5fa61fd23ea 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_allowed_properties.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_allowed_properties.cpp @@ -33,25 +33,23 @@ namespace mongo { constexpr StringData InternalSchemaAllowedPropertiesMatchExpression::kName; -Status InternalSchemaAllowedPropertiesMatchExpression::init( +InternalSchemaAllowedPropertiesMatchExpression::InternalSchemaAllowedPropertiesMatchExpression( boost::container::flat_set<StringData> properties, StringData namePlaceholder, std::vector<PatternSchema> patternProperties, - std::unique_ptr<ExpressionWithPlaceholder> otherwise) { - _properties = std::move(properties); - _namePlaceholder = namePlaceholder; - _patternProperties = std::move(patternProperties); - _otherwise = std::move(otherwise); + std::unique_ptr<ExpressionWithPlaceholder> otherwise) + : MatchExpression(MatchExpression::INTERNAL_SCHEMA_ALLOWED_PROPERTIES), + _properties(std::move(properties)), + _namePlaceholder(namePlaceholder), + _patternProperties(std::move(patternProperties)), + _otherwise(std::move(otherwise)) { for (auto&& constraint : _patternProperties) { const auto& errorStr = constraint.first.regex->error(); - if (!errorStr.empty()) { - return {ErrorCodes::BadValue, - str::stream() << "Invalid regular expression: " << errorStr}; - } + uassert(ErrorCodes::BadValue, + str::stream() << "Invalid regular expression: " << errorStr, + errorStr.empty()); } - - return Status::OK(); } void InternalSchemaAllowedPropertiesMatchExpression::debugString(StringBuilder& debug, @@ -165,11 +163,11 @@ std::unique_ptr<MatchExpression> InternalSchemaAllowedPropertiesMatchExpression: constraint.second->shallowClone()); } - auto clone = stdx::make_unique<InternalSchemaAllowedPropertiesMatchExpression>(); - invariantOK(clone->init(_properties, - _namePlaceholder, - std::move(clonedPatternProperties), - _otherwise->shallowClone())); + auto clone = stdx::make_unique<InternalSchemaAllowedPropertiesMatchExpression>( + _properties, + _namePlaceholder, + std::move(clonedPatternProperties), + _otherwise->shallowClone()); return {std::move(clone)}; } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_allowed_properties.h b/src/mongo/db/matcher/schema/expression_internal_schema_allowed_properties.h index b539318dfe8..89c7448ec79 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_allowed_properties.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_allowed_properties.h @@ -108,13 +108,11 @@ public: static constexpr StringData kName = "$_internalSchemaAllowedProperties"_sd; - explicit InternalSchemaAllowedPropertiesMatchExpression() - : MatchExpression(MatchExpression::INTERNAL_SCHEMA_ALLOWED_PROPERTIES) {} - - Status init(boost::container::flat_set<StringData> properties, - StringData namePlaceholder, - std::vector<PatternSchema> patternProperties, - std::unique_ptr<ExpressionWithPlaceholder> otherwise); + explicit InternalSchemaAllowedPropertiesMatchExpression( + boost::container::flat_set<StringData> properties, + StringData namePlaceholder, + std::vector<PatternSchema> patternProperties, + std::unique_ptr<ExpressionWithPlaceholder> otherwise); void debugString(StringBuilder& debug, int level) const final; diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_cond.h b/src/mongo/db/matcher/schema/expression_internal_schema_cond.h index 94da4bc3781..ab5f38b4d01 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_cond.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_cond.h @@ -41,8 +41,9 @@ class InternalSchemaCondMatchExpression final public: static constexpr StringData kName = "$_internalSchemaCond"_sd; - InternalSchemaCondMatchExpression() - : FixedArityMatchExpression(MatchType::INTERNAL_SCHEMA_COND) {} + explicit InternalSchemaCondMatchExpression( + std::array<std::unique_ptr<MatchExpression>, 3> expressions) + : FixedArityMatchExpression(MatchType::INTERNAL_SCHEMA_COND, std::move(expressions)) {} const MatchExpression* condition() const { return expressions()[0].get(); diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_cond_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_cond_test.cpp index f1a022da7c4..79d4a7c5d6e 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_cond_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_cond_test.cpp @@ -43,8 +43,6 @@ namespace { std::unique_ptr<InternalSchemaCondMatchExpression> createCondMatchExpression(BSONObj condition, BSONObj thenBranch, BSONObj elseBranch) { - auto cond = stdx::make_unique<InternalSchemaCondMatchExpression>(); - boost::intrusive_ptr<ExpressionContextForTest> expCtx(new ExpressionContextForTest()); auto conditionExpr = MatchExpressionParser::parse(condition, expCtx); ASSERT_OK(conditionExpr.getStatus()); @@ -52,9 +50,12 @@ std::unique_ptr<InternalSchemaCondMatchExpression> createCondMatchExpression(BSO ASSERT_OK(thenBranchExpr.getStatus()); auto elseBranchExpr = MatchExpressionParser::parse(elseBranch, expCtx); - cond->init({{std::move(conditionExpr.getValue()), - std::move(thenBranchExpr.getValue()), - std::move(elseBranchExpr.getValue())}}); + std::array<std::unique_ptr<MatchExpression>, 3> expressions = { + {std::move(conditionExpr.getValue()), + std::move(thenBranchExpr.getValue()), + std::move(elseBranchExpr.getValue())}}; + + auto cond = stdx::make_unique<InternalSchemaCondMatchExpression>(std::move(expressions)); return cond; } @@ -103,9 +104,8 @@ TEST(InternalSchemaCondMatchExpressionTest, AppliesToSubobjectsViaObjectMatch) { auto elseQuery = BSON("interests" << "query optimization"); - InternalSchemaObjectMatchExpression objMatch; - ASSERT_OK( - objMatch.init(createCondMatchExpression(conditionQuery, thenQuery, elseQuery), "job"_sd)); + InternalSchemaObjectMatchExpression objMatch( + "job"_sd, createCondMatchExpression(conditionQuery, thenQuery, elseQuery)); ASSERT_TRUE(objMatch.matchesBSON( fromjson("{name: 'anne', job: {team: 'engineering', subteam: 'query'}}"))); diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_eq.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_eq.cpp index 20de5d876e9..54ec03a0bed 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_eq.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_eq.cpp @@ -38,10 +38,10 @@ namespace mongo { constexpr StringData InternalSchemaEqMatchExpression::kName; -Status InternalSchemaEqMatchExpression::init(StringData path, BSONElement rhs) { - invariant(rhs); - _rhsElem = rhs; - return setPath(path); +InternalSchemaEqMatchExpression::InternalSchemaEqMatchExpression(StringData path, BSONElement rhs) + : LeafMatchExpression(MatchType::INTERNAL_SCHEMA_EQ, path), _rhsElem(rhs) { + invariant(_rhsElem); + setTraverseLeafArray(); } bool InternalSchemaEqMatchExpression::matchesSingleElement(const BSONElement& elem, @@ -78,8 +78,7 @@ bool InternalSchemaEqMatchExpression::equivalent(const MatchExpression* other) c } std::unique_ptr<MatchExpression> InternalSchemaEqMatchExpression::shallowClone() const { - auto clone = stdx::make_unique<InternalSchemaEqMatchExpression>(); - invariantOK(clone->init(path(), _rhsElem)); + auto clone = stdx::make_unique<InternalSchemaEqMatchExpression>(path(), _rhsElem); if (getTag()) { clone->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_eq.h b/src/mongo/db/matcher/schema/expression_internal_schema_eq.h index 2f73ccf534e..a8f85a2843e 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_eq.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_eq.h @@ -45,9 +45,7 @@ class InternalSchemaEqMatchExpression final : public LeafMatchExpression { public: static constexpr StringData kName = "$_internalSchemaEq"_sd; - InternalSchemaEqMatchExpression() : LeafMatchExpression(MatchType::INTERNAL_SCHEMA_EQ) {} - - Status init(StringData path, BSONElement rhs); + InternalSchemaEqMatchExpression(StringData path, BSONElement rhs); std::unique_ptr<MatchExpression> shallowClone() const final; diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_eq_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_eq_test.cpp index 3ccc5175092..868c8337450 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_eq_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_eq_test.cpp @@ -40,26 +40,24 @@ namespace { TEST(InternalSchemaEqMatchExpression, CorrectlyMatchesScalarElements) { BSONObj numberOperand = BSON("a" << 5); - InternalSchemaEqMatchExpression eq; - ASSERT_OK(eq.init("a", numberOperand["a"])); - ASSERT_TRUE(eq.matchesBSON(BSON("a" << 5.0))); - ASSERT_FALSE(eq.matchesBSON(BSON("a" << 6))); + InternalSchemaEqMatchExpression eqNumberOperand("a", numberOperand["a"]); + ASSERT_TRUE(eqNumberOperand.matchesBSON(BSON("a" << 5.0))); + ASSERT_FALSE(eqNumberOperand.matchesBSON(BSON("a" << 6))); BSONObj stringOperand = BSON("a" << "str"); - ASSERT_OK(eq.init("a", stringOperand["a"])); - ASSERT_TRUE(eq.matchesBSON(BSON("a" - << "str"))); - ASSERT_FALSE(eq.matchesBSON(BSON("a" - << "string"))); + InternalSchemaEqMatchExpression eqStringOperand("a", stringOperand["a"]); + ASSERT_TRUE(eqStringOperand.matchesBSON(BSON("a" + << "str"))); + ASSERT_FALSE(eqStringOperand.matchesBSON(BSON("a" + << "string"))); } TEST(InternalSchemaEqMatchExpression, CorrectlyMatchesArrayElement) { BSONObj operand = BSON("a" << BSON_ARRAY("b" << 5)); - InternalSchemaEqMatchExpression eq; - ASSERT_OK(eq.init("a", operand["a"])); + InternalSchemaEqMatchExpression eq("a", operand["a"]); ASSERT_TRUE(eq.matchesBSON(BSON("a" << BSON_ARRAY("b" << 5)))); ASSERT_FALSE(eq.matchesBSON(BSON("a" << BSON_ARRAY(5 << "b")))); ASSERT_FALSE(eq.matchesBSON(BSON("a" << BSON_ARRAY("b" << 5 << 5)))); @@ -69,8 +67,7 @@ TEST(InternalSchemaEqMatchExpression, CorrectlyMatchesArrayElement) { TEST(InternalSchemaEqMatchExpression, CorrectlyMatchesNullElement) { BSONObj operand = BSON("a" << BSONNULL); - InternalSchemaEqMatchExpression eq; - ASSERT_OK(eq.init("a", operand["a"])); + InternalSchemaEqMatchExpression eq("a", operand["a"]); ASSERT_TRUE(eq.matchesBSON(BSON("a" << BSONNULL))); ASSERT_FALSE(eq.matchesBSON(BSON("a" << 4))); } @@ -78,8 +75,7 @@ TEST(InternalSchemaEqMatchExpression, CorrectlyMatchesNullElement) { TEST(InternalSchemaEqMatchExpression, NullElementDoesNotMatchMissing) { BSONObj operand = BSON("a" << BSONNULL); - InternalSchemaEqMatchExpression eq; - ASSERT_OK(eq.init("a", operand["a"])); + InternalSchemaEqMatchExpression eq("a", operand["a"]); ASSERT_FALSE(eq.matchesBSON(BSONObj())); ASSERT_FALSE(eq.matchesBSON(BSON("b" << 4))); } @@ -87,17 +83,14 @@ TEST(InternalSchemaEqMatchExpression, NullElementDoesNotMatchMissing) { TEST(InternalSchemaEqMatchExpression, NullElementDoesNotMatchUndefinedOrMissing) { BSONObj operand = BSON("a" << BSONNULL); - InternalSchemaEqMatchExpression eq; - ASSERT_OK(eq.init("a", operand["a"])); + InternalSchemaEqMatchExpression eq("a", operand["a"]); ASSERT_FALSE(eq.matchesBSON(BSONObj())); ASSERT_FALSE(eq.matchesBSON(fromjson("{a: undefined}"))); } TEST(InternalSchemaEqMatchExpression, DoesNotTraverseLeafArrays) { BSONObj operand = BSON("a" << 5); - - InternalSchemaEqMatchExpression eq; - ASSERT_OK(eq.init("a", operand["a"])); + InternalSchemaEqMatchExpression eq("a", operand["a"]); ASSERT_TRUE(eq.matchesBSON(BSON("a" << 5.0))); ASSERT_FALSE(eq.matchesBSON(BSON("a" << BSON_ARRAY(5)))); } @@ -105,8 +98,7 @@ TEST(InternalSchemaEqMatchExpression, DoesNotTraverseLeafArrays) { TEST(InternalSchemaEqMatchExpression, MatchesObjectsIndependentOfFieldOrder) { BSONObj operand = fromjson("{a: {b: 1, c: {d: 2, e: 3}}}"); - InternalSchemaEqMatchExpression eq; - ASSERT_OK(eq.init("a", operand["a"])); + InternalSchemaEqMatchExpression eq("a", operand["a"]); ASSERT_TRUE(eq.matchesBSON(fromjson("{a: {b: 1, c: {d: 2, e: 3}}}"))); ASSERT_TRUE(eq.matchesBSON(fromjson("{a: {c: {e: 3, d: 2}, b: 1}}"))); ASSERT_FALSE(eq.matchesBSON(fromjson("{a: {b: 1, c: {d: 2}, e: 3}}"))); diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_fmod.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_fmod.cpp index dcbe8c2b93b..3cc617d94bb 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_fmod.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_fmod.cpp @@ -36,21 +36,15 @@ namespace mongo { -Status InternalSchemaFmodMatchExpression::init(StringData path, - Decimal128 divisor, - Decimal128 remainder) { - if (divisor.isZero()) { - return Status(ErrorCodes::BadValue, "divisor cannot be 0"); - } - if (divisor.isNaN()) { - return Status(ErrorCodes::BadValue, "divisor cannot be NaN"); - } - if (divisor.isInfinite()) { - return Status(ErrorCodes::BadValue, "divisor cannot be infinite"); - } - _divisor = divisor; - _remainder = remainder; - return setPath(path); +InternalSchemaFmodMatchExpression::InternalSchemaFmodMatchExpression(StringData path, + Decimal128 divisor, + Decimal128 remainder) + : LeafMatchExpression(MatchType::INTERNAL_SCHEMA_FMOD, path), + _divisor(divisor), + _remainder(remainder) { + uassert(ErrorCodes::BadValue, "divisor cannot be 0", !divisor.isZero()); + uassert(ErrorCodes::BadValue, "divisor cannot be NaN", !divisor.isNaN()); + uassert(ErrorCodes::BadValue, "divisor cannot be infinite", !divisor.isInfinite()); } bool InternalSchemaFmodMatchExpression::matchesSingleElement(const BSONElement& e, diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_fmod.h b/src/mongo/db/matcher/schema/expression_internal_schema_fmod.h index 25a7b3c3945..6847913187d 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_fmod.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_fmod.h @@ -38,14 +38,11 @@ namespace mongo { */ class InternalSchemaFmodMatchExpression final : public LeafMatchExpression { public: - InternalSchemaFmodMatchExpression() : LeafMatchExpression(MatchType::INTERNAL_SCHEMA_FMOD) {} - - Status init(StringData path, Decimal128 divisor, Decimal128 remainder); + InternalSchemaFmodMatchExpression(StringData path, Decimal128 divisor, Decimal128 remainder); std::unique_ptr<MatchExpression> shallowClone() const final { std::unique_ptr<InternalSchemaFmodMatchExpression> m = - stdx::make_unique<InternalSchemaFmodMatchExpression>(); - invariantOK(m->init(path(), _divisor, _remainder)); + stdx::make_unique<InternalSchemaFmodMatchExpression>(path(), _divisor, _remainder); if (getTag()) { m->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_fmod_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_fmod_test.cpp index 2eef5fe0ed5..1701f0b8e29 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_fmod_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_fmod_test.cpp @@ -40,8 +40,7 @@ TEST(InternalSchemaFmodMatchExpression, MatchesElement) { BSONObj longLongMatch = BSON("a" << 68719476736LL); BSONObj notMatch = BSON("a" << 6); BSONObj negativeNotMatch = BSON("a" << -2); - InternalSchemaFmodMatchExpression fmod; - ASSERT_OK(fmod.init("", Decimal128(3), Decimal128(1))); + InternalSchemaFmodMatchExpression fmod("", Decimal128(3), Decimal128(1)); ASSERT_TRUE(fmod.matchesSingleElement(match.firstElement())); ASSERT_TRUE(fmod.matchesSingleElement(largerMatch.firstElement())); ASSERT_TRUE(fmod.matchesSingleElement(longLongMatch.firstElement())); @@ -50,49 +49,44 @@ TEST(InternalSchemaFmodMatchExpression, MatchesElement) { } TEST(InternalSchemaFmodMatchExpression, ZeroDivisor) { - InternalSchemaFmodMatchExpression fmod; - ASSERT_NOT_OK(fmod.init("", Decimal128(0), Decimal128(1))); + ASSERT_THROWS_CODE(InternalSchemaFmodMatchExpression fmod("", Decimal128(0), Decimal128(1)), + AssertionException, + ErrorCodes::BadValue); } TEST(InternalSchemaFmodMatchExpression, MatchesScalar) { - InternalSchemaFmodMatchExpression fmod; - ASSERT_OK(fmod.init("a", Decimal128(5), Decimal128(2))); + InternalSchemaFmodMatchExpression fmod("a", Decimal128(5), Decimal128(2)); ASSERT_TRUE(fmod.matchesBSON(BSON("a" << 7.0))); ASSERT_FALSE(fmod.matchesBSON(BSON("a" << 4))); } TEST(InternalSchemaFmodMatchExpression, MatchesNonIntegralValue) { - InternalSchemaFmodMatchExpression fmod; - ASSERT_OK(fmod.init("a", Decimal128(10.5), Decimal128((4.5)))); + InternalSchemaFmodMatchExpression fmod("a", Decimal128(10.5), Decimal128((4.5))); ASSERT_TRUE(fmod.matchesBSON(BSON("a" << 15.0))); ASSERT_FALSE(fmod.matchesBSON(BSON("a" << 10.0))); } TEST(InternalSchemaFmodMatchExpression, MatchesArrayValue) { - InternalSchemaFmodMatchExpression fmod; - ASSERT_OK(fmod.init("a", Decimal128(5), Decimal128(2))); + InternalSchemaFmodMatchExpression fmod("a", Decimal128(5), Decimal128(2)); ASSERT_TRUE(fmod.matchesBSON(BSON("a" << BSON_ARRAY(5 << 12LL)))); ASSERT_FALSE(fmod.matchesBSON(BSON("a" << BSON_ARRAY(6 << 8)))); } TEST(InternalSchemaFmodMatchExpression, DoesNotMatchNull) { - InternalSchemaFmodMatchExpression fmod; - ASSERT_OK(fmod.init("a", Decimal128(5), Decimal128(2))); + InternalSchemaFmodMatchExpression fmod("a", Decimal128(5), Decimal128(2)); ASSERT_FALSE(fmod.matchesBSON(BSONObj())); ASSERT_FALSE(fmod.matchesBSON(BSON("a" << BSONNULL))); } TEST(InternalSchemaFmodMatchExpression, NegativeRemainders) { - InternalSchemaFmodMatchExpression fmod; - ASSERT_OK(fmod.init("a", Decimal128(5), Decimal128(-2.4))); + InternalSchemaFmodMatchExpression fmod("a", Decimal128(5), Decimal128(-2.4)); ASSERT_FALSE(fmod.matchesBSON(BSON("a" << 7.6))); ASSERT_FALSE(fmod.matchesBSON(BSON("a" << 12.4))); ASSERT_TRUE(fmod.matchesBSON(BSON("a" << Decimal128(-12.4)))); } TEST(InternalSchemaFmodMatchExpression, ElemMatchKey) { - InternalSchemaFmodMatchExpression fmod; - ASSERT_OK(fmod.init("a", Decimal128(5), Decimal128(2))); + InternalSchemaFmodMatchExpression fmod("a", Decimal128(5), Decimal128(2)); MatchDetails details; details.requestElemMatchKey(); ASSERT_FALSE(fmod.matchesBSON(BSON("a" << 4), &details)); @@ -105,15 +99,10 @@ TEST(InternalSchemaFmodMatchExpression, ElemMatchKey) { } TEST(InternalSchemaFmodMatchExpression, Equality) { - InternalSchemaFmodMatchExpression m1; - InternalSchemaFmodMatchExpression m2; - InternalSchemaFmodMatchExpression m3; - InternalSchemaFmodMatchExpression m4; - - ASSERT_OK(m1.init("a", Decimal128(1.7), Decimal128(2))); - ASSERT_OK(m2.init("a", Decimal128(2), Decimal128(2))); - ASSERT_OK(m3.init("a", Decimal128(1.7), Decimal128(1))); - ASSERT_OK(m4.init("b", Decimal128(1.7), Decimal128(2))); + InternalSchemaFmodMatchExpression m1("a", Decimal128(1.7), Decimal128(2)); + InternalSchemaFmodMatchExpression m2("a", Decimal128(2), Decimal128(2)); + InternalSchemaFmodMatchExpression m3("a", Decimal128(1.7), Decimal128(1)); + InternalSchemaFmodMatchExpression m4("b", Decimal128(1.7), Decimal128(2)); ASSERT_TRUE(m1.equivalent(&m1)); ASSERT_FALSE(m1.equivalent(&m2)); diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_match_array_index.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_match_array_index.cpp index c081792b4f1..0bca92144be 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_match_array_index.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_match_array_index.cpp @@ -33,6 +33,14 @@ namespace mongo { constexpr StringData InternalSchemaMatchArrayIndexMatchExpression::kName; +InternalSchemaMatchArrayIndexMatchExpression::InternalSchemaMatchArrayIndexMatchExpression( + StringData path, long long index, std::unique_ptr<ExpressionWithPlaceholder> expression) + : ArrayMatchingMatchExpression(MatchExpression::INTERNAL_SCHEMA_MATCH_ARRAY_INDEX, path), + _index(index), + _expression(std::move(expression)) { + invariant(static_cast<bool>(_expression)); +} + void InternalSchemaMatchArrayIndexMatchExpression::debugString(StringBuilder& debug, int level) const { _debugAddSpace(debug, level); @@ -59,14 +67,6 @@ bool InternalSchemaMatchArrayIndexMatchExpression::equivalent(const MatchExpress _expression->equivalent(other->_expression.get()); } -Status InternalSchemaMatchArrayIndexMatchExpression::init( - StringData path, long long index, std::unique_ptr<ExpressionWithPlaceholder> expression) { - invariant(static_cast<bool>(expression)); - _index = index; - _expression = std::move(expression); - return setPath(path); -} - void InternalSchemaMatchArrayIndexMatchExpression::serialize(BSONObjBuilder* builder) const { BSONObjBuilder pathSubobj(builder->subobjStart(path())); { @@ -85,8 +85,11 @@ void InternalSchemaMatchArrayIndexMatchExpression::serialize(BSONObjBuilder* bui std::unique_ptr<MatchExpression> InternalSchemaMatchArrayIndexMatchExpression::shallowClone() const { - auto clone = stdx::make_unique<InternalSchemaMatchArrayIndexMatchExpression>(); - invariantOK(clone->init(path(), _index, _expression->shallowClone())); + auto clone = stdx::make_unique<InternalSchemaMatchArrayIndexMatchExpression>( + path(), _index, _expression->shallowClone()); + if (getTag()) { + clone->setTag(getTag()->clone()); + } return std::move(clone); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_match_array_index.h b/src/mongo/db/matcher/schema/expression_internal_schema_match_array_index.h index 520ccae568c..8b75d91374d 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_match_array_index.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_match_array_index.h @@ -41,12 +41,8 @@ class InternalSchemaMatchArrayIndexMatchExpression final : public ArrayMatchingM public: static constexpr StringData kName = "$_internalSchemaMatchArrayIndex"_sd; - InternalSchemaMatchArrayIndexMatchExpression() - : ArrayMatchingMatchExpression(MatchExpression::INTERNAL_SCHEMA_MATCH_ARRAY_INDEX) {} - - Status init(StringData path, - long long index, - std::unique_ptr<ExpressionWithPlaceholder> expression); + InternalSchemaMatchArrayIndexMatchExpression( + StringData path, long long index, std::unique_ptr<ExpressionWithPlaceholder> expression); void debugString(StringBuilder& debug, int level) const final; diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_max_items.h b/src/mongo/db/matcher/schema/expression_internal_schema_max_items.h index 3ba965e298a..814aba1da84 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_max_items.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_max_items.h @@ -39,9 +39,9 @@ namespace mongo { class InternalSchemaMaxItemsMatchExpression final : public InternalSchemaNumArrayItemsMatchExpression { public: - InternalSchemaMaxItemsMatchExpression() - : InternalSchemaNumArrayItemsMatchExpression(INTERNAL_SCHEMA_MAX_ITEMS, - "$_internalSchemaMaxItems"_sd) {} + InternalSchemaMaxItemsMatchExpression(StringData path, long long numItems) + : InternalSchemaNumArrayItemsMatchExpression( + INTERNAL_SCHEMA_MAX_ITEMS, path, numItems, "$_internalSchemaMaxItems"_sd) {} bool matchesArray(const BSONObj& anArray, MatchDetails* details) const final { return (anArray.nFields() <= numItems()); @@ -49,8 +49,7 @@ public: std::unique_ptr<MatchExpression> shallowClone() const final { std::unique_ptr<InternalSchemaMaxItemsMatchExpression> maxItems = - stdx::make_unique<InternalSchemaMaxItemsMatchExpression>(); - invariantOK(maxItems->init(path(), numItems())); + stdx::make_unique<InternalSchemaMaxItemsMatchExpression>(path(), numItems()); if (getTag()) { maxItems->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_max_items_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_max_items_test.cpp index 27675889dee..88aa6ea1f48 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_max_items_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_max_items_test.cpp @@ -37,8 +37,7 @@ namespace mongo { namespace { TEST(InternalSchemaMaxItemsMatchExpression, RejectsNonArrayElements) { - InternalSchemaMaxItemsMatchExpression maxItems; - ASSERT_OK(maxItems.init("a", 1)); + InternalSchemaMaxItemsMatchExpression maxItems("a", 1); ASSERT(!maxItems.matchesBSON(BSON("a" << BSONObj()))); ASSERT(!maxItems.matchesBSON(BSON("a" << 1))); @@ -47,46 +46,40 @@ TEST(InternalSchemaMaxItemsMatchExpression, RejectsNonArrayElements) { } TEST(InternalSchemaMaxItemsMatchExpression, RejectsArraysWithTooManyElements) { - InternalSchemaMaxItemsMatchExpression maxItems; - ASSERT_OK(maxItems.init("a", 0)); + InternalSchemaMaxItemsMatchExpression maxItems("a", 0); ASSERT(!maxItems.matchesBSON(BSON("a" << BSON_ARRAY(1)))); ASSERT(!maxItems.matchesBSON(BSON("a" << BSON_ARRAY(1 << 2)))); } TEST(InternalSchemaMaxItemsMatchExpression, AcceptsArrayWithLessThanOrEqualToMaxElements) { - InternalSchemaMaxItemsMatchExpression maxItems; - ASSERT_OK(maxItems.init("a", 2)); + InternalSchemaMaxItemsMatchExpression maxItems("a", 2); ASSERT(maxItems.matchesBSON(BSON("a" << BSON_ARRAY(5 << 6)))); ASSERT(maxItems.matchesBSON(BSON("a" << BSON_ARRAY(5)))); } TEST(InternalSchemaMaxItemsMatchExpression, MaxItemsZeroAllowsEmptyArrays) { - InternalSchemaMaxItemsMatchExpression maxItems; - ASSERT_OK(maxItems.init("a", 0)); + InternalSchemaMaxItemsMatchExpression maxItems("a", 0); ASSERT(maxItems.matchesBSON(BSON("a" << BSONArray()))); } TEST(InternalSchemaMaxItemsMatchExpression, NullArrayEntriesCountAsItems) { - InternalSchemaMaxItemsMatchExpression maxItems; - ASSERT_OK(maxItems.init("a", 2)); + InternalSchemaMaxItemsMatchExpression maxItems("a", 2); ASSERT(maxItems.matchesBSON(BSON("a" << BSON_ARRAY(BSONNULL << 1)))); ASSERT(!maxItems.matchesBSON(BSON("a" << BSON_ARRAY(BSONNULL << 1 << 2)))); } TEST(InternalSchemaMaxItemsMatchExpression, NestedArraysAreNotUnwound) { - InternalSchemaMaxItemsMatchExpression maxItems; - ASSERT_OK(maxItems.init("a", 2)); + InternalSchemaMaxItemsMatchExpression maxItems("a", 2); ASSERT(maxItems.matchesBSON(BSON("a" << BSON_ARRAY(BSON_ARRAY(1 << 2 << 3))))); } TEST(InternalSchemaMaxItemsMatchExpression, NestedArraysWorkWithDottedPaths) { - InternalSchemaMaxItemsMatchExpression maxItems; - ASSERT_OK(maxItems.init("a.b", 2)); + InternalSchemaMaxItemsMatchExpression maxItems("a.b", 2); ASSERT(maxItems.matchesBSON(BSON("a" << BSON("b" << BSON_ARRAY(1))))); ASSERT(!maxItems.matchesBSON(BSON("a" << BSON("b" << BSON_ARRAY(1 << 2 << 3))))); diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_max_length.h b/src/mongo/db/matcher/schema/expression_internal_schema_max_length.h index a0e9cbad8bf..377b5b0f174 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_max_length.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_max_length.h @@ -36,9 +36,10 @@ namespace mongo { class InternalSchemaMaxLengthMatchExpression final : public InternalSchemaStrLengthMatchExpression { public: - InternalSchemaMaxLengthMatchExpression() - : InternalSchemaStrLengthMatchExpression(MatchType::INTERNAL_SCHEMA_MAX_LENGTH, - "$_internalSchemaMaxLength"_sd) {} + InternalSchemaMaxLengthMatchExpression(StringData path, long long strLen) + : InternalSchemaStrLengthMatchExpression( + MatchType::INTERNAL_SCHEMA_MAX_LENGTH, path, strLen, "$_internalSchemaMaxLength"_sd) { + } Validator getComparator() const final { return [strLen = strLen()](int lenWithoutNullTerm) { @@ -48,8 +49,7 @@ public: std::unique_ptr<MatchExpression> shallowClone() const final { std::unique_ptr<InternalSchemaMaxLengthMatchExpression> maxLen = - stdx::make_unique<InternalSchemaMaxLengthMatchExpression>(); - invariantOK(maxLen->init(path(), strLen())); + stdx::make_unique<InternalSchemaMaxLengthMatchExpression>(path(), strLen()); if (getTag()) { maxLen->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_max_length_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_max_length_test.cpp index 63b744fc829..55135c0c697 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_max_length_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_max_length_test.cpp @@ -38,8 +38,7 @@ namespace mongo { namespace { TEST(InternalSchemaMaxLengthMatchExpression, RejectsNonStringElements) { - InternalSchemaMaxLengthMatchExpression maxLength; - ASSERT_OK(maxLength.init("a", 1)); + InternalSchemaMaxLengthMatchExpression maxLength("a", 1); ASSERT_FALSE(maxLength.matchesBSON(BSON("a" << BSONObj()))); ASSERT_FALSE(maxLength.matchesBSON(BSON("a" << 1))); @@ -47,8 +46,7 @@ TEST(InternalSchemaMaxLengthMatchExpression, RejectsNonStringElements) { } TEST(InternalSchemaMaxLengthMatchExpression, RejectsStringsWithTooManyChars) { - InternalSchemaMaxLengthMatchExpression maxLength; - ASSERT_OK(maxLength.init("a", 2)); + InternalSchemaMaxLengthMatchExpression maxLength("a", 2); ASSERT_FALSE(maxLength.matchesBSON(BSON("a" << "abc"))); @@ -57,8 +55,7 @@ TEST(InternalSchemaMaxLengthMatchExpression, RejectsStringsWithTooManyChars) { } TEST(InternalSchemaMaxLengthMatchExpression, AcceptsStringsWithLessThanOrEqualToMax) { - InternalSchemaMaxLengthMatchExpression maxLength; - ASSERT_OK(maxLength.init("a", 2)); + InternalSchemaMaxLengthMatchExpression maxLength("a", 2); ASSERT_TRUE(maxLength.matchesBSON(BSON("a" << "ab"))); @@ -69,26 +66,21 @@ TEST(InternalSchemaMaxLengthMatchExpression, AcceptsStringsWithLessThanOrEqualTo } TEST(InternalSchemaMaxLengthMatchExpression, MaxLengthZeroAllowsEmptyString) { - InternalSchemaMaxLengthMatchExpression maxLength; - ASSERT_OK(maxLength.init("a", 0)); + InternalSchemaMaxLengthMatchExpression maxLength("a", 0); ASSERT_TRUE(maxLength.matchesBSON(BSON("a" << ""))); } TEST(InternalSchemaMaxLengthMatchExpression, RejectsNull) { - InternalSchemaMaxLengthMatchExpression maxLength; - ASSERT_OK(maxLength.init("a", 1)); + InternalSchemaMaxLengthMatchExpression maxLength("a", 1); ASSERT_FALSE(maxLength.matchesBSON(BSON("a" << BSONNULL))); } TEST(InternalSchemaMaxLengthMatchExpression, TreatsMultiByteCodepointAsOneCharacter) { - InternalSchemaMaxLengthMatchExpression nonMatchingMaxLength; - InternalSchemaMaxLengthMatchExpression matchingMaxLength; - - ASSERT_OK(nonMatchingMaxLength.init("a", 0)); - ASSERT_OK(matchingMaxLength.init("a", 1)); + InternalSchemaMaxLengthMatchExpression nonMatchingMaxLength("a", 0); + InternalSchemaMaxLengthMatchExpression matchingMaxLength("a", 1); // This string has one code point, so it should meet maximum length 1 but not maximum length 0. constexpr auto testString = u8"\U0001f4a9"; @@ -97,11 +89,8 @@ TEST(InternalSchemaMaxLengthMatchExpression, TreatsMultiByteCodepointAsOneCharac } TEST(InternalSchemaMaxLengthMatchExpression, CorectlyCountsUnicodeCodepoints) { - InternalSchemaMaxLengthMatchExpression nonMatchingMaxLength; - InternalSchemaMaxLengthMatchExpression matchingMaxLength; - - ASSERT_OK(nonMatchingMaxLength.init("a", 4)); - ASSERT_OK(matchingMaxLength.init("a", 5)); + InternalSchemaMaxLengthMatchExpression nonMatchingMaxLength("a", 4); + InternalSchemaMaxLengthMatchExpression matchingMaxLength("a", 5); // A test string that contains single-byte, 2-byte, 3-byte, and 4-byte codepoints. constexpr auto testString = @@ -118,9 +107,7 @@ TEST(InternalSchemaMaxLengthMatchExpression, CorectlyCountsUnicodeCodepoints) { } TEST(InternalSchemaMaxLengthMatchExpression, DealsWithInvalidUTF8) { - InternalSchemaMaxLengthMatchExpression maxLength; - - ASSERT_OK(maxLength.init("a", 1)); + InternalSchemaMaxLengthMatchExpression maxLength("a", 1); // Several kinds of invalid byte sequences listed in the Wikipedia article about UTF-8: // https://en.wikipedia.org/wiki/UTF-8 @@ -138,8 +125,7 @@ TEST(InternalSchemaMaxLengthMatchExpression, DealsWithInvalidUTF8) { } TEST(InternalSchemaMaxLengthMatchExpression, NestedArraysWorkWithDottedPaths) { - InternalSchemaMaxLengthMatchExpression maxLength; - ASSERT_OK(maxLength.init("a.b", 2)); + InternalSchemaMaxLengthMatchExpression maxLength("a.b", 2); ASSERT_TRUE(maxLength.matchesBSON(BSON("a" << BSON("b" << "a")))); @@ -150,22 +136,17 @@ TEST(InternalSchemaMaxLengthMatchExpression, NestedArraysWorkWithDottedPaths) { } TEST(InternalSchemaMaxLengthMatchExpression, SameMaxLengthTreatedEquivalent) { - InternalSchemaMaxLengthMatchExpression maxLength1; - InternalSchemaMaxLengthMatchExpression maxLength2; - InternalSchemaMaxLengthMatchExpression maxLength3; - ASSERT_OK(maxLength1.init("a", 2)); - ASSERT_OK(maxLength2.init("a", 2)); - ASSERT_OK(maxLength3.init("a", 3)); + InternalSchemaMaxLengthMatchExpression maxLength1("a", 2); + InternalSchemaMaxLengthMatchExpression maxLength2("a", 2); + InternalSchemaMaxLengthMatchExpression maxLength3("a", 3); ASSERT_TRUE(maxLength1.equivalent(&maxLength2)); ASSERT_FALSE(maxLength1.equivalent(&maxLength3)); } TEST(InternalSchemaMaxLengthMatchExpression, MinLengthAndMaxLengthAreNotEquivalent) { - InternalSchemaMinLengthMatchExpression minLength; - InternalSchemaMaxLengthMatchExpression maxLength; - ASSERT_OK(minLength.init("a", 2)); - ASSERT_OK(maxLength.init("a", 2)); + InternalSchemaMinLengthMatchExpression minLength("a", 2); + InternalSchemaMaxLengthMatchExpression maxLength("a", 2); ASSERT_FALSE(maxLength.equivalent(&minLength)); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_max_properties.h b/src/mongo/db/matcher/schema/expression_internal_schema_max_properties.h index 5736ca08017..82bc65dabef 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_max_properties.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_max_properties.h @@ -39,8 +39,9 @@ namespace mongo { class InternalSchemaMaxPropertiesMatchExpression final : public InternalSchemaNumPropertiesMatchExpression { public: - InternalSchemaMaxPropertiesMatchExpression() + explicit InternalSchemaMaxPropertiesMatchExpression(long long numProperties) : InternalSchemaNumPropertiesMatchExpression(MatchType::INTERNAL_SCHEMA_MAX_PROPERTIES, + numProperties, "$_internalSchemaMaxProperties") {} bool matches(const MatchableDocument* doc, MatchDetails* details) const final { @@ -57,8 +58,8 @@ public: } virtual std::unique_ptr<MatchExpression> shallowClone() const final { - auto maxProperties = stdx::make_unique<InternalSchemaMaxPropertiesMatchExpression>(); - invariantOK(maxProperties->init(numProperties())); + auto maxProperties = + stdx::make_unique<InternalSchemaMaxPropertiesMatchExpression>(numProperties()); if (getTag()) { maxProperties->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_max_properties_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_max_properties_test.cpp index c626bd81844..16c1c4f1fac 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_max_properties_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_max_properties_test.cpp @@ -38,16 +38,14 @@ namespace mongo { namespace { TEST(InternalSchemaMaxPropertiesMatchExpression, RejectsObjectsWithTooManyElements) { - InternalSchemaMaxPropertiesMatchExpression maxProperties; - ASSERT_OK(maxProperties.init(0)); + InternalSchemaMaxPropertiesMatchExpression maxProperties(0); ASSERT_FALSE(maxProperties.matchesBSON(BSON("b" << 21))); ASSERT_FALSE(maxProperties.matchesBSON(BSON("b" << 21 << "c" << 3))); } TEST(InternalSchemaMaxPropertiesMatchExpression, AcceptsObjectWithLessThanOrEqualToMaxElements) { - InternalSchemaMaxPropertiesMatchExpression maxProperties; - ASSERT_OK(maxProperties.init(2)); + InternalSchemaMaxPropertiesMatchExpression maxProperties(2); ASSERT_TRUE(maxProperties.matchesBSON(BSONObj())); ASSERT_TRUE(maxProperties.matchesBSON(BSON("b" << BSONNULL))); @@ -56,26 +54,21 @@ TEST(InternalSchemaMaxPropertiesMatchExpression, AcceptsObjectWithLessThanOrEqua } TEST(InternalSchemaMaxPropertiesMatchExpression, MaxPropertiesZeroAllowsEmptyObjects) { - InternalSchemaMaxPropertiesMatchExpression maxProperties; - ASSERT_OK(maxProperties.init(0)); + InternalSchemaMaxPropertiesMatchExpression maxProperties(0); ASSERT_TRUE(maxProperties.matchesBSON(BSONObj())); } TEST(InternalSchemaMaxPropertiesMatchExpression, NestedObjectsAreNotUnwound) { - InternalSchemaMaxPropertiesMatchExpression maxProperties; - ASSERT_OK(maxProperties.init(1)); + InternalSchemaMaxPropertiesMatchExpression maxProperties(1); ASSERT_TRUE(maxProperties.matchesBSON(BSON("b" << BSON("c" << 2 << "d" << 3)))); } TEST(InternalSchemaMaxPropertiesMatchExpression, EquivalentFunctionIsAccurate) { - InternalSchemaMaxPropertiesMatchExpression maxProperties1; - InternalSchemaMaxPropertiesMatchExpression maxProperties2; - InternalSchemaMaxPropertiesMatchExpression maxProperties3; - ASSERT_OK(maxProperties1.init(1)); - ASSERT_OK(maxProperties2.init(1)); - ASSERT_OK(maxProperties3.init(2)); + InternalSchemaMaxPropertiesMatchExpression maxProperties1(1); + InternalSchemaMaxPropertiesMatchExpression maxProperties2(1); + InternalSchemaMaxPropertiesMatchExpression maxProperties3(2); ASSERT_TRUE(maxProperties1.equivalent(&maxProperties1)); ASSERT_TRUE(maxProperties1.equivalent(&maxProperties2)); @@ -83,17 +76,14 @@ TEST(InternalSchemaMaxPropertiesMatchExpression, EquivalentFunctionIsAccurate) { } TEST(InternalSchemaMaxPropertiesMatchExpression, NestedArraysAreNotUnwound) { - InternalSchemaMaxPropertiesMatchExpression maxProperties; - ASSERT_OK(maxProperties.init(2)); + InternalSchemaMaxPropertiesMatchExpression maxProperties(2); ASSERT_TRUE(maxProperties.matchesBSON(BSON("a" << (BSON("b" << 2 << "c" << 3 << "d" << 4))))); } TEST(InternalSchemaMaxPropertiesMatchExpression, MinPropertiesNotEquivalentToMaxProperties) { - InternalSchemaMaxPropertiesMatchExpression maxProperties; - InternalSchemaMinPropertiesMatchExpression minProperties; - ASSERT_OK(maxProperties.init(5)); - ASSERT_OK(minProperties.init(5)); + InternalSchemaMaxPropertiesMatchExpression maxProperties(5); + InternalSchemaMinPropertiesMatchExpression minProperties(5); ASSERT_FALSE(maxProperties.equivalent(&minProperties)); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_min_items.h b/src/mongo/db/matcher/schema/expression_internal_schema_min_items.h index 82eb16b5511..3aaffb62347 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_min_items.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_min_items.h @@ -39,9 +39,9 @@ namespace mongo { class InternalSchemaMinItemsMatchExpression final : public InternalSchemaNumArrayItemsMatchExpression { public: - InternalSchemaMinItemsMatchExpression() - : InternalSchemaNumArrayItemsMatchExpression(INTERNAL_SCHEMA_MIN_ITEMS, - "$_internalSchemaMinItems"_sd) {} + InternalSchemaMinItemsMatchExpression(StringData path, long long numItems) + : InternalSchemaNumArrayItemsMatchExpression( + INTERNAL_SCHEMA_MIN_ITEMS, path, numItems, "$_internalSchemaMinItems"_sd) {} bool matchesArray(const BSONObj& anArray, MatchDetails* details) const final { return (anArray.nFields() >= numItems()); @@ -49,8 +49,7 @@ public: std::unique_ptr<MatchExpression> shallowClone() const final { std::unique_ptr<InternalSchemaMinItemsMatchExpression> minItems = - stdx::make_unique<InternalSchemaMinItemsMatchExpression>(); - invariantOK(minItems->init(path(), numItems())); + stdx::make_unique<InternalSchemaMinItemsMatchExpression>(path(), numItems()); if (getTag()) { minItems->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_min_items_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_min_items_test.cpp index 2f43c269c7f..1df2e453539 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_min_items_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_min_items_test.cpp @@ -36,8 +36,7 @@ namespace mongo { namespace { TEST(InternalSchemaMinItemsMatchExpression, RejectsNonArrayElements) { - InternalSchemaMinItemsMatchExpression minItems; - ASSERT_OK(minItems.init("a", 1)); + InternalSchemaMinItemsMatchExpression minItems("a", 1); ASSERT(!minItems.matchesBSON(BSON("a" << BSONObj()))); ASSERT(!minItems.matchesBSON(BSON("a" << 1))); @@ -46,46 +45,40 @@ TEST(InternalSchemaMinItemsMatchExpression, RejectsNonArrayElements) { } TEST(InternalSchemaMinItemsMatchExpression, RejectsArraysWithTooFewElements) { - InternalSchemaMinItemsMatchExpression minItems; - ASSERT_OK(minItems.init("a", 2)); + InternalSchemaMinItemsMatchExpression minItems("a", 2); ASSERT(!minItems.matchesBSON(BSON("a" << BSONArray()))); ASSERT(!minItems.matchesBSON(BSON("a" << BSON_ARRAY(1)))); } TEST(InternalSchemaMinItemsMatchExpression, AcceptsArrayWithAtLeastMinElements) { - InternalSchemaMinItemsMatchExpression minItems; - ASSERT_OK(minItems.init("a", 2)); + InternalSchemaMinItemsMatchExpression minItems("a", 2); ASSERT(minItems.matchesBSON(BSON("a" << BSON_ARRAY(1 << 2)))); ASSERT(minItems.matchesBSON(BSON("a" << BSON_ARRAY(1 << 2 << 3)))); } TEST(InternalSchemaMinItemsMatchExpression, MinItemsZeroAllowsEmptyArrays) { - InternalSchemaMinItemsMatchExpression minItems; - ASSERT_OK(minItems.init("a", 0)); + InternalSchemaMinItemsMatchExpression minItems("a", 0); ASSERT(minItems.matchesBSON(BSON("a" << BSONArray()))); } TEST(InternalSchemaMinItemsMatchExpression, NullArrayEntriesCountAsItems) { - InternalSchemaMinItemsMatchExpression minItems; - ASSERT_OK(minItems.init("a", 1)); + InternalSchemaMinItemsMatchExpression minItems("a", 1); ASSERT(minItems.matchesBSON(BSON("a" << BSON_ARRAY(BSONNULL)))); ASSERT(minItems.matchesBSON(BSON("a" << BSON_ARRAY(BSONNULL << 1)))); } TEST(InternalSchemaMinItemsMatchExpression, NestedArraysAreNotUnwound) { - InternalSchemaMinItemsMatchExpression minItems; - ASSERT_OK(minItems.init("a", 2)); + InternalSchemaMinItemsMatchExpression minItems("a", 2); ASSERT(!minItems.matchesBSON(BSON("a" << BSON_ARRAY(BSON_ARRAY(1 << 2))))); } TEST(InternalSchemaMinItemsMatchExpression, NestedArraysWorkWithDottedPaths) { - InternalSchemaMinItemsMatchExpression minItems; - ASSERT_OK(minItems.init("a.b", 2)); + InternalSchemaMinItemsMatchExpression minItems("a.b", 2); ASSERT(minItems.matchesBSON(BSON("a" << BSON("b" << BSON_ARRAY(1 << 2))))); ASSERT(!minItems.matchesBSON(BSON("a" << BSON("b" << BSON_ARRAY(1))))); diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_min_length.h b/src/mongo/db/matcher/schema/expression_internal_schema_min_length.h index 1d4d18da4e2..aad59831247 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_min_length.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_min_length.h @@ -36,9 +36,10 @@ namespace mongo { class InternalSchemaMinLengthMatchExpression final : public InternalSchemaStrLengthMatchExpression { public: - InternalSchemaMinLengthMatchExpression() - : InternalSchemaStrLengthMatchExpression(MatchType::INTERNAL_SCHEMA_MIN_LENGTH, - "$_internalSchemaMinLength"_sd) {} + InternalSchemaMinLengthMatchExpression(StringData path, long long strLen) + : InternalSchemaStrLengthMatchExpression( + MatchType::INTERNAL_SCHEMA_MIN_LENGTH, path, strLen, "$_internalSchemaMinLength"_sd) { + } Validator getComparator() const final { return [strLen = strLen()](int lenWithoutNullTerm) { @@ -48,8 +49,7 @@ public: std::unique_ptr<MatchExpression> shallowClone() const final { std::unique_ptr<InternalSchemaMinLengthMatchExpression> minLen = - stdx::make_unique<InternalSchemaMinLengthMatchExpression>(); - invariantOK(minLen->init(path(), strLen())); + stdx::make_unique<InternalSchemaMinLengthMatchExpression>(path(), strLen()); if (getTag()) { minLen->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_min_length_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_min_length_test.cpp index 2e72f8ea2ac..8fbdd695d0b 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_min_length_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_min_length_test.cpp @@ -37,8 +37,7 @@ namespace mongo { namespace { TEST(InternalSchemaMinLengthMatchExpression, RejectsNonStringElements) { - InternalSchemaMinLengthMatchExpression minLength; - ASSERT_OK(minLength.init("a", 1)); + InternalSchemaMinLengthMatchExpression minLength("a", 1); ASSERT_FALSE(minLength.matchesBSON(BSON("a" << BSONObj()))); ASSERT_FALSE(minLength.matchesBSON(BSON("a" << 1))); @@ -46,8 +45,7 @@ TEST(InternalSchemaMinLengthMatchExpression, RejectsNonStringElements) { } TEST(InternalSchemaMinLengthMatchExpression, RejectsStringsWithTooFewChars) { - InternalSchemaMinLengthMatchExpression minLength; - ASSERT_OK(minLength.init("a", 2)); + InternalSchemaMinLengthMatchExpression minLength("a", 2); ASSERT_FALSE(minLength.matchesBSON(BSON("a" << ""))); @@ -56,8 +54,7 @@ TEST(InternalSchemaMinLengthMatchExpression, RejectsStringsWithTooFewChars) { } TEST(InternalSchemaMinLengthMatchExpression, AcceptsStringWithAtLeastMinChars) { - InternalSchemaMinLengthMatchExpression minLength; - ASSERT_OK(minLength.init("a", 2)); + InternalSchemaMinLengthMatchExpression minLength("a", 2); ASSERT_TRUE(minLength.matchesBSON(BSON("a" << "ab"))); @@ -68,26 +65,21 @@ TEST(InternalSchemaMinLengthMatchExpression, AcceptsStringWithAtLeastMinChars) { } TEST(InternalSchemaMinLengthMatchExpression, MinLengthZeroAllowsEmptyString) { - InternalSchemaMinLengthMatchExpression minLength; - ASSERT_OK(minLength.init("a", 0)); + InternalSchemaMinLengthMatchExpression minLength("a", 0); ASSERT_TRUE(minLength.matchesBSON(BSON("a" << ""))); } TEST(InternalSchemaMinLengthMatchExpression, RejectsNull) { - InternalSchemaMinLengthMatchExpression minLength; - ASSERT_OK(minLength.init("a", 1)); + InternalSchemaMinLengthMatchExpression minLength("a", 1); ASSERT_FALSE(minLength.matchesBSON(BSON("a" << BSONNULL))); } TEST(InternalSchemaMinLengthMatchExpression, TreatsMultiByteCodepointAsOneCharacter) { - InternalSchemaMinLengthMatchExpression matchingMinLength; - InternalSchemaMinLengthMatchExpression nonMatchingMinLength; - - ASSERT_OK(matchingMinLength.init("a", 1)); - ASSERT_OK(nonMatchingMinLength.init("a", 2)); + InternalSchemaMinLengthMatchExpression matchingMinLength("a", 1); + InternalSchemaMinLengthMatchExpression nonMatchingMinLength("a", 2); // This string has one code point, so it should meet minimum length 1 but not minimum length 2. constexpr auto testString = u8"\U0001f4a9"; @@ -96,11 +88,8 @@ TEST(InternalSchemaMinLengthMatchExpression, TreatsMultiByteCodepointAsOneCharac } TEST(InternalSchemaMinLengthMatchExpression, CorectlyCountsUnicodeCodepoints) { - InternalSchemaMinLengthMatchExpression matchingMinLength; - InternalSchemaMinLengthMatchExpression nonMatchingMinLength; - - ASSERT_OK(matchingMinLength.init("a", 5)); - ASSERT_OK(nonMatchingMinLength.init("a", 6)); + InternalSchemaMinLengthMatchExpression matchingMinLength("a", 5); + InternalSchemaMinLengthMatchExpression nonMatchingMinLength("a", 6); // A test string that contains single-byte, 2-byte, 3-byte, and 4-byte code points. constexpr auto testString = @@ -117,9 +106,7 @@ TEST(InternalSchemaMinLengthMatchExpression, CorectlyCountsUnicodeCodepoints) { } TEST(InternalSchemaMinLengthMatchExpression, DealsWithInvalidUTF8) { - InternalSchemaMinLengthMatchExpression minLength; - - ASSERT_OK(minLength.init("a", 1)); + InternalSchemaMinLengthMatchExpression minLength("a", 1); // Several kinds of invalid byte sequences listed in the Wikipedia article about UTF-8: // https://en.wikipedia.org/wiki/UTF-8 @@ -137,8 +124,7 @@ TEST(InternalSchemaMinLengthMatchExpression, DealsWithInvalidUTF8) { } TEST(InternalSchemaMinLengthMatchExpression, NestedFieldsWorkWithDottedPaths) { - InternalSchemaMinLengthMatchExpression minLength; - ASSERT_OK(minLength.init("a.b", 2)); + InternalSchemaMinLengthMatchExpression minLength("a.b", 2); ASSERT_TRUE(minLength.matchesBSON(BSON("a" << BSON("b" << "ab")))); @@ -149,12 +135,9 @@ TEST(InternalSchemaMinLengthMatchExpression, NestedFieldsWorkWithDottedPaths) { } TEST(InternalSchemaMinLengthMatchExpression, SameMinLengthTreatedEquivalent) { - InternalSchemaMinLengthMatchExpression minLength1; - InternalSchemaMinLengthMatchExpression minLength2; - InternalSchemaMinLengthMatchExpression minLength3; - ASSERT_OK(minLength1.init("a", 2)); - ASSERT_OK(minLength2.init("a", 2)); - ASSERT_OK(minLength3.init("a", 3)); + InternalSchemaMinLengthMatchExpression minLength1("a", 2); + InternalSchemaMinLengthMatchExpression minLength2("a", 2); + InternalSchemaMinLengthMatchExpression minLength3("a", 3); ASSERT_TRUE(minLength1.equivalent(&minLength2)); ASSERT_FALSE(minLength1.equivalent(&minLength3)); diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_min_properties.h b/src/mongo/db/matcher/schema/expression_internal_schema_min_properties.h index b97506fd882..9ac68da48a3 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_min_properties.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_min_properties.h @@ -39,8 +39,9 @@ namespace mongo { class InternalSchemaMinPropertiesMatchExpression final : public InternalSchemaNumPropertiesMatchExpression { public: - InternalSchemaMinPropertiesMatchExpression() + explicit InternalSchemaMinPropertiesMatchExpression(long long numProperties) : InternalSchemaNumPropertiesMatchExpression(MatchType::INTERNAL_SCHEMA_MIN_PROPERTIES, + numProperties, "$_internalSchemaMinProperties") {} bool matches(const MatchableDocument* doc, MatchDetails* details) const final { @@ -57,8 +58,8 @@ public: } virtual std::unique_ptr<MatchExpression> shallowClone() const final { - auto minProperties = stdx::make_unique<InternalSchemaMinPropertiesMatchExpression>(); - invariantOK(minProperties->init(numProperties())); + auto minProperties = + stdx::make_unique<InternalSchemaMinPropertiesMatchExpression>(numProperties()); if (getTag()) { minProperties->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_min_properties_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_min_properties_test.cpp index e364180a7f9..1699c2a6fd4 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_min_properties_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_min_properties_test.cpp @@ -38,16 +38,14 @@ namespace mongo { namespace { TEST(InternalSchemaMinPropertiesMatchExpression, RejectsObjectsWithTooFewElements) { - InternalSchemaMinPropertiesMatchExpression minProperties; - ASSERT_OK(minProperties.init(2)); + InternalSchemaMinPropertiesMatchExpression minProperties(2); ASSERT_FALSE(minProperties.matchesBSON(BSONObj())); ASSERT_FALSE(minProperties.matchesBSON(BSON("b" << 21))); } TEST(InternalSchemaMinPropertiesMatchExpression, AcceptsObjectWithAtLeastMinElements) { - InternalSchemaMinPropertiesMatchExpression minProperties; - ASSERT_OK(minProperties.init(2)); + InternalSchemaMinPropertiesMatchExpression minProperties(2); ASSERT_TRUE(minProperties.matchesBSON(BSON("b" << 21 << "c" << BSONNULL))); ASSERT_TRUE(minProperties.matchesBSON(BSON("b" << 21 << "c" << 3))); @@ -55,33 +53,27 @@ TEST(InternalSchemaMinPropertiesMatchExpression, AcceptsObjectWithAtLeastMinElem } TEST(InternalSchemaMinPropertiesMatchExpression, MinPropertiesZeroAllowsEmptyObjects) { - InternalSchemaMinPropertiesMatchExpression minProperties; - ASSERT_OK(minProperties.init(0)); + InternalSchemaMinPropertiesMatchExpression minProperties(0); ASSERT_TRUE(minProperties.matchesBSON(BSONObj())); } TEST(InternalSchemaMinPropertiesMatchExpression, NestedObjectsAreNotUnwound) { - InternalSchemaMinPropertiesMatchExpression minProperties; - ASSERT_OK(minProperties.init(2)); + InternalSchemaMinPropertiesMatchExpression minProperties(2); ASSERT_FALSE(minProperties.matchesBSON(BSON("b" << BSON("c" << 2 << "d" << 3)))); } TEST(InternalSchemaMinPropertiesMatchExpression, NestedArraysAreNotUnwound) { - InternalSchemaMinPropertiesMatchExpression minProperties; - ASSERT_OK(minProperties.init(2)); + InternalSchemaMinPropertiesMatchExpression minProperties(2); ASSERT_FALSE(minProperties.matchesBSON(BSON("a" << (BSON("b" << 2 << "c" << 3 << "d" << 4))))); } TEST(InternalSchemaMinPropertiesMatchExpression, EquivalentFunctionIsAccurate) { - InternalSchemaMinPropertiesMatchExpression minProperties1; - InternalSchemaMinPropertiesMatchExpression minProperties2; - InternalSchemaMinPropertiesMatchExpression minProperties3; - ASSERT_OK(minProperties1.init(1)); - ASSERT_OK(minProperties2.init(1)); - ASSERT_OK(minProperties3.init(2)); + InternalSchemaMinPropertiesMatchExpression minProperties1(1); + InternalSchemaMinPropertiesMatchExpression minProperties2(1); + InternalSchemaMinPropertiesMatchExpression minProperties3(2); ASSERT_TRUE(minProperties1.equivalent(&minProperties1)); ASSERT_TRUE(minProperties1.equivalent(&minProperties2)); diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_num_array_items.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_num_array_items.cpp index f6a31657847..d5bc5069a35 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_num_array_items.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_num_array_items.cpp @@ -32,6 +32,10 @@ namespace mongo { +InternalSchemaNumArrayItemsMatchExpression::InternalSchemaNumArrayItemsMatchExpression( + MatchType type, StringData path, long long numItems, StringData name) + : ArrayMatchingMatchExpression(type, path), _name(name), _numItems(numItems) {} + void InternalSchemaNumArrayItemsMatchExpression::debugString(StringBuilder& debug, int level) const { _debugAddSpace(debug, level); diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_num_array_items.h b/src/mongo/db/matcher/schema/expression_internal_schema_num_array_items.h index 05dd873d772..b8db5a34258 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_num_array_items.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_num_array_items.h @@ -38,16 +38,13 @@ namespace mongo { */ class InternalSchemaNumArrayItemsMatchExpression : public ArrayMatchingMatchExpression { public: - InternalSchemaNumArrayItemsMatchExpression(MatchType type, StringData name) - : ArrayMatchingMatchExpression(type), _name(name) {} + InternalSchemaNumArrayItemsMatchExpression(MatchType type, + StringData path, + long long numItems, + StringData name); virtual ~InternalSchemaNumArrayItemsMatchExpression() {} - Status init(StringData path, long long numItems) { - _numItems = numItems; - return setPath(path); - } - void debugString(StringBuilder& debug, int level) const final; void serialize(BSONObjBuilder* out) const final; diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_num_properties.h b/src/mongo/db/matcher/schema/expression_internal_schema_num_properties.h index ced6529a668..541b30ebfe4 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_num_properties.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_num_properties.h @@ -39,16 +39,13 @@ namespace mongo { */ class InternalSchemaNumPropertiesMatchExpression : public MatchExpression { public: - InternalSchemaNumPropertiesMatchExpression(MatchType type, std::string name) - : MatchExpression(type), _name(name) {} + InternalSchemaNumPropertiesMatchExpression(MatchType type, + long long numProperties, + std::string name) + : MatchExpression(type), _numProperties(numProperties), _name(name) {} virtual ~InternalSchemaNumPropertiesMatchExpression() {} - Status init(long long numProperties) { - _numProperties = numProperties; - return Status::OK(); - } - size_t numChildren() const final { return 0; } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_object_match.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_object_match.cpp index 9e8d5ac702a..d6a8c05342b 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_object_match.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_object_match.cpp @@ -34,6 +34,12 @@ namespace mongo { constexpr StringData InternalSchemaObjectMatchExpression::kName; +InternalSchemaObjectMatchExpression::InternalSchemaObjectMatchExpression( + StringData path, std::unique_ptr<MatchExpression> expr) + : PathMatchExpression(INTERNAL_SCHEMA_OBJECT_MATCH, path), _sub(std::move(expr)) { + setTraverseLeafArray(); +} + bool InternalSchemaObjectMatchExpression::matchesSingleElement(const BSONElement& elem, MatchDetails* details) const { if (elem.type() != BSONType::Object) { @@ -65,8 +71,8 @@ bool InternalSchemaObjectMatchExpression::equivalent(const MatchExpression* othe } std::unique_ptr<MatchExpression> InternalSchemaObjectMatchExpression::shallowClone() const { - auto clone = stdx::make_unique<InternalSchemaObjectMatchExpression>(); - invariantOK(clone->init(_sub->shallowClone(), path())); + auto clone = + stdx::make_unique<InternalSchemaObjectMatchExpression>(path(), _sub->shallowClone()); if (getTag()) { clone->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_object_match.h b/src/mongo/db/matcher/schema/expression_internal_schema_object_match.h index ef328388c0b..776d35af6de 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_object_match.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_object_match.h @@ -36,12 +36,7 @@ class InternalSchemaObjectMatchExpression final : public PathMatchExpression { public: static constexpr StringData kName = "$_internalSchemaObjectMatch"_sd; - InternalSchemaObjectMatchExpression() : PathMatchExpression(INTERNAL_SCHEMA_OBJECT_MATCH) {} - - Status init(std::unique_ptr<MatchExpression> expr, StringData path) { - _sub = std::move(expr); - return setPath(path); - } + InternalSchemaObjectMatchExpression(StringData path, std::unique_ptr<MatchExpression> expr); bool matchesSingleElement(const BSONElement& elem, MatchDetails* details = nullptr) const final; diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_object_match_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_object_match_test.cpp index a6d0ff5b5f9..f6ad77e4e06 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_object_match_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_object_match_test.cpp @@ -45,8 +45,7 @@ TEST(InternalSchemaObjectMatchExpression, RejectsNonObjectElements) { auto subExpr = MatchExpressionParser::parse(BSON("b" << 1), expCtx); ASSERT_OK(subExpr.getStatus()); - InternalSchemaObjectMatchExpression objMatch; - ASSERT_OK(objMatch.init(std::move(subExpr.getValue()), "a"_sd)); + InternalSchemaObjectMatchExpression objMatch("a"_sd, std::move(subExpr.getValue())); ASSERT_FALSE(objMatch.matchesBSON(BSON("a" << 1))); ASSERT_FALSE(objMatch.matchesBSON(BSON("a" @@ -61,8 +60,7 @@ TEST(InternalSchemaObjectMatchExpression, RejectsObjectsThatDontMatch) { expCtx); ASSERT_OK(subExpr.getStatus()); - InternalSchemaObjectMatchExpression objMatch; - ASSERT_OK(objMatch.init(std::move(subExpr.getValue()), "a"_sd)); + InternalSchemaObjectMatchExpression objMatch("a"_sd, std::move(subExpr.getValue())); ASSERT_FALSE(objMatch.matchesBSON(BSON("a" << BSON("b" << 1)))); ASSERT_FALSE(objMatch.matchesBSON(BSON("a" << BSON("b" << BSONObj())))); @@ -75,8 +73,7 @@ TEST(InternalSchemaObjectMatchExpression, AcceptsObjectsThatMatch) { expCtx); ASSERT_OK(subExpr.getStatus()); - InternalSchemaObjectMatchExpression objMatch; - ASSERT_OK(objMatch.init(std::move(subExpr.getValue()), "a"_sd)); + InternalSchemaObjectMatchExpression objMatch("a"_sd, std::move(subExpr.getValue())); ASSERT_TRUE(objMatch.matchesBSON(BSON("a" << BSON("b" << "string")))); @@ -97,8 +94,7 @@ TEST(InternalSchemaObjectMatchExpression, DottedPathAcceptsObjectsThatMatch) { expCtx); ASSERT_OK(subExpr.getStatus()); - InternalSchemaObjectMatchExpression objMatch; - ASSERT_OK(objMatch.init(std::move(subExpr.getValue()), "a"_sd)); + InternalSchemaObjectMatchExpression objMatch("a"_sd, std::move(subExpr.getValue())); ASSERT_FALSE(objMatch.matchesBSON(BSON("a" << BSON("d" << "string")))); @@ -112,8 +108,7 @@ TEST(InternalSchemaObjectMatchExpression, EmptyMatchAcceptsAllObjects) { auto subExpr = MatchExpressionParser::parse(BSONObj(), expCtx); ASSERT_OK(subExpr.getStatus()); - InternalSchemaObjectMatchExpression objMatch; - ASSERT_OK(objMatch.init(std::move(subExpr.getValue()), "a"_sd)); + InternalSchemaObjectMatchExpression objMatch("a"_sd, std::move(subExpr.getValue())); ASSERT_FALSE(objMatch.matchesBSON(BSON("a" << 1))); ASSERT_FALSE(objMatch.matchesBSON(BSON("a" diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_root_doc_eq.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_root_doc_eq.cpp index c0a5bbf8922..2684533c465 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_root_doc_eq.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_root_doc_eq.cpp @@ -68,8 +68,7 @@ bool InternalSchemaRootDocEqMatchExpression::equivalent(const MatchExpression* o } std::unique_ptr<MatchExpression> InternalSchemaRootDocEqMatchExpression::shallowClone() const { - auto clone = stdx::make_unique<InternalSchemaRootDocEqMatchExpression>(); - clone->init(_rhsObj); + auto clone = stdx::make_unique<InternalSchemaRootDocEqMatchExpression>(_rhsObj.copy()); if (getTag()) { clone->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_root_doc_eq.h b/src/mongo/db/matcher/schema/expression_internal_schema_root_doc_eq.h index e6f53658eda..7ca66e89ca2 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_root_doc_eq.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_root_doc_eq.h @@ -45,12 +45,11 @@ class InternalSchemaRootDocEqMatchExpression final : public MatchExpression { public: static constexpr StringData kName = "$_internalSchemaRootDocEq"_sd; - InternalSchemaRootDocEqMatchExpression() - : MatchExpression(MatchExpression::INTERNAL_SCHEMA_ROOT_DOC_EQ) {} - - void init(BSONObj obj) { - _rhsObj = std::move(obj); - } + /** + * Constructs a new match expression, taking ownership of 'rhs'. + */ + explicit InternalSchemaRootDocEqMatchExpression(BSONObj rhs) + : MatchExpression(MatchExpression::INTERNAL_SCHEMA_ROOT_DOC_EQ), _rhsObj(std::move(rhs)) {} bool matches(const MatchableDocument* doc, MatchDetails* details = nullptr) const final; diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_root_doc_eq_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_root_doc_eq_test.cpp index ade721236d3..0a1e36d69c2 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_root_doc_eq_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_root_doc_eq_test.cpp @@ -38,9 +38,8 @@ namespace mongo { namespace { TEST(InternalSchemaRootDocEqMatchExpression, MatchesObject) { - InternalSchemaRootDocEqMatchExpression rootDocEq; - rootDocEq.init(BSON("a" << 1 << "b" - << "string")); + InternalSchemaRootDocEqMatchExpression rootDocEq(BSON("a" << 1 << "b" + << "string")); ASSERT_TRUE(rootDocEq.matchesBSON(BSON("a" << 1 << "b" << "string"))); ASSERT_FALSE(rootDocEq.matchesBSON(BSON("a" << 2 << "b" @@ -48,40 +47,34 @@ TEST(InternalSchemaRootDocEqMatchExpression, MatchesObject) { } TEST(InternalSchemaRootDocEqMatchExpression, MatchesNestedObject) { - InternalSchemaRootDocEqMatchExpression rootDocEq; - rootDocEq.init(BSON("a" << 1 << "b" << BSON("c" << 1))); + InternalSchemaRootDocEqMatchExpression rootDocEq(BSON("a" << 1 << "b" << BSON("c" << 1))); ASSERT_TRUE(rootDocEq.matchesBSON(BSON("a" << 1 << "b" << BSON("c" << 1)))); ASSERT_FALSE(rootDocEq.matchesBSON(BSON("a" << 1 << "b" << BSON("c" << 2)))); } TEST(InternalSchemaRootDocEqMatchExpression, MatchesObjectIgnoresElementOrder) { - InternalSchemaRootDocEqMatchExpression rootDocEq; - rootDocEq.init(BSON("a" << 1 << "b" << BSON("c" << 1))); + InternalSchemaRootDocEqMatchExpression rootDocEq(BSON("a" << 1 << "b" << BSON("c" << 1))); ASSERT_TRUE(rootDocEq.matchesBSON(BSON("b" << BSON("c" << 1) << "a" << 1))); } TEST(InternalSchemaRootDocEqMatchExpression, MatchesNestedObjectIgnoresElementOrder) { - InternalSchemaRootDocEqMatchExpression rootDocEq; - rootDocEq.init(BSON("a" << BSON("b" << 1 << "c" << 1))); + InternalSchemaRootDocEqMatchExpression rootDocEq(BSON("a" << BSON("b" << 1 << "c" << 1))); ASSERT_TRUE(rootDocEq.matchesBSON(BSON("a" << BSON("c" << 1 << "b" << 1)))); } TEST(InternalSchemaRootDocEqMatchExpression, MatchesEmptyObject) { - InternalSchemaRootDocEqMatchExpression rootDocEq; - rootDocEq.init(BSONObj()); + InternalSchemaRootDocEqMatchExpression rootDocEq{BSONObj()}; ASSERT_TRUE(rootDocEq.matchesBSON(BSONObj())); } TEST(InternalSchemaRootDocEqMatchExpression, MatchesNestedArray) { - InternalSchemaRootDocEqMatchExpression rootDocEq; - rootDocEq.init(BSON("a" << BSON_ARRAY(1 << 2 << 3))); + InternalSchemaRootDocEqMatchExpression rootDocEq(BSON("a" << BSON_ARRAY(1 << 2 << 3))); ASSERT_TRUE(rootDocEq.matchesBSON(BSON("a" << BSON_ARRAY(1 << 2 << 3)))); ASSERT_FALSE(rootDocEq.matchesBSON(BSON("a" << BSON_ARRAY(1 << 3 << 2)))); } TEST(InternalSchemaRootDocEqMatchExpression, MatchesObjectWithNullElement) { - InternalSchemaRootDocEqMatchExpression rootDocEq; - rootDocEq.init(fromjson("{a: null}")); + InternalSchemaRootDocEqMatchExpression rootDocEq(fromjson("{a: null}")); ASSERT_TRUE(rootDocEq.matchesBSON(fromjson("{a: null}"))); ASSERT_FALSE(rootDocEq.matchesBSON(fromjson("{a: 1}"))); ASSERT_FALSE(rootDocEq.matchesBSON(fromjson("{}"))); @@ -94,27 +87,28 @@ TEST(InternalSchemaRootDocEqMatchExpression, EquivalentReturnsCorrectResults) { b: 1, c: 1 }})"); boost::intrusive_ptr<ExpressionContextForTest> expCtx(new ExpressionContextForTest()); - Matcher rootDocEq(query, expCtx); + Matcher rootDocEq(std::move(query), expCtx); query = fromjson(R"( {$_internalSchemaRootDocEq: { c: 1, b: 1 }})"); - Matcher exprEq(query, expCtx); + Matcher exprEq(std::move(query), expCtx); ASSERT_TRUE(rootDocEq.getMatchExpression()->equivalent(exprEq.getMatchExpression())); query = fromjson(R"( {$_internalSchemaRootDocEq: { c: 1 }})"); - Matcher exprNotEq(query, expCtx); + Matcher exprNotEq(std::move(query), expCtx); ASSERT_FALSE(rootDocEq.getMatchExpression()->equivalent(exprNotEq.getMatchExpression())); } TEST(InternalSchemaRootDocEqMatchExpression, EquivalentToClone) { auto query = fromjson("{$_internalSchemaRootDocEq: {a:1, b: {c: 1, d: [1]}}}"); boost::intrusive_ptr<ExpressionContextForTest> expCtx(new ExpressionContextForTest()); - Matcher rootDocEq(query, expCtx); + Matcher rootDocEq(std::move(query), expCtx); + auto clone = rootDocEq.getMatchExpression()->shallowClone(); ASSERT_TRUE(rootDocEq.getMatchExpression()->equivalent(clone.get())); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_str_length.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_str_length.cpp index 02a7b8895e8..f01f3e80ba5 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_str_length.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_str_length.cpp @@ -34,6 +34,12 @@ namespace mongo { +InternalSchemaStrLengthMatchExpression::InternalSchemaStrLengthMatchExpression(MatchType type, + StringData path, + long long strLen, + StringData name) + : LeafMatchExpression(type, path), _name(name), _strLen(strLen) {} + void InternalSchemaStrLengthMatchExpression::debugString(StringBuilder& debug, int level) const { _debugAddSpace(debug, level); debug << path() << " " << _name << " " << _strLen << "\n"; diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_str_length.h b/src/mongo/db/matcher/schema/expression_internal_schema_str_length.h index 90830577432..2a00de506b9 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_str_length.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_str_length.h @@ -38,16 +38,13 @@ class InternalSchemaStrLengthMatchExpression : public LeafMatchExpression { public: using Validator = stdx::function<bool(int)>; - InternalSchemaStrLengthMatchExpression(MatchType type, StringData name) - : LeafMatchExpression(type), _name(name) {} + InternalSchemaStrLengthMatchExpression(MatchType type, + StringData path, + long long strLen, + StringData name); virtual ~InternalSchemaStrLengthMatchExpression() {} - Status init(StringData path, long long strLen) { - _strLen = strLen; - return setPath(path); - } - virtual Validator getComparator() const = 0; bool matchesSingleElement(const BSONElement& elem, diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_unique_items.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_unique_items.cpp index f35d14eb69b..bce1089077c 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_unique_items.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_unique_items.cpp @@ -64,8 +64,7 @@ void InternalSchemaUniqueItemsMatchExpression::serialize(BSONObjBuilder* builder } std::unique_ptr<MatchExpression> InternalSchemaUniqueItemsMatchExpression::shallowClone() const { - auto clone = stdx::make_unique<InternalSchemaUniqueItemsMatchExpression>(); - invariantOK(clone->init(path())); + auto clone = stdx::make_unique<InternalSchemaUniqueItemsMatchExpression>(path()); if (getTag()) { clone->setTag(getTag()->clone()); } diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_unique_items.h b/src/mongo/db/matcher/schema/expression_internal_schema_unique_items.h index f41b9e0ef34..5338d3fbcc6 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_unique_items.h +++ b/src/mongo/db/matcher/schema/expression_internal_schema_unique_items.h @@ -45,12 +45,8 @@ class InternalSchemaUniqueItemsMatchExpression final : public ArrayMatchingMatch public: static constexpr StringData kName = "$_internalSchemaUniqueItems"_sd; - InternalSchemaUniqueItemsMatchExpression() - : ArrayMatchingMatchExpression(MatchExpression::INTERNAL_SCHEMA_UNIQUE_ITEMS) {} - - Status init(StringData path) { - return setPath(path); - } + explicit InternalSchemaUniqueItemsMatchExpression(StringData path) + : ArrayMatchingMatchExpression(MatchExpression::INTERNAL_SCHEMA_UNIQUE_ITEMS, path) {} size_t numChildren() const final { return 0; diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_unique_items_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_unique_items_test.cpp index 5e9d1a119b4..46e3be31d41 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_unique_items_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_unique_items_test.cpp @@ -36,8 +36,7 @@ namespace mongo { namespace { TEST(InternalSchemaUniqueItemsMatchExpression, RejectsNonArrays) { - InternalSchemaUniqueItemsMatchExpression uniqueItems; - ASSERT_OK(uniqueItems.init("foo")); + InternalSchemaUniqueItemsMatchExpression uniqueItems("foo"); ASSERT_FALSE(uniqueItems.matchesBSON(BSON("foo" << 1))); ASSERT_FALSE(uniqueItems.matchesBSON(BSON("foo" << BSONObj()))); ASSERT_FALSE(uniqueItems.matchesBSON(BSON("foo" @@ -45,22 +44,19 @@ TEST(InternalSchemaUniqueItemsMatchExpression, RejectsNonArrays) { } TEST(InternalSchemaUniqueItemsMatchExpression, MatchesEmptyArray) { - InternalSchemaUniqueItemsMatchExpression uniqueItems; - ASSERT_OK(uniqueItems.init("foo")); + InternalSchemaUniqueItemsMatchExpression uniqueItems("foo"); ASSERT_TRUE(uniqueItems.matchesBSON(BSON("foo" << BSONArray()))); } TEST(InternalSchemaUniqueItemsMatchExpression, MatchesOneElementArray) { - InternalSchemaUniqueItemsMatchExpression uniqueItems; - ASSERT_OK(uniqueItems.init("foo")); + InternalSchemaUniqueItemsMatchExpression uniqueItems("foo"); ASSERT_TRUE(uniqueItems.matchesBSON(BSON("foo" << BSON_ARRAY(1)))); ASSERT_TRUE(uniqueItems.matchesBSON(BSON("foo" << BSON_ARRAY(BSONObj())))); ASSERT_TRUE(uniqueItems.matchesBSON(BSON("foo" << BSON_ARRAY(BSON_ARRAY(9 << "bar"))))); } TEST(InternalSchemaUniqueItemsMatchExpression, MatchesArrayOfUniqueItems) { - InternalSchemaUniqueItemsMatchExpression uniqueItems; - ASSERT_OK(uniqueItems.init("foo")); + InternalSchemaUniqueItemsMatchExpression uniqueItems("foo"); ASSERT_TRUE(uniqueItems.matchesBSON(fromjson("{foo: [1, 'bar', {}, [], null]}"))); ASSERT_TRUE(uniqueItems.matchesBSON(fromjson("{foo: [{x: 1}, {x: 2}, {x: 2, y: 3}]}"))); ASSERT_TRUE(uniqueItems.matchesBSON(fromjson("{foo: [[1], [1, 2], 1]}"))); @@ -68,8 +64,7 @@ TEST(InternalSchemaUniqueItemsMatchExpression, MatchesArrayOfUniqueItems) { } TEST(InternalSchemaUniqueItemsMatchExpression, MatchesNestedArrayOfUniqueItems) { - InternalSchemaUniqueItemsMatchExpression uniqueItems; - ASSERT_OK(uniqueItems.init("foo.bar")); + InternalSchemaUniqueItemsMatchExpression uniqueItems("foo.bar"); ASSERT_TRUE(uniqueItems.matchesBSON(fromjson("{foo: {bar: [1, 'bar', {}, [], null]}}"))); ASSERT_TRUE(uniqueItems.matchesBSON(fromjson("{foo: {bar: [{x: 1}, {x: 2}, {x: 2, y: 3}]}}"))); ASSERT_TRUE(uniqueItems.matchesBSON(fromjson("{foo: {bar: [[1], [1, 2], 1]}}"))); @@ -77,8 +72,7 @@ TEST(InternalSchemaUniqueItemsMatchExpression, MatchesNestedArrayOfUniqueItems) } TEST(InternalSchemaUniqueItemsMatchExpression, RejectsArrayWithDuplicates) { - InternalSchemaUniqueItemsMatchExpression uniqueItems; - ASSERT_OK(uniqueItems.init("foo")); + InternalSchemaUniqueItemsMatchExpression uniqueItems("foo"); ASSERT_FALSE(uniqueItems.matchesBSON(fromjson("{foo: [1, 1, 1]}"))); ASSERT_FALSE(uniqueItems.matchesBSON(fromjson("{foo: [['bar'], ['bar']]}"))); ASSERT_FALSE( @@ -86,8 +80,7 @@ TEST(InternalSchemaUniqueItemsMatchExpression, RejectsArrayWithDuplicates) { } TEST(InternalSchemaUniqueItemsMatchExpression, RejectsNestedArrayWithDuplicates) { - InternalSchemaUniqueItemsMatchExpression uniqueItems; - ASSERT_OK(uniqueItems.init("foo")); + InternalSchemaUniqueItemsMatchExpression uniqueItems("foo"); ASSERT_FALSE(uniqueItems.matchesBSON(fromjson("{foo: {bar: [1, 1, 1]}}"))); ASSERT_FALSE(uniqueItems.matchesBSON(fromjson("{foo: {bar: [['baz'], ['baz']]}}"))); ASSERT_FALSE(uniqueItems.matchesBSON( @@ -95,8 +88,7 @@ TEST(InternalSchemaUniqueItemsMatchExpression, RejectsNestedArrayWithDuplicates) } TEST(InternalSchemaUniqueItemsMatchExpression, FieldNameSignificantWhenComparingNestedObjects) { - InternalSchemaUniqueItemsMatchExpression uniqueItems; - ASSERT_OK(uniqueItems.init("foo")); + InternalSchemaUniqueItemsMatchExpression uniqueItems("foo"); ASSERT_TRUE(uniqueItems.matchesBSON(fromjson("{foo: [{x: 7}, {y: 7}]}"))); ASSERT_TRUE(uniqueItems.matchesBSON(fromjson("{foo: [{a: 'bar'}, {b: 'bar'}]}"))); ASSERT_FALSE(uniqueItems.matchesBSON(fromjson("{foo: [{a: 'bar'}, {a: 'bar'}]}"))); @@ -104,8 +96,7 @@ TEST(InternalSchemaUniqueItemsMatchExpression, FieldNameSignificantWhenComparing } TEST(InternalSchemaUniqueItemsMatchExpression, AlwaysUsesBinaryComparisonRegardlessOfCollator) { - InternalSchemaUniqueItemsMatchExpression uniqueItems; - ASSERT_OK(uniqueItems.init("foo")); + InternalSchemaUniqueItemsMatchExpression uniqueItems("foo"); CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual); uniqueItems.setCollator(&collator); diff --git a/src/mongo/db/matcher/schema/expression_internal_schema_xor_test.cpp b/src/mongo/db/matcher/schema/expression_internal_schema_xor_test.cpp index 60d7e4d90e8..0a982bfdba1 100644 --- a/src/mongo/db/matcher/schema/expression_internal_schema_xor_test.cpp +++ b/src/mongo/db/matcher/schema/expression_internal_schema_xor_test.cpp @@ -99,10 +99,8 @@ TEST(InternalSchemaXorOp, DoesNotUseElemMatchKey) { TEST(InternalSchemaXorOp, Equivalent) { BSONObj baseOperand1 = BSON("a" << 1); BSONObj baseOperand2 = BSON("b" << 2); - EqualityMatchExpression sub1; - ASSERT(sub1.init("a", baseOperand1["a"]).isOK()); - EqualityMatchExpression sub2; - ASSERT(sub2.init("b", baseOperand2["b"]).isOK()); + EqualityMatchExpression sub1("a", baseOperand1["a"]); + EqualityMatchExpression sub2("b", baseOperand2["b"]); InternalSchemaXorMatchExpression e1; e1.add(sub1.shallowClone().release()); diff --git a/src/mongo/db/matcher/schema/json_schema_parser.cpp b/src/mongo/db/matcher/schema/json_schema_parser.cpp index 8c107f0b759..fc1eedcc612 100644 --- a/src/mongo/db/matcher/schema/json_schema_parser.cpp +++ b/src/mongo/db/matcher/schema/json_schema_parser.cpp @@ -160,11 +160,9 @@ std::unique_ptr<MatchExpression> makeRestriction(const MatcherTypeSet& restricti // // We need to do this because restriction keywords do not apply when a field is either not // present or of a different type. - auto typeExpr = stdx::make_unique<InternalSchemaTypeExpression>(); - invariantOK(typeExpr->init(path, restrictionType)); + auto typeExpr = stdx::make_unique<InternalSchemaTypeExpression>(path, restrictionType); - auto notExpr = stdx::make_unique<NotMatchExpression>(); - invariantOK(notExpr->init(typeExpr.release())); + auto notExpr = stdx::make_unique<NotMatchExpression>(typeExpr.release()); auto orExpr = stdx::make_unique<OrMatchExpression>(); orExpr->add(notExpr.release()); @@ -228,11 +226,8 @@ StatusWith<std::unique_ptr<InternalSchemaTypeExpression>> parseType( << "' must name at least one type")}; } - auto typeExpr = stdx::make_unique<InternalSchemaTypeExpression>(); - auto initStatus = typeExpr->init(path, std::move(typeSet.getValue())); - if (!initStatus.isOK()) { - return initStatus; - } + auto typeExpr = + stdx::make_unique<InternalSchemaTypeExpression>(path, std::move(typeSet.getValue())); return {std::move(typeExpr)}; } @@ -254,13 +249,9 @@ StatusWithMatchExpression parseMaximum(StringData path, std::unique_ptr<ComparisonMatchExpression> expr; if (isExclusiveMaximum) { - expr = stdx::make_unique<LTMatchExpression>(); + expr = stdx::make_unique<LTMatchExpression>(path, maximum); } else { - expr = stdx::make_unique<LTEMatchExpression>(); - } - auto status = expr->init(path, maximum); - if (!status.isOK()) { - return status; + expr = stdx::make_unique<LTEMatchExpression>(path, maximum); } MatcherTypeSet restrictionType; @@ -285,13 +276,9 @@ StatusWithMatchExpression parseMinimum(StringData path, std::unique_ptr<ComparisonMatchExpression> expr; if (isExclusiveMinimum) { - expr = stdx::make_unique<GTMatchExpression>(); + expr = stdx::make_unique<GTMatchExpression>(path, minimum); } else { - expr = stdx::make_unique<GTEMatchExpression>(); - } - auto status = expr->init(path, minimum); - if (!status.isOK()) { - return status; + expr = stdx::make_unique<GTEMatchExpression>(path, minimum); } MatcherTypeSet restrictionType; @@ -316,11 +303,7 @@ StatusWithMatchExpression parseLength(StringData path, return {stdx::make_unique<AlwaysTrueMatchExpression>()}; } - auto expr = stdx::make_unique<T>(); - auto status = expr->init(path, parsedLength.getValue()); - if (!status.isOK()) { - return status; - } + auto expr = stdx::make_unique<T>(path, parsedLength.getValue()); return makeRestriction(restrictionType, path, std::move(expr), typeExpr); } @@ -337,14 +320,11 @@ StatusWithMatchExpression parsePattern(StringData path, return {stdx::make_unique<AlwaysTrueMatchExpression>()}; } - auto expr = stdx::make_unique<RegexMatchExpression>(); - // JSON Schema does not allow regex flags to be specified. constexpr auto emptyFlags = ""; - auto status = expr->init(path, pattern.valueStringData(), emptyFlags); - if (!status.isOK()) { - return status; - } + auto expr = + stdx::make_unique<RegexMatchExpression>(path, pattern.valueStringData(), emptyFlags); + return makeRestriction(BSONType::String, path, std::move(expr), typeExpr); } @@ -366,11 +346,8 @@ StatusWithMatchExpression parseMultipleOf(StringData path, return {stdx::make_unique<AlwaysTrueMatchExpression>()}; } - auto expr = stdx::make_unique<InternalSchemaFmodMatchExpression>(); - auto status = expr->init(path, multipleOf.numberDecimal(), Decimal128(0)); - if (!status.isOK()) { - return status; - } + auto expr = stdx::make_unique<InternalSchemaFmodMatchExpression>( + path, multipleOf.numberDecimal(), Decimal128(0)); MatcherTypeSet restrictionType; restrictionType.allNumbers = true; @@ -445,16 +422,12 @@ StatusWithMatchExpression parseEnum(StringData path, BSONElement enumElement) { // Top-level non-object enum values can be safely ignored, since MongoDB only stores // objects, not scalars or arrays. if (arrayElem.type() == BSONType::Object) { - auto rootDocEq = stdx::make_unique<InternalSchemaRootDocEqMatchExpression>(); - rootDocEq->init(arrayElem.embeddedObject()); + auto rootDocEq = stdx::make_unique<InternalSchemaRootDocEqMatchExpression>( + arrayElem.embeddedObject()); orExpr->add(rootDocEq.release()); } } else { - auto eqExpr = stdx::make_unique<InternalSchemaEqMatchExpression>(); - auto initStatus = eqExpr->init(path, arrayElem); - if (!initStatus.isOK()) { - return initStatus; - } + auto eqExpr = stdx::make_unique<InternalSchemaEqMatchExpression>(path, arrayElem); orExpr->add(eqExpr.release()); } @@ -520,17 +493,13 @@ StatusWithMatchExpression translateRequired( auto andExpr = stdx::make_unique<AndMatchExpression>(); for (auto&& propertyName : requiredProperties) { - auto existsExpr = stdx::make_unique<ExistsMatchExpression>(); - invariantOK(existsExpr->init(propertyName)); + auto existsExpr = stdx::make_unique<ExistsMatchExpression>(propertyName); if (path.empty()) { andExpr->add(existsExpr.release()); } else { - auto objectMatch = stdx::make_unique<InternalSchemaObjectMatchExpression>(); - auto objectMatchStatus = objectMatch->init(std::move(existsExpr), path); - if (!objectMatchStatus.isOK()) { - return objectMatchStatus; - } + auto objectMatch = + stdx::make_unique<InternalSchemaObjectMatchExpression>(path, std::move(existsExpr)); andExpr->add(objectMatch.release()); } @@ -580,11 +549,10 @@ StatusWithMatchExpression parseProperties( } else { // This property either must not exist or must match the nested schema. Therefore, we // generate the match expression (OR (NOT (EXISTS)) <nestedSchemaMatch>). - auto existsExpr = stdx::make_unique<ExistsMatchExpression>(); - invariantOK(existsExpr->init(property.fieldNameStringData())); + auto existsExpr = + stdx::make_unique<ExistsMatchExpression>(property.fieldNameStringData()); - auto notExpr = stdx::make_unique<NotMatchExpression>(); - invariantOK(notExpr->init(existsExpr.release())); + auto notExpr = stdx::make_unique<NotMatchExpression>(existsExpr.release()); auto orExpr = stdx::make_unique<OrMatchExpression>(); orExpr->add(notExpr.release()); @@ -600,11 +568,8 @@ StatusWithMatchExpression parseProperties( return {std::move(andExpr)}; } - auto objectMatch = stdx::make_unique<InternalSchemaObjectMatchExpression>(); - auto objectMatchStatus = objectMatch->init(std::move(andExpr), path); - if (!objectMatchStatus.isOK()) { - return objectMatchStatus; - } + auto objectMatch = + stdx::make_unique<InternalSchemaObjectMatchExpression>(path, std::move(andExpr)); return makeRestriction(BSONType::Object, path, std::move(objectMatch), typeExpr); } @@ -717,15 +682,11 @@ StatusWithMatchExpression parseAllowedProperties(StringData path, auto otherwiseWithPlaceholder = stdx::make_unique<ExpressionWithPlaceholder>( kNamePlaceholder.toString(), std::move(otherwiseExpr.getValue())); - auto allowedPropertiesExpr = - stdx::make_unique<InternalSchemaAllowedPropertiesMatchExpression>(); - auto status = allowedPropertiesExpr->init(std::move(propertyNames), - kNamePlaceholder, - std::move(patternProperties.getValue()), - std::move(otherwiseWithPlaceholder)); - if (!status.isOK()) { - return status; - } + auto allowedPropertiesExpr = stdx::make_unique<InternalSchemaAllowedPropertiesMatchExpression>( + std::move(propertyNames), + kNamePlaceholder, + std::move(patternProperties.getValue()), + std::move(otherwiseWithPlaceholder)); // If this is a top-level schema, then we have no path and there is no need for an explicit // object match node. @@ -733,11 +694,8 @@ StatusWithMatchExpression parseAllowedProperties(StringData path, return {std::move(allowedPropertiesExpr)}; } - auto objectMatch = stdx::make_unique<InternalSchemaObjectMatchExpression>(); - auto objectMatchStatus = objectMatch->init(std::move(allowedPropertiesExpr), path); - if (!objectMatchStatus.isOK()) { - return objectMatchStatus; - } + auto objectMatch = stdx::make_unique<InternalSchemaObjectMatchExpression>( + path, std::move(allowedPropertiesExpr)); return makeRestriction(BSONType::Object, path, std::move(objectMatch), typeExpr); } @@ -755,39 +713,28 @@ StatusWithMatchExpression parseNumProperties(StringData path, return parsedNumProps.getStatus(); } - auto expr = stdx::make_unique<T>(); - auto status = expr->init(parsedNumProps.getValue()); - if (!status.isOK()) { - return status; - } + auto expr = stdx::make_unique<T>(parsedNumProps.getValue()); if (path.empty()) { // This is a top-level schema. return {std::move(expr)}; } - auto objectMatch = stdx::make_unique<InternalSchemaObjectMatchExpression>(); - auto objectMatchStatus = objectMatch->init(std::move(expr), path); - if (!objectMatchStatus.isOK()) { - return objectMatchStatus; - } + auto objectMatch = + stdx::make_unique<InternalSchemaObjectMatchExpression>(path, std::move(expr)); return makeRestriction(BSONType::Object, path, std::move(objectMatch), typeExpr); } StatusWithMatchExpression makeDependencyExistsClause(StringData path, StringData dependencyName) { - auto existsExpr = stdx::make_unique<ExistsMatchExpression>(); - invariantOK(existsExpr->init(dependencyName)); + auto existsExpr = stdx::make_unique<ExistsMatchExpression>(dependencyName); if (path.empty()) { return {std::move(existsExpr)}; } - auto objectMatch = stdx::make_unique<InternalSchemaObjectMatchExpression>(); - auto status = objectMatch->init(std::move(existsExpr), path); - if (!status.isOK()) { - return status; - } + auto objectMatch = + stdx::make_unique<InternalSchemaObjectMatchExpression>(path, std::move(existsExpr)); return {std::move(objectMatch)}; } @@ -807,10 +754,12 @@ StatusWithMatchExpression translateSchemaDependency(StringData path, return ifClause.getStatus(); } - auto condExpr = stdx::make_unique<InternalSchemaCondMatchExpression>(); - condExpr->init({std::move(ifClause.getValue()), - std::move(nestedSchemaMatch.getValue()), - stdx::make_unique<AlwaysTrueMatchExpression>()}); + std::array<std::unique_ptr<MatchExpression>, 3> expressions = { + std::move(ifClause.getValue()), + std::move(nestedSchemaMatch.getValue()), + stdx::make_unique<AlwaysTrueMatchExpression>()}; + + auto condExpr = stdx::make_unique<InternalSchemaCondMatchExpression>(std::move(expressions)); return {std::move(condExpr)}; } @@ -861,10 +810,12 @@ StatusWithMatchExpression translatePropertyDependency(StringData path, BSONEleme return ifClause.getStatus(); } - auto condExpr = stdx::make_unique<InternalSchemaCondMatchExpression>(); - condExpr->init({std::move(ifClause.getValue()), - std::move(propertyDependencyExpr), - stdx::make_unique<AlwaysTrueMatchExpression>()}); + std::array<std::unique_ptr<MatchExpression>, 3> expressions = { + {std::move(ifClause.getValue()), + std::move(propertyDependencyExpr), + stdx::make_unique<AlwaysTrueMatchExpression>()}}; + + auto condExpr = stdx::make_unique<InternalSchemaCondMatchExpression>(std::move(expressions)); return {std::move(condExpr)}; } @@ -910,11 +861,7 @@ StatusWithMatchExpression parseUniqueItems(BSONElement uniqueItemsElt, } else if (path.empty()) { return {stdx::make_unique<AlwaysTrueMatchExpression>()}; } else if (uniqueItemsElt.boolean()) { - auto uniqueItemsExpr = stdx::make_unique<InternalSchemaUniqueItemsMatchExpression>(); - auto status = uniqueItemsExpr->init(path); - if (!status.isOK()) { - return status; - } + auto uniqueItemsExpr = stdx::make_unique<InternalSchemaUniqueItemsMatchExpression>(path); return makeRestriction(BSONType::Array, path, std::move(uniqueItemsExpr), typeExpr); } @@ -954,9 +901,8 @@ StatusWith<boost::optional<long long>> parseItems(StringData path, } auto exprWithPlaceholder = stdx::make_unique<ExpressionWithPlaceholder>( kNamePlaceholder.toString(), std::move(parsedSubschema.getValue())); - auto matchArrayIndex = - stdx::make_unique<InternalSchemaMatchArrayIndexMatchExpression>(); - invariantOK(matchArrayIndex->init(path, index, std::move(exprWithPlaceholder))); + auto matchArrayIndex = stdx::make_unique<InternalSchemaMatchArrayIndexMatchExpression>( + path, index, std::move(exprWithPlaceholder)); andExprForSubschemas->add(matchArrayIndex.release()); ++index; } @@ -984,11 +930,10 @@ StatusWith<boost::optional<long long>> parseItems(StringData path, if (path.empty()) { andExpr->add(stdx::make_unique<AlwaysTrueMatchExpression>().release()); } else { - auto allElemMatch = - stdx::make_unique<InternalSchemaAllElemMatchFromIndexMatchExpression>(); constexpr auto startIndexForItems = 0LL; - invariantOK( - allElemMatch->init(path, startIndexForItems, std::move(exprWithPlaceholder))); + auto allElemMatch = + stdx::make_unique<InternalSchemaAllElemMatchFromIndexMatchExpression>( + path, startIndexForItems, std::move(exprWithPlaceholder)); andExpr->add(makeRestriction(BSONType::Array, path, std::move(allElemMatch), typeExpr) .release()); } @@ -1039,9 +984,8 @@ Status parseAdditionalItems(StringData path, andExpr->add(stdx::make_unique<AlwaysTrueMatchExpression>().release()); } else { auto allElemMatch = - stdx::make_unique<InternalSchemaAllElemMatchFromIndexMatchExpression>(); - invariantOK( - allElemMatch->init(path, *startIndexForAdditionalItems, std::move(otherwiseExpr))); + stdx::make_unique<InternalSchemaAllElemMatchFromIndexMatchExpression>( + path, *startIndexForAdditionalItems, std::move(otherwiseExpr)); andExpr->add(makeRestriction(BSONType::Array, path, std::move(allElemMatch), typeExpr) .release()); } @@ -1129,11 +1073,7 @@ Status translateLogicalKeywords(StringMap<BSONElement>* keywordMap, return parsedExpr.getStatus(); } - auto notMatchExpr = stdx::make_unique<NotMatchExpression>(); - auto initStatus = notMatchExpr->init(parsedExpr.getValue().release()); - if (!initStatus.isOK()) { - return initStatus; - } + auto notMatchExpr = stdx::make_unique<NotMatchExpression>(parsedExpr.getValue().release()); andExpr->add(notMatchExpr.release()); } @@ -1556,11 +1496,14 @@ constexpr StringData JSONSchemaParser::kSchemaTypeString; StatusWithMatchExpression JSONSchemaParser::parse(BSONObj schema, bool ignoreUnknownKeywords) { LOG(5) << "Parsing JSON Schema: " << schema.jsonString(); - - auto translation = _parse(""_sd, schema, ignoreUnknownKeywords); - if (shouldLog(logger::LogSeverity::Debug(5)) && translation.isOK()) { - LOG(5) << "Translated schema match expression: " << translation.getValue()->toString(); + try { + auto translation = _parse(""_sd, schema, ignoreUnknownKeywords); + if (shouldLog(logger::LogSeverity::Debug(5)) && translation.isOK()) { + LOG(5) << "Translated schema match expression: " << translation.getValue()->toString(); + } + return translation; + } catch (const DBException& ex) { + return {ex.toStatus()}; } - return translation; } } // namespace mongo diff --git a/src/mongo/db/pipeline/document_source_match.cpp b/src/mongo/db/pipeline/document_source_match.cpp index 358775136cd..9d3b6365266 100644 --- a/src/mongo/db/pipeline/document_source_match.cpp +++ b/src/mongo/db/pipeline/document_source_match.cpp @@ -447,10 +447,10 @@ boost::intrusive_ptr<DocumentSourceMatch> DocumentSourceMatch::descendMatchOnPat if (node->getCategory() == MatchExpression::MatchCategory::kLeaf && node->matchType() != MatchExpression::TYPE_OPERATOR) { auto leafNode = static_cast<LeafMatchExpression*>(node); - leafNode->setPath(newPath).transitional_ignore(); + leafNode->setPath(newPath); } else if (node->getCategory() == MatchExpression::MatchCategory::kArrayMatching) { auto arrayNode = static_cast<ArrayMatchingMatchExpression*>(node); - arrayNode->setPath(newPath).transitional_ignore(); + arrayNode->setPath(newPath); } }); diff --git a/src/mongo/db/query/planner_analysis_test.cpp b/src/mongo/db/query/planner_analysis_test.cpp index 783438a482c..23d794fd41c 100644 --- a/src/mongo/db/query/planner_analysis_test.cpp +++ b/src/mongo/db/query/planner_analysis_test.cpp @@ -177,10 +177,10 @@ TEST(QueryPlannerAnalysis, GeoSkipValidation) { QueryPlannerParams params; std::unique_ptr<FetchNode> fetchNodePtr = stdx::make_unique<FetchNode>(); - std::unique_ptr<GeoMatchExpression> exprPtr = stdx::make_unique<GeoMatchExpression>(); + std::unique_ptr<GeoMatchExpression> exprPtr = + stdx::make_unique<GeoMatchExpression>("geometry.field", nullptr, BSONObj()); GeoMatchExpression* expr = exprPtr.get(); - expr->init("geometry.field", nullptr, BSONObj()).transitional_ignore(); FetchNode* fetchNode = fetchNodePtr.get(); // Takes ownership. diff --git a/src/mongo/dbtests/extensions_callback_real_test.cpp b/src/mongo/dbtests/extensions_callback_real_test.cpp index 7ea4e6a4af0..2e342f06645 100644 --- a/src/mongo/dbtests/extensions_callback_real_test.cpp +++ b/src/mongo/dbtests/extensions_callback_real_test.cpp @@ -79,11 +79,10 @@ protected: TEST_F(ExtensionsCallbackRealTest, TextNoIndex) { BSONObj query = fromjson("{$text: {$search:\"awesome\"}}"); - StatusWithMatchExpression result = - ExtensionsCallbackReal(&_opCtx, &_nss).parseText(query.firstElement()); - - ASSERT_NOT_OK(result.getStatus()); - ASSERT_EQ(ErrorCodes::IndexNotFound, result.getStatus()); + ASSERT_THROWS_CODE(StatusWithMatchExpression result( + ExtensionsCallbackReal(&_opCtx, &_nss).parseText(query.firstElement())), + AssertionException, + ErrorCodes::IndexNotFound); } TEST_F(ExtensionsCallbackRealTest, TextBasic) { @@ -116,10 +115,10 @@ TEST_F(ExtensionsCallbackRealTest, TextLanguageError) { false)); // isUnique BSONObj query = fromjson("{$text: {$search:\"awesome\", $language:\"spanglish\"}}"); - StatusWithMatchExpression result = - ExtensionsCallbackReal(&_opCtx, &_nss).parseText(query.firstElement()); - - ASSERT_NOT_OK(result.getStatus()); + ASSERT_THROWS_CODE(StatusWithMatchExpression result( + ExtensionsCallbackReal(&_opCtx, &_nss).parseText(query.firstElement())), + AssertionException, + ErrorCodes::BadValue); } TEST_F(ExtensionsCallbackRealTest, TextCaseSensitiveTrue) { diff --git a/src/mongo/s/shard_key_pattern.cpp b/src/mongo/s/shard_key_pattern.cpp index 549e753ea65..409bc54ec83 100644 --- a/src/mongo/s/shard_key_pattern.cpp +++ b/src/mongo/s/shard_key_pattern.cpp @@ -209,7 +209,7 @@ BSONObj ShardKeyPattern::normalizeShardKey(const BSONObj& shardKey) const { static BSONElement extractKeyElementFromMatchable(const MatchableDocument& matchable, StringData pathStr) { ElementPath path; - path.init(pathStr).transitional_ignore(); + path.init(pathStr); path.setTraverseNonleafArrays(false); path.setTraverseLeafArray(false); |