docs: protected ArrayList<AccessPath> getRelevantAccessPathsForTable(StmtTableScan tableScan,
              List<AbstractExpression> joinExprs,
              List<AbstractExpression> filterExprs,
              List<AbstractExpression> postExprs) {
          ArrayList<AccessPath> paths = new ArrayList<>();
          List<AbstractExpression> allJoinExprs = new ArrayList<>();
          List<AbstractExpression> allExprs = new ArrayList<>();
          // add the empty seq-scan access path
          if (joinExprs != null) {
              allExprs.addAll(joinExprs);
              allJoinExprs.addAll(joinExprs);
          }
          if (postExprs != null) {
              allJoinExprs.addAll(postExprs);
          }
          if (filterExprs != null) {
              allExprs.addAll(filterExprs);
          }
  
          AccessPath naivePath = getRelevantNaivePath(allJoinExprs, filterExprs);
          paths.add(naivePath);
  
          Collection<Index> indexes = tableScan.getIndexes();
          for (Index index : indexes) {
              AccessPath path = getRelevantAccessPathForIndex(tableScan, allExprs, index);
  
              // Process the index WHERE clause into a list of anded
              // sub-expressions and process each sub-expression, searching the
              // query (or matview) WHERE clause for an expression to cover each
              // of them. Coverage can be in the form of an identical filter or
              // a more restrictive filter. Specifically, comparison filters like
              // "X > 1" cover the index predicate filter "X is not null" but are
              // not an exact match. As such, they are not completely optimized
              // out by use of the partial index.
              // The partial index's WHERE sub-expressions must be covered to
              // allow ANY use of the index.
              // Of the covering sub-expressions (from the query or view),
              // those that also EXACTLY match their covered index sub-expression
              // are tracked in exactMatchCoveringExprs so that they
              // can be eliminated from the post-filter expressions.
              List<AbstractExpression> exactMatchCoveringExprs = null;
              boolean hasCoveredPredicate = false;
              String predicatejson = index.getPredicatejson();
              if (path == null) {
                  if (predicatejson.isEmpty()) {
                      // Skip the uselessly irrelevant whole-table index.
                      continue;
                  }
                  exactMatchCoveringExprs = new ArrayList<>();
                  hasCoveredPredicate = isPartialIndexPredicateCovered(
                              tableScan, allExprs,
                              predicatejson, exactMatchCoveringExprs);
                  if ( ! hasCoveredPredicate) {
                      // Skip the index with the inapplicable predicate.
                      continue;
                  }
                  // The partial index with a covered predicate can be used
                  // solely to eliminate a post-filter or even just to reduce the
                  // number of post-filtered tuples,
                  // even though its indexed columns are irrelevant -- so
                  // getRelevantAccessPathForIndex did not return a valid path.
                  // Override the path for a forward scan of the entire partial
                  // index.  The irrelevant keys of the index are ignored.
                  path = getRelevantNaivePath(allJoinExprs, filterExprs);
                  path.index = index;
                  path.lookupType = IndexLookupType.GTE;
              }
              else {
                  assert(path.index != null);
                  assert(path.index == index);
                  // This index on relevant column(s) may need to be rejected if
                  // its predicate is not applicable.
                  if ( ! predicatejson.isEmpty()) {
                      exactMatchCoveringExprs = new ArrayList<>();
                      hasCoveredPredicate = isPartialIndexPredicateCovered(
                              tableScan, allExprs, predicatejson, exactMatchCoveringExprs);
                      if ( ! hasCoveredPredicate) {
                          // Skip the index with the inapplicable predicate.
                          continue;
                      }
                  }
              }
  
              assert(path != null);
              if (hasCoveredPredicate) {
                  assert(exactMatchCoveringExprs != null);
                  filterPostPredicateForPartialIndex(path,
                          exactMatchCoveringExprs);
              }
              if (postExprs != null) {
                  path.joinExprs.addAll(postExprs);
              }
              paths.add(path);
          }
  
          return paths;
      }