docs: private void diffRecursively(CatalogType prevType, CatalogType newType)
      {
          assert(prevType != null) : "Null previous object found in catalog diff traversal.";
          assert(newType != null) : "Null new object found in catalog diff traversal";
  
          Object materializerValue = null;
          // Consider shifting into the strict more required within materialized view definitions.
          if (prevType instanceof Table) {
              // Under normal circumstances, it's highly unlikely that another (nested?) table will
              // appear in the details of a materialized view table. So, when it does (!?), be sure to
              // complain -- and don't let it throw off the accounting of the strict diff mode.
              // That is, don't set the local "materializerValue".
              if (m_inStrictMatViewDiffMode) {
                  // Maybe this should log or append to m_errors?
                  System.out.println("ERROR: unexpected nesting of a Table in CatalogDiffEngine.");
              } else {
                  materializerValue = prevType.getField("materializer");
                  if (materializerValue != null) {
                      // This table is a materialized view, so the changes to it and its children are
                      // strictly limited, e.g. no adding/dropping columns.
                      // In a future development, such changes may be allowed, but they may be implemented
                      // differently (get different catalog commands), such as through a wholesale drop/add
                      // of the entire view and materialized table definitions.
                      // The non-null local "materializerValue" is a reminder to pop out of this mode
                      // before returning from this level of the recursion.
                      m_inStrictMatViewDiffMode = true;
                      if (m_triggeredVerbosity) {
                          System.out.println("DEBUG VERBOSE diffRecursively entering strict mat view mode");
                      }
                  }
              }
          }
  
          // diff local fields
          for (String field : prevType.getFields()) {
              // this field is (or was) set at runtime, so ignore it for diff purposes
              if (field.equals("isUp"))
              {
                  continue;
              }
  
              boolean verbosityTriggeredHere = false;
              if (( ! m_triggeredVerbosity) && field.equals(m_triggerForVerbosity)) {
                  System.out.println("DEBUG VERBOSE diffRecursively verbosity (triggered by field '" + field + "' is ON");
                  verbosityTriggeredHere = true;
                  m_triggeredVerbosity = true;
              }
              // check if the types are different
              // options are: both null => same
              //              one null and one not => different
              //              both not null => check Object.equals()
              Object prevValue = prevType.getField(field);
              Object newValue = newType.getField(field);
              if ((prevValue == null) != (newValue == null)) {
                  if (m_triggeredVerbosity) {
                      if (prevValue == null) {
                          System.out.println("DEBUG VERBOSE diffRecursively found new '" + field + "' only.");
                      } else {
                          System.out.println("DEBUG VERBOSE diffRecursively found prev '" + field + "' only.");
                      }
                  }
                  writeModification(newType, prevType, field);
              }
              // if they're both not null (above/below ifs implies this)
              else if (prevValue != null) {
                  // if comparing CatalogTypes (both must be same)
                  if (prevValue instanceof CatalogType) {
                      assert(newValue instanceof CatalogType);
                      String prevPath = ((CatalogType) prevValue).getCatalogPath();
                      String newPath = ((CatalogType) newValue).getCatalogPath();
                      if (prevPath.compareTo(newPath) != 0) {
                          if (m_triggeredVerbosity) {
                              int padWidth = StringUtils.indexOfDifference(prevPath, newPath);
                              String pad = StringUtils.repeat(" ", padWidth);
                              System.out.println("DEBUG VERBOSE diffRecursively found a path change to '" + field + "':");
                              System.out.println("DEBUG VERBOSE prevPath=" + prevPath);
                              System.out.println("DEBUG VERBOSE diff at->" + pad + "^ position:" + padWidth);
                              System.out.println("DEBUG VERBOSE  newPath=" + newPath);
                          }
                          writeModification(newType, prevType, field);
                      }
                  }
                  // if scalar types
                  else {
                      if (prevValue.equals(newValue) == false) {
                          if (m_triggeredVerbosity) {
                              System.out.println("DEBUG VERBOSE diffRecursively found a scalar change to '" + field + "':");
                              System.out.println("DEBUG VERBOSE diffRecursively prev: " + prevValue);
                              System.out.println("DEBUG VERBOSE diffRecursively new : " + newValue);
                              if (field.equals("plannodetree")) {
                                  try {
                                      System.out.println("DEBUG VERBOSE where prev plannodetree expands to: " +
                                              new String(CompressionService.decodeBase64AndDecompressToBytes((String)prevValue), "UTF-8"));
                                  }
                                  catch (Exception e) {
                                      try {
                                          System.out.println("DEBUG VERBOSE where prev plannodetree expands to: " +
                                                  new String(Encoder.decodeBase64AndDecompressToBytes((String)prevValue), "UTF-8"));
                                      }
                                      catch (UnsupportedEncodingException e2) {}
                                  }
                                  try {
                                      System.out.println("DEBUG VERBOSE where new plannodetree expands to: " +
                                              new String(CompressionService.decodeBase64AndDecompressToBytes((String)newValue), "UTF-8"));
                                  }
                                  catch (Exception e) {
                                      try {
                                          System.out.println("DEBUG VERBOSE where new plannodetree expands to: " +
                                                  new String(Encoder.decodeBase64AndDecompressToBytes((String)newValue), "UTF-8"));
                                      }
                                      catch (UnsupportedEncodingException e2) {}
                                  }
                              }
                          }
                          writeModification(newType, prevType, field);
                      }
                  }
              }
              if (verbosityTriggeredHere) {
                  System.out.println("DEBUG VERBOSE diffRecursively verbosity is OFF");
                  m_triggeredVerbosity = false;
              }
          }
  
          // recurse
          for (String field : prevType.getChildCollections()) {
              boolean verbosityTriggeredHere = false;
              if (field.equals(m_triggerForVerbosity)) {
                  System.out.println("DEBUG VERBOSE diffRecursively verbosity ON");
                  m_triggeredVerbosity = true;
                  verbosityTriggeredHere = true;
              }
              CatalogMap<? extends CatalogType> prevMap = prevType.getCollection(field);
              CatalogMap<? extends CatalogType> newMap = newType.getCollection(field);
              getCommandsToDiff(field, prevMap, newMap);
              if (verbosityTriggeredHere) {
                  System.out.println("DEBUG VERBOSE diffRecursively verbosity OFF");
                  m_triggeredVerbosity = false;
              }
          }
  
          if (materializerValue != null) {
              // Just getting back from recursing into a materialized view table,
              // so drop the strictness required only in that context.
              // It's safe to assume that the prior mode to which this must pop back is the non-strict
              // mode because nesting of table definitions is unpossible AND we guarded against its
              // potential side effects, above, anyway.
              m_inStrictMatViewDiffMode = false;
          }
  
      }