/**
   * Opens this database. The database should be opened after construction. or reopened by the
   * close(int closemode) method during a "shutdown compact". Closes the log if there is an error.
   */
  void reopen() throws HsqlException {

    setState(DATABASE_OPENING);

    try {
      User sysUser;

      isNew =
          (sType == DatabaseManager.S_MEM
              || !HsqlProperties.checkFileExists(sPath, isFilesInJar(), getClass()));
      databaseProperties = new HsqlDatabaseProperties(this);

      databaseProperties.load();
      databaseProperties.setURLProperties(urlProperties);
      compiledStatementManager.reset();

      tTable = new HsqlArrayList();
      userManager = new UserManager();
      hAlias = Library.getAliasMap();
      nameManager = new HsqlNameManager();
      triggerNameList = new DatabaseObjectNames();
      indexNameList = new DatabaseObjectNames();
      constraintNameList = new DatabaseObjectNames();
      sequenceManager = new SequenceManager();
      bReferentialIntegrity = true;
      sysUser = userManager.createSysUser(this);
      sessionManager = new SessionManager(this, sysUser);
      dInfo = DatabaseInformation.newDatabaseInformation(this);

      if (sType != DatabaseManager.S_MEM) {
        logger.openLog(this);
      }

      if (isNew) {
        sessionManager
            .getSysSession()
            .sqlExecuteDirectNoPreChecks("CREATE USER SA PASSWORD \"\" ADMIN");
      }

      dInfo.setWithContent(true);
    } catch (Throwable e) {
      logger.closeLog(Database.CLOSEMODE_IMMEDIATELY);
      logger.releaseLock();
      setState(DATABASE_SHUTDOWN);
      clearStructures();

      if (!(e instanceof HsqlException)) {
        e = Trace.error(Trace.GENERAL_ERROR, e.toString());
      }

      throw (HsqlException) e;
    }

    setState(DATABASE_ONLINE);
  }
  /**
   * Method declaration
   *
   * @throws SQLException
   */
  public void save() throws SQLException {

    close();

    if (Trace.TRACE) {
      Trace.trace();
    }

    try {
      super.save();

      // after saving, open the file again
      load();
    } catch (Exception e) {
      throw Trace.error(Trace.FILE_IO_ERROR, fileName + ".properties " + e);
    }
  }
  /**
   * Opens this database. The database can be opened by the constructor, or reopened by the
   * close(int closemode) method during a "shutdown compact".
   *
   * @see #close(int closemode)
   * @throws SQLException if a database access error occurs
   */
  private void open() throws SQLException {

    boolean newdatabase;
    User sysUser;

    if (sName.length() == 0) {
      throw Trace.error(Trace.GENERAL_ERROR, "bad database name");
    }

    setState(DATABASE_OPENING);
    compiledStatementManager.reset();

    tTable = new HsqlArrayList();
    aAccess = new UserManager();
    hAlias = Library.getAliasMap();
    triggerNameList = new DatabaseObjectNames();
    indexNameList = new DatabaseObjectNames();
    bReferentialIntegrity = true;
    newdatabase = false;
    sysUser = aAccess.createSysUser(this);
    sessionManager = new SessionManager(this, sysUser);
    databaseProperties = new HsqlDatabaseProperties(this);
    dInfo = DatabaseInformation.newDatabaseInformation(this);

    if (sName.equals(".")) {
      newdatabase = true;
    } else {

      // create properties file if not exits and report if new file
      newdatabase = !databaseProperties.load();

      logger.openLog(this, sName);
    }

    if (newdatabase) {
      execute("CREATE USER SA PASSWORD \"\" ADMIN", sessionManager.getSysSession());
    }

    setState(DATABASE_ONLINE);
    dInfo.setWithContent(true);
  }
示例#4
0
  /**
   * When opening a database, the hsqldb.compatible_version property is used to determine if this
   * version of the engine is equal to or greater than the earliest version of the engine capable of
   * opening that database.
   *
   * <p>
   *
   * @return
   * @throws SQLException
   */
  boolean open() throws SQLException {

    if (Trace.TRACE) {
      Trace.trace();
    }

    if (!pProperties.checkFileExists()) {
      create();
      open();

      // this is a new database
      return true;
    }

    // todo: some parts are not necessary for ready-only access
    pProperties.load();

    sFileScript = sName + ".script";
    sFileCache = sName + ".data";
    sFileBackup = sName + ".backup";
    scriptChecker = new File(sFileScript);

    // tony_lai@users 20020820
    // Allows the user to modify log size from the properties file.
    iLogSize = pProperties.getIntegerProperty("hsqldb.log_size", iLogSize);

    String version = pProperties.getProperty("hsqldb.compatible_version");

    // fredt@users 20020428 - patch 1.7.0 by fredt
    int check = version.substring(0, 5).compareTo(jdbcDriver.VERSION);

    Trace.check(check <= 0, Trace.WRONG_DATABASE_FILE_VERSION);

    // save the current version
    pProperties.setProperty("hsqldb.version", jdbcDriver.VERSION);

    if (pProperties.isPropertyTrue("readonly")) {
      bReadOnly = true;

      dDatabase.setReadOnly();

      if (cCache != null) {
        cCache.open(true);
      }

      reopenAllTextCaches();
      runScript();

      return false;
    }

    boolean needbackup = false;
    String state = pProperties.getProperty("modified");

    if (state.equals("yes-new-files")) {
      renameNewToCurrent(sFileScript);
      renameNewToCurrent(sFileBackup);
    } else if (state.equals("yes")) {
      if (isAlreadyOpen()) {
        throw Trace.error(Trace.DATABASE_ALREADY_IN_USE);
      }

      // recovering after a crash (or forgot to close correctly)
      restoreBackup();

      needbackup = true;
    }

    pProperties.setProperty("modified", "yes");
    pProperties.save();

    if (cCache != null) {
      cCache.open(false);
    }

    reopenAllTextCaches();
    runScript();

    if (needbackup) {
      close(false);
      pProperties.setProperty("modified", "yes");
      pProperties.save();

      if (cCache != null) {
        cCache.open(false);
      }

      reopenAllTextCaches();
    }

    openScript();

    // this is an existing database
    return false;
  }