public bool UpdateBlockset(string hash, IEnumerable <string> blocklisthashes, System.Data.IDbTransaction transaction) { m_findblocklisthashCommand.Transaction = transaction; m_findblocklisthashCommand.SetParameterValue(0, hash); var r = m_findblocklisthashCommand.ExecuteScalar(); if (r != null && r != DBNull.Value) { return(false); } m_insertBlockset.Transaction = transaction; m_insertBlockset.SetParameterValue(0, hash); var index = 0L; foreach (var s in blocklisthashes) { m_insertBlockset.SetParameterValue(1, s); m_insertBlockset.SetParameterValue(2, index++); m_insertBlockset.ExecuteNonQuery(); } return(true); }
/// <summary> /// 判断数据库中是否存在指定的对象 /// </summary> /// <param name="obj">对象</param> /// <returns>true:数据库中存在指定关键字的记录 false:数据库中不存在指定关键字的记录</returns> public bool Contains(object obj) { if (obj == null) { throw new ArgumentNullException("obj"); } this.CheckBindInfo(obj.GetType(), true); this.CheckConnetion(); TableBindInfo table = this.GetBindInfo(obj.GetType()); System.Collections.ArrayList values = new System.Collections.ArrayList(); string strSQL = this.BuildCondition(obj, values); bool result = false; if (strSQL != null) { using (System.Data.IDbCommand cmd = myConnection.CreateCommand()) { strSQL = "Select 1 from " + FixTableName(table.TableName) + " Where " + strSQL; cmd.CommandText = strSQL; foreach (object v in values) { System.Data.IDbDataParameter p = cmd.CreateParameter(); p.Value = v; cmd.Parameters.Add(p); } object v2 = cmd.ExecuteScalar(); if (v2 != null && DBNull.Value.Equals(v2) == false) { result = (Convert.ToInt32(v2) == 1); } } } return(false); }
public void RunUpgradeScripts(System.Data.IDbConnection connection) { System.Data.IDbCommand cmd = connection.CreateCommand(); cmd.Connection = connection; cmd.CommandText = "SELECT VersionNumber from DbConfig order by VersionNumber desc LIMIT 1"; int latestVersion = 0; object result = null; try { result = cmd.ExecuteScalar(); } catch (System.Data.Common.DbException) { result = null; latestVersion = 0; } catch (Exception ex) { throw (ex); } if (result != null && !String.IsNullOrEmpty(result.ToString())) { if (!int.TryParse(result.ToString(), out latestVersion)) { latestVersion = 0; } } InitScripts(); UpgradeAll(connection, latestVersion); }
/// <summary> /// 执行查询,并返回查询所返回的结果集中第一行的第一列。 /// </summary> /// <param name="sql">要对数据源执行的 Transact-SQL 语句或存储过程。</param> /// <param name="commandTimeout">在终止执行命令的尝试并生成错误之前的等待时间。-1 表示使用默认值 30 秒。</param> /// <param name="commandType">该值指示如何解释 CommandText 属性。</param> /// <param name="dataParameters">与 Command 对象有关的参数及其到 DataSet 列的映射。如无参数可为 null。</param> /// <returns>从数据库中检索的第一行、第一列的单个值(例如一个聚合值)。</returns> public object ExecuteScalar(string sql, int commandTimeout, System.Data.CommandType commandType, params System.Data.IDbDataParameter[] dataParameters) { #if DEBUG if (this.IsCloseOutputSQL == false) { System.Diagnostics.Debug.WriteLine(sql); } #endif System.Data.IDbCommand cmd = this.m_Conn.CreateCommand(); cmd.CommandText = sql; if (commandTimeout != -1) { cmd.CommandTimeout = commandTimeout; } cmd.CommandType = commandType; if (dataParameters != null) { foreach (System.Data.IDbDataParameter dataParameter in dataParameters) { if (dataParameter != null) { cmd.Parameters.Add(dataParameter); } } } return(cmd.ExecuteScalar()); }
/// <summary> /// Adds a file record to the database /// </summary> /// <param name="filename">The path to the file</param> /// <param name="scantime">The time the file was scanned</param> /// <param name="blocksetID">The ID of the hashkey for the file</param> /// <param name="metadataID">The ID for the metadata</param> /// <param name="transaction">The transaction to use for insertion, or null for no transaction</param> /// <param name="operationId">The operationId to use, or -1 to use the current operation</param> public void AddFile(string filename, DateTime scantime, long blocksetID, long metadataID, System.Data.IDbTransaction transaction) { object fileidobj = null; PathEntryKeeper entry = null; bool entryFound = false; if (m_pathLookup != null) { if (entryFound = (m_pathLookup.TryFind(filename, out entry) && entry != null)) { var fid = entry.GetFilesetID(blocksetID, metadataID); if (fid >= 0) { fileidobj = fid; } } } else { m_findfilesetCommand.Transaction = transaction; m_findfilesetCommand.SetParameterValue(0, blocksetID); m_findfilesetCommand.SetParameterValue(1, metadataID); m_findfilesetCommand.SetParameterValue(2, filename); fileidobj = m_findfilesetCommand.ExecuteScalar(); } if (fileidobj == null || fileidobj == DBNull.Value) { using (var tr = new TemporaryTransactionWrapper(m_connection, transaction)) { m_insertfileCommand.Transaction = tr.Parent; m_insertfileCommand.SetParameterValue(0, filename); m_insertfileCommand.SetParameterValue(1, blocksetID); m_insertfileCommand.SetParameterValue(2, metadataID); fileidobj = Convert.ToInt64(m_insertfileCommand.ExecuteScalar()); tr.Commit(); // We do not need to update this, because we will not ask for the same file twice if (m_pathLookup != null) { if (!entryFound) { entry = new PathEntryKeeper(-1, DateTime.UtcNow); entry.AddFilesetID(blocksetID, metadataID, Convert.ToInt64(fileidobj)); m_pathLookup.Insert(filename, entry); } else { entry.AddFilesetID(blocksetID, metadataID, Convert.ToInt64(fileidobj)); } } } } m_insertfileOperationCommand.Transaction = transaction; m_insertfileOperationCommand.SetParameterValue(0, m_filesetId); m_insertfileOperationCommand.SetParameterValue(1, fileidobj); m_insertfileOperationCommand.SetParameterValue(2, NormalizeDateTimeToEpochSeconds(scantime)); m_insertfileOperationCommand.ExecuteNonQuery(); }
public virtual T ExecuteScalar <T>(System.Data.IDbCommand cmd, bool throwOnAssignNullToNonNullableType) { object objReturnValue = null; using (System.Data.IDbConnection idbc = this.Connection) { cmd.Connection = idbc; try { if (cmd.Connection.State != System.Data.ConnectionState.Open) { cmd.Connection.Open(); } objReturnValue = cmd.ExecuteScalar(); } // End Try catch (System.Data.Common.DbException ex) { if (Log(ex, cmd)) { throw; } } // End Catch finally { if (cmd.Connection.State != System.Data.ConnectionState.Closed) { cmd.Connection.Close(); } } // End Finally } // End using idbc return(ConvertResult <T>(objReturnValue, throwOnAssignNullToNonNullableType)); } // End Function ExecuteScalar(cmd)
public bool UseBlock(string hash, long size, System.Data.IDbTransaction transaction) { m_command.Transaction = transaction; m_command.SetParameterValue(0, hash); m_command.SetParameterValue(1, size); var r = m_command.ExecuteScalar(); return(r != null && r != DBNull.Value); }
/// <summary> /// Adds a block to the local database, returning a value indicating if the value presents a new block /// </summary> /// <param name="key">The block key</param> /// <param name="archivename">The name of the archive that holds the data</param> /// <returns>True if the block should be added to the current output</returns> public bool AddBlock(string key, long size, long volumeid, System.Data.IDbTransaction transaction = null) { object r = null; if (m_blockHashLookup != null) { KeyValuePair <long, long> blockid; if (m_blockHashLookup.TryGet(key, size, out blockid)) { return(false); } } else { m_findblockCommand.Transaction = transaction; m_findblockCommand.SetParameterValue(0, key); m_findblockCommand.SetParameterValue(1, size); r = m_findblockCommand.ExecuteScalar(); } if (r == null || r == DBNull.Value) { m_insertblockCommand.Transaction = transaction; m_insertblockCommand.SetParameterValue(0, key); m_insertblockCommand.SetParameterValue(1, volumeid); m_insertblockCommand.SetParameterValue(2, size); r = m_insertblockCommand.ExecuteScalar(); if (m_blockHashLookup != null) { m_blockHashLookup.Add(key, size, new KeyValuePair <long, long>(Convert.ToInt64(r), size)); } return(true); } else { //We add/update it now if (m_blockHashLookup != null) { m_blockHashLookup.Add(key, size, new KeyValuePair <long, long>(Convert.ToInt64(r), size)); } //If the block is found and the volume is broken somehow. m_findremotevolumestateCommand.Transaction = transaction; r = m_findremotevolumestateCommand.ExecuteScalar(null, r); if (r != null && (r.ToString() == RemoteVolumeState.Temporary.ToString() || r.ToString() == RemoteVolumeState.Uploading.ToString() || r.ToString() == RemoteVolumeState.Uploaded.ToString() || r.ToString() == RemoteVolumeState.Verified.ToString())) { return(false); } else { m_updateblockCommand.Transaction = transaction; m_updateblockCommand.ExecuteNonQuery(null, volumeid, key, size); return(true); } } }
protected override void SaveModel(System.Data.IDbCommand command, T model) { SetParameters(command, model); command.CommandText = getSingleString; bool exists = command.ExecuteScalar() != null; command.CommandText = exists ? update : insert; command.ExecuteNonQuery(); command.Parameters.Clear(); }
private void AddEntry(FilelistEntryType type, long filesetid, string path, DateTime time, long blocksetid, string metahash, long metahashsize, System.Data.IDbTransaction transaction) { var fileid = -1L; var metadataid = AddMetadataset(metahash, metahashsize, transaction); if (m_filesetLookup != null) { PathEntryKeeper e; if (m_filesetLookup.TryFind(path, out e)) { fileid = e.GetFilesetID(blocksetid, metadataid); } } else { m_findFilesetCommand.Transaction = transaction; m_findFilesetCommand.SetParameterValue(0, path); m_findFilesetCommand.SetParameterValue(1, blocksetid); m_findFilesetCommand.SetParameterValue(2, metadataid); var r = m_findFilesetCommand.ExecuteScalar(); if (r != null && r != DBNull.Value) { fileid = Convert.ToInt64(r); } } if (fileid < 0) { m_insertFileCommand.Transaction = transaction; m_insertFileCommand.SetParameterValue(0, path); m_insertFileCommand.SetParameterValue(1, blocksetid); m_insertFileCommand.SetParameterValue(2, metadataid); fileid = Convert.ToInt64(m_insertFileCommand.ExecuteScalar()); if (m_filesetLookup != null) { PathEntryKeeper e; if (m_filesetLookup.TryFind(path, out e)) { e.AddFilesetID(blocksetid, metadataid, fileid); } else { e = new PathEntryKeeper(); e.AddFilesetID(blocksetid, metadataid, fileid); m_filesetLookup.Insert(path, e); } } } m_insertFilesetEntryCommand.Transaction = transaction; m_insertFilesetEntryCommand.SetParameterValue(0, filesetid); m_insertFilesetEntryCommand.SetParameterValue(1, fileid); m_insertFilesetEntryCommand.SetParameterValue(2, NormalizeDateTimeToEpochSeconds(time)); m_insertFilesetEntryCommand.ExecuteNonQuery(); }
public long AddBlockset(string fullhash, long size, IEnumerable <string> blocklisthashes, System.Data.IDbTransaction transaction) { var blocksetid = -1L; if (m_fileHashLookup != null) { if (m_fileHashLookup.TryGet(fullhash, size, out blocksetid)) { return(blocksetid); } else { blocksetid = -1; } } else { m_findBlocksetCommand.Transaction = transaction; m_findBlocksetCommand.SetParameterValue(0, size); m_findBlocksetCommand.SetParameterValue(1, fullhash); var r = m_findBlocksetCommand.ExecuteScalar(); if (r != null && r != DBNull.Value) { return(Convert.ToInt64(r)); } } m_insertBlocksetCommand.Transaction = transaction; m_insertBlocksetCommand.SetParameterValue(0, size); m_insertBlocksetCommand.SetParameterValue(1, fullhash); blocksetid = Convert.ToInt64(m_insertBlocksetCommand.ExecuteScalar()); if (m_fileHashLookup != null) { m_fileHashLookup.Add(fullhash, size, blocksetid); } if (blocklisthashes != null) { var index = 0L; m_insertBlocklistHashCommand.Transaction = transaction; m_insertBlocklistHashCommand.SetParameterValue(0, blocksetid); foreach (var hash in blocklisthashes) { if (!string.IsNullOrEmpty(hash)) { m_insertBlocklistHashCommand.SetParameterValue(1, index++); m_insertBlocklistHashCommand.SetParameterValue(2, hash); m_insertBlocklistHashCommand.ExecuteNonQuery(); } } } return(blocksetid); }
public Object LookupValue(String dataTable, String fieldExpression, String criteria, Object defaultValue) { System.Text.StringBuilder sqlStatement = new StringBuilder(); System.Data.IDbCommand lookupCommand = null; Object returnValue = null; try { SetLastException(null); OnDemandOpen(); sqlStatement.Append("SELECT " + fieldExpression + " FROM " + dataTable); if (criteria.Length > 0) { sqlStatement.Append(" WHERE " + criteria); } // end if lastSqlStatement = sqlStatement.ToString(); lookupCommand = CreateCommand(sqlStatement.ToString()); lock (sqlLock) { returnValue = lookupCommand.ExecuteScalar(); } } // end try catch (System.Data.SqlClient.SqlException SqlException) { SetLastException(SqlException); } // end catch (SqlException) catch (Exception LookupException) { SetLastException(LookupException); throw; } // end catch (Exception) finally { if (lookupCommand != null) { lookupCommand.Dispose(); } OnDemandClose(); } // end finally if (returnValue == null) // TODO: monitor for C# impacts with DBNull { returnValue = defaultValue; } // end if return(returnValue); }
public string GetFileHash(long fileid) { m_selectfileHashCommand.SetParameterValue(0, fileid); var r = m_selectfileHashCommand.ExecuteScalar(); if (r == null || r == DBNull.Value) { return(null); } return(r.ToString()); }
private long GetLastFilesetID(System.Data.IDbCommand cmd) { long id = -1; var r = cmd.ExecuteScalar(@"SELECT ""ID"" FROM ""Fileset"" ORDER BY ""Timestamp"" DESC LIMIT 1"); if (r != null && r != DBNull.Value) { id = Convert.ToInt64(r); } return(id); }
private long GetPreviousFilesetID(System.Data.IDbCommand cmd, DateTime timestamp, long filesetid) { long lastFilesetId = -1; var lastIdObj = cmd.ExecuteScalar(@"SELECT ""ID"" FROM ""Fileset"" WHERE ""Timestamp"" < ? AND ""ID"" != ? ORDER BY ""Timestamp"" DESC ", NormalizeDateTimeToEpochSeconds(timestamp), filesetid); if (lastIdObj != null && lastIdObj != DBNull.Value) { lastFilesetId = Convert.ToInt64(lastIdObj); } return(lastFilesetId); }
public Int32 GetMax(QueryObject queryobject, ClientEnvironment clientEnvironment) { System.Data.IDbCommand cmd = clientEnvironment.connection.CreateCommand(); cmd.Parameters.Clear(); cmd.CommandText = GetMaxSelect(); if (clientEnvironment.transaction != null) { cmd.Transaction = clientEnvironment.transaction; } return(Convert.ToInt32(cmd.ExecuteScalar()) + 1); }
public long GetRemoteVolumeID(string file, System.Data.IDbTransaction transaction = null) { m_selectremotevolumeIdCommand.Transaction = transaction; var o = m_selectremotevolumeIdCommand.ExecuteScalar(null, file); if (o == null || o == DBNull.Value) { return(-1); } else { return(Convert.ToInt64(o)); } }
public long RegisterRemoteVolume(string name, RemoteVolumeType type, RemoteVolumeState state, System.Data.IDbTransaction transaction = null) { using (var tr = new TemporaryTransactionWrapper(m_connection, transaction)) { m_createremotevolumeCommand.SetParameterValue(0, m_operationid); m_createremotevolumeCommand.SetParameterValue(1, name); m_createremotevolumeCommand.SetParameterValue(2, type.ToString()); m_createremotevolumeCommand.SetParameterValue(3, state.ToString()); m_createremotevolumeCommand.SetParameterValue(4, 0); m_createremotevolumeCommand.Transaction = tr.Parent; var r = Convert.ToInt64(m_createremotevolumeCommand.ExecuteScalar()); tr.Commit(); return(r); } }
public static object ExecuteScalar(this System.Data.IDbCommand self, string cmd, params object[] values) { if (cmd != null) { self.CommandText = cmd; } if (values != null && values.Length > 0) { self.Parameters.Clear(); foreach (var n in values) { self.AddParameter(n); } } if (Logging.Log.LogLevel != Duplicati.Library.Logging.LogMessageType.Profiling) { return(self.ExecuteScalar()); } using (new Logging.Timer(LC.L("ExecuteScalar: {0}", self.CommandText))) return(self.ExecuteScalar()); }
private long AddMetadataset(string metahash, long metahashsize, System.Data.IDbTransaction transaction) { var metadataid = -1L; if (metahash == null) { return(metadataid); } if (m_metadataLookup != null) { if (m_metadataLookup.TryGet(metahash, metahashsize, out metadataid)) { return(metadataid); } else { metadataid = -1; } } else { m_findMetadatasetCommand.Transaction = transaction; m_findMetadatasetCommand.SetParameterValue(0, metahash); m_findMetadatasetCommand.SetParameterValue(1, metahashsize); var r = m_findMetadatasetCommand.ExecuteScalar(); if (r != null && r != DBNull.Value) { return(Convert.ToInt64(r)); } } var blocksetid = AddBlockset(metahash, metahashsize, null, transaction); m_insertMetadatasetCommand.Transaction = transaction; m_insertMetadatasetCommand.SetParameterValue(0, blocksetid); metadataid = Convert.ToInt64(m_insertMetadatasetCommand.ExecuteScalar()); if (m_metadataLookup != null) { m_metadataLookup.Add(metahash, metahashsize, metadataid); } return(metadataid); }
/// <summary> /// Adds a metadata set to the database, and returns a value indicating if the record was new /// </summary> /// <param name="hash">The metadata hash</param> /// <param name="metadataid">The id of the metadata set</param> /// <returns>True if the set was added to the database, false otherwise</returns> public bool AddMetadataset(string hash, long size, out long metadataid, System.Data.IDbTransaction transaction = null) { if (size > 0) { if (m_metadataLookup != null) { if (m_metadataLookup.TryGet(hash, size, out metadataid)) { return(false); } } else { m_findmetadatasetProbeCommand.Transaction = transaction; var r = m_findmetadatasetProbeCommand.ExecuteScalar(null, hash, size); if (r != null && r != DBNull.Value) { m_findmetadatasetCommand.Transaction = transaction; m_findmetadatasetCommand.ExecuteScalar(null, hash, size); } } long blocksetid; AddBlockset(hash, size, (int)size, new string[] { hash }, null, out blocksetid, transaction); using (var tr = new TemporaryTransactionWrapper(m_connection, transaction)) { m_insertmetadatasetCommand.Transaction = tr.Parent; m_insertmetadatasetCommand.SetParameterValue(0, blocksetid); metadataid = Convert.ToInt64(m_insertmetadatasetCommand.ExecuteScalar()); tr.Commit(); if (m_metadataLookup != null) { m_metadataLookup.Add(hash, size, metadataid); } } return(true); } metadataid = -2; return(false); }
internal long GetMaxId(string rootDriveName) { if (indexDbConn == null) // error : to be called only after Open() { throw new Exception("Not available in this context. Must be called after Open()"); } string query = "SELECT MAX(i.id) FROM items i, bchunks b, rootdrives r WHERE " + " i.bchunk = b.id AND b.rootdrive = r.id AND r.name = '" + rootDriveName + "'"; System.Data.IDbCommand itemC = indexDbConn.CreateCommand(); itemC.CommandText = query; long maxid = -1; try{ maxid = (long)itemC.ExecuteScalar(); } catch {} return(maxid); }
public static object ExecuteScalar(this System.Data.IDbCommand self, string cmd, params object[] values) { if (cmd != null) { self.CommandText = cmd; } if (values != null && values.Length > 0) { self.Parameters.Clear(); foreach (var n in values) { self.AddParameter(n); } } using (new Logging.Timer(LOGTAG, "ExecuteScalar", string.Format("ExecuteScalar: {0}", self.CommandText))) return(self.ExecuteScalar()); }
internal static object Read(string key) { using (System.Data.IDbConnection connection = GetConnection(Durados.Workflow.JavaScript.GetCacheInCurrentRequest(Durados.Workflow.JavaScript.ConnectionStringKey).ToString())) { connection.Open(); string sql = string.Format("select scalar from durados_session where sessionId = '{0}' and [name] = '{1}'", key, System.Web.HttpContext.Current.Items[Durados.Database.Username].ToString()); using (System.Data.IDbCommand command = GetCommand(sql, connection)) { object scalar = command.ExecuteScalar(); if (scalar == null || scalar == DBNull.Value) { return(null); } else { return(scalar.ToString()); } } } }
public bool UseBlock(string hash, long size) { if (m_lookup != null) { long nsize; if (m_lookup.TryGet(hash, size, out nsize) && nsize == size) { return(true); } else { return(false); } } m_command.SetParameterValue(0, hash); m_command.SetParameterValue(1, size); var r = m_command.ExecuteScalar(); return(r != null && r != DBNull.Value); }
} // LookupValue public Object ExecuteScalar(String sqlStatement) { Object scalarResult = null; System.Data.IDbCommand scalarCommand = null; try { SetLastException(null); lastSqlStatement = sqlStatement; OnDemandOpen(); scalarCommand = CreateCommand(sqlStatement); scalarCommand.CommandTimeout = 0; lock (sqlLock) { scalarResult = scalarCommand.ExecuteScalar(); } } catch (Exception databaseException) { SetLastException(databaseException); throw databaseException; } finally { if (scalarCommand != null) { scalarCommand.Dispose(); } OnDemandClose(); } return(scalarResult); }
public void UpdateBlockset(string hash, IEnumerable <string> blocklisthashes, System.Data.IDbTransaction transaction) { if (m_blockListHashLookup != null) { bool b; if (m_blockListHashLookup.TryGet(hash, -1, out b)) { return; } } else { m_findblocklisthashCommand.Transaction = transaction; m_findblocklisthashCommand.SetParameterValue(0, hash); var r = m_findblocklisthashCommand.ExecuteScalar(); if (r != null && r != DBNull.Value) { return; } } if (m_blockListHashLookup != null) { m_blockListHashLookup.Add(hash, -1, false); } m_insertBlockset.Transaction = transaction; m_insertBlockset.SetParameterValue(0, hash); var index = 0L; foreach (var s in blocklisthashes) { m_insertBlockset.SetParameterValue(1, s); m_insertBlockset.SetParameterValue(2, index++); m_insertBlockset.ExecuteNonQuery(); } }
} // End Sub ExecuteNonQuery public static object ExecuteScalar(string strSQL) { object obj = null; using (System.Data.IDbConnection con = new FbConnection(GetConnectionString())) { try { if (con.State != System.Data.ConnectionState.Open) { con.Open(); } using (System.Data.IDbCommand cmd = con.CreateCommand()) { cmd.CommandText = strSQL; obj = cmd.ExecuteScalar(); } // End Using System.Data.IDbCommand cmd } // End Try catch (System.Data.Common.DbException ex) { System.Console.WriteLine(ex.Message); throw; } // End Catch finally { if (con != null) { if (con.State != System.Data.ConnectionState.Closed) { con.Close(); } } // End if (con != null) } // End Finally } // End Using System.Data.IDbConnection con return(obj); } // End Function ExecuteScalar
private void CreateSchemaAndUser(string sql, System.Data.IDbConnection connection) { if (connection == null) { throw new Exception("Failed to set a connection to external available instance"); } if (connection.State == System.Data.ConnectionState.Closed) { connection.Open(); } using (System.Data.IDbTransaction transaction = connection.BeginTransaction(System.Data.IsolationLevel.ReadCommitted)) { using (System.Data.IDbCommand command = connection.CreateCommand()) { command.Transaction = transaction; command.CommandText = sql; try { //if (command.Connection.State == System.Data.ConnectionState.Closed) // command.Connection.Open(); command.ExecuteScalar(); transaction.Commit(); } catch (Exception ex) { if (connection != null && connection.State != System.Data.ConnectionState.Closed) { transaction.Rollback(); } Maps.Instance.DuradosMap.Logger.Log("AppFactory", null, "CreateNewSchemaAndUser", ex, 1, "Faild to create new schema for new rds app"); throw new Exception("Faild to create new schema for new rds app", ex); } } } }
public void UpdateBlock(string hash, long size, long volumeID, System.Data.IDbTransaction transaction) { var currentVolumeId = -2L; if (m_blockHashLookup != null) { if (!m_blockHashLookup.TryGet(hash, size, out currentVolumeId)) { currentVolumeId = -2; } } else { m_findHashBlockCommand.Transaction = transaction; m_findHashBlockCommand.SetParameterValue(0, hash); m_findHashBlockCommand.SetParameterValue(1, size); var r = m_findHashBlockCommand.ExecuteScalar(); if (r != null && r != DBNull.Value) { currentVolumeId = Convert.ToInt64(r); } } if (currentVolumeId == volumeID) { return; } if (currentVolumeId == -2) { //Insert m_insertBlockCommand.Transaction = transaction; m_insertBlockCommand.SetParameterValue(0, hash); m_insertBlockCommand.SetParameterValue(1, size); m_insertBlockCommand.SetParameterValue(2, volumeID); m_insertBlockCommand.ExecuteNonQuery(); if (m_blockHashLookup != null) { m_blockHashLookup.Add(hash, size, volumeID); } } else if (currentVolumeId == -1) { //Update m_updateBlockVolumeCommand.Transaction = transaction; m_updateBlockVolumeCommand.SetParameterValue(0, volumeID); m_updateBlockVolumeCommand.SetParameterValue(1, hash); m_updateBlockVolumeCommand.SetParameterValue(2, size); var c = m_updateBlockVolumeCommand.ExecuteNonQuery(); if (c != 1) { throw new Exception(string.Format("Failed to update table, found {0} entries for key {1} with size {2}", c, hash, size)); } if (m_blockHashLookup != null) { m_blockHashLookup.Add(hash, size, volumeID); } } else { m_insertDuplicateBlockCommand.Transaction = transaction; m_insertDuplicateBlockCommand.SetParameterValue(0, hash); m_insertDuplicateBlockCommand.SetParameterValue(1, size); m_insertDuplicateBlockCommand.SetParameterValue(2, volumeID); m_insertDuplicateBlockCommand.ExecuteNonQuery(); } }