docs: private boolean indexCovers(Index newIndex, Index existingIndex) {
          assert(newIndex.getParent().getTypeName().equals(existingIndex.getParent().getTypeName()));
  
          // non-unique indexes don't help with this check
          if (existingIndex.getUnique() == false) {
              return false;
          }
  
          // expression indexes only help if they are on exactly the same expressions in the same order.
          // OK -- that's obviously overspecifying the requirement, since expression order has nothing
          // to do with it, and uniqueness of just a subset of the new index expressions would do, but
          // that's hard to check for, so we punt on optimized dynamic update except for the critical
          // case of grand-fathering in a surviving pre-existing index.
          if (existingIndex.getExpressionsjson().length() > 0) {
              if (existingIndex.getExpressionsjson().equals(newIndex.getExpressionsjson())) {
                  return true;
              } else {
                  return false;
              }
          } else if (newIndex.getExpressionsjson().length() > 0) {
              // A column index does not generally provide coverage for an expression index,
              // though there are some special cases not being recognized, here,
              // like expression indexes that list a mix of non-column expressions and unique columns.
              return false;
          }
  
          // partial indexes must have identical predicates
          if (existingIndex.getPredicatejson().length() > 0) {
              if (existingIndex.getPredicatejson().equals(newIndex.getPredicatejson())) {
                  return true;
              } else {
                  return false;
              }
          } else if (newIndex.getPredicatejson().length() > 0) {
              return false;
          }
  
          // iterate over all of the existing columns
          for (ColumnRef existingColRef : existingIndex.getColumns()) {
              boolean foundMatch = false;
              // see if the current column is also in the candidate index
              // for now, assume the tables in question have the same schema
              for (ColumnRef colRef : newIndex.getColumns()) {
                  String colName1 = colRef.getColumn().getName();
                  String colName2 = existingColRef.getColumn().getName();
                  if (colName1.equals(colName2)) {
                      foundMatch = true;
                      break;
                  }
              }
              // if this column isn't covered
              if (!foundMatch) {
                  return false;
              }
          }
  
          // There exists a unique index that contains a subset of the columns in the new index
          return true;
      }