org.h2.engine.DbSettings Maven / Gradle / Ivy
/*
* Copyright 2004-2018 H2 Group. Multiple-Licensed under the MPL 2.0,
* and the EPL 1.0 (http://h2database.com/html/license.html).
* Initial Developer: H2 Group
*/
package org.h2.engine;
import java.util.HashMap;
import org.h2.message.DbException;
import org.h2.util.Utils;
/**
* This class contains various database-level settings. To override the
* documented default value for a database, append the setting in the database
* URL: "jdbc:h2:test;ALIAS_COLUMN_NAME=TRUE" when opening the first connection
* to the database. The settings can not be changed once the database is open.
*
* Some settings are a last resort and temporary solution to work around a
* problem in the application or database engine. Also, there are system
* properties to enable features that are not yet fully tested or that are not
* backward compatible.
*
*/
public class DbSettings extends SettingsBase {
private static DbSettings defaultSettings;
/**
* Database setting ALIAS_COLUMN_NAME (default: false).
* When enabled, aliased columns (as in SELECT ID AS I FROM TEST) return the
* alias (I in this case) in ResultSetMetaData.getColumnName() and 'null' in
* getTableName(). If disabled, the real column name (ID in this case) and
* table name is returned.
*
* This setting only affects the default and the MySQL mode. When using
* any other mode, this feature is enabled for compatibility, even if this
* database setting is not enabled explicitly.
*/
public final boolean aliasColumnName = get("ALIAS_COLUMN_NAME", false);
/**
* Database setting ANALYZE_AUTO (default: 2000).
* After changing this many rows, ANALYZE is automatically run for a table.
* Automatically running ANALYZE is disabled if set to 0. If set to 1000,
* then ANALYZE will run against each user table after about 1000 changes to
* that table. The time between running ANALYZE doubles each time since
* starting the database. It is not run on local temporary tables, and
* tables that have a trigger on SELECT.
*/
public final int analyzeAuto = get("ANALYZE_AUTO", 2000);
/**
* Database setting ANALYZE_SAMPLE (default: 10000).
* The default sample size when analyzing a table.
*/
public final int analyzeSample = get("ANALYZE_SAMPLE", 10_000);
/**
* Database setting DATABASE_TO_UPPER (default: true).
* Database short names are converted to uppercase for the DATABASE()
* function, and in the CATALOG column of all database meta data methods.
* Setting this to "false" is experimental. When set to false, all
* identifier names (table names, column names) are case sensitive (except
* aggregate, built-in functions, data types, and keywords).
*/
public final boolean databaseToUpper = get("DATABASE_TO_UPPER", true);
/**
* Database setting DB_CLOSE_ON_EXIT (default: true).
* Close the database when the virtual machine exits normally, using a
* shutdown hook.
*/
public final boolean dbCloseOnExit = get("DB_CLOSE_ON_EXIT", true);
/**
* Database setting DEFAULT_CONNECTION (default: false).
* Whether Java functions can use
* DriverManager.getConnection("jdbc:default:connection") to
* get a database connection. This feature is disabled by default for
* performance reasons. Please note the Oracle JDBC driver will try to
* resolve this database URL if it is loaded before the H2 driver.
*/
public final boolean defaultConnection = get("DEFAULT_CONNECTION", false);
/**
* Database setting DEFAULT_ESCAPE (default: \).
* The default escape character for LIKE comparisons. To select no escape
* character, use an empty string.
*/
public final String defaultEscape = get("DEFAULT_ESCAPE", "\\");
/**
* Database setting DEFRAG_ALWAYS (default: false).
* Each time the database is closed normally, it is fully defragmented (the
* same as SHUTDOWN DEFRAG). If you execute SHUTDOWN COMPACT, then this
* setting is ignored.
*/
public final boolean defragAlways = get("DEFRAG_ALWAYS", false);
/**
* Database setting DROP_RESTRICT (default: true).
* Whether the default action for DROP TABLE, DROP VIEW, and DROP SCHEMA
* is RESTRICT.
*/
public final boolean dropRestrict = get("DROP_RESTRICT", true);
/**
* Database setting EARLY_FILTER (default: false).
* This setting allows table implementations to apply filter conditions
* early on.
*/
public final boolean earlyFilter = get("EARLY_FILTER", false);
/**
* Database setting ESTIMATED_FUNCTION_TABLE_ROWS (default:
* 1000).
* The estimated number of rows in a function table (for example, CSVREAD or
* FTL_SEARCH). This value is used by the optimizer.
*/
public final int estimatedFunctionTableRows = get(
"ESTIMATED_FUNCTION_TABLE_ROWS", 1000);
/**
* Database setting FUNCTIONS_IN_SCHEMA
* (default: true).
* If set, all functions are stored in a schema. Specially, the SCRIPT
* statement will always include the schema name in the CREATE ALIAS
* statement. This is not backward compatible with H2 versions 1.2.134 and
* older.
*/
public final boolean functionsInSchema = get("FUNCTIONS_IN_SCHEMA", true);
/**
* Database setting LARGE_TRANSACTIONS (default: true).
* Support very large transactions
*/
public final boolean largeTransactions = get("LARGE_TRANSACTIONS", true);
/**
* Database setting LOB_TIMEOUT (default: 300000,
* which means 5 minutes).
* The number of milliseconds a temporary LOB reference is kept until it
* times out. After the timeout, the LOB is no longer accessible using this
* reference.
*/
public final int lobTimeout = get("LOB_TIMEOUT", 300_000);
/**
* Database setting MAX_COMPACT_COUNT
* (default: Integer.MAX_VALUE).
* The maximum number of pages to move when closing a database.
*/
public final int maxCompactCount = get("MAX_COMPACT_COUNT",
Integer.MAX_VALUE);
/**
* Database setting MAX_COMPACT_TIME (default: 200).
* The maximum time in milliseconds used to compact a database when closing.
*/
public final int maxCompactTime = get("MAX_COMPACT_TIME", 200);
/**
* Database setting MAX_QUERY_TIMEOUT (default: 0).
* The maximum timeout of a query in milliseconds. The default is 0, meaning
* no limit. Please note the actual query timeout may be set to a lower
* value.
*/
public final int maxQueryTimeout = get("MAX_QUERY_TIMEOUT", 0);
/**
* Database setting OPTIMIZE_DISTINCT (default: true).
* Improve the performance of simple DISTINCT queries if an index is
* available for the given column. The optimization is used if:
*
* - The select is a single column query without condition
* - The query contains only one table, and no group by
* - There is only one table involved
* - There is an ascending index on the column
* - The selectivity of the column is below 20
*
*/
public final boolean optimizeDistinct = get("OPTIMIZE_DISTINCT", true);
/**
* Database setting OPTIMIZE_EVALUATABLE_SUBQUERIES (default:
* true).
* Optimize subqueries that are not dependent on the outer query.
*/
public final boolean optimizeEvaluatableSubqueries = get(
"OPTIMIZE_EVALUATABLE_SUBQUERIES", true);
/**
* Database setting OPTIMIZE_INSERT_FROM_SELECT
* (default: true).
* Insert into table from query directly bypassing temporary disk storage.
* This also applies to create table as select.
*/
public final boolean optimizeInsertFromSelect = get(
"OPTIMIZE_INSERT_FROM_SELECT", true);
/**
* Database setting OPTIMIZE_IN_LIST (default: true).
* Optimize IN(...) and IN(SELECT ...) comparisons. This includes
* optimization for SELECT, DELETE, and UPDATE.
*/
public final boolean optimizeInList = get("OPTIMIZE_IN_LIST", true);
/**
* Database setting OPTIMIZE_IN_SELECT (default: true).
* Optimize IN(SELECT ...) comparisons. This includes
* optimization for SELECT, DELETE, and UPDATE.
*/
public final boolean optimizeInSelect = get("OPTIMIZE_IN_SELECT", true);
/**
* Database setting OPTIMIZE_IS_NULL (default: false).
* Use an index for condition of the form columnName IS NULL.
*/
public final boolean optimizeIsNull = get("OPTIMIZE_IS_NULL", true);
/**
* Database setting OPTIMIZE_OR (default: true).
* Convert (C=? OR C=?) to (C IN(?, ?)).
*/
public final boolean optimizeOr = get("OPTIMIZE_OR", true);
/**
* Database setting OPTIMIZE_TWO_EQUALS (default: true).
* Optimize expressions of the form A=B AND B=1. In this case, AND A=1 is
* added so an index on A can be used.
*/
public final boolean optimizeTwoEquals = get("OPTIMIZE_TWO_EQUALS", true);
/**
* Database setting OPTIMIZE_UPDATE (default: true).
* Speed up inserts, updates, and deletes by not reading all rows from a
* page unless necessary.
*/
public final boolean optimizeUpdate = get("OPTIMIZE_UPDATE", true);
/**
* Database setting PAGE_STORE_MAX_GROWTH
* (default: 128 * 1024).
* The maximum number of pages the file grows at any time.
*/
public final int pageStoreMaxGrowth = get("PAGE_STORE_MAX_GROWTH",
128 * 1024);
/**
* Database setting PAGE_STORE_INTERNAL_COUNT
* (default: false).
* Update the row counts on a node level.
*/
public final boolean pageStoreInternalCount = get(
"PAGE_STORE_INTERNAL_COUNT", false);
/**
* Database setting PAGE_STORE_TRIM (default: true).
* Trim the database size when closing.
*/
public final boolean pageStoreTrim = get("PAGE_STORE_TRIM", true);
/**
* Database setting QUERY_CACHE_SIZE (default: 8).
* The size of the query cache, in number of cached statements. Each session
* has it's own cache with the given size. The cache is only used if the SQL
* statement and all parameters match. Only the last returned result per
* query is cached. The following statement types are cached: SELECT
* statements are cached (excluding UNION and FOR UPDATE statements), CALL
* if it returns a single value, DELETE, INSERT, MERGE, UPDATE, and
* transactional statements such as COMMIT. This works for both statements
* and prepared statement.
*/
public final int queryCacheSize = get("QUERY_CACHE_SIZE", 8);
/**
* Database setting RECOMPILE_ALWAYS (default: false).
* Always recompile prepared statements.
*/
public final boolean recompileAlways = get("RECOMPILE_ALWAYS", false);
/**
* Database setting RECONNECT_CHECK_DELAY (default: 200).
* Check the .lock.db file every this many milliseconds to detect that the
* database was changed. The process writing to the database must first
* notify a change in the .lock.db file, then wait twice this many
* milliseconds before updating the database.
*/
public final int reconnectCheckDelay = get("RECONNECT_CHECK_DELAY", 200);
/**
* Database setting REUSE_SPACE (default: true).
* If disabled, all changes are appended to the database file, and existing
* content is never overwritten. This setting has no effect if the database
* is already open.
*/
public final boolean reuseSpace = get("REUSE_SPACE", true);
/**
* Database setting ROWID (default: true).
* If set, each table has a pseudo-column _ROWID_.
*/
public final boolean rowId = get("ROWID", true);
/**
* Database setting SELECT_FOR_UPDATE_MVCC
* (default: true).
* If set, SELECT .. FOR UPDATE queries lock only the selected rows when
* using MVCC.
*/
public final boolean selectForUpdateMvcc = get("SELECT_FOR_UPDATE_MVCC", true);
/**
* Database setting SHARE_LINKED_CONNECTIONS
* (default: true).
* Linked connections should be shared, that means connections to the same
* database should be used for all linked tables that connect to the same
* database.
*/
public final boolean shareLinkedConnections = get(
"SHARE_LINKED_CONNECTIONS", true);
/**
* Database setting DEFAULT_TABLE_ENGINE
* (default: null).
* The default table engine to use for new tables.
*/
public final String defaultTableEngine = get("DEFAULT_TABLE_ENGINE", null);
/**
* Database setting MV_STORE
* (default: false for version 1.3, true for version 1.4).
* Use the MVStore storage engine.
*/
public boolean mvStore = get("MV_STORE", Constants.VERSION_MINOR >= 4);
/**
* Database setting COMPRESS
* (default: false).
* Compress data when storing.
*/
public final boolean compressData = get("COMPRESS", false);
/**
* Database setting MULTI_THREADED
* (default: false).
*/
public final boolean multiThreaded = get("MULTI_THREADED", false);
/**
* Database setting STANDARD_DROP_TABLE_RESTRICT (default:
* false).
* true if DROP TABLE RESTRICT should fail if there's any
* foreign key referencing the table to be dropped. false if
* foreign keys referencing the table to be dropped should be silently
* dropped as well.
*/
public final boolean standardDropTableRestrict = get(
"STANDARD_DROP_TABLE_RESTRICT", false);
private DbSettings(HashMap s) {
super(s);
if (s.get("NESTED_JOINS") != null || Utils.getProperty("h2.nestedJoins", null) != null) {
throw DbException.getUnsupportedException("NESTED_JOINS setting is not available since 1.4.197");
}
}
/**
* INTERNAL.
* Get the settings for the given properties (may not be null).
*
* @param s the settings
* @return the settings
*/
public static DbSettings getInstance(HashMap s) {
return new DbSettings(s);
}
/**
* INTERNAL.
* Get the default settings. Those must not be modified.
*
* @return the settings
*/
public static DbSettings getDefaultSettings() {
if (defaultSettings == null) {
defaultSettings = new DbSettings(new HashMap());
}
return defaultSettings;
}
}