/// <summary>
/// Initializes a new instance of the <see cref="IDbCommandCreatorFactory"/> class.
/// </summary>
public IDbCommandCreatorFactory(IDbProvider dbProvider, CommandType commandType, string sql, IDbParameters declaredParameters)
{
this.dbProvider = dbProvider;
this.sql = sql;
this.commandType = commandType;
this.declaredParameters = declaredParameters;
}
/// <summary>
/// Copies the parameters from IDbParameters to the parameter collection in IDbCommand
/// </summary>
/// <param name="command">The command.</param>
/// <param name="springParamCollection">The spring param collection.</param>
public static void CopyParameters(IDbCommand command, IDbParameters springParamCollection)
{
if (springParamCollection != null)
{
IDataParameterCollection collection = springParamCollection.DataParameterCollection;
foreach (IDbDataParameter parameter in collection)
{
IDbDataParameter pClone = (IDbDataParameter)((ICloneable)parameter).Clone();
command.Parameters.Add(pClone);
}
}
}
public DataTable ExecuteQueryAll(string tableName, IDbParameters parameters,string paramMark)
{
string query = "SELECT * FROM " + tableName;
if(parameters.Count > 0)
{
query += " WHERE ";
}
int countParams = 0;
foreach (IDataParameter dbParameter in parameters.DataParameterCollection)
{
countParams++;
if (countParams > 1) query += " AND ";
string columnName = dbParameter.ParameterName;
if(columnName.StartsWith("@")) columnName = columnName.Substring(1);
query += " " + columnName + "=" + paramMark + dbParameter.ParameterName;
}
return AdoTemplate.DataTableCreateWithParams(CommandType.Text, query, parameters);
}
/// <summary>
/// Executes a non query returning the number of rows affected.
/// </summary>
/// <param name="cmdType">The command type.</param>
/// <param name="cmdText">The command text to execute.</param>
/// <param name="parameters">The parameter collection to map.</param>
/// <returns>The number of rows affected.</returns>
public virtual int ExecuteNonQuery(CommandType cmdType, string cmdText,
IDbParameters parameters)
{
#region Instrumentation
if (LOG.IsDebugEnabled)
{
LOG.Debug("Executing NonQuery. " + cmdType + "[" + cmdText + "]");
}
#endregion
return (int)Execute(new ExecuteNonQueryCallbackWithParameters(cmdType, cmdText, parameters));
}
public virtual void QueryWithRowCallback(CommandType cmdType, string cmdText, IRowCallback rowCallback, IDbParameters parameters)
{
QueryWithResultSetExtractor(cmdType, cmdText, new RowCallbackResultSetExtractor(rowCallback), parameters);
}
public DataAdapterUpdateWithCommandBuilderCallback(DataTable dataTable,
object commandBuilder,
ITableMappingCollection mappingCollection,
CommandType selectCommandType,
string selectSql,
IDbParameters selectParameters,
IDataAdapterSetter dataAdapterSetter)
{
containsDataSet = false;
this.dataTable = dataTable;
this.commandBuilder = commandBuilder;
this.mappingCollection = mappingCollection;
this.selectCommandType = selectCommandType;
this.selectSql = selectSql;
this.selectParameters = selectParameters;
this.dataAdapterSetter = dataAdapterSetter;
}
public ExecuteScalarCallbackWithParameters(CommandType cmdType, string cmdText, IDbParameters dbParameters)
{
commandType = cmdType;
commandText = cmdText;
parameters = dbParameters;
}
public static DateTime DoExtract(BaseWNOSPlugin plugin, SpringBaseDao baseDao, string storedProcName,
int commandTimeout)
{
plugin.AppendAuditLogEvent("Executing stored procedure \"{0}\" with timeout of {1} seconds ...",
storedProcName, commandTimeout.ToString());
DateTime runtime = DateTime.Now;
try
{
IDbParameters parameters = baseDao.AdoTemplate.CreateDbParameters();
parameters.AddWithValue(p_run_parm, "NORMAL");
IDbDataParameter runtimeTextParameter = parameters.AddOut(p_runtime_txt, DbType.String, 2048);
IDbDataParameter runtimeParameter = parameters.AddOut(p_runtime, DbType.Date);
baseDao.AdoTemplate.Execute <int>(delegate(DbCommand command)
{
command.CommandType = CommandType.StoredProcedure;
command.CommandText = storedProcName;
command.CommandTimeout = commandTimeout;
Spring.Data.Support.ParameterUtils.CopyParameters(command, parameters);
try
{
SpringBaseDao.ExecuteCommandWithTimeout(command, commandTimeout, delegate(DbCommand commandToExecute)
{
commandToExecute.ExecuteNonQuery();
});
}
catch (Exception ex2)
{
command.Connection.Close();
plugin.AppendAuditLogEvent("Error returned from stored procedure: {0}", ExceptionUtils.GetDeepExceptionMessage(ex2));
throw;
}
if (command.Parameters[runtimeTextParameter.ParameterName].Value != DBNull.Value)
{
string procMessage = command.Parameters[runtimeTextParameter.ParameterName].Value.ToString();
procMessage = procMessage.Replace("\r\n", "\r");
procMessage = procMessage.Replace("\r", "\r\n");
plugin.AppendAuditLogEvent(procMessage);
}
if (command.Parameters[runtimeParameter.ParameterName].Value != DBNull.Value)
{
runtime = DateTime.Parse(command.Parameters[runtimeParameter.ParameterName].Value.ToString());
}
return(0);
});
plugin.AppendAuditLogEvent("Successfully executed stored procedure \"{0}\"", storedProcName);
}
catch (Exception e)
{
plugin.AppendAuditLogEvent("Failed to execute stored procedure \"{0}\" with error: {1}",
storedProcName, ExceptionUtils.GetDeepExceptionMessage(e));
throw;
}
return(runtime);
}
protected virtual void ValidateFillWithParameterArguments(DataSet dataSet, string sql, IDbParameters parameters, ITableMappingCollection tableMapping)
{
ValidateFillWithParameterArguments(dataSet, sql, parameters);
if (tableMapping == null)
{
throw new ArgumentNullException("tableMapping", "ITableMappingCollection for DataSet Fill operations can not be null");
}
}
public void ExecuteNonQueryText()
{
int age = 18;
int counter = 0;
String sql = String.Format("insert into TestObjects(Age, Name) VALUES ({0}, '{1}')",
age++, "George" + counter++);
adoOperations.ExecuteNonQuery(CommandType.Text, sql);
sql = "insert into TestObjects(Age,Name) values (@Age,@Name)";
//One liners are hard due to no standard 'fallback' to use of '?' for property
//placeholders. Providers that use named parameters must always use named
//parameters in SQL string.
//NamedParameterAdoOperations ...
//More portable IDbDataParameterCollection implemenation.
// -> IDbParameters
//Functionality of .NET 2.0 DbParameterCollection + common helper methods that
//are commonly found (still) in subclasses.
//How to create parameter collections?
//1. Get as much milage/portabiliyt out of basic provider interface and
// IDbDataParameter/IDataParameterCollection
// DbParameter/DbParameterCollection
// a. Must use only base DbType (can't cast as no shared base enumeration)
// b. Must use parameter prefix
// c. CLR null and DBNull.Value mapping.
// c. IsNullable is not writable in IDbDataParameter interface (1.1 only)
// c2. SourceColumnNullMapping?
// d. No convenient Add( parameter data ) methods in
// base Parameter Collection classes
// despite prevalence in provider implementations.
// d1. re-use of parameters - parameters are aware if they have been added to
// a collection of another command object.
// e. verbose
IDbParameters parametersCreated = new DbParameters(dbProvider);
IDbDataParameter p = dbProvider.CreateParameter();
p.ParameterName = "@Name";
p.DbType = DbType.String;
p.Size = 12;
p.Value = "George" + counter++;
parametersCreated.AddParameter(p);
IDbDataParameter p2 = dbProvider.CreateParameter();
p2.ParameterName = "@Age";
p2.DbType = DbType.Int32;
p2.Value = age++;
parametersCreated.AddParameter(p2);
adoOperations.ExecuteNonQuery(CommandType.Text, sql, parametersCreated);
//2. Use IDbParameters abstraction.
// e. less verbose...
IDbParameters parameters = adoOperations.CreateDbParameters();
parameters.Add("Name", DbType.String, 12).Value = "George" + counter++;
parameters.Add("Age", SqlDbType.Int).Value = age++;
//Better to use date example...people like to pick provider specific subtype..
//parameters.AddWithValue("Age", age++);
//parameters get 'cloned' before association with command, output values
//are re-associated, and so the parameter collection is re-usable.
adoOperations.ExecuteNonQuery(CommandType.Text, sql, parameters);
}
public static string DoExtract(BaseWNOSPlugin plugin, SpringBaseDao etlDao, string storedProcName,
int commandTimeout)
{
if (string.IsNullOrEmpty(storedProcName))
{
plugin.AppendAuditLogEvent("An ETL stored procedure was not specified, so none was executed");
return(null);
}
plugin.AppendAuditLogEvent("Executing ETL stored procedure \"{0}\" with timeout of {1} seconds ...",
storedProcName, commandTimeout.ToString());
string pk = null;
try
{
IDbParameters parameters = etlDao.AdoTemplate.CreateDbParameters();
IDbDataParameter pkParameter = parameters.AddOut(p_pk_param_name, DbType.String, 50);
etlDao.AdoTemplate.Execute <int>(delegate(DbCommand command)
{
command.CommandType = CommandType.StoredProcedure;
command.CommandText = storedProcName;
command.CommandTimeout = commandTimeout;
Spring.Data.Support.ParameterUtils.CopyParameters(command, parameters);
try
{
SpringBaseDao.ExecuteCommandWithTimeout(command, commandTimeout, delegate(DbCommand commandToExecute)
{
commandToExecute.ExecuteNonQuery();
plugin.AppendAuditLogEvent("Successfully executed ETL stored procedure \"{0}\"", storedProcName);
});
}
catch (Exception spEx)
{
plugin.AppendAuditLogEvent("Failed to execute ETL stored procedure \"{0}\" with error: {1}",
storedProcName, ExceptionUtils.GetDeepExceptionMessage(spEx));
throw;
}
if (command.Parameters[pkParameter.ParameterName].Value == DBNull.Value)
{
// This indicates plugin processing should stop
plugin.AppendAuditLogEvent("The ETL stored procedure \"{0}\" returned NULL for the \"{1}\" out parameter",
storedProcName, p_pk_param_name);
return(0);
}
pk = command.Parameters[pkParameter.ParameterName].Value.ToString();
if (string.IsNullOrEmpty(pk))
{
throw new ArgException("The ETL stored procedure \"{0}\" returned an empty string value for the \"{1}\" out parameter",
storedProcName, p_pk_param_name);
}
return(0);
});
}
catch (Exception e)
{
plugin.AppendAuditLogEvent("Failed to perform extract with error: {0}", ExceptionUtils.GetDeepExceptionMessage(e));
throw;
}
return(pk);
}
protected List <string> GetSqlWhereAndPms(out IDbParameters pms)
{
List <string> list = new List <string>();
pms = Template.CreateDbParameters();
#region 基本的
if (!string.IsNullOrWhiteSpace(Id))
{
list.Add("a.\"Id\"=@Id");
pms.AddWithValue("Id", Id);
}
if (!string.IsNullOrWhiteSpace(OperatorId))
{
list.Add("a.\"OperatorId\"=@OperatorId");
pms.AddWithValue("OperatorId", OperatorId);
}
if (StartCreateTime != null)
{
list.Add("a.\"CreateTime\">=@StartCreateTime");
pms.AddWithValue("StartCreateTime", StartCreateTime);
}
if (EndCreateTime != null)
{
list.Add("a.\"CreateTime\"<=@EndCreateTime");
pms.AddWithValue("EndCreateTime", EndCreateTime);
}
if (!string.IsNullOrWhiteSpace(Remark))
{
list.Add("a.\"Remark\" like @Remark");
pms.AddWithValue("Remark", Remark.Wrap("%"));
}
if (!string.IsNullOrWhiteSpace(PrincipalId))
{
list.Add("a.\"PrincipalId\" = @PrincipalId");
pms.AddWithValue("PrincipalId", PrincipalId);
}
#endregion
if (!string.IsNullOrWhiteSpace(SheepId))
{
list.Add("a.\"SheepId\"=@SheepId");
pms.AddWithValue("SheepId", SheepId);
}
if (MaxWeight != null)
{
list.Add("a.\"Weight\"<=@MaxWeight");
pms.AddWithValue("MaxWeight", MaxWeight);
}
if (MinWeight != null)
{
list.Add("a.\"Weight\">=@MinWeight");
pms.AddWithValue("MinWeight", MinWeight);
}
if (MaxHabitusScore != null)
{
list.Add("a.\"HabitusScore\"<=@MaxHabitusScore");
pms.AddWithValue("MaxHabitusScore", MaxHabitusScore);
}
if (MinHabitusScore != null)
{
list.Add("a.\"HabitusScore\">=@MinHabitusScore");
pms.AddWithValue("MinHabitusScore", MinHabitusScore);
}
if (StartAssessDate != null)
{
list.Add("a.\"AssessDate\">=@StartAssessDate");
pms.AddWithValue("StartAssessDate", StartAssessDate);
}
if (EndAssessDate != null)
{
list.Add("a.\"AssessDate\"<=@EndAssessDate");
pms.AddWithValue("EndAssessDate", EndAssessDate);
}
if (Gender != null)
{
list.Add("s.\"Gender\"=@Gender");
pms.AddWithValue("Gender", (int)Gender);
}
if (!string.IsNullOrWhiteSpace(BreedId))
{
list.Add("b.\"Id\"=@BreedId");
pms.AddWithValue("BreedId", BreedId);
}
return(list);
}
/// <summary>
/// 执行SQL, 返回DataTable
/// </summary>
/// <param name="connString">the ConnectionString</param>
/// <param name="commandText">the execute sql</param>
/// <param name="parameterValues">参数</param>
/// <returns></returns>
public DataTable StoredExecuteDataTable(string connString, string commandText, IDbParameters parameterValues)
{
return(DataTableHelper.GetTable(ExecuteDataset(connString, CommandType.StoredProcedure, commandText, TIMEOUT_DEFAULT, parameterValues)));
}
/// <summary>
/// 可以使用 ExecuteNonQuery 执行编录操作（例如查询数据库的结构或创建诸如表等的数据库对象），或通过执行 UPDATE、INSERT 或 DELETE 语句更改数据库中的数据
/// </summary>
/// <param name="cmdText">sql语句</param>
/// <param name="parameters">DbCommand 的参数</param>
/// <returns>受影响的行数</returns>
public int ExecuteNonQuery(string cmdText, IDbParameters parameters)
{
return(this.ExecuteNonQuery(System.Data.CommandType.Text, cmdText, parameters));
}
/// <summary>
/// 执行查询，将结果集返回到一个DataTable
/// </summary>
/// <param name="commandType">指定如何解释命令字符串</param>
/// <param name="cmdText">sql语句</param>
/// <param name="parameters">DbCommand 的参数</param>
/// <returns>结果集</returns>
public System.Data.DataTable QueryDataTable(System.Data.CommandType commandType, string cmdText, IDbParameters parameters)
{
System.Data.DataTable result = null;
try
{
DbConnection connection = (DbConnection)this.Session.Connection;
ITransaction trans = this.Session.Transaction;
DbCommand command = connection.CreateCommand();
command.CommandText = cmdText;
command.CommandType = commandType;
if (null != parameters)
{
ParameterUtils.CopyParameters(command, parameters);
}
trans.Enlist(command);
result = new System.Data.DataTable();
System.Data.DataRow dt_dr = null;
using (DbDataReader dr = command.ExecuteReader())
{
int index = 0;
while (dr.Read())
{
if (index == 0)
{
for (int i = 0; i < dr.FieldCount; i++)
{
result.Columns.Add(dr.GetName(i), dr.GetFieldType(i));
}
}
dt_dr = result.NewRow();
for (int i = 0; i < dr.FieldCount; i++)
{
dt_dr[i] = dr[i];
}
result.Rows.Add(dt_dr);
index++;
}
}
}
catch (DbException e)
{
ExceptionHandler.AsynchronousThreadExceptionHandler = new DbExceptionHandler();
ExceptionHandler.AsynchronousThreadExceptionHandler.HandleException(e);
}
return(result);
}
/// <summary>
/// 执行查询，并返回查询所返回的结果集中第一行的第一列。所有其他的列和行将被忽略。
/// </summary>
/// <param name="cmdText">sql语句</param>
/// <param name="parameters">DbCommand 的参数</param>
/// <returns>结果集中第一行的第一列</returns>
public object ExecuteScalar(string cmdText, IDbParameters parameters)
{
return(this.ExecuteScalar(System.Data.CommandType.Text, cmdText, parameters));
}
public virtual IList QueryWithRowMapperDelegate(CommandType cmdType, string cmdText, RowMapperDelegate rowMapperDelegate,
IDbParameters parameters)
{
return (IList)QueryWithResultSetExtractor(cmdType, cmdText, new RowMapperResultSetExtractor(rowMapperDelegate), parameters);
}
public virtual int DataSetUpdateWithCommandBuilder(DataSet dataSet,
CommandType commandType,
string selectSql,
IDbParameters selectParameters,
ITableMappingCollection mappingCollection,
IDataAdapterSetter dataAdapterSetter)
{
ValidateUpdateWithCommandBuilderArguments(dataSet, mappingCollection, selectSql);
return (int)Execute(new DataAdapterUpdateWithCommandBuilderCallback(dataSet,
DbProvider.CreateCommandBuilder(),
mappingCollection,
commandType,
selectSql,
selectParameters,
dataAdapterSetter));
}
/// <summary>
/// Execute a query with the specified command text and parameters, mapping a single result row
/// to an object via a RowMapper.
/// </summary>
/// <param name="cmdType">The command type.</param>
/// <param name="cmdText">The command text to execute.</param>
/// <param name="rowMapperDelegate">delegate that will map one object per row</param>
/// <param name="parameters">The parameter collection to use in the query.</param>
/// <returns>The single mapped object.</returns>
/// <exception cref="Spring.Dao.IncorrectResultSizeDataAccessException">
/// If the query does not return exactly one row.
/// </exception>
/// <exception cref="Spring.Dao.DataAccessException">
/// If there is any problem executing the query.
/// </exception>
public virtual object QueryForObjectDelegate(CommandType cmdType, string cmdText, RowMapperDelegate rowMapperDelegate, IDbParameters parameters)
{
IList results = QueryWithRowMapperDelegate(cmdType, cmdText, rowMapperDelegate, parameters);
return DataAccessUtils.RequiredUniqueResultSet(results);
}
public int DataTableUpdate(DataTable dataTable,
ITableMappingCollection mappingCollection,
CommandType insertCommandtype, string insertSql, IDbParameters insertParameters,
CommandType updateCommandtype, string updateSql, IDbParameters updateParameters,
CommandType deleteCommandtype, string deleteSql, IDbParameters deleteParameters,
IDataAdapterSetter dataAdapterSetter)
{
//TODO - refactor to remove cut-n-pasted code.
IDbCommand insertCommand = null;
if (insertSql != null)
{
insertCommand = DbProvider.CreateCommand();
insertCommand.CommandType = insertCommandtype;
insertCommand.CommandText = insertSql;
ParameterUtils.CopyParameters(insertCommand, insertParameters);
}
IDbCommand updateCommand = null;
if (updateSql != null)
{
updateCommand = DbProvider.CreateCommand();
updateCommand.CommandType = updateCommandtype;
updateCommand.CommandText = updateSql;
ParameterUtils.CopyParameters(updateCommand, updateParameters);
}
IDbCommand deleteCommand = null;
if (deleteSql != null)
{
deleteCommand = DbProvider.CreateCommand();
deleteCommand.CommandType = deleteCommandtype;
deleteCommand.CommandText = deleteSql;
ParameterUtils.CopyParameters(deleteCommand, deleteParameters);
}
int returnVal = (int)Execute(new DataAdapterUpdateCallback(dataTable, mappingCollection,
insertCommand, updateCommand, deleteCommand, null));
if (insertSql != null)
{
ParameterUtils.CopyParameters(insertParameters, insertCommand);
}
if (updateSql != null)
{
ParameterUtils.CopyParameters(updateParameters, updateCommand);
}
if (deleteSql != null)
{
ParameterUtils.CopyParameters(deleteParameters, deleteCommand);
}
return returnVal;
}
public virtual int DataSetUpdateWithCommandBuilder(DataSet dataSet,
CommandType commandType,
string selectSql,
IDbParameters selectParameters,
string tableName)
{
ValidateUpdateWithCommandBuilderArguments(dataSet, tableName, selectSql);
ITableMappingCollection mappingCollection = DoCreateMappingCollection(new string[] { tableName });
return (int)Execute(new DataAdapterUpdateWithCommandBuilderCallback(dataSet,
DbProvider.CreateCommandBuilder(),
mappingCollection,
commandType,
selectSql,
selectParameters,
null));
}
public void DataSetUpdate()
{
//'pretend' unique key is the age...
String sql = "select USER_ID, USER_NAME from USER_TABLE";
DataSet dataSet = new DataSet();
adoOperations.DataSetFill(dataSet, CommandType.Text, sql, new string[] { "TestObjects" });
//Create and add new row.
DataRow myDataRow = dataSet.Tables["TestObjects"].NewRow();
myDataRow["USER_ID"] = 101;
myDataRow["USER_NAME"] = "OldManWinter";
dataSet.Tables["TestObjects"].Rows.Add(myDataRow);
IDbParameters parameters = adoOperations.CreateDbParameters();
//TODO - remembering the -1 isn't all that natural... add string name, dbtype, string sourceCol)
//or AddSourceCol("age", SqlDbType.Int); would copy into source col?
parameters.Add("id", OracleType.Int32, -1, "USER_ID");
parameters.Add("name", DbType.String, 12, "USER_NAME");
//Extanious CommandTypes....
adoOperations.DataSetUpdate(dataSet, "TestObjects",
CommandType.Text,
"insert into USER_TABLE(USER_ID, USER_NAME) values (:id,:name)", parameters,
CommandType.Text, null, null,
CommandType.Text, null, null);
//TODO - think about api...
/*
* IDbCommand insertCommand = dbProvider.CreateCommand();
* insertCommand.CommandText = "insert into USER_TABLE(USER_ID, USER_NAME) values (:id,:name)";
* parameters = adoOperations.NewDbParameters();
* //TODO - remembering the -1 isn't all that natural... add string name, dbtype, string sourceCol)
* //or AddSourceCol("age", SqlDbType.Int); would copy into source col?
* parameters.Add("id", OracleType.Int32, -1, "USER_ID");
* parameters.Add("name", DbType.String, 12, "USER_NAME");
*
* //TODO - this isn't all that natural...
* ParameterUtils.CopyParameters(insertCommand, parameters);
*
*
* adoOperations.DataSetUpdate(dataSet, "TestObjects",
* insertCommand,
* null,
* null);
*
*/
//TODO avoid param Utils copy by adding argument...
//adoOperations.DataSetUpdate(dataSet, "TestObjects",
// insertCommand, parameters,
// null, null,
// null, null);
// or avoid all ref to command object....
//adoOperations.DataSetUpdate(dataSet, "TestObjects",
// CommandType type, string sql, parameters,
// null, null,
// null, null);
//TODO how about breaking up the operations...
}
public virtual int DataSetUpdate(DataSet dataSet,
string tableName,
CommandType insertCommandtype, string insertSql, IDbParameters insertParameters,
CommandType updateCommandtype, string updateSql, IDbParameters updateParameters,
CommandType deleteCommandtype, string deleteSql, IDbParameters deleteParameters)
{
ValidateUpdateArguments(dataSet, tableName);
IDbCommand insertCommand = null;
if (insertSql != null)
{
insertCommand = DbProvider.CreateCommand();
insertCommand.CommandType = insertCommandtype;
insertCommand.CommandText = insertSql;
ParameterUtils.CopyParameters(insertCommand, insertParameters);
}
IDbCommand updateCommand = null;
if (updateSql != null)
{
updateCommand = DbProvider.CreateCommand();
updateCommand.CommandType = updateCommandtype;
updateCommand.CommandText = updateSql;
ParameterUtils.CopyParameters(updateCommand, updateParameters);
}
IDbCommand deleteCommand = null;
if (deleteSql != null)
{
deleteCommand = DbProvider.CreateCommand();
deleteCommand.CommandType = deleteCommandtype;
deleteCommand.CommandText = deleteSql;
ParameterUtils.CopyParameters(deleteCommand, deleteParameters);
}
ITableMappingCollection mappingCollection = DoCreateMappingCollection(new string[] { tableName });
int returnVal = (int)Execute(new DataAdapterUpdateCallback(dataSet, mappingCollection,
insertCommand, updateCommand, deleteCommand, null));
if (insertSql != null)
{
ParameterUtils.CopyParameters(insertParameters, insertCommand);
}
if (updateSql != null)
{
ParameterUtils.CopyParameters(updateParameters, updateCommand);
}
if (deleteSql != null)
{
ParameterUtils.CopyParameters(deleteParameters, deleteCommand);
}
return returnVal;
}
public virtual int DataTableUpdateWithCommandBuilder(DataTable dataTable,
CommandType commandType,
string selectSql,
IDbParameters parameters,
ITableMapping tableMapping,
IDataAdapterSetter dataAdapterSetter)
{
ValidateUpdateWithCommandBuilderArguments(dataTable, tableMapping, selectSql);
ITableMappingCollection mappingCollection = new DataTableMappingCollection();
mappingCollection.Add(tableMapping);
return (int)Execute(new DataAdapterUpdateWithCommandBuilderCallback(dataTable,
DbProvider.CreateCommandBuilder(),
mappingCollection,
commandType,
selectSql,
parameters,
dataAdapterSetter));
}
protected virtual void ValidateFillWithParameterArguments(DataSet dataSet, string sql, IDbParameters parameters)
{
ValidateFillArguments(dataSet, sql);
if (parameters == null)
{
throw new ArgumentNullException("parameters", "IDbParameters for DataSet Fill operations can not be null");
}
}
public virtual int DataTableUpdate(DataTable dataTable,
string tableName,
CommandType insertCommandtype, string insertSql, IDbParameters insertParameters,
CommandType updateCommandtype, string updateSql, IDbParameters updateParameters,
CommandType deleteCommandtype, string deleteSql, IDbParameters deleteParameters,
IDataAdapterSetter dataAdapterSetter)
{
ValidateUpdateArguments(dataTable, tableName);
ITableMappingCollection mappingCollection = DoCreateMappingCollection(new string[] { tableName });
return DataTableUpdate(dataTable, mappingCollection,
insertCommandtype, insertSql, insertParameters,
updateCommandtype, updateSql, updateParameters,
deleteCommandtype, deleteSql, deleteParameters,
dataAdapterSetter);
}
public DataAdapterFillCallback(DataTable dataTable,
CommandType commandType,
string sql,
ITableMappingCollection mappingCollection,
IDataAdapterSetter dataAdapterSetter,
IDataSetFillLifecycleProcessor fillLifecycleProcessor,
IDbParameters parameters)
{
containsDataSet = false;
this.dataTable = dataTable;
this.commandType = commandType;
this.sql = sql;
this.mappingCollection = mappingCollection;
this.dataAdapterSetter = dataAdapterSetter;
this.fillLifecycleProcessor = fillLifecycleProcessor;
this.parameters = parameters;
}
public virtual int DataTableUpdate(DataTable dataTable,
ITableMapping tableMapping,
CommandType insertCommandtype, string insertSql, IDbParameters insertParameters,
CommandType updateCommandtype, string updateSql, IDbParameters updateParameters,
CommandType deleteCommandtype, string deleteSql, IDbParameters deleteParameters,
IDataAdapterSetter dataAdapterSetter)
{
ValidateUpdateArguments(dataTable, tableMapping);
ITableMappingCollection mappingCollection = new DataTableMappingCollection();
mappingCollection.Add((object)tableMapping);
return DataTableUpdate(dataTable, mappingCollection,
insertCommandtype, insertSql, insertParameters,
updateCommandtype, updateSql, updateParameters,
deleteCommandtype, deleteSql, deleteParameters,
dataAdapterSetter);
}
public ExecuteNonQueryCallbackWithParameters(CommandType commandType, string commandText, IDbParameters dbParameters)
{
this.commandType = commandType;
this.commandText = commandText;
parameters = dbParameters;
}
public virtual DataSet DataSetCreateWithParams(CommandType commandType, string sql,
IDbParameters parameters,
string[] tableNames)
{
DataSet dataSet = CreateDataSet();
DataSetFillWithParameters(dataSet, commandType, sql, parameters, tableNames);
return dataSet;
}
public QueryCallback(AdoTemplate adoTemplate, CommandType cmdType, string cmdText, ResultSetExtractorDelegate resultSetExtractorDelegate, IDbParameters dbParameters)
{
this.adoTemplate = adoTemplate;
commandType = cmdType;
commandText = cmdText;
this.resultSetExtractorDelegate = resultSetExtractorDelegate;
parameters = dbParameters;
}
public virtual DataSet DataSetCreateWithParams(CommandType commandType, string sql,
IDbParameters parameters,
ITableMappingCollection tableMapping)
{
DataSet dataSet = CreateDataSet();
DataSetFillWithParameters(dataSet, commandType, sql, parameters, tableMapping);
return dataSet;
}
/// <summary>
/// Execute the query with the specified command text and parameters returning a scalar result
/// </summary>
/// <param name="cmdType">The command type</param>
/// <param name="cmdText">The command text to execute.</param>
/// <param name="parameters">The parameter collection to map.</param>
/// <returns>The first column of the first row in the result set</returns>
public virtual object ExecuteScalar(CommandType cmdType, string cmdText,
IDbParameters parameters)
{
return Execute(new ExecuteScalarCallbackWithParameters(cmdType, cmdText, parameters));
}
public virtual DataSet DataSetCreateWithParams(CommandType commandType, string sql,
IDbParameters parameters,
ITableMappingCollection tableMapping,
IDataAdapterSetter dataAdapterSetter,
IDataSetFillLifecycleProcessor fillLifecycleProcessor)
{
DataSet dataSet = CreateDataSet();
DataSetFillWithParameters(dataSet, commandType, sql, parameters, tableMapping, dataAdapterSetter, fillLifecycleProcessor);
return dataSet;
}
public virtual void QueryWithRowCallbackDelegate(CommandType cmdType, string sql, RowCallbackDelegate rowCallbackDelegate, IDbParameters parameters)
{
QueryWithResultSetExtractor(cmdType, sql, new RowCallbackResultSetExtractor(rowCallbackDelegate), parameters);
}
public virtual int DataSetFillWithParameters(DataSet dataSet, CommandType commandType, string sql,
IDbParameters parameters,
string[] tableNames)
{
ValidateFillWithParameterArguments(dataSet, sql, parameters);
if (tableNames == null)
{
tableNames = new string[] { "Table" };
}
ITableMappingCollection tableMapping = DoCreateMappingCollection(tableNames);
return (int)Execute(new DataAdapterFillCallback(dataSet,
commandType, sql,
tableMapping, null, null, parameters));
}
public virtual object QueryWithResultSetExtractorDelegate(CommandType cmdType, string cmdText, ResultSetExtractorDelegate resultSetExtractorDelegate,
IDbParameters parameters)
{
AssertUtils.ArgumentNotNull(resultSetExtractorDelegate, "resultSetExtractorDelegate", "Result set extractor delegate must not be null");
return Execute(new QueryCallback(this, cmdType, cmdText, resultSetExtractorDelegate, parameters));
}
public virtual int DataSetFillWithParameters(DataSet dataSet, CommandType commandType, string sql,
IDbParameters parameters,
ITableMappingCollection tableMapping)
{
ValidateFillWithParameterArguments(dataSet, sql, parameters, tableMapping);
return (int)Execute(new DataAdapterFillCallback(dataSet,
commandType, sql,
tableMapping, null, null, parameters));
}
public virtual int DataSetFillWithParameters(DataSet dataSet, CommandType commandType, string sql,
IDbParameters parameters,
ITableMappingCollection tableMapping,
IDataAdapterSetter dataAdapterSetter,
IDataSetFillLifecycleProcessor fillLifecycleProcessor)
{
ValidateFillWithParameterArguments(dataSet, sql, parameters, tableMapping);
return (int)Execute(new DataAdapterFillCallback(dataSet,
commandType, sql,
tableMapping, dataAdapterSetter, fillLifecycleProcessor, parameters));
}
/// <summary>
/// Initializes a new instance of the <see cref="IDbCommandCreatorFactory"/> class.
/// </summary>
public IDbCommandCreatorFactory(IDbProvider dbProvider, CommandType commandType, string sql, IDbParameters declaredParameters)
{
this.dbProvider = dbProvider;
this.sql = sql;
this.commandType = commandType;
this.declaredParameters = declaredParameters;
}
