vendor/windows-sys-0.28.0/src/Windows/Win32/Storage/Jet/mod.rs

   1 #![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, clashing_extern_declarations, clippy::all)]
   2 #[link(name = "windows")]
   3 extern "system" {
   4     #[cfg(feature = "Win32_Storage_StructuredStorage")]
   5     pub fn JetAddColumnA(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szcolumnname: *const i8, pcolumndef: *const JET_COLUMNDEF, pvdefault: *const ::core::ffi::c_void, cbdefault: u32, pcolumnid: *mut u32) -> i32;
   6     #[cfg(feature = "Win32_Storage_StructuredStorage")]
   7     pub fn JetAddColumnW(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szcolumnname: *const u16, pcolumndef: *const JET_COLUMNDEF, pvdefault: *const ::core::ffi::c_void, cbdefault: u32, pcolumnid: *mut u32) -> i32;
   8     #[cfg(feature = "Win32_Storage_StructuredStorage")]
   9     pub fn JetAttachDatabase2A(sesid: super::StructuredStorage::JET_SESID, szfilename: *const i8, cpgdatabasesizemax: u32, grbit: u32) -> i32;
  10     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  11     pub fn JetAttachDatabase2W(sesid: super::StructuredStorage::JET_SESID, szfilename: *const u16, cpgdatabasesizemax: u32, grbit: u32) -> i32;
  12     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  13     pub fn JetAttachDatabaseA(sesid: super::StructuredStorage::JET_SESID, szfilename: *const i8, grbit: u32) -> i32;
  14     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  15     pub fn JetAttachDatabaseW(sesid: super::StructuredStorage::JET_SESID, szfilename: *const u16, grbit: u32) -> i32;
  16     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  17     pub fn JetBackupA(szbackuppath: *const i8, grbit: u32, pfnstatus: ::core::option::Option<JET_PFNSTATUS>) -> i32;
  18     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  19     pub fn JetBackupInstanceA(instance: super::StructuredStorage::JET_INSTANCE, szbackuppath: *const i8, grbit: u32, pfnstatus: ::core::option::Option<JET_PFNSTATUS>) -> i32;
  20     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  21     pub fn JetBackupInstanceW(instance: super::StructuredStorage::JET_INSTANCE, szbackuppath: *const u16, grbit: u32, pfnstatus: ::core::option::Option<JET_PFNSTATUS>) -> i32;
  22     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  23     pub fn JetBackupW(szbackuppath: *const u16, grbit: u32, pfnstatus: ::core::option::Option<JET_PFNSTATUS>) -> i32;
  24     pub fn JetBeginExternalBackup(grbit: u32) -> i32;
  25     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  26     pub fn JetBeginExternalBackupInstance(instance: super::StructuredStorage::JET_INSTANCE, grbit: u32) -> i32;
  27     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  28     pub fn JetBeginSessionA(instance: super::StructuredStorage::JET_INSTANCE, psesid: *mut super::StructuredStorage::JET_SESID, szusername: *const i8, szpassword: *const i8) -> i32;
  29     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  30     pub fn JetBeginSessionW(instance: super::StructuredStorage::JET_INSTANCE, psesid: *mut super::StructuredStorage::JET_SESID, szusername: *const u16, szpassword: *const u16) -> i32;
  31     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  32     pub fn JetBeginTransaction(sesid: super::StructuredStorage::JET_SESID) -> i32;
  33     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  34     pub fn JetBeginTransaction2(sesid: super::StructuredStorage::JET_SESID, grbit: u32) -> i32;
  35     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  36     pub fn JetBeginTransaction3(sesid: super::StructuredStorage::JET_SESID, trxid: i64, grbit: u32) -> i32;
  37     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  38     pub fn JetCloseDatabase(sesid: super::StructuredStorage::JET_SESID, dbid: u32, grbit: u32) -> i32;
  39     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  40     pub fn JetCloseFile(hffile: super::StructuredStorage::JET_HANDLE) -> i32;
  41     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  42     pub fn JetCloseFileInstance(instance: super::StructuredStorage::JET_INSTANCE, hffile: super::StructuredStorage::JET_HANDLE) -> i32;
  43     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  44     pub fn JetCloseTable(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID) -> i32;
  45     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  46     pub fn JetCommitTransaction(sesid: super::StructuredStorage::JET_SESID, grbit: u32) -> i32;
  47     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  48     pub fn JetCommitTransaction2(sesid: super::StructuredStorage::JET_SESID, grbit: u32, cmsecdurablecommit: u32, pcommitid: *mut JET_COMMIT_ID) -> i32;
  49     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  50     pub fn JetCompactA(sesid: super::StructuredStorage::JET_SESID, szdatabasesrc: *const i8, szdatabasedest: *const i8, pfnstatus: ::core::option::Option<JET_PFNSTATUS>, pconvert: *const CONVERT_A, grbit: u32) -> i32;
  51     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  52     pub fn JetCompactW(sesid: super::StructuredStorage::JET_SESID, szdatabasesrc: *const u16, szdatabasedest: *const u16, pfnstatus: ::core::option::Option<JET_PFNSTATUS>, pconvert: *const CONVERT_W, grbit: u32) -> i32;
  53     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  54     pub fn JetComputeStats(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID) -> i32;
  55     pub fn JetConfigureProcessForCrashDump(grbit: u32) -> i32;
  56     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  57     pub fn JetCreateDatabase2A(sesid: super::StructuredStorage::JET_SESID, szfilename: *const i8, cpgdatabasesizemax: u32, pdbid: *mut u32, grbit: u32) -> i32;
  58     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  59     pub fn JetCreateDatabase2W(sesid: super::StructuredStorage::JET_SESID, szfilename: *const u16, cpgdatabasesizemax: u32, pdbid: *mut u32, grbit: u32) -> i32;
  60     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  61     pub fn JetCreateDatabaseA(sesid: super::StructuredStorage::JET_SESID, szfilename: *const i8, szconnect: *const i8, pdbid: *mut u32, grbit: u32) -> i32;
  62     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  63     pub fn JetCreateDatabaseW(sesid: super::StructuredStorage::JET_SESID, szfilename: *const u16, szconnect: *const u16, pdbid: *mut u32, grbit: u32) -> i32;
  64     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  65     pub fn JetCreateIndex2A(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pindexcreate: *const JET_INDEXCREATE_A, cindexcreate: u32) -> i32;
  66     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  67     pub fn JetCreateIndex2W(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pindexcreate: *const JET_INDEXCREATE_W, cindexcreate: u32) -> i32;
  68     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  69     pub fn JetCreateIndex3A(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pindexcreate: *const JET_INDEXCREATE2_A, cindexcreate: u32) -> i32;
  70     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  71     pub fn JetCreateIndex3W(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pindexcreate: *const JET_INDEXCREATE2_W, cindexcreate: u32) -> i32;
  72     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  73     pub fn JetCreateIndex4A(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pindexcreate: *const JET_INDEXCREATE3_A, cindexcreate: u32) -> i32;
  74     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  75     pub fn JetCreateIndex4W(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pindexcreate: *const JET_INDEXCREATE3_W, cindexcreate: u32) -> i32;
  76     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  77     pub fn JetCreateIndexA(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const i8, grbit: u32, szkey: super::super::Foundation::PSTR, cbkey: u32, ldensity: u32) -> i32;
  78     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  79     pub fn JetCreateIndexW(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const u16, grbit: u32, szkey: super::super::Foundation::PWSTR, cbkey: u32, ldensity: u32) -> i32;
  80     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  81     pub fn JetCreateInstance2A(pinstance: *mut super::StructuredStorage::JET_INSTANCE, szinstancename: *const i8, szdisplayname: *const i8, grbit: u32) -> i32;
  82     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  83     pub fn JetCreateInstance2W(pinstance: *mut super::StructuredStorage::JET_INSTANCE, szinstancename: *const u16, szdisplayname: *const u16, grbit: u32) -> i32;
  84     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  85     pub fn JetCreateInstanceA(pinstance: *mut super::StructuredStorage::JET_INSTANCE, szinstancename: *const i8) -> i32;
  86     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  87     pub fn JetCreateInstanceW(pinstance: *mut super::StructuredStorage::JET_INSTANCE, szinstancename: *const u16) -> i32;
  88     #[cfg(feature = "Win32_Storage_StructuredStorage")]
  89     pub fn JetCreateTableA(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const i8, lpages: u32, ldensity: u32, ptableid: *mut super::StructuredStorage::JET_TABLEID) -> i32;
  90     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  91     pub fn JetCreateTableColumnIndex2A(sesid: super::StructuredStorage::JET_SESID, dbid: u32, ptablecreate: *mut JET_TABLECREATE2_A) -> i32;
  92     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  93     pub fn JetCreateTableColumnIndex2W(sesid: super::StructuredStorage::JET_SESID, dbid: u32, ptablecreate: *mut JET_TABLECREATE2_W) -> i32;
  94     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  95     pub fn JetCreateTableColumnIndex3A(sesid: super::StructuredStorage::JET_SESID, dbid: u32, ptablecreate: *mut JET_TABLECREATE3_A) -> i32;
  96     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  97     pub fn JetCreateTableColumnIndex3W(sesid: super::StructuredStorage::JET_SESID, dbid: u32, ptablecreate: *mut JET_TABLECREATE3_W) -> i32;
  98     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
  99     pub fn JetCreateTableColumnIndex4A(sesid: super::StructuredStorage::JET_SESID, dbid: u32, ptablecreate: *mut JET_TABLECREATE4_A) -> i32;
 100     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 101     pub fn JetCreateTableColumnIndex4W(sesid: super::StructuredStorage::JET_SESID, dbid: u32, ptablecreate: *mut JET_TABLECREATE4_W) -> i32;
 102     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 103     pub fn JetCreateTableColumnIndexA(sesid: super::StructuredStorage::JET_SESID, dbid: u32, ptablecreate: *mut JET_TABLECREATE_A) -> i32;
 104     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 105     pub fn JetCreateTableColumnIndexW(sesid: super::StructuredStorage::JET_SESID, dbid: u32, ptablecreate: *mut JET_TABLECREATE_W) -> i32;
 106     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 107     pub fn JetCreateTableW(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const u16, lpages: u32, ldensity: u32, ptableid: *mut super::StructuredStorage::JET_TABLEID) -> i32;
 108     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 109     pub fn JetDefragment2A(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const i8, pcpasses: *mut u32, pcseconds: *mut u32, callback: ::core::option::Option<JET_CALLBACK>, grbit: u32) -> i32;
 110     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 111     pub fn JetDefragment2W(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const u16, pcpasses: *mut u32, pcseconds: *mut u32, callback: ::core::option::Option<JET_CALLBACK>, grbit: u32) -> i32;
 112     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 113     pub fn JetDefragment3A(sesid: super::StructuredStorage::JET_SESID, szdatabasename: *const i8, sztablename: *const i8, pcpasses: *mut u32, pcseconds: *mut u32, callback: ::core::option::Option<JET_CALLBACK>, pvcontext: *const ::core::ffi::c_void, grbit: u32) -> i32;
 114     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 115     pub fn JetDefragment3W(sesid: super::StructuredStorage::JET_SESID, szdatabasename: *const u16, sztablename: *const u16, pcpasses: *mut u32, pcseconds: *mut u32, callback: ::core::option::Option<JET_CALLBACK>, pvcontext: *const ::core::ffi::c_void, grbit: u32) -> i32;
 116     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 117     pub fn JetDefragmentA(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const i8, pcpasses: *mut u32, pcseconds: *mut u32, grbit: u32) -> i32;
 118     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 119     pub fn JetDefragmentW(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const u16, pcpasses: *mut u32, pcseconds: *mut u32, grbit: u32) -> i32;
 120     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 121     pub fn JetDelete(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID) -> i32;
 122     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 123     pub fn JetDeleteColumn2A(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szcolumnname: *const i8, grbit: u32) -> i32;
 124     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 125     pub fn JetDeleteColumn2W(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szcolumnname: *const u16, grbit: u32) -> i32;
 126     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 127     pub fn JetDeleteColumnA(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szcolumnname: *const i8) -> i32;
 128     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 129     pub fn JetDeleteColumnW(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szcolumnname: *const u16) -> i32;
 130     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 131     pub fn JetDeleteIndexA(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const i8) -> i32;
 132     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 133     pub fn JetDeleteIndexW(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const u16) -> i32;
 134     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 135     pub fn JetDeleteTableA(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const i8) -> i32;
 136     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 137     pub fn JetDeleteTableW(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const u16) -> i32;
 138     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 139     pub fn JetDetachDatabase2A(sesid: super::StructuredStorage::JET_SESID, szfilename: *const i8, grbit: u32) -> i32;
 140     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 141     pub fn JetDetachDatabase2W(sesid: super::StructuredStorage::JET_SESID, szfilename: *const u16, grbit: u32) -> i32;
 142     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 143     pub fn JetDetachDatabaseA(sesid: super::StructuredStorage::JET_SESID, szfilename: *const i8) -> i32;
 144     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 145     pub fn JetDetachDatabaseW(sesid: super::StructuredStorage::JET_SESID, szfilename: *const u16) -> i32;
 146     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 147     pub fn JetDupCursor(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, ptableid: *mut super::StructuredStorage::JET_TABLEID, grbit: u32) -> i32;
 148     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 149     pub fn JetDupSession(sesid: super::StructuredStorage::JET_SESID, psesid: *mut super::StructuredStorage::JET_SESID) -> i32;
 150     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 151     pub fn JetEnableMultiInstanceA(psetsysparam: *const JET_SETSYSPARAM_A, csetsysparam: u32, pcsetsucceed: *mut u32) -> i32;
 152     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 153     pub fn JetEnableMultiInstanceW(psetsysparam: *const JET_SETSYSPARAM_W, csetsysparam: u32, pcsetsucceed: *mut u32) -> i32;
 154     pub fn JetEndExternalBackup() -> i32;
 155     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 156     pub fn JetEndExternalBackupInstance(instance: super::StructuredStorage::JET_INSTANCE) -> i32;
 157     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 158     pub fn JetEndExternalBackupInstance2(instance: super::StructuredStorage::JET_INSTANCE, grbit: u32) -> i32;
 159     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 160     pub fn JetEndSession(sesid: super::StructuredStorage::JET_SESID, grbit: u32) -> i32;
 161     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 162     pub fn JetEnumerateColumns(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, cenumcolumnid: u32, rgenumcolumnid: *const JET_ENUMCOLUMNID, pcenumcolumn: *mut u32, prgenumcolumn: *mut *mut JET_ENUMCOLUMN, pfnrealloc: ::core::option::Option<JET_PFNREALLOC>, pvrealloccontext: *const ::core::ffi::c_void, cbdatamost: u32, grbit: u32) -> i32;
 163     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 164     pub fn JetEscrowUpdate(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, columnid: u32, pv: *const ::core::ffi::c_void, cbmax: u32, pvold: *mut ::core::ffi::c_void, cboldmax: u32, pcboldactual: *mut u32, grbit: u32) -> i32;
 165     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 166     pub fn JetExternalRestore2A(szcheckpointfilepath: *const i8, szlogpath: *const i8, rgrstmap: *const JET_RSTMAP_A, crstfilemap: i32, szbackuplogpath: *const i8, ploginfo: *mut JET_LOGINFO_A, sztargetinstancename: *const i8, sztargetinstancelogpath: *const i8, sztargetinstancecheckpointpath: *const i8, pfn: ::core::option::Option<JET_PFNSTATUS>) -> i32;
 167     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 168     pub fn JetExternalRestore2W(szcheckpointfilepath: *const u16, szlogpath: *const u16, rgrstmap: *const JET_RSTMAP_W, crstfilemap: i32, szbackuplogpath: *const u16, ploginfo: *mut JET_LOGINFO_W, sztargetinstancename: *const u16, sztargetinstancelogpath: *const u16, sztargetinstancecheckpointpath: *const u16, pfn: ::core::option::Option<JET_PFNSTATUS>) -> i32;
 169     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 170     pub fn JetExternalRestoreA(szcheckpointfilepath: *const i8, szlogpath: *const i8, rgrstmap: *const JET_RSTMAP_A, crstfilemap: i32, szbackuplogpath: *const i8, genlow: i32, genhigh: i32, pfn: ::core::option::Option<JET_PFNSTATUS>) -> i32;
 171     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 172     pub fn JetExternalRestoreW(szcheckpointfilepath: *const u16, szlogpath: *const u16, rgrstmap: *const JET_RSTMAP_W, crstfilemap: i32, szbackuplogpath: *const u16, genlow: i32, genhigh: i32, pfn: ::core::option::Option<JET_PFNSTATUS>) -> i32;
 173     #[cfg(feature = "Win32_Foundation")]
 174     pub fn JetFreeBuffer(pbbuf: super::super::Foundation::PSTR) -> i32;
 175     pub fn JetGetAttachInfoA(szzdatabases: *mut i8, cbmax: u32, pcbactual: *mut u32) -> i32;
 176     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 177     pub fn JetGetAttachInfoInstanceA(instance: super::StructuredStorage::JET_INSTANCE, szzdatabases: *mut i8, cbmax: u32, pcbactual: *mut u32) -> i32;
 178     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 179     pub fn JetGetAttachInfoInstanceW(instance: super::StructuredStorage::JET_INSTANCE, szzdatabases: *mut u16, cbmax: u32, pcbactual: *mut u32) -> i32;
 180     pub fn JetGetAttachInfoW(wszzdatabases: *mut u16, cbmax: u32, pcbactual: *mut u32) -> i32;
 181     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 182     pub fn JetGetBookmark(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pvbookmark: *mut ::core::ffi::c_void, cbmax: u32, pcbactual: *mut u32) -> i32;
 183     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 184     pub fn JetGetColumnInfoA(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const i8, pcolumnnameorid: *const i8, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 185     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 186     pub fn JetGetColumnInfoW(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const u16, pwcolumnnameorid: *const u16, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 187     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 188     pub fn JetGetCurrentIndexA(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *mut i8, cbindexname: u32) -> i32;
 189     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 190     pub fn JetGetCurrentIndexW(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *mut u16, cbindexname: u32) -> i32;
 191     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 192     pub fn JetGetCursorInfo(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 193     pub fn JetGetDatabaseFileInfoA(szdatabasename: *const i8, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 194     pub fn JetGetDatabaseFileInfoW(szdatabasename: *const u16, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 195     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 196     pub fn JetGetDatabaseInfoA(sesid: super::StructuredStorage::JET_SESID, dbid: u32, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 197     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 198     pub fn JetGetDatabaseInfoW(sesid: super::StructuredStorage::JET_SESID, dbid: u32, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 199     pub fn JetGetErrorInfoW(pvcontext: *const ::core::ffi::c_void, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32, grbit: u32) -> i32;
 200     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 201     pub fn JetGetIndexInfoA(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const i8, szindexname: *const i8, pvresult: *mut ::core::ffi::c_void, cbresult: u32, infolevel: u32) -> i32;
 202     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 203     pub fn JetGetIndexInfoW(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const u16, szindexname: *const u16, pvresult: *mut ::core::ffi::c_void, cbresult: u32, infolevel: u32) -> i32;
 204     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 205     pub fn JetGetInstanceInfoA(pcinstanceinfo: *mut u32, painstanceinfo: *mut *mut JET_INSTANCE_INFO_A) -> i32;
 206     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 207     pub fn JetGetInstanceInfoW(pcinstanceinfo: *mut u32, painstanceinfo: *mut *mut JET_INSTANCE_INFO_W) -> i32;
 208     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 209     pub fn JetGetInstanceMiscInfo(instance: super::StructuredStorage::JET_INSTANCE, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 210     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 211     pub fn JetGetLS(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pls: *mut JET_LS, grbit: u32) -> i32;
 212     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 213     pub fn JetGetLock(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, grbit: u32) -> i32;
 214     pub fn JetGetLogInfoA(szzlogs: *mut i8, cbmax: u32, pcbactual: *mut u32) -> i32;
 215     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 216     pub fn JetGetLogInfoInstance2A(instance: super::StructuredStorage::JET_INSTANCE, szzlogs: *mut i8, cbmax: u32, pcbactual: *mut u32, ploginfo: *mut JET_LOGINFO_A) -> i32;
 217     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 218     pub fn JetGetLogInfoInstance2W(instance: super::StructuredStorage::JET_INSTANCE, wszzlogs: *mut u16, cbmax: u32, pcbactual: *mut u32, ploginfo: *mut JET_LOGINFO_W) -> i32;
 219     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 220     pub fn JetGetLogInfoInstanceA(instance: super::StructuredStorage::JET_INSTANCE, szzlogs: *mut i8, cbmax: u32, pcbactual: *mut u32) -> i32;
 221     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 222     pub fn JetGetLogInfoInstanceW(instance: super::StructuredStorage::JET_INSTANCE, wszzlogs: *mut u16, cbmax: u32, pcbactual: *mut u32) -> i32;
 223     pub fn JetGetLogInfoW(szzlogs: *mut u16, cbmax: u32, pcbactual: *mut u32) -> i32;
 224     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 225     pub fn JetGetObjectInfoA(sesid: super::StructuredStorage::JET_SESID, dbid: u32, objtyp: u32, szcontainername: *const i8, szobjectname: *const i8, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 226     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 227     pub fn JetGetObjectInfoW(sesid: super::StructuredStorage::JET_SESID, dbid: u32, objtyp: u32, szcontainername: *const u16, szobjectname: *const u16, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 228     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 229     pub fn JetGetRecordPosition(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, precpos: *mut JET_RECPOS, cbrecpos: u32) -> i32;
 230     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 231     pub fn JetGetRecordSize(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, precsize: *mut JET_RECSIZE, grbit: u32) -> i32;
 232     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 233     pub fn JetGetRecordSize2(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, precsize: *mut JET_RECSIZE2, grbit: u32) -> i32;
 234     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 235     pub fn JetGetSecondaryIndexBookmark(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pvsecondarykey: *mut ::core::ffi::c_void, cbsecondarykeymax: u32, pcbsecondarykeyactual: *mut u32, pvprimarybookmark: *mut ::core::ffi::c_void, cbprimarybookmarkmax: u32, pcbprimarybookmarkactual: *mut u32, grbit: u32) -> i32;
 236     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 237     pub fn JetGetSessionParameter(sesid: super::StructuredStorage::JET_SESID, sesparamid: u32, pvparam: *mut ::core::ffi::c_void, cbparammax: u32, pcbparamactual: *mut u32) -> i32;
 238     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 239     pub fn JetGetSystemParameterA(instance: super::StructuredStorage::JET_INSTANCE, sesid: super::StructuredStorage::JET_SESID, paramid: u32, plparam: *mut super::StructuredStorage::JET_API_PTR, szparam: *mut i8, cbmax: u32) -> i32;
 240     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 241     pub fn JetGetSystemParameterW(instance: super::StructuredStorage::JET_INSTANCE, sesid: super::StructuredStorage::JET_SESID, paramid: u32, plparam: *mut super::StructuredStorage::JET_API_PTR, szparam: *mut u16, cbmax: u32) -> i32;
 242     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 243     pub fn JetGetTableColumnInfoA(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szcolumnname: *const i8, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 244     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 245     pub fn JetGetTableColumnInfoW(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szcolumnname: *const u16, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 246     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 247     pub fn JetGetTableIndexInfoA(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const i8, pvresult: *mut ::core::ffi::c_void, cbresult: u32, infolevel: u32) -> i32;
 248     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 249     pub fn JetGetTableIndexInfoW(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const u16, pvresult: *mut ::core::ffi::c_void, cbresult: u32, infolevel: u32) -> i32;
 250     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 251     pub fn JetGetTableInfoA(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 252     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 253     pub fn JetGetTableInfoW(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pvresult: *mut ::core::ffi::c_void, cbmax: u32, infolevel: u32) -> i32;
 254     pub fn JetGetThreadStats(pvresult: *mut ::core::ffi::c_void, cbmax: u32) -> i32;
 255     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 256     pub fn JetGetTruncateLogInfoInstanceA(instance: super::StructuredStorage::JET_INSTANCE, szzlogs: *mut i8, cbmax: u32, pcbactual: *mut u32) -> i32;
 257     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 258     pub fn JetGetTruncateLogInfoInstanceW(instance: super::StructuredStorage::JET_INSTANCE, wszzlogs: *mut u16, cbmax: u32, pcbactual: *mut u32) -> i32;
 259     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 260     pub fn JetGetVersion(sesid: super::StructuredStorage::JET_SESID, pwversion: *mut u32) -> i32;
 261     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 262     pub fn JetGotoBookmark(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pvbookmark: *const ::core::ffi::c_void, cbbookmark: u32) -> i32;
 263     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 264     pub fn JetGotoPosition(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, precpos: *const JET_RECPOS) -> i32;
 265     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 266     pub fn JetGotoSecondaryIndexBookmark(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pvsecondarykey: *const ::core::ffi::c_void, cbsecondarykey: u32, pvprimarybookmark: *const ::core::ffi::c_void, cbprimarybookmark: u32, grbit: u32) -> i32;
 267     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 268     pub fn JetGrowDatabase(sesid: super::StructuredStorage::JET_SESID, dbid: u32, cpg: u32, pcpgreal: *const u32) -> i32;
 269     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 270     pub fn JetIdle(sesid: super::StructuredStorage::JET_SESID, grbit: u32) -> i32;
 271     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 272     pub fn JetIndexRecordCount(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pcrec: *mut u32, crecmax: u32) -> i32;
 273     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 274     pub fn JetInit(pinstance: *mut super::StructuredStorage::JET_INSTANCE) -> i32;
 275     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 276     pub fn JetInit2(pinstance: *mut super::StructuredStorage::JET_INSTANCE, grbit: u32) -> i32;
 277     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 278     pub fn JetInit3A(pinstance: *mut super::StructuredStorage::JET_INSTANCE, prstinfo: *const JET_RSTINFO_A, grbit: u32) -> i32;
 279     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 280     pub fn JetInit3W(pinstance: *mut super::StructuredStorage::JET_INSTANCE, prstinfo: *const JET_RSTINFO_W, grbit: u32) -> i32;
 281     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 282     pub fn JetIntersectIndexes(sesid: super::StructuredStorage::JET_SESID, rgindexrange: *const JET_INDEXRANGE, cindexrange: u32, precordlist: *mut JET_RECORDLIST, grbit: u32) -> i32;
 283     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 284     pub fn JetMakeKey(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pvdata: *const ::core::ffi::c_void, cbdata: u32, grbit: u32) -> i32;
 285     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 286     pub fn JetMove(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, crow: i32, grbit: u32) -> i32;
 287     pub fn JetOSSnapshotAbort(snapid: JET_OSSNAPID, grbit: u32) -> i32;
 288     pub fn JetOSSnapshotEnd(snapid: JET_OSSNAPID, grbit: u32) -> i32;
 289     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 290     pub fn JetOSSnapshotFreezeA(snapid: JET_OSSNAPID, pcinstanceinfo: *mut u32, painstanceinfo: *mut *mut JET_INSTANCE_INFO_A, grbit: u32) -> i32;
 291     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 292     pub fn JetOSSnapshotFreezeW(snapid: JET_OSSNAPID, pcinstanceinfo: *mut u32, painstanceinfo: *mut *mut JET_INSTANCE_INFO_W, grbit: u32) -> i32;
 293     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 294     pub fn JetOSSnapshotGetFreezeInfoA(snapid: JET_OSSNAPID, pcinstanceinfo: *mut u32, painstanceinfo: *mut *mut JET_INSTANCE_INFO_A, grbit: u32) -> i32;
 295     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 296     pub fn JetOSSnapshotGetFreezeInfoW(snapid: JET_OSSNAPID, pcinstanceinfo: *mut u32, painstanceinfo: *mut *mut JET_INSTANCE_INFO_W, grbit: u32) -> i32;
 297     pub fn JetOSSnapshotPrepare(psnapid: *mut JET_OSSNAPID, grbit: u32) -> i32;
 298     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 299     pub fn JetOSSnapshotPrepareInstance(snapid: JET_OSSNAPID, instance: super::StructuredStorage::JET_INSTANCE, grbit: u32) -> i32;
 300     pub fn JetOSSnapshotThaw(snapid: JET_OSSNAPID, grbit: u32) -> i32;
 301     pub fn JetOSSnapshotTruncateLog(snapid: JET_OSSNAPID, grbit: u32) -> i32;
 302     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 303     pub fn JetOSSnapshotTruncateLogInstance(snapid: JET_OSSNAPID, instance: super::StructuredStorage::JET_INSTANCE, grbit: u32) -> i32;
 304     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 305     pub fn JetOpenDatabaseA(sesid: super::StructuredStorage::JET_SESID, szfilename: *const i8, szconnect: *const i8, pdbid: *mut u32, grbit: u32) -> i32;
 306     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 307     pub fn JetOpenDatabaseW(sesid: super::StructuredStorage::JET_SESID, szfilename: *const u16, szconnect: *const u16, pdbid: *mut u32, grbit: u32) -> i32;
 308     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 309     pub fn JetOpenFileA(szfilename: *const i8, phffile: *mut super::StructuredStorage::JET_HANDLE, pulfilesizelow: *mut u32, pulfilesizehigh: *mut u32) -> i32;
 310     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 311     pub fn JetOpenFileInstanceA(instance: super::StructuredStorage::JET_INSTANCE, szfilename: *const i8, phffile: *mut super::StructuredStorage::JET_HANDLE, pulfilesizelow: *mut u32, pulfilesizehigh: *mut u32) -> i32;
 312     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 313     pub fn JetOpenFileInstanceW(instance: super::StructuredStorage::JET_INSTANCE, szfilename: *const u16, phffile: *mut super::StructuredStorage::JET_HANDLE, pulfilesizelow: *mut u32, pulfilesizehigh: *mut u32) -> i32;
 314     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 315     pub fn JetOpenFileW(szfilename: *const u16, phffile: *mut super::StructuredStorage::JET_HANDLE, pulfilesizelow: *mut u32, pulfilesizehigh: *mut u32) -> i32;
 316     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 317     pub fn JetOpenTableA(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const i8, pvparameters: *const ::core::ffi::c_void, cbparameters: u32, grbit: u32, ptableid: *mut super::StructuredStorage::JET_TABLEID) -> i32;
 318     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 319     pub fn JetOpenTableW(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const u16, pvparameters: *const ::core::ffi::c_void, cbparameters: u32, grbit: u32, ptableid: *mut super::StructuredStorage::JET_TABLEID) -> i32;
 320     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 321     pub fn JetOpenTempTable(sesid: super::StructuredStorage::JET_SESID, prgcolumndef: *const JET_COLUMNDEF, ccolumn: u32, grbit: u32, ptableid: *mut super::StructuredStorage::JET_TABLEID, prgcolumnid: *mut u32) -> i32;
 322     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 323     pub fn JetOpenTempTable2(sesid: super::StructuredStorage::JET_SESID, prgcolumndef: *const JET_COLUMNDEF, ccolumn: u32, lcid: u32, grbit: u32, ptableid: *mut super::StructuredStorage::JET_TABLEID, prgcolumnid: *mut u32) -> i32;
 324     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 325     pub fn JetOpenTempTable3(sesid: super::StructuredStorage::JET_SESID, prgcolumndef: *const JET_COLUMNDEF, ccolumn: u32, pidxunicode: *const JET_UNICODEINDEX, grbit: u32, ptableid: *mut super::StructuredStorage::JET_TABLEID, prgcolumnid: *mut u32) -> i32;
 326     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 327     pub fn JetOpenTemporaryTable(sesid: super::StructuredStorage::JET_SESID, popentemporarytable: *const JET_OPENTEMPORARYTABLE) -> i32;
 328     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
 329     pub fn JetOpenTemporaryTable2(sesid: super::StructuredStorage::JET_SESID, popentemporarytable: *const JET_OPENTEMPORARYTABLE2) -> i32;
 330     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 331     pub fn JetPrepareUpdate(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, prep: u32) -> i32;
 332     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 333     pub fn JetPrereadIndexRanges(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, rgindexranges: *const JET_INDEX_RANGE, cindexranges: u32, pcrangespreread: *mut u32, rgcolumnidpreread: *const u32, ccolumnidpreread: u32, grbit: u32) -> i32;
 334     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 335     pub fn JetPrereadKeys(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, rgpvkeys: *const *const ::core::ffi::c_void, rgcbkeys: *const u32, ckeys: i32, pckeyspreread: *mut i32, grbit: u32) -> i32;
 336     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 337     pub fn JetReadFile(hffile: super::StructuredStorage::JET_HANDLE, pv: *mut ::core::ffi::c_void, cb: u32, pcbactual: *mut u32) -> i32;
 338     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 339     pub fn JetReadFileInstance(instance: super::StructuredStorage::JET_INSTANCE, hffile: super::StructuredStorage::JET_HANDLE, pv: *mut ::core::ffi::c_void, cb: u32, pcbactual: *mut u32) -> i32;
 340     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 341     pub fn JetRegisterCallback(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, cbtyp: u32, pcallback: ::core::option::Option<JET_CALLBACK>, pvcontext: *const ::core::ffi::c_void, phcallbackid: *const super::StructuredStorage::JET_HANDLE) -> i32;
 342     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 343     pub fn JetRenameColumnA(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szname: *const i8, sznamenew: *const i8, grbit: u32) -> i32;
 344     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 345     pub fn JetRenameColumnW(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szname: *const u16, sznamenew: *const u16, grbit: u32) -> i32;
 346     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 347     pub fn JetRenameTableA(sesid: super::StructuredStorage::JET_SESID, dbid: u32, szname: *const i8, sznamenew: *const i8) -> i32;
 348     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 349     pub fn JetRenameTableW(sesid: super::StructuredStorage::JET_SESID, dbid: u32, szname: *const u16, sznamenew: *const u16) -> i32;
 350     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 351     pub fn JetResetSessionContext(sesid: super::StructuredStorage::JET_SESID) -> i32;
 352     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 353     pub fn JetResetTableSequential(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, grbit: u32) -> i32;
 354     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 355     pub fn JetResizeDatabase(sesid: super::StructuredStorage::JET_SESID, dbid: u32, cpgtarget: u32, pcpgactual: *mut u32, grbit: u32) -> i32;
 356     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 357     pub fn JetRestore2A(sz: *const i8, szdest: *const i8, pfn: ::core::option::Option<JET_PFNSTATUS>) -> i32;
 358     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 359     pub fn JetRestore2W(sz: *const u16, szdest: *const u16, pfn: ::core::option::Option<JET_PFNSTATUS>) -> i32;
 360     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 361     pub fn JetRestoreA(szsource: *const i8, pfn: ::core::option::Option<JET_PFNSTATUS>) -> i32;
 362     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 363     pub fn JetRestoreInstanceA(instance: super::StructuredStorage::JET_INSTANCE, sz: *const i8, szdest: *const i8, pfn: ::core::option::Option<JET_PFNSTATUS>) -> i32;
 364     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 365     pub fn JetRestoreInstanceW(instance: super::StructuredStorage::JET_INSTANCE, sz: *const u16, szdest: *const u16, pfn: ::core::option::Option<JET_PFNSTATUS>) -> i32;
 366     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 367     pub fn JetRestoreW(szsource: *const u16, pfn: ::core::option::Option<JET_PFNSTATUS>) -> i32;
 368     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 369     pub fn JetRetrieveColumn(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, columnid: u32, pvdata: *mut ::core::ffi::c_void, cbdata: u32, pcbactual: *mut u32, grbit: u32, pretinfo: *mut JET_RETINFO) -> i32;
 370     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 371     pub fn JetRetrieveColumns(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pretrievecolumn: *mut JET_RETRIEVECOLUMN, cretrievecolumn: u32) -> i32;
 372     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 373     pub fn JetRetrieveKey(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pvkey: *mut ::core::ffi::c_void, cbmax: u32, pcbactual: *mut u32, grbit: u32) -> i32;
 374     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 375     pub fn JetRollback(sesid: super::StructuredStorage::JET_SESID, grbit: u32) -> i32;
 376     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 377     pub fn JetSeek(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, grbit: u32) -> i32;
 378     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 379     pub fn JetSetColumn(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, columnid: u32, pvdata: *const ::core::ffi::c_void, cbdata: u32, grbit: u32, psetinfo: *const JET_SETINFO) -> i32;
 380     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 381     pub fn JetSetColumnDefaultValueA(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const i8, szcolumnname: *const i8, pvdata: *const ::core::ffi::c_void, cbdata: u32, grbit: u32) -> i32;
 382     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 383     pub fn JetSetColumnDefaultValueW(sesid: super::StructuredStorage::JET_SESID, dbid: u32, sztablename: *const u16, szcolumnname: *const u16, pvdata: *const ::core::ffi::c_void, cbdata: u32, grbit: u32) -> i32;
 384     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 385     pub fn JetSetColumns(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, psetcolumn: *const JET_SETCOLUMN, csetcolumn: u32) -> i32;
 386     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 387     pub fn JetSetCurrentIndex2A(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const i8, grbit: u32) -> i32;
 388     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 389     pub fn JetSetCurrentIndex2W(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const u16, grbit: u32) -> i32;
 390     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 391     pub fn JetSetCurrentIndex3A(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const i8, grbit: u32, itagsequence: u32) -> i32;
 392     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 393     pub fn JetSetCurrentIndex3W(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const u16, grbit: u32, itagsequence: u32) -> i32;
 394     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 395     pub fn JetSetCurrentIndex4A(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const i8, pindexid: *const JET_INDEXID, grbit: u32, itagsequence: u32) -> i32;
 396     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 397     pub fn JetSetCurrentIndex4W(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const u16, pindexid: *const JET_INDEXID, grbit: u32, itagsequence: u32) -> i32;
 398     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 399     pub fn JetSetCurrentIndexA(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const i8) -> i32;
 400     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 401     pub fn JetSetCurrentIndexW(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, szindexname: *const u16) -> i32;
 402     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 403     pub fn JetSetCursorFilter(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, rgcolumnfilters: *const JET_INDEX_COLUMN, ccolumnfilters: u32, grbit: u32) -> i32;
 404     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 405     pub fn JetSetDatabaseSizeA(sesid: super::StructuredStorage::JET_SESID, szdatabasename: *const i8, cpg: u32, pcpgreal: *mut u32) -> i32;
 406     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 407     pub fn JetSetDatabaseSizeW(sesid: super::StructuredStorage::JET_SESID, szdatabasename: *const u16, cpg: u32, pcpgreal: *mut u32) -> i32;
 408     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 409     pub fn JetSetIndexRange(sesid: super::StructuredStorage::JET_SESID, tableidsrc: super::StructuredStorage::JET_TABLEID, grbit: u32) -> i32;
 410     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 411     pub fn JetSetLS(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, ls: JET_LS, grbit: u32) -> i32;
 412     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 413     pub fn JetSetSessionContext(sesid: super::StructuredStorage::JET_SESID, ulcontext: super::StructuredStorage::JET_API_PTR) -> i32;
 414     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 415     pub fn JetSetSessionParameter(sesid: super::StructuredStorage::JET_SESID, sesparamid: u32, pvparam: *const ::core::ffi::c_void, cbparam: u32) -> i32;
 416     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 417     pub fn JetSetSystemParameterA(pinstance: *mut super::StructuredStorage::JET_INSTANCE, sesid: super::StructuredStorage::JET_SESID, paramid: u32, lparam: super::StructuredStorage::JET_API_PTR, szparam: *const i8) -> i32;
 418     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 419     pub fn JetSetSystemParameterW(pinstance: *mut super::StructuredStorage::JET_INSTANCE, sesid: super::StructuredStorage::JET_SESID, paramid: u32, lparam: super::StructuredStorage::JET_API_PTR, szparam: *const u16) -> i32;
 420     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 421     pub fn JetSetTableSequential(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, grbit: u32) -> i32;
 422     pub fn JetStopBackup() -> i32;
 423     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 424     pub fn JetStopBackupInstance(instance: super::StructuredStorage::JET_INSTANCE) -> i32;
 425     pub fn JetStopService() -> i32;
 426     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 427     pub fn JetStopServiceInstance(instance: super::StructuredStorage::JET_INSTANCE) -> i32;
 428     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 429     pub fn JetStopServiceInstance2(instance: super::StructuredStorage::JET_INSTANCE, grbit: u32) -> i32;
 430     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 431     pub fn JetTerm(instance: super::StructuredStorage::JET_INSTANCE) -> i32;
 432     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 433     pub fn JetTerm2(instance: super::StructuredStorage::JET_INSTANCE, grbit: u32) -> i32;
 434     pub fn JetTruncateLog() -> i32;
 435     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 436     pub fn JetTruncateLogInstance(instance: super::StructuredStorage::JET_INSTANCE) -> i32;
 437     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 438     pub fn JetUnregisterCallback(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, cbtyp: u32, hcallbackid: super::StructuredStorage::JET_HANDLE) -> i32;
 439     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 440     pub fn JetUpdate(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pvbookmark: *mut ::core::ffi::c_void, cbbookmark: u32, pcbactual: *mut u32) -> i32;
 441     #[cfg(feature = "Win32_Storage_StructuredStorage")]
 442     pub fn JetUpdate2(sesid: super::StructuredStorage::JET_SESID, tableid: super::StructuredStorage::JET_TABLEID, pvbookmark: *mut ::core::ffi::c_void, cbbookmark: u32, pcbactual: *mut u32, grbit: u32) -> i32;
 443 }
 444 #[repr(C)]
 445 #[cfg(feature = "Win32_Foundation")]
 446 pub struct CONVERT_A {
 447     pub szOldDll: super::super::Foundation::PSTR,
 448     pub Anonymous: CONVERT_A_0,
 449 }
 450 #[cfg(feature = "Win32_Foundation")]
 451 impl ::core::marker::Copy for CONVERT_A {}
 452 #[cfg(feature = "Win32_Foundation")]
 453 impl ::core::clone::Clone for CONVERT_A {
 454     fn clone(&self) -> Self {
 455         *self
 456     }
 457 }
 458 #[repr(C)]
 459 #[cfg(feature = "Win32_Foundation")]
 460 pub union CONVERT_A_0 {
 461     pub fFlags: u32,
 462     pub Anonymous: CONVERT_A_0_0,
 463 }
 464 #[cfg(feature = "Win32_Foundation")]
 465 impl ::core::marker::Copy for CONVERT_A_0 {}
 466 #[cfg(feature = "Win32_Foundation")]
 467 impl ::core::clone::Clone for CONVERT_A_0 {
 468     fn clone(&self) -> Self {
 469         *self
 470     }
 471 }
 472 #[repr(C)]
 473 #[cfg(feature = "Win32_Foundation")]
 474 pub struct CONVERT_A_0_0 {
 475     pub _bitfield: u32,
 476 }
 477 #[cfg(feature = "Win32_Foundation")]
 478 impl ::core::marker::Copy for CONVERT_A_0_0 {}
 479 #[cfg(feature = "Win32_Foundation")]
 480 impl ::core::clone::Clone for CONVERT_A_0_0 {
 481     fn clone(&self) -> Self {
 482         *self
 483     }
 484 }
 485 #[repr(C)]
 486 #[cfg(feature = "Win32_Foundation")]
 487 pub struct CONVERT_W {
 488     pub szOldDll: super::super::Foundation::PWSTR,
 489     pub Anonymous: CONVERT_W_0,
 490 }
 491 #[cfg(feature = "Win32_Foundation")]
 492 impl ::core::marker::Copy for CONVERT_W {}
 493 #[cfg(feature = "Win32_Foundation")]
 494 impl ::core::clone::Clone for CONVERT_W {
 495     fn clone(&self) -> Self {
 496         *self
 497     }
 498 }
 499 #[repr(C)]
 500 #[cfg(feature = "Win32_Foundation")]
 501 pub union CONVERT_W_0 {
 502     pub fFlags: u32,
 503     pub Anonymous: CONVERT_W_0_0,
 504 }
 505 #[cfg(feature = "Win32_Foundation")]
 506 impl ::core::marker::Copy for CONVERT_W_0 {}
 507 #[cfg(feature = "Win32_Foundation")]
 508 impl ::core::clone::Clone for CONVERT_W_0 {
 509     fn clone(&self) -> Self {
 510         *self
 511     }
 512 }
 513 #[repr(C)]
 514 #[cfg(feature = "Win32_Foundation")]
 515 pub struct CONVERT_W_0_0 {
 516     pub _bitfield: u32,
 517 }
 518 #[cfg(feature = "Win32_Foundation")]
 519 impl ::core::marker::Copy for CONVERT_W_0_0 {}
 520 #[cfg(feature = "Win32_Foundation")]
 521 impl ::core::clone::Clone for CONVERT_W_0_0 {
 522     fn clone(&self) -> Self {
 523         *self
 524     }
 525 }
 526 pub const JET_BASE_NAME_LENGTH: u32 = 3u32;
 527 #[repr(C, packed(1))]
 528 #[cfg(feature = "Win32_Foundation")]
 529 pub struct JET_BKINFO {
 530     pub lgposMark: JET_LGPOS,
 531     pub Anonymous: JET_BKINFO_0,
 532     pub genLow: u32,
 533     pub genHigh: u32,
 534 }
 535 #[cfg(feature = "Win32_Foundation")]
 536 impl ::core::marker::Copy for JET_BKINFO {}
 537 #[cfg(feature = "Win32_Foundation")]
 538 impl ::core::clone::Clone for JET_BKINFO {
 539     fn clone(&self) -> Self {
 540         *self
 541     }
 542 }
 543 #[repr(C)]
 544 #[cfg(feature = "Win32_Foundation")]
 545 pub union JET_BKINFO_0 {
 546     pub logtimeMark: JET_LOGTIME,
 547     pub bklogtimeMark: JET_BKLOGTIME,
 548 }
 549 #[cfg(feature = "Win32_Foundation")]
 550 impl ::core::marker::Copy for JET_BKINFO_0 {}
 551 #[cfg(feature = "Win32_Foundation")]
 552 impl ::core::clone::Clone for JET_BKINFO_0 {
 553     fn clone(&self) -> Self {
 554         *self
 555     }
 556 }
 557 #[repr(C)]
 558 #[cfg(feature = "Win32_Foundation")]
 559 pub struct JET_BKLOGTIME {
 560     pub bSeconds: super::super::Foundation::CHAR,
 561     pub bMinutes: super::super::Foundation::CHAR,
 562     pub bHours: super::super::Foundation::CHAR,
 563     pub bDay: super::super::Foundation::CHAR,
 564     pub bMonth: super::super::Foundation::CHAR,
 565     pub bYear: super::super::Foundation::CHAR,
 566     pub Anonymous1: JET_BKLOGTIME_0,
 567     pub Anonymous2: JET_BKLOGTIME_1,
 568 }
 569 #[cfg(feature = "Win32_Foundation")]
 570 impl ::core::marker::Copy for JET_BKLOGTIME {}
 571 #[cfg(feature = "Win32_Foundation")]
 572 impl ::core::clone::Clone for JET_BKLOGTIME {
 573     fn clone(&self) -> Self {
 574         *self
 575     }
 576 }
 577 #[repr(C)]
 578 #[cfg(feature = "Win32_Foundation")]
 579 pub union JET_BKLOGTIME_0 {
 580     pub bFiller1: super::super::Foundation::CHAR,
 581     pub Anonymous: JET_BKLOGTIME_0_0,
 582 }
 583 #[cfg(feature = "Win32_Foundation")]
 584 impl ::core::marker::Copy for JET_BKLOGTIME_0 {}
 585 #[cfg(feature = "Win32_Foundation")]
 586 impl ::core::clone::Clone for JET_BKLOGTIME_0 {
 587     fn clone(&self) -> Self {
 588         *self
 589     }
 590 }
 591 #[repr(C)]
 592 #[cfg(feature = "Win32_Foundation")]
 593 pub struct JET_BKLOGTIME_0_0 {
 594     pub _bitfield: u8,
 595 }
 596 #[cfg(feature = "Win32_Foundation")]
 597 impl ::core::marker::Copy for JET_BKLOGTIME_0_0 {}
 598 #[cfg(feature = "Win32_Foundation")]
 599 impl ::core::clone::Clone for JET_BKLOGTIME_0_0 {
 600     fn clone(&self) -> Self {
 601         *self
 602     }
 603 }
 604 #[repr(C)]
 605 #[cfg(feature = "Win32_Foundation")]
 606 pub union JET_BKLOGTIME_1 {
 607     pub bFiller2: super::super::Foundation::CHAR,
 608     pub Anonymous: JET_BKLOGTIME_1_0,
 609 }
 610 #[cfg(feature = "Win32_Foundation")]
 611 impl ::core::marker::Copy for JET_BKLOGTIME_1 {}
 612 #[cfg(feature = "Win32_Foundation")]
 613 impl ::core::clone::Clone for JET_BKLOGTIME_1 {
 614     fn clone(&self) -> Self {
 615         *self
 616     }
 617 }
 618 #[repr(C)]
 619 #[cfg(feature = "Win32_Foundation")]
 620 pub struct JET_BKLOGTIME_1_0 {
 621     pub _bitfield: u8,
 622 }
 623 #[cfg(feature = "Win32_Foundation")]
 624 impl ::core::marker::Copy for JET_BKLOGTIME_1_0 {}
 625 #[cfg(feature = "Win32_Foundation")]
 626 impl ::core::clone::Clone for JET_BKLOGTIME_1_0 {
 627     fn clone(&self) -> Self {
 628         *self
 629     }
 630 }
 631 #[cfg(feature = "Win32_Storage_StructuredStorage")]
 632 pub type JET_CALLBACK = unsafe extern "system" fn(sesid: super::StructuredStorage::JET_SESID, dbid: u32, tableid: super::StructuredStorage::JET_TABLEID, cbtyp: u32, pvarg1: *mut ::core::ffi::c_void, pvarg2: *mut ::core::ffi::c_void, pvcontext: *const ::core::ffi::c_void, ulunused: super::StructuredStorage::JET_API_PTR) -> i32;
 633 #[repr(C)]
 634 #[cfg(feature = "Win32_Foundation")]
 635 pub struct JET_COLUMNBASE_A {
 636     pub cbStruct: u32,
 637     pub columnid: u32,
 638     pub coltyp: u32,
 639     pub wCountry: u16,
 640     pub langid: u16,
 641     pub cp: u16,
 642     pub wFiller: u16,
 643     pub cbMax: u32,
 644     pub grbit: u32,
 645     pub szBaseTableName: [super::super::Foundation::CHAR; 256],
 646     pub szBaseColumnName: [super::super::Foundation::CHAR; 256],
 647 }
 648 #[cfg(feature = "Win32_Foundation")]
 649 impl ::core::marker::Copy for JET_COLUMNBASE_A {}
 650 #[cfg(feature = "Win32_Foundation")]
 651 impl ::core::clone::Clone for JET_COLUMNBASE_A {
 652     fn clone(&self) -> Self {
 653         *self
 654     }
 655 }
 656 #[repr(C)]
 657 pub struct JET_COLUMNBASE_W {
 658     pub cbStruct: u32,
 659     pub columnid: u32,
 660     pub coltyp: u32,
 661     pub wCountry: u16,
 662     pub langid: u16,
 663     pub cp: u16,
 664     pub wFiller: u16,
 665     pub cbMax: u32,
 666     pub grbit: u32,
 667     pub szBaseTableName: [u16; 256],
 668     pub szBaseColumnName: [u16; 256],
 669 }
 670 impl ::core::marker::Copy for JET_COLUMNBASE_W {}
 671 impl ::core::clone::Clone for JET_COLUMNBASE_W {
 672     fn clone(&self) -> Self {
 673         *self
 674     }
 675 }
 676 #[repr(C)]
 677 #[cfg(feature = "Win32_Foundation")]
 678 pub struct JET_COLUMNCREATE_A {
 679     pub cbStruct: u32,
 680     pub szColumnName: super::super::Foundation::PSTR,
 681     pub coltyp: u32,
 682     pub cbMax: u32,
 683     pub grbit: u32,
 684     pub pvDefault: *mut ::core::ffi::c_void,
 685     pub cbDefault: u32,
 686     pub cp: u32,
 687     pub columnid: u32,
 688     pub err: i32,
 689 }
 690 #[cfg(feature = "Win32_Foundation")]
 691 impl ::core::marker::Copy for JET_COLUMNCREATE_A {}
 692 #[cfg(feature = "Win32_Foundation")]
 693 impl ::core::clone::Clone for JET_COLUMNCREATE_A {
 694     fn clone(&self) -> Self {
 695         *self
 696     }
 697 }
 698 #[repr(C)]
 699 #[cfg(feature = "Win32_Foundation")]
 700 pub struct JET_COLUMNCREATE_W {
 701     pub cbStruct: u32,
 702     pub szColumnName: super::super::Foundation::PWSTR,
 703     pub coltyp: u32,
 704     pub cbMax: u32,
 705     pub grbit: u32,
 706     pub pvDefault: *mut ::core::ffi::c_void,
 707     pub cbDefault: u32,
 708     pub cp: u32,
 709     pub columnid: u32,
 710     pub err: i32,
 711 }
 712 #[cfg(feature = "Win32_Foundation")]
 713 impl ::core::marker::Copy for JET_COLUMNCREATE_W {}
 714 #[cfg(feature = "Win32_Foundation")]
 715 impl ::core::clone::Clone for JET_COLUMNCREATE_W {
 716     fn clone(&self) -> Self {
 717         *self
 718     }
 719 }
 720 #[repr(C)]
 721 pub struct JET_COLUMNDEF {
 722     pub cbStruct: u32,
 723     pub columnid: u32,
 724     pub coltyp: u32,
 725     pub wCountry: u16,
 726     pub langid: u16,
 727     pub cp: u16,
 728     pub wCollate: u16,
 729     pub cbMax: u32,
 730     pub grbit: u32,
 731 }
 732 impl ::core::marker::Copy for JET_COLUMNDEF {}
 733 impl ::core::clone::Clone for JET_COLUMNDEF {
 734     fn clone(&self) -> Self {
 735         *self
 736     }
 737 }
 738 #[repr(C)]
 739 #[cfg(feature = "Win32_Storage_StructuredStorage")]
 740 pub struct JET_COLUMNLIST {
 741     pub cbStruct: u32,
 742     pub tableid: super::StructuredStorage::JET_TABLEID,
 743     pub cRecord: u32,
 744     pub columnidPresentationOrder: u32,
 745     pub columnidcolumnname: u32,
 746     pub columnidcolumnid: u32,
 747     pub columnidcoltyp: u32,
 748     pub columnidCountry: u32,
 749     pub columnidLangid: u32,
 750     pub columnidCp: u32,
 751     pub columnidCollate: u32,
 752     pub columnidcbMax: u32,
 753     pub columnidgrbit: u32,
 754     pub columnidDefault: u32,
 755     pub columnidBaseTableName: u32,
 756     pub columnidBaseColumnName: u32,
 757     pub columnidDefinitionName: u32,
 758 }
 759 #[cfg(feature = "Win32_Storage_StructuredStorage")]
 760 impl ::core::marker::Copy for JET_COLUMNLIST {}
 761 #[cfg(feature = "Win32_Storage_StructuredStorage")]
 762 impl ::core::clone::Clone for JET_COLUMNLIST {
 763     fn clone(&self) -> Self {
 764         *self
 765     }
 766 }
 767 #[repr(C)]
 768 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
 769 #[cfg(feature = "Win32_Foundation")]
 770 pub struct JET_COMMIT_ID {
 771     pub signLog: JET_SIGNATURE,
 772     pub reserved: i32,
 773     pub commitId: i64,
 774 }
 775 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
 776 #[cfg(feature = "Win32_Foundation")]
 777 impl ::core::marker::Copy for JET_COMMIT_ID {}
 778 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
 779 #[cfg(feature = "Win32_Foundation")]
 780 impl ::core::clone::Clone for JET_COMMIT_ID {
 781     fn clone(&self) -> Self {
 782         *self
 783     }
 784 }
 785 #[repr(C, packed(4))]
 786 #[cfg(any(target_arch = "x86",))]
 787 #[cfg(feature = "Win32_Foundation")]
 788 pub struct JET_COMMIT_ID {
 789     pub signLog: JET_SIGNATURE,
 790     pub reserved: i32,
 791     pub commitId: i64,
 792 }
 793 #[cfg(any(target_arch = "x86",))]
 794 #[cfg(feature = "Win32_Foundation")]
 795 impl ::core::marker::Copy for JET_COMMIT_ID {}
 796 #[cfg(any(target_arch = "x86",))]
 797 #[cfg(feature = "Win32_Foundation")]
 798 impl ::core::clone::Clone for JET_COMMIT_ID {
 799     fn clone(&self) -> Self {
 800         *self
 801     }
 802 }
 803 #[repr(C)]
 804 #[cfg(feature = "Win32_Foundation")]
 805 pub struct JET_CONDITIONALCOLUMN_A {
 806     pub cbStruct: u32,
 807     pub szColumnName: super::super::Foundation::PSTR,
 808     pub grbit: u32,
 809 }
 810 #[cfg(feature = "Win32_Foundation")]
 811 impl ::core::marker::Copy for JET_CONDITIONALCOLUMN_A {}
 812 #[cfg(feature = "Win32_Foundation")]
 813 impl ::core::clone::Clone for JET_CONDITIONALCOLUMN_A {
 814     fn clone(&self) -> Self {
 815         *self
 816     }
 817 }
 818 #[repr(C)]
 819 #[cfg(feature = "Win32_Foundation")]
 820 pub struct JET_CONDITIONALCOLUMN_W {
 821     pub cbStruct: u32,
 822     pub szColumnName: super::super::Foundation::PWSTR,
 823     pub grbit: u32,
 824 }
 825 #[cfg(feature = "Win32_Foundation")]
 826 impl ::core::marker::Copy for JET_CONDITIONALCOLUMN_W {}
 827 #[cfg(feature = "Win32_Foundation")]
 828 impl ::core::clone::Clone for JET_CONDITIONALCOLUMN_W {
 829     fn clone(&self) -> Self {
 830         *self
 831     }
 832 }
 833 pub const JET_ColInfoGrbitMinimalInfo: u32 = 1073741824u32;
 834 pub const JET_ColInfoGrbitNonDerivedColumnsOnly: u32 = 2147483648u32;
 835 pub const JET_ColInfoGrbitSortByColumnid: u32 = 536870912u32;
 836 #[repr(C)]
 837 #[cfg(feature = "Win32_Foundation")]
 838 pub struct JET_DBINFOMISC {
 839     pub ulVersion: u32,
 840     pub ulUpdate: u32,
 841     pub signDb: JET_SIGNATURE,
 842     pub dbstate: u32,
 843     pub lgposConsistent: JET_LGPOS,
 844     pub logtimeConsistent: JET_LOGTIME,
 845     pub logtimeAttach: JET_LOGTIME,
 846     pub lgposAttach: JET_LGPOS,
 847     pub logtimeDetach: JET_LOGTIME,
 848     pub lgposDetach: JET_LGPOS,
 849     pub signLog: JET_SIGNATURE,
 850     pub bkinfoFullPrev: JET_BKINFO,
 851     pub bkinfoIncPrev: JET_BKINFO,
 852     pub bkinfoFullCur: JET_BKINFO,
 853     pub fShadowingDisabled: u32,
 854     pub fUpgradeDb: u32,
 855     pub dwMajorVersion: u32,
 856     pub dwMinorVersion: u32,
 857     pub dwBuildNumber: u32,
 858     pub lSPNumber: i32,
 859     pub cbPageSize: u32,
 860 }
 861 #[cfg(feature = "Win32_Foundation")]
 862 impl ::core::marker::Copy for JET_DBINFOMISC {}
 863 #[cfg(feature = "Win32_Foundation")]
 864 impl ::core::clone::Clone for JET_DBINFOMISC {
 865     fn clone(&self) -> Self {
 866         *self
 867     }
 868 }
 869 #[repr(C)]
 870 #[cfg(feature = "Win32_Foundation")]
 871 pub struct JET_DBINFOMISC2 {
 872     pub ulVersion: u32,
 873     pub ulUpdate: u32,
 874     pub signDb: JET_SIGNATURE,
 875     pub dbstate: u32,
 876     pub lgposConsistent: JET_LGPOS,
 877     pub logtimeConsistent: JET_LOGTIME,
 878     pub logtimeAttach: JET_LOGTIME,
 879     pub lgposAttach: JET_LGPOS,
 880     pub logtimeDetach: JET_LOGTIME,
 881     pub lgposDetach: JET_LGPOS,
 882     pub signLog: JET_SIGNATURE,
 883     pub bkinfoFullPrev: JET_BKINFO,
 884     pub bkinfoIncPrev: JET_BKINFO,
 885     pub bkinfoFullCur: JET_BKINFO,
 886     pub fShadowingDisabled: u32,
 887     pub fUpgradeDb: u32,
 888     pub dwMajorVersion: u32,
 889     pub dwMinorVersion: u32,
 890     pub dwBuildNumber: u32,
 891     pub lSPNumber: i32,
 892     pub cbPageSize: u32,
 893     pub genMinRequired: u32,
 894     pub genMaxRequired: u32,
 895     pub logtimeGenMaxCreate: JET_LOGTIME,
 896     pub ulRepairCount: u32,
 897     pub logtimeRepair: JET_LOGTIME,
 898     pub ulRepairCountOld: u32,
 899     pub ulECCFixSuccess: u32,
 900     pub logtimeECCFixSuccess: JET_LOGTIME,
 901     pub ulECCFixSuccessOld: u32,
 902     pub ulECCFixFail: u32,
 903     pub logtimeECCFixFail: JET_LOGTIME,
 904     pub ulECCFixFailOld: u32,
 905     pub ulBadChecksum: u32,
 906     pub logtimeBadChecksum: JET_LOGTIME,
 907     pub ulBadChecksumOld: u32,
 908 }
 909 #[cfg(feature = "Win32_Foundation")]
 910 impl ::core::marker::Copy for JET_DBINFOMISC2 {}
 911 #[cfg(feature = "Win32_Foundation")]
 912 impl ::core::clone::Clone for JET_DBINFOMISC2 {
 913     fn clone(&self) -> Self {
 914         *self
 915     }
 916 }
 917 #[repr(C)]
 918 #[cfg(feature = "Win32_Foundation")]
 919 pub struct JET_DBINFOMISC3 {
 920     pub ulVersion: u32,
 921     pub ulUpdate: u32,
 922     pub signDb: JET_SIGNATURE,
 923     pub dbstate: u32,
 924     pub lgposConsistent: JET_LGPOS,
 925     pub logtimeConsistent: JET_LOGTIME,
 926     pub logtimeAttach: JET_LOGTIME,
 927     pub lgposAttach: JET_LGPOS,
 928     pub logtimeDetach: JET_LOGTIME,
 929     pub lgposDetach: JET_LGPOS,
 930     pub signLog: JET_SIGNATURE,
 931     pub bkinfoFullPrev: JET_BKINFO,
 932     pub bkinfoIncPrev: JET_BKINFO,
 933     pub bkinfoFullCur: JET_BKINFO,
 934     pub fShadowingDisabled: u32,
 935     pub fUpgradeDb: u32,
 936     pub dwMajorVersion: u32,
 937     pub dwMinorVersion: u32,
 938     pub dwBuildNumber: u32,
 939     pub lSPNumber: i32,
 940     pub cbPageSize: u32,
 941     pub genMinRequired: u32,
 942     pub genMaxRequired: u32,
 943     pub logtimeGenMaxCreate: JET_LOGTIME,
 944     pub ulRepairCount: u32,
 945     pub logtimeRepair: JET_LOGTIME,
 946     pub ulRepairCountOld: u32,
 947     pub ulECCFixSuccess: u32,
 948     pub logtimeECCFixSuccess: JET_LOGTIME,
 949     pub ulECCFixSuccessOld: u32,
 950     pub ulECCFixFail: u32,
 951     pub logtimeECCFixFail: JET_LOGTIME,
 952     pub ulECCFixFailOld: u32,
 953     pub ulBadChecksum: u32,
 954     pub logtimeBadChecksum: JET_LOGTIME,
 955     pub ulBadChecksumOld: u32,
 956     pub genCommitted: u32,
 957 }
 958 #[cfg(feature = "Win32_Foundation")]
 959 impl ::core::marker::Copy for JET_DBINFOMISC3 {}
 960 #[cfg(feature = "Win32_Foundation")]
 961 impl ::core::clone::Clone for JET_DBINFOMISC3 {
 962     fn clone(&self) -> Self {
 963         *self
 964     }
 965 }
 966 #[repr(C)]
 967 #[cfg(feature = "Win32_Foundation")]
 968 pub struct JET_DBINFOMISC4 {
 969     pub ulVersion: u32,
 970     pub ulUpdate: u32,
 971     pub signDb: JET_SIGNATURE,
 972     pub dbstate: u32,
 973     pub lgposConsistent: JET_LGPOS,
 974     pub logtimeConsistent: JET_LOGTIME,
 975     pub logtimeAttach: JET_LOGTIME,
 976     pub lgposAttach: JET_LGPOS,
 977     pub logtimeDetach: JET_LOGTIME,
 978     pub lgposDetach: JET_LGPOS,
 979     pub signLog: JET_SIGNATURE,
 980     pub bkinfoFullPrev: JET_BKINFO,
 981     pub bkinfoIncPrev: JET_BKINFO,
 982     pub bkinfoFullCur: JET_BKINFO,
 983     pub fShadowingDisabled: u32,
 984     pub fUpgradeDb: u32,
 985     pub dwMajorVersion: u32,
 986     pub dwMinorVersion: u32,
 987     pub dwBuildNumber: u32,
 988     pub lSPNumber: i32,
 989     pub cbPageSize: u32,
 990     pub genMinRequired: u32,
 991     pub genMaxRequired: u32,
 992     pub logtimeGenMaxCreate: JET_LOGTIME,
 993     pub ulRepairCount: u32,
 994     pub logtimeRepair: JET_LOGTIME,
 995     pub ulRepairCountOld: u32,
 996     pub ulECCFixSuccess: u32,
 997     pub logtimeECCFixSuccess: JET_LOGTIME,
 998     pub ulECCFixSuccessOld: u32,
 999     pub ulECCFixFail: u32,
1000     pub logtimeECCFixFail: JET_LOGTIME,
1001     pub ulECCFixFailOld: u32,
1002     pub ulBadChecksum: u32,
1003     pub logtimeBadChecksum: JET_LOGTIME,
1004     pub ulBadChecksumOld: u32,
1005     pub genCommitted: u32,
1006     pub bkinfoCopyPrev: JET_BKINFO,
1007     pub bkinfoDiffPrev: JET_BKINFO,
1008 }
1009 #[cfg(feature = "Win32_Foundation")]
1010 impl ::core::marker::Copy for JET_DBINFOMISC4 {}
1011 #[cfg(feature = "Win32_Foundation")]
1012 impl ::core::clone::Clone for JET_DBINFOMISC4 {
1013     fn clone(&self) -> Self {
1014         *self
1015     }
1016 }
1017 #[repr(C)]
1018 pub struct JET_DBINFOUPGRADE {
1019     pub cbStruct: u32,
1020     pub cbFilesizeLow: u32,
1021     pub cbFilesizeHigh: u32,
1022     pub cbFreeSpaceRequiredLow: u32,
1023     pub cbFreeSpaceRequiredHigh: u32,
1024     pub csecToUpgrade: u32,
1025     pub Anonymous: JET_DBINFOUPGRADE_0,
1026 }
1027 impl ::core::marker::Copy for JET_DBINFOUPGRADE {}
1028 impl ::core::clone::Clone for JET_DBINFOUPGRADE {
1029     fn clone(&self) -> Self {
1030         *self
1031     }
1032 }
1033 #[repr(C)]
1034 pub union JET_DBINFOUPGRADE_0 {
1035     pub ulFlags: u32,
1036     pub Anonymous: JET_DBINFOUPGRADE_0_0,
1037 }
1038 impl ::core::marker::Copy for JET_DBINFOUPGRADE_0 {}
1039 impl ::core::clone::Clone for JET_DBINFOUPGRADE_0 {
1040     fn clone(&self) -> Self {
1041         *self
1042     }
1043 }
1044 #[repr(C)]
1045 pub struct JET_DBINFOUPGRADE_0_0 {
1046     pub _bitfield: u32,
1047 }
1048 impl ::core::marker::Copy for JET_DBINFOUPGRADE_0_0 {}
1049 impl ::core::clone::Clone for JET_DBINFOUPGRADE_0_0 {
1050     fn clone(&self) -> Self {
1051         *self
1052     }
1053 }
1054 pub const JET_DbInfoCollate: u32 = 5u32;
1055 pub const JET_DbInfoConnect: u32 = 1u32;
1056 pub const JET_DbInfoCountry: u32 = 2u32;
1057 pub const JET_DbInfoCp: u32 = 4u32;
1058 pub const JET_DbInfoDBInUse: u32 = 15u32;
1059 pub const JET_DbInfoFileType: u32 = 19u32;
1060 pub const JET_DbInfoFilename: u32 = 0u32;
1061 pub const JET_DbInfoFilesize: u32 = 10u32;
1062 pub const JET_DbInfoFilesizeOnDisk: u32 = 21u32;
1063 pub const JET_DbInfoIsam: u32 = 9u32;
1064 pub const JET_DbInfoLCID: u32 = 3u32;
1065 pub const JET_DbInfoLangid: u32 = 3u32;
1066 pub const JET_DbInfoMisc: u32 = 14u32;
1067 pub const JET_DbInfoOptions: u32 = 6u32;
1068 pub const JET_DbInfoPageSize: u32 = 17u32;
1069 pub const JET_DbInfoSpaceAvailable: u32 = 12u32;
1070 pub const JET_DbInfoSpaceOwned: u32 = 11u32;
1071 pub const JET_DbInfoTransactions: u32 = 7u32;
1072 pub const JET_DbInfoUpgrade: u32 = 13u32;
1073 pub const JET_DbInfoVersion: u32 = 8u32;
1074 #[repr(C)]
1075 pub struct JET_ENUMCOLUMN {
1076     pub columnid: u32,
1077     pub err: i32,
1078     pub Anonymous: JET_ENUMCOLUMN_0,
1079 }
1080 impl ::core::marker::Copy for JET_ENUMCOLUMN {}
1081 impl ::core::clone::Clone for JET_ENUMCOLUMN {
1082     fn clone(&self) -> Self {
1083         *self
1084     }
1085 }
1086 #[repr(C)]
1087 pub union JET_ENUMCOLUMN_0 {
1088     pub Anonymous1: JET_ENUMCOLUMN_0_0,
1089     pub Anonymous2: JET_ENUMCOLUMN_0_1,
1090 }
1091 impl ::core::marker::Copy for JET_ENUMCOLUMN_0 {}
1092 impl ::core::clone::Clone for JET_ENUMCOLUMN_0 {
1093     fn clone(&self) -> Self {
1094         *self
1095     }
1096 }
1097 #[repr(C)]
1098 pub struct JET_ENUMCOLUMN_0_0 {
1099     pub cEnumColumnValue: u32,
1100     pub rgEnumColumnValue: *mut JET_ENUMCOLUMNVALUE,
1101 }
1102 impl ::core::marker::Copy for JET_ENUMCOLUMN_0_0 {}
1103 impl ::core::clone::Clone for JET_ENUMCOLUMN_0_0 {
1104     fn clone(&self) -> Self {
1105         *self
1106     }
1107 }
1108 #[repr(C)]
1109 pub struct JET_ENUMCOLUMN_0_1 {
1110     pub cbData: u32,
1111     pub pvData: *mut ::core::ffi::c_void,
1112 }
1113 impl ::core::marker::Copy for JET_ENUMCOLUMN_0_1 {}
1114 impl ::core::clone::Clone for JET_ENUMCOLUMN_0_1 {
1115     fn clone(&self) -> Self {
1116         *self
1117     }
1118 }
1119 #[repr(C)]
1120 pub struct JET_ENUMCOLUMNID {
1121     pub columnid: u32,
1122     pub ctagSequence: u32,
1123     pub rgtagSequence: *mut u32,
1124 }
1125 impl ::core::marker::Copy for JET_ENUMCOLUMNID {}
1126 impl ::core::clone::Clone for JET_ENUMCOLUMNID {
1127     fn clone(&self) -> Self {
1128         *self
1129     }
1130 }
1131 #[repr(C)]
1132 pub struct JET_ENUMCOLUMNVALUE {
1133     pub itagSequence: u32,
1134     pub err: i32,
1135     pub cbData: u32,
1136     pub pvData: *mut ::core::ffi::c_void,
1137 }
1138 impl ::core::marker::Copy for JET_ENUMCOLUMNVALUE {}
1139 impl ::core::clone::Clone for JET_ENUMCOLUMNVALUE {
1140     fn clone(&self) -> Self {
1141         *self
1142     }
1143 }
1144 pub type JET_ERRCAT = i32;
1145 pub const JET_errcatUnknown: JET_ERRCAT = 0i32;
1146 pub const JET_errcatError: JET_ERRCAT = 1i32;
1147 pub const JET_errcatOperation: JET_ERRCAT = 2i32;
1148 pub const JET_errcatFatal: JET_ERRCAT = 3i32;
1149 pub const JET_errcatIO: JET_ERRCAT = 4i32;
1150 pub const JET_errcatResource: JET_ERRCAT = 5i32;
1151 pub const JET_errcatMemory: JET_ERRCAT = 6i32;
1152 pub const JET_errcatQuota: JET_ERRCAT = 7i32;
1153 pub const JET_errcatDisk: JET_ERRCAT = 8i32;
1154 pub const JET_errcatData: JET_ERRCAT = 9i32;
1155 pub const JET_errcatCorruption: JET_ERRCAT = 10i32;
1156 pub const JET_errcatInconsistent: JET_ERRCAT = 11i32;
1157 pub const JET_errcatFragmentation: JET_ERRCAT = 12i32;
1158 pub const JET_errcatApi: JET_ERRCAT = 13i32;
1159 pub const JET_errcatUsage: JET_ERRCAT = 14i32;
1160 pub const JET_errcatState: JET_ERRCAT = 15i32;
1161 pub const JET_errcatObsolete: JET_ERRCAT = 16i32;
1162 pub const JET_errcatMax: JET_ERRCAT = 17i32;
1163 #[repr(C)]
1164 pub struct JET_ERRINFOBASIC_W {
1165     pub cbStruct: u32,
1166     pub errValue: i32,
1167     pub errcatMostSpecific: JET_ERRCAT,
1168     pub rgCategoricalHierarchy: [u8; 8],
1169     pub lSourceLine: u32,
1170     pub rgszSourceFile: [u16; 64],
1171 }
1172 impl ::core::marker::Copy for JET_ERRINFOBASIC_W {}
1173 impl ::core::clone::Clone for JET_ERRINFOBASIC_W {
1174     fn clone(&self) -> Self {
1175         *self
1176     }
1177 }
1178 pub const JET_EventLoggingDisable: u32 = 0u32;
1179 pub const JET_EventLoggingLevelHigh: u32 = 75u32;
1180 pub const JET_EventLoggingLevelLow: u32 = 25u32;
1181 pub const JET_EventLoggingLevelMax: u32 = 100u32;
1182 pub const JET_EventLoggingLevelMedium: u32 = 50u32;
1183 pub const JET_EventLoggingLevelMin: u32 = 1u32;
1184 pub const JET_ExceptionFailFast: u32 = 4u32;
1185 pub const JET_ExceptionMsgBox: u32 = 1u32;
1186 pub const JET_ExceptionNone: u32 = 2u32;
1187 pub type JET_INDEXCHECKING = i32;
1188 pub const JET_IndexCheckingOff: JET_INDEXCHECKING = 0i32;
1189 pub const JET_IndexCheckingOn: JET_INDEXCHECKING = 1i32;
1190 pub const JET_IndexCheckingDeferToOpenTable: JET_INDEXCHECKING = 2i32;
1191 pub const JET_IndexCheckingMax: JET_INDEXCHECKING = 3i32;
1192 #[repr(C)]
1193 #[cfg(feature = "Win32_Foundation")]
1194 pub struct JET_INDEXCREATE2_A {
1195     pub cbStruct: u32,
1196     pub szIndexName: super::super::Foundation::PSTR,
1197     pub szKey: super::super::Foundation::PSTR,
1198     pub cbKey: u32,
1199     pub grbit: u32,
1200     pub ulDensity: u32,
1201     pub Anonymous1: JET_INDEXCREATE2_A_0,
1202     pub Anonymous2: JET_INDEXCREATE2_A_1,
1203     pub rgconditionalcolumn: *mut JET_CONDITIONALCOLUMN_A,
1204     pub cConditionalColumn: u32,
1205     pub err: i32,
1206     pub cbKeyMost: u32,
1207     pub pSpacehints: *mut JET_SPACEHINTS,
1208 }
1209 #[cfg(feature = "Win32_Foundation")]
1210 impl ::core::marker::Copy for JET_INDEXCREATE2_A {}
1211 #[cfg(feature = "Win32_Foundation")]
1212 impl ::core::clone::Clone for JET_INDEXCREATE2_A {
1213     fn clone(&self) -> Self {
1214         *self
1215     }
1216 }
1217 #[repr(C)]
1218 #[cfg(feature = "Win32_Foundation")]
1219 pub union JET_INDEXCREATE2_A_0 {
1220     pub lcid: u32,
1221     pub pidxunicode: *mut JET_UNICODEINDEX,
1222 }
1223 #[cfg(feature = "Win32_Foundation")]
1224 impl ::core::marker::Copy for JET_INDEXCREATE2_A_0 {}
1225 #[cfg(feature = "Win32_Foundation")]
1226 impl ::core::clone::Clone for JET_INDEXCREATE2_A_0 {
1227     fn clone(&self) -> Self {
1228         *self
1229     }
1230 }
1231 #[repr(C)]
1232 #[cfg(feature = "Win32_Foundation")]
1233 pub union JET_INDEXCREATE2_A_1 {
1234     pub cbVarSegMac: u32,
1235     pub ptuplelimits: *mut JET_TUPLELIMITS,
1236 }
1237 #[cfg(feature = "Win32_Foundation")]
1238 impl ::core::marker::Copy for JET_INDEXCREATE2_A_1 {}
1239 #[cfg(feature = "Win32_Foundation")]
1240 impl ::core::clone::Clone for JET_INDEXCREATE2_A_1 {
1241     fn clone(&self) -> Self {
1242         *self
1243     }
1244 }
1245 #[repr(C)]
1246 #[cfg(feature = "Win32_Foundation")]
1247 pub struct JET_INDEXCREATE2_W {
1248     pub cbStruct: u32,
1249     pub szIndexName: super::super::Foundation::PWSTR,
1250     pub szKey: super::super::Foundation::PWSTR,
1251     pub cbKey: u32,
1252     pub grbit: u32,
1253     pub ulDensity: u32,
1254     pub Anonymous1: JET_INDEXCREATE2_W_0,
1255     pub Anonymous2: JET_INDEXCREATE2_W_1,
1256     pub rgconditionalcolumn: *mut JET_CONDITIONALCOLUMN_W,
1257     pub cConditionalColumn: u32,
1258     pub err: i32,
1259     pub cbKeyMost: u32,
1260     pub pSpacehints: *mut JET_SPACEHINTS,
1261 }
1262 #[cfg(feature = "Win32_Foundation")]
1263 impl ::core::marker::Copy for JET_INDEXCREATE2_W {}
1264 #[cfg(feature = "Win32_Foundation")]
1265 impl ::core::clone::Clone for JET_INDEXCREATE2_W {
1266     fn clone(&self) -> Self {
1267         *self
1268     }
1269 }
1270 #[repr(C)]
1271 #[cfg(feature = "Win32_Foundation")]
1272 pub union JET_INDEXCREATE2_W_0 {
1273     pub lcid: u32,
1274     pub pidxunicode: *mut JET_UNICODEINDEX,
1275 }
1276 #[cfg(feature = "Win32_Foundation")]
1277 impl ::core::marker::Copy for JET_INDEXCREATE2_W_0 {}
1278 #[cfg(feature = "Win32_Foundation")]
1279 impl ::core::clone::Clone for JET_INDEXCREATE2_W_0 {
1280     fn clone(&self) -> Self {
1281         *self
1282     }
1283 }
1284 #[repr(C)]
1285 #[cfg(feature = "Win32_Foundation")]
1286 pub union JET_INDEXCREATE2_W_1 {
1287     pub cbVarSegMac: u32,
1288     pub ptuplelimits: *mut JET_TUPLELIMITS,
1289 }
1290 #[cfg(feature = "Win32_Foundation")]
1291 impl ::core::marker::Copy for JET_INDEXCREATE2_W_1 {}
1292 #[cfg(feature = "Win32_Foundation")]
1293 impl ::core::clone::Clone for JET_INDEXCREATE2_W_1 {
1294     fn clone(&self) -> Self {
1295         *self
1296     }
1297 }
1298 #[repr(C)]
1299 #[cfg(feature = "Win32_Foundation")]
1300 pub struct JET_INDEXCREATE3_A {
1301     pub cbStruct: u32,
1302     pub szIndexName: super::super::Foundation::PSTR,
1303     pub szKey: super::super::Foundation::PSTR,
1304     pub cbKey: u32,
1305     pub grbit: u32,
1306     pub ulDensity: u32,
1307     pub pidxunicode: *mut JET_UNICODEINDEX2,
1308     pub Anonymous: JET_INDEXCREATE3_A_0,
1309     pub rgconditionalcolumn: *mut JET_CONDITIONALCOLUMN_A,
1310     pub cConditionalColumn: u32,
1311     pub err: i32,
1312     pub cbKeyMost: u32,
1313     pub pSpacehints: *mut JET_SPACEHINTS,
1314 }
1315 #[cfg(feature = "Win32_Foundation")]
1316 impl ::core::marker::Copy for JET_INDEXCREATE3_A {}
1317 #[cfg(feature = "Win32_Foundation")]
1318 impl ::core::clone::Clone for JET_INDEXCREATE3_A {
1319     fn clone(&self) -> Self {
1320         *self
1321     }
1322 }
1323 #[repr(C)]
1324 #[cfg(feature = "Win32_Foundation")]
1325 pub union JET_INDEXCREATE3_A_0 {
1326     pub cbVarSegMac: u32,
1327     pub ptuplelimits: *mut JET_TUPLELIMITS,
1328 }
1329 #[cfg(feature = "Win32_Foundation")]
1330 impl ::core::marker::Copy for JET_INDEXCREATE3_A_0 {}
1331 #[cfg(feature = "Win32_Foundation")]
1332 impl ::core::clone::Clone for JET_INDEXCREATE3_A_0 {
1333     fn clone(&self) -> Self {
1334         *self
1335     }
1336 }
1337 #[repr(C)]
1338 #[cfg(feature = "Win32_Foundation")]
1339 pub struct JET_INDEXCREATE3_W {
1340     pub cbStruct: u32,
1341     pub szIndexName: super::super::Foundation::PWSTR,
1342     pub szKey: super::super::Foundation::PWSTR,
1343     pub cbKey: u32,
1344     pub grbit: u32,
1345     pub ulDensity: u32,
1346     pub pidxunicode: *mut JET_UNICODEINDEX2,
1347     pub Anonymous: JET_INDEXCREATE3_W_0,
1348     pub rgconditionalcolumn: *mut JET_CONDITIONALCOLUMN_W,
1349     pub cConditionalColumn: u32,
1350     pub err: i32,
1351     pub cbKeyMost: u32,
1352     pub pSpacehints: *mut JET_SPACEHINTS,
1353 }
1354 #[cfg(feature = "Win32_Foundation")]
1355 impl ::core::marker::Copy for JET_INDEXCREATE3_W {}
1356 #[cfg(feature = "Win32_Foundation")]
1357 impl ::core::clone::Clone for JET_INDEXCREATE3_W {
1358     fn clone(&self) -> Self {
1359         *self
1360     }
1361 }
1362 #[repr(C)]
1363 #[cfg(feature = "Win32_Foundation")]
1364 pub union JET_INDEXCREATE3_W_0 {
1365     pub cbVarSegMac: u32,
1366     pub ptuplelimits: *mut JET_TUPLELIMITS,
1367 }
1368 #[cfg(feature = "Win32_Foundation")]
1369 impl ::core::marker::Copy for JET_INDEXCREATE3_W_0 {}
1370 #[cfg(feature = "Win32_Foundation")]
1371 impl ::core::clone::Clone for JET_INDEXCREATE3_W_0 {
1372     fn clone(&self) -> Self {
1373         *self
1374     }
1375 }
1376 #[repr(C)]
1377 #[cfg(feature = "Win32_Foundation")]
1378 pub struct JET_INDEXCREATE_A {
1379     pub cbStruct: u32,
1380     pub szIndexName: super::super::Foundation::PSTR,
1381     pub szKey: super::super::Foundation::PSTR,
1382     pub cbKey: u32,
1383     pub grbit: u32,
1384     pub ulDensity: u32,
1385     pub Anonymous1: JET_INDEXCREATE_A_0,
1386     pub Anonymous2: JET_INDEXCREATE_A_1,
1387     pub rgconditionalcolumn: *mut JET_CONDITIONALCOLUMN_A,
1388     pub cConditionalColumn: u32,
1389     pub err: i32,
1390     pub cbKeyMost: u32,
1391 }
1392 #[cfg(feature = "Win32_Foundation")]
1393 impl ::core::marker::Copy for JET_INDEXCREATE_A {}
1394 #[cfg(feature = "Win32_Foundation")]
1395 impl ::core::clone::Clone for JET_INDEXCREATE_A {
1396     fn clone(&self) -> Self {
1397         *self
1398     }
1399 }
1400 #[repr(C)]
1401 #[cfg(feature = "Win32_Foundation")]
1402 pub union JET_INDEXCREATE_A_0 {
1403     pub lcid: u32,
1404     pub pidxunicode: *mut JET_UNICODEINDEX,
1405 }
1406 #[cfg(feature = "Win32_Foundation")]
1407 impl ::core::marker::Copy for JET_INDEXCREATE_A_0 {}
1408 #[cfg(feature = "Win32_Foundation")]
1409 impl ::core::clone::Clone for JET_INDEXCREATE_A_0 {
1410     fn clone(&self) -> Self {
1411         *self
1412     }
1413 }
1414 #[repr(C)]
1415 #[cfg(feature = "Win32_Foundation")]
1416 pub union JET_INDEXCREATE_A_1 {
1417     pub cbVarSegMac: u32,
1418     pub ptuplelimits: *mut JET_TUPLELIMITS,
1419 }
1420 #[cfg(feature = "Win32_Foundation")]
1421 impl ::core::marker::Copy for JET_INDEXCREATE_A_1 {}
1422 #[cfg(feature = "Win32_Foundation")]
1423 impl ::core::clone::Clone for JET_INDEXCREATE_A_1 {
1424     fn clone(&self) -> Self {
1425         *self
1426     }
1427 }
1428 #[repr(C)]
1429 #[cfg(feature = "Win32_Foundation")]
1430 pub struct JET_INDEXCREATE_W {
1431     pub cbStruct: u32,
1432     pub szIndexName: super::super::Foundation::PWSTR,
1433     pub szKey: super::super::Foundation::PWSTR,
1434     pub cbKey: u32,
1435     pub grbit: u32,
1436     pub ulDensity: u32,
1437     pub Anonymous1: JET_INDEXCREATE_W_0,
1438     pub Anonymous2: JET_INDEXCREATE_W_1,
1439     pub rgconditionalcolumn: *mut JET_CONDITIONALCOLUMN_W,
1440     pub cConditionalColumn: u32,
1441     pub err: i32,
1442     pub cbKeyMost: u32,
1443 }
1444 #[cfg(feature = "Win32_Foundation")]
1445 impl ::core::marker::Copy for JET_INDEXCREATE_W {}
1446 #[cfg(feature = "Win32_Foundation")]
1447 impl ::core::clone::Clone for JET_INDEXCREATE_W {
1448     fn clone(&self) -> Self {
1449         *self
1450     }
1451 }
1452 #[repr(C)]
1453 #[cfg(feature = "Win32_Foundation")]
1454 pub union JET_INDEXCREATE_W_0 {
1455     pub lcid: u32,
1456     pub pidxunicode: *mut JET_UNICODEINDEX,
1457 }
1458 #[cfg(feature = "Win32_Foundation")]
1459 impl ::core::marker::Copy for JET_INDEXCREATE_W_0 {}
1460 #[cfg(feature = "Win32_Foundation")]
1461 impl ::core::clone::Clone for JET_INDEXCREATE_W_0 {
1462     fn clone(&self) -> Self {
1463         *self
1464     }
1465 }
1466 #[repr(C)]
1467 #[cfg(feature = "Win32_Foundation")]
1468 pub union JET_INDEXCREATE_W_1 {
1469     pub cbVarSegMac: u32,
1470     pub ptuplelimits: *mut JET_TUPLELIMITS,
1471 }
1472 #[cfg(feature = "Win32_Foundation")]
1473 impl ::core::marker::Copy for JET_INDEXCREATE_W_1 {}
1474 #[cfg(feature = "Win32_Foundation")]
1475 impl ::core::clone::Clone for JET_INDEXCREATE_W_1 {
1476     fn clone(&self) -> Self {
1477         *self
1478     }
1479 }
1480 #[repr(C)]
1481 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1482 pub struct JET_INDEXID {
1483     pub cbStruct: u32,
1484     pub rgbIndexId: [u8; 16],
1485 }
1486 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1487 impl ::core::marker::Copy for JET_INDEXID {}
1488 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1489 impl ::core::clone::Clone for JET_INDEXID {
1490     fn clone(&self) -> Self {
1491         *self
1492     }
1493 }
1494 #[repr(C)]
1495 #[cfg(any(target_arch = "x86",))]
1496 pub struct JET_INDEXID {
1497     pub cbStruct: u32,
1498     pub rgbIndexId: [u8; 12],
1499 }
1500 #[cfg(any(target_arch = "x86",))]
1501 impl ::core::marker::Copy for JET_INDEXID {}
1502 #[cfg(any(target_arch = "x86",))]
1503 impl ::core::clone::Clone for JET_INDEXID {
1504     fn clone(&self) -> Self {
1505         *self
1506     }
1507 }
1508 #[repr(C)]
1509 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1510 pub struct JET_INDEXLIST {
1511     pub cbStruct: u32,
1512     pub tableid: super::StructuredStorage::JET_TABLEID,
1513     pub cRecord: u32,
1514     pub columnidindexname: u32,
1515     pub columnidgrbitIndex: u32,
1516     pub columnidcKey: u32,
1517     pub columnidcEntry: u32,
1518     pub columnidcPage: u32,
1519     pub columnidcColumn: u32,
1520     pub columnidiColumn: u32,
1521     pub columnidcolumnid: u32,
1522     pub columnidcoltyp: u32,
1523     pub columnidCountry: u32,
1524     pub columnidLangid: u32,
1525     pub columnidCp: u32,
1526     pub columnidCollate: u32,
1527     pub columnidgrbitColumn: u32,
1528     pub columnidcolumnname: u32,
1529     pub columnidLCMapFlags: u32,
1530 }
1531 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1532 impl ::core::marker::Copy for JET_INDEXLIST {}
1533 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1534 impl ::core::clone::Clone for JET_INDEXLIST {
1535     fn clone(&self) -> Self {
1536         *self
1537     }
1538 }
1539 #[repr(C)]
1540 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1541 pub struct JET_INDEXRANGE {
1542     pub cbStruct: u32,
1543     pub tableid: super::StructuredStorage::JET_TABLEID,
1544     pub grbit: u32,
1545 }
1546 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1547 impl ::core::marker::Copy for JET_INDEXRANGE {}
1548 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1549 impl ::core::clone::Clone for JET_INDEXRANGE {
1550     fn clone(&self) -> Self {
1551         *self
1552     }
1553 }
1554 #[repr(C)]
1555 pub struct JET_INDEX_COLUMN {
1556     pub columnid: u32,
1557     pub relop: JET_RELOP,
1558     pub pv: *mut ::core::ffi::c_void,
1559     pub cb: u32,
1560     pub grbit: u32,
1561 }
1562 impl ::core::marker::Copy for JET_INDEX_COLUMN {}
1563 impl ::core::clone::Clone for JET_INDEX_COLUMN {
1564     fn clone(&self) -> Self {
1565         *self
1566     }
1567 }
1568 #[repr(C)]
1569 pub struct JET_INDEX_RANGE {
1570     pub rgStartColumns: *mut JET_INDEX_COLUMN,
1571     pub cStartColumns: u32,
1572     pub rgEndColumns: *mut JET_INDEX_COLUMN,
1573     pub cEndColumns: u32,
1574 }
1575 impl ::core::marker::Copy for JET_INDEX_RANGE {}
1576 impl ::core::clone::Clone for JET_INDEX_RANGE {
1577     fn clone(&self) -> Self {
1578         *self
1579     }
1580 }
1581 #[repr(C)]
1582 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
1583 pub struct JET_INSTANCE_INFO_A {
1584     pub hInstanceId: super::StructuredStorage::JET_INSTANCE,
1585     pub szInstanceName: super::super::Foundation::PSTR,
1586     pub cDatabases: super::StructuredStorage::JET_API_PTR,
1587     pub szDatabaseFileName: *mut *mut i8,
1588     pub szDatabaseDisplayName: *mut *mut i8,
1589     pub szDatabaseSLVFileName_Obsolete: *mut *mut i8,
1590 }
1591 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
1592 impl ::core::marker::Copy for JET_INSTANCE_INFO_A {}
1593 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
1594 impl ::core::clone::Clone for JET_INSTANCE_INFO_A {
1595     fn clone(&self) -> Self {
1596         *self
1597     }
1598 }
1599 #[repr(C)]
1600 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
1601 pub struct JET_INSTANCE_INFO_W {
1602     pub hInstanceId: super::StructuredStorage::JET_INSTANCE,
1603     pub szInstanceName: super::super::Foundation::PWSTR,
1604     pub cDatabases: super::StructuredStorage::JET_API_PTR,
1605     pub szDatabaseFileName: *mut *mut u16,
1606     pub szDatabaseDisplayName: *mut *mut u16,
1607     pub szDatabaseSLVFileName_Obsolete: *mut *mut u16,
1608 }
1609 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
1610 impl ::core::marker::Copy for JET_INSTANCE_INFO_W {}
1611 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
1612 impl ::core::clone::Clone for JET_INSTANCE_INFO_W {
1613     fn clone(&self) -> Self {
1614         *self
1615     }
1616 }
1617 pub const JET_IOPriorityLow: u32 = 1u32;
1618 pub const JET_IOPriorityNormal: u32 = 0u32;
1619 #[repr(C, packed(1))]
1620 pub struct JET_LGPOS {
1621     pub ib: u16,
1622     pub isec: u16,
1623     pub lGeneration: i32,
1624 }
1625 impl ::core::marker::Copy for JET_LGPOS {}
1626 impl ::core::clone::Clone for JET_LGPOS {
1627     fn clone(&self) -> Self {
1628         *self
1629     }
1630 }
1631 #[repr(C)]
1632 #[cfg(feature = "Win32_Foundation")]
1633 pub struct JET_LOGINFO_A {
1634     pub cbSize: u32,
1635     pub ulGenLow: u32,
1636     pub ulGenHigh: u32,
1637     pub szBaseName: [super::super::Foundation::CHAR; 4],
1638 }
1639 #[cfg(feature = "Win32_Foundation")]
1640 impl ::core::marker::Copy for JET_LOGINFO_A {}
1641 #[cfg(feature = "Win32_Foundation")]
1642 impl ::core::clone::Clone for JET_LOGINFO_A {
1643     fn clone(&self) -> Self {
1644         *self
1645     }
1646 }
1647 #[repr(C)]
1648 pub struct JET_LOGINFO_W {
1649     pub cbSize: u32,
1650     pub ulGenLow: u32,
1651     pub ulGenHigh: u32,
1652     pub szBaseName: [u16; 4],
1653 }
1654 impl ::core::marker::Copy for JET_LOGINFO_W {}
1655 impl ::core::clone::Clone for JET_LOGINFO_W {
1656     fn clone(&self) -> Self {
1657         *self
1658     }
1659 }
1660 #[repr(C)]
1661 #[cfg(feature = "Win32_Foundation")]
1662 pub struct JET_LOGTIME {
1663     pub bSeconds: super::super::Foundation::CHAR,
1664     pub bMinutes: super::super::Foundation::CHAR,
1665     pub bHours: super::super::Foundation::CHAR,
1666     pub bDay: super::super::Foundation::CHAR,
1667     pub bMonth: super::super::Foundation::CHAR,
1668     pub bYear: super::super::Foundation::CHAR,
1669     pub Anonymous1: JET_LOGTIME_0,
1670     pub Anonymous2: JET_LOGTIME_1,
1671 }
1672 #[cfg(feature = "Win32_Foundation")]
1673 impl ::core::marker::Copy for JET_LOGTIME {}
1674 #[cfg(feature = "Win32_Foundation")]
1675 impl ::core::clone::Clone for JET_LOGTIME {
1676     fn clone(&self) -> Self {
1677         *self
1678     }
1679 }
1680 #[repr(C)]
1681 #[cfg(feature = "Win32_Foundation")]
1682 pub union JET_LOGTIME_0 {
1683     pub bFiller1: super::super::Foundation::CHAR,
1684     pub Anonymous: JET_LOGTIME_0_0,
1685 }
1686 #[cfg(feature = "Win32_Foundation")]
1687 impl ::core::marker::Copy for JET_LOGTIME_0 {}
1688 #[cfg(feature = "Win32_Foundation")]
1689 impl ::core::clone::Clone for JET_LOGTIME_0 {
1690     fn clone(&self) -> Self {
1691         *self
1692     }
1693 }
1694 #[repr(C)]
1695 #[cfg(feature = "Win32_Foundation")]
1696 pub struct JET_LOGTIME_0_0 {
1697     pub _bitfield: u8,
1698 }
1699 #[cfg(feature = "Win32_Foundation")]
1700 impl ::core::marker::Copy for JET_LOGTIME_0_0 {}
1701 #[cfg(feature = "Win32_Foundation")]
1702 impl ::core::clone::Clone for JET_LOGTIME_0_0 {
1703     fn clone(&self) -> Self {
1704         *self
1705     }
1706 }
1707 #[repr(C)]
1708 #[cfg(feature = "Win32_Foundation")]
1709 pub union JET_LOGTIME_1 {
1710     pub bFiller2: super::super::Foundation::CHAR,
1711     pub Anonymous: JET_LOGTIME_1_0,
1712 }
1713 #[cfg(feature = "Win32_Foundation")]
1714 impl ::core::marker::Copy for JET_LOGTIME_1 {}
1715 #[cfg(feature = "Win32_Foundation")]
1716 impl ::core::clone::Clone for JET_LOGTIME_1 {
1717     fn clone(&self) -> Self {
1718         *self
1719     }
1720 }
1721 #[repr(C)]
1722 #[cfg(feature = "Win32_Foundation")]
1723 pub struct JET_LOGTIME_1_0 {
1724     pub _bitfield: u8,
1725 }
1726 #[cfg(feature = "Win32_Foundation")]
1727 impl ::core::marker::Copy for JET_LOGTIME_1_0 {}
1728 #[cfg(feature = "Win32_Foundation")]
1729 impl ::core::clone::Clone for JET_LOGTIME_1_0 {
1730     fn clone(&self) -> Self {
1731         *self
1732     }
1733 }
1734 pub type JET_LS = usize;
1735 pub const JET_MAX_COMPUTERNAME_LENGTH: u32 = 15u32;
1736 pub const JET_MoveFirst: u32 = 2147483648u32;
1737 pub const JET_MoveLast: u32 = 2147483647u32;
1738 pub const JET_MovePrevious: i32 = -1i32;
1739 #[repr(C)]
1740 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1741 pub struct JET_OBJECTINFO {
1742     pub cbStruct: u32,
1743     pub objtyp: u32,
1744     pub dtCreate: f64,
1745     pub dtUpdate: f64,
1746     pub grbit: u32,
1747     pub flags: u32,
1748     pub cRecord: u32,
1749     pub cPage: u32,
1750 }
1751 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1752 impl ::core::marker::Copy for JET_OBJECTINFO {}
1753 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1754 impl ::core::clone::Clone for JET_OBJECTINFO {
1755     fn clone(&self) -> Self {
1756         *self
1757     }
1758 }
1759 #[repr(C, packed(4))]
1760 #[cfg(any(target_arch = "x86",))]
1761 pub struct JET_OBJECTINFO {
1762     pub cbStruct: u32,
1763     pub objtyp: u32,
1764     pub dtCreate: f64,
1765     pub dtUpdate: f64,
1766     pub grbit: u32,
1767     pub flags: u32,
1768     pub cRecord: u32,
1769     pub cPage: u32,
1770 }
1771 #[cfg(any(target_arch = "x86",))]
1772 impl ::core::marker::Copy for JET_OBJECTINFO {}
1773 #[cfg(any(target_arch = "x86",))]
1774 impl ::core::clone::Clone for JET_OBJECTINFO {
1775     fn clone(&self) -> Self {
1776         *self
1777     }
1778 }
1779 #[repr(C)]
1780 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1781 pub struct JET_OBJECTLIST {
1782     pub cbStruct: u32,
1783     pub tableid: super::StructuredStorage::JET_TABLEID,
1784     pub cRecord: u32,
1785     pub columnidcontainername: u32,
1786     pub columnidobjectname: u32,
1787     pub columnidobjtyp: u32,
1788     pub columniddtCreate: u32,
1789     pub columniddtUpdate: u32,
1790     pub columnidgrbit: u32,
1791     pub columnidflags: u32,
1792     pub columnidcRecord: u32,
1793     pub columnidcPage: u32,
1794 }
1795 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1796 impl ::core::marker::Copy for JET_OBJECTLIST {}
1797 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1798 impl ::core::clone::Clone for JET_OBJECTLIST {
1799     fn clone(&self) -> Self {
1800         *self
1801     }
1802 }
1803 #[repr(C)]
1804 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1805 pub struct JET_OPENTEMPORARYTABLE {
1806     pub cbStruct: u32,
1807     pub prgcolumndef: *mut JET_COLUMNDEF,
1808     pub ccolumn: u32,
1809     pub pidxunicode: *mut JET_UNICODEINDEX,
1810     pub grbit: u32,
1811     pub prgcolumnid: *mut u32,
1812     pub cbKeyMost: u32,
1813     pub cbVarSegMac: u32,
1814     pub tableid: super::StructuredStorage::JET_TABLEID,
1815 }
1816 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1817 impl ::core::marker::Copy for JET_OPENTEMPORARYTABLE {}
1818 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1819 impl ::core::clone::Clone for JET_OPENTEMPORARYTABLE {
1820     fn clone(&self) -> Self {
1821         *self
1822     }
1823 }
1824 #[repr(C)]
1825 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
1826 pub struct JET_OPENTEMPORARYTABLE2 {
1827     pub cbStruct: u32,
1828     pub prgcolumndef: *mut JET_COLUMNDEF,
1829     pub ccolumn: u32,
1830     pub pidxunicode: *mut JET_UNICODEINDEX2,
1831     pub grbit: u32,
1832     pub prgcolumnid: *mut u32,
1833     pub cbKeyMost: u32,
1834     pub cbVarSegMac: u32,
1835     pub tableid: super::StructuredStorage::JET_TABLEID,
1836 }
1837 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
1838 impl ::core::marker::Copy for JET_OPENTEMPORARYTABLE2 {}
1839 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
1840 impl ::core::clone::Clone for JET_OPENTEMPORARYTABLE2 {
1841     fn clone(&self) -> Self {
1842         *self
1843     }
1844 }
1845 #[repr(C)]
1846 pub struct JET_OPERATIONCONTEXT {
1847     pub ulUserID: u32,
1848     pub nOperationID: u8,
1849     pub nOperationType: u8,
1850     pub nClientType: u8,
1851     pub fFlags: u8,
1852 }
1853 impl ::core::marker::Copy for JET_OPERATIONCONTEXT {}
1854 impl ::core::clone::Clone for JET_OPERATIONCONTEXT {
1855     fn clone(&self) -> Self {
1856         *self
1857     }
1858 }
1859 pub type JET_OSSNAPID = usize;
1860 pub const JET_OnlineDefragAll: u32 = 65535u32;
1861 pub const JET_OnlineDefragAllOBSOLETE: u32 = 1u32;
1862 pub const JET_OnlineDefragDatabases: u32 = 2u32;
1863 pub const JET_OnlineDefragDisable: u32 = 0u32;
1864 pub const JET_OnlineDefragSpaceTrees: u32 = 4u32;
1865 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
1866 pub type JET_PFNDURABLECOMMITCALLBACK = unsafe extern "system" fn(instance: super::StructuredStorage::JET_INSTANCE, pcommitidseen: *const JET_COMMIT_ID, grbit: u32) -> i32;
1867 pub type JET_PFNREALLOC = unsafe extern "system" fn(pvcontext: *const ::core::ffi::c_void, pv: *const ::core::ffi::c_void, cb: u32) -> *mut ::core::ffi::c_void;
1868 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1869 pub type JET_PFNSTATUS = unsafe extern "system" fn(sesid: super::StructuredStorage::JET_SESID, snp: u32, snt: u32, pv: *const ::core::ffi::c_void) -> i32;
1870 #[repr(C)]
1871 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1872 #[cfg(feature = "Win32_Foundation")]
1873 pub struct JET_RBSINFOMISC {
1874     pub lRBSGeneration: i32,
1875     pub logtimeCreate: JET_LOGTIME,
1876     pub logtimeCreatePrevRBS: JET_LOGTIME,
1877     pub ulMajor: u32,
1878     pub ulMinor: u32,
1879     pub cbLogicalFileSize: u64,
1880 }
1881 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1882 #[cfg(feature = "Win32_Foundation")]
1883 impl ::core::marker::Copy for JET_RBSINFOMISC {}
1884 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1885 #[cfg(feature = "Win32_Foundation")]
1886 impl ::core::clone::Clone for JET_RBSINFOMISC {
1887     fn clone(&self) -> Self {
1888         *self
1889     }
1890 }
1891 #[repr(C, packed(4))]
1892 #[cfg(any(target_arch = "x86",))]
1893 #[cfg(feature = "Win32_Foundation")]
1894 pub struct JET_RBSINFOMISC {
1895     pub lRBSGeneration: i32,
1896     pub logtimeCreate: JET_LOGTIME,
1897     pub logtimeCreatePrevRBS: JET_LOGTIME,
1898     pub ulMajor: u32,
1899     pub ulMinor: u32,
1900     pub cbLogicalFileSize: u64,
1901 }
1902 #[cfg(any(target_arch = "x86",))]
1903 #[cfg(feature = "Win32_Foundation")]
1904 impl ::core::marker::Copy for JET_RBSINFOMISC {}
1905 #[cfg(any(target_arch = "x86",))]
1906 #[cfg(feature = "Win32_Foundation")]
1907 impl ::core::clone::Clone for JET_RBSINFOMISC {
1908     fn clone(&self) -> Self {
1909         *self
1910     }
1911 }
1912 #[repr(C)]
1913 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1914 #[cfg(feature = "Win32_Foundation")]
1915 pub struct JET_RBSREVERTINFOMISC {
1916     pub lGenMinRevertStart: i32,
1917     pub lGenMaxRevertStart: i32,
1918     pub lGenMinRevertEnd: i32,
1919     pub lGenMaxRevertEnd: i32,
1920     pub logtimeRevertFrom: JET_LOGTIME,
1921     pub cSecRevert: u64,
1922     pub cPagesReverted: u64,
1923 }
1924 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1925 #[cfg(feature = "Win32_Foundation")]
1926 impl ::core::marker::Copy for JET_RBSREVERTINFOMISC {}
1927 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1928 #[cfg(feature = "Win32_Foundation")]
1929 impl ::core::clone::Clone for JET_RBSREVERTINFOMISC {
1930     fn clone(&self) -> Self {
1931         *self
1932     }
1933 }
1934 #[repr(C, packed(4))]
1935 #[cfg(any(target_arch = "x86",))]
1936 #[cfg(feature = "Win32_Foundation")]
1937 pub struct JET_RBSREVERTINFOMISC {
1938     pub lGenMinRevertStart: i32,
1939     pub lGenMaxRevertStart: i32,
1940     pub lGenMinRevertEnd: i32,
1941     pub lGenMaxRevertEnd: i32,
1942     pub logtimeRevertFrom: JET_LOGTIME,
1943     pub cSecRevert: u64,
1944     pub cPagesReverted: u64,
1945 }
1946 #[cfg(any(target_arch = "x86",))]
1947 #[cfg(feature = "Win32_Foundation")]
1948 impl ::core::marker::Copy for JET_RBSREVERTINFOMISC {}
1949 #[cfg(any(target_arch = "x86",))]
1950 #[cfg(feature = "Win32_Foundation")]
1951 impl ::core::clone::Clone for JET_RBSREVERTINFOMISC {
1952     fn clone(&self) -> Self {
1953         *self
1954     }
1955 }
1956 #[repr(C)]
1957 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1958 pub struct JET_RECORDLIST {
1959     pub cbStruct: u32,
1960     pub tableid: super::StructuredStorage::JET_TABLEID,
1961     pub cRecord: u32,
1962     pub columnidBookmark: u32,
1963 }
1964 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1965 impl ::core::marker::Copy for JET_RECORDLIST {}
1966 #[cfg(feature = "Win32_Storage_StructuredStorage")]
1967 impl ::core::clone::Clone for JET_RECORDLIST {
1968     fn clone(&self) -> Self {
1969         *self
1970     }
1971 }
1972 #[repr(C)]
1973 pub struct JET_RECPOS {
1974     pub cbStruct: u32,
1975     pub centriesLT: u32,
1976     pub centriesInRange: u32,
1977     pub centriesTotal: u32,
1978 }
1979 impl ::core::marker::Copy for JET_RECPOS {}
1980 impl ::core::clone::Clone for JET_RECPOS {
1981     fn clone(&self) -> Self {
1982         *self
1983     }
1984 }
1985 #[repr(C)]
1986 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1987 pub struct JET_RECSIZE {
1988     pub cbData: u64,
1989     pub cbLongValueData: u64,
1990     pub cbOverhead: u64,
1991     pub cbLongValueOverhead: u64,
1992     pub cNonTaggedColumns: u64,
1993     pub cTaggedColumns: u64,
1994     pub cLongValues: u64,
1995     pub cMultiValues: u64,
1996 }
1997 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
1998 impl ::core::marker::Copy for JET_RECSIZE {}
1999 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2000 impl ::core::clone::Clone for JET_RECSIZE {
2001     fn clone(&self) -> Self {
2002         *self
2003     }
2004 }
2005 #[repr(C, packed(4))]
2006 #[cfg(any(target_arch = "x86",))]
2007 pub struct JET_RECSIZE {
2008     pub cbData: u64,
2009     pub cbLongValueData: u64,
2010     pub cbOverhead: u64,
2011     pub cbLongValueOverhead: u64,
2012     pub cNonTaggedColumns: u64,
2013     pub cTaggedColumns: u64,
2014     pub cLongValues: u64,
2015     pub cMultiValues: u64,
2016 }
2017 #[cfg(any(target_arch = "x86",))]
2018 impl ::core::marker::Copy for JET_RECSIZE {}
2019 #[cfg(any(target_arch = "x86",))]
2020 impl ::core::clone::Clone for JET_RECSIZE {
2021     fn clone(&self) -> Self {
2022         *self
2023     }
2024 }
2025 #[repr(C)]
2026 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2027 pub struct JET_RECSIZE2 {
2028     pub cbData: u64,
2029     pub cbLongValueData: u64,
2030     pub cbOverhead: u64,
2031     pub cbLongValueOverhead: u64,
2032     pub cNonTaggedColumns: u64,
2033     pub cTaggedColumns: u64,
2034     pub cLongValues: u64,
2035     pub cMultiValues: u64,
2036     pub cCompressedColumns: u64,
2037     pub cbDataCompressed: u64,
2038     pub cbLongValueDataCompressed: u64,
2039 }
2040 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2041 impl ::core::marker::Copy for JET_RECSIZE2 {}
2042 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2043 impl ::core::clone::Clone for JET_RECSIZE2 {
2044     fn clone(&self) -> Self {
2045         *self
2046     }
2047 }
2048 #[repr(C, packed(4))]
2049 #[cfg(any(target_arch = "x86",))]
2050 pub struct JET_RECSIZE2 {
2051     pub cbData: u64,
2052     pub cbLongValueData: u64,
2053     pub cbOverhead: u64,
2054     pub cbLongValueOverhead: u64,
2055     pub cNonTaggedColumns: u64,
2056     pub cTaggedColumns: u64,
2057     pub cLongValues: u64,
2058     pub cMultiValues: u64,
2059     pub cCompressedColumns: u64,
2060     pub cbDataCompressed: u64,
2061     pub cbLongValueDataCompressed: u64,
2062 }
2063 #[cfg(any(target_arch = "x86",))]
2064 impl ::core::marker::Copy for JET_RECSIZE2 {}
2065 #[cfg(any(target_arch = "x86",))]
2066 impl ::core::clone::Clone for JET_RECSIZE2 {
2067     fn clone(&self) -> Self {
2068         *self
2069     }
2070 }
2071 pub type JET_RELOP = i32;
2072 pub const JET_relopEquals: JET_RELOP = 0i32;
2073 pub const JET_relopPrefixEquals: JET_RELOP = 1i32;
2074 pub const JET_relopNotEquals: JET_RELOP = 2i32;
2075 pub const JET_relopLessThanOrEqual: JET_RELOP = 3i32;
2076 pub const JET_relopLessThan: JET_RELOP = 4i32;
2077 pub const JET_relopGreaterThanOrEqual: JET_RELOP = 5i32;
2078 pub const JET_relopGreaterThan: JET_RELOP = 6i32;
2079 pub const JET_relopBitmaskEqualsZero: JET_RELOP = 7i32;
2080 pub const JET_relopBitmaskNotEqualsZero: JET_RELOP = 8i32;
2081 #[repr(C)]
2082 pub struct JET_RETINFO {
2083     pub cbStruct: u32,
2084     pub ibLongValue: u32,
2085     pub itagSequence: u32,
2086     pub columnidNextTagged: u32,
2087 }
2088 impl ::core::marker::Copy for JET_RETINFO {}
2089 impl ::core::clone::Clone for JET_RETINFO {
2090     fn clone(&self) -> Self {
2091         *self
2092     }
2093 }
2094 #[repr(C)]
2095 pub struct JET_RETRIEVECOLUMN {
2096     pub columnid: u32,
2097     pub pvData: *mut ::core::ffi::c_void,
2098     pub cbData: u32,
2099     pub cbActual: u32,
2100     pub grbit: u32,
2101     pub ibLongValue: u32,
2102     pub itagSequence: u32,
2103     pub columnidNextTagged: u32,
2104     pub err: i32,
2105 }
2106 impl ::core::marker::Copy for JET_RETRIEVECOLUMN {}
2107 impl ::core::clone::Clone for JET_RETRIEVECOLUMN {
2108     fn clone(&self) -> Self {
2109         *self
2110     }
2111 }
2112 #[repr(C)]
2113 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2114 pub struct JET_RSTINFO_A {
2115     pub cbStruct: u32,
2116     pub rgrstmap: *mut JET_RSTMAP_A,
2117     pub crstmap: i32,
2118     pub lgposStop: JET_LGPOS,
2119     pub logtimeStop: JET_LOGTIME,
2120     pub pfnStatus: JET_PFNSTATUS,
2121 }
2122 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2123 impl ::core::marker::Copy for JET_RSTINFO_A {}
2124 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2125 impl ::core::clone::Clone for JET_RSTINFO_A {
2126     fn clone(&self) -> Self {
2127         *self
2128     }
2129 }
2130 #[repr(C)]
2131 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2132 pub struct JET_RSTINFO_W {
2133     pub cbStruct: u32,
2134     pub rgrstmap: *mut JET_RSTMAP_W,
2135     pub crstmap: i32,
2136     pub lgposStop: JET_LGPOS,
2137     pub logtimeStop: JET_LOGTIME,
2138     pub pfnStatus: JET_PFNSTATUS,
2139 }
2140 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2141 impl ::core::marker::Copy for JET_RSTINFO_W {}
2142 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2143 impl ::core::clone::Clone for JET_RSTINFO_W {
2144     fn clone(&self) -> Self {
2145         *self
2146     }
2147 }
2148 #[repr(C)]
2149 #[cfg(feature = "Win32_Foundation")]
2150 pub struct JET_RSTMAP_A {
2151     pub szDatabaseName: super::super::Foundation::PSTR,
2152     pub szNewDatabaseName: super::super::Foundation::PSTR,
2153 }
2154 #[cfg(feature = "Win32_Foundation")]
2155 impl ::core::marker::Copy for JET_RSTMAP_A {}
2156 #[cfg(feature = "Win32_Foundation")]
2157 impl ::core::clone::Clone for JET_RSTMAP_A {
2158     fn clone(&self) -> Self {
2159         *self
2160     }
2161 }
2162 #[repr(C)]
2163 #[cfg(feature = "Win32_Foundation")]
2164 pub struct JET_RSTMAP_W {
2165     pub szDatabaseName: super::super::Foundation::PWSTR,
2166     pub szNewDatabaseName: super::super::Foundation::PWSTR,
2167 }
2168 #[cfg(feature = "Win32_Foundation")]
2169 impl ::core::marker::Copy for JET_RSTMAP_W {}
2170 #[cfg(feature = "Win32_Foundation")]
2171 impl ::core::clone::Clone for JET_RSTMAP_W {
2172     fn clone(&self) -> Self {
2173         *self
2174     }
2175 }
2176 #[repr(C)]
2177 pub struct JET_SETCOLUMN {
2178     pub columnid: u32,
2179     pub pvData: *mut ::core::ffi::c_void,
2180     pub cbData: u32,
2181     pub grbit: u32,
2182     pub ibLongValue: u32,
2183     pub itagSequence: u32,
2184     pub err: i32,
2185 }
2186 impl ::core::marker::Copy for JET_SETCOLUMN {}
2187 impl ::core::clone::Clone for JET_SETCOLUMN {
2188     fn clone(&self) -> Self {
2189         *self
2190     }
2191 }
2192 #[repr(C)]
2193 pub struct JET_SETINFO {
2194     pub cbStruct: u32,
2195     pub ibLongValue: u32,
2196     pub itagSequence: u32,
2197 }
2198 impl ::core::marker::Copy for JET_SETINFO {}
2199 impl ::core::clone::Clone for JET_SETINFO {
2200     fn clone(&self) -> Self {
2201         *self
2202     }
2203 }
2204 #[repr(C)]
2205 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2206 pub struct JET_SETSYSPARAM_A {
2207     pub paramid: u32,
2208     pub lParam: super::StructuredStorage::JET_API_PTR,
2209     pub sz: super::super::Foundation::PSTR,
2210     pub err: i32,
2211 }
2212 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2213 impl ::core::marker::Copy for JET_SETSYSPARAM_A {}
2214 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2215 impl ::core::clone::Clone for JET_SETSYSPARAM_A {
2216     fn clone(&self) -> Self {
2217         *self
2218     }
2219 }
2220 #[repr(C)]
2221 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2222 pub struct JET_SETSYSPARAM_W {
2223     pub paramid: u32,
2224     pub lParam: super::StructuredStorage::JET_API_PTR,
2225     pub sz: super::super::Foundation::PWSTR,
2226     pub err: i32,
2227 }
2228 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2229 impl ::core::marker::Copy for JET_SETSYSPARAM_W {}
2230 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2231 impl ::core::clone::Clone for JET_SETSYSPARAM_W {
2232     fn clone(&self) -> Self {
2233         *self
2234     }
2235 }
2236 #[repr(C, packed(1))]
2237 #[cfg(feature = "Win32_Foundation")]
2238 pub struct JET_SIGNATURE {
2239     pub ulRandom: u32,
2240     pub logtimeCreate: JET_LOGTIME,
2241     pub szComputerName: [super::super::Foundation::CHAR; 16],
2242 }
2243 #[cfg(feature = "Win32_Foundation")]
2244 impl ::core::marker::Copy for JET_SIGNATURE {}
2245 #[cfg(feature = "Win32_Foundation")]
2246 impl ::core::clone::Clone for JET_SIGNATURE {
2247     fn clone(&self) -> Self {
2248         *self
2249     }
2250 }
2251 #[repr(C)]
2252 pub struct JET_SNPROG {
2253     pub cbStruct: u32,
2254     pub cunitDone: u32,
2255     pub cunitTotal: u32,
2256 }
2257 impl ::core::marker::Copy for JET_SNPROG {}
2258 impl ::core::clone::Clone for JET_SNPROG {
2259     fn clone(&self) -> Self {
2260         *self
2261     }
2262 }
2263 #[repr(C)]
2264 pub struct JET_SPACEHINTS {
2265     pub cbStruct: u32,
2266     pub ulInitialDensity: u32,
2267     pub cbInitial: u32,
2268     pub grbit: u32,
2269     pub ulMaintDensity: u32,
2270     pub ulGrowth: u32,
2271     pub cbMinExtent: u32,
2272     pub cbMaxExtent: u32,
2273 }
2274 impl ::core::marker::Copy for JET_SPACEHINTS {}
2275 impl ::core::clone::Clone for JET_SPACEHINTS {
2276     fn clone(&self) -> Self {
2277         *self
2278     }
2279 }
2280 #[repr(C)]
2281 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2282 pub struct JET_TABLECREATE2_A {
2283     pub cbStruct: u32,
2284     pub szTableName: super::super::Foundation::PSTR,
2285     pub szTemplateTableName: super::super::Foundation::PSTR,
2286     pub ulPages: u32,
2287     pub ulDensity: u32,
2288     pub rgcolumncreate: *mut JET_COLUMNCREATE_A,
2289     pub cColumns: u32,
2290     pub rgindexcreate: *mut JET_INDEXCREATE_A,
2291     pub cIndexes: u32,
2292     pub szCallback: super::super::Foundation::PSTR,
2293     pub cbtyp: u32,
2294     pub grbit: u32,
2295     pub tableid: super::StructuredStorage::JET_TABLEID,
2296     pub cCreated: u32,
2297 }
2298 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2299 impl ::core::marker::Copy for JET_TABLECREATE2_A {}
2300 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2301 impl ::core::clone::Clone for JET_TABLECREATE2_A {
2302     fn clone(&self) -> Self {
2303         *self
2304     }
2305 }
2306 #[repr(C)]
2307 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2308 pub struct JET_TABLECREATE2_W {
2309     pub cbStruct: u32,
2310     pub szTableName: super::super::Foundation::PWSTR,
2311     pub szTemplateTableName: super::super::Foundation::PWSTR,
2312     pub ulPages: u32,
2313     pub ulDensity: u32,
2314     pub rgcolumncreate: *mut JET_COLUMNCREATE_W,
2315     pub cColumns: u32,
2316     pub rgindexcreate: *mut JET_INDEXCREATE_W,
2317     pub cIndexes: u32,
2318     pub szCallback: super::super::Foundation::PWSTR,
2319     pub cbtyp: u32,
2320     pub grbit: u32,
2321     pub tableid: super::StructuredStorage::JET_TABLEID,
2322     pub cCreated: u32,
2323 }
2324 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2325 impl ::core::marker::Copy for JET_TABLECREATE2_W {}
2326 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2327 impl ::core::clone::Clone for JET_TABLECREATE2_W {
2328     fn clone(&self) -> Self {
2329         *self
2330     }
2331 }
2332 #[repr(C)]
2333 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2334 pub struct JET_TABLECREATE3_A {
2335     pub cbStruct: u32,
2336     pub szTableName: super::super::Foundation::PSTR,
2337     pub szTemplateTableName: super::super::Foundation::PSTR,
2338     pub ulPages: u32,
2339     pub ulDensity: u32,
2340     pub rgcolumncreate: *mut JET_COLUMNCREATE_A,
2341     pub cColumns: u32,
2342     pub rgindexcreate: *mut JET_INDEXCREATE2_A,
2343     pub cIndexes: u32,
2344     pub szCallback: super::super::Foundation::PSTR,
2345     pub cbtyp: u32,
2346     pub grbit: u32,
2347     pub pSeqSpacehints: *mut JET_SPACEHINTS,
2348     pub pLVSpacehints: *mut JET_SPACEHINTS,
2349     pub cbSeparateLV: u32,
2350     pub tableid: super::StructuredStorage::JET_TABLEID,
2351     pub cCreated: u32,
2352 }
2353 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2354 impl ::core::marker::Copy for JET_TABLECREATE3_A {}
2355 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2356 impl ::core::clone::Clone for JET_TABLECREATE3_A {
2357     fn clone(&self) -> Self {
2358         *self
2359     }
2360 }
2361 #[repr(C)]
2362 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2363 pub struct JET_TABLECREATE3_W {
2364     pub cbStruct: u32,
2365     pub szTableName: super::super::Foundation::PWSTR,
2366     pub szTemplateTableName: super::super::Foundation::PWSTR,
2367     pub ulPages: u32,
2368     pub ulDensity: u32,
2369     pub rgcolumncreate: *mut JET_COLUMNCREATE_W,
2370     pub cColumns: u32,
2371     pub rgindexcreate: *mut JET_INDEXCREATE2_W,
2372     pub cIndexes: u32,
2373     pub szCallback: super::super::Foundation::PWSTR,
2374     pub cbtyp: u32,
2375     pub grbit: u32,
2376     pub pSeqSpacehints: *mut JET_SPACEHINTS,
2377     pub pLVSpacehints: *mut JET_SPACEHINTS,
2378     pub cbSeparateLV: u32,
2379     pub tableid: super::StructuredStorage::JET_TABLEID,
2380     pub cCreated: u32,
2381 }
2382 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2383 impl ::core::marker::Copy for JET_TABLECREATE3_W {}
2384 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2385 impl ::core::clone::Clone for JET_TABLECREATE3_W {
2386     fn clone(&self) -> Self {
2387         *self
2388     }
2389 }
2390 #[repr(C)]
2391 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2392 pub struct JET_TABLECREATE4_A {
2393     pub cbStruct: u32,
2394     pub szTableName: super::super::Foundation::PSTR,
2395     pub szTemplateTableName: super::super::Foundation::PSTR,
2396     pub ulPages: u32,
2397     pub ulDensity: u32,
2398     pub rgcolumncreate: *mut JET_COLUMNCREATE_A,
2399     pub cColumns: u32,
2400     pub rgindexcreate: *mut JET_INDEXCREATE3_A,
2401     pub cIndexes: u32,
2402     pub szCallback: super::super::Foundation::PSTR,
2403     pub cbtyp: u32,
2404     pub grbit: u32,
2405     pub pSeqSpacehints: *mut JET_SPACEHINTS,
2406     pub pLVSpacehints: *mut JET_SPACEHINTS,
2407     pub cbSeparateLV: u32,
2408     pub tableid: super::StructuredStorage::JET_TABLEID,
2409     pub cCreated: u32,
2410 }
2411 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2412 impl ::core::marker::Copy for JET_TABLECREATE4_A {}
2413 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2414 impl ::core::clone::Clone for JET_TABLECREATE4_A {
2415     fn clone(&self) -> Self {
2416         *self
2417     }
2418 }
2419 #[repr(C)]
2420 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2421 pub struct JET_TABLECREATE4_W {
2422     pub cbStruct: u32,
2423     pub szTableName: super::super::Foundation::PWSTR,
2424     pub szTemplateTableName: super::super::Foundation::PWSTR,
2425     pub ulPages: u32,
2426     pub ulDensity: u32,
2427     pub rgcolumncreate: *mut JET_COLUMNCREATE_W,
2428     pub cColumns: u32,
2429     pub rgindexcreate: *mut JET_INDEXCREATE3_W,
2430     pub cIndexes: u32,
2431     pub szCallback: super::super::Foundation::PWSTR,
2432     pub cbtyp: u32,
2433     pub grbit: u32,
2434     pub pSeqSpacehints: *mut JET_SPACEHINTS,
2435     pub pLVSpacehints: *mut JET_SPACEHINTS,
2436     pub cbSeparateLV: u32,
2437     pub tableid: super::StructuredStorage::JET_TABLEID,
2438     pub cCreated: u32,
2439 }
2440 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2441 impl ::core::marker::Copy for JET_TABLECREATE4_W {}
2442 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2443 impl ::core::clone::Clone for JET_TABLECREATE4_W {
2444     fn clone(&self) -> Self {
2445         *self
2446     }
2447 }
2448 #[repr(C)]
2449 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2450 pub struct JET_TABLECREATE_A {
2451     pub cbStruct: u32,
2452     pub szTableName: super::super::Foundation::PSTR,
2453     pub szTemplateTableName: super::super::Foundation::PSTR,
2454     pub ulPages: u32,
2455     pub ulDensity: u32,
2456     pub rgcolumncreate: *mut JET_COLUMNCREATE_A,
2457     pub cColumns: u32,
2458     pub rgindexcreate: *mut JET_INDEXCREATE_A,
2459     pub cIndexes: u32,
2460     pub grbit: u32,
2461     pub tableid: super::StructuredStorage::JET_TABLEID,
2462     pub cCreated: u32,
2463 }
2464 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2465 impl ::core::marker::Copy for JET_TABLECREATE_A {}
2466 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2467 impl ::core::clone::Clone for JET_TABLECREATE_A {
2468     fn clone(&self) -> Self {
2469         *self
2470     }
2471 }
2472 #[repr(C)]
2473 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2474 pub struct JET_TABLECREATE_W {
2475     pub cbStruct: u32,
2476     pub szTableName: super::super::Foundation::PWSTR,
2477     pub szTemplateTableName: super::super::Foundation::PWSTR,
2478     pub ulPages: u32,
2479     pub ulDensity: u32,
2480     pub rgcolumncreate: *mut JET_COLUMNCREATE_W,
2481     pub cColumns: u32,
2482     pub rgindexcreate: *mut JET_INDEXCREATE_W,
2483     pub cIndexes: u32,
2484     pub grbit: u32,
2485     pub tableid: super::StructuredStorage::JET_TABLEID,
2486     pub cCreated: u32,
2487 }
2488 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2489 impl ::core::marker::Copy for JET_TABLECREATE_W {}
2490 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_StructuredStorage"))]
2491 impl ::core::clone::Clone for JET_TABLECREATE_W {
2492     fn clone(&self) -> Self {
2493         *self
2494     }
2495 }
2496 #[repr(C)]
2497 pub struct JET_THREADSTATS {
2498     pub cbStruct: u32,
2499     pub cPageReferenced: u32,
2500     pub cPageRead: u32,
2501     pub cPagePreread: u32,
2502     pub cPageDirtied: u32,
2503     pub cPageRedirtied: u32,
2504     pub cLogRecord: u32,
2505     pub cbLogRecord: u32,
2506 }
2507 impl ::core::marker::Copy for JET_THREADSTATS {}
2508 impl ::core::clone::Clone for JET_THREADSTATS {
2509     fn clone(&self) -> Self {
2510         *self
2511     }
2512 }
2513 #[repr(C)]
2514 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2515 pub struct JET_THREADSTATS2 {
2516     pub cbStruct: u32,
2517     pub cPageReferenced: u32,
2518     pub cPageRead: u32,
2519     pub cPagePreread: u32,
2520     pub cPageDirtied: u32,
2521     pub cPageRedirtied: u32,
2522     pub cLogRecord: u32,
2523     pub cbLogRecord: u32,
2524     pub cusecPageCacheMiss: u64,
2525     pub cPageCacheMiss: u32,
2526 }
2527 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2528 impl ::core::marker::Copy for JET_THREADSTATS2 {}
2529 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2530 impl ::core::clone::Clone for JET_THREADSTATS2 {
2531     fn clone(&self) -> Self {
2532         *self
2533     }
2534 }
2535 #[repr(C, packed(4))]
2536 #[cfg(any(target_arch = "x86",))]
2537 pub struct JET_THREADSTATS2 {
2538     pub cbStruct: u32,
2539     pub cPageReferenced: u32,
2540     pub cPageRead: u32,
2541     pub cPagePreread: u32,
2542     pub cPageDirtied: u32,
2543     pub cPageRedirtied: u32,
2544     pub cLogRecord: u32,
2545     pub cbLogRecord: u32,
2546     pub cusecPageCacheMiss: u64,
2547     pub cPageCacheMiss: u32,
2548 }
2549 #[cfg(any(target_arch = "x86",))]
2550 impl ::core::marker::Copy for JET_THREADSTATS2 {}
2551 #[cfg(any(target_arch = "x86",))]
2552 impl ::core::clone::Clone for JET_THREADSTATS2 {
2553     fn clone(&self) -> Self {
2554         *self
2555     }
2556 }
2557 #[repr(C)]
2558 pub struct JET_TUPLELIMITS {
2559     pub chLengthMin: u32,
2560     pub chLengthMax: u32,
2561     pub chToIndexMax: u32,
2562     pub cchIncrement: u32,
2563     pub ichStart: u32,
2564 }
2565 impl ::core::marker::Copy for JET_TUPLELIMITS {}
2566 impl ::core::clone::Clone for JET_TUPLELIMITS {
2567     fn clone(&self) -> Self {
2568         *self
2569     }
2570 }
2571 #[repr(C)]
2572 pub struct JET_UNICODEINDEX {
2573     pub lcid: u32,
2574     pub dwMapFlags: u32,
2575 }
2576 impl ::core::marker::Copy for JET_UNICODEINDEX {}
2577 impl ::core::clone::Clone for JET_UNICODEINDEX {
2578     fn clone(&self) -> Self {
2579         *self
2580     }
2581 }
2582 #[repr(C)]
2583 #[cfg(feature = "Win32_Foundation")]
2584 pub struct JET_UNICODEINDEX2 {
2585     pub szLocaleName: super::super::Foundation::PWSTR,
2586     pub dwMapFlags: u32,
2587 }
2588 #[cfg(feature = "Win32_Foundation")]
2589 impl ::core::marker::Copy for JET_UNICODEINDEX2 {}
2590 #[cfg(feature = "Win32_Foundation")]
2591 impl ::core::clone::Clone for JET_UNICODEINDEX2 {
2592     fn clone(&self) -> Self {
2593         *self
2594     }
2595 }
2596 #[repr(C)]
2597 #[cfg(feature = "Win32_Foundation")]
2598 pub struct JET_USERDEFINEDDEFAULT_A {
2599     pub szCallback: super::super::Foundation::PSTR,
2600     pub pbUserData: *mut u8,
2601     pub cbUserData: u32,
2602     pub szDependantColumns: super::super::Foundation::PSTR,
2603 }
2604 #[cfg(feature = "Win32_Foundation")]
2605 impl ::core::marker::Copy for JET_USERDEFINEDDEFAULT_A {}
2606 #[cfg(feature = "Win32_Foundation")]
2607 impl ::core::clone::Clone for JET_USERDEFINEDDEFAULT_A {
2608     fn clone(&self) -> Self {
2609         *self
2610     }
2611 }
2612 #[repr(C)]
2613 #[cfg(feature = "Win32_Foundation")]
2614 pub struct JET_USERDEFINEDDEFAULT_W {
2615     pub szCallback: super::super::Foundation::PWSTR,
2616     pub pbUserData: *mut u8,
2617     pub cbUserData: u32,
2618     pub szDependantColumns: super::super::Foundation::PWSTR,
2619 }
2620 #[cfg(feature = "Win32_Foundation")]
2621 impl ::core::marker::Copy for JET_USERDEFINEDDEFAULT_W {}
2622 #[cfg(feature = "Win32_Foundation")]
2623 impl ::core::clone::Clone for JET_USERDEFINEDDEFAULT_W {
2624     fn clone(&self) -> Self {
2625         *self
2626     }
2627 }
2628 pub const JET_bitAbortSnapshot: u32 = 1u32;
2629 pub const JET_bitAllDatabasesSnapshot: u32 = 1u32;
2630 pub const JET_bitBackupAtomic: u32 = 4u32;
2631 pub const JET_bitBackupEndAbort: u32 = 2u32;
2632 pub const JET_bitBackupEndNormal: u32 = 1u32;
2633 pub const JET_bitBackupIncremental: u32 = 1u32;
2634 pub const JET_bitBackupSnapshot: u32 = 16u32;
2635 pub const JET_bitBackupTruncateDone: u32 = 256u32;
2636 pub const JET_bitBookmarkPermitVirtualCurrency: u32 = 1u32;
2637 pub const JET_bitCheckUniqueness: u32 = 64u32;
2638 pub const JET_bitColumnAutoincrement: u32 = 16u32;
2639 pub const JET_bitColumnCompressed: u32 = 524288u32;
2640 pub const JET_bitColumnDeleteOnZero: u32 = 131072u32;
2641 pub const JET_bitColumnEscrowUpdate: u32 = 2048u32;
2642 pub const JET_bitColumnFinalize: u32 = 16384u32;
2643 pub const JET_bitColumnFixed: u32 = 1u32;
2644 pub const JET_bitColumnMaybeNull: u32 = 8192u32;
2645 pub const JET_bitColumnMultiValued: u32 = 1024u32;
2646 pub const JET_bitColumnNotNULL: u32 = 4u32;
2647 pub const JET_bitColumnTTDescending: u32 = 128u32;
2648 pub const JET_bitColumnTTKey: u32 = 64u32;
2649 pub const JET_bitColumnTagged: u32 = 2u32;
2650 pub const JET_bitColumnUnversioned: u32 = 4096u32;
2651 pub const JET_bitColumnUpdatable: u32 = 32u32;
2652 pub const JET_bitColumnUserDefinedDefault: u32 = 32768u32;
2653 pub const JET_bitColumnVersion: u32 = 8u32;
2654 pub const JET_bitCommitLazyFlush: u32 = 1u32;
2655 pub const JET_bitCompactRepair: u32 = 64u32;
2656 pub const JET_bitCompactStats: u32 = 32u32;
2657 pub const JET_bitConfigStoreReadControlDefault: u32 = 0u32;
2658 pub const JET_bitConfigStoreReadControlDisableAll: u32 = 2u32;
2659 pub const JET_bitConfigStoreReadControlInhibitRead: u32 = 1u32;
2660 pub const JET_bitContinueAfterThaw: u32 = 4u32;
2661 pub const JET_bitCopySnapshot: u32 = 2u32;
2662 pub const JET_bitCreateHintAppendSequential: u32 = 2u32;
2663 pub const JET_bitCreateHintHotpointSequential: u32 = 4u32;
2664 pub const JET_bitDbDeleteCorruptIndexes: u32 = 16u32;
2665 pub const JET_bitDbDeleteUnicodeIndexes: u32 = 1024u32;
2666 pub const JET_bitDbEnableBackgroundMaintenance: u32 = 2048u32;
2667 pub const JET_bitDbExclusive: u32 = 2u32;
2668 pub const JET_bitDbOverwriteExisting: u32 = 512u32;
2669 pub const JET_bitDbPurgeCacheOnAttach: u32 = 4096u32;
2670 pub const JET_bitDbReadOnly: u32 = 1u32;
2671 pub const JET_bitDbRecoveryOff: u32 = 8u32;
2672 pub const JET_bitDbShadowingOff: u32 = 128u32;
2673 pub const JET_bitDbUpgrade: u32 = 512u32;
2674 pub const JET_bitDefragmentAvailSpaceTreesOnly: u32 = 64u32;
2675 pub const JET_bitDefragmentBTree: u32 = 256u32;
2676 pub const JET_bitDefragmentBatchStart: u32 = 1u32;
2677 pub const JET_bitDefragmentBatchStop: u32 = 2u32;
2678 pub const JET_bitDefragmentNoPartialMerges: u32 = 128u32;
2679 pub const JET_bitDeleteAllExistingLogs: u32 = 1u32;
2680 pub const JET_bitDeleteColumnIgnoreTemplateColumns: u32 = 1u32;
2681 pub const JET_bitDeleteHintTableSequential: u32 = 256u32;
2682 pub const JET_bitDumpCacheIncludeCachedPages: u32 = 32u32;
2683 pub const JET_bitDumpCacheIncludeCorruptedPages: u32 = 64u32;
2684 pub const JET_bitDumpCacheIncludeDirtyPages: u32 = 16u32;
2685 pub const JET_bitDumpCacheMaximum: u32 = 8u32;
2686 pub const JET_bitDumpCacheMinimum: u32 = 4u32;
2687 pub const JET_bitDumpCacheNoDecommit: u32 = 128u32;
2688 pub const JET_bitDumpMaximum: u32 = 2u32;
2689 pub const JET_bitDumpMinimum: u32 = 1u32;
2690 pub const JET_bitDurableCommitCallbackLogUnavailable: u32 = 1u32;
2691 pub const JET_bitESE98FileNames: u32 = 1u32;
2692 pub const JET_bitEightDotThreeSoftCompat: u32 = 2u32;
2693 pub const JET_bitEnumerateCompressOutput: u32 = 524288u32;
2694 pub const JET_bitEnumerateCopy: u32 = 1u32;
2695 pub const JET_bitEnumerateIgnoreDefault: u32 = 32u32;
2696 pub const JET_bitEnumerateIgnoreUserDefinedDefault: u32 = 1048576u32;
2697 pub const JET_bitEnumerateInRecordOnly: u32 = 2097152u32;
2698 pub const JET_bitEnumeratePresenceOnly: u32 = 131072u32;
2699 pub const JET_bitEnumerateTaggedOnly: u32 = 262144u32;
2700 pub const JET_bitEscrowNoRollback: u32 = 1u32;
2701 pub const JET_bitExplicitPrepare: u32 = 8u32;
2702 pub const JET_bitForceDetach: u32 = 1u32;
2703 pub const JET_bitForceNewLog: u32 = 16u32;
2704 pub const JET_bitFullColumnEndLimit: u32 = 512u32;
2705 pub const JET_bitFullColumnStartLimit: u32 = 256u32;
2706 pub const JET_bitHungIOEvent: u32 = 1u32;
2707 pub const JET_bitIdleCompact: u32 = 2u32;
2708 pub const JET_bitIdleFlushBuffers: u32 = 1u32;
2709 pub const JET_bitIdleStatus: u32 = 4u32;
2710 pub const JET_bitIncrementalSnapshot: u32 = 1u32;
2711 pub const JET_bitIndexColumnMustBeNonNull: u32 = 2u32;
2712 pub const JET_bitIndexColumnMustBeNull: u32 = 1u32;
2713 pub const JET_bitIndexCrossProduct: u32 = 16384u32;
2714 pub const JET_bitIndexDisallowNull: u32 = 4u32;
2715 pub const JET_bitIndexDisallowTruncation: u32 = 65536u32;
2716 pub const JET_bitIndexDotNetGuid: u32 = 262144u32;
2717 pub const JET_bitIndexEmpty: u32 = 256u32;
2718 pub const JET_bitIndexIgnoreAnyNull: u32 = 32u32;
2719 pub const JET_bitIndexIgnoreFirstNull: u32 = 64u32;
2720 pub const JET_bitIndexIgnoreNull: u32 = 8u32;
2721 pub const JET_bitIndexImmutableStructure: u32 = 524288u32;
2722 pub const JET_bitIndexKeyMost: u32 = 32768u32;
2723 pub const JET_bitIndexLazyFlush: u32 = 128u32;
2724 pub const JET_bitIndexNestedTable: u32 = 131072u32;
2725 pub const JET_bitIndexPrimary: u32 = 2u32;
2726 pub const JET_bitIndexSortNullsHigh: u32 = 1024u32;
2727 pub const JET_bitIndexTupleLimits: u32 = 8192u32;
2728 pub const JET_bitIndexTuples: u32 = 4096u32;
2729 pub const JET_bitIndexUnicode: u32 = 2048u32;
2730 pub const JET_bitIndexUnique: u32 = 1u32;
2731 pub const JET_bitIndexUnversioned: u32 = 512u32;
2732 pub const JET_bitKeepDbAttachedAtEndOfRecovery: u32 = 4096u32;
2733 pub const JET_bitKeyAscending: u32 = 0u32;
2734 pub const JET_bitKeyDataZeroLength: u32 = 16u32;
2735 pub const JET_bitKeyDescending: u32 = 1u32;
2736 pub const JET_bitLSCursor: u32 = 2u32;
2737 pub const JET_bitLSReset: u32 = 1u32;
2738 pub const JET_bitLSTable: u32 = 4u32;
2739 pub const JET_bitLogStreamMustExist: u32 = 64u32;
2740 pub const JET_bitMoveFirst: u32 = 0u32;
2741 pub const JET_bitMoveKeyNE: u32 = 1u32;
2742 pub const JET_bitNewKey: u32 = 1u32;
2743 pub const JET_bitNoMove: u32 = 2u32;
2744 pub const JET_bitNormalizedKey: u32 = 8u32;
2745 pub const JET_bitObjectSystem: u32 = 2147483648u32;
2746 pub const JET_bitObjectTableDerived: u32 = 268435456u32;
2747 pub const JET_bitObjectTableFixedDDL: u32 = 1073741824u32;
2748 pub const JET_bitObjectTableNoFixedVarColumnsInDerivedTables: u32 = 67108864u32;
2749 pub const JET_bitObjectTableTemplate: u32 = 536870912u32;
2750 pub const JET_bitPartialColumnEndLimit: u32 = 2048u32;
2751 pub const JET_bitPartialColumnStartLimit: u32 = 1024u32;
2752 pub const JET_bitPrereadBackward: u32 = 2u32;
2753 pub const JET_bitPrereadFirstPage: u32 = 4u32;
2754 pub const JET_bitPrereadForward: u32 = 1u32;
2755 pub const JET_bitPrereadNormalizedKey: u32 = 8u32;
2756 pub const JET_bitRangeInclusive: u32 = 1u32;
2757 pub const JET_bitRangeInstantDuration: u32 = 4u32;
2758 pub const JET_bitRangeRemove: u32 = 8u32;
2759 pub const JET_bitRangeUpperLimit: u32 = 2u32;
2760 pub const JET_bitReadLock: u32 = 1u32;
2761 pub const JET_bitRecordInIndex: u32 = 1u32;
2762 pub const JET_bitRecordNotInIndex: u32 = 2u32;
2763 pub const JET_bitRecordSizeInCopyBuffer: u32 = 1u32;
2764 pub const JET_bitRecordSizeLocal: u32 = 4u32;
2765 pub const JET_bitRecordSizeRunningTotal: u32 = 2u32;
2766 pub const JET_bitRecoveryWithoutUndo: u32 = 8u32;
2767 pub const JET_bitReplayIgnoreLostLogs: u32 = 128u32;
2768 pub const JET_bitReplayIgnoreMissingDB: u32 = 4u32;
2769 pub const JET_bitReplayMissingMapEntryDB: u32 = 32u32;
2770 pub const JET_bitResizeDatabaseOnlyGrow: u32 = 1u32;
2771 pub const JET_bitResizeDatabaseOnlyShrink: u32 = 2u32;
2772 pub const JET_bitRetrieveCopy: u32 = 1u32;
2773 pub const JET_bitRetrieveFromIndex: u32 = 2u32;
2774 pub const JET_bitRetrieveFromPrimaryBookmark: u32 = 4u32;
2775 pub const JET_bitRetrieveHintReserve1: u32 = 8u32;
2776 pub const JET_bitRetrieveHintReserve2: u32 = 64u32;
2777 pub const JET_bitRetrieveHintReserve3: u32 = 128u32;
2778 pub const JET_bitRetrieveHintTableScanBackward: u32 = 32u32;
2779 pub const JET_bitRetrieveHintTableScanForward: u32 = 16u32;
2780 pub const JET_bitRetrieveIgnoreDefault: u32 = 32u32;
2781 pub const JET_bitRetrieveNull: u32 = 16u32;
2782 pub const JET_bitRetrieveTag: u32 = 8u32;
2783 pub const JET_bitRetrieveTuple: u32 = 2048u32;
2784 pub const JET_bitRollbackAll: u32 = 1u32;
2785 pub const JET_bitSeekEQ: u32 = 1u32;
2786 pub const JET_bitSeekGE: u32 = 8u32;
2787 pub const JET_bitSeekGT: u32 = 16u32;
2788 pub const JET_bitSeekLE: u32 = 4u32;
2789 pub const JET_bitSeekLT: u32 = 2u32;
2790 pub const JET_bitSetAppendLV: u32 = 1u32;
2791 pub const JET_bitSetCompressed: u32 = 131072u32;
2792 pub const JET_bitSetContiguousLV: u32 = 262144u32;
2793 pub const JET_bitSetIndexRange: u32 = 32u32;
2794 pub const JET_bitSetIntrinsicLV: u32 = 1024u32;
2795 pub const JET_bitSetOverwriteLV: u32 = 4u32;
2796 pub const JET_bitSetRevertToDefaultValue: u32 = 512u32;
2797 pub const JET_bitSetSeparateLV: u32 = 64u32;
2798 pub const JET_bitSetSizeLV: u32 = 8u32;
2799 pub const JET_bitSetUncompressed: u32 = 65536u32;
2800 pub const JET_bitSetUniqueMultiValues: u32 = 128u32;
2801 pub const JET_bitSetUniqueNormalizedMultiValues: u32 = 256u32;
2802 pub const JET_bitSetZeroLength: u32 = 32u32;
2803 pub const JET_bitShrinkDatabaseOff: u32 = 0u32;
2804 pub const JET_bitShrinkDatabaseOn: u32 = 1u32;
2805 pub const JET_bitShrinkDatabaseRealtime: u32 = 2u32;
2806 pub const JET_bitShrinkDatabaseTrim: u32 = 1u32;
2807 pub const JET_bitSpaceHintsUtilizeParentSpace: u32 = 1u32;
2808 pub const JET_bitStopServiceAll: u32 = 0u32;
2809 pub const JET_bitStopServiceBackgroundUserTasks: u32 = 2u32;
2810 pub const JET_bitStopServiceQuiesceCaches: u32 = 4u32;
2811 pub const JET_bitStopServiceResume: u32 = 2147483648u32;
2812 pub const JET_bitStrLimit: u32 = 2u32;
2813 pub const JET_bitSubStrLimit: u32 = 4u32;
2814 pub const JET_bitTTDotNetGuid: u32 = 256u32;
2815 pub const JET_bitTTErrorOnDuplicateInsertion: u32 = 32u32;
2816 pub const JET_bitTTForceMaterialization: u32 = 32u32;
2817 pub const JET_bitTTForwardOnly: u32 = 64u32;
2818 pub const JET_bitTTIndexed: u32 = 1u32;
2819 pub const JET_bitTTIntrinsicLVsOnly: u32 = 128u32;
2820 pub const JET_bitTTScrollable: u32 = 8u32;
2821 pub const JET_bitTTSortNullsHigh: u32 = 16u32;
2822 pub const JET_bitTTUnique: u32 = 2u32;
2823 pub const JET_bitTTUpdatable: u32 = 4u32;
2824 pub const JET_bitTableClass1: u32 = 65536u32;
2825 pub const JET_bitTableClass10: u32 = 655360u32;
2826 pub const JET_bitTableClass11: u32 = 720896u32;
2827 pub const JET_bitTableClass12: u32 = 786432u32;
2828 pub const JET_bitTableClass13: u32 = 851968u32;
2829 pub const JET_bitTableClass14: u32 = 917504u32;
2830 pub const JET_bitTableClass15: u32 = 983040u32;
2831 pub const JET_bitTableClass2: u32 = 131072u32;
2832 pub const JET_bitTableClass3: u32 = 196608u32;
2833 pub const JET_bitTableClass4: u32 = 262144u32;
2834 pub const JET_bitTableClass5: u32 = 327680u32;
2835 pub const JET_bitTableClass6: u32 = 393216u32;
2836 pub const JET_bitTableClass7: u32 = 458752u32;
2837 pub const JET_bitTableClass8: u32 = 524288u32;
2838 pub const JET_bitTableClass9: u32 = 589824u32;
2839 pub const JET_bitTableClassMask: u32 = 2031616u32;
2840 pub const JET_bitTableClassNone: u32 = 0u32;
2841 pub const JET_bitTableCreateFixedDDL: u32 = 1u32;
2842 pub const JET_bitTableCreateImmutableStructure: u32 = 8u32;
2843 pub const JET_bitTableCreateNoFixedVarColumnsInDerivedTables: u32 = 4u32;
2844 pub const JET_bitTableCreateTemplateTable: u32 = 2u32;
2845 pub const JET_bitTableDenyRead: u32 = 2u32;
2846 pub const JET_bitTableDenyWrite: u32 = 1u32;
2847 pub const JET_bitTableInfoBookmark: u32 = 2u32;
2848 pub const JET_bitTableInfoRollback: u32 = 4u32;
2849 pub const JET_bitTableInfoUpdatable: u32 = 1u32;
2850 pub const JET_bitTableNoCache: u32 = 32u32;
2851 pub const JET_bitTableOpportuneRead: u32 = 128u32;
2852 pub const JET_bitTablePermitDDL: u32 = 16u32;
2853 pub const JET_bitTablePreread: u32 = 64u32;
2854 pub const JET_bitTableReadOnly: u32 = 4u32;
2855 pub const JET_bitTableSequential: u32 = 32768u32;
2856 pub const JET_bitTableUpdatable: u32 = 8u32;
2857 pub const JET_bitTermAbrupt: u32 = 2u32;
2858 pub const JET_bitTermComplete: u32 = 1u32;
2859 pub const JET_bitTermDirty: u32 = 8u32;
2860 pub const JET_bitTermStopBackup: u32 = 4u32;
2861 pub const JET_bitTransactionReadOnly: u32 = 1u32;
2862 pub const JET_bitTruncateLogsAfterRecovery: u32 = 16u32;
2863 pub const JET_bitUpdateCheckESE97Compatibility: u32 = 1u32;
2864 pub const JET_bitWaitAllLevel0Commit: u32 = 8u32;
2865 pub const JET_bitWaitLastLevel0Commit: u32 = 2u32;
2866 pub const JET_bitWriteLock: u32 = 2u32;
2867 pub const JET_bitZeroLength: u32 = 1u32;
2868 pub const JET_cbBookmarkMost: u32 = 256u32;
2869 pub const JET_cbColumnLVPageOverhead: u32 = 82u32;
2870 pub const JET_cbColumnMost: u32 = 255u32;
2871 pub const JET_cbFullNameMost: u32 = 255u32;
2872 pub const JET_cbKeyMost: u32 = 255u32;
2873 pub const JET_cbKeyMost2KBytePage: u32 = 500u32;
2874 pub const JET_cbKeyMost4KBytePage: u32 = 1000u32;
2875 pub const JET_cbKeyMost8KBytePage: u32 = 2000u32;
2876 pub const JET_cbKeyMostMin: u32 = 255u32;
2877 pub const JET_cbLVColumnMost: u32 = 2147483647u32;
2878 pub const JET_cbLVDefaultValueMost: u32 = 255u32;
2879 pub const JET_cbLimitKeyMost: u32 = 256u32;
2880 pub const JET_cbNameMost: u32 = 64u32;
2881 pub const JET_cbPrimaryKeyMost: u32 = 255u32;
2882 pub const JET_cbSecondaryKeyMost: u32 = 255u32;
2883 pub const JET_cbtypAfterDelete: u32 = 64u32;
2884 pub const JET_cbtypAfterInsert: u32 = 4u32;
2885 pub const JET_cbtypAfterReplace: u32 = 16u32;
2886 pub const JET_cbtypBeforeDelete: u32 = 32u32;
2887 pub const JET_cbtypBeforeInsert: u32 = 2u32;
2888 pub const JET_cbtypBeforeReplace: u32 = 8u32;
2889 pub const JET_cbtypFinalize: u32 = 1u32;
2890 pub const JET_cbtypFreeCursorLS: u32 = 512u32;
2891 pub const JET_cbtypFreeTableLS: u32 = 1024u32;
2892 pub const JET_cbtypNull: u32 = 0u32;
2893 pub const JET_cbtypOnlineDefragCompleted: u32 = 256u32;
2894 pub const JET_cbtypUserDefinedDefaultValue: u32 = 128u32;
2895 pub const JET_ccolFixedMost: u32 = 127u32;
2896 pub const JET_ccolKeyMost: u32 = 16u32;
2897 pub const JET_ccolMost: u32 = 65248u32;
2898 pub const JET_ccolVarMost: u32 = 128u32;
2899 pub const JET_coltypBinary: u32 = 9u32;
2900 pub const JET_coltypBit: u32 = 1u32;
2901 pub const JET_coltypCurrency: u32 = 5u32;
2902 pub const JET_coltypDateTime: u32 = 8u32;
2903 pub const JET_coltypGUID: u32 = 16u32;
2904 pub const JET_coltypIEEEDouble: u32 = 7u32;
2905 pub const JET_coltypIEEESingle: u32 = 6u32;
2906 pub const JET_coltypLong: u32 = 4u32;
2907 pub const JET_coltypLongBinary: u32 = 11u32;
2908 pub const JET_coltypLongLong: u32 = 15u32;
2909 pub const JET_coltypLongText: u32 = 12u32;
2910 pub const JET_coltypMax: u32 = 13u32;
2911 pub const JET_coltypNil: u32 = 0u32;
2912 pub const JET_coltypSLV: u32 = 13u32;
2913 pub const JET_coltypShort: u32 = 3u32;
2914 pub const JET_coltypText: u32 = 10u32;
2915 pub const JET_coltypUnsignedByte: u32 = 2u32;
2916 pub const JET_coltypUnsignedLong: u32 = 14u32;
2917 pub const JET_coltypUnsignedLongLong: u32 = 18u32;
2918 pub const JET_coltypUnsignedShort: u32 = 17u32;
2919 pub const JET_configDefault: u32 = 1u32;
2920 pub const JET_configDynamicMediumMemory: u32 = 32u32;
2921 pub const JET_configHighConcurrencyScaling: u32 = 1024u32;
2922 pub const JET_configLowDiskFootprint: u32 = 4u32;
2923 pub const JET_configLowMemory: u32 = 16u32;
2924 pub const JET_configLowPower: u32 = 64u32;
2925 pub const JET_configMediumDiskFootprint: u32 = 8u32;
2926 pub const JET_configRemoveQuotas: u32 = 2u32;
2927 pub const JET_configRunSilent: u32 = 256u32;
2928 pub const JET_configSSDProfileIO: u32 = 128u32;
2929 pub const JET_configUnthrottledMemory: u32 = 512u32;
2930 pub const JET_dbstateBeingConverted: u32 = 4u32;
2931 pub const JET_dbstateCleanShutdown: u32 = 3u32;
2932 pub const JET_dbstateDirtyShutdown: u32 = 2u32;
2933 pub const JET_dbstateForceDetach: u32 = 5u32;
2934 pub const JET_dbstateJustCreated: u32 = 1u32;
2935 pub const JET_errAccessDenied: i32 = -1907i32;
2936 pub const JET_errAfterInitialization: i32 = -1850i32;
2937 pub const JET_errAlreadyInitialized: i32 = -1030i32;
2938 pub const JET_errAlreadyPrepared: i32 = -1607i32;
2939 pub const JET_errAttachedDatabaseMismatch: i32 = -1216i32;
2940 pub const JET_errBackupAbortByServer: i32 = -801i32;
2941 pub const JET_errBackupDirectoryNotEmpty: i32 = -504i32;
2942 pub const JET_errBackupInProgress: i32 = -505i32;
2943 pub const JET_errBackupNotAllowedYet: i32 = -523i32;
2944 pub const JET_errBadBackupDatabaseSize: i32 = -561i32;
2945 pub const JET_errBadBookmark: i32 = -328i32;
2946 pub const JET_errBadCheckpointSignature: i32 = -532i32;
2947 pub const JET_errBadColumnId: i32 = -1517i32;
2948 pub const JET_errBadDbSignature: i32 = -531i32;
2949 pub const JET_errBadEmptyPage: i32 = -351i32;
2950 pub const JET_errBadItagSequence: i32 = -1518i32;
2951 pub const JET_errBadLineCount: i32 = -354i32;
2952 pub const JET_errBadLogSignature: i32 = -530i32;
2953 pub const JET_errBadLogVersion: i32 = -514i32;
2954 pub const JET_errBadPageLink: i32 = -327i32;
2955 pub const JET_errBadParentPageLink: i32 = -338i32;
2956 pub const JET_errBadPatchPage: i32 = -535i32;
2957 pub const JET_errBadRestoreTargetInstance: i32 = -577i32;
2958 pub const JET_errBufferTooSmall: i32 = -1038i32;
2959 pub const JET_errCallbackFailed: i32 = -2101i32;
2960 pub const JET_errCallbackNotResolved: i32 = -2102i32;
2961 pub const JET_errCannotAddFixedVarColumnToDerivedTable: i32 = -1330i32;
2962 pub const JET_errCannotBeTagged: i32 = -1521i32;
2963 pub const JET_errCannotDeleteSystemTable: i32 = -1318i32;
2964 pub const JET_errCannotDeleteTempTable: i32 = -1317i32;
2965 pub const JET_errCannotDeleteTemplateTable: i32 = -1319i32;
2966 pub const JET_errCannotDisableVersioning: i32 = -1208i32;
2967 pub const JET_errCannotIndex: i32 = -1071i32;
2968 pub const JET_errCannotIndexOnEncryptedColumn: i32 = -1440i32;
2969 pub const JET_errCannotLogDuringRecoveryRedo: i32 = -512i32;
2970 pub const JET_errCannotMaterializeForwardOnlySort: i32 = -1113i32;
2971 pub const JET_errCannotNestDDL: i32 = -1325i32;
2972 pub const JET_errCannotSeparateIntrinsicLV: i32 = -416i32;
2973 pub const JET_errCatalogCorrupted: i32 = -1220i32;
2974 pub const JET_errCheckpointCorrupt: i32 = -533i32;
2975 pub const JET_errCheckpointDepthTooDeep: i32 = -614i32;
2976 pub const JET_errCheckpointFileNotFound: i32 = -542i32;
2977 pub const JET_errClientRequestToStopJetService: i32 = -1329i32;
2978 pub const JET_errColumnCannotBeCompressed: i32 = -1538i32;
2979 pub const JET_errColumnCannotBeEncrypted: i32 = -1439i32;
2980 pub const JET_errColumnDoesNotFit: i32 = -1503i32;
2981 pub const JET_errColumnDuplicate: i32 = -1508i32;
2982 pub const JET_errColumnInRelationship: i32 = -1519i32;
2983 pub const JET_errColumnInUse: i32 = -1046i32;
2984 pub const JET_errColumnIndexed: i32 = -1505i32;
2985 pub const JET_errColumnLong: i32 = -1501i32;
2986 pub const JET_errColumnNoChunk: i32 = -1502i32;
2987 pub const JET_errColumnNoEncryptionKey: i32 = -1540i32;
2988 pub const JET_errColumnNotFound: i32 = -1507i32;
2989 pub const JET_errColumnNotUpdatable: i32 = -1048i32;
2990 pub const JET_errColumnRedundant: i32 = -1510i32;
2991 pub const JET_errColumnTooBig: i32 = -1506i32;
2992 pub const JET_errCommittedLogFileCorrupt: i32 = -586i32;
2993 pub const JET_errCommittedLogFilesMissing: i32 = -582i32;
2994 pub const JET_errConsistentTimeMismatch: i32 = -551i32;
2995 pub const JET_errContainerNotEmpty: i32 = -1043i32;
2996 pub const JET_errDDLNotInheritable: i32 = -1326i32;
2997 pub const JET_errDataHasChanged: i32 = -1611i32;
2998 pub const JET_errDatabase200Format: i32 = -1210i32;
2999 pub const JET_errDatabase400Format: i32 = -1211i32;
3000 pub const JET_errDatabase500Format: i32 = -1212i32;
3001 pub const JET_errDatabaseAlreadyRunningMaintenance: i32 = -2004i32;
3002 pub const JET_errDatabaseAlreadyUpgraded: i32 = -562i32;
3003 pub const JET_errDatabaseAttachedForRecovery: i32 = -1231i32;
3004 pub const JET_errDatabaseBufferDependenciesCorrupted: i32 = -255i32;
3005 pub const JET_errDatabaseCorrupted: i32 = -1206i32;
3006 pub const JET_errDatabaseCorruptedNoRepair: i32 = -1224i32;
3007 pub const JET_errDatabaseDirtyShutdown: i32 = -550i32;
3008 pub const JET_errDatabaseDuplicate: i32 = -1201i32;
3009 pub const JET_errDatabaseFileReadOnly: i32 = -1008i32;
3010 pub const JET_errDatabaseIdInUse: i32 = -1218i32;
3011 pub const JET_errDatabaseInUse: i32 = -1202i32;
3012 pub const JET_errDatabaseIncompleteUpgrade: i32 = -563i32;
3013 pub const JET_errDatabaseInconsistent: i32 = -550i32;
3014 pub const JET_errDatabaseInvalidName: i32 = -1204i32;
3015 pub const JET_errDatabaseInvalidPages: i32 = -1205i32;
3016 pub const JET_errDatabaseInvalidPath: i32 = -1217i32;
3017 pub const JET_errDatabaseLeakInSpace: i32 = -348i32;
3018 pub const JET_errDatabaseLocked: i32 = -1207i32;
3019 pub const JET_errDatabaseLogSetMismatch: i32 = -539i32;
3020 pub const JET_errDatabaseNotFound: i32 = -1203i32;
3021 pub const JET_errDatabaseNotReady: i32 = -1230i32;
3022 pub const JET_errDatabasePatchFileMismatch: i32 = -552i32;
3023 pub const JET_errDatabaseSharingViolation: i32 = -1215i32;
3024 pub const JET_errDatabaseSignInUse: i32 = -1222i32;
3025 pub const JET_errDatabaseStreamingFileMismatch: i32 = -540i32;
3026 pub const JET_errDatabaseUnavailable: i32 = -1091i32;
3027 pub const JET_errDatabasesNotFromSameSnapshot: i32 = -580i32;
3028 pub const JET_errDbTimeCorrupted: i32 = -344i32;
3029 pub const JET_errDbTimeTooNew: i32 = -567i32;
3030 pub const JET_errDbTimeTooOld: i32 = -566i32;
3031 pub const JET_errDecompressionFailed: i32 = -1620i32;
3032 pub const JET_errDecryptionFailed: i32 = -1622i32;
3033 pub const JET_errDefaultValueTooBig: i32 = -1524i32;
3034 pub const JET_errDeleteBackupFileFail: i32 = -524i32;
3035 pub const JET_errDensityInvalid: i32 = -1307i32;
3036 pub const JET_errDerivedColumnCorruption: i32 = -1529i32;
3037 pub const JET_errDirtyShutdown: i32 = -1116i32;
3038 pub const JET_errDisabledFunctionality: i32 = -112i32;
3039 pub const JET_errDiskFull: i32 = -1808i32;
3040 pub const JET_errDiskIO: i32 = -1022i32;
3041 pub const JET_errDiskReadVerificationFailure: i32 = -1021i32;
3042 pub const JET_errEncryptionBadItag: i32 = -1623i32;
3043 pub const JET_errEndingRestoreLogTooLow: i32 = -553i32;
3044 pub const JET_errEngineFormatVersionNoLongerSupportedTooLow: i32 = -619i32;
3045 pub const JET_errEngineFormatVersionNotYetImplementedTooHigh: i32 = -620i32;
3046 pub const JET_errEngineFormatVersionParamTooLowForRequestedFeature: i32 = -621i32;
3047 pub const JET_errEngineFormatVersionSpecifiedTooLowForDatabaseVersion: i32 = -623i32;
3048 pub const JET_errEngineFormatVersionSpecifiedTooLowForLogVersion: i32 = -622i32;
3049 pub const JET_errEntryPointNotFound: i32 = -1911i32;
3050 pub const JET_errExclusiveTableLockRequired: i32 = -1322i32;
3051 pub const JET_errExistingLogFileHasBadSignature: i32 = -610i32;
3052 pub const JET_errExistingLogFileIsNotContiguous: i32 = -611i32;
3053 pub const JET_errFeatureNotAvailable: i32 = -1001i32;
3054 pub const JET_errFileAccessDenied: i32 = -1032i32;
3055 pub const JET_errFileAlreadyExists: i32 = -1814i32;
3056 pub const JET_errFileClose: i32 = -102i32;
3057 pub const JET_errFileCompressed: i32 = -4005i32;
3058 pub const JET_errFileIOAbort: i32 = -4002i32;
3059 pub const JET_errFileIOBeyondEOF: i32 = -4001i32;
3060 pub const JET_errFileIOFail: i32 = -4004i32;
3061 pub const JET_errFileIORetry: i32 = -4003i32;
3062 pub const JET_errFileIOSparse: i32 = -4000i32;
3063 pub const JET_errFileInvalidType: i32 = -1812i32;
3064 pub const JET_errFileNotFound: i32 = -1811i32;
3065 pub const JET_errFileSystemCorruption: i32 = -1121i32;
3066 pub const JET_errFilteredMoveNotSupported: i32 = -1124i32;
3067 pub const JET_errFixedDDL: i32 = -1323i32;
3068 pub const JET_errFixedInheritedDDL: i32 = -1324i32;
3069 pub const JET_errFlushMapDatabaseMismatch: i32 = -1919i32;
3070 pub const JET_errFlushMapUnrecoverable: i32 = -1920i32;
3071 pub const JET_errFlushMapVersionUnsupported: i32 = -1918i32;
3072 pub const JET_errForceDetachNotAllowed: i32 = -1219i32;
3073 pub const JET_errGivenLogFileHasBadSignature: i32 = -555i32;
3074 pub const JET_errGivenLogFileIsNotContiguous: i32 = -556i32;
3075 pub const JET_errIllegalOperation: i32 = -1312i32;
3076 pub const JET_errInTransaction: i32 = -1108i32;
3077 pub const JET_errIndexBuildCorrupted: i32 = -1412i32;
3078 pub const JET_errIndexCantBuild: i32 = -1401i32;
3079 pub const JET_errIndexDuplicate: i32 = -1403i32;
3080 pub const JET_errIndexHasPrimary: i32 = -1402i32;
3081 pub const JET_errIndexInUse: i32 = -1051i32;
3082 pub const JET_errIndexInvalidDef: i32 = -1406i32;
3083 pub const JET_errIndexMustStay: i32 = -1405i32;
3084 pub const JET_errIndexNotFound: i32 = -1404i32;
3085 pub const JET_errIndexTuplesCannotRetrieveFromIndex: i32 = -1436i32;
3086 pub const JET_errIndexTuplesInvalidLimits: i32 = -1435i32;
3087 pub const JET_errIndexTuplesKeyTooSmall: i32 = -1437i32;
3088 pub const JET_errIndexTuplesNonUniqueOnly: i32 = -1432i32;
3089 pub const JET_errIndexTuplesOneColumnOnly: i32 = -1431i32;
3090 pub const JET_errIndexTuplesSecondaryIndexOnly: i32 = -1430i32;
3091 pub const JET_errIndexTuplesTextBinaryColumnsOnly: i32 = -1433i32;
3092 pub const JET_errIndexTuplesTextColumnsOnly: i32 = -1433i32;
3093 pub const JET_errIndexTuplesTooManyColumns: i32 = -1431i32;
3094 pub const JET_errIndexTuplesVarSegMacNotAllowed: i32 = -1434i32;
3095 pub const JET_errInitInProgress: i32 = -1031i32;
3096 pub const JET_errInstanceNameInUse: i32 = -1086i32;
3097 pub const JET_errInstanceUnavailable: i32 = -1090i32;
3098 pub const JET_errInstanceUnavailableDueToFatalLogDiskFull: i32 = -1092i32;
3099 pub const JET_errInternalError: i32 = -107i32;
3100 pub const JET_errInvalidBackup: i32 = -526i32;
3101 pub const JET_errInvalidBackupSequence: i32 = -521i32;
3102 pub const JET_errInvalidBookmark: i32 = -1045i32;
3103 pub const JET_errInvalidBufferSize: i32 = -1047i32;
3104 pub const JET_errInvalidCodePage: i32 = -1063i32;
3105 pub const JET_errInvalidColumnType: i32 = -1511i32;
3106 pub const JET_errInvalidCountry: i32 = -1061i32;
3107 pub const JET_errInvalidCreateDbVersion: i32 = -1225i32;
3108 pub const JET_errInvalidCreateIndex: i32 = -1409i32;
3109 pub const JET_errInvalidDatabase: i32 = -1028i32;
3110 pub const JET_errInvalidDatabaseId: i32 = -1010i32;
3111 pub const JET_errInvalidDatabaseVersion: i32 = -1209i32;
3112 pub const JET_errInvalidDbparamId: i32 = -1095i32;
3113 pub const JET_errInvalidFilename: i32 = -1044i32;
3114 pub const JET_errInvalidGrbit: i32 = -900i32;
3115 pub const JET_errInvalidIndexId: i32 = -1416i32;
3116 pub const JET_errInvalidInstance: i32 = -1115i32;
3117 pub const JET_errInvalidLCMapStringFlags: i32 = -1064i32;
3118 pub const JET_errInvalidLVChunkSize: i32 = -1438i32;
3119 pub const JET_errInvalidLanguageId: i32 = -1062i32;
3120 pub const JET_errInvalidLogDirectory: i32 = -1025i32;
3121 pub const JET_errInvalidLogSequence: i32 = -515i32;
3122 pub const JET_errInvalidLoggedOperation: i32 = -500i32;
3123 pub const JET_errInvalidName: i32 = -1002i32;
3124 pub const JET_errInvalidObject: i32 = -1316i32;
3125 pub const JET_errInvalidOnSort: i32 = -1702i32;
3126 pub const JET_errInvalidOperation: i32 = -1906i32;
3127 pub const JET_errInvalidParameter: i32 = -1003i32;
3128 pub const JET_errInvalidPath: i32 = -1023i32;
3129 pub const JET_errInvalidPlaceholderColumn: i32 = -1530i32;
3130 pub const JET_errInvalidPreread: i32 = -424i32;
3131 pub const JET_errInvalidSesid: i32 = -1104i32;
3132 pub const JET_errInvalidSesparamId: i32 = -1093i32;
3133 pub const JET_errInvalidSettings: i32 = -1328i32;
3134 pub const JET_errInvalidSystemPath: i32 = -1024i32;
3135 pub const JET_errInvalidTableId: i32 = -1310i32;
3136 pub const JET_errKeyBoundary: i32 = -324i32;
3137 pub const JET_errKeyDuplicate: i32 = -1605i32;
3138 pub const JET_errKeyIsMade: i32 = -1516i32;
3139 pub const JET_errKeyNotMade: i32 = -1608i32;
3140 pub const JET_errKeyTooBig: i32 = -408i32;
3141 pub const JET_errKeyTruncated: i32 = -346i32;
3142 pub const JET_errLSAlreadySet: i32 = -3001i32;
3143 pub const JET_errLSCallbackNotSpecified: i32 = -3000i32;
3144 pub const JET_errLSNotSet: i32 = -3002i32;
3145 pub const JET_errLVCorrupted: i32 = -1526i32;
3146 pub const JET_errLanguageNotSupported: i32 = -1619i32;
3147 pub const JET_errLinkNotSupported: i32 = -1052i32;
3148 pub const JET_errLogBufferTooSmall: i32 = -517i32;
3149 pub const JET_errLogCorruptDuringHardRecovery: i32 = -574i32;
3150 pub const JET_errLogCorruptDuringHardRestore: i32 = -573i32;
3151 pub const JET_errLogCorrupted: i32 = -1852i32;
3152 pub const JET_errLogDisabledDueToRecoveryFailure: i32 = -511i32;
3153 pub const JET_errLogDiskFull: i32 = -529i32;
3154 pub const JET_errLogFileCorrupt: i32 = -501i32;
3155 pub const JET_errLogFileNotCopied: i32 = -616i32;
3156 pub const JET_errLogFilePathInUse: i32 = -1084i32;
3157 pub const JET_errLogFileSizeMismatch: i32 = -541i32;
3158 pub const JET_errLogFileSizeMismatchDatabasesConsistent: i32 = -545i32;
3159 pub const JET_errLogGenerationMismatch: i32 = -513i32;
3160 pub const JET_errLogReadVerifyFailure: i32 = -612i32;
3161 pub const JET_errLogSectorSizeMismatch: i32 = -546i32;
3162 pub const JET_errLogSectorSizeMismatchDatabasesConsistent: i32 = -547i32;
3163 pub const JET_errLogSequenceChecksumMismatch: i32 = -590i32;
3164 pub const JET_errLogSequenceEnd: i32 = -519i32;
3165 pub const JET_errLogSequenceEndDatabasesConsistent: i32 = -548i32;
3166 pub const JET_errLogTornWriteDuringHardRecovery: i32 = -571i32;
3167 pub const JET_errLogTornWriteDuringHardRestore: i32 = -570i32;
3168 pub const JET_errLogWriteFail: i32 = -510i32;
3169 pub const JET_errLoggingDisabled: i32 = -516i32;
3170 pub const JET_errMakeBackupDirectoryFail: i32 = -525i32;
3171 pub const JET_errMissingCurrentLogFiles: i32 = -565i32;
3172 pub const JET_errMissingFileToBackup: i32 = -569i32;
3173 pub const JET_errMissingFullBackup: i32 = -560i32;
3174 pub const JET_errMissingLogFile: i32 = -528i32;
3175 pub const JET_errMissingPatchPage: i32 = -534i32;
3176 pub const JET_errMissingPreviousLogFile: i32 = -509i32;
3177 pub const JET_errMissingRestoreLogFiles: i32 = -557i32;
3178 pub const JET_errMultiValuedColumnMustBeTagged: i32 = -1509i32;
3179 pub const JET_errMultiValuedDuplicate: i32 = -1525i32;
3180 pub const JET_errMultiValuedDuplicateAfterTruncation: i32 = -1528i32;
3181 pub const JET_errMultiValuedIndexViolation: i32 = -1411i32;
3182 pub const JET_errMustBeSeparateLongValue: i32 = -423i32;
3183 pub const JET_errMustDisableLoggingForDbUpgrade: i32 = -575i32;
3184 pub const JET_errMustRollback: i32 = -1057i32;
3185 pub const JET_errNTSystemCallFailed: i32 = -334i32;
3186 pub const JET_errNoBackup: i32 = -520i32;
3187 pub const JET_errNoBackupDirectory: i32 = -503i32;
3188 pub const JET_errNoCurrentIndex: i32 = -1515i32;
3189 pub const JET_errNoCurrentRecord: i32 = -1603i32;
3190 pub const JET_errNodeCorrupted: i32 = -358i32;
3191 pub const JET_errNotInTransaction: i32 = -1054i32;
3192 pub const JET_errNotInitialized: i32 = -1029i32;
3193 pub const JET_errNullInvalid: i32 = -1504i32;
3194 pub const JET_errNullKeyDisallowed: i32 = -1053i32;
3195 pub const JET_errOSSnapshotInvalidSequence: i32 = -2401i32;
3196 pub const JET_errOSSnapshotInvalidSnapId: i32 = -2404i32;
3197 pub const JET_errOSSnapshotNotAllowed: i32 = -2403i32;
3198 pub const JET_errOSSnapshotTimeOut: i32 = -2402i32;
3199 pub const JET_errObjectDuplicate: i32 = -1314i32;
3200 pub const JET_errObjectNotFound: i32 = -1305i32;
3201 pub const JET_errOneDatabasePerSession: i32 = -1916i32;
3202 pub const JET_errOutOfAutoincrementValues: i32 = -1076i32;
3203 pub const JET_errOutOfBuffers: i32 = -1014i32;
3204 pub const JET_errOutOfCursors: i32 = -1013i32;
3205 pub const JET_errOutOfDatabaseSpace: i32 = -1012i32;
3206 pub const JET_errOutOfDbtimeValues: i32 = -1077i32;
3207 pub const JET_errOutOfFileHandles: i32 = -1020i32;
3208 pub const JET_errOutOfLongValueIDs: i32 = -1075i32;
3209 pub const JET_errOutOfMemory: i32 = -1011i32;
3210 pub const JET_errOutOfObjectIDs: i32 = -1074i32;
3211 pub const JET_errOutOfSequentialIndexValues: i32 = -1078i32;
3212 pub const JET_errOutOfSessions: i32 = -1101i32;
3213 pub const JET_errOutOfThreads: i32 = -103i32;
3214 pub const JET_errPageBoundary: i32 = -323i32;
3215 pub const JET_errPageInitializedMismatch: i32 = -596i32;
3216 pub const JET_errPageNotInitialized: i32 = -1019i32;
3217 pub const JET_errPageSizeMismatch: i32 = -1213i32;
3218 pub const JET_errPageTagCorrupted: i32 = -357i32;
3219 pub const JET_errPartiallyAttachedDB: i32 = -1221i32;
3220 pub const JET_errPatchFileMissing: i32 = -538i32;
3221 pub const JET_errPermissionDenied: i32 = -1809i32;
3222 pub const JET_errPreviousVersion: i32 = -322i32;
3223 pub const JET_errPrimaryIndexCorrupted: i32 = -1413i32;
3224 pub const JET_errReadLostFlushVerifyFailure: i32 = -1119i32;
3225 pub const JET_errReadPgnoVerifyFailure: i32 = -1118i32;
3226 pub const JET_errReadVerifyFailure: i32 = -1018i32;
3227 pub const JET_errRecordDeleted: i32 = -1017i32;
3228 pub const JET_errRecordFormatConversionFailed: i32 = -1915i32;
3229 pub const JET_errRecordNoCopy: i32 = -1602i32;
3230 pub const JET_errRecordNotDeleted: i32 = -1072i32;
3231 pub const JET_errRecordNotFound: i32 = -1601i32;
3232 pub const JET_errRecordPrimaryChanged: i32 = -1604i32;
3233 pub const JET_errRecordTooBig: i32 = -1026i32;
3234 pub const JET_errRecordTooBigForBackwardCompatibility: i32 = -1112i32;
3235 pub const JET_errRecoveredWithErrors: i32 = -527i32;
3236 pub const JET_errRecoveredWithoutUndo: i32 = -579i32;
3237 pub const JET_errRecoveredWithoutUndoDatabasesConsistent: i32 = -584i32;
3238 pub const JET_errRecoveryVerifyFailure: i32 = -1123i32;
3239 pub const JET_errRedoAbruptEnded: i32 = -536i32;
3240 pub const JET_errRequiredLogFilesMissing: i32 = -543i32;
3241 pub const JET_errRestoreInProgress: i32 = -506i32;
3242 pub const JET_errRestoreOfNonBackupDatabase: i32 = -615i32;
3243 pub const JET_errRfsFailure: i32 = -100i32;
3244 pub const JET_errRfsNotArmed: i32 = -101i32;
3245 pub const JET_errRollbackError: i32 = -1917i32;
3246 pub const JET_errRollbackRequired: i32 = -1109i32;
3247 pub const JET_errRunningInMultiInstanceMode: i32 = -1081i32;
3248 pub const JET_errRunningInOneInstanceMode: i32 = -1080i32;
3249 pub const JET_errSPAvailExtCacheOutOfMemory: i32 = -342i32;
3250 pub const JET_errSPAvailExtCacheOutOfSync: i32 = -340i32;
3251 pub const JET_errSPAvailExtCorrupted: i32 = -341i32;
3252 pub const JET_errSPOwnExtCorrupted: i32 = -343i32;
3253 pub const JET_errSecondaryIndexCorrupted: i32 = -1414i32;
3254 pub const JET_errSectorSizeNotSupported: i32 = -583i32;
3255 pub const JET_errSeparatedLongValue: i32 = -421i32;
3256 pub const JET_errSesidTableIdMismatch: i32 = -1114i32;
3257 pub const JET_errSessionContextAlreadySet: i32 = -1912i32;
3258 pub const JET_errSessionContextNotSetByThisThread: i32 = -1913i32;
3259 pub const JET_errSessionInUse: i32 = -1914i32;
3260 pub const JET_errSessionSharingViolation: i32 = -1910i32;
3261 pub const JET_errSessionWriteConflict: i32 = -1111i32;
3262 pub const JET_errSoftRecoveryOnBackupDatabase: i32 = -544i32;
3263 pub const JET_errSoftRecoveryOnSnapshot: i32 = -581i32;
3264 pub const JET_errSpaceHintsInvalid: i32 = -2103i32;
3265 pub const JET_errStartingRestoreLogTooHigh: i32 = -554i32;
3266 pub const JET_errStreamingDataNotLogged: i32 = -549i32;
3267 pub const JET_errSuccess: u32 = 0u32;
3268 pub const JET_errSystemParameterConflict: i32 = -1087i32;
3269 pub const JET_errSystemParamsAlreadySet: i32 = -1082i32;
3270 pub const JET_errSystemPathInUse: i32 = -1083i32;
3271 pub const JET_errTableDuplicate: i32 = -1303i32;
3272 pub const JET_errTableInUse: i32 = -1304i32;
3273 pub const JET_errTableLocked: i32 = -1302i32;
3274 pub const JET_errTableNotEmpty: i32 = -1308i32;
3275 pub const JET_errTaggedNotNULL: i32 = -1514i32;
3276 pub const JET_errTaskDropped: i32 = -106i32;
3277 pub const JET_errTempFileOpenError: i32 = -1803i32;
3278 pub const JET_errTempPathInUse: i32 = -1085i32;
3279 pub const JET_errTermInProgress: i32 = -1000i32;
3280 pub const JET_errTooManyActiveUsers: i32 = -1059i32;
3281 pub const JET_errTooManyAttachedDatabases: i32 = -1805i32;
3282 pub const JET_errTooManyColumns: i32 = -1040i32;
3283 pub const JET_errTooManyIO: i32 = -105i32;
3284 pub const JET_errTooManyIndexes: i32 = -1015i32;
3285 pub const JET_errTooManyInstances: i32 = -1214i32;
3286 pub const JET_errTooManyKeys: i32 = -1016i32;
3287 pub const JET_errTooManyMempoolEntries: i32 = -1073i32;
3288 pub const JET_errTooManyOpenDatabases: i32 = -1027i32;
3289 pub const JET_errTooManyOpenIndexes: i32 = -1410i32;
3290 pub const JET_errTooManyOpenTables: i32 = -1311i32;
3291 pub const JET_errTooManyOpenTablesAndCleanupTimedOut: i32 = -1313i32;
3292 pub const JET_errTooManyRecords: i32 = -1094i32;
3293 pub const JET_errTooManySorts: i32 = -1701i32;
3294 pub const JET_errTooManySplits: i32 = -1909i32;
3295 pub const JET_errTransReadOnly: i32 = -1110i32;
3296 pub const JET_errTransTooDeep: i32 = -1103i32;
3297 pub const JET_errTransactionTooLong: i32 = -618i32;
3298 pub const JET_errTransactionsNotReadyDuringRecovery: i32 = -1232i32;
3299 pub const JET_errUnicodeLanguageValidationFailure: i32 = -604i32;
3300 pub const JET_errUnicodeNormalizationNotSupported: i32 = -603i32;
3301 pub const JET_errUnicodeTranslationBufferTooSmall: i32 = -601i32;
3302 pub const JET_errUnicodeTranslationFail: i32 = -602i32;
3303 pub const JET_errUnloadableOSFunctionality: i32 = -113i32;
3304 pub const JET_errUpdateMustVersion: i32 = -1621i32;
3305 pub const JET_errUpdateNotPrepared: i32 = -1609i32;
3306 pub const JET_errVersionStoreEntryTooBig: i32 = -1065i32;
3307 pub const JET_errVersionStoreOutOfMemory: i32 = -1069i32;
3308 pub const JET_errVersionStoreOutOfMemoryAndCleanupTimedOut: i32 = -1066i32;
3309 pub const JET_errWriteConflict: i32 = -1102i32;
3310 pub const JET_errWriteConflictPrimaryIndex: i32 = -1105i32;
3311 pub const JET_filetypeCheckpoint: u32 = 4u32;
3312 pub const JET_filetypeDatabase: u32 = 1u32;
3313 pub const JET_filetypeFlushMap: u32 = 7u32;
3314 pub const JET_filetypeLog: u32 = 3u32;
3315 pub const JET_filetypeTempDatabase: u32 = 5u32;
3316 pub const JET_filetypeUnknown: u32 = 0u32;
3317 pub const JET_objtypNil: u32 = 0u32;
3318 pub const JET_objtypTable: u32 = 1u32;
3319 pub const JET_paramAccessDeniedRetryPeriod: u32 = 53u32;
3320 pub const JET_paramAlternateDatabaseRecoveryPath: u32 = 113u32;
3321 pub const JET_paramBaseName: u32 = 3u32;
3322 pub const JET_paramBatchIOBufferMax: u32 = 22u32;
3323 pub const JET_paramCachePriority: u32 = 177u32;
3324 pub const JET_paramCacheSize: u32 = 41u32;
3325 pub const JET_paramCacheSizeMax: u32 = 23u32;
3326 pub const JET_paramCacheSizeMin: u32 = 60u32;
3327 pub const JET_paramCachedClosedTables: u32 = 125u32;
3328 pub const JET_paramCheckFormatWhenOpenFail: u32 = 44u32;
3329 pub const JET_paramCheckpointDepthMax: u32 = 24u32;
3330 pub const JET_paramCheckpointIOMax: u32 = 135u32;
3331 pub const JET_paramCircularLog: u32 = 17u32;
3332 pub const JET_paramCleanupMismatchedLogFiles: u32 = 77u32;
3333 pub const JET_paramCommitDefault: u32 = 16u32;
3334 pub const JET_paramConfigStoreSpec: u32 = 189u32;
3335 pub const JET_paramConfiguration: u32 = 129u32;
3336 pub const JET_paramCreatePathIfNotExist: u32 = 100u32;
3337 pub const JET_paramDatabasePageSize: u32 = 64u32;
3338 pub const JET_paramDbExtensionSize: u32 = 18u32;
3339 pub const JET_paramDbScanIntervalMaxSec: u32 = 172u32;
3340 pub const JET_paramDbScanIntervalMinSec: u32 = 171u32;
3341 pub const JET_paramDbScanThrottle: u32 = 170u32;
3342 pub const JET_paramDefragmentSequentialBTrees: u32 = 160u32;
3343 pub const JET_paramDefragmentSequentialBTreesDensityCheckFrequency: u32 = 161u32;
3344 pub const JET_paramDeleteOldLogs: u32 = 48u32;
3345 pub const JET_paramDeleteOutOfRangeLogs: u32 = 52u32;
3346 pub const JET_paramDisableCallbacks: u32 = 65u32;
3347 pub const JET_paramDisablePerfmon: u32 = 107u32;
3348 pub const JET_paramDurableCommitCallback: u32 = 187u32;
3349 pub const JET_paramEnableAdvanced: u32 = 130u32;
3350 pub const JET_paramEnableDBScanInRecovery: u32 = 169u32;
3351 pub const JET_paramEnableDBScanSerialization: u32 = 180u32;
3352 pub const JET_paramEnableFileCache: u32 = 126u32;
3353 pub const JET_paramEnableIndexChecking: u32 = 45u32;
3354 pub const JET_paramEnableIndexCleanup: u32 = 54u32;
3355 pub const JET_paramEnableOnlineDefrag: u32 = 35u32;
3356 pub const JET_paramEnablePersistedCallbacks: u32 = 156u32;
3357 pub const JET_paramEnableRBS: u32 = 215u32;
3358 pub const JET_paramEnableShrinkDatabase: u32 = 184u32;
3359 pub const JET_paramEnableSqm: u32 = 188u32;
3360 pub const JET_paramEnableTempTableVersioning: u32 = 46u32;
3361 pub const JET_paramEnableViewCache: u32 = 127u32;
3362 pub const JET_paramErrorToString: u32 = 70u32;
3363 pub const JET_paramEventLogCache: u32 = 99u32;
3364 pub const JET_paramEventLoggingLevel: u32 = 51u32;
3365 pub const JET_paramEventSource: u32 = 4u32;
3366 pub const JET_paramEventSourceKey: u32 = 49u32;
3367 pub const JET_paramExceptionAction: u32 = 98u32;
3368 pub const JET_paramGlobalMinVerPages: u32 = 81u32;
3369 pub const JET_paramHungIOActions: u32 = 182u32;
3370 pub const JET_paramHungIOThreshold: u32 = 181u32;
3371 pub const JET_paramIOPriority: u32 = 152u32;
3372 pub const JET_paramIOThrottlingTimeQuanta: u32 = 162u32;
3373 pub const JET_paramIgnoreLogVersion: u32 = 47u32;
3374 pub const JET_paramIndexTupleIncrement: u32 = 132u32;
3375 pub const JET_paramIndexTupleStart: u32 = 133u32;
3376 pub const JET_paramIndexTuplesLengthMax: u32 = 111u32;
3377 pub const JET_paramIndexTuplesLengthMin: u32 = 110u32;
3378 pub const JET_paramIndexTuplesToIndexMax: u32 = 112u32;
3379 pub const JET_paramKeyMost: u32 = 134u32;
3380 pub const JET_paramLRUKCorrInterval: u32 = 25u32;
3381 pub const JET_paramLRUKHistoryMax: u32 = 26u32;
3382 pub const JET_paramLRUKPolicy: u32 = 27u32;
3383 pub const JET_paramLRUKTimeout: u32 = 28u32;
3384 pub const JET_paramLRUKTrxCorrInterval: u32 = 29u32;
3385 pub const JET_paramLVChunkSizeMost: u32 = 163u32;
3386 pub const JET_paramLegacyFileNames: u32 = 136u32;
3387 pub const JET_paramLogBuffers: u32 = 12u32;
3388 pub const JET_paramLogCheckpointPeriod: u32 = 14u32;
3389 pub const JET_paramLogFileCreateAsynch: u32 = 69u32;
3390 pub const JET_paramLogFilePath: u32 = 2u32;
3391 pub const JET_paramLogFileSize: u32 = 11u32;
3392 pub const JET_paramLogWaitingUserMax: u32 = 15u32;
3393 pub const JET_paramMaxCoalesceReadGapSize: u32 = 166u32;
3394 pub const JET_paramMaxCoalesceReadSize: u32 = 164u32;
3395 pub const JET_paramMaxCoalesceWriteGapSize: u32 = 167u32;
3396 pub const JET_paramMaxCoalesceWriteSize: u32 = 165u32;
3397 pub const JET_paramMaxColtyp: u32 = 131u32;
3398 pub const JET_paramMaxCursors: u32 = 8u32;
3399 pub const JET_paramMaxInstances: u32 = 104u32;
3400 pub const JET_paramMaxOpenTables: u32 = 6u32;
3401 pub const JET_paramMaxSessions: u32 = 5u32;
3402 pub const JET_paramMaxTemporaryTables: u32 = 10u32;
3403 pub const JET_paramMaxTransactionSize: u32 = 178u32;
3404 pub const JET_paramMaxValueInvalid: u32 = 217u32;
3405 pub const JET_paramMaxVerPages: u32 = 9u32;
3406 pub const JET_paramMinDataForXpress: u32 = 183u32;
3407 pub const JET_paramNoInformationEvent: u32 = 50u32;
3408 pub const JET_paramOSSnapshotTimeout: u32 = 82u32;
3409 pub const JET_paramOneDatabasePerSession: u32 = 102u32;
3410 pub const JET_paramOutstandingIOMax: u32 = 30u32;
3411 pub const JET_paramPageFragment: u32 = 20u32;
3412 pub const JET_paramPageHintCacheSize: u32 = 101u32;
3413 pub const JET_paramPageTempDBMin: u32 = 19u32;
3414 pub const JET_paramPreferredMaxOpenTables: u32 = 7u32;
3415 pub const JET_paramPreferredVerPages: u32 = 63u32;
3416 pub const JET_paramPrereadIOMax: u32 = 179u32;
3417 pub const JET_paramProcessFriendlyName: u32 = 186u32;
3418 pub const JET_paramRBSFilePath: u32 = 216u32;
3419 pub const JET_paramRecordUpgradeDirtyLevel: u32 = 78u32;
3420 pub const JET_paramRecovery: u32 = 34u32;
3421 pub const JET_paramRuntimeCallback: u32 = 73u32;
3422 pub const JET_paramStartFlushThreshold: u32 = 31u32;
3423 pub const JET_paramStopFlushThreshold: u32 = 32u32;
3424 pub const JET_paramSystemPath: u32 = 0u32;
3425 pub const JET_paramTableClass10Name: u32 = 146u32;
3426 pub const JET_paramTableClass11Name: u32 = 147u32;
3427 pub const JET_paramTableClass12Name: u32 = 148u32;
3428 pub const JET_paramTableClass13Name: u32 = 149u32;
3429 pub const JET_paramTableClass14Name: u32 = 150u32;
3430 pub const JET_paramTableClass15Name: u32 = 151u32;
3431 pub const JET_paramTableClass1Name: u32 = 137u32;
3432 pub const JET_paramTableClass2Name: u32 = 138u32;
3433 pub const JET_paramTableClass3Name: u32 = 139u32;
3434 pub const JET_paramTableClass4Name: u32 = 140u32;
3435 pub const JET_paramTableClass5Name: u32 = 141u32;
3436 pub const JET_paramTableClass6Name: u32 = 142u32;
3437 pub const JET_paramTableClass7Name: u32 = 143u32;
3438 pub const JET_paramTableClass8Name: u32 = 144u32;
3439 pub const JET_paramTableClass9Name: u32 = 145u32;
3440 pub const JET_paramTempPath: u32 = 1u32;
3441 pub const JET_paramUnicodeIndexDefault: u32 = 72u32;
3442 pub const JET_paramUseFlushForWriteDurability: u32 = 214u32;
3443 pub const JET_paramVerPageSize: u32 = 128u32;
3444 pub const JET_paramVersionStoreTaskQueueMax: u32 = 105u32;
3445 pub const JET_paramWaitLogFlush: u32 = 13u32;
3446 pub const JET_paramWaypointLatency: u32 = 153u32;
3447 pub const JET_paramZeroDatabaseDuringBackup: u32 = 71u32;
3448 pub const JET_prepCancel: u32 = 3u32;
3449 pub const JET_prepInsert: u32 = 0u32;
3450 pub const JET_prepInsertCopy: u32 = 5u32;
3451 pub const JET_prepInsertCopyDeleteOriginal: u32 = 7u32;
3452 pub const JET_prepInsertCopyReplaceOriginal: u32 = 9u32;
3453 pub const JET_prepReplace: u32 = 2u32;
3454 pub const JET_prepReplaceNoLock: u32 = 4u32;
3455 pub const JET_revertstateCompleted: u32 = 3u32;
3456 pub const JET_revertstateCopingLogs: u32 = 2u32;
3457 pub const JET_revertstateInProgress: u32 = 1u32;
3458 pub const JET_revertstateNone: u32 = 0u32;
3459 pub const JET_sesparamCommitDefault: u32 = 4097u32;
3460 pub const JET_sesparamCorrelationID: u32 = 4101u32;
3461 pub const JET_sesparamMaxValueInvalid: u32 = 4110u32;
3462 pub const JET_sesparamOperationContext: u32 = 4100u32;
3463 pub const JET_sesparamTransactionLevel: u32 = 4099u32;
3464 pub const JET_snpBackup: u32 = 9u32;
3465 pub const JET_snpCompact: u32 = 4u32;
3466 pub const JET_snpRepair: u32 = 2u32;
3467 pub const JET_snpRestore: u32 = 8u32;
3468 pub const JET_snpScrub: u32 = 11u32;
3469 pub const JET_snpUpgrade: u32 = 10u32;
3470 pub const JET_snpUpgradeRecordFormat: u32 = 12u32;
3471 pub const JET_sntBegin: u32 = 5u32;
3472 pub const JET_sntComplete: u32 = 6u32;
3473 pub const JET_sntFail: u32 = 3u32;
3474 pub const JET_sntProgress: u32 = 0u32;
3475 pub const JET_sntRequirements: u32 = 7u32;
3476 pub const JET_sqmDisable: u32 = 0u32;
3477 pub const JET_sqmEnable: u32 = 1u32;
3478 pub const JET_sqmFromCEIP: u32 = 2u32;
3479 pub const JET_wrnBufferTruncated: u32 = 1006u32;
3480 pub const JET_wrnCallbackNotRegistered: u32 = 2100u32;
3481 pub const JET_wrnColumnDefault: u32 = 1537u32;
3482 pub const JET_wrnColumnMaxTruncated: u32 = 1512u32;
3483 pub const JET_wrnColumnMoreTags: u32 = 1533u32;
3484 pub const JET_wrnColumnNotInRecord: u32 = 1539u32;
3485 pub const JET_wrnColumnNotLocal: u32 = 1532u32;
3486 pub const JET_wrnColumnNull: u32 = 1004u32;
3487 pub const JET_wrnColumnPresent: u32 = 1535u32;
3488 pub const JET_wrnColumnReference: u32 = 1541u32;
3489 pub const JET_wrnColumnSetNull: u32 = 1068u32;
3490 pub const JET_wrnColumnSingleValue: u32 = 1536u32;
3491 pub const JET_wrnColumnSkipped: u32 = 1531u32;
3492 pub const JET_wrnColumnTruncated: u32 = 1534u32;
3493 pub const JET_wrnCommittedLogFilesLost: u32 = 585u32;
3494 pub const JET_wrnCommittedLogFilesRemoved: u32 = 587u32;
3495 pub const JET_wrnCopyLongValue: u32 = 1520u32;
3496 pub const JET_wrnCorruptIndexDeleted: u32 = 1415u32;
3497 pub const JET_wrnDataHasChanged: u32 = 1610u32;
3498 pub const JET_wrnDatabaseAttached: u32 = 1007u32;
3499 pub const JET_wrnDatabaseRepaired: u32 = 595u32;
3500 pub const JET_wrnDefragAlreadyRunning: u32 = 2000u32;
3501 pub const JET_wrnDefragNotRunning: u32 = 2001u32;
3502 pub const JET_wrnExistingLogFileHasBadSignature: u32 = 558u32;
3503 pub const JET_wrnExistingLogFileIsNotContiguous: u32 = 559u32;
3504 pub const JET_wrnFileOpenReadOnly: u32 = 1813u32;
3505 pub const JET_wrnFinishWithUndo: u32 = 588u32;
3506 pub const JET_wrnIdleFull: u32 = 1908u32;
3507 pub const JET_wrnKeyChanged: u32 = 1618u32;
3508 pub const JET_wrnNoErrorInfo: u32 = 1055u32;
3509 pub const JET_wrnNoIdleActivity: u32 = 1058u32;
3510 pub const JET_wrnNoWriteLock: u32 = 1067u32;
3511 pub const JET_wrnNyi: i32 = -1i32;
3512 pub const JET_wrnPrimaryIndexOutOfDate: u32 = 1417u32;
3513 pub const JET_wrnRemainingVersions: u32 = 321u32;
3514 pub const JET_wrnSecondaryIndexOutOfDate: u32 = 1418u32;
3515 pub const JET_wrnSeekNotEqual: u32 = 1039u32;
3516 pub const JET_wrnSeparateLongValue: u32 = 406u32;
3517 pub const JET_wrnShrinkNotPossible: u32 = 1122u32;
3518 pub const JET_wrnSkipThisRecord: u32 = 564u32;
3519 pub const JET_wrnSortOverflow: u32 = 1009u32;
3520 pub const JET_wrnTableEmpty: u32 = 1301u32;
3521 pub const JET_wrnTableInUseBySystem: u32 = 1327u32;
3522 pub const JET_wrnTargetInstanceRunning: u32 = 578u32;
3523 pub const JET_wrnUniqueKey: u32 = 345u32;