/// <summary> /// Removes resource from database and /// </summary> public void Remove(string resourceName) { if (String.IsNullOrEmpty(resourceName)) { return; } string rn = _urp + resourceName; byte[] btKey = DataTypesConvertor.ConvertKey <string>(rn); _sync.EnterWriteLock(); try { _d.Remove(rn); LTrie.Remove(ref btKey); LTrie.Commit(); } catch (Exception ex) { throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.DBREEZE_RESOURCES_CONCERNING, "in Remove", ex); } finally { _sync.ExitWriteLock(); } }
public IList <Transactions> GetTransactionsByAccountCode(int?id) { List <Transactions> transactionList = new List <Transactions>(); using (SqlConnection con = new SqlConnection(CS)) { SqlCommand cmd = new SqlCommand("pr_GetTransactionsByAccountCode", con); cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@account_code", id); con.Open(); SqlDataReader rdr = cmd.ExecuteReader(); while (rdr.Read()) { var transactionModel = new Transactions() { code = DataTypesConvertor.ConvertToInt(rdr["code"]), account_code = DataTypesConvertor.ConvertToInt(rdr["account_code"]), transaction_date = DataTypesConvertor.ConvertToDateTime(rdr["transaction_date"]), capture_date = DataTypesConvertor.ConvertToDateTime(rdr["capture_date"]), amount = DataTypesConvertor.ConvertToDecimal(rdr["amount"]), description = rdr["description"].ToString() }; transactionList.Add(transactionModel); } return(transactionList); } }
public IList <Persons> SearchPersons(string term) { List <Persons> personsList = new List <Persons>(); using (SqlConnection con = new SqlConnection(CS)) { SqlCommand cmd = new SqlCommand("pr_SearchPerson", con); cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@term", term); con.Open(); SqlDataReader rdr = cmd.ExecuteReader(); while (rdr.Read()) { var personModel = new Persons() { code = DataTypesConvertor.ConvertToInt(rdr["code"]), name = rdr["name"].ToString(), surname = rdr["surname"].ToString(), id_number = rdr["id_number"].ToString() }; personsList.Add(personModel); } return(personsList); } }
public IList <Accounts> GetAccountsByPersonCode(int?id) { List <Accounts> accountList = new List <Accounts>(); using (SqlConnection con = new SqlConnection(CS)) { SqlCommand cmd = new SqlCommand("pr_GetAccountsByPersonCode", con); cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@person_code", id); con.Open(); SqlDataReader rdr = cmd.ExecuteReader(); while (rdr.Read()) { var accountModel = new Accounts() { code = DataTypesConvertor.ConvertToInt(rdr["code"]), person_code = DataTypesConvertor.ConvertToInt(rdr["person_code"]), account_number = rdr["account_number"].ToString(), outstanding_balance = DataTypesConvertor.ConvertToDecimal(rdr["outstanding_balance"]) }; accountList.Add(accountModel); } return(accountList); } }
/// <summary> /// Removes from the table key /// </summary> /// <typeparam name="TKey"></typeparam> /// <param name="tableName"></param> /// <param name="key"></param> public void Remove <TKey>(string tableName, TKey key) { if (key == null) { throw new Exception("RandomKeySorter, key can't be null"); } byte[] btKey = DataTypesConvertor.ConvertKey <TKey>(key); var keyH = btKey.ToBytesString(); isUsed = true; if (!_cnt.ContainsKey(tableName)) { _cnt[tableName] = 0; } if (!_dRemove.ContainsKey(tableName)) { _dRemove[tableName] = new Dictionary <string, byte[]>(); } _dRemove[tableName][keyH] = btKey; _cnt[tableName]++; if (_cnt[tableName] >= AutomaticFlushLimitQuantityPerTable) { Flush(tableName); } }
/// <summary> /// /// </summary> /// <param name="tableName"></param> /// <param name="key"></param> /// <param name="value"></param> public void Insert <TKey, TValue>(string tableName, TKey key, TValue value) { if (key == null) { throw new Exception("RandomKeySorter, key can't be null"); } byte[] btKey = DataTypesConvertor.ConvertKey <TKey>(key); byte[] btValue = DataTypesConvertor.ConvertKey <TValue>(value); var keyH = btKey.ToBytesString(); isUsed = true; if (!_cnt.ContainsKey(tableName)) { _cnt[tableName] = 0; } if (!_dInsert.ContainsKey(tableName)) { _dInsert[tableName] = new Dictionary <string, KeyValuePair <byte[], byte[]> >(); } _dInsert[tableName][keyH] = new KeyValuePair <byte[], byte[]>(btKey, btValue); _cnt[tableName]++; if (_cnt[tableName] >= AutomaticFlushLimitQuantityPerTable) { Flush(tableName); } }
public Guid AddClientInformation(ClientInformation ClientInformation) { Guid ClientInformationID = new Guid("00000000-0000-0000-0000-000000000000"); SqlConnection con = new SqlConnection(GlobalSettings.connection); con.Open(); SqlCommand Cmd = new SqlCommand("sp_AddClientInformation", con); Cmd.CommandType = System.Data.CommandType.StoredProcedure; Cmd.Parameters.AddWithValue("@Title", ClientInformation.Title); Cmd.Parameters.AddWithValue("@Name", ClientInformation.Name); Cmd.Parameters.AddWithValue("@MiddleName", ClientInformation.MiddleName); Cmd.Parameters.AddWithValue("@Surname", ClientInformation.Surname); Cmd.Parameters.AddWithValue("@Gender", ClientInformation.Gender); Cmd.Parameters.AddWithValue("@DateOfBirth", DataTypesConvertor.ConvertToDateTime(ClientInformation.DateOfBirth)); Cmd.Parameters.AddWithValue("@IDNumber", ClientInformation.IDNumber); Cmd.Parameters.AddWithValue("@Cell", ClientInformation.Cell); Cmd.Parameters.AddWithValue("@TelHome", ClientInformation.TelHome); Cmd.Parameters.AddWithValue("@TelWork", ClientInformation.TelWork); Cmd.Parameters.AddWithValue("@Email", ClientInformation.Email); Cmd.Parameters.AddWithValue("@StreetNameAndNumber", ClientInformation.StreetNameAndNumber); Cmd.Parameters.AddWithValue("@Suburb", ClientInformation.Suburb); Cmd.Parameters.AddWithValue("@City", ClientInformation.City); Cmd.Parameters.AddWithValue("@PostalCode", ClientInformation.PostalCode); SqlDataReader dr = Cmd.ExecuteReader(); while (dr.Read()) { ClientInformationID = DataTypesConvertor.ConvertToGuid(dr["ClientInformationID"].ToString()); } dr.Close(); con.Close(); return(ClientInformationID); }
/// <summary> /// /// </summary> /// <param name="tableName"></param> /// <param name="key"></param> /// <param name="value"></param> public void Insert <TKey, TValue>(string tableName, TKey key, TValue value) { if (key == null) { throw new Exception("RandomKeySorter, key can't be null"); } byte[] btKey = DataTypesConvertor.ConvertKey <TKey>(key); byte[] btValue = DataTypesConvertor.ConvertKey <TValue>(value); var keyH = btKey.ToBytesString(); isUsed = true; if (!_cnt.ContainsKey(tableName)) { _cnt[tableName] = 0; } if (!_dInsert.ContainsKey(tableName)) { _dInsert[tableName] = new Dictionary <string, KeyValuePair <byte[], byte[]> >(); } _dInsert[tableName][keyH] = new KeyValuePair <byte[], byte[]>(btKey, btValue); _cnt[tableName]++; //Getting rid of Automatic flush, that makes inefficient TryGetValueByKey after flushing (will need always to check HD if not found in sorter) //if (_cnt[tableName] >= AutomaticFlushLimitQuantityPerTable) // Flush(tableName); }
/// <summary> /// Tries to grab from DBreeze first found node by supplied externalId /// or returns new DGNode (not yet saved to DB) with Node.Exists = false. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="externalId"></param> /// <param name="AsReadVisibilityScope"></param> /// <returns></returns> public DGNode GetNode <T>(T externalId, bool AsReadVisibilityScope = false) { DGNode node = null; byte[] btExId = DataTypesConvertor.ConvertKey <T>(externalId); if (externalId != null) { byte[] key = new byte[] { 1 }.Concat(btExId); foreach (var n in tran.SelectForwardStartFrom <byte[], byte[]>(tableName, key, false, AsReadVisibilityScope)) { if (!key.Substring(0, key.Length)._ByteArrayEquals(n.Key.Substring(0, key.Length))) { break; } else { node = new DGNode(btExId) { content = n.Value, graph = this, internalId = n.Key.Substring(key.Length).To_UInt32_BigEndian() }; break; } } } return(node ?? new DGNode(btExId) { graph = this }); }
/// <summary> /// Creates node (not yet saved to DB). Can be use node.Update, after node fill up. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="externalId"></param> /// <returns></returns> public DGNode NewNode <T>(T externalId) { var btExId = DataTypesConvertor.ConvertKey <T>(externalId); return(new DGNode(btExId) { graph = this }); }
/// <summary> /// SelectStartsWith. /// Value instance, when byte[], must stay immutable, please use Dbreeze.Utils.CloneArray /// </summary> /// <typeparam name="TValue"></typeparam> /// <param name="resourceNameStartsWith"></param> /// <param name="resourceSettings"></param> /// <returns></returns> public IEnumerable <KeyValuePair <string, TValue> > SelectStartsWith <TValue>(string resourceNameStartsWith, Settings resourceSettings = null) { if (!String.IsNullOrEmpty(resourceNameStartsWith)) { if (resourceSettings == null) { resourceSettings = _defaultSetting; } byte[] val = null; string rn = String.Empty; byte[] btKey = null; _sync.EnterUpgradeableReadLock(); btKey = DataTypesConvertor.ConvertKey <string>(_urp + resourceNameStartsWith); var q = LTrie.IterateForwardStartsWith(btKey, true, false); if (!resourceSettings.SortingAscending) { q = LTrie.IterateBackwardStartsWith(btKey, true, false); } foreach (var el in q) { rn = el.Key.UTF8_GetString(); if (!_d.TryGetValue(rn, out val)) { val = el.GetFullValue(false); if (resourceSettings.HoldInMemory) { _sync.EnterWriteLock(); try { _d[rn] = val; } catch (Exception) { } finally { _sync.ExitWriteLock(); } } } //no try..catch for yield return yield return(new KeyValuePair <string, TValue>(rn.Substring(1), val == null ? default(TValue) : DataTypesConvertor.ConvertBack <TValue>(val))); } _sync.ExitUpgradeableReadLock(); }//if is null or }
///// <summary> ///// Any content bound to node from outside ///// </summary> //public byte[] Content //{ // get // { // return content; // } // set // { // if (content._ByteArrayEquals(value)) // return; // content = value; // contentWasModified = true; // } //} /// <summary> /// Sets content and returns this node back /// </summary> /// <typeparam name="T"></typeparam> /// <param name="content"></param> /// <returns></returns> public DGNode SetContent <T>(T content) { byte[] c = DataTypesConvertor.ConvertValue <T>(content); if (c._ByteArrayEquals(this.content)) { return(this); } this.content = c; contentWasModified = true; return(this); }
/// <summary> /// Removes from the table key /// </summary> /// <typeparam name="TKey"></typeparam> /// <param name="tableName"></param> /// <param name="key"></param> public void Remove <TKey>(string tableName, TKey key) { if (key == null) { throw new Exception("RandomKeySorter, key can't be null"); } byte[] btKey = DataTypesConvertor.ConvertKey <TKey>(key); var keyH = btKey.ToBytesString(); isUsed = true; if (!_cnt.ContainsKey(tableName)) { _cnt[tableName] = 0; } Dictionary <string, KeyValuePair <byte[], byte[]> > dInsertTable = null; if (_dInsert.TryGetValue(tableName, out dInsertTable)) { //Trying already to remove these values //NOTE if (dInsertTable.ContainsKey(keyH)) { dInsertTable.Remove(keyH); _cnt[tableName]--; if (!WasAutomaticallyFlushed) { return; //we can go out and don't put this to _remove list if in this session we entites were not flushed due to AutomaticFlushLimitQuantityPerTable, unless we must leave them in _dRemove table, so they are deleted when using Flush() } } } if (!_dRemove.ContainsKey(tableName)) { _dRemove[tableName] = new Dictionary <string, byte[]>(); } _dRemove[tableName][keyH] = btKey; _cnt[tableName]++; //Getting rid of Automatic flush, that makes inefficient TryGetValueByKey after flushing (will need always to check HD if not found in sorter) //if (_cnt[tableName] >= AutomaticFlushLimitQuantityPerTable) // Flush(tableName); }
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="externalId"></param> /// <param name="AsReadVisibilityScope"></param> /// <returns></returns> public IEnumerable <DGNode> GetParent <T>(T externalId, bool AsReadVisibilityScope = false) { if (this.internalId == 0) //Not existing in DB node { yield return(null); } CheckGraph(); if (externalId == null) { throw new Exception("Searched ID can't be null"); } byte[] btExId = DataTypesConvertor.ConvertKey <T>(externalId); byte[] key = new byte[] { 4 }.ConcatMany(this.internalId.To_4_bytes_array_BigEndian(), btExId); byte[] key1 = null; DBreeze.DataTypes.Row <byte[], byte[]> row = null; DGNode node = null; foreach (var n in this.graph.tran.SelectForwardStartFrom <byte[], byte[]>(this.graph.tableName, key, false, AsReadVisibilityScope)) { //if (n.Key.Length <= 5) //1 - protocol + 4 bytes internalID //{ // break; //} //else if (!key.Substring(0, key.Length)._ByteArrayEquals(n.Key.Substring(0, key.Length))) { break; } else { node = new DGNode(btExId) { content = n.Value, graph = this.graph, internalId = n.Key.Substring(key.Length).To_UInt32_BigEndian() }; key1 = new byte[] { 1 }.ConcatMany(btExId, node.internalId.To_4_bytes_array_BigEndian()); row = this.graph.tran.Select <byte[], byte[]>(this.graph.tableName, key1, true); node.content = row.Value; yield return(node); } } }
public List <ClientInformation> GetAllClientInformation() { List <ClientInformation> ClientInformationDataList = new List <ClientInformation>(); SqlConnection con = new SqlConnection(GlobalSettings.connection); con.Open(); SqlCommand Cmd = new SqlCommand("sp_GetAllClientInformation", con); Cmd.CommandType = System.Data.CommandType.StoredProcedure; SqlDataReader dr = Cmd.ExecuteReader(); while (dr.Read()) { ClientInformation ClientInformation = new ClientInformation(); ClientInformation.ClientInformationID = DataTypesConvertor.ConvertToGuid(dr["ClientInformationID"].ToString()); ClientInformation.Title = dr["Title"].ToString(); ClientInformation.Name = dr["Name"].ToString(); ClientInformation.MiddleName = dr["MiddleName"].ToString(); ClientInformation.Surname = dr["Surname"].ToString(); ClientInformation.Gender = dr["Gender"].ToString(); ClientInformation.DateOfBirth = DataTypesConvertor.ConvertToDateTime(dr["DateOfBirth"].ToString()); ClientInformation.IDNumber = dr["IDNumber"].ToString(); ClientInformation.Cell = dr["Cell"].ToString(); ClientInformation.TelHome = dr["TelHome"].ToString(); ClientInformation.TelWork = dr["TelWork"].ToString(); ClientInformation.Email = dr["Email"].ToString(); ClientInformation.StreetNameAndNumber = dr["StreetNameAndNumber"].ToString(); ClientInformation.Suburb = dr["Suburb"].ToString(); ClientInformation.City = dr["City"].ToString(); ClientInformation.PostalCode = dr["PostalCode"].ToString(); ClientInformationDataList.Add(ClientInformation); } dr.Close(); con.Close(); return(ClientInformationDataList); }
public Persons GetPersonsById(int?id) { Persons personModel = new Persons(); using (SqlConnection con = new SqlConnection(CS)) { SqlCommand cmd = new SqlCommand("pr_GetPersonByCode", con); cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@code", id); con.Open(); SqlDataReader rdr = cmd.ExecuteReader(); while (rdr.Read()) { personModel.code = DataTypesConvertor.ConvertToInt(rdr["code"]); personModel.name = rdr["name"].ToString(); personModel.surname = rdr["surname"].ToString(); personModel.id_number = rdr["id_number"].ToString(); } return(personModel); } }
public Accounts GetAccountByCode(int?id) { Accounts accountModel = new Accounts(); using (SqlConnection con = new SqlConnection(CS)) { SqlCommand cmd = new SqlCommand("pr_GetAccountByCode", con); cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@code", id); con.Open(); SqlDataReader rdr = cmd.ExecuteReader(); while (rdr.Read()) { accountModel.code = DataTypesConvertor.ConvertToInt(rdr["code"]); accountModel.person_code = DataTypesConvertor.ConvertToInt(rdr["person_code"]); accountModel.account_number = rdr["account_number"].ToString(); accountModel.outstanding_balance = DataTypesConvertor.ConvertToDecimal(rdr["outstanding_balance"]); } return(accountModel); } }
/// <summary> /// Removes resources from database and In-Memory dictionary /// </summary> public void Remove(IList <string> resourcesNames) { if (resourcesNames == null || resourcesNames.Count == 0) { return; } byte[] btKey; string rn = String.Empty; _sync.EnterWriteLock(); try { foreach (var rs in resourcesNames) { if (String.IsNullOrEmpty(rs)) { continue; } rn = _urp + rs; _d.Remove(rn); btKey = DataTypesConvertor.ConvertKey <string>(rn); LTrie.Remove(ref btKey); } LTrie.Commit(); } catch (Exception ex) { throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.DBREEZE_RESOURCES_CONCERNING, "in Remove batch", ex); } finally { _sync.ExitWriteLock(); } }
public Transactions GetTransactionByCode(int?id) { Transactions accountModel = new Transactions(); using (SqlConnection con = new SqlConnection(CS)) { SqlCommand cmd = new SqlCommand("pr_GetTransactionByCode", con); cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@code", id); con.Open(); SqlDataReader rdr = cmd.ExecuteReader(); while (rdr.Read()) { accountModel.code = DataTypesConvertor.ConvertToInt(rdr["code"]); accountModel.account_code = DataTypesConvertor.ConvertToInt(rdr["person_code"]); accountModel.transaction_date = DataTypesConvertor.ConvertToDateTime(rdr["transaction_date"]); accountModel.capture_date = DataTypesConvertor.ConvertToDateTime(rdr["capture_date"]); accountModel.amount = DataTypesConvertor.ConvertToDecimal(rdr["amount"]); accountModel.description = rdr["description"].ToString(); } return(accountModel); } }
/// <summary> /// /// </summary> /// <param name="indexNumber">Must be unique for every index, will be used for searches</param> /// <param name="props">chain of data types forming byte[] index. if null is supplied existing index entry will be removed</param> public DBreezeIndex(byte indexNumber, params object[] props) { AddPrimaryToTheEnd = true; PrimaryIndex = false; if (IndexNumber == 0) { throw new Exception("DBreezeIndex: zero as index number is not allowed!"); } //if(props.Count() == 0) // throw new Exception($"DBreeze.Transaction.InsertObject: index { indexNumber } is incorrectly defined"); IndexNumber = indexNumber; if (props != null) { foreach (var prop in props) { if (prop == null) { AddPrimaryToTheEnd = false; bts.Clear(); break; } //throw new Exception($"DBreeze.Transaction.InsertObject: index { indexNumber } is incorrectly defined"); bts.Add(DataTypesConvertor.ConvertValue(prop, prop.GetType())); } } else { AddPrimaryToTheEnd = false; } }
/// <summary> /// Returns content back /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public T GetContent <T>() { return(DataTypesConvertor.ConvertBack <T>(this.content)); }
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public T ExternalId <T>() { return(DataTypesConvertor.ConvertBack <T>(externalId)); }
/// <summary> /// Gets resource from memory or database (if not yet loaded) /// Value instance, when byte[], must stay immutable, please use Dbreeze.Utils.CloneArray /// </summary> /// <typeparam name="TValue"></typeparam> /// <param name="resourceName"></param> /// <param name="resourceSettings">resource extra behaviour</param> /// <returns></returns> public TValue Select <TValue>(string resourceName, Settings resourceSettings = null) { if (String.IsNullOrEmpty(resourceName)) { return(default(TValue)); } if (resourceSettings == null) { resourceSettings = _defaultSetting; } byte[] val = null; string rn = _urp + resourceName; _sync.EnterUpgradeableReadLock(); try { if (!_d.TryGetValue(rn, out val)) { //Value is not found _sync.EnterWriteLock(); try { //At this moment value appeared if (_d.TryGetValue(rn, out val)) { return(val == null ? default(TValue) : DataTypesConvertor.ConvertBack <TValue>(val)); } //trying to get from database byte[] btKey = DataTypesConvertor.ConvertKey <string>(rn); var row = LTrie.GetKey(btKey, false, false); if (row.Exists) { val = row.GetFullValue(false); if (val == null) { if (resourceSettings.HoldInMemory) { _d[rn] = null; } return(default(TValue)); } else { if (resourceSettings.HoldInMemory) { _d[rn] = val; } return(DataTypesConvertor.ConvertBack <TValue>(val)); } } else { if (resourceSettings.HoldInMemory) { _d[rn] = null; } return(default(TValue)); } } catch (Exception ex) { throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.DBREEZE_RESOURCES_CONCERNING, "in Select 1", ex); } finally { _sync.ExitWriteLock(); } } else { return(val == null ? default(TValue) : DataTypesConvertor.ConvertBack <TValue>(val)); } } catch (System.Exception ex) { throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.DBREEZE_RESOURCES_CONCERNING, "in Select 2", ex); } finally { _sync.ExitUpgradeableReadLock(); } }
/// <summary> /// Gets resources of the same type as a batch from memory or database (if not yet loaded). /// Value instance, when byte[], must stay immutable, please use Dbreeze.Utils.CloneArray /// </summary> /// <typeparam name="TValue"></typeparam> /// <param name="resourcesNames"></param> /// <param name="resourceSettings">resource extra behaviour</param> /// <returns></returns> public IDictionary <string, TValue> Select <TValue>(IList <string> resourcesNames, Settings resourceSettings = null) { Dictionary <string, TValue> ret = new Dictionary <string, TValue>(); if (resourcesNames == null || resourcesNames.Count < 1) { return(ret); } if (resourceSettings == null) { resourceSettings = _defaultSetting; } byte[] val = null; string rn = String.Empty; //bool ba = typeof(TValue) == typeof(byte[]); _sync.EnterUpgradeableReadLock(); try { foreach (var rsn in resourcesNames.OrderBy(r => r)) { if (String.IsNullOrEmpty(rsn)) { continue; } rn = _urp + rsn; if (!_d.TryGetValue(rn, out val)) { //Value is not found _sync.EnterWriteLock(); try { //At this moment value appeared if (_d.TryGetValue(rn, out val)) { if (val != null) { ret[rsn] = DataTypesConvertor.ConvertBack <TValue>(val); } else { ret[rsn] = default(TValue); } continue; } //trying to get from database byte[] btKey = DataTypesConvertor.ConvertKey <string>(rn); var row = LTrie.GetKey(btKey, false, false); if (row.Exists) { val = row.GetFullValue(false); if (val == null) { if (resourceSettings.HoldInMemory) { _d[rn] = null; } ret[rsn] = default(TValue); } else { if (resourceSettings.HoldInMemory) { _d[rn] = val; } ret[rsn] = DataTypesConvertor.ConvertBack <TValue>(val); } } else { if (resourceSettings.HoldInMemory) { _d[rn] = null; } ret[rsn] = default(TValue); } } catch (Exception ex) { throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.DBREEZE_RESOURCES_CONCERNING, "in Select 1", ex); } finally { _sync.ExitWriteLock(); } } else { if (val == null) { ret[rsn] = default(TValue); } else { ret[rsn] = DataTypesConvertor.ConvertBack <TValue>(val); } } }//eo foreach } catch (System.Exception ex) { throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.DBREEZE_RESOURCES_CONCERNING, "in Select 2", ex); } finally { _sync.ExitUpgradeableReadLock(); } return(ret); }
/// <summary> /// Insert resource /// </summary> /// <typeparam name="TValue"></typeparam> /// <param name="resourceName"></param> /// <param name="resourceObject"></param> /// <param name="resourceSettings">resource extra behaviour</param> public void Insert <TValue>(string resourceName, TValue resourceObject, Settings resourceSettings = null) { if (String.IsNullOrEmpty(resourceName)) { return; } if (resourceSettings == null) { resourceSettings = _defaultSetting; } string rn = _urp + resourceName; byte[] btKey = DataTypesConvertor.ConvertKey <string>(rn); byte[] btValue = DataTypesConvertor.ConvertValue <TValue>(resourceObject); _sync.EnterWriteLock(); try { //------- Verification, to prevent storing of the identical value if (resourceSettings.InsertWithVerification) { byte[] btExVal = null; if (_d.TryGetValue(rn, out btExVal)) { if (btExVal._ByteArrayEquals(btValue)) { return; } } else { //Grabbing from disk if (resourceSettings.HoldOnDisk) { var row = LTrie.GetKey(btKey, false, false); if (row.Exists) { btExVal = row.GetFullValue(false); if (btExVal._ByteArrayEquals(btValue)) { if (resourceSettings.HoldInMemory) { _d[rn] = btValue; } return; } } } } } //------- if (resourceSettings.HoldOnDisk) { bool cov = LTrie.OverWriteIsAllowed; if (resourceSettings.FastUpdates) { LTrie.OverWriteIsAllowed = false; } LTrie.Add(btKey, btValue); LTrie.Commit(); if (resourceSettings.FastUpdates) { LTrie.OverWriteIsAllowed = cov; } } if (resourceSettings.HoldInMemory) { _d[rn] = btValue; } } catch (Exception ex) { throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.DBREEZE_RESOURCES_CONCERNING, "in Insert", ex); } finally { _sync.ExitWriteLock(); } #region "remark" // if (holdInMemory) // { // _sync.EnterWriteLock(); // try // { // _d[resourceName] = btValue; // } // catch (Exception ex) // { // throw ex; // } // finally // { // _sync.ExitWriteLock(); // } // } // Action a = () => // { // _sync.EnterWriteLock(); // try // { // LTrie.Add(btKey, btValue); // LTrie.Commit(); // } // catch (Exception ex) // { // throw ex; // } // finally // { // _sync.ExitWriteLock(); // } // }; //#if NET35 || NETr40 //The same must be use for .NET 4.0 // new System.Threading.Thread(new System.Threading.ThreadStart(() => // { // a(); // })).Start(); //#else // System.Threading.Tasks.Task.Run(() => { // a(); // }); //#endif #endregion }
/// <summary> /// Batch insert of resources where value is a defined DBreeze or DBreeze.CustomSerializer type /// </summary> /// <typeparam name="TValue"></typeparam> /// <param name="resources"></param> /// <param name="resourceSettings"></param> public void Insert <TValue>(IDictionary <string, TValue> resources, Settings resourceSettings = null) { this.Insert(resources.ToDictionary(r => r.Key, r => DataTypesConvertor.ConvertValue <TValue>(r.Value)), resourceSettings); }
/// <summary> /// Batch insert of resources where value is a byte[] /// </summary> /// <param name="resources"></param> /// <param name="resourceSettings">resource extra behaviour</param> public void Insert(IDictionary <string, byte[]> resources, Settings resourceSettings = null) { if (resources == null || resources.Count < 1) { return; } if (resourceSettings == null) { resourceSettings = _defaultSetting; } byte[] btKey = null; byte[] btExVal = null; string rn = String.Empty; _sync.EnterWriteLock(); try { bool cov = LTrie.OverWriteIsAllowed; if (resourceSettings.HoldOnDisk && resourceSettings.FastUpdates) { LTrie.OverWriteIsAllowed = false; } foreach (var rs in resources.OrderBy(r => r.Key)) { if (String.IsNullOrEmpty(rs.Key)) { continue; } rn = _urp + rs.Key; //------- Verification, to prevent storing of the identical value if (resourceSettings.InsertWithVerification) { if (_d.TryGetValue(rn, out btExVal)) { if (btExVal._ByteArrayEquals(rs.Value)) { continue; } } else { //Grabbing from disk if (resourceSettings.HoldOnDisk) { var row = LTrie.GetKey(btKey, false, false); if (row.Exists) { btExVal = row.GetFullValue(false); if (btExVal._ByteArrayEquals(rs.Value)) { if (resourceSettings.HoldInMemory) { _d[rn] = rs.Value; } continue; } } } } } //------- if (resourceSettings.HoldInMemory) { _d[rn] = rs.Value; } if (resourceSettings.HoldOnDisk) { btKey = DataTypesConvertor.ConvertKey <string>(rn); LTrie.Add(btKey, rs.Value); } } if (resourceSettings.HoldOnDisk) { if (resourceSettings.FastUpdates) { LTrie.OverWriteIsAllowed = cov; } LTrie.Commit(); } } catch (Exception ex) { throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.DBREEZE_RESOURCES_CONCERNING, "in Insert batch", ex); } finally { _sync.ExitWriteLock(); } }