001: /*
002:
003: Derby - Class org.apache.derby.iapi.reference.Property
004:
005: Licensed to the Apache Software Foundation (ASF) under one or more
006: contributor license agreements. See the NOTICE file distributed with
007: this work for additional information regarding copyright ownership.
008: The ASF licenses this file to you under the Apache License, Version 2.0
009: (the "License"); you may not use this file except in compliance with
010: the License. You may obtain a copy of the License at
011:
012: http://www.apache.org/licenses/LICENSE-2.0
013:
014: Unless required by applicable law or agreed to in writing, software
015: distributed under the License is distributed on an "AS IS" BASIS,
016: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017: See the License for the specific language governing permissions and
018: limitations under the License.
019:
020: */
021:
022: package org.apache.derby.iapi.reference;
023:
024: /**
025: List of all properties understood by the system. It also has some other static fields.
026:
027:
028: <P>
029: This class exists for two reasons
030: <Ol>
031: <LI> To act as the internal documentation for the properties.
032: <LI> To remove the need to declare a java static field for the property
033: name in the protocol/implementation class. This reduces the footprint as
034: the string is final and thus can be included simply as a String constant pool entry.
035: </OL>
036: <P>
037: This class should not be shipped with the product.
038:
039: <P>
040: This class has no methods, all it contains are String's which by
041: are public, static and final since they are declared in an interface.
042: */
043:
044: public interface Property {
045:
046: /**
047: * Name of the file that contains system wide properties. Has to be located
048: * in ${derby.system.home} if set, otherwise ${user.dir}
049: */
050: public static final String PROPERTIES_FILE = "derby.properties";
051:
052: /**
053: By convention properties that must not be stored any persistent form of
054: service properties start with this prefix.
055: */
056: public static final String PROPERTY_RUNTIME_PREFIX = "derby.__rt.";
057:
058: /*
059: ** derby.service.* and related properties
060: */
061:
062: /*
063: ** derby.stream.* and related properties
064: */
065:
066: /**
067: derby.stream.error.logSeverityLevel=integerValue
068: <BR>
069: Indicates the minimum level of severity for errors that are reported to the error stream.
070: Default to 0 in a "sane" server, and SESSION_SEVERITY in the insane (and product) server.
071:
072: @see org.apache.derby.iapi.error.ExceptionSeverity#SESSION_SEVERITY
073: */
074: String LOG_SEVERITY_LEVEL = "derby.stream.error.logSeverityLevel";
075:
076: /**
077: derby.stream.error.file=<b>absolute or relative error log filename</b>
078: Takes precendence over derby.stream.error.method.
079: Takes precendence over derby.stream.error.field
080: */
081:
082: String ERRORLOG_FILE_PROPERTY = "derby.stream.error.file";
083:
084: /**
085: derby.stream.error.method=
086: <className>.<methodName> returning an OutputStream or Writer object
087: Takes precendence over derby.stream.error.field
088: */
089:
090: String ERRORLOG_METHOD_PROPERTY = "derby.stream.error.method";
091:
092: /**
093: derby.stream.error.field=
094: <className>.<fieldName> returning an OutputStream or Writer object>
095: */
096:
097: String ERRORLOG_FIELD_PROPERTY = "derby.stream.error.field";
098:
099: /**
100: derby.infolog.append={true,false}
101: <BR>
102: * If the info stream goes to a file and the file already exist, it can
103: * either delete the existing file or append to it. User can specifiy
104: * whether info log file should append or not by setting
105: * derby.infolog.append={true/false}
106: *
107: * The default behavior is that the exiting file will be deleted when a new
108: * info stream is started.
109: */
110: String LOG_FILE_APPEND = "derby.infolog.append";
111:
112: /*
113: ** derby.service.* and related properties
114: */
115: /**
116: derby.system.home
117: <BR>
118: Property name for the home directory. Any relative path in the
119: system should be accessed though this property
120: */
121: String SYSTEM_HOME_PROPERTY = "derby.system.home";
122:
123: /**
124: derby.system.bootAll
125: <BR>
126: Automatically boot any services at start up time. When set to true
127: this services will be booted at startup, otherwise services
128: will be booted on demand.
129: */
130: String BOOT_ALL = "derby.system.bootAll";
131:
132: /**
133: derby.database.noAutoBoot
134: <BR>
135: Don't automatically boot this service at start up time. When set to true
136: this service will only be booted on demand, otherwise the service
137: will be booted at startup time if possible.
138: */
139: String NO_AUTO_BOOT = "derby.database.noAutoBoot";
140:
141: /**
142: derby.__deleteOnCreate
143: <BR>
144: Before creating this service delete any remenants (e.g. the directory)
145: of a previous service at the same location.
146:
147: <P>
148: <B>INTERNAL USE ONLY</B>
149: */
150: String DELETE_ON_CREATE = "derby.__deleteOnCreate";
151:
152: /**
153: derby.database.forceDatabaseLock
154: <BR>
155: Cloudscape attempts to prevent two instances of Cloudscape from booting
156: the same database with the use of a file called db.lck inside the
157: database directory.
158:
159: On some platforms, Cloudscape can successfully prevent a second
160: instance of Cloudscape from booting the database, and thus prevents
161: corruption. If this is the case, you will see an SQLException like the
162: following:
163:
164: ERROR XJ040: Failed to start database 'toursDB', see the next exception
165: for details.
166: ERROR XSDB6: Another instance of Cloudscape may have already booted the
167: database C:\databases\toursDB.
168:
169: The error is also written to the information log.
170:
171: On other platforms, Cloudscape issues a warning message if an instance
172: of Cloudscape attempts to boot a database that may already have a
173: running instance of Cloudscape attached to it.
174: However, it does not prevent the second instance from booting, and thus
175: potentially corrupting, the database.
176:
177: If a warning message has been issued, corruption may already have
178: occurred.
179:
180:
181: NOTE: When you are using Cloudview, error messages appear in the
182: console or operating system window from which Cloudview was started.
183:
184: The warning message looks like this:
185:
186: WARNING: Cloudscape (instance 80000000-00d2-3265-de92-000a0a0a0200) is
187: attempting to boot the database /export/home/sky/wombat even though
188: Cloudscape (instance 80000000-00d2-3265-8abf-000a0a0a0200) may still be
189: active. Only one instance of Cloudscape
190: should boot a database at a time. Severe and non-recoverable corruption
191: can result and may have already occurred.
192:
193: The warning is also written to the information log.
194:
195: This warning is primarily a Technical Support aid to determine the
196: cause of corruption. However, if you see this warning, your best
197: choice is to close the connection and exit the JVM. This minimizes the
198: risk of a corruption. Close all instances of Cloudscape, then restart
199: one instance of Cloudscape and shut down the database properly so that
200: the db.lck file can be removed. The warning message continues to appear
201: until a proper shutdown of the Cloudscape system can delete the db.lck
202: file.
203:
204: If the "derby.database.forceDatabaseLock" property is set to true
205: then this default behavior is altered on systems where cloudscape cannot
206: prevent this dual booting. If the to true, then if the platform does
207: not provide the ability for cloudscape to guarantee no double boot, and
208: if cloudscape finds a db.lck file when it boots, it will throw an
209: exception (TODO - mikem - add what exception), leave the db.lck file
210: in place and not boot the system. At this point the system will not
211: boot until the db.lck file is removed by hand. Note that this
212: situation can arise even when 2 VM's are not accessing the same
213: cloudscape system. Also note that if the db.lck file is removed by
214: hand while a VM is still accessing a derby.database, then there
215: is no way for cloudscape to prevent a second VM from starting up and
216: possibly corrupting the database. In this situation no warning
217: message will be logged to the error log.
218:
219: To disable the default behavior of the db.lck file set property as
220: follows:
221:
222: derby.database.forceDatabaseLock=true
223:
224: */
225: String FORCE_DATABASE_LOCK = "derby.database.forceDatabaseLock";
226:
227: /*
228: ** derby.locks.* and related properties
229: */
230:
231: String LOCKS_INTRO = "derby.locks.";
232:
233: /**
234: derby.locks.escalationThreshold
235: <BR>
236: The number of row locks on a table after which we escalate to
237: table locking. Also used by the optimizer to decide when to
238: start with table locking. The String value must be convertible
239: to an int.
240: */
241: String LOCKS_ESCALATION_THRESHOLD = "derby.locks.escalationThreshold";
242:
243: /**
244: The default value for LOCKS_ESCALATION_THRESHOLD
245: */
246: int DEFAULT_LOCKS_ESCALATION_THRESHOLD = 5000;
247:
248: /**
249: The minimum value for LOCKS_ESCALATION_THRESHOLD
250: */
251: int MIN_LOCKS_ESCALATION_THRESHOLD = 100;
252:
253: /**
254: Configuration parameter for deadlock timeouts, set in seconds.
255: */
256: public static final String DEADLOCK_TIMEOUT = "derby.locks.deadlockTimeout";
257:
258: /**
259: Default value for deadlock timesouts (20 seconds)
260: */
261: public static final int DEADLOCK_TIMEOUT_DEFAULT = 20;
262:
263: /**
264: Default value for wait timeouts (60 seconds)
265: */
266: public static final int WAIT_TIMEOUT_DEFAULT = 60;
267:
268: /**
269: Turn on lock monitor to help debug deadlocks. Default value is OFF.
270: With this property turned on, all deadlocks will cause a tracing to be
271: output to the db2j.LOG file.
272: <BR>
273: This property takes effect dynamically.
274: */
275: public static final String DEADLOCK_MONITOR = "derby.locks.monitor";
276:
277: /**
278: Turn on deadlock trace to help debug deadlocks.
279:
280: Effect 1: This property only takes effect if DEADLOCK_MONITOR is turned
281: ON for deadlock trace. With this property turned on, each lock object
282: involved in a deadlock will output its stack trace to db2j.LOG.
283:
284: Effect 2: When a timeout occurs, a lockTable dump will also be output
285: to db2j.LOG. This acts independent of DEADLOCK_MONITOR.
286: <BR>
287: This property takes effect dynamically.
288: */
289: public static final String DEADLOCK_TRACE = "derby.locks.deadlockTrace";
290:
291: /**
292: Configuration parameter for lock wait timeouts, set in seconds.
293: */
294: public static final String LOCKWAIT_TIMEOUT = "derby.locks.waitTimeout";
295:
296: /*
297: ** db2j.database.*
298: */
299:
300: /**
301: derby.database.classpath
302: <BR>
303: Consists of a series of two part jar names.
304: */
305: String DATABASE_CLASSPATH = "derby.database.classpath";
306:
307: /**
308: internal use only, passes the database classpathinto the class manager
309: */
310: String BOOT_DB_CLASSPATH = PROPERTY_RUNTIME_PREFIX
311: + "database.classpath";
312:
313: /**
314: derby.database.propertiesOnly
315: */
316: String DATABASE_PROPERTIES_ONLY = "derby.database.propertiesOnly";
317:
318: /*
319: ** derby.storage.*
320: */
321:
322: /**
323: * Creation of an access factory should be done with no logging.
324: * This is a run-time property that should not make it to disk
325: * in the service.properties file.
326: **/
327: public static final String CREATE_WITH_NO_LOG = PROPERTY_RUNTIME_PREFIX
328: + "storage.createWithNoLog";
329:
330: /**
331: * The page size to create a table or index with. Must be a multiple
332: * of 2k, usual choices are: 2k, 4k, 8k, 16k, 32k, 64k. The default
333: * if property is not set is 4k.
334: **/
335: public static final String PAGE_SIZE_PARAMETER = "derby.storage.pageSize";
336:
337: /**
338: * The default page size to use for tables that contain a long column.
339: **/
340: public static final String PAGE_SIZE_DEFAULT_LONG = "32768";
341:
342: /**
343: * The bump threshold for pages sizes for create tables
344: * If the approximate column sizes of a table is greater than this
345: * threshold, the page size for the tbl is bumped to PAGE_SIZE_DEFAULT_LONG
346: * provided the page size is not already specified as a property
347: **/
348: public static final int TBL_PAGE_SIZE_BUMP_THRESHOLD = 4096;
349:
350: /**
351: * The bump threshold for pages size for index.
352: * If the approximate key columns of an index is greater than this
353: * threshold, the page size for the index is bumped to PAGE_SIZE_DEFAULT_LONG
354: * provided the page size is not already specified as a property
355: **/
356: public static final int IDX_PAGE_SIZE_BUMP_THRESHOLD = 1024;
357:
358: /**
359: * In cloudscape products which support Row Level Locking (rll), use this
360: * property to disable rll. Application's which use rll will use more
361: * system resources, so if an application knows that it does not need rll
362: * then it can use this system property to force all locking in the system
363: * to lock at the table level.
364: *
365: * This property can be set to the boolean values "true" or "false".
366: * Setting the property to true is the same as not setting the property at
367: * all, and will result in rll being enabled. Setting the property to
368: * false disables rll.
369: *
370: **/
371: public static final String ROW_LOCKING = "derby.storage.rowLocking";
372:
373: /**
374: derby.storage.propertiesId
375: <BR>
376: Stores the id of the conglomerate that holds the per-database
377: properties. Is stored in the service.properties file.
378:
379: <P>
380: <B>INTERNAL USE ONLY</B>
381: */
382: String PROPERTIES_CONGLOM_ID = "derby.storage.propertiesId";
383:
384: /**
385: derby.storage.tempDirectory
386: <BR>
387: Sets the temp directory for a database.
388: <P>
389: */
390: String STORAGE_TEMP_DIRECTORY = "derby.storage.tempDirectory";
391:
392: /**
393: * derby.system.durability
394: * <p>
395: * Currently the only valid supported case insensitive value is 'test'
396: * Note, if this property is set to any other value other than 'test', this
397: * property setting is ignored
398: *
399: * In the future, this property can be used to set different modes - for
400: * example a form of relaxed durability where database can recover to a
401: * consistent state, or to enable some kind of in-memory mode.
402: * <BR>
403: * When set to 'test', the store system will not force sync calls in the
404: * following cases
405: * - for the log file at each commit
406: * - for the log file before data page is forced to disk
407: * - for page allocation when file is grown
408: * - for data writes during checkpoint
409: *
410: * That means
411: * - a commit no longer guarantees that the transaction's modification
412: * will survive a system crash or JVM termination
413: * - the database may not recover successfully upon restart
414: * - a near full disk at runtime may cause unexpected errors
415: * - database can be in an inconsistent state
416: * <p>
417: * This setting is provided for performance reasons and should ideally
418: * only be used when the system can withstand the above consequences.
419: * <BR>
420: * One sample use would be to use this mode (derby.system.durability=test)
421: * when using Derby as a test database, where high performance is required
422: * and the data is not very important
423: * <BR>
424: * Valid supported values are test
425: * <BR>
426: * Example
427: * derby.system.durability=test
428: * One can set this as a command line option to the JVM when starting the
429: * application or in the derby.properties file. It is a system level
430: * property.
431: * <BR>
432: * This property is static; if you change it while Derby is running,
433: * the change does not take effect until you reboot.
434: */
435: public static final String DURABILITY_PROPERTY = "derby.system.durability";
436:
437: /**
438: * This is a value supported for derby.system.durability
439: * When derby.system.durability=test, the storage system does not
440: * force syncs and the system may not recover. It is also possible that
441: * the database might be in an inconsistent state
442: * @see #DURABILITY_PROPERTY
443: */
444: public static final String DURABILITY_TESTMODE_NO_SYNC = "test";
445:
446: /**
447: * derby.storage.fileSyncTransactionLog
448: * <p>
449: * When set, the store system will use sync() call on the log at
450: * commit instead of doing a write sync on all writes to the log;
451: * even if the write sync mode (rws) is supported in the JVM.
452: * <p>
453: *
454: **/
455: public static final String FILESYNC_TRANSACTION_LOG = "derby.storage.fileSyncTransactionLog";
456:
457: /**
458: * derby.storage.logArchiveMode
459: *<BR>
460: *used to identify whether the log is being archived for the database or not.
461: * It Is stored in the service.properties file.
462: *
463: * This property can be set to the boolean values "true" or "false".
464: * Setting the property to true means log is being archived, which could be
465: * used for roll-forward recovery. Setting the property to
466: * false disables log archive mode.
467: *<P>
468: *<B>INTERNAL USE ONLY</B>
469: */
470: String LOG_ARCHIVE_MODE = "derby.storage.logArchiveMode";
471:
472: /**
473: * derby.storage.logDeviceWhenBackedUp
474: *<BR>
475: * This property indicates the logDevice location(path) when the backup was
476: * taken, used to restore the log to the same location while restoring from
477: * backup.
478: *<P>
479: *<B>INTERNAL USE ONLY</B>
480: */
481: String LOG_DEVICE_AT_BACKUP = "derby.storage.logDeviceWhenBackedUp";
482:
483: /**
484: * derby.module.modulename
485: * <P>
486: * Defines a new module. Modulename is a name used when loading the definition
487: * of a module, it provides the linkage to other properties used to define the
488: * module, derby.env.jdk.modulename and derby.env.classes.modulename.
489: *
490: * The value is a Java class name that implements functionality required by
491: * the other parts of a Derby system or database. The class can optionally implement
492: * these classes to control its use and startup.
493: * <UL>
494: * <LI> org.apache.derby.iapi.services.monitor.ModuleControl
495: * <LI> org.apache.derby.iapi.services.monitor.ModuleSupportable
496: * </UL>
497: */
498: String MODULE_PREFIX = "derby.module.";
499:
500: /**
501: * derby.subSubProtocol.xxx
502: *<p>
503: *
504: * A new subsubprotocol can be defined by specifying the class that handles storage for the
505: * subsubprotocol by implementing the
506: * {@link org.apache.derby.io.StorageFactory StorageFactory} or
507: * {@link org.apache.derby.io.WritableStorageFactory WritableStorageFactory} interface. This
508: * is done using a property named db2j.subsubprotocol.<i>xxx</i> where <i>xxx</i> is the subsubprotocol name.
509: * Subsubprotocol names are case sensitive and must be at least 3 characters in length.
510: *<p>
511: *
512: * For instance:
513: *<br>
514: * derby.subSubProtocol.mem=com.mycompany.MemStore
515: *<br>
516: * defines the "mem" subsubprotocol with class com.mycompany.MemStore as its StorageFactory implementation.
517: * A database implemented using this subsubprotocol can be opened with the URL "jdbc:derby:mem:myDatabase".
518: *<p>
519: *
520: * Subsubprotocols "directory", "classpath", "jar", "http", and "https" are built in and may not be overridden.
521: */
522: String SUB_SUB_PROTOCOL_PREFIX = "derby.subSubProtocol.";
523:
524: /**
525: * Declare a minimum JDK level the class for a module or sub sub protocol supports.
526: * Set to an integer value from the JVMInfo class to represent a JDK.
527: * If the JDK is running at a lower level than the class requires
528: * then the class will not be loaded and will not be used.
529: *
530: * If there are multiple modules classes implementing the same functionality
531: * and supported by the JVM, then the one with the highest JDK
532: * requirements will be selected. This functionality is not present for
533: * sub sub protocol classes yet.
534: *
535: * See org.apache.derby.iapi.services.info.JVMInfo.JDK_ID
536: */
537: String MODULE_ENV_JDK_PREFIX = "derby.env.jdk.";
538:
539: /**
540: * Declare a set of classes that the class for a module or sub sub protocol requires.
541: * Value is a comma separated list of classes. If the classes listed are not
542: * loadable by the virtual machine then the module class will not be loaded and will not be used.
543: */
544: String MODULE_ENV_CLASSES_PREFIX = "derby.env.classes.";
545:
546: /*
547: ** derby.language.*
548: */
549:
550: /**
551: * The size of the table descriptor cache used by the
552: * data dictionary. Database. Static.
553: * <p>
554: * Undocumented.
555: */
556: String LANG_TD_CACHE_SIZE = "derby.language.tableDescriptorCacheSize";
557: int LANG_TD_CACHE_SIZE_DEFAULT = 64;
558:
559: /**
560: * The size of the permissions cache used by the data dictionary.
561: * Database. Static.
562: * <p>
563: * Undocumented.
564: */
565: String LANG_PERMISSIONS_CACHE_SIZE = "derby.language.permissionsCacheSize";
566: int LANG_PERMISSIONS_CACHE_SIZE_DEFAULT = 64;
567: /**
568: * The size of the stored prepared statment descriptor cache
569: * used by the data dictionary. Database. Static.
570: * <p>
571: * Externally visible.
572: */
573: String LANG_SPS_CACHE_SIZE = "derby.language.spsCacheSize";
574: int LANG_SPS_CACHE_SIZE_DEFAULT = 32;
575:
576: /**
577: derby.language.stalePlanCheckInterval
578:
579: <P>
580: This property tells the number of times a prepared statement should
581: be executed before checking whether its plan is stale. Database.
582: Dynamic.
583: <P>
584: Externally visible.
585: */
586: String LANGUAGE_STALE_PLAN_CHECK_INTERVAL = "derby.language.stalePlanCheckInterval";
587:
588: /** Default value for above */
589: int DEFAULT_LANGUAGE_STALE_PLAN_CHECK_INTERVAL = 100;
590:
591: /** Minimum value for above */
592: int MIN_LANGUAGE_STALE_PLAN_CHECK_INTERVAL = 5;
593:
594: /*
595: Statement plan cache size
596: By default, 100 statements are cached
597: */
598: String STATEMENT_CACHE_SIZE = "derby.language.statementCacheSize";
599: int STATEMENT_CACHE_SIZE_DEFAULT = 100;
600:
601: /* some static fields */
602: public static final String DEFAULT_USER_NAME = "APP";
603: public static final String DATABASE_MODULE = "org.apache.derby.database.Database";
604:
605: /*
606: Property to enable Grant & Revoke SQL authorization. Introduced in Derby 10.2
607: release. New databases and existing databases (in Derby 10.2) still use legacy
608: authorization by default and by setting this property to true could request for
609: SQL standard authorization model.
610: */
611: public static final String SQL_AUTHORIZATION_PROPERTY = "derby.database.sqlAuthorization";
612:
613: public static final String DEFAULT_CONNECTION_MODE_PROPERTY = "derby.database.defaultConnectionMode";
614:
615: public static final String NO_ACCESS = "noAccess";
616: public static final String READ_ONLY_ACCESS = "readOnlyAccess";
617: public static final String FULL_ACCESS = "fullAccess";
618: public static final String DEFAULT_ACCESS = FULL_ACCESS;
619:
620: public static final String READ_ONLY_ACCESS_USERS_PROPERTY = "derby.database.readOnlyAccessUsers";
621:
622: public static final String FULL_ACCESS_USERS_PROPERTY = "derby.database.fullAccessUsers";
623:
624: /*
625: ** Authentication
626: */
627:
628: // This is the property that turn on/off authentication
629: public static final String REQUIRE_AUTHENTICATION_PARAMETER = "derby.connection.requireAuthentication";
630:
631: public static final String AUTHENTICATION_PROVIDER_PARAMETER = "derby.authentication.provider";
632:
633: // This is the user property used by Cloudscape and LDAP schemes
634: public static final String USER_PROPERTY_PREFIX = "derby.user.";
635:
636: // These are the different built-in providers Cloudscape supports
637:
638: public static final String AUTHENTICATION_PROVIDER_BUILTIN = "BUILTIN";
639:
640: public static final String AUTHENTICATION_PROVIDER_LDAP = "LDAP";
641:
642: public static final String AUTHENTICATION_SERVER_PARAMETER = "derby.authentication.server";
643:
644: /*
645: ** Log
646: */
647:
648: /**
649: Property name for specifying log switch interval
650: */
651: public static final String LOG_SWITCH_INTERVAL = "derby.storage.logSwitchInterval";
652:
653: /**
654: Property name for specifying checkpoint interval
655: */
656: public static final String CHECKPOINT_INTERVAL = "derby.storage.checkpointInterval";
657:
658: /**
659: Property name for specifying log archival location
660: */
661: public static final String LOG_ARCHIVAL_DIRECTORY = "derby.storage.logArchive";
662:
663: /**
664: Property name for specifying log Buffer Size
665: */
666: public static final String LOG_BUFFER_SIZE = "derby.storage.logBufferSize";
667:
668: /*
669: ** Upgrade
670: */
671:
672: /**
673: * Allow database upgrade during alpha/beta time. Only intended
674: * to be used to allow Derby developers to test their upgrade code.
675: * Only supported as a system/application (derby.properties) property.
676: */
677: String ALPHA_BETA_ALLOW_UPGRADE = "derby.database.allowPreReleaseUpgrade";
678:
679: /**
680: db2j.inRestore
681: <BR>
682: This Property is used to indicate that we are in restore mode if
683: if the system is doing a restore from backup.
684: Used internally to set flags to indicate that service is not booted.
685: <P>
686: <B>INTERNAL USE ONLY</B>
687: */
688: String IN_RESTORE_FROM_BACKUP = PROPERTY_RUNTIME_PREFIX
689: + "inRestore";
690:
691: /**
692: db2j.deleteRootOnError
693: <BR>
694: If we a new root is created while doing restore from backup,
695: it should be deleted if a error occur before we could complete restore
696: successfully.
697: <P>
698: <B>INTERNAL USE ONLY</B>
699: */
700: String DELETE_ROOT_ON_ERROR = PROPERTY_RUNTIME_PREFIX
701: + "deleteRootOnError";
702:
703: public static final String HTTP_DB_FILE_OFFSET = "db2j.http.file.offset";
704: public static final String HTTP_DB_FILE_LENGTH = "db2j.http.file.length";
705: public static final String HTTP_DB_FILE_NAME = "db2j.http.file.name";
706:
707: /**
708: * derby.drda.startNetworkServer
709: *<BR>
710: * If true then we will attempt to start a DRDA network server when Cloudscape boots,
711: * turning the current JVM into a server.
712: *<BR>
713: * Default: false
714: */
715: public static final String START_DRDA = "derby.drda.startNetworkServer";
716:
717: /**
718: * derby.drda.logConnections
719: *<BR>
720: * Indicates whether to log connections and disconnections.
721: *<BR>
722: * Default: false
723: */
724: public final static String DRDA_PROP_LOGCONNECTIONS = "derby.drda.logConnections";
725: /**
726: * derby.drda.traceAll
727: *<BR>
728: * Turns tracing on for all sessions.
729: *<BR>
730: * Default: false
731: */
732: public final static String DRDA_PROP_TRACEALL = "derby.drda.traceAll";
733: public final static String DRDA_PROP_TRACE = "derby.drda.trace";
734:
735: /**
736: * derby.drda.traceDirectory
737: *<BR>
738: * The directory used for network server tracing files.
739: *<BR>
740: * Default: if the derby.system.home property has been set,
741: * it is the default. Otherwise, the default is the current directory.
742: */
743: public final static String DRDA_PROP_TRACEDIRECTORY = "derby.drda.traceDirectory";
744:
745: public final static String DRDA_PROP_MINTHREADS = "derby.drda.minThreads";
746: public final static String DRDA_PROP_MAXTHREADS = "derby.drda.maxThreads";
747: public final static String DRDA_PROP_TIMESLICE = "derby.drda.timeSlice";
748:
749: /**
750: * derby.drda.securityMechanism
751: *<BR>
752: * This property can be set to one of the following values
753: * USER_ONLY_SECURITY
754: * CLEAR_TEXT_PASSWORD_SECURITY
755: * ENCRYPTED_USER_AND_PASSWORD_SECURITY
756: * STRONG_PASSWORD_SUBSTITUTE_SECURITY
757: * <BR>
758: * if derby.drda.securityMechanism is set to a valid mechanism, then
759: * the Network Server accepts only connections which use that
760: * security mechanism. No other types of connections are accepted.
761: * <BR>
762: * if the derby.drda.securityMechanism is not set at all, then the
763: * Network Server accepts any connection which uses a valid
764: * security mechanism.
765: * <BR>
766: * E.g derby.drda.securityMechanism=USER_ONLY_SECURITY
767: * This property is static. Server must be restarted for the property to take effect.
768: * Default value for this property is as though it is not set - in which case
769: * the server will allow clients with supported security mechanisms to connect
770: */
771: public final static String DRDA_PROP_SECURITYMECHANISM = "derby.drda.securityMechanism";
772:
773: /**
774: * derby.drda.portNumber
775: *<BR>
776: * The port number used by the network server.
777: */
778: public final static String DRDA_PROP_PORTNUMBER = "derby.drda.portNumber";
779: public final static String DRDA_PROP_HOSTNAME = "derby.drda.host";
780:
781: /**
782: * derby.drda.keepAlive
783: *
784: *<BR>
785: * client socket setKeepAlive value
786: */
787: public final static String DRDA_PROP_KEEPALIVE = "derby.drda.keepAlive";
788:
789: /**
790: * derby.drda.streamOutBufferSize
791: * size of buffer used when stream out for client.
792: *
793: */
794: public final static String DRDA_PROP_STREAMOUTBUFFERSIZE = "derby.drda.streamOutBufferSize";
795:
796: /*
797: ** Internal properties, mainly used by Monitor.
798: */
799: public static final String SERVICE_PROTOCOL = "derby.serviceProtocol";
800: public static final String SERVICE_LOCALE = "derby.serviceLocale";
801:
802: /**
803: * db2j.storage.dataNotSyncedAtCheckPoint
804: * <p>
805: * When set, the store system will not force a sync() call on the
806: * containers during a checkpoint.
807: * <p>
808: * An internal debug system only flag. The recovery system will not
809: * work properly if this flag is enabled, it is provided to do performance
810: * debugging to see whether the system is I/O bound based on checkpoint
811: * synchronous I/O.
812: * <p>
813: *
814: **/
815: public static final String STORAGE_DATA_NOT_SYNCED_AT_CHECKPOINT = "db2j.storage.dataNotSyncedAtCheckPoint";
816:
817: /**
818: * db2j.storage.dataNotSyncedAtAllocation
819: * <p>
820: * When set, the store system will not force a sync() call on the
821: * containers when pages are allocated.
822: * <p>
823: * An internal debug system only flag. The recovery system will not
824: * work properly if this flag is enabled, it is provided to do performance
825: * debugging to see whether the system is I/O bound based on page allocation
826: * synchronous I/O.
827: * <p>
828: *
829: **/
830: public static final String STORAGE_DATA_NOT_SYNCED_AT_ALLOCATION = "db2j.storage.dataNotSyncedAtAllocation";
831:
832: /**
833: * db2j.storage.logNotSynced
834: * <p>
835: * When set, the store system will not force a sync() call on the log at
836: * commit.
837: * <p>
838: * An internal debug system only flag. The recovery system will not
839: * work properly if this flag is enabled, it is provided to do performance
840: * debugging to see whether the system is I/O bound based on log file
841: * synchronous I/O.
842: * <p>
843: *
844: **/
845: public static final String STORAGE_LOG_NOT_SYNCED = "db2j.storage.logNotSynced";
846:
847: }
|