public int ExecuteNonQuery(DbCommandWrapper dbCmdWrapper, Transaction tx)
{
int result = 0;
DbHelper dbHelper = null;
if (tx == null)
{
dbHelper = new DbHelper(conn);
}
else
{
dbHelper = new DbHelper(tx.GetConnection());
}
if (sql.Equals(""))
{
result = dbHelper.ExecuteNonQuery(dbCmdWrapper, true, storedProcName, true, tx);
logger.Write(Severity.Debug, "ExecuteNonQuery() with command wrapper and transaction - " + storedProcName);
}
else
{
result = dbHelper.ExecuteNonQuery(dbCmdWrapper, false, sql, true, tx);
logger.Write(Severity.Debug, "ExecuteNonQuery() with command wrapper and transaction - " + sql);
}
return(result);
}
public List <T> ExecuteList <T>(DbCommandWrapper dbCommandWrapper,
IDataMapper <T> dataMapper, int index, int size)
{
List <T> list = null;
DbHelper dbHelper = new DbHelper(dataSource);
if (sql.Equals(""))
{
list = dbHelper.ExecuteList <T>(dbCommandWrapper, true,
storedProcName, dataMapper, index, size);
logger.Write(Severity.Debug, "ExecuteList() with command wrapper"
+ " and paging - " + storedProcName);
}
else
{
list = dbHelper.ExecuteList <T>(dbCommandWrapper, false,
sql, dataMapper, index, size);
logger.Write(Severity.Debug, "ExecuteList() with command wrapper"
+ " and paging- " + sql);
}
return(list);
}
public int ExecuteNonQuery(DbCommandWrapper cmdWrapper,
bool isStoredProc, string cmdText, bool isTransaction, Transaction tx)
{
int result = 0;
DbCommand cmd = null;
try
{
cmd = conn.CreateCommand();
if (isTransaction)
{
cmd.Transaction = tx.GetTransaction();
}
if (isStoredProc)
{
cmd.CommandType = CommandType.StoredProcedure;
}
else
{
cmd.CommandType = CommandType.Text;
}
cmd.CommandText = cmdText;
foreach (ParameterClause param in cmdWrapper.Parameters)
{
AddParameter(cmd, param);
}
result = cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
if (cmd != null)
{
cmd.Dispose();
}
logger.Write(Severity.Error, ex.ToString());
throw ex;
}
finally
{
if (cmd != null)
{
cmd.Dispose();
}
}
return(result);
}
public object ExecuteScalar(DbCommandWrapper cmdWrapper,
bool isStoredProc, string cmdText)
{
object result = null;
DbCommand cmd = null;
try
{
cmd = conn.CreateCommand();
if (isStoredProc)
{
cmd.CommandType = CommandType.StoredProcedure;
}
else
{
cmd.CommandType = CommandType.Text;
}
cmd = conn.CreateCommand();
cmdWrapper.Command = cmd;
cmd.Connection = conn;
cmd.CommandText = cmdText;
foreach (ParameterClause param in cmdWrapper.Parameters)
{
AddParameter(cmd, param);
}
result = cmd.ExecuteScalar();
}
catch (Exception ex)
{
if (cmd != null)
{
cmd.Dispose();
}
logger.Write(Severity.Error, ex.ToString());
throw ex;
}
finally
{
if (cmd != null)
{
cmd.Dispose();
}
}
return(result);
}
public int ExecuteNonQuery(DbCommandWrapper dbCmdWrapper)
{
int result = 0;
DbHelper dbHelper = new DbHelper(conn);
if (sql.Equals(""))
{
result = dbHelper.ExecuteNonQuery(dbCmdWrapper, true, storedProcName, false, null);
logger.Write(Severity.Debug, "ExecuteNonQuery() with command wrapper - " + storedProcName);
}
else
{
result = dbHelper.ExecuteNonQuery(dbCmdWrapper, false, sql, false, null);
logger.Write(Severity.Debug, "ExecuteNonQuery() with command wrapper - " + sql);
}
return(result);
}
public object ExecuteScalar(DbCommandWrapper dbCmdWrapper)
{
object result = null;
DbHelper dbHelper = new DbHelper(conn);
if (sql.Equals(""))
{
result = dbHelper.ExecuteScalar(dbCmdWrapper, true, storedProcName);
logger.Write(Severity.Debug, "ExecuteScalar() with command wrapper - " + storedProcName);
}
else
{
result = dbHelper.ExecuteScalar(dbCmdWrapper, false, sql);
logger.Write(Severity.Debug, "ExecuteScalar() with command wrapper - " + sql);
}
return(result);
}
public DataSet ExecuteDataSet(DbCommandWrapper dbCmdWrapper)
{
DataSet dataSet = null;
DbHelper dbHelper = new DbHelper(dataSource);
if (sql.Equals(""))
{
dataSet = dbHelper.ExecuteDataSet(dbCmdWrapper, true, storedProcName);
logger.Write(Severity.Debug, "ExecuteDataSet() with command wrapper - " + storedProcName);
}
else
{
dataSet = dbHelper.ExecuteDataSet(dbCmdWrapper, false, sql);
logger.Write(Severity.Debug, "ExecuteDataSet() with command wrapper - " + sql);
}
return(dataSet);
}
public IDataReader ExecuteReader(DbCommandWrapper dbCmdWrapper)
{
IDataReader rdr = null;
DbHelper dbHelper = new DbHelper(conn);
if (sql.Equals(""))
{
rdr = dbHelper.ExecuteReader(dbCmdWrapper, true, storedProcName);
logger.Write(Severity.Debug, "ExecuteReader() with command wrapper - " + storedProcName);
}
else
{
rdr = dbHelper.ExecuteReader(dbCmdWrapper, false, sql);
logger.Write(Severity.Debug, "ExecuteReader() with command wrapper - " + sql);
}
return(rdr);
}
public List <T> ExecuteList <T>(DbCommandWrapper dbCmdWrapper,
DataMapperDelegate <T> dataMapper)
{
List <T> list = null;
DbHelper dbHelper = new DbHelper(conn);
if (sql.Equals(""))
{
list = dbHelper.ExecuteList <T>(dbCmdWrapper, true,
storedProcName, dataMapper);
logger.Write(Severity.Debug, "ExecuteList() with command wrapper and delegate - " + storedProcName);
}
else
{
list = dbHelper.ExecuteList <T>(dbCmdWrapper, false,
sql, dataMapper);
logger.Write(Severity.Debug, "ExecuteList() with command wrapper and delegate - " + sql);
}
return(list);
}
public T ExecuteObject <T>(DbCommandWrapper dbCmdWrapper,
IDataMapper <T> dataMapper)
{
T obj = default(T);
DbHelper dbHelper = new DbHelper(conn);
if (sql.Equals(""))
{
obj = dbHelper.ExecuteObject <T>(dbCmdWrapper, true,
storedProcName, dataMapper);
logger.Write(Severity.Debug, "ExecuteObject() with command wrapper - " + storedProcName);
}
else
{
obj = dbHelper.ExecuteObject <T>(dbCmdWrapper, false,
sql, dataMapper);
logger.Write(Severity.Debug, "ExecuteObject() with command wrapper - " + sql);
}
return(obj);
}
public List <T> ExecuteList <T>(DbCommandWrapper cmdWrapper, bool isStoredProc,
string sql, IDataMapper <T> dataMapper, int index, int size)
{
List <T> list = new List <T>();
IDataReader rdr = null;
DataSet dataSet = null;
DbCommand cmd = null;
DbDataAdapter da = null;
DbProviderFactory factory = null;
try
{
factory = DbProviderFactories.GetFactory(dataSource.Provider);
da = factory.CreateDataAdapter();
cmd = conn.CreateCommand();
cmdWrapper.Command = cmd;
cmd.Connection = conn;
if (isStoredProc)
{
cmd.CommandType = CommandType.StoredProcedure;
}
else
{
cmd.CommandType = CommandType.Text;
}
cmd.CommandText = sql;
dataSet = new DataSet();
da.SelectCommand = cmd;
da.Fill(dataSet, index, size, typeof(T).ToString());
foreach (ParameterClause param in cmdWrapper.Parameters)
{
AddParameter(cmd, param);
}
rdr = dataSet.Tables[typeof(T).ToString()].CreateDataReader();
while (rdr.Read())
{
list.Add(dataMapper.Map(rdr));
}
}
catch (Exception ex)
{
logger.Write(Severity.Error, ex.ToString());
if (cmd != null)
{
cmd.Dispose();
}
if (da != null)
{
da.Dispose();
}
if (dataSet != null)
{
dataSet.Dispose();
}
if (rdr != null)
{
rdr.Close();
}
throw ex;
}
finally
{
if (cmd != null)
{
cmd.Dispose();
}
if (da != null)
{
da.Dispose();
}
if (dataSet != null)
{
dataSet.Dispose();
}
if (rdr != null)
{
rdr.Close();
}
}
return(list);
}
public List <T> ExecuteList <T>(DbCommandWrapper cmdWrapper, bool isStoredProc,
string cmdText, Origami.Data.DataContext.DataMapperDelegate <T> dataMapper)
{
List <T> list = new List <T>();
DbCommand cmd = null;
IDataReader rdr = null;
try
{
cmd = conn.CreateCommand();
cmdWrapper.Command = cmd;
if (isStoredProc)
{
cmd.CommandType = CommandType.StoredProcedure;
}
else
{
cmd.CommandType = CommandType.Text;
}
cmd.CommandText = cmdText;
foreach (ParameterClause param in cmdWrapper.Parameters)
{
AddParameter(cmd, param);
}
cmd.CommandText = cmdText;
rdr = cmd.ExecuteReader();
while (rdr.Read())
{
list.Add(dataMapper.Invoke(rdr));
}
}
catch (Exception ex)
{
logger.Write(Severity.Error, ex.ToString());
if (cmd != null)
{
cmd.Dispose();
}
if (rdr != null)
{
rdr.Close();
}
throw ex;
}
finally
{
if (cmd != null)
{
cmd.Dispose();
}
if (rdr != null)
{
rdr.Close();
}
}
return(list);
}
public T ExecuteObject <T>(DbCommandWrapper cmdWrapper, bool isStoredProc,
string cmdText, IDataMapper <T> dataMapper)
{
T obj = default(T);
DbCommand cmd = null;
IDataReader rdr = null;
try
{
cmd = conn.CreateCommand();
cmdWrapper.Command = cmd;
if (isStoredProc)
{
cmd.CommandType = CommandType.StoredProcedure;
}
else
{
cmd.CommandType = CommandType.Text;
}
cmd.CommandText = cmdText;
foreach (ParameterClause param in cmdWrapper.Parameters)
{
AddParameter(cmd, param);
}
rdr = cmd.ExecuteReader();
if (rdr.Read())
{
obj = dataMapper.Map(rdr);
}
}
catch (Exception ex)
{
if (cmd != null)
{
cmd.Dispose();
}
if (rdr != null)
{
rdr.Close();
}
logger.Write(Severity.Error, ex.ToString());
throw ex;
}
finally
{
if (cmd != null)
{
cmd.Dispose();
}
if (rdr != null)
{
rdr.Close();
}
}
return(obj);
}
public DataSet ExecuteDataSet(DbCommandWrapper cmdWrapper,
bool isStoredProc, string cmdText)
{
DataSet dataSet = null;
DbCommand cmd = null;
DbDataAdapter da = null;
DbProviderFactory factory = null;
try
{
factory = DbProviderFactories.GetFactory(dataSource.Provider);
da = factory.CreateDataAdapter();
cmd.Connection = conn;
cmd = conn.CreateCommand();
cmdWrapper.Command = cmd;
if (isStoredProc)
{
cmd.CommandType = CommandType.StoredProcedure;
}
else
{
cmd.CommandType = CommandType.Text;
}
cmd.CommandText = cmdText;
dataSet = new DataSet();
foreach (ParameterClause param in cmdWrapper.Parameters)
{
AddParameter(cmd, param);
}
da.SelectCommand = cmd;
da.Fill(dataSet);
}
catch (Exception ex)
{
if (da != null)
{
da.Dispose();
}
if (cmd != null)
{
cmd.Dispose();
}
logger.Write(Severity.Error, ex.ToString());
throw ex;
}
finally
{
if (cmd != null)
{
cmd.Dispose();
}
}
return(dataSet);
}
