RepoMirrors
/
DSInternals
mirror of https://github.com/MichaelGrafnetter/DSInternals
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
DSInternals/Src/Microsoft.Isam.Esent.Interop/grbits.cs

1778 lines
62 KiB
C#
Raw Blame History

//-----------------------------------------------------------------------
// <copyright file="grbits.cs" company="Microsoft Corporation">
// Copyright (c) Microsoft Corporation.
// </copyright>
//-----------------------------------------------------------------------
namespace Microsoft.Isam.Esent.Interop
{
using System;
using System.Collections.Generic;
/// <summary>
/// Options for <see cref="Api.JetCreateInstance2"/>.
/// </summary>
[Flags]
public enum CreateInstanceGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
}
/// <summary>
/// Options for <see cref="Api.JetInit2"/>.
/// </summary>
/// <seealso cref="Vista.VistaGrbits.RecoveryWithoutUndo"/>
/// <seealso cref="Vista.VistaGrbits.TruncateLogsAfterRecovery"/>
/// <seealso cref="Vista.VistaGrbits.ReplayMissingMapEntryDB"/>
/// <seealso cref="Vista.VistaGrbits.LogStreamMustExist"/>
/// <seealso cref="Windows7.Windows7Grbits.ReplayIgnoreLostLogs"/>
/// <seealso cref="Windows8.Windows8Grbits.KeepDbAttachedAtEndOfRecovery"/>
[Flags]
public enum InitGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0
}
/// <summary>
/// Options for <see cref="Api.JetTerm2"/>.
/// </summary>
/// <seealso cref="Windows7.Windows7Grbits.Dirty"/>
[Flags]
public enum TermGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// Requests that the instance be shut down cleanly. Any optional
/// cleanup work that would ordinarily be done in the background at
/// run time is completed immediately.
/// </summary>
Complete = 1,
/// <summary>
/// Requests that the instance be shut down as quickly as possible.
/// Any optional work that would ordinarily be done in the
/// background at run time is abandoned.
/// </summary>
Abrupt = 2,
}
/// <summary>
/// Options for <see cref="Api.JetCreateDatabase"/>.
/// </summary>
/// <seealso cref="Windows7.Windows7Grbits.EnableCreateDbBackgroundMaintenance"/>
[Flags]
public enum CreateDatabaseGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// By default, if JetCreateDatabase is called and the database already exists,
/// the Api call will fail and the original database will not be overwritten.
/// OverwriteExisting changes this behavior, and the old database
/// will be overwritten with a new one.
/// </summary>
OverwriteExisting = 0x200,
/// <summary>
/// Turns off logging. Setting this bit loses the ability to replay log files
/// and recover the database to a consistent usable state after a crash.
/// </summary>
RecoveryOff = 0x8,
}
/// <summary>
/// Options for <see cref="Api.JetDetachDatabase2"/>.
/// </summary>
[Flags]
public enum DetachDatabaseGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// If <see cref="ForceDetach"/> is used, <see cref="EsentForceDetachNotAllowedException"/> will be returned.
/// </summary>
[Obsolete("ForceDetach is no longer used.")]
ForceDetach = 1,
/// <summary>
/// <see cref="ForceClose"/> is no longer used.
/// </summary>
[Obsolete("ForceClose is no longer used.")]
ForceClose = 0x2,
/// <summary>
/// If <see cref="ForceCloseAndDetach"/> is used, <see cref="EsentForceDetachNotAllowedException"/> will be returned.
/// </summary>
[Obsolete("ForceCloseAndDetach is no longer used.")]
ForceCloseAndDetach = (0x2 | 0x1 /*ForceDetach*/),
}
/// <summary>
/// Options for <see cref="Api.JetAttachDatabase"/>.
/// </summary>
/// <seealso cref="Windows7.Windows7Grbits.EnableAttachDbBackgroundMaintenance"/>
/// <seealso cref="Windows8.Windows8Grbits.PurgeCacheOnAttach"/>
[Flags]
public enum AttachDatabaseGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// Prevents modifications to the database.
/// </summary>
ReadOnly = 0x1,
/// <summary>
/// If JET_paramEnableIndexChecking has been set, all indexes over Unicode
/// data will be deleted.
/// </summary>
DeleteCorruptIndexes = 0x10,
}
/// <summary>
/// Options for <see cref="Api.JetOpenDatabase"/>.
/// </summary>
[Flags]
public enum OpenDatabaseGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// Prevents modifications to the database.
/// </summary>
ReadOnly = 0x1,
/// <summary>
/// Allows only a single session to attach a database.
/// Normally, several sessions can open a database.
/// </summary>
Exclusive = 0x2,
}
/// <summary>
/// Options for <see cref="Api.JetCloseDatabase"/>.
/// </summary>
[Flags]
public enum CloseDatabaseGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
}
#if !MANAGEDESENT_ON_WSA // Not exposed in MSDK
/// <summary>
/// Options for <see cref="Api.JetCompact"/>.
/// </summary>
[Flags]
public enum CompactGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// Causes JetCompact to dump statistics on the source database to a file
/// named DFRGINFO.TXT. Statistics include the name of each table in
/// source database, number of rows in each table, total size in bytes of
/// all rows in each table, total size in bytes of all columns of type
/// <see cref="JET_coltyp.LongText"/> or <see cref="JET_coltyp.LongBinary"/>
/// that were large enough to be stored separate from the record, number
/// of clustered index leaf pages, and the number of long value leaf pages.
/// In addition, summary statistics including the size of the source database,
/// destination database, time required for database compaction, temporary
/// database space are all dumped as well.
/// </summary>
Stats = 0x20,
/// <summary>
/// Used when the source database is known to be corrupt. It enables a
/// whole set of new behaviors intended to salvage as much data as
/// possible from the source database. JetCompact with this option set
/// may return <see cref="JET_err.Success"/> but not copy all of the data
/// created in the source database. Data that was in damaged portions of
/// the source database will be skipped.
/// </summary>
[Obsolete("Use esentutl repair functionality instead.")]
Repair = 0x40,
}
/// <summary>
/// Options for <see cref="Api.JetOSSnapshotFreeze"/>.
/// </summary>
[Flags]
public enum SnapshotFreezeGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
}
/// <summary>
/// Options for <see cref="Api.JetOSSnapshotPrepare"/>.
/// </summary>
/// <seealso cref="Vista.VistaGrbits.ContinueAfterThaw"/>
/// <seealso cref="Windows7.Windows7Grbits.ExplicitPrepare"/>
[Flags]
public enum SnapshotPrepareGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// Only logfiles will be taken.
/// </summary>
IncrementalSnapshot = 0x1,
/// <summary>
/// A copy snapshot (normal or incremental) with no log truncation.
/// </summary>
CopySnapshot = 0x2,
}
/// <summary>
/// Options for <see cref="Api.JetOSSnapshotThaw"/>.
/// </summary>
[Flags]
public enum SnapshotThawGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
}
/// <summary>
/// Options for <see cref="Api.JetBackupInstance"/>.
/// </summary>
[Flags]
public enum BackupGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// Creates an incremental backup as opposed to a full backup. This
/// means that only the log files created since the last full or
/// incremental backup will be backed up.
/// </summary>
Incremental = 0x1,
/// <summary>
/// Creates a full backup of the database. This allows the preservation
/// of an existing backup in the same directory if the new backup fails.
/// </summary>
Atomic = 0x4,
}
/// <summary>
/// Options for <see cref="Api.JetBeginExternalBackupInstance"/>.
/// </summary>
[Flags]
public enum BeginExternalBackupGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// Creates an incremental backup as opposed to a full backup. This
/// means that only the log files since the last full or incremental
/// backup will be backed up.
/// </summary>
Incremental = 0x1,
}
/// <summary>
/// Options for <see cref="Api.JetEndExternalBackupInstance"/>.
/// </summary>
/// <seealso cref="Vista.VistaGrbits.TruncateDone"/>
[Flags]
public enum EndExternalBackupGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// The client application finished the backup completely, and is ending normally.
/// </summary>
Normal = 0x1,
/// <summary>
/// The client application is aborting the backup.
/// </summary>
Abort = 0x2,
}
#endif // !MANAGEDESENT_ON_WSA
/// <summary>
/// Options for <see cref="Api.JetBeginTransaction2"/>.
/// </summary>
[Flags]
public enum BeginTransactionGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// The transaction will not modify the database. If an update is attempted,
/// that operation will fail with <see cref="JET_err.TransReadOnly"/>. This
/// option is ignored unless it is requested when the given session is not
/// already in a transaction.
/// </summary>
ReadOnly = 0x1,
}
/// <summary>
/// Options for JetCommitTransaction.
/// </summary>
/// <seealso cref="Windows7.Windows7Grbits.ForceNewLog"/>
[Flags]
public enum CommitTransactionGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// The transaction is committed normally but this Api does not wait for
/// the transaction to be flushed to the transaction log file before returning
/// to the caller. This drastically reduces the duration of a commit operation
/// at the cost of durability. Any transaction that is not flushed to the log
/// before a crash will be automatically aborted during crash recovery during
/// the next call to JetInit. If WaitLastLevel0Commit or WaitAllLevel0Commit
/// are specified, this option is ignored.
/// </summary>
LazyFlush = 0x1,
/// <summary>
/// If the session has previously committed any transactions and they have not yet
/// been flushed to the transaction log file, they should be flushed immediately.
/// This Api will wait until the transactions have been flushed before returning
/// to the caller. This is useful if the application has previously committed several
/// transactions using JET_bitCommitLazyFlush and now wants to flush all of them to disk.
/// </summary>
/// <remarks>
/// This option may be used even if the session is not currently in a transaction.
/// This option cannot be used in combination with any other option.
/// </remarks>
WaitLastLevel0Commit = 0x2,
}
/// <summary>
/// Options for JetRollbackTransaction.
/// </summary>
[Flags]
public enum RollbackTransactionGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// This option requests that all changes made to the state of the
/// database during all save points be undone. As a result, the
/// session will exit the transaction.
/// </summary>
RollbackAll = 0x1,
}
/// <summary>
/// Options for JetEndSession.
/// </summary>
[Flags]
public enum EndSessionGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
}
/// <summary>
/// Options for JetOpenTable.
/// </summary>
[Flags]
public enum OpenTableGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// This table cannot be opened for write access by another session.
/// </summary>
DenyWrite = 0x1,
/// <summary>
/// This table cannot be opened for read access by another session.
/// </summary>
DenyRead = 0x2,
/// <summary>
/// Request read-only access to the table.
/// </summary>
ReadOnly = 0x4,
/// <summary>
/// Request write access to the table.
/// </summary>
Updatable = 0x8,
/// <summary>
/// Allow DDL modifications to a table flagged as FixedDDL. This option
/// must be used with DenyRead.
/// </summary>
PermitDDL = 0x10,
/// <summary>
/// Do not cache pages for this table.
/// </summary>
NoCache = 0x20,
/// <summary>
/// Provides a hint that the table is probably not in the buffer cache, and
/// that pre-reading may be beneficial to performance.
/// </summary>
Preread = 0x40,
/// <summary>
/// Assume a sequential access pattern and prefetch database pages.
/// </summary>
Sequential = 0x8000,
/// <summary>
/// Table belongs to stats class 1.
/// </summary>
TableClass1 = 0x00010000,
/// <summary>
/// Table belongs to stats class 2.
/// </summary>
TableClass2 = 0x00020000,
/// <summary>
/// Table belongs to stats class 3.
/// </summary>
TableClass3 = 0x00030000,
/// <summary>
/// Table belongs to stats class 4.
/// </summary>
TableClass4 = 0x00040000,
/// <summary>
/// Table belongs to stats class 5.
/// </summary>
TableClass5 = 0x00050000,
/// <summary>
/// Table belongs to stats class 6.
/// </summary>
TableClass6 = 0x00060000,
/// <summary>
/// Table belongs to stats class 7.
/// </summary>
TableClass7 = 0x00070000,
/// <summary>
/// Table belongs to stats class 8.
/// </summary>
TableClass8 = 0x00080000,
/// <summary>
/// Table belongs to stats class 9.
/// </summary>
TableClass9 = 0x00090000,
/// <summary>
/// Table belongs to stats class 10.
/// </summary>
TableClass10 = 0x000A0000,
/// <summary>
/// Table belongs to stats class 11.
/// </summary>
TableClass11 = 0x000B0000,
/// <summary>
/// Table belongs to stats class 12.
/// </summary>
TableClass12 = 0x000C0000,
/// <summary>
/// Table belongs to stats class 13.
/// </summary>
TableClass13 = 0x000D0000,
/// <summary>
/// Table belongs to stats class 14.
/// </summary>
TableClass14 = 0x000E0000,
/// <summary>
/// Table belongs to stats class 15.
/// </summary>
TableClass15 = 0x000F0000,
}
#if !MANAGEDESENT_ON_WSA // Not exposed in MSDK
/// <summary>
/// Options for <see cref="Api.JetDupCursor"/>.
/// </summary>
[Flags]
public enum DupCursorGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
}
/// <summary>
/// Options for <see cref="Api.JetSetLS"/> and <see cref="Api.JetGetLS"/>.
/// </summary>
[Flags]
public enum LsGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// The context handle for the chosen object should be reset to JET_LSNil.
/// </summary>
Reset = 0x1,
/// <summary>
/// Specifies the context handle should be associated with the given cursor.
/// </summary>
Cursor = 0x2,
/// <summary>
/// Specifies that the context handle should be associated with the
/// table associated with the given cursor. It is illegal to use this
/// option with <see cref="Cursor"/>.
/// </summary>
Table = 0x4,
}
#endif // !MANAGEDESENT_ON_WSA
/// <summary>
/// Options for the <see cref="Api.JetSetColumn(JET_SESID, JET_TABLEID, JET_COLUMNID, byte[], int, int, SetColumnGrbit, JET_SETINFO)"/>
/// and its associated overloads.
/// </summary>
/// <seealso cref="Windows7.Windows7Grbits.Compressed"/>
/// <seealso cref="Windows7.Windows7Grbits.Uncompressed"/>
[Flags]
public enum SetColumnGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// This option is used to append data to a column of type JET_coltypLongText
/// or JET_coltypLongBinary. The same behavior can be achieved by determining
/// the size of the existing long value and specifying ibLongValue in psetinfo.
/// However, its simpler to use this grbit since knowing the size of the existing
/// column value is not necessary.
/// </summary>
AppendLV = 0x1,
/// <summary>
/// This option is used replace the existing long value with the newly provided
/// data. When this option is used, it is as though the existing long value has
/// been set to 0 (zero) length prior to setting the new data.
/// </summary>
OverwriteLV = 0x4,
/// <summary>
/// This option is only applicable for tagged, sparse or multi-valued columns.
/// It causes the column to return the default column value on subsequent retrieve
/// column operations. All existing column values are removed.
/// </summary>
RevertToDefaultValue = 0x200,
/// <summary>
/// This option is used to force a long value, columns of type JET_coltyp.LongText
/// or JET_coltyp.LongBinary, to be stored separately from the remainder of record
/// data. This occurs normally when the size of the long value prevents it from being
/// stored with remaining record data. However, this option can be used to force the
/// long value to be stored separately. Note that long values four bytes in size
/// of smaller cannot be forced to be separate. In such cases, the option is ignored.
/// </summary>
SeparateLV = 0x40,
/// <summary>
/// This option is used to interpret the input buffer as a integer number of bytes
/// to set as the length of the long value described by the given columnid and if
/// provided, the sequence number in psetinfo->itagSequence. If the size given is
/// larger than the existing column value, the column will be extended with 0s.
/// If the size is smaller than the existing column value then the value will be
/// truncated.
/// </summary>
SizeLV = 0x8,
/// <summary>
/// This option is used to enforce that all values in a multi-valued column are
/// distinct. This option compares the source column data, without any
/// transformations, to other existing column values and an error is returned
/// if a duplicate is found. If this option is given, then AppendLV, OverwriteLV
/// and SizeLV cannot also be given.
/// </summary>
UniqueMultiValues = 0x80,
/// <summary>
/// This option is used to enforce that all values in a multi-valued column are
/// distinct. This option compares the key normalized transformation of column
/// data, to other similarly transformed existing column values and an error is
/// returned if a duplicate is found. If this option is given, then AppendLV,
/// OverwriteLV and SizeLV cannot also be given.
/// </summary>
UniqueNormalizedMultiValues = 0x100,
/// <summary>
/// This option is used to set a value to zero length. Normally, a column value
/// is set to NULL by passing a cbMax of 0 (zero). However, for some types, like
/// JET_coltyp.Text, a column value can be 0 (zero) length instead of NULL, and
/// this option is used to differentiate between NULL and 0 (zero) length.
/// </summary>
ZeroLength = 0x20,
/// <summary>
/// Try to store long-value columns in the record, even if they exceed the default
/// separation size.
/// </summary>
IntrinsicLV = 0x400,
}
/// <summary>
/// Options for JetRetrieveColumn.
/// </summary>
[Flags]
public enum RetrieveColumnGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// This flag causes retrieve column to retrieve the modified value instead of
/// the original value. If the value has not been modified, then the original
/// value is retrieved. In this way, a value that has not yet been inserted or
/// updated may be retrieved during the operation of inserting or updating a record.
/// </summary>
RetrieveCopy = 0x1,
/// <summary>
/// This option is used to retrieve column values from the index, if possible,
/// without accessing the record. In this way, unnecessary loading of records
/// can be avoided when needed data is available from index entries themselves.
/// </summary>
RetrieveFromIndex = 0x2,
/// <summary>
/// This option is used to retrieve column values from the index bookmark,
/// and may differ from the index value when a column appears both in the
/// primary index and the current index. This option should not be specified
/// if the current index is the clustered, or primary, index. This bit cannot
/// be set if RetrieveFromIndex is also set.
/// </summary>
RetrieveFromPrimaryBookmark = 0x4,
/// <summary>
/// This option is used to retrieve the sequence number of a multi-valued
/// column value in JET_RETINFO.itagSequence. Retrieving the sequence number
/// can be a costly operation and should only be done if necessary.
/// </summary>
RetrieveTag = 0x8,
/// <summary>
/// This option is used to retrieve multi-valued column NULL values. If
/// this option is not specified, multi-valued column NULL values will
/// automatically be skipped.
/// </summary>
RetrieveNull = 0x10,
/// <summary>
/// This option affects only multi-valued columns and causes a NULL
/// value to be returned when the requested sequence number is 1 and
/// there are no set values for the column in the record.
/// </summary>
RetrieveIgnoreDefault = 0x20,
}
/// <summary>
/// Options for <see cref="Api.JetEnumerateColumns(JET_SESID, JET_TABLEID, EnumerateColumnsGrbit, out IEnumerable&lt;EnumeratedColumn&gt;)"/>
/// and its associated overloads.
/// </summary>
/// <seealso cref="Server2003.Server2003Grbits.EnumerateIgnoreUserDefinedDefault"/>
/// <seealso cref="Windows7.Windows7Grbits.EnumerateInRecordOnly"/>
[Flags]
public enum EnumerateColumnsGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// When enumerating column values, all columns for which we are retrieving
/// all values and that have only one non-NULL column value may be returned
/// in a compressed format. The status for such columns will be set to
/// <see cref="JET_wrn.ColumnSingleValue"/> and the size of the column value
/// and the memory containing the column value will be returned directly in
/// the <see cref="JET_ENUMCOLUMN"/> structure. It is not guaranteed that
/// all eligible columns are compressed in this manner. See
/// <see cref="JET_ENUMCOLUMN"/> for more information.
/// </summary>
EnumerateCompressOutput = 0x00080000,
/// <summary>
/// This option indicates that the modified column values of the record
/// should be enumerated rather than the original column values. If a
/// column value has not been modified, the original column value is
/// enumerated. In this way, a column value that has not yet been inserted
/// or updated may be enumerated when inserting or updating a record.
/// </summary>
/// <remarks>
/// This option is identical to <see cref="RetrieveColumnGrbit.RetrieveCopy"/>.
/// </remarks>
EnumerateCopy = 0x1,
/// <summary>
/// If a given column is not present in the record then no column value
/// will be returned. Ordinarily, the default value for the column,
/// if any, would be returned in this case. It is guaranteed that if the
/// column is set to a value different than the default value then that
/// different value will be returned (that is, if a column with a
/// default value is explicitly set to NULL then a NULL will be returned
/// as the value for that column). Even if this option is requested, it
/// is still possible to see a column value that happens to be equal to
/// the default value. No effort is made to remove column values that
/// match their default values.
/// It is important to remember that this option affects the output of
/// <see cref="Api.JetEnumerateColumns(JET_SESID, JET_TABLEID, EnumerateColumnsGrbit, out IEnumerable&lt;EnumeratedColumn&gt;)"/>
/// and its associated overloads when used with
/// <see cref="EnumerateColumnsGrbit.EnumeratePresenceOnly"/> or
/// <see cref="EnumerateColumnsGrbit.EnumerateTaggedOnly"/>.
/// </summary>
EnumerateIgnoreDefault = 0x20,
/// <summary>
/// If a non-NULL value exists for the requested column or column value
/// then the associated data is not returned. Instead, the associated
/// status for that column or column value will be set to
/// <see cref="JET_wrn.ColumnPresent"/>. If the column or column value
/// is NULL then <see cref="JET_wrn.ColumnNull"/> will be returned as usual.
/// </summary>
EnumeratePresenceOnly = 0x00020000,
/// <summary>
/// When enumerating all column values in the record (for example,that is
/// when numColumnids is zero), only tagged column values will be returned.
/// This option is not allowed when enumerating a specific array of column IDs.
/// </summary>
EnumerateTaggedOnly = 0x00040000,
}
#if !MANAGEDESENT_ON_WSA // Not exposed in MSDK
/// <summary>
/// Options for <see cref="Vista.VistaApi.JetGetRecordSize"/>.
/// </summary>
[Flags]
public enum GetRecordSizeGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// Retrieve the size of the record that is in the copy buffer prepared
/// or update. Otherwise, the tableid must be positioned on a record,
/// and that record will be used.
/// </summary>
InCopyBuffer = 0x1,
/// <summary>
/// The JET_RECSIZE is not zeroed before filling the contents, effectively
/// acting as an accumulation of the statistics for multiple records visited
/// or updated.
/// </summary>
RunningTotal = 0x2,
/// <summary>
/// Ignore non-intrinsic Long Values. Only the local record on the page
/// will be used.
/// </summary>
Local = 0x4,
}
#endif // !MANAGEDESENT_ON_WSA
/// <summary>
/// Options for <see cref="Api.JetGetSecondaryIndexBookmark"/>.
/// </summary>
[Flags]
public enum GetSecondaryIndexBookmarkGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
}
/// <summary>
/// Options for <see cref="Api.JetGotoSecondaryIndexBookmark"/>.
/// </summary>
[Flags]
public enum GotoSecondaryIndexBookmarkGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// In the event that the index entry can no longer be found, the cursor
/// will be left positioned where that index entry was previously found.
/// The operation will still fail with JET_errRecordDeleted; however,
/// it will be possible to move to the next or previous index entry
/// relative to the index entry that is now missing.
/// </summary>
BookmarkPermitVirtualCurrency = 0x1,
}
/// <summary>
/// Options for JetMove.
/// </summary>
[Flags]
public enum MoveGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// Moves the cursor forward or backward by the number of index entries
/// required to skip the requested number of index key values encountered
/// in the index. This has the effect of collapsing index entries with
/// duplicate key values into a single index entry.
/// </summary>
MoveKeyNE = 0x1,
}
/// <summary>
/// Options for JetMakeKey.
/// </summary>
[Flags]
public enum MakeKeyGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// A new search key should be constructed. Any previously existing search
/// key is discarded.
/// </summary>
NewKey = 0x1,
/// <summary>
/// When this option is specified, all other options are ignored, any
/// previously existing search key is discarded, and the contents of the
/// input buffer are loaded as the new search key.
/// </summary>
NormalizedKey = 0x8,
/// <summary>
/// If the size of the input buffer is zero and the current key column
/// is a variable length column, this option indicates that the input
/// buffer contains a zero length value. Otherwise, an input buffer size
/// of zero would indicate a NULL value.
/// </summary>
KeyDataZeroLength = 0x10,
/// <summary>
/// This option indicates that the search key should be constructed
/// such that any key columns that come after the current key column
/// should be considered to be wildcards.
/// </summary>
StrLimit = 0x2,
/// <summary>
/// This option indicates that the search key should be constructed
/// such that the current key column is considered to be a prefix
/// wildcard and that any key columns that come after the current
/// key column should be considered to be wildcards.
/// </summary>
SubStrLimit = 0x4,
/// <summary>
/// The search key should be constructed such that any key columns
/// that come after the current key column should be considered to
/// be wildcards.
/// </summary>
FullColumnStartLimit = 0x100,
/// <summary>
/// The search key should be constructed in such a way that any key
/// columns that come after the current key column are considered to
/// be wildcards.
/// </summary>
FullColumnEndLimit = 0x200,
/// <summary>
/// The search key should be constructed such that the current key
/// column is considered to be a prefix wildcard and that any key
/// columns that come after the current key column should be considered
/// to be wildcards.
/// </summary>
PartialColumnStartLimit = 0x400,
/// <summary>
/// The search key should be constructed such that the current key
/// column is considered to be a prefix wildcard and that any key
/// columns that come after the current key column should be considered
/// to be wildcards.
/// </summary>
PartialColumnEndLimit = 0x800,
}
/// <summary>
/// Options for JetRetrieveKey.
/// </summary>
[Flags]
public enum RetrieveKeyGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// Retrieve the currently constructed key.
/// </summary>
RetrieveCopy = 0x1,
}
/// <summary>
/// Options for <see cref="Api.JetSeek"/>.
/// </summary>
[Flags]
public enum SeekGrbit
{
/// <summary>
/// The cursor will be positioned at the index entry closest to the
/// start of the index that exactly matches the search key.
/// </summary>
SeekEQ = 0x1,
/// <summary>
/// The cursor will be positioned at the index entry closest to the
/// end of the index that is less than an index entry that would
/// exactly match the search criteria.
/// </summary>
SeekLT = 0x2,
/// <summary>
/// The cursor will be positioned at the index entry closest to the
/// end of the index that is less than or equal to an index entry
/// that would exactly match the search criteria.
/// </summary>
SeekLE = 0x4,
/// <summary>
/// The cursor will be positioned at the index entry closest to the
/// start of the index that is greater than or equal to an index
/// entry that would exactly match the search criteria.
/// </summary>
SeekGE = 0x8,
/// <summary>
/// The cursor will be positioned at the index entry closest to the
/// start of the index that is greater than an index entry that
/// would exactly match the search criteria.
/// </summary>
SeekGT = 0x10,
/// <summary>
/// An index range will automatically be setup for all keys that
/// exactly match the search key.
/// </summary>
SetIndexRange = 0x20,
}
/// <summary>
/// Options for <see cref="Api.JetSetIndexRange"/>.
/// </summary>
[Flags]
public enum SetIndexRangeGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0x0,
/// <summary>
/// This option indicates that the limit of the index range is inclusive.
/// </summary>
RangeInclusive = 0x1,
/// <summary>
/// The search key in the cursor represents the search criteria for the
/// index entry closest to the end of the index that will match the index
/// range.
/// </summary>
RangeUpperLimit = 0x2,
/// <summary>
/// The index range should be removed as soon as it has been established.
/// This is useful for testing for the existence of index entries that
/// match the search criteria.
/// </summary>
RangeInstantDuration = 0x4,
/// <summary>
/// Cancel and existing index range.
/// </summary>
RangeRemove = 0x8,
}
/// <summary>
/// Options for the <see cref="JET_INDEXRANGE"/> object.
/// </summary>
[Flags]
public enum IndexRangeGrbit
{
/// <summary>
/// Records in the cursors indexrange should be included in the output.
/// </summary>
RecordInIndex = 0x1,
}
/// <summary>
/// Options for <see cref="Api.JetIntersectIndexes"/>.
/// </summary>
[Flags]
public enum IntersectIndexesGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
}
/// <summary>
/// Options for <see cref="Api.JetSetCurrentIndex2"/> and
/// <see cref="Api.JetSetCurrentIndex3"/>.
/// </summary>
[Flags]
public enum SetCurrentIndexGrbit
{
/// <summary>
/// Default options. This is the same as <see cref="MoveFirst"/>.
/// </summary>
None = 0,
/// <summary>
/// Indicates that the cursor should be positioned on the first entry of
/// the specified index. If the current index is being selected then this
/// option is ignored.
/// </summary>
MoveFirst = 0,
/// <summary>
/// Indicates that the cursor should be positioned on the index entry
/// of the new index that corresponds to the record associated with the
/// index entry at the current position of the cursor on the old index.
/// </summary>
NoMove = 0x2,
}
/// <summary>
/// Options for <see cref="Api.JetSetTableSequential"/>.
/// </summary>
/// <seealso cref="Windows7.Windows7Grbits.Backward"/>
[Flags]
public enum SetTableSequentialGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
}
/// <summary>
/// Options for <see cref="Api.JetResetTableSequential"/>.
/// </summary>
[Flags]
public enum ResetTableSequentialGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
}
/// <summary>
/// Options for JetGetLock.
/// </summary>
[Flags]
public enum GetLockGrbit
{
/// <summary>
/// Acquire a read lock on the current record. Read locks are incompatible with
/// write locks already held by other sessions but are compatible with read locks
/// held by other sessions.
/// </summary>
Read = 0x1,
/// <summary>
/// Acquire a write lock on the current record. Write locks are not compatible
/// with write or read locks held by other sessions but are compatible with
/// read locks held by the same session.
/// </summary>
Write = 0x2,
}
/// <summary>
/// Options for <see cref="Api.JetEscrowUpdate"/>.
/// </summary>
[Flags]
public enum EscrowUpdateGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// Even if the session performing the escrow update has its transaction rollback
/// this update will not be undone. As the log records may not be flushed to disk,
/// recent escrow updates done with this flag may be lost if there is a crash.
/// </summary>
NoRollback = 0x1,
}
/// <summary>
/// Options for the <see cref="JET_COLUMNDEF"/> structure.
/// </summary>
/// <seealso cref="Windows7.Windows7Grbits.ColumnCompressed"/>
[Flags]
public enum ColumndefGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0x0,
/// <summary>
/// The column will be fixed. It will always use the same amount of space in a row,
/// regardless of how much data is being stored in the column. ColumnFixed
/// cannot be used with ColumnTagged. This bit cannot be used with long values
/// (that is JET_coltyp.LongText and JET_coltyp.LongBinary).
/// </summary>
ColumnFixed = 0x1,
/// <summary>
/// The column will be tagged. Tagged columns do not take up any space in the database
/// if they do not contain data. This bit cannot be used with ColumnFixed.
/// </summary>
ColumnTagged = 0x2,
/// <summary>
/// The column must never be set to a NULL value. On Windows XP this can only be applied to
/// fixed columns (bit, byte, integer, etc).
/// </summary>
ColumnNotNULL = 0x4,
/// <summary>
/// The column is a version column that specifies the version of the row. The value of
/// this column starts at zero and will be automatically incremented for each update on
/// the row. This option can only be applied to <see cref="JET_coltyp.Long"/> columns. This option cannot
/// be used with <see cref="ColumnAutoincrement"/>, <see cref="ColumnEscrowUpdate"/>, or <see cref="ColumnTagged"/>.
/// </summary>
ColumnVersion = 0x8,
/// <summary>
/// The column will automatically be incremented. The number is an increasing number, and
/// is guaranteed to be unique within a table. The numbers, however, might not be continuous.
/// For example, if five rows are inserted into a table, the "autoincrement" column could
/// contain the values { 1, 2, 6, 7, 8 }. This bit can only be used on columns of type
/// <see cref="JET_coltyp.Long"/> or <see cref="JET_coltyp.Currency"/>.
/// </summary>
ColumnAutoincrement = 0x10,
/// <summary>
/// The column can be updated. This is NOT a valid grbit to set on input to any API. It is
/// returned as part of the <see cref="JET_COLUMNDEF"/> structure's grbit member, as an
/// output from Api.JetGetColumnInfo.
/// </summary>
ColumnUpdatable = 0x20,
/// <summary>
/// The column can be multi-valued.
/// A multi-valued column can have zero, one, or more values
/// associated with it. The various values in a multi-valued column are identified by a number
/// called the itagSequence member, which belongs to various structures, including:
/// <see cref="JET_RETINFO"/>, <see cref="JET_SETINFO"/>, <see cref="JET_SETCOLUMN"/>, <see cref="JET_RETRIEVECOLUMN"/>, and <see cref="JET_ENUMCOLUMNVALUE"/>.
/// Multi-valued columns must be tagged columns; that is, they cannot be fixed-length or
/// variable-length columns.
/// </summary>
ColumnMultiValued = 0x400,
/// <summary>
/// Specifies that a column is an escrow update column. An escrow update column can be
/// updated concurrently by different sessions with JetEscrowUpdate and will maintain
/// transactional consistency. An escrow update column must also meet the following conditions:
/// An escrow update column can be created only when the table is empty.
/// An escrow update column must be of type JET_coltypLong.
/// An escrow update column must have a default value.
/// ColumnEscrowUpdate cannot be used in conjunction with <see cref="ColumnTagged"/>,
/// <see cref="ColumnVersion"/>, or <see cref="ColumnAutoincrement"/>.
/// </summary>
ColumnEscrowUpdate = 0x800,
/// <summary>
/// The column will be created in an without version information. This means that other
/// transactions that attempt to add a column with the same name will fail. This bit
/// is only useful with JetAddColumn. It cannot be used within a transaction.
/// </summary>
ColumnUnversioned = 0x1000,
/// <summary>
/// In doing an outer join, the retrieve column operation might not have a match
/// from the inner table.
/// </summary>
ColumnMaybeNull = 0x2000,
/// <summary>
/// When the escrow-update column reaches a value of zero, the callback function will be invoked.
/// </summary>
ColumnFinalize = 0x4000,
/// <summary>
/// The default value for a column will be provided by a callback function. A column that
/// has a user-defined default must be a tagged column. Specifying <see cref="ColumnUserDefinedDefault"/>
/// means that pvDefault must point to a JET_USERDEFINEDDEFAULT structure, and cbDefault must be
/// set to sizeof( JET_USERDEFINEDDEFAULT ).
/// </summary>
ColumnUserDefinedDefault = 0x8000,
/// <summary>
/// The column will be a key column for the temporary table. The order
/// of the column definitions with this option specified in the input
/// array will determine the precedence of each key column for the
/// temporary table. The first column definition in the array that
/// has this option set will be the most significant key column and
/// so on. If more key columns are requested than can be supported
/// by the database engine then this option is ignored for the
/// unsupportable key columns.
/// </summary>
TTKey = 0x40,
/// <summary>
/// The sort order of the key column for the temporary table should
/// be descending rather than ascending. If this option is specified
/// without <see cref="TTKey"/> then this option is ignored.
/// </summary>
TTDescending = 0x80,
}
/// <summary>
/// Options for the <see cref="JET_TABLECREATE"/> parameter used by
/// <see cref="Api.JetCreateTableColumnIndex3"/>.
/// </summary>
/// <seealso cref="Windows10.Windows10Grbits.TableCreateImmutableStructure"/>
[Flags]
public enum CreateTableColumnIndexGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0x0,
/// <summary>
/// The DDL is fixed.
/// </summary>
FixedDDL = 0x1,
/// <summary>
/// The DDL is inheritable. Implies FixedDDL.
/// </summary>
TemplateTable = 0x2,
/// <summary>
/// Used in conjunction with TemplateTable.
/// </summary>
NoFixedVarColumnsInDerivedTables = 0x4,
}
/// <summary>
/// Options for <see cref="Api.JetCreateIndex"/> and <see cref="JET_INDEXCREATE"/>.
/// </summary>
/// <seealso cref="Vista.VistaGrbits.IndexCrossProduct"/>
/// <seealso cref="Vista.VistaGrbits.IndexDisallowTruncation"/>
/// <seealso cref="Vista.VistaGrbits.IndexNestedTable"/>
/// <seealso cref="Vista.VistaGrbits.IndexUnicode"/>
/// <seealso cref="Vista.VistaGrbits.IndexKeyMost"/>
/// <seealso cref="Windows8.Windows8Grbits.IndexDotNetGuid"/>
/// <seealso cref="Windows10.Windows10Grbits.IndexCreateImmutableStructure"/>
[Flags]
public enum CreateIndexGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0x0,
/// <summary>
/// Duplicate index entries (keys) are disallowed. This is enforced when JetUpdate is called,
/// not when JetSetColumn is called.
/// </summary>
IndexUnique = 0x1,
/// <summary>
/// The index is a primary (clustered) index. Every table must have exactly one primary index.
/// If no primary index is explicitly defined over a table, then the database engine will
/// create its own primary index.
/// </summary>
IndexPrimary = 0x2,
/// <summary>
/// None of the columns over which the index is created may contain a NULL value.
/// </summary>
IndexDisallowNull = 0x4,
/// <summary>
/// Do not add an index entry for a row if all of the columns being indexed are NULL.
/// </summary>
IndexIgnoreNull = 0x8,
/// <summary>
/// Do not add an index entry for a row if any of the columns being indexed are NULL.
/// </summary>
IndexIgnoreAnyNull = 0x20,
/// <summary>
/// Do not add an index entry for a row if the first column being indexed is NULL.
/// </summary>
IndexIgnoreFirstNull = 0x40,
/// <summary>
/// Specifies that the index operations will be logged lazily. JET_bitIndexLazyFlush does not
/// affect the laziness of data updates. If the indexing operations is interrupted by process
/// termination, Soft Recovery will still be able to able to get the database to a consistent
/// state, but the index may not be present.
/// </summary>
IndexLazyFlush = 0x80,
/// <summary>
/// Do not attempt to build the index, because all entries would evaluate to NULL. grbit MUST
/// also specify JET_bitIgnoreAnyNull when JET_bitIndexEmpty is passed. This is a performance
/// enhancement. For example if a new column is added to a table, then an index is created over
/// this newly added column, all of the records in the table would be scanned even though they
/// would never get added to the index anyway. Specifying JET_bitIndexEmpty skips the scanning
/// of the table, which could potentially take a long time.
/// </summary>
IndexEmpty = 0x100,
/// <summary>
/// Causes index creation to be visible to other transactions. Normally a session in a
/// transaction will not be able to see an index creation operation in another session. This
/// flag can be useful if another transaction is likely to create the same index, so that the
/// second index-create will simply fail instead of potentially causing many unnecessary database
/// operations. The second transaction may not be able to use the index immediately. The index
/// creation operation needs to complete before it is usable. The session must not currently be in
/// a transaction to create an index without version information.
/// </summary>
IndexUnversioned = 0x200,
/// <summary>
/// Specifying this flag causes NULL values to be sorted after data for all columns in the index.
/// </summary>
IndexSortNullsHigh = 0x400,
}
/// <summary>
/// Key definition grbits. Used when retrieving information about an index, contained
/// in the column specified in <see cref="JET_INDEXLIST.columnidgrbitColumn"/>.
/// </summary>
[Flags]
public enum IndexKeyGrbit
{
/// <summary>
/// Key segment is ascending.
/// </summary>
Ascending = 0x0,
/// <summary>
/// Key segment is descending.
/// </summary>
Descending = 0x1,
}
/// <summary>
/// Options for the <seealso cref="JET_CONDITIONALCOLUMN"/> structure.
/// </summary>
[Flags]
public enum ConditionalColumnGrbit
{
/// <summary>
/// The column must be null for an index entry to appear in the index.
/// </summary>
ColumnMustBeNull = 0x1,
/// <summary>
/// The column must be non-null for an index entry to appear in the index.
/// </summary>
ColumnMustBeNonNull = 0x2,
}
/// <summary>
/// Options for temporary table creation, with <see cref="Api.JetOpenTempTable"/>,
/// Api.JetOpenTempTable2, and <see cref="Api.JetOpenTempTable3"/>.
/// </summary>
/// <seealso cref="Server2003.Server2003Grbits.ForwardOnly"/>
/// <seealso cref="Windows7.Windows7Grbits.IntrinsicLVsOnly"/>
/// <seealso cref="Windows8.Windows8Grbits.TTDotNetGuid"/>
[Flags]
public enum TempTableGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// This option requests that the temporary table be flexible enough to
/// permit the use of JetSeek to lookup records by index key. If this
/// functionality it not required then it is best to not request it. If this
/// functionality is not requested then the temporary table manager may be
/// able to choose a strategy for managing the temporary table that will
/// result in improved performance.
/// </summary>
Indexed = 0x1,
/// <summary>
/// This option requests that records with duplicate index keys be removed
/// from the final set of records in the temporary table.
/// Prior to Windows Server 2003, the database engine always assumed this
/// option to be in effect due to the fact that all clustered indexes must
/// also be a primary key and thus must be unique. As of Windows Server
/// 2003, it is now possible to create a temporary table that does NOT
/// remove duplicates when the <see cref="Server2003.Server2003Grbits.ForwardOnly"/>
/// option is also specified.
/// It is not possible to know which duplicate will win and which duplicates
/// will be discarded in general. However, when the
/// <see cref="ErrorOnDuplicateInsertion"/> option is requested then the first
/// record with a given index key to be inserted into the temporary table
/// will always win.
/// </summary>
Unique = 0x2,
/// <summary>
/// This option requests that the temporary table be flexible enough to
/// allow records that have previously been inserted to be subsequently
/// changed. If this functionality it not required then it is best to not
/// request it. If this functionality is not requested then the temporary
/// table manager may be able to choose a strategy for managing the
/// temporary table that will result in improved performance.
/// </summary>
Updatable = 0x4,
/// <summary>
/// This option requests that the temporary table be flexible enough to
/// allow records to be scanned in arbitrary order and direction using
/// <see cref="Api.JetMove(JET_SESID,JET_TABLEID,int,MoveGrbit)"/>.
/// If this functionality it not required then it is best to not
/// request it. If this functionality is not requested then the temporary
/// table manager may be able to choose a strategy for managing the
/// temporary table that will result in improved performance.
/// </summary>
Scrollable = 0x8,
/// <summary>
/// This option requests that NULL key column values sort closer
/// to the end of the index than non-NULL key column values.
/// </summary>
SortNullsHigh = 0x10,
/// <summary>
/// This option forces the temporary table manager to abandon
/// any attempt to choose a clever strategy for managing the
/// temporary table that will result in enhanced performance.
/// </summary>
ForceMaterialization = 0x20,
/// <summary>
/// This option requests that any attempt to insert a record with the same
/// index key as a previously inserted record will immediately fail with
/// <see cref="JET_err.KeyDuplicate"/>. If this option is not requested then a duplicate
/// may be detected immediately and fail or may be silently removed later
/// depending on the strategy chosen by the database engine to implement the
/// temporary table based on the requested functionality. If this
/// functionality it not required then it is best to not request it. If this
/// functionality is not requested then the temporary table manager may be
/// able to choose a strategy for managing the temporary table that will
/// result in improved performance.
/// </summary>
ErrorOnDuplicateInsertion = 0x20,
}
/// <summary>
/// Options for <see cref="Api.JetDeleteColumn2"/>.
/// </summary>
[Flags]
public enum DeleteColumnGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
/// <summary>
/// The API should only attempt to delete columns in the derived table.
/// If a column of that name exists in the base table it will be ignored.
/// </summary>
IgnoreTemplateColumns = 0x1,
}
/// <summary>
/// Options for <see cref="Api.JetRenameColumn"/>.
/// </summary>
[Flags]
public enum RenameColumnGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
}
#if !MANAGEDESENT_ON_WSA // Not exposed in MSDK
/// <summary>
/// Options for <see cref="Api.JetSetColumnDefaultValue"/>.
/// </summary>
[Flags]
public enum SetColumnDefaultValueGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0,
}
/// <summary>
/// Options for <see cref="Api.JetIdle"/>.
/// </summary>
[Flags]
public enum IdleGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0x0,
/// <summary>
/// Reserved for future use. If this flag is specified, the API will return <see cref="JET_err.InvalidGrbit"/>.
/// </summary>
FlushBuffers = 0x01,
/// <summary>Triggers cleanup of the version store.</summary>
Compact = 0x02,
/// <summary>
/// Returns <see cref="JET_wrn.IdleFull"/> if version store is more than half full.
/// </summary>
GetStatus = 0x04,
}
#endif // !MANAGEDESENT_ON_WSA
/// <summary>
/// Options for <see cref="Api.JetDefragment"/>.
/// </summary>
/// <seealso cref="Windows7.Windows7Grbits.NoPartialMerges"/>
/// <seealso cref="Windows7.Windows7Grbits.DefragmentBTree"/>
[Flags]
public enum DefragGrbit
{
/// <summary>
/// Defragments the available space portion of ESE database space
/// allocation. Database space is divided into two types, owned
/// space and available space. Owned space is allocated to a table
/// or index while available space is ready for use within the table
/// or index, respectively. Available space is much more dynamic in
/// behavior and requires on-line defragmentation more so than owned
/// space or table or index data.
/// </summary>
AvailSpaceTreesOnly = 0x40,
/// <summary>
/// Starts a new defragmentation task.
/// </summary>
BatchStart = 0x1,
/// <summary>
/// Stops a defragmentation task.
/// </summary>
BatchStop = 0x2,
}
/// <summary>
/// Grbits for the various Api.JetGetColumnInfo and Api.JetGetTableColumnInfo
/// overloads.
/// </summary>
/// <remarks>
/// Internally this value is OR'ed together with the
/// <see cref="JET_ColInfo"/> info level. The info level is not publically exposed
/// in this CLR code because it's only used to differentiate the type of the output
/// parameter, which is covered by having explicit function overloads with different
/// signatures. There is no need to expose JET_ColInfo to CLR.
/// </remarks>
[Flags]
public enum ColInfoGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0x0,
/// <summary>
/// For lists (example: <see cref="JET_ColInfo.List"/>), only return
/// non-derived columns (if the table is derived from a template).
/// </summary>
/// <remarks>This value is 0x80000000.</remarks>
NonDerivedColumnsOnly = int.MinValue,
/// <summary>
/// For lists (example: <see cref="JET_ColInfo.List"/>), only return
/// the column name and columnid of each column.
/// </summary>
MinimalInfo = 0x40000000,
/// <summary>
/// For lists (example: <see cref="JET_ColInfo.List"/>), sort
/// returned column list by columnid (the default is to sort list by column name).
/// </summary>
SortByColumnid = 0x20000000,
}
/// <summary>
/// Options for <see cref="JET_SPACEHINTS"/>.
/// </summary>
[Flags]
public enum SpaceHintsGrbit
{
/// <summary>
/// Default options.
/// </summary>
None = 0x0,
// Generic bits.
/// <summary>
/// This changes the internal allocation policy to get space hierarchically
/// from a B-Tree's immediate parent.
/// </summary>
SpaceHintUtilizeParentSpace = 0x00000001,
// Create bits.
/// <summary>
/// This bit will enable Append split behavior to grow according to the
/// growth dynamics of the table (set by cbMinExtent, ulGrowth, cbMaxExtent).
/// </summary>
CreateHintAppendSequential = 0x00000002,
/// <summary>
/// This bit will enable Hotpoint split behavior to grow according to the
/// growth dynamics of the table (set by cbMinExtent, ulGrowth, cbMaxExtent).
/// </summary>
CreateHintHotpointSequential = 0x00000004,
// Retrieve bits.
/// <summary>
/// Reserved and ignored.
/// </summary>
RetrieveHintReserve1 = 0x00000008,
/// <summary>
/// By setting this the client indicates that forward sequential scan is
/// the predominant usage pattern of this table (causing B+ Tree defrag to
/// be auto-triggered to clean it up if fragmented).
/// </summary>
RetrieveHintTableScanForward = 0x00000010,
/// <summary>
/// By setting this the client indicates that backwards sequential scan
/// is the predominant usage pattern of this table(causing B+ Tree defrag to
/// be auto-triggered to clean it up if fragmented).
/// </summary>
RetrieveHintTableScanBackward = 0x00000020,
/// <summary>
/// Reserved and ignored.
/// </summary>
RetrieveHintReserve2 = 0x00000040,
/// <summary>
/// Reserved and ignored.
/// </summary>
RetrieveHintReserve3 = 0x00000080,
// Delete bits.
/// <summary>
/// The application expects this table to be cleaned up in-order
/// sequentially (from lowest key to highest key).
/// </summary>
DeleteHintTableSequential = 0x00000100,
}
}
Reference in New Issue View Git Blame Copy Permalink