apacheGH-46777: [C++] Use SimplifyIsIn only when the value_set of the expression is lower than a threshold (apache#46859)

### Rationale for this change

Using `SimplifyIsIn` when the value set is large has a substantial performance penalty.

### What changes are included in this PR?

Ensure we do not use the simplification when the value_set on the expression is higher than a threshold (50).

### Are these changes tested?

I've tested locally that the reproducer goes back to pre change levels.
```
$ python read.py 
=== PYARROW VERSION 20 ===
Retrieved 10,000,000 rows in 3.08 seconds.
```

I have added a test for large sets and validate the expression is not being modified.

### Are there any user-facing changes?

No

* GitHub Issue: apache#46777

Lead-authored-by: Raúl Cumplido <[email protected]>
Co-authored-by: Antoine Pitrou <[email protected]>
Signed-off-by: Raúl Cumplido <[email protected]>

Author: raulcd

cpp/src/arrow/compute/expression.cc

@@ -1267,6 +1267,15 @@ struct Inequality {
 
     auto options = checked_pointer_cast<SetLookupOptions>(is_in_call->options);
 
+    // The maximum number of values in the is_in expression set of values
+    // in order to use the simplification.
+    // If the set is large there are performance implications, see:
+    // https://github.com/apache/arrow/issues/46777
+    constexpr int16_t kIsInSimplificationMaxValueSet = 50;
+    if (options->value_set.length() > kIsInSimplificationMaxValueSet) {
+      return std::nullopt;
+    }
+
     const auto& lhs = Comparison::StripOrderPreservingCasts(is_in_call->arguments[0]);
     if (!lhs.field_ref()) return std::nullopt;
     if (*lhs.field_ref() != guarantee.target) return std::nullopt;

cpp/src/arrow/compute/expression_test.cc

@@ -80,6 +80,16 @@ Expression add(Expression l, Expression r) {
   return call("add", {std::move(l), std::move(r)});
 }
 
+std::string make_range_json(int start, int end) {
+  std::string result = "[";
+  for (int i = start; i <= end; ++i) {
+    if (i > start) result += ",";
+    result += std::to_string(i);
+  }
+  result += "]";
+  return result;
+}
+
 const auto no_change = std::nullopt;
 
 TEST(ExpressionUtils, Comparison) {
@@ -1679,6 +1689,16 @@ TEST(Expression, SimplifyIsIn) {
     Simplify{is_in(field_ref("u32"), int64(), "[1,3,5,7,9]", null_matching)}
         .WithGuarantee(greater(field_ref("u32"), literal(3)))
         .Expect(is_in(field_ref("u32"), int64(), "[5,7,9]", null_matching));
+
+    Simplify{is_in(field_ref("u32"), int64(), make_range_json(1, 40), null_matching)}
+        .WithGuarantee(greater(field_ref("u32"), literal(10)))
+        .Expect(is_in(field_ref("u32"), int64(), make_range_json(11, 40), null_matching));
+
+    // For large ranges we don't do any simplification, see
+    // `kIsInSimplificationMaxValueSet` in expression.cc.
+    Simplify{is_in(field_ref("u32"), int64(), make_range_json(1, 100), null_matching)}
+        .WithGuarantee(greater(field_ref("u32"), literal(3)))
+        .ExpectUnchanged();
   }
 
   Simplify{