docs: protected void addHonoraryOrderByExpressions(
              HashSet<AbstractExpression> orderByExprs,
              List<ParsedColInfo> candidateColumns) {
          // If there is not exactly one table scan we will not proceed.
          // We don't really know how to make indices work with joins,
          // and there is nothing more to do with subqueries.  The processing
          // of joins is the content of ticket ENG-8677.
          if (m_tableAliasMap.size() != 1) {
              return;
          }
  
          HashMap<AbstractExpression, Set<AbstractExpression>> valueEquivalence =
                  analyzeValueEquivalence();
          for (ParsedColInfo colInfo : candidateColumns) {
              AbstractExpression colExpr = colInfo.m_expression;
              if (colExpr instanceof TupleValueExpression) {
                  Set<AbstractExpression> tveEquivs = valueEquivalence.get(colExpr);
                  if (tveEquivs != null) {
                      for (AbstractExpression expr : tveEquivs) {
                          if (expr instanceof ParameterValueExpression
                                  || expr instanceof ConstantValueExpression) {
                              orderByExprs.add(colExpr);
                          }
                      }
                  }
              }
          }
          // We know there's exactly one.
          StmtTableScan scan = m_tableAliasMap.values().iterator().next();
          // Get the table.  There's only one.
          Table table = getTableFromDB(scan.getTableName());
          // Maybe this is a subquery?  If we can't find the table
          // there's no use to continue.
          if (table == null) {
              return;
          }
          // Now, look to see if there is a constraint which can help us.
          // If there is a unique constraint on a set of columns, and all
          // the constrained columns are in the order by list, then all
          // the columns in the table can be added to the order by list.
          //
          // The indices we care about have columns, but the order by list has expressions.
          // Extract the columns from the order by list.
          Set<Column> orderByColumns = new HashSet<>();
          for (AbstractExpression expr : orderByExprs) {
              if (expr instanceof TupleValueExpression) {
                  TupleValueExpression tve = (TupleValueExpression) expr;
                  Column col = table.getColumns().get(tve.getColumnName());
                  orderByColumns.add(col);
              }
          }
          CatalogMap<Constraint> constraints = table.getConstraints();
          // If we have no constraints, there's nothing more to do here.
          if (constraints == null) {
              return;
          }
  
          Set<Index> indices = new HashSet<>();
          for (Constraint constraint : constraints) {
              Index index = constraint.getIndex();
              // Only use column indices for now.
              if (index != null && index.getUnique() && index.getExpressionsjson().isEmpty()) {
                  indices.add(index);
              }
          }
          for (ParsedColInfo colInfo : candidateColumns) {
              AbstractExpression expr = colInfo.m_expression;
              if (expr instanceof TupleValueExpression) {
                  TupleValueExpression tve = (TupleValueExpression) expr;
                  // If one of the indices is completely covered
                  // we will not have to process any other indices.
                  // So, we remember this and early-out.
                  for (Index index : indices) {
                      CatalogMap<ColumnRef> columns = index.getColumns();
                      // If all the columns in this index are in the current
                      // honorary order by list, then we can add all the
                      // columns in this table to the honorary order by list.
                      boolean addAllColumns = true;
                      for (ColumnRef cr : columns) {
                          Column col = cr.getColumn();
                          if (orderByColumns.contains(col) == false) {
                              addAllColumns = false;
                              break;
                          }
                      }
                      if (addAllColumns) {
                          for (Column addCol : table.getColumns()) {
                              // We have to convert this to a TVE to add
                              // it to the orderByExprs.  We will use -1
                              // for the column index.  We don't have a column
                              // alias.
                              TupleValueExpression ntve = new TupleValueExpression(tve.getTableName(),
                                                                                   tve.getTableAlias(),
                                                                                   addCol.getName(),
                                                                                   null,
                                                                                   -1);
                              orderByExprs.add(ntve);
                          }
                          // Don't forget to remember to forget the other indices.  (E. Presley, 1955)
                          break;
                      }
                  }
              }
          }
      }