docs: public static void runScript(Database database, String logFilename,
                                   int logType) {
  
          IntKeyHashMap sessionMap = new IntKeyHashMap();
          Session       current    = null;
          int           currentId  = 0;
  
          database.setReferentialIntegrity(false);
  
          ScriptReaderBase scr = null;
          String           statement;
          int              statementType;
  
          try {
              StopWatch sw = new StopWatch();
  
              scr = ScriptReaderBase.newScriptReader(database, logFilename,
                                                     logType);
  
              while (scr.readLoggedStatement(current)) {
                  int sessionId = scr.getSessionNumber();
  
                  if (current == null || currentId != sessionId) {
                      currentId = sessionId;
                      current   = (Session) sessionMap.get(currentId);
  
                      if (current == null) {
                          current =
                              database.getSessionManager().newSession(database,
                                  database.getUserManager().getSysUser(), false,
                                  true, 0);
  
                          sessionMap.put(currentId, current);
                      }
                  }
  
                  if (current.isClosed()) {
                      sessionMap.remove(currentId);
  
                      continue;
                  }
  
                  Result result = null;
  
                  statementType = scr.getStatementType();
  
                  switch (statementType) {
  
                      case ScriptReaderBase.ANY_STATEMENT :
                          statement = scr.getLoggedStatement();
                          result    = current.executeDirectStatement(statement);
  
                          if (result != null && result.isError()) {
                              if (result.getException() != null) {
                                  throw result.getException();
                              }
  
                              throw Error.error(result);
                          }
                          break;
  
                      case ScriptReaderBase.SEQUENCE_STATEMENT :
                          scr.getCurrentSequence().reset(scr.getSequenceValue());
                          break;
  
                      case ScriptReaderBase.COMMIT_STATEMENT :
                          current.commit(false);
                          break;
  
                      case ScriptReaderBase.INSERT_STATEMENT : {
                          current.beginAction(null);
  
                          Object[] data = scr.getData();
  
                          scr.getCurrentTable().insertNoCheckFromLog(current,
                                  data);
                          current.endAction(Result.updateOneResult);
  
                          break;
                      }
                      case ScriptReaderBase.DELETE_STATEMENT : {
                          current.beginAction(null);
  
                          Object[] data = scr.getData();
  
                          scr.getCurrentTable().deleteNoCheckFromLog(current,
                                  data);
                          current.endAction(Result.updateOneResult);
  
                          break;
                      }
                      case ScriptReaderBase.SET_SCHEMA_STATEMENT : {
                          current.setSchema(scr.getCurrentSchema());
                      }
                  }
  
                  if (current.isClosed()) {
                      sessionMap.remove(currentId);
                  }
              }
          } catch (Throwable e) {
              String message;
  
              // catch out-of-memory errors and terminate
              if (e instanceof EOFException) {
  
                  // end of file - normal end
              } else if (e instanceof OutOfMemoryError) {
                  message = "out of memory processing " + logFilename
                            + " line: " + scr.getLineNumber();
  
                  database.logger.appLog.logContext(SimpleLog.LOG_ERROR,
                                                    message);
  
                  throw Error.error(ErrorCode.OUT_OF_MEMORY);
              } else {
  
                  // stop processing on bad log line
                  message = logFilename + " line: " + scr.getLineNumber() + " "
                            + e.toString();
  
                  database.logger.appLog.logContext(SimpleLog.LOG_ERROR,
                                                    message);
              }
          } finally {
              if (scr != null) {
                  scr.close();
              }
  
              database.getSessionManager().closeAllSessions();
              database.setReferentialIntegrity(true);
          }
      }