gt:         if (val != null) {
context: /* Copyright (c) 2001-2011, The HSQL Development Group
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * Redistributions of source code must retain the above copyright notice, this
   * list of conditions and the following disclaimer.
   *
   * Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * Neither the name of the HSQL Development Group nor the names of its
   * contributors may be used to endorse or promote products derived from this
   * software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
   * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  
  
  package org.hsqldb.persist;
  
  import java.util.Enumeration;
  
  import org.hsqldb.Database;
  import org.hsqldb.DatabaseURL;
  import org.hsqldb.error.Error;
  import org.hsqldb.error.ErrorCode;
  import org.hsqldb.lib.HashMap;
  import org.hsqldb.lib.HashSet;
  import org.hsqldb.lib.Iterator;
  import org.hsqldb.lib.Set;
  import org.hsqldb.lib.StringUtil;
  
  /**
   * Manages a .properties file for a database.
   *
   * @author Fred Toussi (fredt@users dot sourceforge.net)
   * @version 2.3.0
   * @since 1.7.0
   */
  public class HsqlDatabaseProperties extends HsqlProperties {
  
      private static final String hsqldb_method_class_names =
          "hsqldb.method_class_names";
      public static final String textdb_allow_full_path =
          "textdb.allow_full_path";
      private static HashSet accessibleJavaMethodNames;
      private static boolean allowFullPath;
  
      static {
          try {
              String prop = System.getProperty(hsqldb_method_class_names);
  
              if (prop != null) {
                  accessibleJavaMethodNames = new HashSet();
  
                  String[] names = StringUtil.split(prop, ";");
  
                  for (int i = 0; i < names.length; i++) {
                      accessibleJavaMethodNames.add(names[i]);
                  }
              }
  
              prop = System.getProperty(textdb_allow_full_path);
  
              if (prop != null) {
                  if (Boolean.valueOf(prop)) {
                      allowFullPath = true;
                  }
              }
          } catch (Exception e) {}
      }
  
      /**
       * If the system property "hsqldb.method_class_names" is not set, then
       * static methods of all available Java classes can be accessed as functions
       * in HSQLDB. If the property is set, then only the list of semicolon
       * seperated method names becomes accessible. An empty property value means
       * no class is accessible.<p>
       *
       * A property value that ends with .* is treated as a wild card and allows
       * access to all classe or method names formed by substitution of the
       * asterisk.<p>
       *
       * All methods of java.lang.Math are always accessible.
       */
      public static boolean supportsJavaMethod(String name) {
  
          if (accessibleJavaMethodNames == null) {
              return true;
          }
  
          if (name.startsWith("java.lang.Math.")) {
              return true;
          }
  
          if (accessibleJavaMethodNames.contains(name)) {
              return true;
          }
  
          Iterator it = accessibleJavaMethodNames.iterator();
  
          while (it.hasNext()) {
              String className = (String) it.next();
              int    limit     = className.lastIndexOf(".*");
  
              if (limit < 1) {
                  continue;
              }
  
              if (name.startsWith(className.substring(0, limit + 1))) {
                  return true;
              }
          }
  
          return false;
      }
  
      // accessibility
      public static final int SYSTEM_PROPERTY = 0;
      public static final int FILE_PROPERTY   = 1;
      public static final int SQL_PROPERTY    = 2;
  
      // db files modified
      public static final int     FILES_NOT_MODIFIED = 0;
      public static final int     FILES_MODIFIED     = 1;
      public static final int     FILES_MODIFIED_NEW = 2;
      public static final int     FILES_NEW          = 3;
      private static final String MODIFIED_NO        = "no";
      private static final String MODIFIED_YES       = "yes";
      private static final String MODIFIED_YES_NEW   = "yes-new-files";
      private static final String MODIFIED_NO_NEW    = "no-new-files";
  
      // allowed property metadata
      private static final HashMap dbMeta   = new HashMap(67);
      private static final HashMap textMeta = new HashMap(17);
  
      // versions
      public static final String VERSION_STRING_1_8_0 = "1.8.0";
      public static final String THIS_VERSION         = "2.3.0";
      public static final String THIS_FULL_VERSION    = "2.3.0";
      public static final String THIS_CACHE_VERSION   = "2.0.0";
      public static final String PRODUCT_NAME         = "HSQL Database Engine";
      public static final int    MAJOR                = 2,
                                 MINOR                = 3,
                                 REVISION             = 0;
  
      /**
       * system properties supported by HSQLDB
       */
      public static final String system_lockfile_poll_retries_property =
          "hsqldb.lockfile_poll_retries";
      public static final String system_max_char_or_varchar_display_size =
          "hsqldb.max_char_or_varchar_display_size";
  
      //
      public static final String hsqldb_inc_backup = "hsqldb.inc_backup";
  
      //
      public static final String  hsqldb_version  = "version";
      public static final String  hsqldb_readonly = "readonly";
      private static final String hsqldb_modified = "modified";
  
      //
      public static final String hsqldb_cache_version = "hsqldb.cache_version";
  
      //
      public static final String runtime_gc_interval = "runtime.gc_interval";
  
      //
      public static final String url_ifexists        = "ifexists";
      public static final String url_create          = "create";
      public static final String url_default_schema  = "default_schema";
      public static final String url_check_props     = "check_props";
      public static final String url_get_column_name = "get_column_name";
      public static final String url_close_result    = "close_result";
  
      //
      public static final String url_storage_class_name = "storage_class_name";
      public static final String url_fileaccess_class_name =
          "fileaccess_class_name";
      public static final String url_storage_key = "storage_key";
      public static final String url_shutdown    = "shutdown";
      public static final String url_recover     = "recover";
      public static final String url_tls_wrapper = "tls_wrapper";
  
      //
      public static final String url_crypt_key      = "crypt_key";
      public static final String url_crypt_type     = "crypt_type";
      public static final String url_crypt_provider = "crypt_provider";
      public static final String url_crypt_lobs     = "crypt_lobs";
  
      //
      public static final String hsqldb_tx       = "hsqldb.tx";
      public static final String hsqldb_tx_level = "hsqldb.tx_level";
      public static final String hsqldb_tx_conflict_rollback =
          "hsqldb.tx_conflict_rollback";
      public static final String hsqldb_applog         = "hsqldb.applog";
      public static final String hsqldb_sqllog         = "hsqldb.sqllog";
      public static final String hsqldb_lob_file_scale = "hsqldb.lob_file_scale";
      public static final String hsqldb_lob_file_compressed =
          "hsqldb.lob_compressed";
      public static final String hsqldb_cache_file_scale =
          "hsqldb.cache_file_scale";
      public static final String hsqldb_cache_free_count =
          "hsqldb.cache_free_count";
      public static final String hsqldb_cache_rows = "hsqldb.cache_rows";
      public static final String hsqldb_cache_size = "hsqldb.cache_size";
      public static final String hsqldb_default_table_type =
          "hsqldb.default_table_type";
      public static final String hsqldb_defrag_limit   = "hsqldb.defrag_limit";
      public static final String hsqldb_files_readonly = "files_readonly";
      public static final String hsqldb_lock_file      = "hsqldb.lock_file";
      public static final String hsqldb_log_data       = "hsqldb.log_data";
      public static final String hsqldb_log_size       = "hsqldb.log_size";
      public static final String hsqldb_nio_data_file  = "hsqldb.nio_data_file";
      public static final String hsqldb_nio_max_size   = "hsqldb.nio_max_size";
      public static final String hsqldb_script_format  = "hsqldb.script_format";
      public static final String hsqldb_temp_directory = "hsqldb.temp_directory";
      public static final String hsqldb_result_max_memory_rows =
          "hsqldb.result_max_memory_rows";
      public static final String hsqldb_write_delay = "hsqldb.write_delay";
      public static final String hsqldb_write_delay_millis =
          "hsqldb.write_delay_millis";
      public static final String hsqldb_full_log_replay =
          "hsqldb.full_log_replay";
      public static final String hsqldb_large_data  = "hsqldb.large_data";
      public static final String hsqldb_files_space = "hsqldb.files_space";
      public static final String hsqldb_files_check = "hsqldb.files_check";
  
      //
      public static final String sql_ref_integrity       = "sql.ref_integrity";
      public static final String sql_compare_in_locale = "sql.compare_in_locale";
      public static final String sql_enforce_size        = "sql.enforce_size";
      public static final String sql_enforce_strict_size =
          "sql.enforce_strict_size";    // synonym for sql_enforce_size
      public static final String sql_enforce_refs  = "sql.enforce_refs";
      public static final String sql_enforce_names = "sql.enforce_names";
      public static final String sql_regular_names = "sql.regular_names";
      public static final String sql_enforce_types = "sql.enforce_types";
      public static final String sql_enforce_tdcd  = "sql.enforce_tdc_delete";
      public static final String sql_enforce_tdcu  = "sql.enforce_tdc_update";
      public static final String sql_concat_nulls  = "sql.concat_nulls";
      public static final String sql_nulls_first   = "sql.nulls_first";
      public static final String sql_nulls_order   = "sql.nulls_order";
      public static final String sql_unique_nulls  = "sql.unique_nulls";
      public static final String sql_convert_trunc = "sql.convert_trunc";
      public static final String sql_avg_scale     = "sql.avg_scale";
      public static final String sql_double_nan    = "sql.double_nan";
      public static final String sql_syntax_db2    = "sql.syntax_db2";
      public static final String sql_syntax_mss    = "sql.syntax_mss";
      public static final String sql_syntax_mys    = "sql.syntax_mys";
      public static final String sql_syntax_ora    = "sql.syntax_ora";
      public static final String sql_syntax_pgs    = "sql.syntax_pgs";
      public static final String jdbc_translate_tti_types =
          "jdbc.translate_tti_types";
      public static final String sql_longvar_is_lob = "sql.longvar_is_lob";
      public static final String sql_pad_space      = "sql.pad_space";
      public static final String sql_ignore_case    = "sql.ignore_case";
  
      //
      public static final String textdb_cache_scale = "textdb.cache_scale";
      public static final String textdb_cache_size_scale =
          "textdb.cache_size_scale";
      public static final String textdb_cache_rows   = "textdb.cache_rows";
      public static final String textdb_cache_size   = "textdb.cache_size";
      public static final String textdb_all_quoted   = "textdb.all_quoted";
      public static final String textdb_encoding     = "textdb.encoding";
      public static final String textdb_ignore_first = "textdb.ignore_first";
      public static final String textdb_quoted       = "textdb.quoted";
      public static final String textdb_fs           = "textdb.fs";
      public static final String textdb_vs           = "textdb.vs";
      public static final String textdb_lvs          = "textdb.lvs";
  
      static {
  
          // text table defaults
          textMeta.put(textdb_allow_full_path,
                       HsqlProperties.getMeta(textdb_allow_full_path,
                                              SYSTEM_PROPERTY, allowFullPath));
          textMeta.put(textdb_quoted,
                       HsqlProperties.getMeta(textdb_quoted, SQL_PROPERTY,
                                              true));
          textMeta.put(textdb_all_quoted,
                       HsqlProperties.getMeta(textdb_all_quoted, SQL_PROPERTY,
                                              false));
          textMeta.put(textdb_ignore_first,
                       HsqlProperties.getMeta(textdb_ignore_first, SQL_PROPERTY,
                                              false));
          textMeta.put(textdb_fs,
                       HsqlProperties.getMeta(textdb_fs, SQL_PROPERTY, ","));
          textMeta.put(textdb_vs,
                       HsqlProperties.getMeta(textdb_vs, SQL_PROPERTY, null));
          textMeta.put(textdb_lvs,
                       HsqlProperties.getMeta(textdb_lvs, SQL_PROPERTY, null));
          textMeta.put(textdb_encoding,
                       HsqlProperties.getMeta(textdb_encoding, SQL_PROPERTY,
                                              "ISO-8859-1"));
          textMeta.put(textdb_cache_scale,
                       HsqlProperties.getMeta(textdb_cache_scale, SQL_PROPERTY,
                                              10, 8, 16));
          textMeta.put(textdb_cache_size_scale,
                       HsqlProperties.getMeta(textdb_cache_size_scale,
                                              SQL_PROPERTY, 10, 6, 20));
          textMeta.put(textdb_cache_rows,
                       HsqlProperties.getMeta(textdb_cache_rows, SQL_PROPERTY,
                                              1000, 100, 1000000));
          textMeta.put(textdb_cache_size,
                       HsqlProperties.getMeta(textdb_cache_size, SQL_PROPERTY,
                                              100, 10, 1000000));
          dbMeta.putAll(textMeta);
  
          // string defaults for protected props
          dbMeta.put(hsqldb_version,
                     HsqlProperties.getMeta(hsqldb_version, FILE_PROPERTY,
                                            null));
          dbMeta.put(hsqldb_modified,
                     HsqlProperties.getMeta(hsqldb_modified, FILE_PROPERTY,
                                            null));
          dbMeta.put(hsqldb_cache_version,
                     HsqlProperties.getMeta(hsqldb_cache_version, FILE_PROPERTY,
                                            null));
  
          // boolean defaults for protected props
          dbMeta.put(hsqldb_readonly,
                     HsqlProperties.getMeta(hsqldb_readonly, FILE_PROPERTY,
                                            false));
          dbMeta.put(hsqldb_files_readonly,
                     HsqlProperties.getMeta(hsqldb_files_readonly,
                                            FILE_PROPERTY, false));
  
          // string defaults for user defined props
          dbMeta.put(hsqldb_tx,
                     HsqlProperties.getMeta(hsqldb_tx, SQL_PROPERTY, "LOCKS"));
          dbMeta.put(hsqldb_tx_level,
                     HsqlProperties.getMeta(hsqldb_tx_level, SQL_PROPERTY,
                                            "READ_COMMITTED"));
          dbMeta.put(hsqldb_temp_directory,
                     HsqlProperties.getMeta(hsqldb_temp_directory, SQL_PROPERTY,
                                            null));
          dbMeta.put(hsqldb_default_table_type,
                     HsqlProperties.getMeta(hsqldb_default_table_type,
                                            SQL_PROPERTY, "MEMORY"));
  
          // boolean defaults for user defined props
          dbMeta.put(hsqldb_tx_conflict_rollback,
                     HsqlProperties.getMeta(hsqldb_tx_conflict_rollback,
                                            SQL_PROPERTY, true));
          dbMeta.put(jdbc_translate_tti_types,
                     HsqlProperties.getMeta(jdbc_translate_tti_types,
                                            SQL_PROPERTY, true));
          dbMeta.put(hsqldb_inc_backup,
                     HsqlProperties.getMeta(hsqldb_inc_backup, SQL_PROPERTY,
                                            true));
          dbMeta.put(hsqldb_lock_file,
                     HsqlProperties.getMeta(hsqldb_lock_file, SQL_PROPERTY,
                                            true));
          dbMeta.put(hsqldb_log_data,
                     HsqlProperties.getMeta(hsqldb_log_data, SQL_PROPERTY,
                                            true));
          dbMeta.put(hsqldb_nio_data_file,
                     HsqlProperties.getMeta(hsqldb_nio_data_file, SQL_PROPERTY,
                                            true));
          dbMeta.put(hsqldb_full_log_replay,
                     HsqlProperties.getMeta(hsqldb_full_log_replay,
                                            SQL_PROPERTY, false));
          dbMeta.put(sql_ref_integrity,
                     HsqlProperties.getMeta(sql_ref_integrity, SQL_PROPERTY,
                                            true));
  
          // SQL reserved words not allowed as some identifiers
          dbMeta.put(sql_enforce_names,
                     HsqlProperties.getMeta(sql_enforce_names, SQL_PROPERTY,
                                            false));
          dbMeta.put(sql_regular_names,
                     HsqlProperties.getMeta(sql_regular_names, SQL_PROPERTY,
                                            true));
          dbMeta.put(sql_enforce_refs,
                     HsqlProperties.getMeta(sql_enforce_refs, SQL_PROPERTY,
                                            false));
  
          // char padding to size and exception if data is too long
          dbMeta.put(sql_enforce_size,
                     HsqlProperties.getMeta(sql_enforce_size, SQL_PROPERTY,
                                            true));
          dbMeta.put(sql_enforce_types,
                     HsqlProperties.getMeta(sql_enforce_types, SQL_PROPERTY,
                                            false));
          dbMeta.put(sql_enforce_tdcd,
                     HsqlProperties.getMeta(sql_enforce_tdcd, SQL_PROPERTY,
                                            true));
          dbMeta.put(sql_enforce_tdcu,
                     HsqlProperties.getMeta(sql_enforce_tdcu, SQL_PROPERTY,
                                            true));
          dbMeta.put(sql_concat_nulls,
                     HsqlProperties.getMeta(sql_concat_nulls, SQL_PROPERTY,
                                            true));
          dbMeta.put(sql_nulls_first,
                     HsqlProperties.getMeta(sql_nulls_first, SQL_PROPERTY,
                                            true));
          dbMeta.put(sql_nulls_order,
                     HsqlProperties.getMeta(sql_nulls_order, SQL_PROPERTY,
                                            true));
          dbMeta.put(sql_unique_nulls,
                     HsqlProperties.getMeta(sql_unique_nulls, SQL_PROPERTY,
                                            true));
          dbMeta.put(sql_convert_trunc,
                     HsqlProperties.getMeta(sql_convert_trunc, SQL_PROPERTY,
                                            true));
          dbMeta.put(sql_avg_scale,
                     HsqlProperties.getMeta(sql_avg_scale, SQL_PROPERTY, 0, 0,
                                            10));
          dbMeta.put(sql_double_nan,
                     HsqlProperties.getMeta(sql_double_nan, SQL_PROPERTY, true));
          dbMeta.put(sql_syntax_db2,
                     HsqlProperties.getMeta(sql_syntax_db2, SQL_PROPERTY,
                                            false));
          dbMeta.put(sql_syntax_mss,
                     HsqlProperties.getMeta(sql_syntax_mss, SQL_PROPERTY,
                                            false));
          dbMeta.put(sql_syntax_mys,
                     HsqlProperties.getMeta(sql_syntax_mys, SQL_PROPERTY,
                                            false));
          dbMeta.put(sql_syntax_ora,
                     HsqlProperties.getMeta(sql_syntax_ora, SQL_PROPERTY,
                                            false));
          dbMeta.put(sql_syntax_pgs,
                     HsqlProperties.getMeta(sql_syntax_pgs, SQL_PROPERTY,
                                            false));
          dbMeta.put(sql_compare_in_locale,
                     HsqlProperties.getMeta(sql_compare_in_locale, SQL_PROPERTY,
                                            false));
          dbMeta.put(sql_longvar_is_lob,
                     HsqlProperties.getMeta(sql_longvar_is_lob, SQL_PROPERTY,
                                            false));
          dbMeta.put(sql_pad_space,
                     HsqlProperties.getMeta(sql_pad_space, SQL_PROPERTY, true));
          dbMeta.put(sql_ignore_case,
                     HsqlProperties.getMeta(sql_ignore_case, SQL_PROPERTY,
                                            false));
          dbMeta.put(hsqldb_write_delay,
                     HsqlProperties.getMeta(hsqldb_write_delay, SQL_PROPERTY,
                                            true));
          dbMeta.put(hsqldb_large_data,
                     HsqlProperties.getMeta(hsqldb_large_data, SQL_PROPERTY,
                                            false));
          dbMeta.put(hsqldb_files_space,
                     HsqlProperties.getMeta(hsqldb_files_space, SQL_PROPERTY,
                                            false));
          dbMeta.put(hsqldb_files_check,
                     HsqlProperties.getMeta(hsqldb_files_check, SQL_PROPERTY, 0,
                                            new int[] {
              0, 1
          }));
  
          // integral defaults for user-defined props - sets
          dbMeta.put(hsqldb_write_delay_millis,
                     HsqlProperties.getMeta(hsqldb_write_delay_millis,
                                            SQL_PROPERTY, 500, 0, 10000));
          dbMeta.put(hsqldb_applog,
                     HsqlProperties.getMeta(hsqldb_applog, SQL_PROPERTY, 0, 0,
                                            3));
          dbMeta.put(hsqldb_sqllog,
                     HsqlProperties.getMeta(hsqldb_sqllog, SQL_PROPERTY, 0, 0,
                                            4));
          dbMeta.put(hsqldb_script_format,
                     HsqlProperties.getMeta(hsqldb_script_format, SQL_PROPERTY,
                                            0, new int[] {
              0, 1, 3
          }));
          dbMeta.put(hsqldb_lob_file_scale,
                     HsqlProperties.getMeta(hsqldb_lob_file_scale, SQL_PROPERTY,
                                            32, new int[] {
              1, 2, 4, 8, 16, 32
          }));
          dbMeta.put(hsqldb_lob_file_compressed,
                     HsqlProperties.getMeta(hsqldb_lob_file_compressed,
                                            SQL_PROPERTY, false));
  
          // this property is normally 8 - or 1 for old databases from early versions
          dbMeta.put(hsqldb_cache_file_scale,
                     HsqlProperties.getMeta(hsqldb_cache_file_scale,
                                            SQL_PROPERTY, 32, new int[] {
              1, 8, 16, 32, 64, 128, 256, 512, 1024
          }));
  
          // integral defaults for user defined props - ranges
          dbMeta.put(hsqldb_log_size,
                     HsqlProperties.getMeta(hsqldb_log_size, SQL_PROPERTY, 50,
                                            0, 4 * 1024));
          dbMeta.put(hsqldb_defrag_limit,
                     HsqlProperties.getMeta(hsqldb_defrag_limit, SQL_PROPERTY,
                                            0, 0, 100));
          dbMeta.put(runtime_gc_interval,
                     HsqlProperties.getMeta(runtime_gc_interval, SQL_PROPERTY,
                                            0, 0, 1000000));
          dbMeta.put(hsqldb_cache_size,
                     HsqlProperties.getMeta(hsqldb_cache_size, SQL_PROPERTY,
                                            10000, 100, 4 * 1024 * 1024));
          dbMeta.put(hsqldb_cache_rows,
                     HsqlProperties.getMeta(hsqldb_cache_rows, SQL_PROPERTY,
                                            50000, 100, 4 * 1024 * 1024));
          dbMeta.put(hsqldb_cache_free_count,
                     HsqlProperties.getMeta(hsqldb_cache_free_count,
                                            SQL_PROPERTY, 512, 0, 4096));
          dbMeta.put(hsqldb_result_max_memory_rows,
                     HsqlProperties.getMeta(hsqldb_result_max_memory_rows,
                                            SQL_PROPERTY, 0, 0,
                                            4 * 1024 * 1024));
          dbMeta.put(hsqldb_nio_max_size,
                     HsqlProperties.getMeta(hsqldb_nio_max_size, SQL_PROPERTY,
                                            256, 64, 262144));
      }
  
      private Database database;
  
      public HsqlDatabaseProperties(Database db) {
  
          super(dbMeta, db.getPath(), db.logger.getFileAccess(),
                db.isFilesInJar());
  
          database = db;
  
          setNewDatabaseProperties();
      }
  
      void setNewDatabaseProperties() {
  
          // version of a new database
          setProperty(hsqldb_version, THIS_VERSION);
          setProperty(hsqldb_modified, MODIFIED_NO_NEW);
  
          // OOo related code
          if (database.logger.isStoredFileAccess()) {
              setProperty(hsqldb_cache_rows, 25000);
              setProperty(hsqldb_cache_size, 6000);
              setProperty(hsqldb_log_size, 10);
              setProperty(sql_enforce_size, true);
              setProperty(hsqldb_nio_data_file, false);
              setProperty(hsqldb_lock_file, true);
              setProperty(hsqldb_default_table_type, "cached");
              setProperty(jdbc_translate_tti_types, true);
          }
  
          // OOo end
      }
  
      /**
       * Creates file with defaults if it didn't exist.
       * Returns false if file already existed.
       */
      public boolean load() {
  
          boolean exists;
  
          if (!DatabaseURL.isFileBasedDatabaseType(database.getType())) {
              return true;
          }
  
          try {
              exists = super.load();
          } catch (Throwable t) {
              throw Error.error(t, ErrorCode.FILE_IO_ERROR,
                                ErrorCode.M_LOAD_SAVE_PROPERTIES, new Object[] {
                  t.toString(), fileName
              });
          }
  
          if (!exists) {
              return false;
          }
  
          filterLoadedProperties();
  
          String version = getStringProperty(hsqldb_version);
          int    check = version.substring(0, 5).compareTo(VERSION_STRING_1_8_0);
  
          // do not open early version databases
          if (check < 0) {
              throw Error.error(ErrorCode.WRONG_DATABASE_FILE_VERSION);
          }
  
          // do not open databases of 1.8 versions if script format is not compatible
          if (check == 0) {
              if (getIntegerProperty(hsqldb_script_format) != 0) {
                  throw Error.error(ErrorCode.WRONG_DATABASE_FILE_VERSION);
              }
          }
  
          check = version.substring(0, 2).compareTo(THIS_VERSION);
  
          // do not open if the database belongs to a later (future) version (3.x)
          if (check > 0) {
              throw Error.error(ErrorCode.WRONG_DATABASE_FILE_VERSION);
          }
  
          return true;
      }
  
      public void save() {
  
          if (!DatabaseURL.isFileBasedDatabaseType(database.getType())
                  || database.isFilesReadOnly() || database.isFilesInJar()) {
              return;
          }
  
          try {
              HsqlProperties props = new HsqlProperties(dbMeta,
                  database.getPath(), database.logger.getFileAccess(), false);
  
              if (getIntegerProperty(hsqldb_script_format) == 3) {
                  props.setProperty(hsqldb_script_format, 3);
              }
  
              props.setProperty(hsqldb_version, THIS_VERSION);
  
              if (database.logger.isStoredFileAccess()) {
                  if (!database.logger.isNewStoredFileAccess()) {
  
  // when jar is used with embedded databases in AOO 3.4 and recent(2012) LO this
  // line can be uncommented to circumvent hard-coded check in OOo code in
  // drivers/hsqldb/HDriver.cxx
  //                    props.setProperty(hsqldb_version, VERSION_STRING_1_8_0);
                  }
              }
  
              props.setProperty(hsqldb_modified, getProperty(hsqldb_modified));
              props.save(fileName + ".properties" + ".new");
              fa.renameElement(fileName + ".properties" + ".new",
                               fileName + ".properties");
          } catch (Throwable t) {
              database.logger.logSevereEvent("save failed", t);
  
              throw Error.error(t, ErrorCode.FILE_IO_ERROR,
                                ErrorCode.M_LOAD_SAVE_PROPERTIES, new Object[] {
                  t.toString(), fileName
              });
          }
      }
  
      void filterLoadedProperties() {
  
          String val = stringProps.getProperty(sql_enforce_strict_size);
  
  