Skip to content

H
h2database
提交 a268defe authored 作者: Thomas Mueller's avatar Thomas Mueller
浏览文件
操作

Changes to prepare for version 1.4.x beta

上级 ac7c016e
显示空白字符变更
内嵌 并排
正在显示 包含 0 行增加 和 2841 行删除
h2/src/main/org/h2/constant/DbSettings.java deleted 100644 → 0
浏览文件 @ ac7c016e
/*
* 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.h2.constant;
import java.util.HashMap;
import org.h2.engine.SettingsBase;
/**
* 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.
* <p>
* 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.
* </p>
*/
public class DbSettings extends SettingsBase {
private static DbSettings defaultSettings;
/**
* Database setting <code>ALIAS_COLUMN_NAME</code> (default: false).<br />
* 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.
* <br />
* 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 <code>ANALYZE_AUTO</code> (default: 2000).<br />
* 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 <code>ANALYZE_SAMPLE</code> (default: 10000).<br />
* The default sample size when analyzing a table.
*/
public final int analyzeSample = get("ANALYZE_SAMPLE", 10000);
/**
* Database setting <code>DATABASE_TO_UPPER</code> (default: true).<br />
* 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 <code>DB_CLOSE_ON_EXIT</code> (default: true).<br />
* 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 <code>DEFAULT_CONNECTION</code> (default: false).<br />
* Whether Java functions can use
* <code>DriverManager.getConnection("jdbc:default:connection")</code> 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 <code>DEFAULT_ESCAPE</code> (default: \).<br />
* 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 <code>DEFRAG_ALWAYS</code> (default: false).<br />
* Each time the database is closed, it is fully defragmented (SHUTDOWN
* DEFRAG).
*/
public final boolean defragAlways = get("DEFRAG_ALWAYS", false);
/**
* Database setting <code>DROP_RESTRICT</code> (default: true).<br />
* Whether the default action for DROP TABLE and DROP VIEW is RESTRICT.
*/
public final boolean dropRestrict = get("DROP_RESTRICT", true);
/**
* Database setting <code>EARLY_FILTER</code> (default: false).<br />
* This setting allows table implementations to apply filter conditions
* early on.
*/
public final boolean earlyFilter = get("EARLY_FILTER", false);
/**
* Database setting <code>ESTIMATED_FUNCTION_TABLE_ROWS</code> (default:
* 1000).<br />
* 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 <code>FUNCTIONS_IN_SCHEMA</code>
* (default: true).<br />
* 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 <code>LARGE_RESULT_BUFFER_SIZE</code>
* (default: 4096).<br />
* 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 <code>LARGE_TRANSACTIONS</code> (default: true).<br />
* Support very large transactions
*/
public final boolean largeTransactions = get("LARGE_TRANSACTIONS", true);
/**
* Database setting <code>MAX_COMPACT_COUNT</code>
* (default: Integer.MAX_VALUE).<br />
* The maximum number of pages to move when closing a database.
*/
public final int maxCompactCount = get("MAX_COMPACT_COUNT",
Integer.MAX_VALUE);
/**
* Database setting <code>MAX_COMPACT_TIME</code> (default: 200).<br />
* The maximum time in milliseconds used to compact a database when closing.
*/
public final int maxCompactTime = get("MAX_COMPACT_TIME", 200);
/**
* Database setting <code>MAX_MEMORY_ROWS_DISTINCT</code> (default:
* 10000).<br />
* 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 <code>MAX_QUERY_TIMEOUT</code> (default: 0).<br />
* 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 <code>NESTED_JOINS</code> (default: true).<br />
* Whether nested joins should be supported.
*/
public final boolean nestedJoins = get("NESTED_JOINS", true);
/**
* Database setting <code>OPTIMIZE_DISTINCT</code> (default: true).<br />
* Improve the performance of simple DISTINCT queries if an index is
* available for the given column. The optimization is used if:
* <ul>
* <li>The select is a single column query without condition </li>
* <li>The query contains only one table, and no group by </li>
* <li>There is only one table involved </li>
* <li>There is an ascending index on the column </li>
* <li>The selectivity of the column is below 20 </li>
* </ul>
*/
public final boolean optimizeDistinct = get("OPTIMIZE_DISTINCT", true);
/**
* Database setting <code>OPTIMIZE_EVALUATABLE_SUBQUERIES</code> (default:
* true).<br />
* Optimize subqueries that are not dependent on the outer query.
*/
public final boolean optimizeEvaluatableSubqueries = get(
"OPTIMIZE_EVALUATABLE_SUBQUERIES", true);
/**
* Database setting <code>OPTIMIZE_INSERT_FROM_SELECT</code>
* (default: true).<br />
* 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 <code>OPTIMIZE_IN_LIST</code> (default: true).<br />
* 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 <code>OPTIMIZE_IN_SELECT</code> (default: true).<br />
* Optimize IN(SELECT ...) comparisons. This includes
* optimization for SELECT, DELETE, and UPDATE.
*/
public final boolean optimizeInSelect = get("OPTIMIZE_IN_SELECT", true);
/**
* Database setting <code>OPTIMIZE_IS_NULL</code> (default: false).<br />
* Use an index for condition of the form columnName IS NULL.
*/
public final boolean optimizeIsNull = get("OPTIMIZE_IS_NULL", true);
/**
* Database setting <code>OPTIMIZE_OR</code> (default: true).<br />
* Convert (C=? OR C=?) to (C IN(?, ?)).
*/
public final boolean optimizeOr = get("OPTIMIZE_OR", true);
/**
* Database setting <code>OPTIMIZE_TWO_EQUALS</code> (default: true).<br />
* 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 <code>OPTIMIZE_UPDATE</code> (default: true).<br />
* 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 <code>PAGE_STORE_MAX_GROWTH</code>
* (default: 128 * 1024).<br />
* The maximum number of pages the file grows at any time.
*/
public final int pageStoreMaxGrowth = get("PAGE_STORE_MAX_GROWTH",
128 * 1024);
/**
* Database setting <code>PAGE_STORE_INTERNAL_COUNT</code>
* (default: false).<br />
* Update the row counts on a node level.
*/
public final boolean pageStoreInternalCount = get(
"PAGE_STORE_INTERNAL_COUNT", false);
/**
* Database setting <code>PAGE_STORE_TRIM</code> (default: true).<br />
* Trim the database size when closing.
*/
public final boolean pageStoreTrim = get("PAGE_STORE_TRIM", true);
/**
* Database setting <code>QUERY_CACHE_SIZE</code> (default: 8).<br />
* 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 <code>RECOMPILE_ALWAYS</code> (default: false).<br />
* Always recompile prepared statements.
*/
public final boolean recompileAlways = get("RECOMPILE_ALWAYS", false);
/**
* Database setting <code>RECONNECT_CHECK_DELAY</code> (default: 200).<br />
* 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 <code>ROWID</code> (default: true).<br />
* If set, each table has a pseudo-column _ROWID_.
*/
public final boolean rowId = get("ROWID", true);
/**
* Database setting <code>SELECT_FOR_UPDATE_MVCC</code>
* (default: true).<br />
* 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 <code>SHARE_LINKED_CONNECTIONS</code>
* (default: true).<br />
* 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 <code>DEFAULT_TABLE_ENGINE</code>
* (default: null).<br />
* The default table engine to use for new tables.
*/
public String defaultTableEngine = get("DEFAULT_TABLE_ENGINE", null);
/**
* Database setting <code>MV_STORE</code>
* (default: false).<br />
* Use the MVStore storage engine.
*/
public final boolean mvStore = get("MV_STORE", false);
/**
* Database setting <code>COMPRESS</code>
* (default: false).<br />
* Compress data when storing.
*/
public final boolean compressData = get("COMPRESS", false);
private DbSettings(HashMap<String, String> 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<String, String> s) {
if (s == null || s.isEmpty()) {
if (defaultSettings == null) {
defaultSettings = new DbSettings(new HashMap<String, String>());
}
return defaultSettings;
}
return new DbSettings(s);
}
}
h2/src/main/org/h2/constant/ErrorCode.java deleted 100644 → 0
浏览文件 @ ac7c016e
/*
* 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.h2.constant;
/**
* This class defines the error codes used for SQL exceptions.
* Error messages are formatted as follows:
* <pre>
* { error message (possibly translated; may include quoted data) }
* { error message in English if different }
* { SQL statement if applicable }
* { [ error code - build number ] }
* </pre>
* Example:
* <pre>
* Syntax error in SQL statement "SELECT * FORM[*] TEST ";
* SQL statement: select * form test [42000-125]
* </pre>
* The [*] marks the position of the syntax error
* (FORM instead of FROM in this case).
* The error code is 42000, and the build number is 125,
* meaning version 1.2.125.
*/
public class ErrorCode {
// 02: no data
/**
* The error with code <code>2000</code> is thrown when
* the result set is positioned before the first or after the last row, or
* not on a valid row for the given operation.
* Example of wrong usage:
* <pre>
* ResultSet rs = stat.executeQuery("SELECT * FROM DUAL");
* rs.getString(1);
* </pre>
* Correct:
* <pre>
* ResultSet rs = stat.executeQuery("SELECT * FROM DUAL");
* rs.next();
* rs.getString(1);
* </pre>
*/
public static final int NO_DATA_AVAILABLE = 2000;
// 07: dynamic SQL error
/**
* The error with code <code>7001</code> is thrown when
* trying to call a function with the wrong number of parameters.
* Example:
* <pre>
* CALL ABS(1, 2)
* </pre>
*/
public static final int INVALID_PARAMETER_COUNT_2 = 7001;
// 08: connection exception
/**
* The error with code <code>8000</code> is thrown when
* there was a problem trying to create a database lock.
* See the message and cause for details.
*/
public static final int ERROR_OPENING_DATABASE_1 = 8000;
// 21: cardinality violation
/**
* The error with code <code>21002</code> is thrown when the number of
* columns does not match. Possible reasons are: for an INSERT or MERGE
* statement, the column count does not match the table or the column list
* specified. For a SELECT UNION statement, both queries return a different
* number of columns. For a constraint, the number of referenced and
* referencing columns does not match. Example:
* <pre>
* CREATE TABLE TEST(ID INT, NAME VARCHAR);
* INSERT INTO TEST VALUES('Hello');
* </pre>
*/
public static final int COLUMN_COUNT_DOES_NOT_MATCH = 21002;
// 22: data exception
/**
* The error with code <code>22001</code> is thrown when
* trying to insert a value that is too long for the column.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT, NAME VARCHAR(2));
* INSERT INTO TEST VALUES(1, 'Hello');
* </pre>
*/
public static final int VALUE_TOO_LONG_2 = 22001;
/**
* The error with code <code>22003</code> is thrown when a value is out of
* range when converting to another data type. Example:
* <pre>
* CALL CAST(1000000 AS TINYINT);
* SELECT CAST(124.34 AS DECIMAL(2, 2));
* </pre>
*/
public static final int NUMERIC_VALUE_OUT_OF_RANGE_1 = 22003;
/**
* The error with code <code>22012</code> is thrown when trying to divide
* a value by zero. Example:
* <pre>
* CALL 1/0;
* </pre>
*/
public static final int DIVISION_BY_ZERO_1 = 22012;
/**
* The error with code <code>22018</code> is thrown when
* trying to convert a value to a data type where the conversion is
* undefined, or when an error occurred trying to convert. Example:
* <pre>
* CALL CAST(DATE '2001-01-01' AS BOOLEAN);
* CALL CAST('CHF 99.95' AS INT);
* </pre>
*/
public static final int DATA_CONVERSION_ERROR_1 = 22018;
/**
* The error with code <code>22025</code> is thrown when using an invalid
* escape character sequence for LIKE or REGEXP. The default escape
* character is '\'. The escape character is required when searching for
* the characters '%', '_' and the escape character itself. That means if
* you want to search for the text '10%', you need to use LIKE '10\%'. If
* you want to search for 'C:\temp' you need to use 'C:\\temp'. The escape
* character can be changed using the ESCAPE clause as in LIKE '10+%' ESCAPE
* '+'. Example of wrong usage:
* <pre>
* CALL 'C:\temp' LIKE 'C:\temp';
* CALL '1+1' LIKE '1+1' ESCAPE '+';
* </pre>
* Correct:
* <pre>
* CALL 'C:\temp' LIKE 'C:\\temp';
* CALL '1+1' LIKE '1++1' ESCAPE '+';
* </pre>
*/
public static final int LIKE_ESCAPE_ERROR_1 = 22025;
// 23: constraint violation
/**
* The error with code <code>23502</code> is thrown when
* trying to insert NULL into a column that does not allow NULL.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT, NAME VARCHAR NOT NULL);
* INSERT INTO TEST(ID) VALUES(1);
* </pre>
*/
public static final int NULL_NOT_ALLOWED = 23502;
/**
* The error with code <code>23503</code> is thrown when trying to delete
* or update a row when this would violate a referential constraint, because
* there is a child row that would become an orphan. Example:
* <pre>
* CREATE TABLE TEST(ID INT PRIMARY KEY, PARENT INT);
* INSERT INTO TEST VALUES(1, 1), (2, 1);
* ALTER TABLE TEST ADD CONSTRAINT TEST_ID_PARENT
* FOREIGN KEY(PARENT) REFERENCES TEST(ID) ON DELETE RESTRICT;
* DELETE FROM TEST WHERE ID = 1;
* </pre>
*/
public static final int REFERENTIAL_INTEGRITY_VIOLATED_CHILD_EXISTS_1 = 23503;
/**
* The error with code <code>23505</code> is thrown when trying to insert
* a row that would violate a unique index or primary key. Example:
* <pre>
* CREATE TABLE TEST(ID INT PRIMARY KEY);
* INSERT INTO TEST VALUES(1);
* INSERT INTO TEST VALUES(1);
* </pre>
*/
public static final int DUPLICATE_KEY_1 = 23505;
/**
* The error with code <code>23506</code> is thrown when trying to insert
* or update a row that would violate a referential constraint, because the
* referenced row does not exist. Example:
* <pre>
* CREATE TABLE PARENT(ID INT PRIMARY KEY);
* CREATE TABLE CHILD(P_ID INT REFERENCES PARENT(ID));
* INSERT INTO CHILD VALUES(1);
* </pre>
*/
public static final int REFERENTIAL_INTEGRITY_VIOLATED_PARENT_MISSING_1 = 23506;
/**
* The error with code <code>23507</code> is thrown when
* updating or deleting from a table with a foreign key constraint
* that should set the default value, but there is no default value defined.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT PRIMARY KEY, PARENT INT);
* INSERT INTO TEST VALUES(1, 1), (2, 1);
* ALTER TABLE TEST ADD CONSTRAINT TEST_ID_PARENT
* FOREIGN KEY(PARENT) REFERENCES TEST(ID) ON DELETE SET DEFAULT;
* DELETE FROM TEST WHERE ID = 1;
* </pre>
*/
public static final int NO_DEFAULT_SET_1 = 23507;
/**
* The error with code <code>23513</code> is thrown when
* a check constraint is violated. Example:
* <pre>
* CREATE TABLE TEST(ID INT CHECK ID&gt;0);
* INSERT INTO TEST VALUES(0);
* </pre>
*/
public static final int CHECK_CONSTRAINT_VIOLATED_1 = 23513;
/**
* The error with code <code>23514</code> is thrown when
* evaluation of a check constraint resulted in a error.
*/
public static final int CHECK_CONSTRAINT_INVALID = 23514;
// 28: invalid authorization specification
/**
* The error with code <code>28000</code> is thrown when
* there is no such user registered in the database, when the user password
* does not match, or when the database encryption password does not match
* (if database encryption is used).
*/
public static final int WRONG_USER_OR_PASSWORD = 28000;
// 3B: savepoint exception
/**
* The error with code <code>40001</code> is thrown when
* the database engine has detected a deadlock. The transaction of this
* session has been rolled back to solve the problem. A deadlock occurs when
* a session tries to lock a table another session has locked, while the
* other session wants to lock a table the first session has locked. As an
* example, session 1 has locked table A, while session 2 has locked table
* B. If session 1 now tries to lock table B and session 2 tries to lock
* table A, a deadlock has occurred. Deadlocks that involve more than two
* sessions are also possible. To solve deadlock problems, an application
* should lock tables always in the same order, such as always lock table A
* before locking table B. For details, see <a
* href="http://en.wikipedia.org/wiki/Deadlock">Wikipedia Deadlock</a>.
*/
public static final int DEADLOCK_1 = 40001;
// 42: syntax error or access rule violation
/**
* The error with code <code>42000</code> is thrown when
* trying to execute an invalid SQL statement.
* Example:
* <pre>
* CREATE ALIAS REMAINDER FOR "IEEEremainder";
* </pre>
*/
public static final int SYNTAX_ERROR_1 = 42000;
/**
* The error with code <code>42001</code> is thrown when
* trying to execute an invalid SQL statement.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT);
* INSERT INTO TEST(1);
* </pre>
*/
public static final int SYNTAX_ERROR_2 = 42001;
/**
* The error with code <code>42101</code> is thrown when
* trying to create a table or view if an object with this name already
* exists. Example:
* <pre>
* CREATE TABLE TEST(ID INT);
* CREATE TABLE TEST(ID INT PRIMARY KEY);
* </pre>
*/
public static final int TABLE_OR_VIEW_ALREADY_EXISTS_1 = 42101;
/**
* The error with code <code>42102</code> is thrown when
* trying to query, modify or drop a table or view that does not exists
* in this schema and database. A common cause is that the wrong
* database was opened.
* Example:
* <pre>
* SELECT * FROM ABC;
* </pre>
*/
public static final int TABLE_OR_VIEW_NOT_FOUND_1 = 42102;
/**
* The error with code <code>42111</code> is thrown when
* trying to create an index if an index with the same name already exists.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT, NAME VARCHAR);
* CREATE INDEX IDX_ID ON TEST(ID);
* CREATE TABLE ADDRESS(ID INT);
* CREATE INDEX IDX_ID ON ADDRESS(ID);
* </pre>
*/
public static final int INDEX_ALREADY_EXISTS_1 = 42111;
/**
* The error with code <code>42112</code> is thrown when
* trying to drop or reference an index that does not exist.
* Example:
* <pre>
* DROP INDEX ABC;
* </pre>
*/
public static final int INDEX_NOT_FOUND_1 = 42112;
/**
* The error with code <code>42121</code> is thrown when trying to create
* a table or insert into a table and use the same column name twice.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT, ID INT);
* </pre>
*/
public static final int DUPLICATE_COLUMN_NAME_1 = 42121;
/**
* The error with code <code>42122</code> is thrown when
* referencing an non-existing column.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT);
* SELECT NAME FROM TEST;
* </pre>
*/
public static final int COLUMN_NOT_FOUND_1 = 42122;
// 0A: feature not supported
// HZ: remote database access
//
/**
* The error with code <code>50000</code> is thrown when
* something unexpected occurs, for example an internal stack
* overflow. For details about the problem, see the cause of the
* exception in the stack trace.
*/
public static final int GENERAL_ERROR_1 = 50000;
/**
* The error with code <code>50004</code> is thrown when
* creating a table with an unsupported data type, or
* when the data type is unknown because parameters are used.
* Example:
* <pre>
* CREATE TABLE TEST(ID VERYSMALLINT);
* </pre>
*/
public static final int UNKNOWN_DATA_TYPE_1 = 50004;
/**
* The error with code <code>50100</code> is thrown when calling an
* unsupported JDBC method or database feature. See the stack trace for
* details.
*/
public static final int FEATURE_NOT_SUPPORTED_1 = 50100;
/**
* The error with code <code>50200</code> is thrown when
* another connection locked an object longer than the lock timeout
* set for this connection, or when a deadlock occurred.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT);
* -- connection 1:
* SET AUTOCOMMIT FALSE;
* INSERT INTO TEST VALUES(1);
* -- connection 2:
* SET AUTOCOMMIT FALSE;
* INSERT INTO TEST VALUES(1);
* </pre>
*/
public static final int LOCK_TIMEOUT_1 = 50200;
/**
* The error with code <code>90000</code> is thrown when
* a function that does not return a result set was used in the FROM clause.
* Example:
* <pre>
* SELECT * FROM SIN(1);
* </pre>
*/
public static final int FUNCTION_MUST_RETURN_RESULT_SET_1 = 90000;
/**
* The error with code <code>90001</code> is thrown when
* Statement.executeUpdate() was called for a SELECT statement.
* This is not allowed according to the JDBC specs.
*/
public static final int METHOD_NOT_ALLOWED_FOR_QUERY = 90001;
/**
* The error with code <code>90002</code> is thrown when
* Statement.executeQuery() was called for a statement that does
* not return a result set (for example, an UPDATE statement).
* This is not allowed according to the JDBC specs.
*/
public static final int METHOD_ONLY_ALLOWED_FOR_QUERY = 90002;
/**
* The error with code <code>90003</code> is thrown when
* trying to convert a String to a binary value. Two hex digits
* per byte are required. Example of wrong usage:
* <pre>
* CALL X'00023';
* Hexadecimal string with odd number of characters: 00023
* </pre>
* Correct:
* <pre>
* CALL X'000023';
* </pre>
*/
public static final int HEX_STRING_ODD_1 = 90003;
/**
* The error with code <code>90004</code> is thrown when
* trying to convert a text to binary, but the expression contains
* a non-hexadecimal character.
* Example:
* <pre>
* CALL X'ABCDEFGH';
* CALL CAST('ABCDEFGH' AS BINARY);
* </pre>
* Conversion from text to binary is supported, but the text must
* represent the hexadecimal encoded bytes.
*/
public static final int HEX_STRING_WRONG_1 = 90004;
/**
* The error with code <code>90005</code> is thrown when
* trying to create a trigger and using the combination of SELECT
* and FOR EACH ROW, which we do not support.
*/
public static final int TRIGGER_SELECT_AND_ROW_BASED_NOT_SUPPORTED = 90005;
/**
* The error with code <code>90006</code> is thrown when
* trying to get a value from a sequence that has run out of numbers
* and does not have cycling enabled.
*/
public static final int SEQUENCE_EXHAUSTED = 90006;
/**
* The error with code <code>90007</code> is thrown when
* trying to call a JDBC method on an object that has been closed.
*/
public static final int OBJECT_CLOSED = 90007;
/**
* The error with code <code>90008</code> is thrown when
* trying to use a value that is not valid for the given operation.
* Example:
* <pre>
* CREATE SEQUENCE TEST INCREMENT 0;
* </pre>
*/
public static final int INVALID_VALUE_2 = 90008;
/**
* The error with code <code>90009</code> is thrown when
* trying to create a sequence with an invalid combination
* of attributes (min value, max value, start value, etc).
*/
public static final int SEQUENCE_ATTRIBUTES_INVALID = 90009;
/**
* The error with code <code>90010</code> is thrown when
* trying to format a timestamp or number using TO_CHAR
* with an invalid format.
*/
public static final int INVALID_TO_CHAR_FORMAT = 90010;
/**
* The error with code <code>22007</code> is thrown when
* a text can not be converted to a date, time, or timestamp constant.
* Examples:
* <pre>
* CALL DATE '2007-January-01';
* CALL TIME '14:61:00';
* CALL TIMESTAMP '2001-02-30 12:00:00';
* </pre>
*/
public static final int INVALID_DATETIME_CONSTANT_2 = 22007;
/**
* The error with code <code>90012</code> is thrown when
* trying to execute a statement with an parameter.
* Example:
* <pre>
* CALL SIN(?);
* </pre>
*/
public static final int PARAMETER_NOT_SET_1 = 90012;
/**
* The error with code <code>90013</code> is thrown when
* trying to open a database that does not exist using the flag
* IFEXISTS=TRUE, or when trying to access a database object with a catalog
* name that does not match the database name. Example:
* <pre>
* CREATE TABLE TEST(ID INT);
* SELECT XYZ.PUBLIC.TEST.ID FROM TEST;
* </pre>
*/
public static final int DATABASE_NOT_FOUND_1 = 90013;
/**
* The error with code <code>90014</code> is thrown when
* trying to parse a date with an unsupported format string, or
* when the date can not be parsed.
* Example:
* <pre>
* CALL PARSEDATETIME('2001 January', 'yyyy mm');
* </pre>
*/
public static final int PARSE_ERROR_1 = 90014;
/**
* The error with code <code>90015</code> is thrown when
* using an aggregate function with a data type that is not supported.
* Example:
* <pre>
* SELECT SUM('Hello') FROM DUAL;
* </pre>
*/
public static final int SUM_OR_AVG_ON_WRONG_DATATYPE_1 = 90015;
/**
* The error with code <code>90016</code> is thrown when
* a column was used in the expression list or the order by clause of a
* group or aggregate query, and that column is not in the GROUP BY clause.
* Example of wrong usage:
* <pre>
* CREATE TABLE TEST(ID INT, NAME VARCHAR);
* INSERT INTO TEST VALUES(1, 'Hello'), (2, 'World');
* SELECT ID, MAX(NAME) FROM TEST;
* Column ID must be in the GROUP BY list.
* </pre>
* Correct:
* <pre>
* SELECT ID, MAX(NAME) FROM TEST GROUP BY ID;
* </pre>
*/
public static final int MUST_GROUP_BY_COLUMN_1 = 90016;
/**
* The error with code <code>90017</code> is thrown when
* trying to define a second primary key constraint for this table.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR);
* ALTER TABLE TEST ADD CONSTRAINT PK PRIMARY KEY(NAME);
* </pre>
*/
public static final int SECOND_PRIMARY_KEY = 90017;
/**
* The error with code <code>90018</code> is thrown when
* the connection was opened, but never closed. In the finalizer of the
* connection, this forgotten close was detected and the connection was
* closed automatically, but relying on the finalizer is not good practice
* as it is not guaranteed and behavior is virtual machine dependent. The
* application should close the connection. This exception only appears in
* the .trace.db file. Example of wrong usage:
* <pre>
* Connection conn;
* conn = DriverManager.getConnection(&quot;jdbc:h2:&tilde;/test&quot;);
* conn = null;
* The connection was not closed by the application and is
* garbage collected
* </pre>
* Correct:
* <pre>
* conn.close();
* </pre>
*/
public static final int TRACE_CONNECTION_NOT_CLOSED = 90018;
/**
* The error with code <code>90019</code> is thrown when
* trying to drop the current user, if there are no other admin users.
* Example:
* <pre>
* DROP USER SA;
* </pre>
*/
public static final int CANNOT_DROP_CURRENT_USER = 90019;
/**
* The error with code <code>90020</code> is thrown when trying to open a
* database in embedded mode if this database is already in use in another
* process (or in a different class loader). Multiple connections to the
* same database are supported in the following cases:
* <ul><li>In embedded mode (URL of the form jdbc:h2:~/test) if all
* connections are opened within the same process and class loader.
* </li><li>In server and cluster mode (URL of the form
* jdbc:h2:tcp://localhost/test) using remote connections.
* </li></ul>
* The mixed mode is also supported. This mode requires to start a server
* in the same process where the database is open in embedded mode.
*/
public static final int DATABASE_ALREADY_OPEN_1 = 90020;
/**
* The error with code <code>90022</code> is thrown when
* trying to call a unknown function.
* Example:
* <pre>
* CALL SPECIAL_SIN(10);
* </pre>
*/
public static final int FUNCTION_NOT_FOUND_1 = 90022;
/**
* The error with code <code>90023</code> is thrown when
* trying to set a primary key on a nullable column.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT, NAME VARCHAR);
* ALTER TABLE TEST ADD CONSTRAINT PK PRIMARY KEY(ID);
* </pre>
*/
public static final int COLUMN_MUST_NOT_BE_NULLABLE_1 = 90023;
/**
* The error with code <code>90024</code> is thrown when
* a file could not be renamed.
*/
public static final int FILE_RENAME_FAILED_2 = 90024;
/**
* The error with code <code>90025</code> is thrown when
* a file could not be deleted, because it is still in use
* (only in Windows), or because an error occurred when deleting.
*/
public static final int FILE_DELETE_FAILED_1 = 90025;
/**
* The error with code <code>90026</code> is thrown when
* an object could not be serialized.
*/
public static final int SERIALIZATION_FAILED_1 = 90026;
/**
* The error with code <code>90027</code> is thrown when
* an object could not be de-serialized.
*/
public static final int DESERIALIZATION_FAILED_1 = 90027;
/**
* The error with code <code>90028</code> is thrown when
* an input / output error occurred. For more information, see the root
* cause of the exception.
*/
public static final int IO_EXCEPTION_1 = 90028;
/**
* The error with code <code>90029</code> is thrown when
* calling ResultSet.deleteRow(), insertRow(), or updateRow()
* when the current row is not updatable.
* Example:
* <pre>
* ResultSet rs = stat.executeQuery("SELECT * FROM TEST");
* rs.next();
* rs.insertRow();
* </pre>
*/
public static final int NOT_ON_UPDATABLE_ROW = 90029;
/**
* The error with code <code>90030</code> is thrown when
* the database engine has detected a checksum mismatch in the data
* or index. To solve this problem, restore a backup or use the
* Recovery tool (org.h2.tools.Recover).
*/
public static final int FILE_CORRUPTED_1 = 90030;
/**
* The error with code <code>90031</code> is thrown when
* an input / output error occurred. For more information, see the root
* cause of the exception.
*/
public static final int IO_EXCEPTION_2 = 90031;
/**
* The error with code <code>90032</code> is thrown when
* trying to drop or alter a user that does not exist.
* Example:
* <pre>
* DROP USER TEST_USER;
* </pre>
*/
public static final int USER_NOT_FOUND_1 = 90032;
/**
* The error with code <code>90033</code> is thrown when
* trying to create a user or role if a user with this name already exists.
* Example:
* <pre>
* CREATE USER TEST_USER;
* CREATE USER TEST_USER;
* </pre>
*/
public static final int USER_ALREADY_EXISTS_1 = 90033;
/**
* The error with code <code>90034</code> is thrown when
* writing to the trace file failed, for example because the there
* is an I/O exception. This message is printed to System.out,
* but only once.
*/
public static final int TRACE_FILE_ERROR_2 = 90034;
/**
* The error with code <code>90035</code> is thrown when
* trying to create a sequence if a sequence with this name already
* exists.
* Example:
* <pre>
* CREATE SEQUENCE TEST_SEQ;
* CREATE SEQUENCE TEST_SEQ;
* </pre>
*/
public static final int SEQUENCE_ALREADY_EXISTS_1 = 90035;
/**
* The error with code <code>90036</code> is thrown when
* trying to access a sequence that does not exist.
* Example:
* <pre>
* SELECT NEXT VALUE FOR SEQUENCE XYZ;
* </pre>
*/
public static final int SEQUENCE_NOT_FOUND_1 = 90036;
/**
* The error with code <code>90037</code> is thrown when
* trying to drop or alter a view that does not exist.
* Example:
* <pre>
* DROP VIEW XYZ;
* </pre>
*/
public static final int VIEW_NOT_FOUND_1 = 90037;
/**
* The error with code <code>90038</code> is thrown when
* trying to create a view if a view with this name already
* exists.
* Example:
* <pre>
* CREATE VIEW DUMMY AS SELECT * FROM DUAL;
* CREATE VIEW DUMMY AS SELECT * FROM DUAL;
* </pre>
*/
public static final int VIEW_ALREADY_EXISTS_1 = 90038;
/**
* The error with code <code>90040</code> is thrown when
* a user that is not administrator tries to execute a statement
* that requires admin privileges.
*/
public static final int ADMIN_RIGHTS_REQUIRED = 90040;
/**
* The error with code <code>90041</code> is thrown when
* trying to create a trigger and there is already a trigger with that name.
* <pre>
* CREATE TABLE TEST(ID INT);
* CREATE TRIGGER TRIGGER_A AFTER INSERT ON TEST
* CALL "org.h2.samples.TriggerSample$MyTrigger";
* CREATE TRIGGER TRIGGER_A AFTER INSERT ON TEST
* CALL "org.h2.samples.TriggerSample$MyTrigger";
* </pre>
*/
public static final int TRIGGER_ALREADY_EXISTS_1 = 90041;
/**
* The error with code <code>90042</code> is thrown when
* trying to drop a trigger that does not exist.
* Example:
* <pre>
* DROP TRIGGER TRIGGER_XYZ;
* </pre>
*/
public static final int TRIGGER_NOT_FOUND_1 = 90042;
/**
* The error with code <code>90043</code> is thrown when
* there is an error initializing the trigger, for example because the
* class does not implement the Trigger interface.
* See the root cause for details.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT);
* CREATE TRIGGER TRIGGER_A AFTER INSERT ON TEST
* CALL "java.lang.String";
* </pre>
*/
public static final int ERROR_CREATING_TRIGGER_OBJECT_3 = 90043;
/**
* The error with code <code>90044</code> is thrown when
* an exception or error occurred while calling the triggers fire method.
* See the root cause for details.
*/
public static final int ERROR_EXECUTING_TRIGGER_3 = 90044;
/**
* The error with code <code>90045</code> is thrown when trying to create a
* constraint if an object with this name already exists. Example:
* <pre>
* CREATE TABLE TEST(ID INT NOT NULL);
* ALTER TABLE TEST ADD CONSTRAINT PK PRIMARY KEY(ID);
* ALTER TABLE TEST ADD CONSTRAINT PK PRIMARY KEY(ID);
* </pre>
*/
public static final int CONSTRAINT_ALREADY_EXISTS_1 = 90045;
/**
* The error with code <code>90046</code> is thrown when
* trying to open a connection to a database using an unsupported URL
* format. Please see the documentation on the supported URL format and
* examples. Example:
* <pre>
* jdbc: h2:;;
* </pre>
*/
public static final int URL_FORMAT_ERROR_2 = 90046;
/**
* The error with code <code>90047</code> is thrown when
* trying to connect to a TCP server with an incompatible client.
*/
public static final int DRIVER_VERSION_ERROR_2 = 90047;
/**
* The error with code <code>90048</code> is thrown when
* the file header of a database files (*.db) does not match the
* expected version, or if it is corrupted.
*/
public static final int FILE_VERSION_ERROR_1 = 90048;
/**
* The error with code <code>90049</code> is thrown when
* trying to open an encrypted database with the wrong file encryption
* password or algorithm.
*/
public static final int FILE_ENCRYPTION_ERROR_1 = 90049;
/**
* The error with code <code>90050</code> is thrown when trying to open an
* encrypted database, but not separating the file password from the user
* password. The file password is specified in the password field, before
* the user password. A single space needs to be added between the file
* password and the user password; the file password itself may not contain
* spaces. File passwords (as well as user passwords) are case sensitive.
* Example of wrong usage:
* <pre>
* String url = &quot;jdbc:h2:&tilde;/test;CIPHER=AES&quot;;
* String passwords = &quot;filePasswordUserPassword&quot;;
* DriverManager.getConnection(url, &quot;sa&quot;, pwds);
* </pre>
* Correct:
* <pre>
* String url = &quot;jdbc:h2:&tilde;/test;CIPHER=AES&quot;;
* String passwords = &quot;filePassword userPassword&quot;;
* DriverManager.getConnection(url, &quot;sa&quot;, pwds);
* </pre>
*/
public static final int WRONG_PASSWORD_FORMAT = 90050;
/**
* The error with code <code>57014</code> is thrown when
* a statement was canceled using Statement.cancel() or
* when the query timeout has been reached.
* Examples:
* <pre>
* stat.setQueryTimeout(1);
* stat.cancel();
* </pre>
*/
public static final int STATEMENT_WAS_CANCELED = 57014;
/**
* The error with code <code>90052</code> is thrown when
* a subquery that is used as a value contains more than one column.
* Example of wrong usage:
* <pre>
* CREATE TABLE TEST(ID INT);
* INSERT INTO TEST VALUES(1), (2);
* SELECT * FROM TEST WHERE ID IN (SELECT 1, 2 FROM DUAL);
* </pre>
* Correct:
* <pre>
* CREATE TABLE TEST(ID INT);
* INSERT INTO TEST VALUES(1), (2);
* SELECT * FROM TEST WHERE ID IN (1, 2);
* </pre>
*/
public static final int SUBQUERY_IS_NOT_SINGLE_COLUMN = 90052;
/**
* The error with code <code>90053</code> is thrown when
* a subquery that is used as a value contains more than one row.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT, NAME VARCHAR);
* INSERT INTO TEST VALUES(1, 'Hello'), (1, 'World');
* SELECT X, (SELECT NAME FROM TEST WHERE ID=X) FROM DUAL;
* </pre>
*/
public static final int SCALAR_SUBQUERY_CONTAINS_MORE_THAN_ONE_ROW = 90053;
/**
* The error with code <code>90054</code> is thrown when
* an aggregate function is used where it is not allowed.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT);
* INSERT INTO TEST VALUES(1), (2);
* SELECT MAX(ID) FROM TEST WHERE ID = MAX(ID) GROUP BY ID;
* </pre>
*/
public static final int INVALID_USE_OF_AGGREGATE_FUNCTION_1 = 90054;
/**
* The error with code <code>90055</code> is thrown when
* trying to open a database with an unsupported cipher algorithm.
* Supported are AES and XTEA.
* Example:
* <pre>
* jdbc:h2:~/test;CIPHER=DES
* </pre>
*/
public static final int UNSUPPORTED_CIPHER = 90055;
/**
* The error with code <code>90057</code> is thrown when
* trying to drop a constraint that does not exist.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT);
* ALTER TABLE TEST DROP CONSTRAINT CID;
* </pre>
*/
public static final int CONSTRAINT_NOT_FOUND_1 = 90057;
/**
* The error with code <code>90058</code> is thrown when trying to call
* commit or rollback inside a trigger, or when trying to call a method
* inside a trigger that implicitly commits the current transaction, if an
* object is locked. This is not because it would release the lock too
* early.
*/
public static final int COMMIT_ROLLBACK_NOT_ALLOWED = 90058;
/**
* The error with code <code>90059</code> is thrown when
* a query contains a column that could belong to multiple tables.
* Example:
* <pre>
* CREATE TABLE PARENT(ID INT, NAME VARCHAR);
* CREATE TABLE CHILD(PID INT, NAME VARCHAR);
* SELECT ID, NAME FROM PARENT P, CHILD C WHERE P.ID = C.PID;
* </pre>
*/
public static final int AMBIGUOUS_COLUMN_NAME_1 = 90059;
/**
* The error with code <code>90060</code> is thrown when
* trying to use a file locking mechanism that is not supported.
* Currently only FILE (the default) and SOCKET are supported
* Example:
* <pre>
* jdbc:h2:~/test;FILE_LOCK=LDAP
* </pre>
*/
public static final int UNSUPPORTED_LOCK_METHOD_1 = 90060;
/**
* The error with code <code>90061</code> is thrown when
* trying to start a server if a server is already running at the same port.
* It could also be a firewall problem. To find out if another server is
* already running, run the following command on Windows:
* <pre>
* netstat -ano
* </pre>
* The column PID is the process id as listed in the Task Manager.
* For Linux, use:
* <pre>
* netstat -npl
* </pre>
*/
public static final int EXCEPTION_OPENING_PORT_2 = 90061;
/**
* The error with code <code>90062</code> is thrown when
* a directory or file could not be created. This can occur when
* trying to create a directory if a file with the same name already
* exists, or vice versa.
*
*/
public static final int FILE_CREATION_FAILED_1 = 90062;
/**
* The error with code <code>90063</code> is thrown when
* trying to rollback to a savepoint that is not defined.
* Example:
* <pre>
* ROLLBACK TO SAVEPOINT S_UNKNOWN;
* </pre>
*/
public static final int SAVEPOINT_IS_INVALID_1 = 90063;
/**
* The error with code <code>90064</code> is thrown when
* Savepoint.getSavepointName() is called on an unnamed savepoint.
* Example:
* <pre>
* Savepoint sp = conn.setSavepoint();
* sp.getSavepointName();
* </pre>
*/
public static final int SAVEPOINT_IS_UNNAMED = 90064;
/**
* The error with code <code>90065</code> is thrown when
* Savepoint.getSavepointId() is called on a named savepoint.
* Example:
* <pre>
* Savepoint sp = conn.setSavepoint("Joe");
* sp.getSavepointId();
* </pre>
*/
public static final int SAVEPOINT_IS_NAMED = 90065;
/**
* The error with code <code>90066</code> is thrown when
* the same property appears twice in the database URL or in
* the connection properties.
* Example:
* <pre>
* jdbc:h2:~/test;LOCK_TIMEOUT=0;LOCK_TIMEOUT=1
* </pre>
*/
public static final int DUPLICATE_PROPERTY_1 = 90066;
/**
* The error with code <code>90067</code> is thrown when the client could
* not connect to the database, or if the connection was lost. Possible
* reasons are: the database server is not running at the given port, the
* connection was closed due to a shutdown, or the server was stopped. Other
* possible causes are: the server is not an H2 server, or the network
* connection is broken.
*/
public static final int CONNECTION_BROKEN_1 = 90067;
/**
* The error with code <code>90068</code> is thrown when the given
* expression that is used in the ORDER BY is not in the result list. This
* is required for distinct queries, otherwise the result would be
* ambiguous.
* Example of wrong usage:
* <pre>
* CREATE TABLE TEST(ID INT, NAME VARCHAR);
* INSERT INTO TEST VALUES(2, 'Hello'), (1, 'Hello');
* SELECT DISTINCT NAME FROM TEST ORDER BY ID;
* Order by expression ID must be in the result list in this case
* </pre>
* Correct:
* <pre>
* SELECT DISTINCT ID, NAME FROM TEST ORDER BY ID;
* </pre>
*/
public static final int ORDER_BY_NOT_IN_RESULT = 90068;
/**
* The error with code <code>90069</code> is thrown when
* trying to create a role if an object with this name already exists.
* Example:
* <pre>
* CREATE ROLE TEST_ROLE;
* CREATE ROLE TEST_ROLE;
* </pre>
*/
public static final int ROLE_ALREADY_EXISTS_1 = 90069;
/**
* The error with code <code>90070</code> is thrown when
* trying to drop or grant a role that does not exists.
* Example:
* <pre>
* DROP ROLE TEST_ROLE_2;
* </pre>
*/
public static final int ROLE_NOT_FOUND_1 = 90070;
/**
* The error with code <code>90071</code> is thrown when
* trying to grant or revoke if no role or user with that name exists.
* Example:
* <pre>
* GRANT SELECT ON TEST TO UNKNOWN;
* </pre>
*/
public static final int USER_OR_ROLE_NOT_FOUND_1 = 90071;
/**
* The error with code <code>90072</code> is thrown when
* trying to grant or revoke both roles and rights at the same time.
* Example:
* <pre>
* GRANT SELECT, TEST_ROLE ON TEST TO SA;
* </pre>
*/
public static final int ROLES_AND_RIGHT_CANNOT_BE_MIXED = 90072;
/**
* The error with code <code>90073</code> is thrown when trying to create
* an alias for a Java method, if two methods exists in this class that have
* this name and the same number of parameters.
* Example of wrong usage:
* <pre>
* CREATE ALIAS GET_LONG FOR
* "java.lang.Long.getLong";
* </pre>
* Correct:
* <pre>
* CREATE ALIAS GET_LONG FOR
* "java.lang.Long.getLong(java.lang.String, java.lang.Long)";
* </pre>
*/
public static final int METHODS_MUST_HAVE_DIFFERENT_PARAMETER_COUNTS_2 = 90073;
/**
* The error with code <code>90074</code> is thrown when
* trying to grant a role that has already been granted.
* Example:
* <pre>
* CREATE ROLE TEST_A;
* CREATE ROLE TEST_B;
* GRANT TEST_A TO TEST_B;
* GRANT TEST_B TO TEST_A;
* </pre>
*/
public static final int ROLE_ALREADY_GRANTED_1 = 90074;
/**
* The error with code <code>90075</code> is thrown when
* trying to alter a table and allow null for a column that is part of a
* primary key or hash index.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT PRIMARY KEY);
* ALTER TABLE TEST ALTER COLUMN ID NULL;
* </pre>
*/
public static final int COLUMN_IS_PART_OF_INDEX_1 = 90075;
/**
* The error with code <code>90076</code> is thrown when
* trying to create a function alias for a system function or for a function
* that is already defined.
* Example:
* <pre>
* CREATE ALIAS SQRT FOR "java.lang.Math.sqrt"
* </pre>
*/
public static final int FUNCTION_ALIAS_ALREADY_EXISTS_1 = 90076;
/**
* The error with code <code>90077</code> is thrown when
* trying to drop a system function or a function alias that does not exist.
* Example:
* <pre>
* DROP ALIAS SQRT;
* </pre>
*/
public static final int FUNCTION_ALIAS_NOT_FOUND_1 = 90077;
/**
* The error with code <code>90078</code> is thrown when
* trying to create a schema if an object with this name already exists.
* Example:
* <pre>
* CREATE SCHEMA TEST_SCHEMA;
* CREATE SCHEMA TEST_SCHEMA;
* </pre>
*/
public static final int SCHEMA_ALREADY_EXISTS_1 = 90078;
/**
* The error with code <code>90079</code> is thrown when
* trying to drop a schema that does not exist.
* Example:
* <pre>
* DROP SCHEMA UNKNOWN;
* </pre>
*/
public static final int SCHEMA_NOT_FOUND_1 = 90079;
/**
* The error with code <code>90080</code> is thrown when
* trying to rename a object to a different schema, or when trying to
* create a related object in another schema.
* For CREATE LINKED TABLE, it is thrown when multiple tables with that
* name exist in different schemas.
* Example:
* <pre>
* CREATE SCHEMA TEST_SCHEMA;
* CREATE TABLE TEST(ID INT);
* CREATE INDEX TEST_ID ON TEST(ID);
* ALTER INDEX TEST_ID RENAME TO TEST_SCHEMA.IDX_TEST_ID;
* </pre>
*/
public static final int SCHEMA_NAME_MUST_MATCH = 90080;
/**
* The error with code <code>90081</code> is thrown when
* trying to alter a column to not allow NULL, if there
* is already data in the table where this column is NULL.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT);
* INSERT INTO TEST VALUES(NULL);
* ALTER TABLE TEST ALTER COLUMN ID VARCHAR NOT NULL;
* </pre>
*/
public static final int COLUMN_CONTAINS_NULL_VALUES_1 = 90081;
/**
* The error with code <code>90082</code> is thrown when
* trying to drop a system generated sequence.
*/
public static final int SEQUENCE_BELONGS_TO_A_TABLE_1 = 90082;
/**
* The error with code <code>90083</code> is thrown when
* trying to drop a column that is part of a constraint.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT, PID INT REFERENCES(ID));
* ALTER TABLE TEST DROP COLUMN PID;
* </pre>
*/
public static final int COLUMN_IS_REFERENCED_1 = 90083;
/**
* The error with code <code>90084</code> is thrown when
* trying to drop the last column of a table.
* Example:
* <pre>
* CREATE TABLE TEST(ID INT);
* ALTER TABLE TEST DROP COLUMN ID;
* </pre>
*/
public static final int CANNOT_DROP_LAST_COLUMN = 90084;
/**
* The error with code <code>90085</code> is thrown when
* trying to manually drop an index that was generated by the system
* because of a unique or referential constraint. To find out what
* constraint causes the problem, run:
* <pre>
* SELECT * FROM INFORMATION_SCHEMA.CONSTRAINTS
* WHERE UNIQUE_INDEX_NAME = '&lt;index name&gt;';
* </pre>
* Example of wrong usage:
* <pre>
* CREATE TABLE TEST(ID INT, CONSTRAINT UID UNIQUE(ID));
* DROP INDEX UID_INDEX_0;
* Index UID_INDEX_0 belongs to constraint UID
* </pre>
* Correct:
* <pre>
* ALTER TABLE TEST DROP CONSTRAINT UID;
* </pre>
*/
public static final int INDEX_BELONGS_TO_CONSTRAINT_2 = 90085;
/**
* The error with code <code>90086</code> is thrown when
* a class can not be loaded because it is not in the classpath
* or because a related class is not in the classpath.
* Example:
* <pre>
* CREATE ALIAS TEST FOR "java.lang.invalid.Math.sqrt";
* </pre>
*/
public static final int CLASS_NOT_FOUND_1 = 90086;
/**
* The error with code <code>90087</code> is thrown when
* the specified method was not found in the class.
* Example:
* <pre>
* CREATE ALIAS TO_BINARY FOR "java.lang.Long.toBinaryString(long)";
* CALL TO_BINARY(10, 2);
* </pre>
*/
public static final int METHOD_NOT_FOUND_1 = 90087;
/**
* The error with code <code>90088</code> is thrown when
* trying to switch to an unknown mode.
* Example:
* <pre>
* SET MODE UNKNOWN;
* </pre>
*/
public static final int UNKNOWN_MODE_1 = 90088;
/**
* The error with code <code>90089</code> is thrown when
* trying to change the collation while there was already data in
* the database. The collation of the database must be set when the
* database is empty.
* Example of wrong usage:
* <pre>
* CREATE TABLE TEST(NAME VARCHAR PRIMARY KEY);
* INSERT INTO TEST VALUES('Hello', 'World');
* SET COLLATION DE;
* Collation cannot be changed because there is a data table: PUBLIC.TEST
* </pre>
* Correct:
* <pre>
* SET COLLATION DE;
* CREATE TABLE TEST(NAME VARCHAR PRIMARY KEY);
* INSERT INTO TEST VALUES('Hello', 'World');
* </pre>
*/
public static final int COLLATION_CHANGE_WITH_DATA_TABLE_1 = 90089;
/**
* The error with code <code>90090</code> is thrown when
* trying to drop a schema that may not be dropped (the schema PUBLIC
* and the schema INFORMATION_SCHEMA).
* Example:
* <pre>
* DROP SCHEMA PUBLIC;
* </pre>
*/
public static final int SCHEMA_CAN_NOT_BE_DROPPED_1 = 90090;
/**
* The error with code <code>90091</code> is thrown when
* trying to drop the role PUBLIC.
* Example:
* <pre>
* DROP ROLE PUBLIC;
* </pre>
*/
public static final int ROLE_CAN_NOT_BE_DROPPED_1 = 90091;
/**
* The error with code <code>90092</code> is thrown when
* the source code is not compiled for the Java platform used.
* At runtime, the existence of the class java.sql.Savepoint is checked.
*/
public static final int UNSUPPORTED_JAVA_VERSION = 90092;
/**
* The error with code <code>90093</code> is thrown when
* trying to connect to a clustered database that runs in standalone
* mode. This can happen if clustering is not enabled on the database,
* or if one of the clients disabled clustering because it can not see
* the other cluster node.
*/
public static final int CLUSTER_ERROR_DATABASE_RUNS_ALONE = 90093;
/**
* The error with code <code>90094</code> is thrown when
* trying to connect to a clustered database that runs together with a
* different cluster node setting than what is used when trying to connect.
*/
public static final int CLUSTER_ERROR_DATABASE_RUNS_CLUSTERED_1 = 90094;
/**
* The error with code <code>90095</code> is thrown when
* calling the method STRINGDECODE with an invalid escape sequence.
* Only Java style escape sequences and Java properties file escape
* sequences are supported.
* Example:
* <pre>
* CALL STRINGDECODE('\i');
* </pre>
*/
public static final int STRING_FORMAT_ERROR_1 = 90095;
/**
* The error with code <code>90096</code> is thrown when
* trying to perform an operation with a non-admin user if the
* user does not have enough rights.
*/
public static final int NOT_ENOUGH_RIGHTS_FOR_1 = 90096;
/**
* The error with code <code>90097</code> is thrown when
* trying to delete or update a database if it is open in read-only mode.
* Example:
* <pre>
* jdbc:h2:~/test;ACCESS_MODE_DATA=R
* CREATE TABLE TEST(ID INT);
* </pre>
*/
public static final int DATABASE_IS_READ_ONLY = 90097;
/**
* The error with code <code>90098</code> is thrown when the database has
* been closed, for example because the system ran out of memory or because
* the self-destruction counter has reached zero. This counter is only used
* for recovery testing, and not set in normal operation.
*/
public static final int DATABASE_IS_CLOSED = 90098;
/**
* The error with code <code>90099</code> is thrown when an error occurred
* trying to initialize the database event listener. Example:
* <pre>
* jdbc:h2:&tilde;/test;DATABASE_EVENT_LISTENER='java.lang.String'
* </pre>
*/
public static final int ERROR_SETTING_DATABASE_EVENT_LISTENER_2 = 90099;
/**
* The error with code <code>90100</code> is thrown when
* there is no more space available on the device where the database
* files are stored.
*/
public static final int NO_DISK_SPACE_AVAILABLE = 90100;
/**
* The error with code <code>90101</code> is thrown when
* the XA API detected unsupported transaction names. This can happen
* when mixing application generated transaction names and transaction names
* generated by this databases XAConnection API.
*/
public static final int WRONG_XID_FORMAT_1 = 90101;
/**
* The error with code <code>90102</code> is thrown when
* trying to use unsupported options for the given compression algorithm.
* Example of wrong usage:
* <pre>
* CALL COMPRESS(STRINGTOUTF8(SPACE(100)), 'DEFLATE l 10');
* </pre>
* Correct:
* <pre>
* CALL COMPRESS(STRINGTOUTF8(SPACE(100)), 'DEFLATE l 9');
* </pre>
*/
public static final int UNSUPPORTED_COMPRESSION_OPTIONS_1 = 90102;
/**
* The error with code <code>90103</code> is thrown when
* trying to use an unsupported compression algorithm.
* Example:
* <pre>
* CALL COMPRESS(STRINGTOUTF8(SPACE(100)), 'BZIP');
* </pre>
*/
public static final int UNSUPPORTED_COMPRESSION_ALGORITHM_1 = 90103;
/**
* The error with code <code>90104</code> is thrown when
* the data can not be de-compressed.
* Example:
* <pre>
* CALL EXPAND(X'00FF');
* </pre>
*/
public static final int COMPRESSION_ERROR = 90104;
/**
* The error with code <code>90105</code> is thrown when
* an exception occurred in a user-defined method.
* Example:
* <pre>
* CREATE ALIAS SYS_PROP FOR "java.lang.System.getProperty";
* CALL SYS_PROP(NULL);
* </pre>
*/
public static final int EXCEPTION_IN_FUNCTION_1 = 90105;
/**
* The error with code <code>90106</code> is thrown when
* trying to truncate a table that can not be truncated.
* Tables with referential integrity constraints can not be truncated.
* Also, system tables and view can not be truncated.
* Example:
* <pre>
* TRUNCATE TABLE INFORMATION_SCHEMA.SETTINGS;
* </pre>
*/
public static final int CANNOT_TRUNCATE_1 = 90106;
/**
* The error with code <code>90107</code> is thrown when
* trying to drop an object because another object would become invalid.
* Example:
* <pre>
* CREATE TABLE COUNT(X INT);
* CREATE TABLE ITEMS(ID INT DEFAULT SELECT MAX(X)+1 FROM COUNT);
* DROP TABLE COUNT;
* </pre>
*/
public static final int CANNOT_DROP_2 = 90107;
/**
* The error with code <code>90108</code> is thrown when not enough heap
* memory was available. A possible solutions is to increase the memory size
* using <code>java -Xmx128m ...</code>. Another solution is to reduce
* the cache size.
*/
public static final int OUT_OF_MEMORY = 90108;
/**
* The error with code <code>90109</code> is thrown when
* trying to run a query against an invalid view.
* Example:
* <pre>
* CREATE FORCE VIEW TEST_VIEW AS SELECT * FROM TEST;
* SELECT * FROM TEST_VIEW;
* </pre>
*/
public static final int VIEW_IS_INVALID_2 = 90109;
/**
* The error with code <code>90111</code> is thrown when
* an exception occurred while accessing a linked table.
*/
public static final int ERROR_ACCESSING_LINKED_TABLE_2 = 90111;
/**
* The error with code <code>90112</code> is thrown when a row was deleted
* twice while locking was disabled. This is an intern exception that should
* never be thrown to the application, because such deleted should be
* detected and the resulting exception ignored inside the database engine.
* <pre>
* Row not found when trying to delete from index UID_INDEX_0
* </pre>
*/
public static final int ROW_NOT_FOUND_WHEN_DELETING_1 = 90112;
/**
* The error with code <code>90113</code> is thrown when
* the database URL contains unsupported settings.
* Example:
* <pre>
* jdbc:h2:~/test;UNKNOWN=TRUE
* </pre>
*/
public static final int UNSUPPORTED_SETTING_1 = 90113;
/**
* The error with code <code>90114</code> is thrown when
* trying to create a constant if a constant with this name already exists.
* Example:
* <pre>
* CREATE CONSTANT TEST VALUE 1;
* CREATE CONSTANT TEST VALUE 1;
* </pre>
*/
public static final int CONSTANT_ALREADY_EXISTS_1 = 90114;
/**
* The error with code <code>90115</code> is thrown when
* trying to drop a constant that does not exists.
* Example:
* <pre>
* DROP CONSTANT UNKNOWN;
* </pre>
*/
public static final int CONSTANT_NOT_FOUND_1 = 90115;
/**
* The error with code <code>90116</code> is thrown when
* trying use a literal in a SQL statement if literals are disabled.
* If literals are disabled, use PreparedStatement and parameters instead
* of literals in the SQL statement.
* Example:
* <pre>
* SET ALLOW_LITERALS NONE;
* CALL 1+1;
* </pre>
*/
public static final int LITERALS_ARE_NOT_ALLOWED = 90116;
/**
* The error with code <code>90117</code> is thrown when
* trying to connect to a TCP server from another machine, if remote
* connections are not allowed. To allow remote connections,
* start the TCP server using the option -tcpAllowOthers as in:
* <pre>
* java org.h2.tools.Server -tcp -tcpAllowOthers
* </pre>
* Or, when starting the server from an application, use:
* <pre>
* Server server = Server.createTcpServer("-tcpAllowOthers");
* server.start();
* </pre>
*/
public static final int REMOTE_CONNECTION_NOT_ALLOWED = 90117;
/**
* The error with code <code>90118</code> is thrown when
* trying to drop a table can not be dropped.
* Example:
* <pre>
* DROP TABLE INFORMATION_SCHEMA.SETTINGS;
* </pre>
*/
public static final int CANNOT_DROP_TABLE_1 = 90118;
/**
* The error with code <code>90119</code> is thrown when
* trying to create a domain if an object with this name already exists,
* or when trying to overload a built-in data type.
* Example:
* <pre>
* CREATE DOMAIN INTEGER AS VARCHAR;
* CREATE DOMAIN EMAIL AS VARCHAR CHECK LOCATE('@', VALUE) > 0;
* CREATE DOMAIN EMAIL AS VARCHAR CHECK LOCATE('@', VALUE) > 0;
* </pre>
*/
public static final int USER_DATA_TYPE_ALREADY_EXISTS_1 = 90119;
/**
* The error with code <code>90120</code> is thrown when
* trying to drop a domain that doesn't exist.
* Example:
* <pre>
* DROP DOMAIN UNKNOWN;
* </pre>
*/
public static final int USER_DATA_TYPE_NOT_FOUND_1 = 90120;
/**
* The error with code <code>90121</code> is thrown when
* a database operation is started while the virtual machine exits
* (for example in a shutdown hook), or when the session is closed.
*/
public static final int DATABASE_CALLED_AT_SHUTDOWN = 90121;
/**
* The error with code <code>90123</code> is thrown when
* trying mix regular parameters and indexed parameters in the same
* statement. Example:
* <pre>
* SELECT ?, ?1 FROM DUAL;
* </pre>
*/
public static final int CANNOT_MIX_INDEXED_AND_UNINDEXED_PARAMS = 90123;
/**
* The error with code <code>90124</code> is thrown when
* trying to access a file that doesn't exist. This can occur when trying to
* read a lob if the lob file has been deleted by another application.
*/
public static final int FILE_NOT_FOUND_1 = 90124;
/**
* The error with code <code>90125</code> is thrown when
* PreparedStatement.setBigDecimal is called with object that extends the
* class BigDecimal, and the system property h2.allowBigDecimalExtensions is
* not set. Using extensions of BigDecimal is dangerous because the database
* relies on the behavior of BigDecimal. Example of wrong usage:
* <pre>
* BigDecimal bd = new MyDecimal("$10.3");
* prep.setBigDecimal(1, bd);
* Invalid class, expected java.math.BigDecimal but got MyDecimal
* </pre>
* Correct:
* <pre>
* BigDecimal bd = new BigDecimal(&quot;10.3&quot;);
* prep.setBigDecimal(1, bd);
* </pre>
*/
public static final int INVALID_CLASS_2 = 90125;
/**
* The error with code <code>90126</code> is thrown when
* trying to call the BACKUP statement for an in-memory database.
* Example:
* <pre>
* jdbc:h2:mem:
* BACKUP TO 'test.zip';
* </pre>
*/
public static final int DATABASE_IS_NOT_PERSISTENT = 90126;
/**
* The error with code <code>90127</code> is thrown when
* trying to update or delete a row in a result set if the result set is
* not updatable. Result sets are only updatable if:
* the statement was created with updatable concurrency;
* all columns of the result set are from the same table;
* the table is a data table (not a system table or view);
* all columns of the primary key or any unique index are included;
* all columns of the result set are columns of that table.
*/
public static final int RESULT_SET_NOT_UPDATABLE = 90127;
/**
* The error with code <code>90128</code> is thrown when
* trying to call a method of the ResultSet that is only supported
* for scrollable result sets, and the result set is not scrollable.
* Example:
* <pre>
* rs.first();
* </pre>
*/
public static final int RESULT_SET_NOT_SCROLLABLE = 90128;
/**
* The error with code <code>90129</code> is thrown when
* trying to commit a transaction that doesn't exist.
* Example:
* <pre>
* PREPARE COMMIT ABC;
* COMMIT TRANSACTION TEST;
* </pre>
*/
public static final int TRANSACTION_NOT_FOUND_1 = 90129;
/**
* The error with code <code>90130</code> is thrown when
* an execute method of PreparedStatement was called with a SQL statement.
* This is not allowed according to the JDBC specification. Instead, use
* an execute method of Statement.
* Example of wrong usage:
* <pre>
* PreparedStatement prep = conn.prepareStatement("SELECT * FROM TEST");
* prep.execute("DELETE FROM TEST");
* </pre>
* Correct:
* <pre>
* Statement stat = conn.createStatement();
* stat.execute("DELETE FROM TEST");
* </pre>
*/
public static final int METHOD_NOT_ALLOWED_FOR_PREPARED_STATEMENT = 90130;
/**
* The error with code <code>90131</code> is thrown when using multi version
* concurrency control, and trying to update the same row from within two
* connections at the same time, or trying to insert two rows with the same
* key from two connections. Example:
* <pre>
* jdbc:h2:~/test;MVCC=TRUE
* Session 1:
* CREATE TABLE TEST(ID INT);
* INSERT INTO TEST VALUES(1);
* SET AUTOCOMMIT FALSE;
* UPDATE TEST SET ID = 2;
* Session 2:
* SET AUTOCOMMIT FALSE;
* UPDATE TEST SET ID = 3;
* </pre>
*/
public static final int CONCURRENT_UPDATE_1 = 90131;
/**
* The error with code <code>90132</code> is thrown when
* trying to drop a user-defined aggregate function that doesn't exist.
* Example:
* <pre>
* DROP AGGREGATE UNKNOWN;
* </pre>
*/
public static final int AGGREGATE_NOT_FOUND_1 = 90132;
/**
* The error with code <code>90133</code> is thrown when
* trying to change a specific database property while the database is
* already open. The MVCC property needs to be set in the first connection
* (in the connection opening the database) and can not be changed later on.
*/
public static final int CANNOT_CHANGE_SETTING_WHEN_OPEN_1 = 90133;
/**
* The error with code <code>90134</code> is thrown when
* trying to load a Java class that is not part of the allowed classes. By
* default, all classes are allowed, but this can be changed using the
* system property h2.allowedClasses.
*/
public static final int ACCESS_DENIED_TO_CLASS_1 = 90134;
/**
* The error with code <code>90135</code> is thrown when
* trying to open a connection to a database that is currently open
* in exclusive mode. The exclusive mode is set using:
* <pre>
* SET EXCLUSIVE TRUE;
* </pre>
*/
public static final int DATABASE_IS_IN_EXCLUSIVE_MODE = 90135;
/**
* The error with code <code>90136</code> is thrown when
* executing a query that used an unsupported outer join condition.
* Example:
* <pre>
* SELECT * FROM DUAL A LEFT JOIN DUAL B ON B.X=(SELECT MAX(X) FROM DUAL);
* </pre>
*/
public static final int UNSUPPORTED_OUTER_JOIN_CONDITION_1 = 90136;
/**
* The error with code <code>90137</code> is thrown when
* trying to assign a value to something that is not a variable.
* <pre>
* SELECT AMOUNT, SET(@V, IFNULL(@V, 0)+AMOUNT) FROM TEST;
* </pre>
*/
public static final int CAN_ONLY_ASSIGN_TO_VARIABLE_1 = 90137;
/**
* The error with code <code>90138</code> is thrown when
*
* trying to open a persistent database using an incorrect database name.
* The name of a persistent database contains the path and file name prefix
* where the data is stored. The file name part of a database name must be
* at least two characters.
*
* Example of wrong usage:
* <pre>
* DriverManager.getConnection("jdbc:h2:~/t");
* DriverManager.getConnection("jdbc:h2:~/test/");
* </pre>
* Correct:
* <pre>
* DriverManager.getConnection("jdbc:h2:~/te");
* DriverManager.getConnection("jdbc:h2:~/test/te");
* </pre>
*/
public static final int INVALID_DATABASE_NAME_1 = 90138;
/**
* The error with code <code>90139</code> is thrown when
* the specified public static Java method was not found in the class.
* Example:
* <pre>
* CREATE ALIAS TEST FOR "java.lang.Math.test";
* </pre>
*/
public static final int PUBLIC_STATIC_JAVA_METHOD_NOT_FOUND_1 = 90139;
/**
* The error with code <code>90140</code> is thrown when trying to update or
* delete a row in a result set if the statement was not created with
* updatable concurrency. Result sets are only updatable if the statement
* was created with updatable concurrency, and if the result set contains
* all columns of the primary key or of a unique index of a table.
*/
public static final int RESULT_SET_READONLY = 90140;
/**
* The error with code <code>90141</code> is thrown when
* trying to change the java object serializer while there was already data
* in the database. The serializer of the database must be set when the
* database is empty.
*/
public static final int JAVA_OBJECT_SERIALIZER_CHANGE_WITH_DATA_TABLE = 90141;
// next are 90011, 90021, 90039,
// 90051, 90056, 90110, 90122, 90142
private ErrorCode() {
// utility class
}
/**
* INTERNAL
*/
public static boolean isCommon(int errorCode) {
switch (errorCode) {
case DATA_CONVERSION_ERROR_1:
case DUPLICATE_KEY_1:
case LOCK_TIMEOUT_1:
case NULL_NOT_ALLOWED:
case NO_DATA_AVAILABLE:
case NUMERIC_VALUE_OUT_OF_RANGE_1:
case REFERENTIAL_INTEGRITY_VIOLATED_CHILD_EXISTS_1:
case REFERENTIAL_INTEGRITY_VIOLATED_PARENT_MISSING_1:
case SYNTAX_ERROR_1:
case SYNTAX_ERROR_2:
case TABLE_OR_VIEW_ALREADY_EXISTS_1:
case TABLE_OR_VIEW_NOT_FOUND_1:
case VALUE_TOO_LONG_2:
case FUNCTION_ALIAS_ALREADY_EXISTS_1:
return true;
}
return false;
}
/**
* INTERNAL
*/
public static String getState(int errorCode) {
// To convert SQLState to error code, replace
// 21S: 210, 42S: 421, HY: 50, C: 1, T: 2
switch (errorCode) {
// 02: no data
case NO_DATA_AVAILABLE: return "02000";
// 07: dynamic SQL error
case INVALID_PARAMETER_COUNT_2: return "07001";
// 08: connection exception
case ERROR_OPENING_DATABASE_1: return "08000";
// 21: cardinality violation
case COLUMN_COUNT_DOES_NOT_MATCH: return "21S02";
// 42: syntax error or access rule violation
case TABLE_OR_VIEW_ALREADY_EXISTS_1: return "42S01";
case TABLE_OR_VIEW_NOT_FOUND_1: return "42S02";
case INDEX_ALREADY_EXISTS_1: return "42S11";
case INDEX_NOT_FOUND_1: return "42S12";
case DUPLICATE_COLUMN_NAME_1: return "42S21";
case COLUMN_NOT_FOUND_1: return "42S22";
// 0A: feature not supported
// HZ: remote database access
// HY
case GENERAL_ERROR_1: return "HY000";
case UNKNOWN_DATA_TYPE_1: return "HY004";
case FEATURE_NOT_SUPPORTED_1: return "HYC00";
case LOCK_TIMEOUT_1: return "HYT00";
default:
return "" + errorCode;
}
}
}
h2/src/main/org/h2/constant/SysProperties.java deleted 100644 → 0
浏览文件 @ ac7c016e
/*
* 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.h2.constant;
import org.h2.message.TraceSystem;
import org.h2.util.MathUtils;
import org.h2.util.Utils;
/**
* The constants defined in this class are initialized from system properties.
* Some system properties are per machine settings, and others are as 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.
* <p>
* System properties can be set when starting the virtual machine:
* </p>
*
* <pre>
* java -Dh2.baseDir=/temp
* </pre>
*
* They can be set within the application, but this must be done before loading
* any classes of this database (before loading the JDBC driver):
*
* <pre>
* System.setProperty(&quot;h2.baseDir&quot;, &quot;/temp&quot;);
* </pre>
*/
public class SysProperties {
/**
* INTERNAL
*/
public static final String H2_SCRIPT_DIRECTORY = "h2.scriptDirectory";
/**
* INTERNAL
*/
public static final String H2_BROWSER = "h2.browser";
/**
* System property <code>file.encoding</code> (default: Cp1252).<br />
* It is usually set by the system and is the default encoding used for the
* RunScript and CSV tool.
*/
public static final String FILE_ENCODING =
Utils.getProperty("file.encoding", "Cp1252");
/**
* System property <code>file.separator</code> (default: /).<br />
* It is usually set by the system, and used to build absolute file names.
*/
public static final String FILE_SEPARATOR =
Utils.getProperty("file.separator", "/");
/**
* System property <code>java.specification.version</code>.<br />
* It is set by the system. Examples: 1.4, 1.5, 1.6.
*/
public static final String JAVA_SPECIFICATION_VERSION =
Utils.getProperty("java.specification.version", "1.4");
/**
* System property <code>line.separator</code> (default: \n).<br />
* It is usually set by the system, and used by the script and trace tools.
*/
public static final String LINE_SEPARATOR =
Utils.getProperty("line.separator", "\n");
/**
* System property <code>user.home</code> (empty string if not set).<br />
* It is usually set by the system, and used as a replacement for ~ in file
* names.
*/
public static final String USER_HOME =
Utils.getProperty("user.home", "");
/**
* System property <code>h2.allowedClasses</code> (default: *).<br />
* Comma separated list of class names or prefixes.
*/
public static final String ALLOWED_CLASSES =
Utils.getProperty("h2.allowedClasses", "*");
/**
* System property <code>h2.browser</code> (default: null).<br />
* The preferred browser to use. If not set, the default browser is used.
* For Windows, to use the Internet Explorer, set this property to
* 'explorer'. For Mac OS, if the default browser is not Safari and you want
* to use Safari, use:
* <code>java -Dh2.browser="open,-a,Safari,%url" ...</code>.
*/
public static final String BROWSER =
Utils.getProperty(H2_BROWSER, null);
/**
* System property <code>h2.enableAnonymousSSL</code> (default: true).<br />
* When using SSL connection, the anonymous cipher suite
* SSL_DH_anon_WITH_RC4_128_MD5 should be enabled.
*/
public static final boolean ENABLE_ANONYMOUS_SSL =
Utils.getProperty("h2.enableAnonymousSSL", true);
/**
* System property <code>h2.bindAddress</code> (default: null).<br />
* The bind address to use.
*/
public static final String BIND_ADDRESS =
Utils.getProperty("h2.bindAddress", null);
/**
* System property <code>h2.check</code> (default: true).<br />
* Assertions in the database engine.
*/
//## CHECK ##
public static final boolean CHECK =
Utils.getProperty("h2.check", true);
/*/
public static final boolean CHECK = false;
//*/
/**
* System property <code>h2.check2</code> (default: true).<br />
* Additional assertions in the database engine.
*/
//## CHECK ##
public static final boolean CHECK2 =
Utils.getProperty("h2.check2", false);
/*/
public static final boolean CHECK2 = false;
//*/
/**
* System property <code>h2.clientTraceDirectory</code> (default:
* trace.db/).<br />
* Directory where the trace files of the JDBC client are stored (only for
* client / server).
*/
public static final String CLIENT_TRACE_DIRECTORY =
Utils.getProperty("h2.clientTraceDirectory", "trace.db/");
/**
* System property <code>h2.collatorCacheSize</code> (default: 32000).<br />
* The cache size for collation keys (in elements). Used when a collator has
* been set for the database.
*/
public static final int COLLATOR_CACHE_SIZE =
Utils.getProperty("h2.collatorCacheSize", 32000);
/**
* System property <code>h2.consoleStream</code> (default: true).<br />
* H2 Console: stream query results.
*/
public static final boolean CONSOLE_STREAM =
Utils.getProperty("h2.consoleStream", true);
/**
* System property <code>h2.consoleTimeout</code> (default: 1800000).<br />
* H2 Console: session timeout in milliseconds. The default is 30 minutes.
*/
public static final int CONSOLE_TIMEOUT =
Utils.getProperty("h2.consoleTimeout", 30 * 60 * 1000);
/**
* System property <code>h2.dataSourceTraceLevel</code> (default: 1).<br />
* The trace level of the data source implementation. Default is 1 for
* error.
*/
public static final int DATASOURCE_TRACE_LEVEL =
Utils.getProperty("h2.dataSourceTraceLevel", TraceSystem.ERROR);
/**
* System property <code>h2.delayWrongPasswordMin</code>
* (default: 250).<br />
* The minimum delay in milliseconds before an exception is thrown for using
* the wrong user name or password. This slows down brute force attacks. The
* delay is reset to this value after a successful login. Unsuccessful
* logins will double the time until DELAY_WRONG_PASSWORD_MAX.
* To disable the delay, set this system property to 0.
*/
public static final int DELAY_WRONG_PASSWORD_MIN =
Utils.getProperty("h2.delayWrongPasswordMin", 250);
/**
* System property <code>h2.delayWrongPasswordMax</code>
* (default: 4000).<br />
* The maximum delay in milliseconds before an exception is thrown for using
* the wrong user name or password. This slows down brute force attacks. The
* delay is reset after a successful login. The value 0 means there is no
* maximum delay.
*/
public static final int DELAY_WRONG_PASSWORD_MAX =
Utils.getProperty("h2.delayWrongPasswordMax", 4000);
/**
* System property <code>h2.javaSystemCompiler</code> (default: true).<br />
* Whether to use the Java system compiler
* (ToolProvider.getSystemJavaCompiler()) if it is available to compile user
* defined functions. If disabled or if the system compiler is not
* available, the com.sun.tools.javac compiler is used if available, and
* "javac" (as an external process) is used if not.
*/
public static final boolean JAVA_SYSTEM_COMPILER =
Utils.getProperty("h2.javaSystemCompiler", true);
/**
* System property <code>h2.lobCloseBetweenReads</code>
* (default: false).<br />
* Close LOB files between read operations.
*/
public static boolean lobCloseBetweenReads =
Utils.getProperty("h2.lobCloseBetweenReads", false);
/**
* System property <code>h2.lobFilesPerDirectory</code>
* (default: 256).<br />
* Maximum number of LOB files per directory.
*/
public static final int LOB_FILES_PER_DIRECTORY =
Utils.getProperty("h2.lobFilesPerDirectory", 256);
/**
* System property <code>h2.lobClientMaxSizeMemory</code> (default:
* 1048576).<br />
* The maximum size of a LOB object to keep in memory on the client side
* when using the server mode.
*/
public static final int LOB_CLIENT_MAX_SIZE_MEMORY =
Utils.getProperty("h2.lobClientMaxSizeMemory", 1024 * 1024);
/**
* System property <code>h2.maxFileRetry</code> (default: 16).<br />
* Number of times to retry file delete and rename. in Windows, files can't
* be deleted if they are open. Waiting a bit can help (sometimes the
* Windows Explorer opens the files for a short time) may help. Sometimes,
* running garbage collection may close files if the user forgot to call
* Connection.close() or InputStream.close().
*/
public static final int MAX_FILE_RETRY =
Math.max(1, Utils.getProperty("h2.maxFileRetry", 16));
/**
* System property <code>h2.maxReconnect</code> (default: 3).<br />
* The maximum number of tries to reconnect in a row.
*/
public static final int MAX_RECONNECT =
Utils.getProperty("h2.maxReconnect", 3);
/**
* System property <code>h2.maxTraceDataLength</code>
* (default: 65535).<br />
* The maximum size of a LOB value that is written as data to the trace
* system.
*/
public static final long MAX_TRACE_DATA_LENGTH =
Utils.getProperty("h2.maxTraceDataLength", 65535);
/**
* System property <code>h2.modifyOnWrite</code> (default: false).<br />
* Only modify the database file when recovery is necessary, or when writing
* to the database. If disabled, opening the database always writes to the
* file (except if the database is read-only). When enabled, the serialized
* file lock is faster.
*/
public static final boolean MODIFY_ON_WRITE =
Utils.getProperty("h2.modifyOnWrite", false);
/**
* System property <code>h2.nioLoadMapped</code> (default: false).<br />
* If the mapped buffer should be loaded when the file is opened.
* This can improve performance.
*/
public static final boolean NIO_LOAD_MAPPED =
Utils.getProperty("h2.nioLoadMapped", false);
/**
* System property <code>h2.nioCleanerHack</code> (default: false).<br />
* If enabled, use the reflection hack to un-map the mapped file if
* possible. If disabled, System.gc() is called in a loop until the object
* is garbage collected. See also
* http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4724038
*/
public static final boolean NIO_CLEANER_HACK =
Utils.getProperty("h2.nioCleanerHack", false);
/**
* System property <code>h2.objectCache</code> (default: true).<br />
* Cache commonly used values (numbers, strings). There is a shared cache
* for all values.
*/
public static final boolean OBJECT_CACHE =
Utils.getProperty("h2.objectCache", true);
/**
* System property <code>h2.objectCacheMaxPerElementSize</code> (default:
* 4096).<br />
* The maximum size (precision) of an object in the cache.
*/
public static final int OBJECT_CACHE_MAX_PER_ELEMENT_SIZE =
Utils.getProperty("h2.objectCacheMaxPerElementSize", 4096);
/**
* System property <code>h2.objectCacheSize</code> (default: 1024).<br />
* The maximum number of objects in the cache.
* This value must be a power of 2.
*/
public static final int OBJECT_CACHE_SIZE =
MathUtils.nextPowerOf2(Utils.getProperty("h2.objectCacheSize", 1024));
/**
* System property <code>h2.pgClientEncoding</code> (default: UTF-8).<br />
* Default client encoding for PG server. It is used if the client does not
* sends his encoding.
*/
public static final String PG_DEFAULT_CLIENT_ENCODING =
Utils.getProperty("h2.pgClientEncoding", "UTF-8");
/**
* System property <code>h2.prefixTempFile</code> (default: h2.temp).<br />
* The prefix for temporary files in the temp directory.
*/
public static final String PREFIX_TEMP_FILE =
Utils.getProperty("h2.prefixTempFile", "h2.temp");
/**
* System property <code>h2.serverCachedObjects</code> (default: 64).<br />
* TCP Server: number of cached objects per session.
*/
public static final int SERVER_CACHED_OBJECTS =
Utils.getProperty("h2.serverCachedObjects", 64);
/**
* System property <code>h2.serverResultSetFetchSize</code>
* (default: 100).<br />
* The default result set fetch size when using the server mode.
*/
public static final int SERVER_RESULT_SET_FETCH_SIZE =
Utils.getProperty("h2.serverResultSetFetchSize", 100);
/**
* System property <code>h2.socketConnectRetry</code> (default: 16).<br />
* The number of times to retry opening a socket. Windows sometimes fails
* to open a socket, see bug
* http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6213296
*/
public static final int SOCKET_CONNECT_RETRY =
Utils.getProperty("h2.socketConnectRetry", 16);
/**
* System property <code>h2.socketConnectTimeout</code>
* (default: 2000).<br />
* The timeout in milliseconds to connect to a server.
*/
public static final int SOCKET_CONNECT_TIMEOUT =
Utils.getProperty("h2.socketConnectTimeout", 2000);
/**
* System property <code>h2.sortNullsHigh</code> (default: false).<br />
* Invert the default sorting behavior for NULL, such that NULL
* is at the end of a result set in an ascending sort and at
* the beginning of a result set in a descending sort.
*/
public static final boolean SORT_NULLS_HIGH =
Utils.getProperty("h2.sortNullsHigh", false);
/**
* System property <code>h2.splitFileSizeShift</code> (default: 30).<br />
* The maximum file size of a split file is 1L &lt;&lt; x.
*/
public static final long SPLIT_FILE_SIZE_SHIFT =
Utils.getProperty("h2.splitFileSizeShift", 30);
/**
* System property <code>h2.storeLocalTime</code> (default: false).<br />
* Store the local time. If disabled, the daylight saving offset is not
* taken into account.
*/
public static final boolean STORE_LOCAL_TIME =
Utils.getProperty("h2.storeLocalTime", false);
/**
* System property <code>h2.syncMethod</code> (default: sync).<br />
* What method to call when closing the database, on checkpoint, and on
* CHECKPOINT SYNC. The following options are supported:
* "sync" (default): RandomAccessFile.getFD().sync();
* "force": RandomAccessFile.getChannel().force(true);
* "forceFalse": RandomAccessFile.getChannel().force(false);
* "": do not call a method (fast but there is a risk of data loss
* on power failure).
*/
public static final String SYNC_METHOD =
Utils.getProperty("h2.syncMethod", "sync");
/**
* System property <code>h2.traceIO</code> (default: false).<br />
* Trace all I/O operations.
*/
public static final boolean TRACE_IO =
Utils.getProperty("h2.traceIO", false);
/**
* System property <code>h2.urlMap</code> (default: null).<br />
* A properties file that contains a mapping between database URLs. New
* connections are written into the file. An empty value in the map means no
* redirection is used for the given URL.
*/
public static final String URL_MAP =
Utils.getProperty("h2.urlMap", null);
/**
* System property <code>h2.useThreadContextClassLoader</code>
* (default: false).<br />
* Instead of using the default class loader when deserializing objects, the
* current thread-context class loader will be used.
*/
public static final boolean USE_THREAD_CONTEXT_CLASS_LOADER =
Utils.getProperty("h2.useThreadContextClassLoader", false);
/**
* System property <code>h2.serializeJavaObject</code>
* (default: true).<br />
* <b>If true</b>, values of type OTHER will be stored in serialized form
* and have the semantics of binary data for all operations (such as sorting
* and conversion to string).
* <br />
* <b>If false</b>, the objects will be serialized only for I/O operations
* and a few other special cases (for example when someone tries to get the
* value in binary form or when comparing objects that are not comparable
* otherwise).
* <br />
* If the object implements the Comparable interface, the method compareTo
* will be used for sorting (but only if objects being compared have a
* common comparable super type). Otherwise the objects will be compared by
* type, and if they are the same by hashCode, and if the hash codes are
* equal, but objects are not, the serialized forms (the byte arrays) are
* compared.
* <br />
* The string representation of the values use the toString method of
* object.
* <br />
* In client-server mode, the server must have all required classes in the
* class path. On the client side, this setting is required to be disabled
* as well, to have correct string representation and display size.
* <br />
* In embedded mode, no data copying occurs, so the user has to make
* defensive copy himself before storing, or ensure that the value object is
* immutable.
*/
public static boolean serializeJavaObject =
Utils.getProperty("h2.serializeJavaObject", true);
/**
* System property <code>h2.javaObjectSerializer</code>
* (default: null).<br />
* The JavaObjectSerializer class name for java objects being stored in
* column of type OTHER. It must be the same on client and server to work
* correctly.
*/
public static final String JAVA_OBJECT_SERIALIZER =
Utils.getProperty("h2.javaObjectSerializer", null);
private static final String H2_BASE_DIR = "h2.baseDir";
private SysProperties() {
// utility class
}
/**
* INTERNAL
*/
public static void setBaseDir(String dir) {
if (!dir.endsWith("/")) {
dir += "/";
}
System.setProperty(H2_BASE_DIR, dir);
}
/**
* INTERNAL
*/
public static String getBaseDir() {
return Utils.getProperty(H2_BASE_DIR, null);
}
/**
* System property <code>h2.scriptDirectory</code> (default: empty
* string).<br />
* Relative or absolute directory where the script files are stored to or
* read from.
*
* @return the current value
*/
public static String getScriptDirectory() {
return Utils.getProperty(H2_SCRIPT_DIRECTORY, "");
}
}
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论