org.glowroot.shaded.h2.engine.DbSettings Maven / Gradle / Ivy
The newest version!
/*
* Copyright 2004-2013 H2 Group. Multiple-Licensed under the H2 License,
* Version 1.0, and under the Eclipse Public License, Version 1.0
* (http://h2database.com/html/license.html).
* Initial Developer: H2 Group
*/
package org.glowroot.shaded.h2.engine;
import java.util.HashMap;
/**
* 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", 10000);
/**
* 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 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, it is fully defragmented (SHUTDOWN
* DEFRAG).
*/
public final boolean defragAlways = get("DEFRAG_ALWAYS", false);
/**
* Database setting DROP_RESTRICT (default: true).
* Whether the default action for DROP TABLE and DROP VIEW 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_RESULT_BUFFER_SIZE
* (default: 4096).
* Buffer size for large result sets. Set this value to 0 to disable the
* buffer.
*/
public final int largeResultBufferSize = get("LARGE_RESULT_BUFFER_SIZE",
4 * 1024);
/**
* Database setting LARGE_TRANSACTIONS (default: true).
* Support very large transactions
*/
public final boolean largeTransactions = get("LARGE_TRANSACTIONS", true);
/**
* 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_MEMORY_ROWS_DISTINCT (default:
* 10000).
* The maximum number of rows kept in-memory for SELECT DISTINCT queries. If
* more than this number of rows are in a result set, a temporary table is
* used.
*/
public final int maxMemoryRowsDistinct = get("MAX_MEMORY_ROWS_DISTINCT",
10000);
/**
* 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 int maxQueryTimeout = get("MAX_QUERY_TIMEOUT", 0);
/**
* Database setting NESTED_JOINS (default: true).
* Whether nested joins should be supported.
*/
public final boolean nestedJoins = get("NESTED_JOINS", true);
/**
* 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 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 String defaultTableEngine = get("DEFAULT_TABLE_ENGINE", null);
/**
* Database setting MV_STORE
* (default: false).
* Use the MVStore storage engine.
*/
public final 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);
private DbSettings(HashMap s) {
super(s);
}
/**
* INTERNAL.
* Get the settings for the given properties (may be null).
*
* @param s the settings
* @return the settings
*/
public static DbSettings getInstance(HashMap s) {
if (s == null || s.isEmpty()) {
if (defaultSettings == null) {
defaultSettings = new DbSettings(new HashMap());
}
return defaultSettings;
}
return new DbSettings(s);
}
}