docs: private ResultSet read(ConsistencyLevel cl, int retryCount) {
  
      System.out.printf("Reading at %s (retry count: %d)%n", cl, retryCount);
  
      Statement stmt =
          SimpleStatement.newInstance(
                  "SELECT sensor_id, date, timestamp, value "
                      + "FROM downgrading.sensor_data "
                      + "WHERE "
                      + "sensor_id = 756716f7-2e54-4715-9f00-91dcbea6cf50 AND "
                      + "date = '2018-02-26' AND "
                      + "timestamp > '2018-02-26+01:00'")
              .setConsistencyLevel(cl);
  
      try {
  
        ResultSet rows = session.execute(stmt);
        System.out.println("Read succeeded at " + cl);
        return rows;
  
      } catch (DriverException e) {
  
        if (retryCount == maxRetries) {
          throw e;
        }
  
        e = unwrapAllNodesFailedException(e);
  
        System.out.println("Read failed: " + e);
  
        // General intent: downgrade and retry at the highest consistency level
        // that is likely to succeed.
  
        if (e instanceof UnavailableException) {
  
          // Downgrade to the number of replicas reported alive and retry.
          int aliveReplicas = ((UnavailableException) e).getAlive();
  
          ConsistencyLevel downgraded = downgrade(cl, aliveReplicas, e);
          return read(downgraded, retryCount + 1);
  
        } else if (e instanceof ReadTimeoutException) {
  
          ReadTimeoutException readTimeout = (ReadTimeoutException) e;
          int received = readTimeout.getReceived();
          int required = readTimeout.getBlockFor();
  
          // If fewer replicas responded than required by the consistency level
          // (but at least one replica did respond), retry with a consistency level
          // equal to the number of received acknowledgements.
          if (received < required) {
  
            ConsistencyLevel downgraded = downgrade(cl, received, e);
            return read(downgraded, retryCount + 1);
          }
  
          // If we received enough replies to meet the consistency level,
          // but the actual data was not present among the received responses,
          // then retry with the initial consistency level, we might be luckier next time
          // and get the data back.
          if (!readTimeout.wasDataPresent()) {
  
            return read(cl, retryCount + 1);
          }
  
          // Otherwise, abort since the read timeout is unlikely to be solved by a retry.
          throw e;
  
        } else {
  
          // Unexpected error: just retry with same consistency level
          // and hope to talk to a healthier coordinator.
          return read(cl, retryCount + 1);
        }
      }
    }