1527 lines
67 KiB
C#
1527 lines
67 KiB
C#
// ---------------------------------------------------------------------------
|
|
// <copyright file="DatabaseConfig.g.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//
|
|
// </copyright>
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// DO NOT EDIT THIS FILE DIRECTLY!
|
|
//
|
|
// This file is autogenerated from sysparam.xml using DatabaseConfig.xsl, with compatMode = ""
|
|
// To modify or add new params, make changes to sysparam.xml and then run gengen.bat to update the source files.
|
|
|
|
namespace Microsoft.Database.Isam.Config
|
|
{
|
|
using System;
|
|
using Microsoft.Isam.Esent.Interop;
|
|
using Microsoft.Isam.Esent.Interop.Vista;
|
|
using Microsoft.Isam.Esent.Interop.Windows7;
|
|
using Microsoft.Isam.Esent.Interop.Windows8;
|
|
using Microsoft.Isam.Esent.Interop.Windows81;
|
|
|
|
/// <summary>
|
|
/// A class that contains all engine wide Ese parameters.
|
|
/// </summary>
|
|
public partial class DatabaseConfig : ConfigSetBase
|
|
{
|
|
/// <summary>
|
|
/// The exclusive upper bound on JET_param*.
|
|
/// </summary>
|
|
internal const int ParamMaxValueInvalid = 196; // should be equal to JET_paramMaxValueInvalid
|
|
|
|
/// <summary>
|
|
/// Fills the param table from auto-generated code.
|
|
/// </summary>
|
|
static partial void FillParamTable()
|
|
{
|
|
DatabaseConfig.ParamTable[0] = new ParamDef(0, false, typeof(string)); // JET_paramSystemPath
|
|
DatabaseConfig.ParamTable[1] = new ParamDef(1, false, typeof(string)); // JET_paramTempPath
|
|
DatabaseConfig.ParamTable[2] = new ParamDef(2, false, typeof(string)); // JET_paramLogFilePath
|
|
DatabaseConfig.ParamTable[3] = new ParamDef(3, false, typeof(string)); // JET_paramBaseName
|
|
DatabaseConfig.ParamTable[4] = new ParamDef(4, false, typeof(string)); // JET_paramEventSource
|
|
DatabaseConfig.ParamTable[5] = new ParamDef(5, false, typeof(int)); // JET_paramMaxSessions
|
|
DatabaseConfig.ParamTable[6] = new ParamDef(6, false, typeof(int)); // JET_paramMaxOpenTables
|
|
DatabaseConfig.ParamTable[8] = new ParamDef(8, false, typeof(int)); // JET_paramMaxCursors
|
|
DatabaseConfig.ParamTable[9] = new ParamDef(9, false, typeof(int)); // JET_paramMaxVerPages
|
|
DatabaseConfig.ParamTable[10] = new ParamDef(10, false, typeof(int)); // JET_paramMaxTemporaryTables
|
|
DatabaseConfig.ParamTable[11] = new ParamDef(11, false, typeof(int)); // JET_paramLogFileSize
|
|
DatabaseConfig.ParamTable[12] = new ParamDef(12, false, typeof(int)); // JET_paramLogBuffers
|
|
DatabaseConfig.ParamTable[16] = new ParamDef(16, false, typeof(CommitTransactionGrbit)); // JET_paramCommitDefault
|
|
DatabaseConfig.ParamTable[17] = new ParamDef(17, false, typeof(bool)); // JET_paramCircularLog
|
|
DatabaseConfig.ParamTable[18] = new ParamDef(18, false, typeof(int)); // JET_paramDbExtensionSize
|
|
DatabaseConfig.ParamTable[19] = new ParamDef(19, false, typeof(int)); // JET_paramPageTempDBMin
|
|
DatabaseConfig.ParamTable[20] = new ParamDef(20, false, typeof(int)); // JET_paramPageFragment
|
|
DatabaseConfig.ParamTable[23] = new ParamDef(23, false, typeof(int)); // JET_paramCacheSizeMax
|
|
DatabaseConfig.ParamTable[24] = new ParamDef(24, false, typeof(int)); // JET_paramCheckpointDepthMax
|
|
DatabaseConfig.ParamTable[25] = new ParamDef(25, true, typeof(int)); // JET_paramLRUKCorrInterval
|
|
DatabaseConfig.ParamTable[26] = new ParamDef(26, true, typeof(int)); // JET_paramLRUKHistoryMax
|
|
DatabaseConfig.ParamTable[27] = new ParamDef(27, true, typeof(int)); // JET_paramLRUKPolicy
|
|
DatabaseConfig.ParamTable[28] = new ParamDef(28, true, typeof(int)); // JET_paramLRUKTimeout
|
|
DatabaseConfig.ParamTable[30] = new ParamDef(30, true, typeof(int)); // JET_paramOutstandingIOMax
|
|
DatabaseConfig.ParamTable[31] = new ParamDef(31, false, typeof(int)); // JET_paramStartFlushThreshold
|
|
DatabaseConfig.ParamTable[32] = new ParamDef(32, false, typeof(int)); // JET_paramStopFlushThreshold
|
|
DatabaseConfig.ParamTable[34] = new ParamDef(34, false, typeof(string)); // JET_paramRecovery
|
|
DatabaseConfig.ParamTable[35] = new ParamDef(35, false, typeof(int)); // JET_paramEnableOnlineDefrag
|
|
DatabaseConfig.ParamTable[37] = new ParamDef(37, false, typeof(IntPtr)); // JET_paramPrintFunction
|
|
DatabaseConfig.ParamTable[38] = new ParamDef(38, false, typeof(int)); // JET_paramTransactionLevel
|
|
DatabaseConfig.ParamTable[39] = new ParamDef(39, false, typeof(int)); // JET_paramRFS2IOsPermitted
|
|
DatabaseConfig.ParamTable[40] = new ParamDef(40, false, typeof(int)); // JET_paramRFS2AllocsPermitted
|
|
DatabaseConfig.ParamTable[41] = new ParamDef(41, false, typeof(int)); // JET_paramCacheSize
|
|
DatabaseConfig.ParamTable[42] = new ParamDef(42, false, typeof(int)); // JET_paramCacheRequests
|
|
DatabaseConfig.ParamTable[43] = new ParamDef(43, false, typeof(int)); // JET_paramCacheHits
|
|
DatabaseConfig.ParamTable[45] = new ParamDef(45, false, typeof(bool)); // JET_paramEnableIndexChecking
|
|
DatabaseConfig.ParamTable[46] = new ParamDef(46, false, typeof(bool)); // JET_paramEnableTempTableVersioning
|
|
DatabaseConfig.ParamTable[49] = new ParamDef(49, false, typeof(string)); // JET_paramEventSourceKey
|
|
DatabaseConfig.ParamTable[50] = new ParamDef(50, false, typeof(bool)); // JET_paramNoInformationEvent
|
|
DatabaseConfig.ParamTable[51] = new ParamDef(51, false, typeof(EventLoggingLevels)); // JET_paramEventLoggingLevel
|
|
DatabaseConfig.ParamTable[52] = new ParamDef(52, false, typeof(bool)); // JET_paramDeleteOutOfRangeLogs
|
|
DatabaseConfig.ParamTable[53] = new ParamDef(53, false, typeof(int)); // JET_paramAccessDeniedRetryPeriod
|
|
DatabaseConfig.ParamTable[54] = new ParamDef(54, false, typeof(bool)); // JET_paramEnableIndexCleanup
|
|
DatabaseConfig.ParamTable[60] = new ParamDef(60, false, typeof(int)); // JET_paramCacheSizeMin
|
|
DatabaseConfig.ParamTable[63] = new ParamDef(63, false, typeof(int)); // JET_paramPreferredVerPages
|
|
DatabaseConfig.ParamTable[64] = new ParamDef(64, true, typeof(int)); // JET_paramDatabasePageSize
|
|
DatabaseConfig.ParamTable[65] = new ParamDef(65, false, typeof(bool)); // JET_paramDisableCallbacks
|
|
DatabaseConfig.ParamTable[69] = new ParamDef(69, false, typeof(bool)); // JET_paramLogFileCreateAsynch
|
|
DatabaseConfig.ParamTable[71] = new ParamDef(71, false, typeof(bool)); // JET_paramZeroDatabaseDuringBackup
|
|
DatabaseConfig.ParamTable[72] = new ParamDef(72, false, typeof(JET_UNICODEINDEX)); // JET_paramUnicodeIndexDefault
|
|
DatabaseConfig.ParamTable[73] = new ParamDef(73, false, typeof(IntPtr)); // JET_paramRuntimeCallback
|
|
DatabaseConfig.ParamTable[77] = new ParamDef(77, false, typeof(bool)); // JET_paramCleanupMismatchedLogFiles
|
|
DatabaseConfig.ParamTable[79] = new ParamDef(79, false, typeof(int)); // JET_paramRecoveryCurrentLogfile
|
|
DatabaseConfig.ParamTable[81] = new ParamDef(81, true, typeof(int)); // JET_paramGlobalMinVerPages
|
|
DatabaseConfig.ParamTable[82] = new ParamDef(82, false, typeof(int)); // JET_paramOSSnapshotTimeout
|
|
DatabaseConfig.ParamTable[98] = new ParamDef(98, false, typeof(JET_ExceptionAction)); // JET_paramExceptionAction
|
|
DatabaseConfig.ParamTable[99] = new ParamDef(99, true, typeof(int)); // JET_paramEventLogCache
|
|
DatabaseConfig.ParamTable[100] = new ParamDef(100, false, typeof(bool)); // JET_paramCreatePathIfNotExist
|
|
DatabaseConfig.ParamTable[101] = new ParamDef(101, true, typeof(int)); // JET_paramPageHintCacheSize
|
|
DatabaseConfig.ParamTable[102] = new ParamDef(102, false, typeof(bool)); // JET_paramOneDatabasePerSession
|
|
DatabaseConfig.ParamTable[104] = new ParamDef(104, true, typeof(int)); // JET_paramMaxInstances
|
|
DatabaseConfig.ParamTable[105] = new ParamDef(105, false, typeof(int)); // JET_paramVersionStoreTaskQueueMax
|
|
DatabaseConfig.ParamTable[107] = new ParamDef(107, true, typeof(bool)); // JET_paramDisablePerfmon
|
|
DatabaseConfig.ParamTable[110] = new ParamDef(110, false, typeof(int)); // JET_paramIndexTuplesLengthMin
|
|
DatabaseConfig.ParamTable[111] = new ParamDef(111, false, typeof(int)); // JET_paramIndexTuplesLengthMax
|
|
DatabaseConfig.ParamTable[112] = new ParamDef(112, false, typeof(int)); // JET_paramIndexTuplesToIndexMax
|
|
DatabaseConfig.ParamTable[113] = new ParamDef(113, false, typeof(string)); // JET_paramAlternateDatabaseRecoveryPath
|
|
DatabaseConfig.ParamTable[125] = new ParamDef(125, false, typeof(int)); // JET_paramCachedClosedTables
|
|
DatabaseConfig.ParamTable[126] = new ParamDef(126, true, typeof(bool)); // JET_paramEnableFileCache
|
|
DatabaseConfig.ParamTable[127] = new ParamDef(127, true, typeof(bool)); // JET_paramEnableViewCache
|
|
DatabaseConfig.ParamTable[128] = new ParamDef(128, true, typeof(int)); // JET_paramVerPageSize
|
|
DatabaseConfig.ParamTable[129] = new ParamDef(129, false, typeof(int)); // JET_paramConfiguration
|
|
DatabaseConfig.ParamTable[130] = new ParamDef(130, false, typeof(bool)); // JET_paramEnableAdvanced
|
|
DatabaseConfig.ParamTable[131] = new ParamDef(131, false, typeof(int)); // JET_paramMaxColtyp
|
|
DatabaseConfig.ParamTable[132] = new ParamDef(132, false, typeof(int)); // JET_paramIndexTupleIncrement
|
|
DatabaseConfig.ParamTable[133] = new ParamDef(133, false, typeof(int)); // JET_paramIndexTupleStart
|
|
DatabaseConfig.ParamTable[134] = new ParamDef(134, false, typeof(int)); // JET_paramKeyMost
|
|
DatabaseConfig.ParamTable[135] = new ParamDef(135, false, typeof(int)); // JET_paramCheckpointIOMax
|
|
DatabaseConfig.ParamTable[136] = new ParamDef(136, false, typeof(LegacyFileNames)); // JET_paramLegacyFileNames
|
|
DatabaseConfig.ParamTable[137] = new ParamDef(137, true, typeof(string)); // JET_paramTableClass1Name
|
|
DatabaseConfig.ParamTable[138] = new ParamDef(138, true, typeof(string)); // JET_paramTableClass2Name
|
|
DatabaseConfig.ParamTable[139] = new ParamDef(139, true, typeof(string)); // JET_paramTableClass3Name
|
|
DatabaseConfig.ParamTable[140] = new ParamDef(140, true, typeof(string)); // JET_paramTableClass4Name
|
|
DatabaseConfig.ParamTable[141] = new ParamDef(141, true, typeof(string)); // JET_paramTableClass5Name
|
|
DatabaseConfig.ParamTable[142] = new ParamDef(142, true, typeof(string)); // JET_paramTableClass6Name
|
|
DatabaseConfig.ParamTable[143] = new ParamDef(143, true, typeof(string)); // JET_paramTableClass7Name
|
|
DatabaseConfig.ParamTable[144] = new ParamDef(144, true, typeof(string)); // JET_paramTableClass8Name
|
|
DatabaseConfig.ParamTable[145] = new ParamDef(145, true, typeof(string)); // JET_paramTableClass9Name
|
|
DatabaseConfig.ParamTable[146] = new ParamDef(146, true, typeof(string)); // JET_paramTableClass10Name
|
|
DatabaseConfig.ParamTable[147] = new ParamDef(147, true, typeof(string)); // JET_paramTableClass11Name
|
|
DatabaseConfig.ParamTable[148] = new ParamDef(148, true, typeof(string)); // JET_paramTableClass12Name
|
|
DatabaseConfig.ParamTable[149] = new ParamDef(149, true, typeof(string)); // JET_paramTableClass13Name
|
|
DatabaseConfig.ParamTable[150] = new ParamDef(150, true, typeof(string)); // JET_paramTableClass14Name
|
|
DatabaseConfig.ParamTable[151] = new ParamDef(151, true, typeof(string)); // JET_paramTableClass15Name
|
|
DatabaseConfig.ParamTable[152] = new ParamDef(152, false, typeof(int)); // JET_paramIOPriority
|
|
DatabaseConfig.ParamTable[153] = new ParamDef(153, false, typeof(int)); // JET_paramWaypointLatency
|
|
DatabaseConfig.ParamTable[155] = new ParamDef(155, true, typeof(bool)); // JET_paramDisableBlockVerification
|
|
DatabaseConfig.ParamTable[156] = new ParamDef(156, false, typeof(bool)); // JET_paramEnablePersistedCallbacks
|
|
DatabaseConfig.ParamTable[158] = new ParamDef(158, false, typeof(int)); // JET_paramPeriodicLogRolloverLLR
|
|
DatabaseConfig.ParamTable[160] = new ParamDef(160, false, typeof(bool)); // JET_paramDefragmentSequentialBTrees
|
|
DatabaseConfig.ParamTable[161] = new ParamDef(161, false, typeof(int)); // JET_paramDefragmentSequentialBTreesDensityCheckFrequency
|
|
DatabaseConfig.ParamTable[162] = new ParamDef(162, true, typeof(int)); // JET_paramIOThrottlingTimeQuanta
|
|
DatabaseConfig.ParamTable[163] = new ParamDef(163, false, typeof(int)); // JET_paramLVChunkSizeMost
|
|
DatabaseConfig.ParamTable[164] = new ParamDef(164, true, typeof(int)); // JET_paramMaxCoalesceReadSize
|
|
DatabaseConfig.ParamTable[165] = new ParamDef(165, true, typeof(int)); // JET_paramMaxCoalesceWriteSize
|
|
DatabaseConfig.ParamTable[166] = new ParamDef(166, true, typeof(int)); // JET_paramMaxCoalesceReadGapSize
|
|
DatabaseConfig.ParamTable[167] = new ParamDef(167, true, typeof(int)); // JET_paramMaxCoalesceWriteGapSize
|
|
DatabaseConfig.ParamTable[169] = new ParamDef(169, false, typeof(int)); // JET_paramEnableDBScanInRecovery
|
|
DatabaseConfig.ParamTable[170] = new ParamDef(170, false, typeof(int)); // JET_paramDbScanThrottle
|
|
DatabaseConfig.ParamTable[171] = new ParamDef(171, false, typeof(int)); // JET_paramDbScanIntervalMinSec
|
|
DatabaseConfig.ParamTable[172] = new ParamDef(172, false, typeof(int)); // JET_paramDbScanIntervalMaxSec
|
|
DatabaseConfig.ParamTable[177] = new ParamDef(177, false, typeof(int)); // JET_paramCachePriority
|
|
DatabaseConfig.ParamTable[178] = new ParamDef(178, false, typeof(int)); // JET_paramMaxTransactionSize
|
|
DatabaseConfig.ParamTable[179] = new ParamDef(179, false, typeof(int)); // JET_paramPrereadIOMax
|
|
DatabaseConfig.ParamTable[180] = new ParamDef(180, false, typeof(bool)); // JET_paramEnableDBScanSerialization
|
|
DatabaseConfig.ParamTable[181] = new ParamDef(181, true, typeof(int)); // JET_paramHungIOThreshold
|
|
DatabaseConfig.ParamTable[182] = new ParamDef(182, true, typeof(int)); // JET_paramHungIOActions
|
|
DatabaseConfig.ParamTable[183] = new ParamDef(183, true, typeof(int)); // JET_paramMinDataForXpress
|
|
DatabaseConfig.ParamTable[184] = new ParamDef(184, false, typeof(ShrinkDatabaseGrbit)); // JET_paramEnableShrinkDatabase
|
|
DatabaseConfig.ParamTable[186] = new ParamDef(186, true, typeof(string)); // JET_paramProcessFriendlyName
|
|
DatabaseConfig.ParamTable[187] = new ParamDef(187, false, typeof(IntPtr)); // JET_paramDurableCommitCallback
|
|
DatabaseConfig.ParamTable[189] = new ParamDef(189, false, typeof(string)); // JET_paramConfigStoreSpec
|
|
DatabaseConfig.ParamTable[193] = new ParamDef(193, false, typeof(int)); // JET_paramPersistedLostFlushDetection
|
|
DatabaseConfig.ParamTable[194] = new ParamDef(194, false, typeof(int)); // JET_paramEngineFormatVersion
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter indicates the relative or absolute file system path of the
|
|
/// folder that will contain the checkpoint file for the instance. The path
|
|
/// must be terminated with a backslash character, which indicates that the
|
|
/// target path is a folder.
|
|
/// </summary>
|
|
public string SystemPath
|
|
{
|
|
get { return this.GetParam<string>(0); }
|
|
set { this.SetParam(0, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter indicates the relative or absolute file system path of
|
|
/// the folder or file that will contain the temporary database for the instance.
|
|
/// If the path is to a folder that will contain the temporary database then it
|
|
/// must be terminated with a backslash character.
|
|
/// </summary>
|
|
public string TempPath
|
|
{
|
|
get { return this.GetParam<string>(1); }
|
|
set { this.SetParam(1, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter indicates the relative or absolute file system path of the
|
|
/// folder that will contain the transaction logs for the instance. The path must
|
|
/// be terminated with a backslash character, which indicates that the target path
|
|
/// is a folder.
|
|
/// </summary>
|
|
public string LogFilePath
|
|
{
|
|
get { return this.GetParam<string>(2); }
|
|
set { this.SetParam(2, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter sets the three letter prefix used for many of the files used by
|
|
/// the database engine. For example, the checkpoint file is called EDB.CHK by
|
|
/// default because EDB is the default base name.
|
|
/// </summary>
|
|
public string BaseName
|
|
{
|
|
get { return this.GetParam<string>(3); }
|
|
set { this.SetParam(3, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter supplies an application specific string that will be added to
|
|
/// any event log messages that are emitted by the database engine. This allows
|
|
/// easy correlation of event log messages with the source application. By default
|
|
/// the host application executable name will be used.
|
|
/// </summary>
|
|
public string EventSource
|
|
{
|
|
get { return this.GetParam<string>(4); }
|
|
set { this.SetParam(4, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter reserves the requested number of session resources for use by an
|
|
/// instance. A session resource directly corresponds to a JET_SESID data type.
|
|
/// This setting will affect how many sessions can be used at the same time.
|
|
/// </summary>
|
|
public int MaxSessions
|
|
{
|
|
get { return this.GetParam<int>(5); }
|
|
set { this.SetParam(5, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter reserves the requested number of B+ Tree resources for use by
|
|
/// an instance. This setting will affect how many tables can be used at the same time.
|
|
/// </summary>
|
|
public int MaxOpenTables
|
|
{
|
|
get { return this.GetParam<int>(6); }
|
|
set { this.SetParam(6, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter reserves the requested number of version store pages for use by an instance.
|
|
/// </summary>
|
|
public int MaxCursors
|
|
{
|
|
get { return this.GetParam<int>(8); }
|
|
set { this.SetParam(8, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter reserves the requested number of version store pages for use by an instance.
|
|
/// </summary>
|
|
public int MaxVerPages
|
|
{
|
|
get { return this.GetParam<int>(9); }
|
|
set { this.SetParam(9, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter reserves the requested number of temporary table resources for use
|
|
/// by an instance. This setting will affect how many temporary tables can be used at
|
|
/// the same time. If this system parameter is set to zero then no temporary database
|
|
/// will be created and any activity that requires use of the temporary database will
|
|
/// fail. This setting can be useful to avoid the I/O required to create the temporary
|
|
/// database if it is known that it will not be used.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The use of a temporary table also requires a cursor resource.
|
|
/// </remarks>
|
|
public int MaxTemporaryTables
|
|
{
|
|
get { return this.GetParam<int>(10); }
|
|
set { this.SetParam(10, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter will configure the size of the transaction log files. Each
|
|
/// transaction log file is a fixed size. The size is equal to the setting of
|
|
/// this system parameter in units of 1024 bytes.
|
|
/// </summary>
|
|
public int LogFileSize
|
|
{
|
|
get { return this.GetParam<int>(11); }
|
|
set { this.SetParam(11, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter will configure the amount of memory used to cache log records
|
|
/// before they are written to the transaction log file. The unit for this
|
|
/// parameter is the sector size of the volume that holds the transaction log files.
|
|
/// The sector size is almost always 512 bytes, so it is safe to assume that size
|
|
/// for the unit. This parameter has an impact on performance. When the database
|
|
/// engine is under heavy update load, this buffer can become full very rapidly.
|
|
/// A larger cache size for the transaction log file is critical for good update
|
|
/// performance under such a high load condition. The default is known to be too small
|
|
/// for this case.
|
|
/// Do not set this parameter to a number of buffers that is larger (in bytes) than
|
|
/// half the size of a transaction log file.
|
|
/// </summary>
|
|
public int LogBuffers
|
|
{
|
|
get { return this.GetParam<int>(12); }
|
|
set { this.SetParam(12, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter sets the default grbits for committing transactions.
|
|
/// See <see cref="Api.JetCommitTransaction"/> and <see cref="Windows8Api.JetCommitTransaction2"/>L
|
|
/// </summary>
|
|
public CommitTransactionGrbit CommitDefault
|
|
{
|
|
get { return this.GetParam<CommitTransactionGrbit>(16); }
|
|
set { this.SetParam(16, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter configures how transaction log files are managed by the database
|
|
/// engine. When circular logging is off, all transaction log files that are generated
|
|
/// are retained on disk until they are no longer needed because a full backup of the
|
|
/// database has been performed. When circular logging is on, only transaction log files
|
|
/// that are younger than the current checkpoint are retained on disk. The benefit of
|
|
/// this mode is that backups are not required to retire old transaction log files.
|
|
/// </summary>
|
|
public bool CircularLog
|
|
{
|
|
get { return this.GetParam<bool>(17); }
|
|
set { this.SetParam(17, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls the amount of space that is added to a database file each
|
|
/// time it needs to grow to accommodate more data. The size is in database pages.
|
|
/// </summary>
|
|
public int DbExtensionSize
|
|
{
|
|
get { return this.GetParam<int>(18); }
|
|
set { this.SetParam(18, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls the initial size of the temporary database. The size is in
|
|
/// database pages. A size of zero indicates that the default size of an ordinary
|
|
/// database should be used. It is often desirable for small applications to configure
|
|
/// the temporary database to be as small as possible. Setting this parameter to
|
|
/// SystemParameters.PageTempDBSmallest will achieve the smallest temporary database possible.
|
|
/// </summary>
|
|
public int PageTempDBMin
|
|
{
|
|
get { return this.GetParam<int>(19); }
|
|
set { this.SetParam(19, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets PageFragment of type int
|
|
/// </summary>
|
|
public int PageFragment
|
|
{
|
|
get { return this.GetParam<int>(20); }
|
|
set { this.SetParam(20, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter configures the maximum size of the database page cache. The size
|
|
/// is in database pages. If this parameter is left to its default value, then the
|
|
/// maximum size of the cache will be set to the size of physical memory when JetInit
|
|
/// is called.
|
|
/// </summary>
|
|
public int CacheSizeMax
|
|
{
|
|
get { return this.GetParam<int>(23); }
|
|
set { this.SetParam(23, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls how aggressively database pages are flushed from the
|
|
/// database page cache to minimize the amount of time it will take to recover from a
|
|
/// crash. The parameter is a threshold in bytes for about how many transaction log
|
|
/// files will need to be replayed after a crash. If circular logging is enabled using
|
|
/// JET_param.CircularLog then this parameter will also control the approximate amount
|
|
/// of transaction log files that will be retained on disk.
|
|
/// </summary>
|
|
public int CheckpointDepthMax
|
|
{
|
|
get { return this.GetParam<int>(24); }
|
|
set { this.SetParam(24, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls the correlation interval of ESE's LRU-K page replacement
|
|
/// algorithm.
|
|
/// </summary>
|
|
public int LRUKCorrInterval
|
|
{
|
|
get { return this.GetParam<int>(25); }
|
|
set { this.SetParam(25, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets LRUKHistoryMax of type int
|
|
/// </summary>
|
|
public int LRUKHistoryMax
|
|
{
|
|
get { return this.GetParam<int>(26); }
|
|
set { this.SetParam(26, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets LRUKPolicy of type int
|
|
/// </summary>
|
|
public int LRUKPolicy
|
|
{
|
|
get { return this.GetParam<int>(27); }
|
|
set { this.SetParam(27, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls the timeout interval of ESE's LRU-K page replacement
|
|
/// algorithm.
|
|
/// </summary>
|
|
public int LRUKTimeout
|
|
{
|
|
get { return this.GetParam<int>(28); }
|
|
set { this.SetParam(28, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls how many database file I/Os can be queued
|
|
/// per-disk in the host operating system at one time. A larger value
|
|
/// for this parameter can significantly help the performance of a large
|
|
/// database application.
|
|
/// </summary>
|
|
public int OutstandingIOMax
|
|
{
|
|
get { return this.GetParam<int>(30); }
|
|
set { this.SetParam(30, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls when the database page cache begins evicting pages from the
|
|
/// cache to make room for pages that are not cached. When the number of page buffers in the cache
|
|
/// drops below this threshold then a background process will be started to replenish that pool
|
|
/// of available buffers. This threshold is always relative to the maximum cache size as set by
|
|
/// JET_paramCacheSizeMax. This threshold must also always be less than the stop threshold as
|
|
/// set by JET_paramStopFlushThreshold.
|
|
/// <para>
|
|
/// The distance height of the start threshold will determine the response time that the database
|
|
/// page cache must have to produce available buffers before the application needs them. A high
|
|
/// start threshold will give the background process more time to react. However, a high start
|
|
/// threshold implies a higher stop threshold and that will reduce the effective size of the
|
|
/// database page cache for modified pages (Windows 2000) or for all pages (Windows XP and later).
|
|
/// </para>
|
|
/// </summary>
|
|
public int StartFlushThreshold
|
|
{
|
|
get { return this.GetParam<int>(31); }
|
|
set { this.SetParam(31, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls when the database page cache ends evicting pages from the cache to make
|
|
/// room for pages that are not cached. When the number of page buffers in the cache rises above
|
|
/// this threshold then the background process that was started to replenish that pool of available
|
|
/// buffers is stopped. This threshold is always relative to the maximum cache size as set by
|
|
/// JET_paramCacheSizeMax. This threshold must also always be greater than the start threshold
|
|
/// as set by JET_paramStartFlushThreshold.
|
|
/// <para>
|
|
/// The distance between the start threshold and the stop threshold affects the efficiency with
|
|
/// which database pages are flushed by the background process. A larger gap will make it
|
|
/// more likely that writes to neighboring pages may be combined. However, a high stop
|
|
/// threshold will reduce the effective size of the database page cache for modified
|
|
/// pages (Windows 2000) or for all pages (Windows XP and later).
|
|
/// </para>
|
|
/// </summary>
|
|
public int StopFlushThreshold
|
|
{
|
|
get { return this.GetParam<int>(32); }
|
|
set { this.SetParam(32, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter is the master switch that controls crash recovery for an instance.
|
|
/// If this parameter is set to "On" then ARIES style recovery will be used to bring all
|
|
/// databases in the instance to a consistent state in the event of a process or machine
|
|
/// crash. If this parameter is set to "Off" then all databases in the instance will be
|
|
/// managed without the benefit of crash recovery. That is to say, that if the instance
|
|
/// is not shut down cleanly using JetTerm prior to the process exiting or machine shutdown
|
|
/// then the contents of all databases in that instance will be corrupted.
|
|
/// </summary>
|
|
public string Recovery
|
|
{
|
|
get { return this.GetParam<string>(34); }
|
|
set { this.SetParam(34, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls the behavior of online defragmentation when initiated using
|
|
/// <see cref="Api.JetDefragment"/> and <see cref="Api.JetDefragment2"/>.
|
|
/// </summary>
|
|
public int EnableOnlineDefrag
|
|
{
|
|
get { return this.GetParam<int>(35); }
|
|
set { this.SetParam(35, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets PrintFunction of type IntPtr
|
|
/// </summary>
|
|
public IntPtr PrintFunction
|
|
{
|
|
get { return this.GetParam<IntPtr>(37); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets TransactionLevel of type int
|
|
/// </summary>
|
|
public int TransactionLevel
|
|
{
|
|
get { return this.GetParam<int>(38); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets RFS2IOsPermitted of type int
|
|
/// </summary>
|
|
public int RFS2IOsPermitted
|
|
{
|
|
get { return this.GetParam<int>(39); }
|
|
set { this.SetParam(39, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets RFS2AllocsPermitted of type int
|
|
/// </summary>
|
|
public int RFS2AllocsPermitted
|
|
{
|
|
get { return this.GetParam<int>(40); }
|
|
set { this.SetParam(40, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter can be used to control the size of the database page cache at run time.
|
|
/// Ordinarily, the cache will automatically tune its size as a function of database and
|
|
/// machine activity levels. If the application sets this parameter to zero, then the cache
|
|
/// will tune its own size in this manner. However, if the application sets this parameter
|
|
/// to a non-zero value then the cache will adjust itself to that target size.
|
|
/// </summary>
|
|
public int CacheSize
|
|
{
|
|
get { return this.GetParam<int>(41); }
|
|
set { this.SetParam(41, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets CacheRequests of type int
|
|
/// </summary>
|
|
public int CacheRequests
|
|
{
|
|
get { return this.GetParam<int>(42); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets CacheHits of type int
|
|
/// </summary>
|
|
public int CacheHits
|
|
{
|
|
get { return this.GetParam<int>(43); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// When this parameter is true, every database is checked at JetAttachDatabase time for
|
|
/// indexes over Unicode key columns that were built using an older version of the NLS
|
|
/// library in the operating system. This must be done because the database engine persists
|
|
/// the sort keys generated by LCMapStringW and the value of these sort keys change from release to release.
|
|
/// If a primary index is detected to be in this state then JetAttachDatabase will always fail with
|
|
/// JET_err.PrimaryIndexCorrupted.
|
|
/// If any secondary indexes are detected to be in this state then there are two possible outcomes.
|
|
/// If AttachDatabaseGrbit.DeleteCorruptIndexes was passed to JetAttachDatabase then these indexes
|
|
/// will be deleted and JET_wrnCorruptIndexDeleted will be returned from JetAttachDatabase. These
|
|
/// indexes will need to be recreated by your application. If AttachDatabaseGrbit.DeleteCorruptIndexes
|
|
/// was not passed to JetAttachDatabase then the call will fail with JET_errSecondaryIndexCorrupted.
|
|
/// </summary>
|
|
public bool EnableIndexChecking
|
|
{
|
|
get { return this.GetParam<bool>(45); }
|
|
set { this.SetParam(45, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets EnableTempTableVersioning of type bool
|
|
/// </summary>
|
|
public bool EnableTempTableVersioning
|
|
{
|
|
get { return this.GetParam<bool>(46); }
|
|
set { this.SetParam(46, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter can be used to control which event log the database engine uses for its event log
|
|
/// messages. By default, all event log messages will go to the Application event log. If the registry
|
|
/// key name for another event log is configured then the event log messages will go there instead.
|
|
/// </summary>
|
|
public string EventSourceKey
|
|
{
|
|
get { return this.GetParam<string>(49); }
|
|
set { this.SetParam(49, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// When this parameter is true, informational event log messages that would ordinarily be generated by
|
|
/// the database engine will be suppressed.
|
|
/// </summary>
|
|
public bool NoInformationEvent
|
|
{
|
|
get { return this.GetParam<bool>(50); }
|
|
set { this.SetParam(50, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Configures the detail level of eventlog messages that are emitted
|
|
/// to the eventlog by the database engine. Higher numbers will result
|
|
/// in more detailed eventlog messages.
|
|
/// </summary>
|
|
public EventLoggingLevels EventLoggingLevel
|
|
{
|
|
get { return this.GetParam<EventLoggingLevels>(51); }
|
|
set { this.SetParam(51, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete the log files that are not matching (generation wise) during soft recovery.
|
|
/// </summary>
|
|
public bool DeleteOutOfRangeLogs
|
|
{
|
|
get { return this.GetParam<bool>(52); }
|
|
set { this.SetParam(52, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets AccessDeniedRetryPeriod of type int
|
|
/// </summary>
|
|
public int AccessDeniedRetryPeriod
|
|
{
|
|
get { return this.GetParam<int>(53); }
|
|
set { this.SetParam(53, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// After Windows 7, it was discovered that JET_paramEnableIndexCleanup had some implementation limitations, reducing its effectiveness.
|
|
/// Rather than update it to work with locale names, the functionality is removed altogether.
|
|
/// </para>
|
|
/// <para>
|
|
/// Unfortunately JET_paramEnableIndexCleanup can not be ignored altogether. JET_paramEnableIndexChecking defaults to false, so if
|
|
/// JET_paramEnableIndexCleanup were to be removed entirely, then by default there were would be no checks for NLS changes!
|
|
/// </para>
|
|
/// <para>
|
|
/// The current behavious (when enabled) is to track the language sort versions for the indices, and when the sort version for that
|
|
/// particular locale changes, the engine knows which indices are now invalid. For example, if the sort version for only "de-de" changes,
|
|
/// then the "de-de" indices are invalid, but the "en-us" indices will be fine.
|
|
/// </para>
|
|
/// <para>
|
|
/// Post-Windows 8:
|
|
/// JET_paramEnableIndexChecking accepts JET_INDEXCHECKING (which is an enum). The values of '0' and '1' have the same meaning as before,
|
|
/// but '2' is JET_IndexCheckingDeferToOpenTable, which means that the NLS up-to-date-ness is NOT checked when the database is attached.
|
|
/// It is deferred to JetOpenTable(), which may now fail with JET_errPrimaryIndexCorrupted or JET_errSecondaryIndexCorrupted (which
|
|
/// are NOT actual corruptions, but instead reflect an NLS sort change).
|
|
/// </para>
|
|
/// <para>
|
|
/// IN SUMMARY:
|
|
/// New code should explicitly set both IndexChecking and IndexCleanup to the same value.
|
|
/// </para>
|
|
/// </summary>
|
|
public bool EnableIndexCleanup
|
|
{
|
|
get { return this.GetParam<bool>(54); }
|
|
set { this.SetParam(54, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter configures the minimum size of the database page cache. The size is in database pages.
|
|
/// </summary>
|
|
public int CacheSizeMin
|
|
{
|
|
get { return this.GetParam<int>(60); }
|
|
set { this.SetParam(60, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter represents a threshold relative to <see cref="JET_param.MaxVerPages"/> that controls
|
|
/// the discretionary use of version pages by the database engine. If the size of the version store exceeds
|
|
/// this threshold then any information that is only used for optional background tasks, such as reclaiming
|
|
/// deleted space in the database, is instead sacrificed to preserve room for transactional information.
|
|
/// </summary>
|
|
public int PreferredVerPages
|
|
{
|
|
get { return this.GetParam<int>(63); }
|
|
set { this.SetParam(63, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter configures the page size for the database. The page
|
|
/// size is the smallest unit of space allocation possible for a database
|
|
/// file. The database page size is also very important because it sets
|
|
/// the upper limit on the size of an individual record in the database.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Only one database page size is supported per process at this time.
|
|
/// This means that if you are in a single process that contains different
|
|
/// applications that use the database engine then they must all agree on
|
|
/// a database page size.
|
|
/// </remarks>
|
|
public int DatabasePageSize
|
|
{
|
|
get { return this.GetParam<int>(64); }
|
|
set { this.SetParam(64, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets DisableCallbacks of type bool
|
|
/// </summary>
|
|
public bool DisableCallbacks
|
|
{
|
|
get { return this.GetParam<bool>(65); }
|
|
set { this.SetParam(65, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets LogFileCreateAsynch of type bool
|
|
/// </summary>
|
|
public bool LogFileCreateAsynch
|
|
{
|
|
get { return this.GetParam<bool>(69); }
|
|
set { this.SetParam(69, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets ZeroDatabaseDuringBackup of type bool
|
|
/// </summary>
|
|
public bool ZeroDatabaseDuringBackup
|
|
{
|
|
get { return this.GetParam<bool>(71); }
|
|
set { this.SetParam(71, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter configures the default LCMapString() lcid and flags to use for indexing unicode data.
|
|
/// See <see cref="Windows8Api.JetCreateIndex4"/> for more details.
|
|
/// </summary>
|
|
public JET_UNICODEINDEX UnicodeIndexDefault
|
|
{
|
|
get { return this.GetParam<JET_UNICODEINDEX>(72); }
|
|
set { this.SetParam(72, value); }
|
|
}
|
|
|
|
#if !MANAGEDESENT_ON_WSA // Not exposed in MSDK
|
|
/// <summary>
|
|
/// Configures the engine with a <see cref="JET_CALLBACK"/> delegate.
|
|
/// This callback may be called for the following reasons:
|
|
/// <see cref="JET_cbtyp.FreeCursorLS"/>, <see cref="JET_cbtyp.FreeTableLS"/>
|
|
/// or <see cref="JET_cbtyp.Null"/>. See <see cref="Api.JetSetLS"/>
|
|
/// for more information. This parameter cannot currently be retrieved.
|
|
/// </summary>
|
|
public IntPtr RuntimeCallback
|
|
{
|
|
get { return this.GetParam<IntPtr>(73); }
|
|
set { this.SetParam(73, value); }
|
|
}
|
|
#endif
|
|
|
|
/// <summary>
|
|
/// This parameter controls the outcome of JetInit when the database
|
|
/// engine is configured to start using transaction log files on disk
|
|
/// that are of a different size than what is configured. Normally,
|
|
/// <see cref="Api.JetInit"/> will successfully recover the databases
|
|
/// but will fail with <see cref="JET_err.LogFileSizeMismatchDatabasesConsistent"/>
|
|
/// to indicate that the log file size is misconfigured. However, when
|
|
/// this parameter is set to true then the database engine will silently
|
|
/// delete all the old log files, start a new set of transaction log files
|
|
/// using the configured log file size. This parameter is useful when the
|
|
/// application wishes to transparently change its transaction log file
|
|
/// size yet still work transparently in upgrade and restore scenarios.
|
|
/// </summary>
|
|
public bool CleanupMismatchedLogFiles
|
|
{
|
|
get { return this.GetParam<bool>(77); }
|
|
set { this.SetParam(77, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets RecoveryCurrentLogfile of type int
|
|
/// </summary>
|
|
public int RecoveryCurrentLogfile
|
|
{
|
|
get { return this.GetParam<int>(79); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets GlobalMinVerPages of type int
|
|
/// </summary>
|
|
public int GlobalMinVerPages
|
|
{
|
|
get { return this.GetParam<int>(81); }
|
|
set { this.SetParam(81, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets OSSnapshotTimeout of type int
|
|
/// </summary>
|
|
public int OSSnapshotTimeout
|
|
{
|
|
get { return this.GetParam<int>(82); }
|
|
set { this.SetParam(82, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls what happens when an exception is thrown by the
|
|
/// database engine or code that is called by the database engine. When set
|
|
/// to JET_ExceptionMsgBox, any exception will be thrown to the Windows unhandled
|
|
/// exception filter. This will result in the exception being handled as an
|
|
/// application failure. The intent is to prevent application code from erroneously
|
|
/// trying to catch and ignore an exception generated by the database engine.
|
|
/// This cannot be allowed because database corruption could occur. If the application
|
|
/// wishes to properly handle these exceptions then the protection can be disabled
|
|
/// by setting this parameter to JET_ExceptionNone.
|
|
/// </summary>
|
|
public JET_ExceptionAction ExceptionAction
|
|
{
|
|
get { return this.GetParam<JET_ExceptionAction>(98); }
|
|
set { this.SetParam(98, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets EventLogCache of type int
|
|
/// </summary>
|
|
public int EventLogCache
|
|
{
|
|
get { return this.GetParam<int>(99); }
|
|
set { this.SetParam(99, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// When this parameter is set to true then any folder that is missing in a file system path in use by
|
|
/// the database engine will be silently created. Otherwise, the operation that uses the missing file system
|
|
/// path will fail with JET_err.InvalidPath.
|
|
/// </summary>
|
|
public bool CreatePathIfNotExist
|
|
{
|
|
get { return this.GetParam<bool>(100); }
|
|
set { this.SetParam(100, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets PageHintCacheSize of type int
|
|
/// </summary>
|
|
public int PageHintCacheSize
|
|
{
|
|
get { return this.GetParam<int>(101); }
|
|
set { this.SetParam(101, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// When this parameter is true then only one database is allowed to
|
|
/// be opened using JetOpenDatabase by a given session at one time.
|
|
/// The temporary database is excluded from this restriction.
|
|
/// </summary>
|
|
public bool OneDatabasePerSession
|
|
{
|
|
get { return this.GetParam<bool>(102); }
|
|
set { this.SetParam(102, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls the maximum number of instances that can be created in a single process.
|
|
/// </summary>
|
|
public int MaxInstances
|
|
{
|
|
get { return this.GetParam<int>(104); }
|
|
set { this.SetParam(104, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls the number of background cleanup work items that
|
|
/// can be queued to the database engine thread pool at any one time.
|
|
/// </summary>
|
|
public int VersionStoreTaskQueueMax
|
|
{
|
|
get { return this.GetParam<int>(105); }
|
|
set { this.SetParam(105, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets DisablePerfmon of type bool
|
|
/// </summary>
|
|
public bool DisablePerfmon
|
|
{
|
|
get { return this.GetParam<bool>(107); }
|
|
set { this.SetParam(107, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets IndexTuplesLengthMin of type int
|
|
/// </summary>
|
|
public int IndexTuplesLengthMin
|
|
{
|
|
get { return this.GetParam<int>(110); }
|
|
set { this.SetParam(110, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets IndexTuplesLengthMax of type int
|
|
/// </summary>
|
|
public int IndexTuplesLengthMax
|
|
{
|
|
get { return this.GetParam<int>(111); }
|
|
set { this.SetParam(111, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets IndexTuplesToIndexMax of type int
|
|
/// </summary>
|
|
public int IndexTuplesToIndexMax
|
|
{
|
|
get { return this.GetParam<int>(112); }
|
|
set { this.SetParam(112, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The full path to each database is persisted in the transaction logs
|
|
/// at run time. Ordinarily, these databases must remain at the original
|
|
/// location for transaction replay to function correctly. This
|
|
/// parameter can be used to force crash recovery or a restore operation
|
|
/// to look for the databases referenced in the transaction log in the
|
|
/// specified folder.
|
|
/// </summary>
|
|
public string AlternateDatabaseRecoveryPath
|
|
{
|
|
get { return this.GetParam<string>(113); }
|
|
set { this.SetParam(113, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter controls the number of B+ Tree resources cached by
|
|
/// the instance after the tables they represent have been closed by
|
|
/// the application. Large values for this parameter will cause the
|
|
/// database engine to use more memory but will increase the speed
|
|
/// with which a large number of tables can be opened randomly by
|
|
/// the application. This is useful for applications that have a
|
|
/// schema with a very large number of tables.
|
|
/// </summary>
|
|
public int CachedClosedTables
|
|
{
|
|
get { return this.GetParam<int>(125); }
|
|
set { this.SetParam(125, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enable the use of the OS file cache for all managed files.
|
|
/// </summary>
|
|
public bool EnableFileCache
|
|
{
|
|
get { return this.GetParam<bool>(126); }
|
|
set { this.SetParam(126, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enable the use of memory mapped file I/O for database files.
|
|
/// </summary>
|
|
public bool EnableViewCache
|
|
{
|
|
get { return this.GetParam<bool>(127); }
|
|
set { this.SetParam(127, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter sets the page size used by the version store.
|
|
/// This page size is a runtime parameter and has no effect on the database format.
|
|
/// </summary>
|
|
public int VerPageSize
|
|
{
|
|
get { return this.GetParam<int>(128); }
|
|
set { this.SetParam(128, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter exposes multiple sets of default values for the
|
|
/// entire set of system parameters. When this parameter is set to
|
|
/// a specific configuration, all system parameter values are reset
|
|
/// to their default values for that configuration. If the
|
|
/// configuration is set for a specific instance then global system
|
|
/// parameters will not be reset to their default values.
|
|
/// Small Configuration (0): The database engine is optimized for memory use.
|
|
/// Legacy Configuration (1): The database engine has its traditional defaults.
|
|
/// </summary>
|
|
public int Configuration
|
|
{
|
|
get { return this.GetParam<int>(129); }
|
|
set { this.SetParam(129, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter is used to control when the database engine accepts
|
|
/// or rejects changes to a subset of the system parameters. This
|
|
/// parameter is used in conjunction with ><see cref="Configuration"/> to
|
|
/// prevent some system parameters from being set away from the selected
|
|
/// configuration's defaults.
|
|
/// </summary>
|
|
public bool EnableAdvanced
|
|
{
|
|
get { return this.GetParam<bool>(130); }
|
|
set { this.SetParam(130, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets MaxColtyp of type int
|
|
/// </summary>
|
|
public int MaxColtyp
|
|
{
|
|
get { return this.GetParam<int>(131); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets IndexTupleIncrement of type int
|
|
/// </summary>
|
|
public int IndexTupleIncrement
|
|
{
|
|
get { return this.GetParam<int>(132); }
|
|
set { this.SetParam(132, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets IndexTupleStart of type int
|
|
/// </summary>
|
|
public int IndexTupleStart
|
|
{
|
|
get { return this.GetParam<int>(133); }
|
|
set { this.SetParam(133, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This read-only parameter indicates the maximum allowable index key
|
|
/// length that can be selected for the current database page size
|
|
/// (as configured by <see cref="JET_param.DatabasePageSize"/>).
|
|
/// </summary>
|
|
public int KeyMost
|
|
{
|
|
get { return this.GetParam<int>(134); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter is used to control the maxiumum number of pending flush writes generated by checkpoint advancement.
|
|
/// </summary>
|
|
public int CheckpointIOMax
|
|
{
|
|
get { return this.GetParam<int>(135); }
|
|
set { this.SetParam(135, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter provides backwards compatibility with the file naming conventions of earlier releases of the database engine.
|
|
/// </summary>
|
|
public LegacyFileNames LegacyFileNames
|
|
{
|
|
get { return this.GetParam<LegacyFileNames>(136); }
|
|
set { this.SetParam(136, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 1.
|
|
/// </summary>
|
|
public string TableClass1Name
|
|
{
|
|
get { return this.GetParam<string>(137); }
|
|
set { this.SetParam(137, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 2.
|
|
/// </summary>
|
|
public string TableClass2Name
|
|
{
|
|
get { return this.GetParam<string>(138); }
|
|
set { this.SetParam(138, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 3.
|
|
/// </summary>
|
|
public string TableClass3Name
|
|
{
|
|
get { return this.GetParam<string>(139); }
|
|
set { this.SetParam(139, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 4.
|
|
/// </summary>
|
|
public string TableClass4Name
|
|
{
|
|
get { return this.GetParam<string>(140); }
|
|
set { this.SetParam(140, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 5.
|
|
/// </summary>
|
|
public string TableClass5Name
|
|
{
|
|
get { return this.GetParam<string>(141); }
|
|
set { this.SetParam(141, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 6.
|
|
/// </summary>
|
|
public string TableClass6Name
|
|
{
|
|
get { return this.GetParam<string>(142); }
|
|
set { this.SetParam(142, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 7.
|
|
/// </summary>
|
|
public string TableClass7Name
|
|
{
|
|
get { return this.GetParam<string>(143); }
|
|
set { this.SetParam(143, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 8.
|
|
/// </summary>
|
|
public string TableClass8Name
|
|
{
|
|
get { return this.GetParam<string>(144); }
|
|
set { this.SetParam(144, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 9.
|
|
/// </summary>
|
|
public string TableClass9Name
|
|
{
|
|
get { return this.GetParam<string>(145); }
|
|
set { this.SetParam(145, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 10.
|
|
/// </summary>
|
|
public string TableClass10Name
|
|
{
|
|
get { return this.GetParam<string>(146); }
|
|
set { this.SetParam(146, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 11.
|
|
/// </summary>
|
|
public string TableClass11Name
|
|
{
|
|
get { return this.GetParam<string>(147); }
|
|
set { this.SetParam(147, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 12.
|
|
/// </summary>
|
|
public string TableClass12Name
|
|
{
|
|
get { return this.GetParam<string>(148); }
|
|
set { this.SetParam(148, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 13.
|
|
/// </summary>
|
|
public string TableClass13Name
|
|
{
|
|
get { return this.GetParam<string>(149); }
|
|
set { this.SetParam(149, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 14.
|
|
/// </summary>
|
|
public string TableClass14Name
|
|
{
|
|
get { return this.GetParam<string>(150); }
|
|
set { this.SetParam(150, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the name associated with table class 15.
|
|
/// </summary>
|
|
public string TableClass15Name
|
|
{
|
|
get { return this.GetParam<string>(151); }
|
|
set { this.SetParam(151, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets IOPriority of type int
|
|
/// </summary>
|
|
public int IOPriority
|
|
{
|
|
get { return this.GetParam<int>(152); }
|
|
set { this.SetParam(152, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter sets the number of logs that esent will defer database
|
|
/// flushes for. This can be used to increase database recoverability if
|
|
/// failures cause logfiles to be lost.
|
|
/// </summary>
|
|
public int WaypointLatency
|
|
{
|
|
get { return this.GetParam<int>(153); }
|
|
set { this.SetParam(153, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets DisableBlockVerification of type bool
|
|
/// </summary>
|
|
public bool DisableBlockVerification
|
|
{
|
|
get { return this.GetParam<bool>(155); }
|
|
set { this.SetParam(155, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets EnablePersistedCallbacks of type bool
|
|
/// </summary>
|
|
public bool EnablePersistedCallbacks
|
|
{
|
|
get { return this.GetParam<bool>(156); }
|
|
set { this.SetParam(156, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets PeriodicLogRolloverLLR of type int
|
|
/// </summary>
|
|
public int PeriodicLogRolloverLLR
|
|
{
|
|
get { return this.GetParam<int>(158); }
|
|
set { this.SetParam(158, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets DefragmentSequentialBTrees of type bool
|
|
/// </summary>
|
|
public bool DefragmentSequentialBTrees
|
|
{
|
|
get { return this.GetParam<bool>(160); }
|
|
set { this.SetParam(160, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets DefragmentSequentialBTreesDensityCheckFrequency of type int
|
|
/// </summary>
|
|
public int DefragmentSequentialBTreesDensityCheckFrequency
|
|
{
|
|
get { return this.GetParam<int>(161); }
|
|
set { this.SetParam(161, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets IOThrottlingTimeQuanta of type int
|
|
/// </summary>
|
|
public int IOThrottlingTimeQuanta
|
|
{
|
|
get { return this.GetParam<int>(162); }
|
|
set { this.SetParam(162, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter is used to retrieve the chunk size of long-value
|
|
/// (blob) data. Setting and retrieving data in multiples of this
|
|
/// size increases efficiency.
|
|
/// </summary>
|
|
public int LVChunkSizeMost
|
|
{
|
|
get { return this.GetParam<int>(163); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maximum number of bytes that can be grouped for a coalesced read operation.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// max = 10MB
|
|
/// </remarks>
|
|
public int MaxCoalesceReadSize
|
|
{
|
|
get { return this.GetParam<int>(164); }
|
|
set { this.SetParam(164, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maximum number of bytes that can be grouped for a coalesced write operation.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// max = 10MB
|
|
/// </remarks>
|
|
public int MaxCoalesceWriteSize
|
|
{
|
|
get { return this.GetParam<int>(165); }
|
|
set { this.SetParam(165, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maximum number of bytes that can be gapped for a coalesced read operation.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// max = 10MB
|
|
/// </remarks>
|
|
public int MaxCoalesceReadGapSize
|
|
{
|
|
get { return this.GetParam<int>(166); }
|
|
set { this.SetParam(166, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maximum number of bytes that can be gapped for a coalesced write operation.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// max = 10MB
|
|
/// </remarks>
|
|
public int MaxCoalesceWriteGapSize
|
|
{
|
|
get { return this.GetParam<int>(167); }
|
|
set { this.SetParam(167, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter enables or disables Database Maintenance during recovery.
|
|
/// </summary>
|
|
public int EnableDBScanInRecovery
|
|
{
|
|
get { return this.GetParam<int>(169); }
|
|
set { this.SetParam(169, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This parameter sets the throttling interval for database scan, in milliseconds.
|
|
/// </summary>
|
|
public int DbScanThrottle
|
|
{
|
|
get { return this.GetParam<int>(170); }
|
|
set { this.SetParam(170, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The minimum amount of time to wait between two consecutive database scans.
|
|
/// This parameter can be used to control how soon a database scan restarts after it has finished scanning the full database.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// min = 0 sec, max = 3 weeks, default = 1 day
|
|
/// </remarks>
|
|
public int DbScanIntervalMinSec
|
|
{
|
|
get { return this.GetParam<int>(171); }
|
|
set { this.SetParam(171, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The maximum amount of time allowed between two consecutive database scans.
|
|
/// This parameter can be used to control the maximum allowed time a database scan can take.
|
|
/// The engine writes a warning message to the event log if a database scan can't finish in the specifed time.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// min = 1 sec, max = 50 years, default = 1 week
|
|
/// </remarks>
|
|
public int DbScanIntervalMaxSec
|
|
{
|
|
get { return this.GetParam<int>(172); }
|
|
set { this.SetParam(172, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Per-instance property for relative cache priorities (default = 100).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// min = 0, max = 1000, default = 100
|
|
/// </remarks>
|
|
public int CachePriority
|
|
{
|
|
get { return this.GetParam<int>(177); }
|
|
set { this.SetParam(177, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Percentage of version store that can be used by oldest transaction
|
|
/// before <see cref="JET_err.VersionStoreOutOfMemory"/> (default = 100).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// min = 0, max = 100, default = 100
|
|
/// </remarks>
|
|
public int MaxTransactionSize
|
|
{
|
|
get { return this.GetParam<int>(178); }
|
|
set { this.SetParam(178, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maximum number of I/O operations dispatched for a given preread operation.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// min = 0, max = 256, default = 8
|
|
/// </remarks>
|
|
public int PrereadIOMax
|
|
{
|
|
get { return this.GetParam<int>(179); }
|
|
set { this.SetParam(179, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Setting this parameter to true forces database maintenance/scan related IOs to be
|
|
/// issued one at a time if they share the same disk.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// default = false
|
|
/// </remarks>
|
|
public bool EnableDBScanSerialization
|
|
{
|
|
get { return this.GetParam<bool>(180); }
|
|
set { this.SetParam(180, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The threshold in milliseconds for what is considered a hung IO that should be acted upon.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// min = 11 sec (see Reasonable Period in http://www.microsoft.com/whdc/driver/kernel/iocancel.mspx), max = 30 min, default = 30 seconds
|
|
/// </remarks>
|
|
public int HungIOThreshold
|
|
{
|
|
get { return this.GetParam<int>(181); }
|
|
set { this.SetParam(181, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// A set of actions to be taken on IOs that appear hung.
|
|
/// </summary>
|
|
public int HungIOActions
|
|
{
|
|
get { return this.GetParam<int>(182); }
|
|
set { this.SetParam(182, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Smallest amount of data that should be compressed with xpress compression.
|
|
/// </summary>
|
|
public int MinDataForXpress
|
|
{
|
|
get { return this.GetParam<int>(183); }
|
|
set { this.SetParam(183, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Whether to free space back to the OS after deleting data. This may free space
|
|
/// in the middle of files (done in the units of database extents). This uses Sparse Files,
|
|
/// which is available on NTFS and ReFS (not FAT). The exact method of releasing space is an
|
|
/// implementation detail and is subject to change.
|
|
/// </summary>
|
|
public ShrinkDatabaseGrbit EnableShrinkDatabase
|
|
{
|
|
get { return this.GetParam<ShrinkDatabaseGrbit>(184); }
|
|
set { this.SetParam(184, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Friendly name for this instance of the process.
|
|
/// </summary>
|
|
public string ProcessFriendlyName
|
|
{
|
|
get { return this.GetParam<string>(186); }
|
|
set { this.SetParam(186, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Callback for when log is flushed.
|
|
/// </summary>
|
|
public IntPtr DurableCommitCallback
|
|
{
|
|
get { return this.GetParam<IntPtr>(187); }
|
|
set { this.SetParam(187, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// This allows the client to specify a registry path preceded by a reg: to optionally configure
|
|
/// loading or overriding parameters from the registry.
|
|
/// </summary>
|
|
public string ConfigStoreSpec
|
|
{
|
|
get { return this.GetParam<string>(189); }
|
|
set { this.SetParam(189, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Configures persisted lost flush detection for databases while attached to an instance.
|
|
/// </summary>
|
|
public int PersistedLostFlushDetection
|
|
{
|
|
get { return this.GetParam<int>(193); }
|
|
set { this.SetParam(193, value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Engine format version - specifies the maximum format version the engine should allow, ensuring no format features are used beyond this (allowing the DB / logs to be forward compatible).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Note: It is generally expected that most consumers will for simplicity set this even before the
|
|
/// JetInit call to affect both log and database formats.
|
|
/// However to support some complex consumer scenarios, while this param may seem like it can be set
|
|
/// after instance init / JetInit(), we actually maintain a slight more complicated lifecycle. We
|
|
/// allow it to be set after inst init as long as there are zero attached databases.
|
|
/// </remarks>
|
|
public int EngineFormatVersion
|
|
{
|
|
get { return this.GetParam<int>(194); }
|
|
set { this.SetParam(194, value); }
|
|
}
|
|
|
|
}
|
|
}
|