docs: private static AbstractPlanNode getIndexAccessPlanForTable(
              StmtTableScan tableScan, AccessPath path) {
          // now assume this will be an index scan and get the relevant index
          Index index = path.index;
          IndexScanPlanNode scanNode = new IndexScanPlanNode(tableScan, index);
          AbstractPlanNode resultNode = scanNode;
          // set sortDirection here because it might be used for IN list
          scanNode.setSortDirection(path.sortDirection);
          // Build the list of search-keys for the index in question
          // They are the rhs expressions of normalized indexExpr comparisons
          // except for geo indexes. For geo indexes, the search key is directly
          // the one element of indexExprs.
          for (AbstractExpression expr : path.indexExprs) {
              if (path.lookupType == IndexLookupType.GEO_CONTAINS) {
                  scanNode.addSearchKeyExpression(expr);
                  scanNode.addCompareNotDistinctFlag(false);
                  continue;
              }
              AbstractExpression exprRightChild = expr.getRight();
              assert(exprRightChild != null);
              if (expr.getExpressionType() == ExpressionType.COMPARE_IN) {
                  // Replace this method's result with an injected NLIJ.
                  resultNode = injectIndexedJoinWithMaterializedScan(exprRightChild, scanNode);
                  // Extract a TVE from the LHS MaterializedScan for use by the IndexScan in its new role.
                  MaterializedScanPlanNode matscan = (MaterializedScanPlanNode)resultNode.getChild(0);
                  AbstractExpression elemExpr = matscan.getOutputExpression();
                  assert(elemExpr != null);
                  // Replace the IN LIST condition in the end expression referencing all the list elements
                  // with a more efficient equality filter referencing the TVE for each element in turn.
                  replaceInListFilterWithEqualityFilter(path.endExprs, exprRightChild, elemExpr);
                  // Set up the similar VectorValue --> TVE replacement of the search key expression.
                  exprRightChild = elemExpr;
              }
              if (exprRightChild instanceof AbstractSubqueryExpression) {
                  // The AbstractSubqueryExpression must be wrapped up into a
                  // ScalarValueExpression which extracts the actual row/column from
                  // the subquery
                  // ENG-8175: this part of code seems not working for float/varchar type index ?!
  
                  // DEAD CODE with the guards on index: ENG-8203
                  assert(false);
              }
              scanNode.addSearchKeyExpression(exprRightChild);
              // If the index expression is an "IS NOT DISTINCT FROM" comparison, let the NULL values go through. (ENG-11096)
              scanNode.addCompareNotDistinctFlag(expr.getExpressionType() == ExpressionType.COMPARE_NOTDISTINCT);
          }
          // create the IndexScanNode with all its metadata
          scanNode.setLookupType(path.lookupType);
          scanNode.setBindings(path.bindings);
          scanNode.setEndExpression(ExpressionUtil.combinePredicates(path.endExprs));
          if (! path.index.getPredicatejson().isEmpty()) {
              try {
                  scanNode.setPartialIndexPredicate(
                          AbstractExpression.fromJSONString(path.index.getPredicatejson(), tableScan));
              } catch (JSONException e) {
                  throw new PlanningErrorException(e.getMessage(), 0);
              }
          }
          scanNode.setPredicate(path.otherExprs);
          // Propagate the sorting information
          // into the scan node from the access path.
          // The initial expression is needed to control a (short?) forward scan to adjust the start of a reverse
          // iteration after it had to initially settle for starting at "greater than a prefix key".
          scanNode.setInitialExpression(ExpressionUtil.combinePredicates(path.initialExpr));
          scanNode.setSkipNullPredicate();
          scanNode.setEliminatedPostFilters(path.eliminatedPostExprs);
          final IndexUseForOrderBy indexUse = scanNode.indexUse();
          indexUse.setWindowFunctionUsesIndex(path.m_windowFunctionUsesIndex);
          indexUse.setSortOrderFromIndexScan(path.sortDirection);
          indexUse.setWindowFunctionIsCompatibleWithOrderBy(path.m_stmtOrderByIsCompatible);
          indexUse.setFinalExpressionOrderFromIndexScan(path.m_finalExpressionOrder);
          return resultNode;
      }