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();
}
}
