Regression in string matching in 4.3

[JoelCourtney]

I am trying to match a string with regex, but with an exception for a specific string like so:

let query = new Query({
  str: {
    $regex: ".*MATCH",
    $not: "NOT_A_MATCH"
  }
});

console.log(query.test({
  str: "NOT_A_MATCH"
}));
// expected: false

In 4.2 this query correctly returns false. In 4.3 and later this now returns true. In this simple case I can workaround by removing the $not and making the regex a little more complex, but this still seems like a bug.

[kofrasa]

Hi @JoelCourtney, thanks for the report. Your query is incorrect but due to weak input validation the library does not throw an error. Only a single operator is processed when specified for a field, which in this will be the $regex operator.

The string "NOT_A_MATCH" does match the regex /.*MATCH/, so the expected return is true.

The behaviour in 4.2.0 was incorrect.

Also the value for $not is invalid see https://www.mongodb.com/docs/manual/reference/operator/query/not/.

[JoelCourtney]

@kofrasa Thanks for responding. My bad with the $not operator. If I'm understanding you right though, I'd expect this query to behave oddly too:

let query = new Query({
  num: {
    $gt: 0,
    $ne: 5
  }
});

console.log(query.test({
  num // see below
}));

When num: 0, it prints false, when num: 3 it prints true, and when num: 5 it prints false. This seems to mean that both operators are being applied and implicitly and'ed together. Is this a bug?

EDIT num: 0 used to be num: 1. That was a typo.

[kofrasa]

Both operators are applied and ANDed together however the results you described is wrong. The outputs should be true for both 1 and 3, and false for 5. Perhaps you are still testing on 4.3.0. The bug if fixed in the new version. You can run the test here. https://runkit.com/embed/6py5m6di0nl5

[JoelCourtney]

Ah that was a typo, I meant 0 instead of 1. Regardless, this still doesn't make sense:

Only a single operator is processed when specified for a field

Both operators are applied and ANDed together

Those statements seem to directly contradict each other. Why does this query only apply one operator and ignores the other:

str: {
  $regex: ".*MATCH",
  $ne: "NOT_A_MATCH"
}

But this query applies both:

num: {
  $gt: 0,
  $ne: 5
}

[kofrasa]

Sorry for the confusion. The first statement is false in the context of using the Query object. All the operators in the expression are processed and the results ANDed together.

The first statement is only true for pipeline and expression operators.

[JoelCourtney]

Thanks for clarifying. Then do you agree that there is a bug here? Here's a section from the mongo docs that uses the exact same pattern that I'm trying to use. If you use this query in mingo 4.3 or higher: { name: { $regex: /acme.*corp/i, $nin: [ 'acmeblahcorp' ] } }, and test the object {name: 'acmeblahcorp'}, it incorrectly returns true. In 4.2 it returns false.

[kofrasa]

Yes there is a bug. I see what you mean. The behaviour is inconsistent specifically with $regex matching.