/// <summary> /// Gets the data for a row ID. /// </summary> /// <param name="keyCode"></param> /// <param name="rowData"></param> /// <returns></returns> public int GetRowN(int keyCode, out Span <byte> rowData) { rowData = default; int dataLength = DBT.RowDataLength; int entryIndex = DBT.GetIndexOfID(keyCode); //if (uVar1 < *(uint *)(file + 8)) { if (entryIndex < DBT.EntryCount) { // ORIGINAL: iVar2 = (int)this->UnkOffset4 + *(int *)(file + uVar1 * 8 + 0x14); SpanReader sr = new SpanReader(DBT.Buffer, DBT.Endian); // Short version sr.Position = DBT.HeaderSize + (8 * entryIndex) + 4; int entryOffset = sr.ReadInt32(); sr.Position = DBT.UnkOffset4 + entryOffset; if ((DBT.VersionHigh & 1) == 0) { rowData = sr.ReadBytes(dataLength); // memcpy(retSdbIndex,offs,dataLength); } else { rowData = DBT.ExtractRow(ref sr); } } return(dataLength); }
/* * Copy between the C# byte array and the C library's void * as needed. * The library will call this method when it needs data from us or has * data to give us. This prevents us from needing to copy all data in * and all data out. The callback to this method gets set when the * DatabaseEnvironment is created (or the Database if created w/o an * environment.) */ internal static int dbt_usercopy(IntPtr dbtp, uint offset, IntPtr buf, uint size, uint flags) { DBT dbt = new DBT(dbtp, false); DatabaseEntry ent = dbt.app_data; if (flags == DbConstants.DB_USERCOPY_GETDATA) { Marshal.Copy(ent.Data, 0, buf, (int)size); } else { /* * If the offset is zero, we're writing a new buffer and can * simply allocate byte array. If the offset is not zero, * however, we are appending to the exisiting array. Since we * can't extend it, we have to allocate a new one and copy. * * Our caller is setting dbt.size, so set ent._data directly, * since ent.Data would overwrite dbt.size. */ if (offset != 0) { byte[] t = new byte[ent.Data.Length + (int)size]; ent.Data.CopyTo(t, 0); ent._data = t; } else { ent._data = new byte[(int)size]; } Marshal.Copy(buf, ent.Data, (int)offset, (int)size); } return(0); }
private static int doCompress(IntPtr dbp, IntPtr prevKeyp, IntPtr prevDatap, IntPtr keyp, IntPtr datap, IntPtr destp) { DB db = new DB(dbp, false); DatabaseEntry prevKey = DatabaseEntry.fromDBT(new DBT(prevKeyp, false)); DatabaseEntry prevData = DatabaseEntry.fromDBT(new DBT(prevDatap, false)); DatabaseEntry key = DatabaseEntry.fromDBT(new DBT(keyp, false)); DatabaseEntry data = DatabaseEntry.fromDBT(new DBT(datap, false)); DBT dest = new DBT(destp, false); BTreeDatabase btdb = (BTreeDatabase)(db.api_internal); byte[] arr = new byte[(int)dest.ulen]; int len; try { if (btdb.Compress(prevKey, prevData, key, data, ref arr, out len)) { Marshal.Copy(arr, 0, dest.dataPtr, len); dest.size = (uint)len; return(0); } else { return(DbConstants.DB_BUFFER_SMALL); } } catch (Exception) { return(-1); } }
private static int doDecompress(IntPtr dbp, IntPtr prevKeyp, IntPtr prevDatap, IntPtr cmpp, IntPtr destKeyp, IntPtr destDatap) { DB db = new DB(dbp, false); DatabaseEntry prevKey = DatabaseEntry.fromDBT(new DBT(prevKeyp, false)); DatabaseEntry prevData = DatabaseEntry.fromDBT(new DBT(prevDatap, false)); DBT compressed = new DBT(cmpp, false); DBT destKey = new DBT(destKeyp, false); DBT destData = new DBT(destDatap, false); BTreeDatabase btdb = (BTreeDatabase)(db.api_internal); uint size; try { KeyValuePair <DatabaseEntry, DatabaseEntry> kvp = btdb.Decompress(prevKey, prevData, compressed.data, out size); int keylen = kvp.Key.Data.Length; int datalen = kvp.Value.Data.Length; destKey.size = (uint)keylen; destData.size = (uint)datalen; if (keylen > destKey.ulen || datalen > destData.ulen) { return(DbConstants.DB_BUFFER_SMALL); } Marshal.Copy(kvp.Key.Data, 0, destKey.dataPtr, keylen); Marshal.Copy(kvp.Value.Data, 0, destData.dataPtr, datalen); compressed.size = size; return(0); } catch (Exception) { return(-1); } }
private static void doAppend(IntPtr dbp, IntPtr dbtp1, uint recno) { DB db = new DB(dbp, false); DBT dbt1 = new DBT(dbtp1, false); RecnoDatabase rdb = (RecnoDatabase)(db.api_internal); rdb.AppendCallback(DatabaseEntry.fromDBT(dbt1), recno); }
/// <summary> /// Create a new, empty DatabaseEntry object. /// </summary> public DatabaseEntry() { dbt = new DBT(); if (!this.GetType().IsGenericType) { dbt.app_data = this; } }
private static int doCompare(IntPtr dbp, IntPtr dbtp1, IntPtr dbtp2) { DB db = new DB(dbp, false); DBT dbt1 = new DBT(dbtp1, false); DBT dbt2 = new DBT(dbtp2, false); return(((HashDatabase)(db.api_internal)).compareHandler( DatabaseEntry.fromDBT(dbt1), DatabaseEntry.fromDBT(dbt2))); }
private static int doCompare(IntPtr dbp, IntPtr dbtp1, IntPtr dbtp2) { DB db = new DB(dbp, false); DBT dbt1 = new DBT(dbtp1, false); DBT dbt2 = new DBT(dbtp2, false); BTreeDatabase btdb = (BTreeDatabase)(db.api_internal); return(btdb.Compare( DatabaseEntry.fromDBT(dbt1), DatabaseEntry.fromDBT(dbt2))); }
private static int doDupCompare( IntPtr dbp, IntPtr dbt1p, IntPtr dbt2p) { DB db = new DB(dbp, false); DBT dbt1 = new DBT(dbt1p, false); DBT dbt2 = new DBT(dbt2p, false); return(((HashDatabase)(db.api_internal)).DupCompare( DatabaseEntry.fromDBT(dbt1), DatabaseEntry.fromDBT(dbt2))); }
internal static DatabaseEntry fromDBT(DBT dbt) { if (dbt.app_data != null) { return(dbt.app_data); } else { return(new DatabaseEntry(dbt)); } }
/// <summary> /// Send a message on the message channel. The message is sent /// asynchronously. The method does not wait for a response before /// returning. It usually completes quickly because it only waits for /// local TCP implementation to accept the bytes into its network data /// buffer. However, this message could block briefly for longer /// messages, and/or if the network data buffer is nearly full. /// It could even block indefinitely if the remote site is slow /// to read. /// </summary> /// <remarks> /// <para> /// To block while waiting for a response from a remote site, use /// <see cref="SendRequest"/> instead of this method. /// </para> /// <para> /// The sent message is received and handled at remote sites using a /// message dispatch callback, which is configured using /// <see cref="DatabaseEnvironment.RepMessageDispatch"/>. This /// method may be used within the message dispatch callback on the /// remote site to send a reply or acknowledgement for messages that it /// receives and is handling. /// </para> /// <para> /// This method may be used on channels opened to any destination. See /// <see cref="DatabaseEnvironment.RepMgrChannel"/> for a list of /// potential destinations. /// </para> /// </remarks> /// <param name="msg"> /// An array of DatabaseEntry objects. Any flags for the DatabaseEntry /// objects are ignored. /// </param> public void SendMessage(DatabaseEntry[] msg) { int size = msg.Length; IntPtr[] dbts = new IntPtr[size]; for (int i = 0; i < size; i++) { dbts[i] = DBT.getCPtr(DatabaseEntry.getDBT(msg[i])).Handle; } channel.send_msg(dbts, (uint)size, 0); }
private static int doCompare(IntPtr dbp, IntPtr dbtp1, IntPtr dbtp2) { DB db = new DB(dbp, false); DBT dbt1 = new DBT(dbtp1, false); DBT dbt2 = new DBT(dbtp2, false); SecondaryBTreeDatabase tmp = (SecondaryBTreeDatabase)db.api_internal; return(tmp.compareHandler( DatabaseEntry.fromDBT(dbt1), DatabaseEntry.fromDBT(dbt2))); }
private static int doDupCompare( IntPtr dbp, IntPtr dbt1p, IntPtr dbt2p) { DB db = new DB(dbp, false); DBT dbt1 = new DBT(dbt1p, false); DBT dbt2 = new DBT(dbt2p, false); SecondaryHashDatabase tmp = (SecondaryHashDatabase)db.api_internal; return(tmp.DupCompare( DatabaseEntry.fromDBT(dbt1), DatabaseEntry.fromDBT(dbt2))); }
private static int doDupCompare( IntPtr dbp, IntPtr dbt1p, IntPtr dbt2p, IntPtr locp) { DB db = new DB(dbp, false); DBT dbt1 = new DBT(dbt1p, false); DBT dbt2 = new DBT(dbt2p, false); if (locp != IntPtr.Zero) { locp = IntPtr.Zero; } return(((SecondaryBTreeDatabase)(db.api_internal)).DupCompare( DatabaseEntry.fromDBT(dbt1), DatabaseEntry.fromDBT(dbt2))); }
/// <summary> /// Send a message on the message channel. The message is sent /// synchronously. The method blocks waiting for a response before /// returning. If a response is not received within the timeout value /// configured for this request, this method returns with an error /// condition. /// </summary> /// <remarks> /// <para> /// To avoid block while waiting for a response from a remote site, /// use <see cref="SendMessage"/> /// </para> /// <para> /// The message sent by this method is received and handled at remote /// sites using a message dispatch callback, which is configured using /// <see cref="DatabaseEnvironment.RepMessageDispatch"/> /// </para> /// </remarks> /// <param name="request"> /// DatabaseEntry objects array. Any flags for the DatabaseEntry objects /// are ignored. /// </param> /// <param name="timeout"> /// The amount of time that may elapse while this method waits for a /// response from the remote site. The timeout value must be specified /// as an unsigned 32-bit number of microseconds, limiting the maximum /// timeout to roughly 71 minutes. A timeout value of 0 indicates that /// the channel's default timeout value should be used. This default is /// configured using <see cref="Timeout"/>. /// </param> /// <returns>The response from remote site</returns> public DatabaseEntry SendRequest( DatabaseEntry[] request, uint timeout) { int size = request.Length; IntPtr[] dbts = new IntPtr[size]; for (int i = 0; i < size; i++) { dbts[i] = DBT.getCPtr(DatabaseEntry.getDBT(request[i])).Handle; } DatabaseEntry response = new DatabaseEntry(); channel.send_request(dbts, (uint)size, response, timeout, 0); return(response); }
protected override void WndProc(ref Message m) { if (m.Msg == 537) { DBT dBT = (DBT)(int)m.WParam; if (!(m.LParam == IntPtr.Zero)) { Marshal.ReadInt32(m.LParam, 4); } DBT dBT2 = dBT; if (dBT2 == DBT.DBT_DEVNODES_CHANGED || dBT2 == DBT.DBT_DEVICEARRIVAL || dBT2 == DBT.DBT_DEVICEREMOVECOMPLETE) { RefreshPrint = true; } } base.WndProc(ref m); }
private static int doCompare(IntPtr dbp, IntPtr dbtp1, IntPtr dbtp2, IntPtr locp) { DB db = new DB(dbp, false); DBT dbt1 = new DBT(dbtp1, false); DBT dbt2 = new DBT(dbtp2, false); if (locp != IntPtr.Zero) { locp = IntPtr.Zero; } SecondaryHashDatabase tmp = (SecondaryHashDatabase)db.api_internal; return(tmp.Compare( DatabaseEntry.fromDBT(dbt1), DatabaseEntry.fromDBT(dbt2))); }
private void OnDeviceChanged(DBT dbt, DEV_BROADCAST_VOLUME volume) { if (volume.dbcv_devicetype != DBT_DEVTP.DBT_DEVTYP_VOLUME) { return; } switch (dbt) { case DBT.DBT_DEVICEARRIVAL: case DBT.DBT_DEVICEREMOVECOMPLETE: DrivesChanged?.Invoke(this, EventArgs.Empty); break; default: break; } }
/// <summary> /// Send a message on the message channel. The message is sent /// synchronously. The method blocks waiting for a response before /// returning. If a response is not received within the timeout value /// configured for this request, this method returns with an error /// condition. /// </summary> /// <remarks> /// <para> /// To avoid block while waiting for a response from a remote site, /// use <see cref="SendMessage"/> /// </para> /// <para> /// The message sent by this method is received and handled at remote /// sites using a message dispatch callback, which is configured using /// <see cref="DatabaseEnvironment.RepMessageDispatch"/> /// </para> /// </remarks> /// <param name="request"> /// DatabaseEntry objects array. Any flags for the DatabaseEntry objects /// are ignored. /// </param> /// <param name="bufferSize">Size of bulk buffer</param> /// <param name="timeout"> /// The amount of time that may elapse while this method waits for a /// response from the remote site. The timeout value must be specified /// as an unsigned 32-bit number of microseconds, limiting the maximum /// timeout to roughly 71 minutes. A timeout value of 0 indicates that /// the channel's default timeout value should be used. This default is /// configured using <see cref="Timeout"/>. /// </param> /// <returns>Multiple responses from the remote site.</returns> public MultipleDatabaseEntry SendRequest( DatabaseEntry[] request, int bufferSize, uint timeout) { int size = request.Length; IntPtr[] dbts = new IntPtr[size]; for (int i = 0; i < size; i++) { dbts[i] = DBT.getCPtr(DatabaseEntry.getDBT(request[i])).Handle; } DatabaseEntry data = new DatabaseEntry(); data.UserData = new byte[bufferSize]; channel.send_request(dbts, (uint)size, data, timeout, DbConstants.DB_MULTIPLE); MultipleDatabaseEntry response = new MultipleDatabaseEntry(data); return(response); }
/// <summary> /// Protected method to call the key generation function. /// </summary> /// <param name="dbp">Secondary DB Handle</param> /// <param name="keyp">Primary Key</param> /// <param name="datap">Primary Data</param> /// <param name="skeyp">Scondary Key</param> /// <returns>0 on success, !0 on failure</returns> protected static int doAssociate( IntPtr dbp, IntPtr keyp, IntPtr datap, IntPtr skeyp) { DB db = new DB(dbp, false); DBT key = new DBT(keyp, false); DBT data = new DBT(datap, false); DBT skey = new DBT(skeyp, false); DatabaseEntry s = ((SecondaryDatabase)db.api_internal).KeyGen( DatabaseEntry.fromDBT(key), DatabaseEntry.fromDBT(data)); if (s == null) { return(DbConstants.DB_DONOTINDEX); } skey.data = s.Data; return(0); }
/// <inheritdoc /> protected override void WndProc(ref Message m) { base.WndProc(ref m); if (m.Msg != Win32.WM_DEVICECHANGE) { return; } DBT wParam = (DBT)(int)m.WParam; switch (wParam) { case DBT.DBT_DEVICEARRIVAL: lblMessage.Text = MSG_DETACH; lblMessage.ForeColor = Color.Green; break; case DBT.DBT_DEVICEREMOVECOMPLETE: Close(); break; } }
/// <summary> /// Protected method to nullify a foreign key /// </summary> /// <param name="dbp">Secondary DB Handle</param> /// <param name="keyp">Primary Key</param> /// <param name="datap">Primary Data</param> /// <param name="fkeyp">Foreign Key</param> /// <param name="changed">Whether the foreign key has changed</param> /// <returns>0 on success, !0 on failure</returns> protected static int doNullify(IntPtr dbp, IntPtr keyp, IntPtr datap, IntPtr fkeyp, ref int changed) { DB db = new DB(dbp, false); DBT key = new DBT(keyp, false); DBT data = new DBT(datap, false); DBT fkey = new DBT(fkeyp, false); DatabaseEntry d = ((SecondaryDatabase)db.api_internal).Nullifier( DatabaseEntry.fromDBT(key), DatabaseEntry.fromDBT(data), DatabaseEntry.fromDBT(fkey)); if (d == null) { changed = 0; } else { changed = 1; data.data = d.Data; } return(0); }
/// <summary> /// 查询数据库 /// </summary> /// <returns></returns> private DataSet QueryDS(QueryDataSetModel dsm, DBT dbt = DBT.sqllite) { DataSet ds = new DataSet(); string sql = string.Empty; switch (dbt) { case DBT.sqllite: sql = "SELECT " + dsm.columns + " FROM " + dsm.tableName + " WHERE " + dsm.whereStr + " ORDER BY " + dsm.orderBy + " LIMIT " + dsm.pageSize + " OFFSET " + dsm.pageSize * (dsm.pageIndex - 1); if (dsm.total) { sql += "; select count(1) AS counts from " + dsm.tableName + " WHERE " + dsm.whereStr; ds = DB.HelperSQLite.Query(sql); } else { ds = DB.HelperSQLite.Query(sql); } break; } return(ds); }
static DbRetVal AppRecoverWrapFast(DB_ENV* evp, ref DBT logrec, DB_LSN* lsnp, DB_RECOPS op) { Env env = null; try { env = (Env)((GCHandle)evp->api_internal).Target; CallbackStatus cs = env.appRecoverFast(env, ref logrec, lsnp, (RecoveryOps)op); return cs == CallbackStatus.Success ? DbRetVal.SUCCESS : DbRetVal.APP_RECOVER_FAILED; } catch (Exception ex) { Trace.WriteLine(ex.Message, "TxnRecover"); return DbRetVal.APP_RECOVER_FAILED; } }
static DbRetVal PageOutWrapCLS(DB_ENV* evp, UInt32 pgno, void* pgaddr, ref DBT pgcookie) { Env env = null; try { env = (Env)((GCHandle)evp->api_internal).Target; CallbackStatus cs = PageInOutWrapCLS(env, pgno, pgaddr, ref pgcookie, env.pageOutCLS); return cs == CallbackStatus.Success ? DbRetVal.SUCCESS : DbRetVal.PAGE_OUT_FAILED; } catch (Exception ex) { Trace.WriteLine(ex.Message, "PageOut"); return DbRetVal.PAGE_OUT_FAILED; } }
static CallbackStatus PageInOutWrapCLS(Env env, UInt32 pgno, void* pgaddr, ref DBT pgcookie, PageInOutFcn pgInOut) { // construct DbEntry for pgcookie int size = unchecked((int)pgcookie.size); // we are not using a shared buffer - the call-back might take // a long time and we do not want to lock the buffer that long byte[] buffer = new byte[size]; Marshal.Copy((IntPtr)pgcookie.data, buffer, 0, size); DbEntry cookieEntry = DbEntry.InOut(buffer, 0, size); cookieEntry.dbt.flags = pgcookie.flags; cookieEntry.dbt.dlen = pgcookie.dlen; cookieEntry.dbt.doff = pgcookie.doff; // call CLS compliant delegate - we assume it is not null return pgInOut(env, new CachePage(pgno, (IntPtr)pgaddr), ref cookieEntry); }
private DatabaseEntry(DBT dbtp) { dbt = dbtp; Data = (byte[])dbtp.data.Clone(); }
// constructs a DB_LOCKREQ instance based on this instance and an // externally (in unmanaged memory) allocated DBT and byte buffer; // bufp *must* point to memory large enough to hold obj.Size bytes internal unsafe DB_LOCKREQ PrepareLockReq(DBT* dbt, ref byte* bufp) { DB_LOCKREQ dblr = new DB_LOCKREQ((DB_LOCKOP)op, (DB_LOCKMODE)mode, unchecked((uint)timeout), (IntPtr)dbt, lck.dblck); dbt->data = bufp; dbt->size = obj.dbt.size; dbt->flags = DBT.DB_DBT_USERMEM; if (bufp != null) Marshal.Copy(obj.Buffer, obj.Start, (IntPtr)bufp, obj.Size); bufp += obj.dbt.size; return dblr; }
static DbRetVal RepSendWrapFast( DB_ENV* evp, ref DBT control, ref DBT rec, DB_LSN* lsnp, int envid, uint flags) { Env env = null; try { env = Util.GetEnv(evp); CallbackStatus cs = env.repSendFast( env, ref control, ref rec, lsnp, envid, unchecked((RepSendFlags)flags)); return cs == CallbackStatus.Success ? DbRetVal.SUCCESS : DbRetVal.REPSEND_FAILED; } catch (Exception ex) { Trace.WriteLine(ex.Message, "RepSend"); if (env != null) env.Error((int)DbRetVal.REPSEND_FAILED, ex.Message); else evp->Err(evp, (int)DbRetVal.REPSEND_FAILED, null); return DbRetVal.REPSEND_FAILED; } }
private void Config(BTreeDatabaseConfig cfg) { base.Config(cfg); /* * Database.Config calls set_flags, but that does not get the BTree * specific flags. No harm in calling it again. */ db.set_flags(cfg.flags); if (cfg.BlobDir != null && cfg.Env == null) { db.set_ext_file_dir(cfg.BlobDir); } if (cfg.ExternalFileDir != null && cfg.Env == null) { db.set_ext_file_dir(cfg.ExternalFileDir); } if (cfg.blobThresholdIsSet) { db.set_ext_file_threshold(cfg.BlobThreshold, 0); } if (cfg.BTreeCompare != null) { Compare = cfg.BTreeCompare; } if (cfg.BTreePrefixCompare != null) { PrefixCompare = cfg.BTreePrefixCompare; } // The duplicate comparison function cannot change. if (cfg.DuplicateCompare != null) { DupCompare = cfg.DuplicateCompare; } if (cfg.minkeysIsSet) { db.set_bt_minkey(cfg.MinKeysPerPage); } if (cfg.compressionIsSet) { Compress = cfg.Compress; Decompress = cfg.Decompress; if (Compress == null) { doCompressRef = null; } else { doCompressRef = new BDB_CompressDelegate(doCompress); } if (Decompress == null) { doDecompressRef = null; } else { doDecompressRef = new BDB_DecompressDelegate(doDecompress); } db.set_bt_compress(doCompressRef, doDecompressRef); } if (cfg.partitionIsSet) { nparts = cfg.NParts; Partition = cfg.Partition; if (Partition == null) { doPartitionRef = null; } else { doPartitionRef = new BDB_PartitionDelegate(doPartition); } partitionKeys = cfg.PartitionKeys; IntPtr[] ptrs = null; if (partitionKeys != null) { int size = (int)nparts - 1; ptrs = new IntPtr[size]; for (int i = 0; i < size; i++) { ptrs[i] = DBT.getCPtr( DatabaseEntry.getDBT(partitionKeys[i])).Handle; } } db.set_partition(nparts, ptrs, doPartitionRef); } }
public DeviceDetectorEventArgs(DBT changeType, DEV_BROADCAST_VOLUME volumeInfo) { Cancel = false; _ChangeType = changeType; _VolumeInfo = volumeInfo; }
static DbRetVal RepSendWrapCLS( DB_ENV* evp, ref DBT control, ref DBT rec, DB_LSN* lsnp, int envid, uint flags) { Env env = null; try { env = Util.GetEnv(evp); lock (env.callBackLock) { // construct DbEntry for control int size = unchecked((int)control.size); if (size > env.callBackBuffer1.Length) env.callBackBuffer1 = new byte[size]; Marshal.Copy((IntPtr)control.data, env.callBackBuffer1, 0, size); DbEntry ctrlEntry = DbEntry.InOut(env.callBackBuffer1, 0, size); // construct DbEntry for rec size = unchecked((int)rec.size); if (size > env.callBackBuffer2.Length) env.callBackBuffer2 = new byte[size]; Marshal.Copy((IntPtr)rec.data, env.callBackBuffer2, 0, size); DbEntry recEntry = DbEntry.InOut(env.callBackBuffer2, 0, size); // construct Lsn Lsn? lsn; if (lsnp == null) lsn = null; else lsn = new Lsn(*lsnp); // call CLS compliant delegate - we assume it is not null CallbackStatus cs = env.repSendCLS( env, ref ctrlEntry, ref recEntry, lsn, envid, unchecked((RepSendFlags)flags)); return cs == CallbackStatus.Success ? DbRetVal.SUCCESS : DbRetVal.REPSEND_FAILED; } } catch (Exception ex) { Trace.WriteLine(ex.Message, "RepSend"); if (env != null) env.Error((int)DbRetVal.REPSEND_FAILED, ex.Message); else evp->Err(evp, (int)DbRetVal.REPSEND_FAILED, null); return DbRetVal.REPSEND_FAILED; } }
// faster way of getting vendor name, uses "unsafe" techniques private unsafe DbRetVal GetVendorNameFast(DbFile secondary, ref DBT key, ref DBT data, ref DBT result) { // not implemented - would need "UnsafeBufferFormatter" return(DbRetVal.DONOTINDEX); }
static CallbackStatus PageInOutWrapCLS(Env env, UInt32 pgno, void* pgaddr, ref DBT pgcookie, PageInOutFcn pgInOut) { IntPtr cookie = IntPtr.Zero; // extract IntPtr from DBT int size = unchecked((int)pgcookie.size); if (size != 0) { if (size != sizeof(IntPtr)) throw new BdbException("Invalid page cookie."); cookie = *(IntPtr*)pgcookie.data; } // call CLS compliant delegate - we assume it is not null return pgInOut(env, new CachePage(pgno, (IntPtr)pgaddr), cookie); }
/// <summary> /// Protected method to call the key generation function. /// </summary> /// <param name="dbp">Secondary DB Handle</param> /// <param name="keyp">Primary Key</param> /// <param name="datap">Primary Data</param> /// <param name="skeyp">Scondary Key</param> /// <returns>0 on success, !0 on failure</returns> protected static int doAssociate( IntPtr dbp, IntPtr keyp, IntPtr datap, IntPtr skeyp) { DB db = new DB(dbp, false); DBT key = new DBT(keyp, false); DBT data = new DBT(datap, false); DBT skey = new DBT(skeyp, false); IntPtr dataPtr, sdataPtr; int nrecs, dbt_sz; DatabaseEntry s = ((SecondaryDatabase)db.api_internal).KeyGen( DatabaseEntry.fromDBT(key), DatabaseEntry.fromDBT(data)); if (s == null) { return(DbConstants.DB_DONOTINDEX); } if (s is MultipleDatabaseEntry) { MultipleDatabaseEntry mde = (MultipleDatabaseEntry)s; nrecs = mde.nRecs; /* * Allocate an array of nrecs DBT in native memory. The call * returns sizeof(DBT), so that we know where one DBT ends and * the next begins. */ dbt_sz = (int)libdb_csharp.alloc_dbt_arr(null, nrecs, out sdataPtr); /* * We need a managed array to copy each DBT into and then we'll * copy the managed array to the native array we just allocated. * We are not able to copy native -> native. */ byte[] arr = new byte[nrecs * dbt_sz]; IntPtr p; int off = 0; /* Copy each DBT into the array. */ foreach (DatabaseEntry dbt in mde) { /* Allocate room for the data in native memory. */ dataPtr = libdb_csharp.__os_umalloc(null, dbt.size); Marshal.Copy(dbt.Data, 0, dataPtr, (int)dbt.size); dbt.dbt.dataPtr = dataPtr; dbt.flags |= DbConstants.DB_DBT_APPMALLOC; p = DBT.getCPtr(DatabaseEntry.getDBT(dbt)).Handle; Marshal.Copy(p, arr, off, dbt_sz); off += dbt_sz; } Marshal.Copy(arr, 0, sdataPtr, nrecs * dbt_sz); skey.dataPtr = sdataPtr; skey.size = (uint)mde.nRecs; skey.flags = DbConstants.DB_DBT_MULTIPLE | DbConstants.DB_DBT_APPMALLOC; } else { skey.data = s.Data; } return(0); }
static DbRetVal AppRecoverWrapCLS(DB_ENV* evp, ref DBT logrec, DB_LSN* lsnp, DB_RECOPS op) { Env env = null; try { env = (Env)((GCHandle)evp->api_internal).Target; // construct DbEntry for log_rec int size = unchecked((int)logrec.size); // we are not using a shared buffer - the call-back might take // a long time and we do not want to lock the buffer that long byte[] buffer = new byte[size]; Marshal.Copy((IntPtr)logrec.data, buffer, 0, size); DbEntry logEntry = DbEntry.InOut(buffer, 0, size); logEntry.dbt.flags = logrec.flags; logEntry.dbt.dlen = logrec.dlen; logEntry.dbt.doff = logrec.doff; // construct Lsn Lsn? lsn; if (lsnp == null) lsn = null; else lsn = new Lsn(*lsnp); // call CLS compliant delegate - we assume it is not null CallbackStatus cs = env.appRecoverCLS(env, ref logEntry, lsn, (RecoveryOps)op); return cs == CallbackStatus.Success ? DbRetVal.SUCCESS : DbRetVal.APP_RECOVER_FAILED; } catch (Exception ex) { Trace.WriteLine(ex.Message, "TxnRecover"); return DbRetVal.APP_RECOVER_FAILED; } }
internal static void AddKeys(Dictionary <string, string> db, DBT dbtp) { try { if (dbtp == DBT.SDB) { using (SQLiteTransaction trans = SDB.BeginTransaction()) { using (SQLiteCommand addKeysCmd = new SQLiteCommand(SDB)) { foreach (KeyValuePair <string, string> pair in db) { string sqlIns = "INSERT INTO TEXTDB (hex, virusname) VALUES('" + pair.Key + "', '" + pair.Value + "');"; addKeysCmd.CommandText = sqlIns; addKeysCmd.ExecuteNonQuery(); } } trans.Commit(); } SetCount(db.Count.ToString()); } else if (dbtp == DBT.HDB) { using (SQLiteTransaction trans = HADB.BeginTransaction()) { using (SQLiteCommand addKeysCmd = new SQLiteCommand(HADB)) { foreach (KeyValuePair <string, string> pair in db) { string sqlIns = string.Format("INSERT INTO {0} (hash, virusname) VALUES('" + pair.Key + "', '" + pair.Value + "');", FileFormat.GetTable(pair.Key)); addKeysCmd.CommandText = sqlIns; addKeysCmd.Transaction = trans; addKeysCmd.ExecuteNonQuery(); } } trans.Commit(); } SetCount(db.Count.ToString()); } else if (dbtp == DBT.HEUR) { using (SQLiteTransaction trans = SDB.BeginTransaction()) { using (SQLiteCommand addKeysCmd = new SQLiteCommand(SDB)) { foreach (KeyValuePair <string, string> pair in db) { string sqlIns = "INSERT INTO HEURISTIC (instruction, rate) VALUES('" + pair.Key + "', '" + pair.Value + "');"; addKeysCmd.CommandText = sqlIns; addKeysCmd.Transaction = trans; addKeysCmd.ExecuteNonQuery(); } } trans.Commit(); } SetCount(db.Count.ToString()); } else if (dbtp == DBT.WDB) { using (SQLiteTransaction trans = WDB.BeginTransaction()) { using (SQLiteCommand addKeysCmd = new SQLiteCommand(WDB)) { foreach (KeyValuePair <string, string> pair in db) { string sqlIns = string.Format("INSERT INTO {0} (blacklistid, hash) VALUES('{1}', '{2}');", FileFormat.GetTable(pair.Key), pair.Value, pair.Key); addKeysCmd.CommandText = sqlIns; addKeysCmd.Transaction = trans; addKeysCmd.ExecuteNonQuery(); } } trans.Commit(); } SetCount(db.Count.ToString()); } else { using (SQLiteTransaction trans = PEDB.BeginTransaction()) { using (SQLiteCommand addKeysCmd = new SQLiteCommand(PEDB)) { foreach (KeyValuePair <string, string> pair in db) { string sqlIns = string.Format("INSERT INTO {0} (hash, virusname) VALUES('" + pair.Key + "', '" + pair.Value + "');", FileFormat.GetTable(pair.Key)); addKeysCmd.CommandText = sqlIns; addKeysCmd.ExecuteNonQuery(); } } trans.Commit(); } SetCount(db.Count.ToString()); } } catch { } finally { } }
private void Config(HashDatabaseConfig cfg) { base.Config(cfg); /* * Database.Config calls set_flags, but that does not get the Hash * specific flags. No harm in calling it again. */ db.set_flags(cfg.flags); if (cfg.BlobDir != null && cfg.Env == null) { db.set_ext_file_dir(cfg.BlobDir); } if (cfg.ExternalFileDir != null && cfg.Env == null) { db.set_ext_file_dir(cfg.ExternalFileDir); } if (cfg.blobThresholdIsSet) { db.set_ext_file_threshold(cfg.BlobThreshold, 0); } if (cfg.HashFunction != null) { HashFunction = cfg.HashFunction; } // The duplicate comparison function cannot change. if (cfg.DuplicateCompare != null) { DupCompare = cfg.DuplicateCompare; } if (cfg.fillFactorIsSet) { db.set_h_ffactor(cfg.FillFactor); } if (cfg.nelemIsSet) { db.set_h_nelem(cfg.TableSize); } if (cfg.HashComparison != null) { Compare = cfg.HashComparison; } if (cfg.partitionIsSet) { nparts = cfg.NParts; Partition = cfg.Partition; if (Partition == null) { doPartitionRef = null; } else { doPartitionRef = new BDB_PartitionDelegate(doPartition); } partitionKeys = cfg.PartitionKeys; IntPtr[] ptrs = null; if (partitionKeys != null) { int size = (int)nparts - 1; ptrs = new IntPtr[size]; for (int i = 0; i < size; i++) { ptrs[i] = DBT.getCPtr( DatabaseEntry.getDBT(partitionKeys[i])).Handle; } } db.set_partition(nparts, ptrs, doPartitionRef); } }