docs: public static boolean isPartialIndexPredicateCovered(StmtTableScan tableScan,
              List<AbstractExpression> coveringExprs,
              String predicatejson,
              List<AbstractExpression> exactMatchCoveringExprs) {
          assert ( ! predicatejson.isEmpty());
          AbstractExpression indexPredicate = null;
          try {
              indexPredicate = AbstractExpression.fromJSONString(predicatejson, tableScan);
          } catch (JSONException e) {
              e.printStackTrace();
              assert(false);
              return false;
          }
          List<AbstractExpression> exprsToCover = ExpressionUtil.uncombinePredicate(indexPredicate);
  
          for (AbstractExpression coveringExpr : coveringExprs) {
              if (exprsToCover.isEmpty()) {
                  // We are done there. All the index predicate expressions are covered.
                  break;
              }
  
              // Each covering expression and its reversed copy need to be tested for the index expression coverage.
              AbstractExpression reversedCoveringExpr = null;
              ExpressionType reverseCoveringType = ComparisonExpression.reverses.get(coveringExpr.getExpressionType());
              if (reverseCoveringType != null) {
                  // reverse the expression
                  reversedCoveringExpr = new ComparisonExpression(
                          reverseCoveringType, coveringExpr.getRight(), coveringExpr.getLeft());
              }
              // Exact match first.
              if (removeExactMatchCoveredExpressions(coveringExpr, exprsToCover)) {
                  exactMatchCoveringExprs.add(coveringExpr);
              }
              // Try the reversed expression for the exact match
              if (reversedCoveringExpr != null && removeExactMatchCoveredExpressions(reversedCoveringExpr, exprsToCover)) {
                  // It is the original expression that we need to remember
                  exactMatchCoveringExprs.add(coveringExpr);
              }
          }
  
          // Handle the remaining NOT NULL index predicate expressions that can be covered by NULL rejecting expressions
          exprsToCover = removeNotNullCoveredExpressions(tableScan, coveringExprs, exprsToCover);
  
          // All index predicate expressions must be covered for index to be selected
          return exprsToCover.isEmpty();
      }