//----------------------------------------------------------------------- // // Copyright (c) Microsoft Corporation. // //----------------------------------------------------------------------- namespace Microsoft.Isam.Esent.Interop.Windows8 { using System; using Microsoft.Isam.Esent.Interop.Vista; using Win81 = Microsoft.Isam.Esent.Interop.Windows81; /// /// Api calls introduced in Windows 8. /// public static class Windows8Api { #region Init / Term /// /// Prepares an instance for termination. Can also be used to resume a previous quiescing. /// /// The (running) instance to use. /// The options to stop or resume the instance. public static void JetStopServiceInstance2( JET_INSTANCE instance, StopServiceGrbit grbit) { Api.Check(Api.Impl.JetStopServiceInstance2(instance, grbit)); } #endregion #region Transactions /// /// Causes a session to enter a transaction or create a new save point in an existing /// transaction. /// /// The session to begin the transaction for. /// An optional identifier supplied by the user for identifying the transaction. /// Transaction options. /// Introduced in Windows 8. public static void JetBeginTransaction3(JET_SESID sesid, long userTransactionId, BeginTransactionGrbit grbit) { Api.Check(Api.Impl.JetBeginTransaction3(sesid, userTransactionId, grbit)); } /// /// Commits the changes made to the state of the database during the current save point /// and migrates them to the previous save point. If the outermost save point is committed /// then the changes made during that save point will be committed to the state of the /// database and the session will exit the transaction. /// /// The session to commit the transaction for. /// Commit options. /// Duration to commit lazy transaction. /// Commit-id associated with this commit record. public static void JetCommitTransaction2( JET_SESID sesid, CommitTransactionGrbit grbit, TimeSpan durableCommit, out JET_COMMIT_ID commitId) { Api.Check(Api.Impl.JetCommitTransaction2(sesid, grbit, durableCommit, out commitId)); } #endregion /// /// Gets extended information about an error. /// /// The error code about which to retrieve information. /// Information about the specified error code. public static void JetGetErrorInfo( JET_err error, out JET_ERRINFOBASIC errinfo) { Api.Check(Api.Impl.JetGetErrorInfo(error, out errinfo)); } /// /// Resizes a currently open database. Windows 8: Only supports growing a database file. /// Windows 8.1: When is set to /// , and if the /// file system supports Sparse Files, then space may be freed up in the middle of the /// file. /// /// /// Many APIs return the logical size of the file, not how many bytes it takes up on disk. /// Win32's GetCompressedFileSize returns the correct on-disk size. /// /// returns the on-disk size when used with /// /// /// The session to use. /// The database to grow. /// The desired size of the database, in pages. /// The size of the database, in pages, after the call. /// Resize options. public static void JetResizeDatabase( JET_SESID sesid, JET_DBID dbid, int desiredPages, out int actualPages, ResizeDatabaseGrbit grbit) { Api.Check(Api.Impl.JetResizeDatabase(sesid, dbid, desiredPages, out actualPages, grbit)); } #region DDL /// /// Creates indexes over data in an ESE database. /// /// /// When creating multiple indexes (i.e. with numIndexCreates /// greater than 1) this method MUST be called /// outside of any transactions and with exclusive access to the /// table. The JET_TABLEID returned by "Api.JetCreateTable" /// will have exlusive access or the table can be opened for /// exclusive access by passing /// to . /// /// The session to use. /// The table to create the index on. /// Array of objects describing the indexes to be created. /// Number of index description objects. public static void JetCreateIndex4( JET_SESID sesid, JET_TABLEID tableid, JET_INDEXCREATE[] indexcreates, int numIndexCreates) { Api.Check(Api.Impl.JetCreateIndex4(sesid, tableid, indexcreates, numIndexCreates)); } /// /// Creates a temporary table with a single index. A temporary table /// stores and retrieves records just like an ordinary table created /// using JetCreateTableColumnIndex. However, temporary tables are /// much faster than ordinary tables due to their volatile nature. /// They can also be used to very quickly sort and perform duplicate /// removal on record sets when accessed in a purely sequential manner. /// Also see /// , /// "Api.JetOpenTempTable2", /// . /// . /// /// /// Use /// for earlier versions of Esent. /// /// The session to use. /// /// Description of the temporary table to create on input. After a /// successful call, the structure contains the handle to the temporary /// table and column identifications. Use /// to free the temporary table when finished. /// public static void JetOpenTemporaryTable2(JET_SESID sesid, JET_OPENTEMPORARYTABLE temporarytable) { Api.Check(Api.Impl.JetOpenTemporaryTable2(sesid, temporarytable)); } /// /// Creates a table, adds columns, and indices on that table. /// /// /// The session to use. /// The database to which to add the new table. /// Object describing the table to create. /// public static void JetCreateTableColumnIndex4( JET_SESID sesid, JET_DBID dbid, JET_TABLECREATE tablecreate) { Api.Check(Api.Impl.JetCreateTableColumnIndex4(sesid, dbid, tablecreate)); } #endregion #region Session Parameters /// /// Gets a parameter on the provided session state, used for the lifetime of this session or until reset. /// /// The session to set the parameter on. /// The ID of the session parameter to set, see /// and . /// A 32-bit integer to retrieve. public static void JetGetSessionParameter( JET_SESID sesid, JET_sesparam sesparamid, out int value) { Api.Check(Api.Impl.JetGetSessionParameter(sesid, sesparamid, out value)); } /// /// Gets a parameter on the provided session state, used for the lifetime of this session or until reset. /// /// The session to set the parameter on. /// The ID of the session parameter to set, see /// and . /// A byte array to retrieve. /// AThe length of the data array. /// The actual size of the data field. public static void JetGetSessionParameter( JET_SESID sesid, JET_sesparam sesparamid, byte[] data, int length, out int actualDataSize) { Api.Check(Api.Impl.JetGetSessionParameter(sesid, sesparamid, data, length, out actualDataSize)); } /// /// Sets a parameter on the provided session state, used for the lifetime of this session or until reset. /// /// The session to set the parameter on. /// The ID of the session parameter to set. /// A 32-bit integer to set. public static void JetSetSessionParameter(JET_SESID sesid, JET_sesparam sesparamid, int value) { Api.Check(Api.Impl.JetSetSessionParameter(sesid, sesparamid, value)); } /// /// Sets a parameter on the provided session state, used for the lifetime of this session or until reset. /// /// The session to set the parameter on. /// The ID of the session parameter to set. /// Data to set in this session parameter. /// Size of the data provided. public static void JetSetSessionParameter( JET_SESID sesid, JET_sesparam sesparamid, byte[] data, int dataSize) { Api.Check(Api.Impl.JetSetSessionParameter(sesid, sesparamid, data, dataSize)); } #endregion #region Misc /// /// If the records with the specified key ranges are not in the buffer /// cache, then start asynchronous reads to bring the records into the /// database buffer cache. /// /// The session to use. /// The table to issue the prereads against. /// The key ranges to preread. /// The index of the first key range in the array to read. /// The maximum number of key ranges to preread. /// Returns the number of keys actually preread. /// List of column ids for long value columns to preread. /// Preread options. Used to specify the direction of the preread. /// true if some preread done, false otherwise. public static bool JetTryPrereadIndexRanges( JET_SESID sesid, JET_TABLEID tableid, JET_INDEX_RANGE[] indexRanges, int rangeIndex, int rangeCount, out int rangesPreread, JET_COLUMNID[] columnsPreread, PrereadIndexRangesGrbit grbit) { JET_err err = (JET_err)Api.Impl.JetPrereadIndexRanges(sesid, tableid, indexRanges, rangeIndex, rangeCount, out rangesPreread, columnsPreread, grbit); return err >= JET_err.Success; } /// /// If the records with the specified key ranges are not in the buffer /// cache, then start asynchronous reads to bring the records into the /// database buffer cache. /// /// The session to use. /// The table to issue the prereads against. /// The key ranges to preread. /// The index of the first key range in the array to read. /// The maximum number of key ranges to preread. /// Returns the number of keys actually preread. /// List of column ids for long value columns to preread. /// Preread options. Used to specify the direction of the preread. public static void JetPrereadIndexRanges( JET_SESID sesid, JET_TABLEID tableid, JET_INDEX_RANGE[] indexRanges, int rangeIndex, int rangeCount, out int rangesPreread, JET_COLUMNID[] columnsPreread, PrereadIndexRangesGrbit grbit) { Api.Check(Api.Impl.JetPrereadIndexRanges(sesid, tableid, indexRanges, rangeIndex, rangeCount, out rangesPreread, columnsPreread, grbit)); } /// /// If the records with the specified key ranges are not in the /// buffer cache then start asynchronous reads to bring the records /// into the database buffer cache. /// /// The session to use. /// The table to issue the prereads against. /// The start of key ranges to preread. /// The lengths of the start keys to preread. /// The end of key rangess to preread. /// The lengths of the end keys to preread. /// The index of the first key range in the array to read. /// The maximum number of key ranges to preread. /// Returns the number of keys actually preread. /// List of column ids for long value columns to preread. /// Preread options. Used to specify the direction of the preread. public static void PrereadKeyRanges( JET_SESID sesid, JET_TABLEID tableid, byte[][] keysStart, int[] keyStartLengths, byte[][] keysEnd, int[] keyEndLengths, int rangeIndex, int rangeCount, out int rangesPreread, JET_COLUMNID[] columnsPreread, PrereadIndexRangesGrbit grbit) { Api.Check(Api.Impl.JetPrereadKeyRanges(sesid, tableid, keysStart, keyStartLengths, keysEnd, keyEndLengths, rangeIndex, rangeCount, out rangesPreread, columnsPreread, grbit)); } /// /// Set an array of simple filters for . /// /// The session to use for the call. /// The cursor to position. /// Simple record filters. /// Move options. public static void JetSetCursorFilter(JET_SESID sesid, JET_TABLEID tableid, JET_INDEX_COLUMN[] filters, CursorFilterGrbit grbit) { Api.Check(Api.Impl.JetSetCursorFilter(sesid, tableid, filters, grbit)); } #endregion } }