namespace Microshaoft
{
using System;
using System.IO;
using System.Data;
using System.Data.SqlClient;
using System.CodeDom;
using System.CodeDom.Compiler;
using Microsoft.CSharp;
using Microshaoft.Data;
public class Class1
{
[STAThread]
static void Main(string[] args)
{
string spName = "sp_test";
//spName = args[0];
string _ConnectionString = @"application name=test;Integrated Security=SSPI;Persist Security Info=False;Initial Catalog=VNet3Center;Data Source=.\sqlexpress";
SqlConnection sc = new SqlConnection(_ConnectionString);
string s = GenerateCode(spName, true, sc, "Microshaoft", "Class1");
//string s = "asdsad";
System.Windows.Forms.Clipboard.SetDataObject(s);
Console.WriteLine(s);
}
public static string GenerateCode
(
string spName
, bool includeReturnValueParameter
, SqlConnection connection
, string nameSpace
, string className
)
{
SqlParameter[] spa = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
int length = spa.Length;
CSharpCodeProvider provider = new CSharpCodeProvider();
//ICodeGenerator generator = provider.CreateGenerator();
CodeCompileUnit ccu = new CodeCompileUnit();
CodeNamespace cn = new CodeNamespace(nameSpace); //添加名称空间
cn.Imports.Add(new CodeNamespaceImport("System"));
cn.Imports.Add(new CodeNamespaceImport("System.Data"));
cn.Imports.Add(new CodeNamespaceImport("System.Data.SqlClient"));
//cn.Imports.Add(new CodeNamespaceImport("Microshaoft.Data"));
CodeTypeDeclaration ctd = new CodeTypeDeclaration(className);
System.CodeDom.CodeMemberField cmf = new CodeMemberField(new CodeTypeReference(typeof(string)),"_ConnectionString");
cmf.Attributes = MemberAttributes.Static | MemberAttributes.Public;
cmf.InitExpression = new CodeSnippetExpression("@\"" + connection.ConnectionString + "\"" );//new CodePrimitiveExpression(connection.ConnectionString);
ctd.Members.Add(cmf);
//int rows = spa.Length;
CodeMemberMethod cmm = new CodeMemberMethod();
CodeSnippetStatement css = null;
css = new CodeSnippetStatement("SqlConnection connection = new SqlConnection(_ConnectionString);");
cmm.Statements.Add(css);
//css = new CodeSnippetStatement("SqlParameter[] parameters = new SqlParameter[" + (length+1).ToString() + "];");
//cmm.Statements.Add(css);
css = new CodeSnippetStatement(string.Format("SqlCommand command = new SqlCommand(\"{0}\", connection);", spName));
cmm.Statements.Add(css);
css = new CodeSnippetStatement("command.CommandType = CommandType.StoredProcedure;");
cmm.Statements.Add(css);
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Name = "ExecProc_" + spName;
cmm.Attributes = MemberAttributes.Public| MemberAttributes.Final | MemberAttributes.Static;
int i = 1;
CodeStatementCollection csc = new CodeStatementCollection();
foreach (SqlParameter parameter in spa)
{
string paramName = "p_" + parameter.ParameterName.Substring(1);
string paramTypeName = GetTypeName(parameter.SqlDbType);
CodeTypeReference paramType = new CodeTypeReference(paramTypeName);
//paramType.ToString();
CodeParameterDeclarationExpression cpde = new CodeParameterDeclarationExpression(paramType, paramName);
//css = new CodeSnippetStatement("parameters[" + i.ToString() + "] = new SqlParameter(\"" + parameter.ParameterName + "\", SqlDbType." + parameter.SqlDbType + ");");
//css = new CodeSnippetStatement("SqlParameter parameter" + i.ToString() + " = new SqlParameter(\"" + parameter.ParameterName + "\", SqlDbType." + parameter.SqlDbType + ");");
//cmm.Statements.Add(css);
if (paramTypeName == "System.String")
{
css = new CodeSnippetStatement(string.Format("SqlParameter parameter" + i.ToString() + " = command.Parameters.Add(\"{0}\", SqlDbType.{1}, {2});", parameter.ParameterName, parameter.SqlDbType, parameter.Size));
cmm.Statements.Add(css);
}
else if (paramTypeName == "System.String")
{
}
else
{
css = new CodeSnippetStatement(string.Format("SqlParameter parameter" + i.ToString() + " = command.Parameters.Add(\"{0}\", SqlDbType.{1});", parameter.ParameterName, parameter.SqlDbType));
cmm.Statements.Add(css);
}
if(parameter.Direction != ParameterDirection.Input)
{
cpde.Direction = FieldDirection.Out;
css = new CodeSnippetStatement("parameter" + i.ToString() + ".Direction = ParameterDirection.Output;");
cmm.Statements.Add(css);
css = new CodeSnippetStatement(paramName + " = null;");
csc.Add(css);
css = new CodeSnippetStatement("if (parameter" + i.ToString() + ".Value != DBNull.Value)");
csc.Add(css);
css = new CodeSnippetStatement("{");
csc.Add(css);
CodeSnippetExpression cse = new CodeSnippetExpression(paramName);
CodeCastExpression cce = new CodeCastExpression(paramTypeName,new CodeSnippetExpression("parameter" + i.ToString() + ".Value") );
CodeAssignStatement cas = new CodeAssignStatement(cse,cce);
csc.Add(cas);
css = new CodeSnippetStatement("}");
csc.Add(css);
}
else
{
string ss = "";
if (paramTypeName == "System.String")
{
ss = string.Format("parameter{0}.Value = ({1} != null ? (object) {1} : DBNull.Value);", i, paramName);
}
else
{
ss = string.Format("parameter{0}.Value = {1};", i, paramName);
}
css = new CodeSnippetStatement(ss);
cmm.Statements.Add(css);
}
cmm.Parameters.Add(cpde);
i++;
}
// css = new CodeSnippetStatement("SqlParameter parameterReturn = new SqlParameter(\"@RETURN_VALUE\", SqlDbType.Int);");
css = new CodeSnippetStatement("SqlParameter parameterReturn = command.Parameters.Add(\"@RETURN_VALUE\", SqlDbType.Int);");
cmm.Statements.Add(css);
css = new CodeSnippetStatement("parameterReturn.Direction = ParameterDirection.ReturnValue;");
cmm.Statements.Add(css);
css = new CodeSnippetStatement("connection.Open();");
cmm.Statements.Add(css);
css = new CodeSnippetStatement("//SqlDataAdapter sda = new SqlDataAdapter(command);");
cmm.Statements.Add(css);
css = new CodeSnippetStatement("//DataSet ds = new DataSet();");
cmm.Statements.Add(css);
css = new CodeSnippetStatement("//sda.Fill(ds);");
cmm.Statements.Add(css);
css = new CodeSnippetStatement("command.ExecuteNonQuery();");
cmm.Statements.Add(css);
css = new CodeSnippetStatement("connection.Close();");
cmm.Statements.Add(css);
for (int j =0 ;j < csc.Count; j++)
{
cmm.Statements.Add(csc[j]);
}
css = new CodeSnippetStatement("//return ds.Tables[0];");
cmm.Statements.Add(css);
if (includeReturnValueParameter)
{
//CodeSnippetExpression cse = new CodeSnippetExpression("p_RETURN_VALUE");
CodeCastExpression cce = new CodeCastExpression(typeof(int),new CodeSnippetExpression("parameterReturn.Value"));
//CodeAssignStatement cas = new CodeAssignStatement(cse,cce);
//cmm.Statements.Add(cas);
cmm.Statements.Add(new CodeMethodReturnStatement(cce));
}
ctd.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "Main";
cmm.Attributes = MemberAttributes.Public| MemberAttributes.Final | MemberAttributes.Static;
ctd.Members.Add(cmm);
cn.Types.Add(ctd);
ccu.Namespaces.Add(cn);
using(StreamWriter sw = new StreamWriter(@"test.cs",false) )
{
provider.GenerateCodeFromCompileUnit(ccu,sw,new CodeGeneratorOptions());
sw.Close();
}
string s = null;
using (StreamReader sr = new StreamReader(@"test.cs"))
{
s = sr.ReadToEnd();
sr.Close();
}
return s;
}
public static string GenerateCodeWithSqlHelper
(
string spName
, bool includeReturnValueParameter
, SqlConnection connection
, string nameSpace
, string className
)
{
SqlParameter[] spa = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
int length = spa.Length;
CSharpCodeProvider provider = new CSharpCodeProvider();
//ICodeGenerator generator = provider.CreateGenerator();
CodeCompileUnit ccu = new CodeCompileUnit();
CodeNamespace cn = new CodeNamespace(nameSpace); //添加名称空间
cn.Imports.Add(new CodeNamespaceImport("System"));
cn.Imports.Add(new CodeNamespaceImport("System.Data"));
cn.Imports.Add(new CodeNamespaceImport("System.Data.SqlClient"));
cn.Imports.Add(new CodeNamespaceImport("Microshaoft.Data"));
CodeTypeDeclaration ctd = new CodeTypeDeclaration(className);
System.CodeDom.CodeMemberField cmf = new CodeMemberField(new CodeTypeReference(typeof(string)),"_ConnectionString");
cmf.Attributes = MemberAttributes.Static | MemberAttributes.Public;
cmf.InitExpression = new CodeSnippetExpression("@\"" + connection.ConnectionString + "\"" );//new CodePrimitiveExpression(connection.ConnectionString);
ctd.Members.Add(cmf);
//int rows = spa.Length;
CodeMemberMethod cmm = new CodeMemberMethod();
CodeSnippetStatement css = null;
css = new CodeSnippetStatement("SqlParameter[] parameters = new SqlParameter[" + (length+1).ToString() + "];");
cmm.Statements.Add(css);
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Name = "ExecProc_" + spName;
cmm.Attributes = MemberAttributes.Public| MemberAttributes.Final | MemberAttributes.Static;
int i = 0;
CodeStatementCollection csc = new CodeStatementCollection();
foreach(SqlParameter parameter in spa)
{
string paramName = "p_" + parameter.ParameterName.Substring(1);
string paramTypeName = GetTypeName(parameter.SqlDbType);
CodeTypeReference paramType = new CodeTypeReference(paramTypeName);
paramType.ToString();
CodeParameterDeclarationExpression cpde = new CodeParameterDeclarationExpression(paramType, paramName);
css = new CodeSnippetStatement("parameters[" + i.ToString() + "] = new SqlParameter(\"" + parameter.ParameterName + "\", SqlDbType." + parameter.SqlDbType + ");");
cmm.Statements.Add(css);
if(parameter.Direction != ParameterDirection.Input)
{
cpde.Direction = FieldDirection.Out;
if (paramTypeName == "System.String")
{
css = new CodeSnippetStatement("parameters[" + i.ToString() + "].Size = " + parameter.Size + ";");
cmm.Statements.Add(css);
}
css = new CodeSnippetStatement("parameters[" + i.ToString() + "].Direction = ParameterDirection.Output;");
cmm.Statements.Add(css);
css = new CodeSnippetStatement(paramName + " = null;");
csc.Add(css);
css = new CodeSnippetStatement("if (parameters[" + i.ToString() + "].Value != System.DBNull.Value)");
csc.Add(css);
css = new CodeSnippetStatement("{");
csc.Add(css);
CodeSnippetExpression cse = new CodeSnippetExpression(paramName);
CodeCastExpression cce = new CodeCastExpression(paramTypeName,new CodeSnippetExpression("parameters[" + i.ToString() + "].Value") );
CodeAssignStatement cas = new CodeAssignStatement(cse,cce);
csc.Add(cas);
css = new CodeSnippetStatement("}");
csc.Add(css);
}
else
{
css = new CodeSnippetStatement("parameters[" + i.ToString() + "].Value = " + paramName + ";");
cmm.Statements.Add(css);
}
cmm.Parameters.Add(cpde);
i++;
}
css = new CodeSnippetStatement("parameters[" + length.ToString() + "] = new SqlParameter(\"@RETURN_VALUE\", SqlDbType.Int);");
cmm.Statements.Add(css);
css = new CodeSnippetStatement("parameters[" + length.ToString() + "].Direction = ParameterDirection.ReturnValue;");
cmm.Statements.Add(css);
css = new CodeSnippetStatement("SqlConnection connection = new SqlConnection(_ConnectionString);");
cmm.Statements.Add(css);
css = new CodeSnippetStatement("SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, \""+ spName+"\", parameters);");
cmm.Statements.Add(css);
for (int j =0 ;j<csc.Count; j++)
{
cmm.Statements.Add(csc[j]);
}
if (includeReturnValueParameter)
{
//CodeSnippetExpression cse = new CodeSnippetExpression("p_RETURN_VALUE");
CodeCastExpression cce = new CodeCastExpression(typeof(int),new CodeSnippetExpression("parameters[" + i.ToString() + "].Value") );
//CodeAssignStatement cas = new CodeAssignStatement(cse,cce);
//cmm.Statements.Add(cas);
cmm.Statements.Add( new CodeMethodReturnStatement( cce));
}
ctd.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "Main";
cmm.Attributes = MemberAttributes.Public| MemberAttributes.Final | MemberAttributes.Static;
ctd.Members.Add(cmm);
cn.Types.Add(ctd);
ccu.Namespaces.Add(cn);
using(StreamWriter sw = new StreamWriter(@"test.cs",false) )
{
provider.GenerateCodeFromCompileUnit(ccu,sw,new CodeGeneratorOptions());
sw.Close();
}
string s = null;
using(StreamReader sr = new StreamReader(@"test.cs"))
{
s = sr.ReadToEnd();
sr.Close();
}
return s;
}
public static string GetTypeName(SqlDbType Type)
{
string s = "System.String";
switch (Type)
{
case SqlDbType.Int :
{
s = "System.Int32";
break;
}
case SqlDbType.SmallInt :
{
s = "System.Int32";
break;
}
case SqlDbType.TinyInt :
{
s = "System.Int32";
break;
}
case SqlDbType.BigInt :
{
s = "System.Int64";
break;
}
case SqlDbType.Bit :
{
s = "System.Boolean";
break;
}
case SqlDbType.Decimal :
{
s = "System.Decimal";
break;
}
case SqlDbType.Float :
{
s = "System.Single";
break;
}
case SqlDbType.Money :
{
s = "System.Decimal";
break;
}
case SqlDbType.SmallMoney :
{
s = "System.Decimal";
break;
}
case SqlDbType.Real:
{
s = "System.Single";
break;
}
case SqlDbType.DateTime :
{
s = "DateTime";
break;
}
case SqlDbType.SmallDateTime:
{
s = "DateTime";
break;
}
case SqlDbType.UniqueIdentifier :
{
s = "Guid";
break;
}
default :
{
s = "System.String";
break;
}
}
return s;
}
}
}
//================================================================================================================
// 下面是 Microsoft SqlHelper :
//Data Access Application Block 3.1
// http://www.gotdotnet.com/workspaces/workspace.aspx?id=c20d12b0-af52-402b-9b7c-aaeb21d1f431
// SqlHelper.v3.1.cs
//csc.exe SqlHelper.v3.1.cs /t:library /r:C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.Data.OracleClient.dll
namespace Microshaoft.Data
{
using System;
using System.IO;
using System.Data;
using System.Xml;
using System.Data.SqlClient;
using System.Data.Odbc;
using System.Data.OleDb;
using System.Data.OracleClient;
using System.Data.Common;
using System.Collections;
using System.Configuration;
using System.Text;
using System.Text.RegularExpressions;
using System.Reflection;
using System.Diagnostics;
/// <summary>
/// The AdoHelper class is intended to encapsulate high performance, scalable best practices for
/// common data access uses. It uses the Abstract Factory pattern to be easily extensible
/// to any ADO.NET provider. The current implementation provides helpers for SQL Server, ODBC,
/// OLEDB, and Oracle.
/// </summary>
public abstract class AdoHelper
{
/// <summary>
/// This enum is used to indicate whether the connection was provided by the caller, or created by AdoHelper, so that
/// we can set the appropriate CommandBehavior when calling ExecuteReader()
/// </summary>
protected enum AdoConnectionOwnership
{
/// <summary>Connection is owned and managed by ADOHelper</summary>
Internal,
/// <summary>Connection is owned and managed by the caller</summary>
External
}
#region Declare members
// necessary for handling the general case of needing event handlers for RowUpdating/ed events
/// <summary>
/// Internal handler used for bubbling up the event to the user
/// </summary>
protected RowUpdatingHandler m_rowUpdating;
/// <summary>
/// Internal handler used for bubbling up the event to the user
/// </summary>
protected RowUpdatedHandler m_rowUpdated;
#endregion
#region Provider specific abstract methods
/// <summary>
/// Returns an IDbConnection object for the given connection string
/// </summary>
/// <param name="connectionString">The connection string to be used to create the connection</param>
/// <returns>An IDbConnection object</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
public abstract IDbConnection GetConnection(string connectionString);
/// <summary>
/// Returns an IDbDataAdapter object
/// </summary>
/// <returns>The IDbDataAdapter</returns>
public abstract IDbDataAdapter GetDataAdapter();
/// <summary>
/// Calls the CommandBuilder.DeriveParameters method for the specified provider, doing any setup and cleanup necessary
/// </summary>
/// <param name="cmd">The IDbCommand referencing the stored procedure from which the parameter information is to be derived. The derived parameters are added to the Parameters collection of the IDbCommand. </param>
public abstract void DeriveParameters(IDbCommand cmd);
/// <summary>
/// Returns an IDataParameter object
/// </summary>
/// <returns>The IDataParameter object</returns>
public abstract IDataParameter GetParameter();
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the provided IDbConnection.
/// </summary>
/// <example>
/// <code>
/// XmlReader r = helper.ExecuteXmlReader(command);
/// </code></example>
/// <param name="cmd">The IDbCommand to execute</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
public abstract XmlReader ExecuteXmlReader(IDbCommand cmd);
/// <summary>
/// Provider specific code to set up the updating/ed event handlers used by UpdateDataset
/// </summary>
/// <param name="dataAdapter">DataAdapter to attach the event handlers to</param>
/// <param name="rowUpdatingHandler">The handler to be called when a row is updating</param>
/// <param name="rowUpdatedHandler">The handler to be called when a row is updated</param>
protected abstract void AddUpdateEventHandlers(IDbDataAdapter dataAdapter, RowUpdatingHandler rowUpdatingHandler, RowUpdatedHandler rowUpdatedHandler);
/// <summary>
/// Returns an array of IDataParameters of the specified size
/// </summary>
/// <param name="size">size of the array</param>
/// <returns>The array of IDataParameters</returns>
protected abstract IDataParameter[] GetDataParameters(int size);
/// <summary>
/// Handle any provider-specific issues with BLOBs here by "washing" the IDataParameter and returning a new one that is set up appropriately for the provider.
/// </summary>
/// <param name="connection">The IDbConnection to use in cleansing the parameter</param>
/// <param name="p">The parameter before cleansing</param>
/// <returns>The parameter after it's been cleansed.</returns>
protected abstract IDataParameter GetBlobParameter(IDbConnection connection, IDataParameter p);
#endregion
#region Delegates
// also used in our general case of RowUpdating/ed events
/// <summary>
/// Delegate for creating a RowUpdatingEvent handler
/// </summary>
/// <param name="obj">The object that published the event</param>
/// <param name="e">The RowUpdatingEventArgs for the event</param>
public delegate void RowUpdatingHandler(object obj, RowUpdatingEventArgs e);
/// <summary>
/// Delegate for creating a RowUpdatedEvent handler
/// </summary>
/// <param name="obj">The object that published the event</param>
/// <param name="e">The RowUpdatedEventArgs for the event</param>
public delegate void RowUpdatedHandler(object obj, RowUpdatedEventArgs e);
#endregion
#region Factory
/// <summary>
/// Create an AdoHelper for working with a specific provider (i.e. Sql, Odbc, OleDb, Oracle)
/// </summary>
/// <param name="providerAssembly">Assembly containing the specified helper subclass</param>
/// <param name="providerType">Specific type of the provider</param>
/// <returns>An AdoHelper instance of the specified type</returns>
/// <example><code>
/// AdoHelper helper = AdoHelper.CreateHelper("GotDotNet.ApplicationBlocks.Data", "GotDotNet.ApplicationBlocks.Data.OleDb");
/// </code></example>
public static AdoHelper CreateHelper(string providerAssembly, string providerType)
{
Assembly assembly = Assembly.Load(providerAssembly);
object provider = assembly.CreateInstance(providerType);
if (provider is AdoHelper)
{
return provider as AdoHelper;
}
else
{
throw new InvalidOperationException("The provider specified does not extend the AdoHelper abstract class.");
}
}
/// <summary>
/// Create an AdoHelper instance for working with a specific provider by using a providerAlias specified in the App.Config file.
/// </summary>
/// <param name="providerAlias">The alias to look up</param>
/// <returns>An AdoHelper instance of the specified type</returns>
/// <example><code>
/// AdoHelper helper = AdoHelper.CreateHelper("OracleHelper");
/// </code></example>
public static AdoHelper CreateHelper(string providerAlias)
{
IDictionary dict;
try
{
//dict = ConfigurationSettings.GetConfig("daabProviders") as IDictionary;
dict = ConfigurationManager.GetSection("daabProviders") as IDictionary;
}
catch (Exception e)
{
throw new InvalidOperationException("If the section is not defined on the configuration file this method can't be used to create an AdoHelper instance.", e);
}
ProviderAlias providerConfig = dict[providerAlias] as ProviderAlias;
string providerAssembly = providerConfig.AssemblyName;
string providerType = providerConfig.TypeName;
Assembly assembly = Assembly.Load(providerAssembly);
object provider = assembly.CreateInstance(providerType);
if (provider is AdoHelper)
{
return provider as AdoHelper;
}
else
{
throw new InvalidOperationException("The provider specified does not extends the AdoHelper abstract class.");
}
}
#endregion
#region GetParameter
/// <summary>
/// Get an IDataParameter for use in a SQL command
/// </summary>
/// <param name="name">The name of the parameter to create</param>
/// <param name="value">The value of the specified parameter</param>
/// <returns>An IDataParameter object</returns>
public virtual IDataParameter GetParameter(string name, object value)
{
IDataParameter parameter = GetParameter();
parameter.ParameterName = name;
parameter.Value = value;
return parameter;
}
/// <summary>
/// Get an IDataParameter for use in a SQL command
/// </summary>
/// <param name="name">The name of the parameter to create</param>
/// <param name="dbType">The System.Data.DbType of the parameter</param>
/// <param name="size">The size of the parameter</param>
/// <param name="direction">The System.Data.ParameterDirection of the parameter</param>
/// <returns>An IDataParameter object</returns>
public virtual IDataParameter GetParameter(string name, DbType dbType, int size, ParameterDirection direction)
{
IDataParameter dataParameter = GetParameter();
dataParameter.DbType = dbType;
dataParameter.Direction = direction;
dataParameter.ParameterName = name;
if (size > 0 && dataParameter is IDbDataParameter)
{
IDbDataParameter dbDataParameter = (IDbDataParameter) dataParameter;
dbDataParameter.Size = size;
}
return dataParameter;
}
/// <summary>
/// Get an IDataParameter for use in a SQL command
/// </summary>
/// <param name="name">The name of the parameter to create</param>
/// <param name="dbType">The System.Data.DbType of the parameter</param>
/// <param name="size">The size of the parameter</param>
/// <param name="sourceColumn">The source column of the parameter</param>
/// <param name="sourceVersion">The System.Data.DataRowVersion of the parameter</param>
/// <returns>An IDataParameter object</returns>
public virtual IDataParameter GetParameter(string name, DbType dbType, int size, string sourceColumn, DataRowVersion sourceVersion)
{
IDataParameter dataParameter = GetParameter();
dataParameter.DbType = dbType;
dataParameter.ParameterName = name;
dataParameter.SourceColumn = sourceColumn;
dataParameter.SourceVersion = sourceVersion;
if (size > 0 && dataParameter is IDbDataParameter)
{
IDbDataParameter dbDataParameter = (IDbDataParameter) dataParameter;
dbDataParameter.Size = size;
}
return dataParameter;
}
#endregion
#region private utility methods
/// <summary>
/// This method is used to attach array of IDataParameters to an IDbCommand.
///
/// This method will assign a value of DbNull to any parameter with a direction of
/// InputOutput and a value of null.
///
/// This behavior will prevent default values from being used, but
/// this will be the less common case than an intended pure output parameter (derived as InputOutput)
/// where the user provided no input value.
/// </summary>
/// <param name="command">The command to which the parameters will be added</param>
/// <param name="commandParameters">An array of IDataParameterParameters to be added to command</param>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
protected virtual void AttachParameters(IDbCommand command, IDataParameter[] commandParameters)
{
if (command == null) throw new ArgumentNullException("command");
if (commandParameters != null)
{
foreach (IDataParameter p in commandParameters)
{
if (p != null)
{
// Check for derived output value with no value assigned
if ((p.Direction == ParameterDirection.InputOutput ||
p.Direction == ParameterDirection.Input) &&
(p.Value == null))
{
p.Value = DBNull.Value;
}
if (p.DbType == DbType.Binary)
{
// special handling for BLOBs
command.Parameters.Add(GetBlobParameter(command.Connection, p));
}
else
{
command.Parameters.Add(p);
}
}
}
}
}
/// <summary>
/// This method assigns dataRow column values to an IDataParameterCollection
/// </summary>
/// <param name="commandParameters">The IDataParameterCollection to be assigned values</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values</param>
/// <exception cref="System.InvalidOperationException">Thrown if any of the parameter names are invalid.</exception>
protected internal void AssignParameterValues(IDataParameterCollection commandParameters, DataRow dataRow)
{
if (commandParameters == null || dataRow == null)
{
// Do nothing if we get no data
return;
}
DataColumnCollection columns = dataRow.Table.Columns;
int i = 0;
// Set the parameters values
foreach (IDataParameter commandParameter in commandParameters)
{
// Check the parameter name
if (commandParameter.ParameterName == null ||
commandParameter.ParameterName.Length <= 1)
throw new InvalidOperationException(string.Format(
"Please provide a valid parameter name on the parameter #{0}, the ParameterName property has the following value: '{1}'.",
i, commandParameter.ParameterName));
if (columns.Contains(commandParameter.ParameterName))
commandParameter.Value = dataRow[commandParameter.ParameterName];
else if (columns.Contains(commandParameter.ParameterName.Substring(1)))
commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];
i++;
}
}
/// <summary>
/// This method assigns dataRow column values to an array of IDataParameters
/// </summary>
/// <param name="commandParameters">Array of IDataParameters to be assigned values</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values</param>
/// <exception cref="System.InvalidOperationException">Thrown if any of the parameter names are invalid.</exception>
protected void AssignParameterValues(IDataParameter[] commandParameters, DataRow dataRow)
{
if ((commandParameters == null) || (dataRow == null))
{
// Do nothing if we get no data
return;
}
DataColumnCollection columns = dataRow.Table.Columns;
int i = 0;
// Set the parameters values
foreach (IDataParameter commandParameter in commandParameters)
{
// Check the parameter name
if (commandParameter.ParameterName == null ||
commandParameter.ParameterName.Length <= 1)
throw new InvalidOperationException(string.Format(
"Please provide a valid parameter name on the parameter #{0}, the ParameterName property has the following value: '{1}'.",
i, commandParameter.ParameterName));
if (columns.Contains(commandParameter.ParameterName))
commandParameter.Value = dataRow[commandParameter.ParameterName];
else if (columns.Contains(commandParameter.ParameterName.Substring(1)))
commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];
i++;
}
}
/// <summary>
/// This method assigns an array of values to an array of IDataParameters
/// </summary>
/// <param name="commandParameters">Array of IDataParameters to be assigned values</param>
/// <param name="parameterValues">Array of objects holding the values to be assigned</param>
/// <exception cref="System.ArgumentException">Thrown if an incorrect number of parameters are passed.</exception>
protected void AssignParameterValues(IDataParameter[] commandParameters, object[] parameterValues)
{
if ((commandParameters == null) || (parameterValues == null))
{
// Do nothing if we get no data
return;
}
// We must have the same number of values as we pave parameters to put them in
if (commandParameters.Length != parameterValues.Length)
{
throw new ArgumentException("Parameter count does not match Parameter Value count.");
}
// Iterate through the IDataParameters, assigning the values from the corresponding position in the
// value array
for (int i = 0, j = commandParameters.Length, k = 0; i < j; i++)
{
if (commandParameters[i].Direction != ParameterDirection.ReturnValue)
{
// If the current array value derives from IDataParameter, then assign its Value property
if (parameterValues[k] is IDataParameter)
{
IDataParameter paramInstance;
paramInstance = (IDataParameter) parameterValues[k];
if (paramInstance.Direction == ParameterDirection.ReturnValue)
{
paramInstance = (IDataParameter) parameterValues[++k];
}
if (paramInstance.Value == null)
{
commandParameters[i].Value = DBNull.Value;
}
else
{
commandParameters[i].Value = paramInstance.Value;
}
}
else if (parameterValues[k] == null)
{
commandParameters[i].Value = DBNull.Value;
}
else
{
commandParameters[i].Value = parameterValues[k];
}
k++;
}
}
}
/// <summary>
/// This method cleans up the parameter syntax for the provider
/// </summary>
/// <param name="command">The IDbCommand containing the parameters to clean up.</param>
public virtual void CleanParameterSyntax(IDbCommand command)
{
// do nothing by default
}
/// <summary>
/// This method opens (if necessary) and assigns a connection, transaction, command type and parameters
/// to the provided command
/// </summary>
/// <param name="command">The IDbCommand to be prepared</param>
/// <param name="connection">A valid IDbConnection, on which to execute this command</param>
/// <param name="transaction">A valid IDbTransaction, or 'null'</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters to be associated with the command or 'null' if no parameters are required</param>
/// <param name="mustCloseConnection"><c>true</c> if the connection was opened by the method, otherwose is false.</param>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null.</exception>
protected virtual void PrepareCommand(IDbCommand command, IDbConnection connection, IDbTransaction transaction, CommandType commandType, string commandText, IDataParameter[] commandParameters, out bool mustCloseConnection)
{
if (command == null) throw new ArgumentNullException("command");
if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
// If the provided connection is not open, we will open it
if (connection.State != ConnectionState.Open)
{
mustCloseConnection = true;
connection.Open();
}
else
{
mustCloseConnection = false;
}
// Associate the connection with the command
command.Connection = connection;
// Set the command text (stored procedure name or SQL statement)
command.CommandText = commandText;
// If we were provided a transaction, assign it
if (transaction != null)
{
if (transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
command.Transaction = transaction;
}
// Set the command type
command.CommandType = commandType;
// Attach the command parameters if they are provided
if (commandParameters != null)
{
AttachParameters(command, commandParameters);
}
return;
}
/// <summary>
/// This method clears (if necessary) the connection, transaction, command type and parameters
/// from the provided command
/// </summary>
/// <remarks>
/// Not implemented here because the behavior of this method differs on each data provider.
/// </remarks>
/// <param name="command">The IDbCommand to be cleared</param>
protected virtual void ClearCommand(IDbCommand command)
{
// do nothing by default
}
#endregion private utility methods
#region ExecuteDataset
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the database specified in
/// the connection string.
/// </summary>
/// <param name="command">The IDbCommand object to use</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
public virtual DataSet ExecuteDataset(IDbCommand command)
{
bool mustCloseConnection = false;
// Clean Up Parameter Syntax
CleanParameterSyntax(command);
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
mustCloseConnection = true;
}
// Create the DataAdapter & DataSet
IDbDataAdapter da = null;
try
{
da = GetDataAdapter();
da.SelectCommand = command;
DataSet ds = new DataSet();
try
{
// Fill the DataSet using default values for DataTable names, etc
da.Fill(ds);
}
catch (Exception ex)
{
// Don't just throw ex. It changes the call stack. But we want the ex around for debugging, so...
Debug.WriteLine(ex);
throw;
}
// Detach the IDataParameters from the command object, so they can be used again
// Don't do this...screws up output params -- cjb
//command.Parameters.Clear();
// Return the DataSet
return ds;
}
finally
{
if (mustCloseConnection)
{
command.Connection.Close();
}
if (da != null)
{
IDisposable id = da as IDisposable;
if (id != null)
id.Dispose();
}
}
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset and takes no parameters) against the database specified in
/// the connection string.
/// </summary>
/// <example>
/// <code>
/// DataSet ds = helper.ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");
/// </code></example>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <returns>A DataSet containing the resultset generated by the command</returns>
public virtual DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteDataset(connectionString, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the database specified in the connection string
/// using the provided parameters.
/// </summary>
/// <example>
/// <code>
/// DataSet ds = helper.ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new IDbParameter("@prodid", 24));
/// </code></example>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDbParamters used to execute the command</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
public virtual DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
// Create & open an IDbConnection, and dispose of it after we are done
using (IDbConnection connection = GetConnection(connectionString))
{
connection.Open();
// Call the overload that takes a connection in place of the connection string
return ExecuteDataset(connection, commandType, commandText, commandParameters);
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the database specified in
/// the connection string using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// DataSet ds = helper.ExecuteDataset(connString, "GetOrders", 24, 36);
/// </code></example>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
public virtual DataSet ExecuteDataset(string connectionString, string spName, params object[] parameterValues)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discovery
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, iDataParameterValues);
}
else
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(connectionString, spName, includeReturnValue);
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDataParameters
return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset and takes no parameters) against the provided IDbConnection.
/// </summary>
/// <example>
/// <code>
/// DataSet ds = helper.ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual DataSet ExecuteDataset(IDbConnection connection, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteDataset(connection, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the specified IDbConnection
/// using the provided parameters.
/// </summary>
/// <example>
/// <code>
/// DataSet ds = helper.ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new IDataParameter("@prodid", 24));
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual DataSet ExecuteDataset(IDbConnection connection, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (connection == null) throw new ArgumentNullException("connection");
// Create a command and prepare it for execution
IDbCommand cmd = connection.CreateCommand();
bool mustCloseConnection = false;
PrepareCommand(cmd, connection, (IDbTransaction) null, commandType, commandText, commandParameters, out mustCloseConnection);
CleanParameterSyntax(cmd);
DataSet ds = ExecuteDataset(cmd);
if (mustCloseConnection)
connection.Close();
// Return the DataSet
return ds;
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified IDbConnection
/// using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// DataSet ds = helper.ExecuteDataset(conn, "GetOrders", 24, 36);
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual DataSet ExecuteDataset(IDbConnection connection, string spName, params object[] parameterValues)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discovery
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
return ExecuteDataset(connection, CommandType.StoredProcedure, spName, iDataParameterValues);
}
else
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(connection, spName, includeReturnValue);
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDataParameters
return ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
return ExecuteDataset(connection, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset and takes no parameters) against the provided IDbTransaction.
/// </summary>
/// <example><code>
/// DataSet ds = helper.ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders");
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual DataSet ExecuteDataset(IDbTransaction transaction, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteDataset(transaction, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the specified IDbTransaction
/// using the provided parameters.
/// </summary>
/// <example>
/// <code>
/// DataSet ds = helper.ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new IDataParameter("@prodid", 24));
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual DataSet ExecuteDataset(IDbTransaction transaction, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
// Create a command and prepare it for execution
IDbCommand cmd = transaction.Connection.CreateCommand();
bool mustCloseConnection = false;
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
CleanParameterSyntax(cmd);
return ExecuteDataset(cmd);
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified
/// IDbTransaction using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// DataSet ds = helper.ExecuteDataset(tran, "GetOrders", 24, 36);
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual DataSet ExecuteDataset(IDbTransaction transaction, string spName, params object[] parameterValues)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discovery
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, iDataParameterValues);
}
else
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(transaction.Connection, spName, includeReturnValue);
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDataParameters
return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
return ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion ExecuteDataset
#region ExecuteNonQuery
/// <summary>
/// Execute an IDbCommand (that returns no resultset) against the database
/// </summary>
/// <param name="command">The IDbCommand to execute</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
public virtual int ExecuteNonQuery(IDbCommand command)
{
bool mustCloseConnection = false;
// Clean Up Parameter Syntax
CleanParameterSyntax(command);
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
mustCloseConnection = true;
}
if (command == null) throw new ArgumentNullException("command");
int returnVal;
returnVal = command.ExecuteNonQuery();
if (mustCloseConnection)
{
command.Connection.Close();
}
return returnVal;
}
/// <summary>
/// Execute an IDbCommand (that returns no resultset and takes no parameters) against the database specified in
/// the connection string
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
public virtual int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteNonQuery(connectionString, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns no resultset) against the database specified in the connection string
/// using the provided parameters
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
public virtual int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
// Create & open an IDbConnection, and dispose of it after we are done
using (IDbConnection connection = GetConnection(connectionString))
{
connection.Open();
// Call the overload that takes a connection in place of the connection string
return ExecuteNonQuery(connection, commandType, commandText, commandParameters);
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns no resultset) against the database specified in
/// the connection string using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// </remarks>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="spName">The name of the stored prcedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
public virtual int ExecuteNonQuery(string connectionString, string spName, params object[] parameterValues)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discoveryu
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, iDataParameterValues);
}
else
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(connectionString, spName, includeReturnValue);
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDataParameters
return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute an IDbCommand (that returns no resultset and takes no parameters) against the provided IDbConnection.
/// </summary>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual int ExecuteNonQuery(IDbConnection connection, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteNonQuery(connection, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns no resultset) against the specified IDbConnection
/// using the provided parameters.
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDbParamters used to execute the command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual int ExecuteNonQuery(IDbConnection connection, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (connection == null) throw new ArgumentNullException("connection");
// Create a command and prepare it for execution
IDbCommand cmd = connection.CreateCommand();
bool mustCloseConnection = false;
PrepareCommand(cmd, connection, (IDbTransaction) null, commandType, commandText, commandParameters, out mustCloseConnection);
CleanParameterSyntax(cmd);
// Finally, execute the command
int retval = ExecuteNonQuery(cmd);
// Detach the IDataParameters from the command object, so they can be used again
// don't do this...screws up output parameters -- cjbreisch
// cmd.Parameters.Clear();
if (mustCloseConnection)
connection.Close();
return retval;
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns no resultset) against the specified IDbConnection
/// using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// </remarks>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual int ExecuteNonQuery(IDbConnection connection, string spName, params object[] parameterValues)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discoveryu
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, iDataParameterValues);
}
else
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(connection, spName, includeReturnValue);
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDataParameters
return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute an IDbCommand (that returns no resultset and takes no parameters) against the provided IDbTransaction.
/// </summary>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual int ExecuteNonQuery(IDbTransaction transaction, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteNonQuery(transaction, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns no resultset) against the specified IDbTransaction
/// using the provided parameters.
/// </summary>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual int ExecuteNonQuery(IDbTransaction transaction, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
// Create a command and prepare it for execution
IDbCommand cmd = transaction.Connection.CreateCommand();
bool mustCloseConnection = false;
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
CleanParameterSyntax(cmd);
// Finally, execute the command
int retval = ExecuteNonQuery(cmd);
// Detach the IDataParameters from the command object, so they can be used again
// don't do this...screws up output parameters -- cjbreisch
// cmd.Parameters.Clear();
return retval;
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns no resultset) against the specified
/// IDbTransaction using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual int ExecuteNonQuery(IDbTransaction transaction, string spName, params object[] parameterValues)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discoveryu
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, iDataParameterValues);
}
else
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(transaction.Connection, spName, includeReturnValue);
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDbParameters
return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion ExecuteNonQuery
#region ExecuteReader
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the database specified in
/// the connection string.
/// </summary>
/// <param name="command">The IDbCommand object to use</param>
/// <returns>A IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
public virtual IDataReader ExecuteReader(IDbCommand command)
{
return ExecuteReader(command, AdoConnectionOwnership.External);
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the database specified in
/// the connection string.
/// </summary>
/// <param name="command">The IDbCommand object to use</param>
/// <param name="connectionOwnership">Enum indicating whether the connection was created internally or externally.</param>
/// <returns>A IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
protected virtual IDataReader ExecuteReader(IDbCommand command, AdoConnectionOwnership connectionOwnership)
{
// Clean Up Parameter Syntax
CleanParameterSyntax(command);
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
connectionOwnership = AdoConnectionOwnership.Internal;
}
// Create a reader
IDataReader dataReader;
// Call ExecuteReader with the appropriate CommandBehavior
if (connectionOwnership == AdoConnectionOwnership.External)
{
dataReader = command.ExecuteReader();
}
else
{
try
{
dataReader = command.ExecuteReader(CommandBehavior.CloseConnection);
}
catch (Exception ex)
{
// Don't just throw ex. It changes the call stack. But we want the ex around for debugging, so...
Debug.WriteLine(ex);
throw;
}
}
ClearCommand(command);
return dataReader;
}
/// <summary>
/// Create and prepare an IDbCommand, and call ExecuteReader with the appropriate CommandBehavior.
/// </summary>
/// <remarks>
/// If we created and opened the connection, we want the connection to be closed when the DataReader is closed.
///
/// If the caller provided the connection, we want to leave it to them to manage.
/// </remarks>
/// <param name="connection">A valid IDbConnection, on which to execute this command</param>
/// <param name="transaction">A valid IDbTransaction, or 'null'</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters to be associated with the command or 'null' if no parameters are required</param>
/// <param name="connectionOwnership">Indicates whether the connection parameter was provided by the caller, or created by AdoHelper</param>
/// <returns>IDataReader containing the results of the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
private IDataReader ExecuteReader(IDbConnection connection, IDbTransaction transaction, CommandType commandType, string commandText, IDataParameter[] commandParameters, AdoConnectionOwnership connectionOwnership)
{
if (connection == null) throw new ArgumentNullException("connection");
bool mustCloseConnection = false;
// Create a command and prepare it for execution
IDbCommand cmd = connection.CreateCommand();
try
{
PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
CleanParameterSyntax(cmd);
// override conenctionOwnership if we created the connection in PrepareCommand -- cjbreisch
if (mustCloseConnection)
{
connectionOwnership = AdoConnectionOwnership.Internal;
}
// Create a reader
IDataReader dataReader;
dataReader = ExecuteReader(cmd, connectionOwnership);
ClearCommand(cmd);
return dataReader;
}
catch
{
if (mustCloseConnection)
connection.Close();
throw;
}
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset and takes no parameters) against the database specified in
/// the connection string.
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>A IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
public virtual IDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteReader(connectionString, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the database specified in the connection string
/// using the provided parameters.
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <returns>A IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
public virtual IDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
IDbConnection connection = null;
try
{
connection = GetConnection(connectionString);
connection.Open();
// Call the private overload that takes an internally owned connection in place of the connection string
return ExecuteReader(connection, null, commandType, commandText, commandParameters, AdoConnectionOwnership.Internal);
}
catch
{
// If we fail to return the IDataReader, we need to close the connection ourselves
if (connection != null) connection.Close();
throw;
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the database specified in
/// the connection string using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// IDataReader dr = helper.ExecuteReader(connString, "GetOrders", 24, 36);
/// </code></example>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>an IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
public virtual IDataReader ExecuteReader(string connectionString, string spName, params object[] parameterValues)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discovery
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
return ExecuteReader(connectionString, CommandType.StoredProcedure, spName, iDataParameterValues);
}
else
{
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(connectionString, spName, includeReturnValue);
AssignParameterValues(commandParameters, parameterValues);
return ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
return ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset and takes no parameters) against the provided IDbConnection.
/// </summary>
/// <example>
/// <code>
/// IDataReader dr = helper.ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders");
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>an IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
public virtual IDataReader ExecuteReader(IDbConnection connection, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteReader(connection, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the specified IDbConnection
/// using the provided parameters.
/// </summary>
/// <example>
/// <code>
/// IDataReader dr = helper.ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new IDataParameter("@prodid", 24));
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <returns>an IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual IDataReader ExecuteReader(IDbConnection connection, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
// Pass through the call to the private overload using a null transaction value and an externally owned connection
return ExecuteReader(connection, (IDbTransaction) null, commandType, commandText, commandParameters, AdoConnectionOwnership.External);
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified IDbConnection
/// using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// IDataReader dr = helper.ExecuteReader(conn, "GetOrders", 24, 36);
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>an IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual IDataReader ExecuteReader(IDbConnection connection, string spName, params object[] parameterValues)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discovery
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
return ExecuteReader(connection, CommandType.StoredProcedure, spName, iDataParameterValues);
}
else
{
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(connection, spName, includeReturnValue);
AssignParameterValues(commandParameters, parameterValues);
return ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
return ExecuteReader(connection, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset and takes no parameters) against the provided IDbTransaction.
/// </summary>
/// <example><code>
/// IDataReader dr = helper.ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders");
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>A IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
public virtual IDataReader ExecuteReader(IDbTransaction transaction, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteReader(transaction, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the specified IDbTransaction
/// using the provided parameters.
/// </summary>
/// <example>
/// <code>
/// IDataReader dr = helper.ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new IDataParameter("@prodid", 24));
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <returns>A IDataReader containing the resultset generated by the command</returns>
public virtual IDataReader ExecuteReader(IDbTransaction transaction, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
// Pass through to private overload, indicating that the connection is owned by the caller
return ExecuteReader(transaction.Connection, transaction, commandType, commandText, commandParameters, AdoConnectionOwnership.External);
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified
/// IDbTransaction using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// IDataReader dr = helper.ExecuteReader(tran, "GetOrders", 24, 36);
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>an IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual IDataReader ExecuteReader(IDbTransaction transaction, string spName, params object[] parameterValues)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discovery
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
return ExecuteReader(transaction, CommandType.StoredProcedure, spName, iDataParameterValues);
}
else
{
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(transaction.Connection, spName, includeReturnValue);
AssignParameterValues(commandParameters, parameterValues);
return ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
return ExecuteReader(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion ExecuteReader
#region ExecuteScalar
/// <summary>
/// Execute an IDbCommand (that returns a 1x1 resultset) against the database specified in
/// the connection string.
/// </summary>
/// <param name="command">The IDbCommand to execute</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
public virtual object ExecuteScalar(IDbCommand command)
{
bool mustCloseConnection = false;
// Clean Up Parameter Syntax
CleanParameterSyntax(command);
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
mustCloseConnection = true;
}
// Execute the command & return the results
object retval = command.ExecuteScalar();
// Detach the IDataParameters from the command object, so they can be used again
// don't do this...screws up output params -- cjbreisch
// command.Parameters.Clear();
if (mustCloseConnection)
{
command.Connection.Close();
}
return retval;
}
/// <summary>
/// Execute an IDbCommand (that returns a 1x1 resultset and takes no parameters) against the database specified in
/// the connection string.
/// </summary>
/// <example>
/// <code>
/// int orderCount = (int)helper.ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount");
/// </code></example>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
public virtual object ExecuteScalar(string connectionString, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteScalar(connectionString, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns a 1x1 resultset) against the database specified in the connection string
/// using the provided parameters.
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
public virtual object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
// Create & open an IDbConnection, and dispose of it after we are done
IDbConnection connection = null;
try
{
connection = GetConnection(connectionString);
connection.Open();
// Call the overload that takes a connection in place of the connection string
return ExecuteScalar(connection, commandType, commandText, commandParameters);
}
finally
{
IDisposable id = connection as IDisposable;
if (id != null) id.Dispose();
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a 1x1 resultset) against the database specified in
/// the connection string using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// int orderCount = (int)helper.ExecuteScalar(connString, "GetOrderCount", 24, 36);
/// </code></example>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
public virtual object ExecuteScalar(string connectionString, string spName, params object[] parameterValues)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discovery
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, iDataParameterValues);
}
else
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(connectionString, spName, includeReturnValue);
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDataParameters
return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute an IDbCommand (that returns a 1x1 resultset and takes no parameters) against the provided IDbConnection.
/// </summary>
/// <example>
/// <code>
/// int orderCount = (int)helper.ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount");
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
public virtual object ExecuteScalar(IDbConnection connection, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDbParameters
return ExecuteScalar(connection, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns a 1x1 resultset) against the specified IDbConnection
/// using the provided parameters.
/// </summary>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual object ExecuteScalar(IDbConnection connection, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (connection == null) throw new ArgumentNullException("connection");
// Create a command and prepare it for execution
IDbCommand cmd = connection.CreateCommand();
bool mustCloseConnection = false;
PrepareCommand(cmd, connection, (IDbTransaction) null, commandType, commandText, commandParameters, out mustCloseConnection);
CleanParameterSyntax(cmd);
// Execute the command & return the results
object retval = ExecuteScalar(cmd);
// Detach the IDataParameters from the command object, so they can be used again
// don't do this...screws up output parameters -- cjbreisch
// cmd.Parameters.Clear();
if (mustCloseConnection)
connection.Close();
return retval;
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a 1x1 resultset) against the specified IDbConnection
/// using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// int orderCount = (int)helper.ExecuteScalar(conn, "GetOrderCount", 24, 36);
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual object ExecuteScalar(IDbConnection connection, string spName, params object[] parameterValues)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discovery
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
return ExecuteScalar(connection, CommandType.StoredProcedure, spName, iDataParameterValues);
}
else
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(connection, spName, includeReturnValue);
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDataParameters
return ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
return ExecuteScalar(connection, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute an IDbCommand (that returns a 1x1 resultset and takes no parameters) against the provided IDbTransaction.
/// </summary>
/// <example>
/// <code>
/// int orderCount = (int)helper.ExecuteScalar(tran, CommandType.StoredProcedure, "GetOrderCount");
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
public virtual object ExecuteScalar(IDbTransaction transaction, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteScalar(transaction, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns a 1x1 resultset) against the specified IDbTransaction
/// using the provided parameters.
/// </summary>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDbParamters used to execute the command</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual object ExecuteScalar(IDbTransaction transaction, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
// Create a command and prepare it for execution
IDbCommand cmd = transaction.Connection.CreateCommand();
bool mustCloseConnection = false;
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
CleanParameterSyntax(cmd);
// Execute the command & return the results
object retval = ExecuteScalar(cmd);
// Detach the IDataParameters from the command object, so they can be used again
// don't do this...screws up output parameters -- cjbreisch
// cmd.Parameters.Clear();
return retval;
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a 1x1 resultset) against the specified
/// IDbTransaction using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// int orderCount = (int)helper.ExecuteScalar(tran, "GetOrderCount", 24, 36);
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the transaction is rolled back or commmitted</exception>
public virtual object ExecuteScalar(IDbTransaction transaction, string spName, params object[] parameterValues)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discovery
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
return ExecuteScalar(transaction, CommandType.StoredProcedure, spName, iDataParameterValues);
}
else
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(transaction.Connection, spName, includeReturnValue);
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDataParameters
return ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
return ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion ExecuteScalar
#region ExecuteXmlReader
/// <summary>
/// Execute an IDbCommand (that returns a resultset and takes no parameters) against the provided IDbConnection.
/// </summary>
/// <example>
/// <code>
/// XmlReader r = helper.ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders");
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command using "FOR XML AUTO"</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public XmlReader ExecuteXmlReader(IDbConnection connection, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteXmlReader(connection, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the specified IDbConnection
/// using the provided parameters.
/// </summary>
/// <example>
/// <code>
/// XmlReader r = helper.ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders", GetParameter("@prodid", 24));
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command using "FOR XML AUTO"</param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public XmlReader ExecuteXmlReader(IDbConnection connection, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (connection == null) throw new ArgumentNullException("connection");
bool mustCloseConnection = false;
// Create a command and prepare it for execution
IDbCommand cmd = connection.CreateCommand();
try
{
PrepareCommand(cmd, connection, (IDbTransaction) null, commandType, commandText, commandParameters, out mustCloseConnection);
CleanParameterSyntax(cmd);
return ExecuteXmlReader(cmd);
}
catch (Exception ex)
{
if (mustCloseConnection)
connection.Close();
// Don't just throw ex. It changes the call stack. But we want the ex around for debugging, so...
Debug.WriteLine(ex);
throw;
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified IDbConnection
/// using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// XmlReader r = helper.ExecuteXmlReader(conn, "GetOrders", 24, 36);
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="spName">The name of the stored procedure using "FOR XML AUTO"</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public XmlReader ExecuteXmlReader(IDbConnection connection, string spName, params object[] parameterValues)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
ArrayList tempParameter = new ArrayList();
foreach (IDataParameter parameter in GetSpParameterSet(connection, spName))
{
tempParameter.Add(parameter);
}
IDataParameter[] commandParameters = (IDataParameter[]) tempParameter.ToArray(typeof (IDataParameter));
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDataParameters
return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
// Otherwise we can just call the SP without params
return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset and takes no parameters) against the provided IDbTransaction.
/// </summary>
/// <example>
/// <code>
/// XmlReader r = helper.ExecuteXmlReader(tran, CommandType.StoredProcedure, "GetOrders");
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command using "FOR XML AUTO"</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public XmlReader ExecuteXmlReader(IDbTransaction transaction, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of IDataParameters
return ExecuteXmlReader(transaction, commandType, commandText, (IDataParameter[]) null);
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the specified IDbTransaction
/// using the provided parameters.
/// </summary>
/// <example>
/// <code>
/// XmlReader r = helper.ExecuteXmlReader(tran, CommandType.StoredProcedure, "GetOrders", GetParameter("@prodid", 24));
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command using "FOR XML AUTO"</param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public XmlReader ExecuteXmlReader(IDbTransaction transaction, CommandType commandType, string commandText, params IDataParameter[] commandParameters)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
// Create a command and prepare it for execution
IDbCommand cmd = transaction.Connection.CreateCommand();
bool mustCloseConnection = false;
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
CleanParameterSyntax(cmd);
// Create the DataAdapter & DataSet
XmlReader retval = ExecuteXmlReader(cmd);
// Detach the IDataParameters from the command object, so they can be used again
// don't do this...screws up output params -- cjbreisch
// cmd.Parameters.Clear();
return retval;
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified
/// IDbTransaction using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// XmlReader r = helper.ExecuteXmlReader(trans, "GetOrders", 24, 36);
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="spName">The name of the stored procedure using "FOR XML AUTO"</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public XmlReader ExecuteXmlReader(IDbTransaction transaction, string spName, params object[] parameterValues)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
ArrayList tempParameter = new ArrayList();
foreach (IDataParameter parameter in GetSpParameterSet(transaction.Connection, spName))
{
tempParameter.Add(parameter);
}
IDataParameter[] commandParameters = (IDataParameter[]) tempParameter.ToArray(typeof (IDataParameter));
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDataParameters
return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
// Otherwise we can just call the SP without params
return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion ExecuteXmlReader
#region ExecuteXmlReaderTypedParams
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified IDbConnection
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will assign the parameter values based on parameter order.
/// </summary>
/// <param name="command">The IDbCommand to execute</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
public XmlReader ExecuteXmlReaderTypedParams(IDbCommand command, DataRow dataRow)
{
if (command == null) throw new ArgumentNullException("command");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Set the parameters values
AssignParameterValues(command.Parameters, dataRow);
return ExecuteXmlReader(command);
}
else
{
return ExecuteXmlReader(command);
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified IDbConnection
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="connection">A valid IDbConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public XmlReader ExecuteXmlReaderTypedParams(IDbConnection connection, String spName, DataRow dataRow)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
ArrayList tempParameter = new ArrayList();
foreach (IDataParameter parameter in GetSpParameterSet(connection, spName))
{
tempParameter.Add(parameter);
}
IDataParameter[] commandParameters = (IDataParameter[]) tempParameter.ToArray(typeof (IDataParameter));
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified IDbTransaction
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="transaction">A valid IDbTransaction object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public XmlReader ExecuteXmlReaderTypedParams(IDbTransaction transaction, String spName, DataRow dataRow)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
ArrayList tempParameter = new ArrayList();
foreach (IDataParameter parameter in GetSpParameterSet(transaction.Connection, spName))
{
tempParameter.Add(parameter);
}
IDataParameter[] commandParameters = (IDataParameter[]) tempParameter.ToArray(typeof (IDataParameter));
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion
#region FillDataset
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the database specified in
/// the connection string.
/// </summary>
/// <param name="command">The IDbCommand to execute</param>
/// <param name="dataSet">A DataSet wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)</param>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
public virtual void FillDataset(IDbCommand command, DataSet dataSet, string[] tableNames)
{
bool mustCloseConnection = false;
// Clean Up Parameter Syntax
CleanParameterSyntax(command);
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
mustCloseConnection = true;
}
// Create the DataAdapter & DataSet
IDbDataAdapter dataAdapter = null;
try
{
dataAdapter = GetDataAdapter();
dataAdapter.SelectCommand = command;
// Add the table mappings specified by the user
if (tableNames != null && tableNames.Length > 0)
{
string tableName = "Table";
for (int index = 0; index < tableNames.Length; index++)
{
if (tableNames[index] == null || tableNames[index].Length == 0)
throw new ArgumentException("The tableNames parameter must contain a list of tables, a value was provided as null or empty string.", "tableNames");
dataAdapter.TableMappings.Add(
tableName + (index == 0 ? "" : index.ToString()),
tableNames[index]);
}
}
// Fill the DataSet using default values for DataTable names, etc
dataAdapter.Fill(dataSet);
if (mustCloseConnection)
{
command.Connection.Close();
}
// Detach the IDataParameters from the command object, so they can be used again
// don't do this...screws up output params --cjb
// command.Parameters.Clear();
}
finally
{
IDisposable id = dataAdapter as IDisposable;
if (id != null) id.Dispose();
}
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset and takes no parameters) against the database specified in
/// the connection string.
/// </summary>
/// <example>
/// <code>
/// helper.FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
/// </code></example>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="dataSet">A DataSet wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)</param>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
public virtual void FillDataset(string connectionString, CommandType commandType, string commandText, DataSet dataSet, string[] tableNames)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (dataSet == null) throw new ArgumentNullException("dataSet");
// Create & open an IDbConnection, and dispose of it after we are done
IDbConnection connection = null;
try
{
connection = GetConnection(connectionString);
connection.Open();
// Call the overload that takes a connection in place of the connection string
FillDataset(connection, commandType, commandText, dataSet, tableNames);
}
finally
{
IDisposable id = connection as IDisposable;
if (id != null) id.Dispose();
}
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the database specified in the connection string
/// using the provided parameters.
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <param name="dataSet">A DataSet wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
public virtual void FillDataset(string connectionString, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames,
params IDataParameter[] commandParameters)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (dataSet == null) throw new ArgumentNullException("dataSet");
// Create & open an IDbConnection, and dispose of it after we are done
IDbConnection connection = null;
try
{
connection = GetConnection(connectionString);
connection.Open();
// Call the overload that takes a connection in place of the connection string
FillDataset(connection, commandType, commandText, dataSet, tableNames, commandParameters);
}
finally
{
IDisposable id = connection as IDisposable;
if (id != null) id.Dispose();
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the database specified in
/// the connection string using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// helper.FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, 24);
/// </code></example>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
public virtual void FillDataset(string connectionString, string spName,
DataSet dataSet, string[] tableNames,
params object[] parameterValues)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (dataSet == null) throw new ArgumentNullException("dataSet");
// Create & open an IDbConnection, and dispose of it after we are done
IDbConnection connection = null;
try
{
connection = GetConnection(connectionString);
connection.Open();
// Call the overload that takes a connection in place of the connection string
FillDataset(connection, spName, dataSet, tableNames, parameterValues);
}
finally
{
IDisposable id = connection as IDisposable;
if (id != null) id.Dispose();
}
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset and takes no parameters) against the provided IDbConnection.
/// </summary>
/// <example>
/// <code>
/// helper.FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual void FillDataset(IDbConnection connection, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames)
{
FillDataset(connection, commandType, commandText, dataSet, tableNames, null);
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the specified IDbConnection
/// using the provided parameters.
/// </summary>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="dataSet">A DataSet wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual void FillDataset(IDbConnection connection, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames,
params IDataParameter[] commandParameters)
{
FillDataset(connection, null, commandType, commandText, dataSet, tableNames, commandParameters);
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified IDbConnection
/// using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// helper.FillDataset(conn, "GetOrders", ds, new string[] {"orders"}, 24, 36);
/// </code></example>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual void FillDataset(IDbConnection connection, string spName,
DataSet dataSet, string[] tableNames,
params object[] parameterValues)
{
if (connection == null) throw new ArgumentNullException("connection");
if (dataSet == null) throw new ArgumentNullException("dataSet");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discovery
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames, iDataParameterValues);
}
else
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(connection, spName, includeReturnValue);
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDataParameters
FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames);
}
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset and takes no parameters) against the provided IDbTransaction.
/// </summary>
/// <example>
/// <code>
/// helper.FillDataset(tran, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual void FillDataset(IDbTransaction transaction, CommandType commandType,
string commandText,
DataSet dataSet, string[] tableNames)
{
FillDataset(transaction, commandType, commandText, dataSet, tableNames, null);
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the specified IDbTransaction
/// using the provided parameters.
/// </summary>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="dataSet">A DataSet wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual void FillDataset(IDbTransaction transaction, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames,
params IDataParameter[] commandParameters)
{
FillDataset(transaction.Connection, transaction, commandType, commandText, dataSet, tableNames, commandParameters);
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified
/// IDbTransaction using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
/// </remarks>
/// <example>
/// <code>
/// helper.FillDataset(tran, "GetOrders", ds, new string[] {"orders"}, 24, 36);
/// </code></example>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual void FillDataset(IDbTransaction transaction, string spName,
DataSet dataSet, string[] tableNames,
params object[] parameterValues)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
if (dataSet == null) throw new ArgumentNullException("dataSet");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If we receive parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
IDataParameter[] iDataParameterValues = GetDataParameters(parameterValues.Length);
// if we've been passed IDataParameters, don't do parameter discovery
if (AreParameterValuesIDataParameters(parameterValues, iDataParameterValues))
{
FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames, iDataParameterValues);
}
else
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
bool includeReturnValue = CheckForReturnValueParameter(parameterValues);
IDataParameter[] commandParameters = GetSpParameterSet(transaction.Connection, spName, includeReturnValue);
// Assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);
// Call the overload that takes an array of IDataParameters
FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters);
}
}
else
{
// Otherwise we can just call the SP without params
FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames);
}
}
/// <summary>
/// Private helper method that execute an IDbCommand (that returns a resultset) against the specified IDbTransaction and IDbConnection
/// using the provided parameters.
/// </summary>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="transaction">A valid IDbTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="dataSet">A DataSet wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <param name="commandParameters">An array of IDataParameters used to execute the command</param>
private void FillDataset(IDbConnection connection, IDbTransaction transaction, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames,
params IDataParameter[] commandParameters)
{
if (connection == null) throw new ArgumentNullException("connection");
if (dataSet == null) throw new ArgumentNullException("dataSet");
// Create a command and prepare it for execution
IDbCommand command = connection.CreateCommand();
bool mustCloseConnection = false;
PrepareCommand(command, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
CleanParameterSyntax(command);
FillDataset(command, dataSet, tableNames);
if (mustCloseConnection)
connection.Close();
}
#endregion
#region UpdateDataset
/// <summary>
/// This method consumes the RowUpdatingEvent and passes it on to the consumer specifed in the call to UpdateDataset
/// </summary>
/// <param name="obj">The object that generated the event</param>
/// <param name="e">The System.Data.Common.RowUpdatingEventArgs</param>
protected void RowUpdating(object obj, System.Data.Common.RowUpdatingEventArgs e)
{
if (this.m_rowUpdating != null)
m_rowUpdating(obj, e);
}
/// <summary>
/// This method consumes the RowUpdatedEvent and passes it on to the consumer specifed in the call to UpdateDataset
/// </summary>
/// <param name="obj">The object that generated the event</param>
/// <param name="e">The System.Data.Common.RowUpdatingEventArgs</param>
protected void RowUpdated(object obj, System.Data.Common.RowUpdatedEventArgs e)
{
if (this.m_rowUpdated != null)
m_rowUpdated(obj, e);
}
/// <summary>
/// Set up a command for updating a DataSet.
/// </summary>
/// <param name="command">command object to prepare</param>
/// <param name="mustCloseConnection">output parameter specifying whether the connection used should be closed by the DAAB</param>
/// <returns>An IDbCommand object</returns>
protected virtual IDbCommand SetCommand(IDbCommand command, out bool mustCloseConnection)
{
mustCloseConnection = false;
if (command != null)
{
IDataParameter[] commandParameters = new IDataParameter[command.Parameters.Count];
command.Parameters.CopyTo(commandParameters, 0);
command.Parameters.Clear();
this.PrepareCommand(command, command.Connection, null, command.CommandType, command.CommandText, commandParameters, out mustCloseConnection);
CleanParameterSyntax(command);
}
return command;
}
/// <summary>
/// Executes the respective command for each inserted, updated, or deleted row in the DataSet.
/// </summary>
/// <example>
/// <code>
/// helper.UpdateDataset(conn, insertCommand, deleteCommand, updateCommand, dataSet, "Order");
/// </code></example>
/// <param name="insertCommand">A valid SQL statement or stored procedure to insert new records into the data source</param>
/// <param name="deleteCommand">A valid SQL statement or stored procedure to delete records from the data source</param>
/// <param name="updateCommand">A valid SQL statement or stored procedure used to update records in the data source</param>
/// <param name="dataSet">The DataSet used to update the data source</param>
/// <param name="tableName">The DataTable used to update the data source.</param>
public virtual void UpdateDataset(IDbCommand insertCommand, IDbCommand deleteCommand, IDbCommand updateCommand, DataSet dataSet, string tableName)
{
UpdateDataset(insertCommand, deleteCommand, updateCommand, dataSet, tableName, null, null);
}
/// <summary>
/// Executes the IDbCommand for each inserted, updated, or deleted row in the DataSet also implementing RowUpdating and RowUpdated Event Handlers
/// </summary>
/// <example>
/// <code>
/// RowUpdatingEventHandler rowUpdatingHandler = new RowUpdatingEventHandler( OnRowUpdating );
/// RowUpdatedEventHandler rowUpdatedHandler = new RowUpdatedEventHandler( OnRowUpdated );
/// helper.UpdateDataSet(sqlInsertCommand, sqlDeleteCommand, sqlUpdateCommand, dataSet, "Order", rowUpdatingHandler, rowUpdatedHandler);
/// </code></example>
/// <param name="insertCommand">A valid SQL statement or stored procedure to insert new records into the data source</param>
/// <param name="deleteCommand">A valid SQL statement or stored procedure to delete records from the data source</param>
/// <param name="updateCommand">A valid SQL statement or stored procedure used to update records in the data source</param>
/// <param name="dataSet">The DataSet used to update the data source</param>
/// <param name="tableName">The DataTable used to update the data source.</param>
/// <param name="rowUpdatingHandler">RowUpdatingEventHandler</param>
/// <param name="rowUpdatedHandler">RowUpdatedEventHandler</param>
public void UpdateDataset(IDbCommand insertCommand, IDbCommand deleteCommand, IDbCommand updateCommand,
DataSet dataSet, string tableName, RowUpdatingHandler rowUpdatingHandler, RowUpdatedHandler rowUpdatedHandler)
{
int rowsAffected = 0;
if (tableName == null || tableName.Length == 0) throw new ArgumentNullException("tableName");
// Create an IDbDataAdapter, and dispose of it after we are done
IDbDataAdapter dataAdapter = null;
try
{
bool mustCloseUpdateConnection = false;
bool mustCloseInsertConnection = false;
bool mustCloseDeleteConnection = false;
dataAdapter = GetDataAdapter();
// Set the data adapter commands
dataAdapter.UpdateCommand = SetCommand(updateCommand, out mustCloseUpdateConnection);
dataAdapter.InsertCommand = SetCommand(insertCommand, out mustCloseInsertConnection);
dataAdapter.DeleteCommand = SetCommand(deleteCommand, out mustCloseDeleteConnection);
AddUpdateEventHandlers(dataAdapter, rowUpdatingHandler, rowUpdatedHandler);
if (dataAdapter is DbDataAdapter)
{
// Update the DataSet changes in the data source
try
{
rowsAffected = ((DbDataAdapter) dataAdapter).Update(dataSet, tableName);
}
catch (Exception ex)
{
// Don't just throw ex. It changes the call stack. But we want the ex around for debugging, so...
Debug.WriteLine(ex);
throw;
}
}
else
{
dataAdapter.TableMappings.Add(tableName, "Table");
// Update the DataSet changes in the data source
rowsAffected = dataAdapter.Update(dataSet);
}
// Commit all the changes made to the DataSet
dataSet.Tables[tableName].AcceptChanges();
if (mustCloseUpdateConnection)
{
updateCommand.Connection.Close();
}
if (mustCloseInsertConnection)
{
insertCommand.Connection.Close();
}
if (mustCloseDeleteConnection)
{
deleteCommand.Connection.Close();
}
}
finally
{
IDisposable id = dataAdapter as IDisposable;
if (id != null) id.Dispose();
}
}
#endregion
#region CreateCommand
/// <summary>
/// Simplify the creation of an IDbCommand object by allowing
/// a stored procedure and optional parameters to be provided
/// </summary>
/// <example>
/// <code>
/// IDbCommand command = helper.CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName");
/// </code></example>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="sourceColumns">An array of string to be assigned as the source columns of the stored procedure parameters</param>
/// <returns>A valid IDbCommand object</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.InvalidOperationException">Thrown if any of the IDataParameters.ParameterNames are null, or if the parameter count does not match the number of values supplied</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentException">Thrown if the parameter count does not match the number of values supplied</exception>
public virtual IDbCommand CreateCommand(string connectionString, string spName, params string[] sourceColumns)
{
return CreateCommand(this.GetConnection(connectionString), spName, sourceColumns);
}
/// <summary>
/// Simplify the creation of an IDbCommand object by allowing
/// a stored procedure and optional parameters to be provided
/// </summary>
/// <example>
/// <code>
/// IDbCommand command = helper.CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName");
/// </code></example>
/// <param name="connection">A valid IDbConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="sourceColumns">An array of string to be assigned as the source columns of the stored procedure parameters</param>
/// <returns>A valid IDbCommand object</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual IDbCommand CreateCommand(IDbConnection connection, string spName, params string[] sourceColumns)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// Create an IDbCommand
IDbCommand cmd = connection.CreateCommand();
cmd.CommandText = spName;
cmd.CommandType = CommandType.StoredProcedure;
// If we receive parameter values, we need to figure out where they go
if ((sourceColumns != null) && (sourceColumns.Length > 0))
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(connection, spName);
// Assign the provided source columns to these parameters based on parameter order
for (int index = 0; index < sourceColumns.Length; index++)
if (commandParameters[index].SourceColumn == String.Empty)
commandParameters[index].SourceColumn = sourceColumns[index];
// Attach the discovered parameters to the IDbCommand object
AttachParameters(cmd, commandParameters);
}
return cmd;
}
/// <summary>
/// Simplify the creation of an IDbCommand object by allowing
/// a stored procedure and optional parameters to be provided
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandText">A valid SQL statement</param>
/// <param name="commandType">A System.Data.CommandType</param>
/// <param name="commandParameters">The parameters for the SQL statement</param>
/// <returns>A valid IDbCommand object</returns>
public virtual IDbCommand CreateCommand(string connectionString, string commandText, CommandType commandType, params IDataParameter[] commandParameters)
{
return CreateCommand(this.GetConnection(connectionString), commandText, commandType, commandParameters);
}
/// <summary>
/// Simplify the creation of an IDbCommand object by allowing
/// a stored procedure and optional parameters to be provided
/// </summary>
/// <example><code>
/// IDbCommand command = helper.CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName");
/// </code></example>
/// <param name="connection">A valid IDbConnection object</param>
/// <param name="commandText">A valid SQL statement</param>
/// <param name="commandType">A System.Data.CommandType</param>
/// <param name="commandParameters">The parameters for the SQL statement</param>
/// <returns>A valid IDbCommand object</returns>
public virtual IDbCommand CreateCommand(IDbConnection connection, string commandText, CommandType commandType, params IDataParameter[] commandParameters)
{
if (connection == null) throw new ArgumentNullException("connection");
if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
// Create an IDbCommand
IDbCommand cmd = connection.CreateCommand();
cmd.CommandText = commandText;
cmd.CommandType = commandType;
// If we receive parameter values, we need to figure out where they go
if ((commandParameters != null) && (commandParameters.Length > 0))
{
// Assign the provided source columns to these parameters based on parameter order
for (int index = 0; index < commandParameters.Length; index++)
commandParameters[index].SourceColumn = commandParameters[index].ParameterName.TrimStart(new char[] {'@'});
// Attach the discovered parameters to the IDbCommand object
AttachParameters(cmd, commandParameters);
}
return cmd;
}
#endregion
#region ExecuteNonQueryTypedParams
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns no resultset)
/// against the database specified in the connection string using the
/// dataRow column values as the stored procedure's parameters values.
/// This method will assign the parameter values based on row values.
/// </summary>
/// <param name="command">The IDbCommand to execute</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
public virtual int ExecuteNonQueryTypedParams(IDbCommand command, DataRow dataRow)
{
int retVal = 0;
// Clean Up Parameter Syntax
CleanParameterSyntax(command);
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Set the parameters values
AssignParameterValues(command.Parameters, dataRow);
retVal = ExecuteNonQuery(command);
}
else
{
retVal = ExecuteNonQuery(command);
}
return retVal;
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns no resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on row values.
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
public virtual int ExecuteNonQueryTypedParams(String connectionString, String spName, DataRow dataRow)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(connectionString, spName);
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns no resultset) against the specified IDbConnection
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on row values.
/// </summary>
/// <param name="connection">A valid IDbConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual int ExecuteNonQueryTypedParams(IDbConnection connection, String spName, DataRow dataRow)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(connection, spName);
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns no resultset) against the specified
/// IDbTransaction using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on row values.
/// </summary>
/// <param name="transaction">A valid IDbTransaction object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An int representing the number of rows affected by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual int ExecuteNonQueryTypedParams(IDbTransaction transaction, String spName, DataRow dataRow)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// Sf the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(transaction.Connection, spName);
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion
#region ExecuteDatasetTypedParams
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will assign the paraemter values based on row values.
/// </summary>
/// <param name="command">The IDbCommand to execute</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
public virtual DataSet ExecuteDatasetTypedParams(IDbCommand command, DataRow dataRow)
{
DataSet ds = null;
// Clean Up Parameter Syntax
CleanParameterSyntax(command);
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Set the parameters values
AssignParameterValues(command.Parameters, dataRow);
ds = ExecuteDataset(command);
}
else
{
ds = ExecuteDataset(command);
}
return ds;
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on row values.
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
public virtual DataSet ExecuteDatasetTypedParams(string connectionString, String spName, DataRow dataRow)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
//If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(connectionString, spName);
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified IDbConnection
/// using the dataRow column values as the store procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on row values.
/// </summary>
/// <param name="connection">A valid IDbConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual DataSet ExecuteDatasetTypedParams(IDbConnection connection, String spName, DataRow dataRow)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(connection, spName);
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteDataset(connection, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified IDbTransaction
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on row values.
/// </summary>
/// <param name="transaction">A valid IDbTransaction object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A DataSet containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual DataSet ExecuteDatasetTypedParams(IDbTransaction transaction, String spName, DataRow dataRow)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(transaction.Connection, spName);
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion
#region ExecuteReaderTypedParams
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will assign the parameter values based on parameter order.
/// </summary>
/// <param name="command">The IDbCommand to execute</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
public virtual IDataReader ExecuteReaderTypedParams(IDbCommand command, DataRow dataRow)
{
IDataReader reader = null;
// Clean Up Parameter Syntax
CleanParameterSyntax(command);
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Set the parameters values
AssignParameterValues(command.Parameters, dataRow);
reader = ExecuteReader(command);
}
else
{
reader = ExecuteReader(command);
}
return reader;
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
public virtual IDataReader ExecuteReaderTypedParams(String connectionString, String spName, DataRow dataRow)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(connectionString, spName);
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified IDbConnection
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="connection">A valid IDbConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual IDataReader ExecuteReaderTypedParams(IDbConnection connection, String spName, DataRow dataRow)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(connection, spName);
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteReader(connection, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a resultset) against the specified IDbTransaction
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="transaction">A valid IDbTransaction object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A IDataReader containing the resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual IDataReader ExecuteReaderTypedParams(IDbTransaction transaction, String spName, DataRow dataRow)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(transaction.Connection, spName);
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteReader(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion
#region ExecuteScalarTypedParams
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a 1x1 resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will assign the parameter values based on parameter order.
/// </summary>
/// <param name="command">The IDbCommand to execute</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if command is null.</exception>
public virtual object ExecuteScalarTypedParams(IDbCommand command, DataRow dataRow)
{
object retVal = null;
// Clean Up Parameter Syntax
CleanParameterSyntax(command);
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Set the parameters values
AssignParameterValues(command.Parameters, dataRow);
retVal = ExecuteScalar(command);
}
else
{
retVal = ExecuteScalar(command);
}
return retVal;
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a 1x1 resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
public virtual object ExecuteScalarTypedParams(String connectionString, String spName, DataRow dataRow)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(connectionString, spName);
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a 1x1 resultset) against the specified IDbConnection
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="connection">A valid IDbConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual object ExecuteScalarTypedParams(IDbConnection connection, String spName, DataRow dataRow)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(connection, spName);
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteScalar(connection, CommandType.StoredProcedure, spName);
}
}
/// <summary>
/// Execute a stored procedure via an IDbCommand (that returns a 1x1 resultset) against the specified IDbTransaction
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="transaction">A valid IDbTransaction object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if transaction.Connection is null</exception>
public virtual object ExecuteScalarTypedParams(IDbTransaction transaction, String spName, DataRow dataRow)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
IDataParameter[] commandParameters = GetSpParameterSet(transaction.Connection, spName);
// Set the parameters values
AssignParameterValues(commandParameters, dataRow);
return ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
else
{
return ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
}
}
#endregion
#region Parameter Discovery Functions
/// <summary>
/// Checks for the existence of a return value parameter in the parametervalues
/// </summary>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>true if the parameterValues contains a return value parameter, false otherwise</returns>
private bool CheckForReturnValueParameter(object[] parameterValues)
{
bool hasReturnValue = false;
foreach (object paramObject in parameterValues)
{
if (paramObject is IDataParameter)
{
IDataParameter paramInstance = (IDataParameter) paramObject;
if (paramInstance.Direction == ParameterDirection.ReturnValue)
{
hasReturnValue = true;
break;
}
}
}
return hasReturnValue;
}
/// <summary>
/// Check to see if the parameter values passed to the helper are, in fact, IDataParameters.
/// </summary>
/// <param name="parameterValues">Array of parameter values passed to helper</param>
/// <param name="iDataParameterValues">new array of IDataParameters built from parameter values</param>
/// <returns>True if the parameter values are IDataParameters</returns>
private bool AreParameterValuesIDataParameters(object[] parameterValues, IDataParameter[] iDataParameterValues)
{
bool areIDataParameters = true;
for (int i = 0; i < parameterValues.Length; i++)
{
if (!(parameterValues[i] is IDataParameter))
{
areIDataParameters = false;
break;
}
iDataParameterValues[i] = (IDataParameter) parameterValues[i];
}
return areIDataParameters;
}
/// <summary>
/// Retrieves the set of IDataParameters appropriate for the stored procedure
/// </summary>
/// <remarks>
/// This method will query the database for this information, and then store it in a cache for future requests.
/// </remarks>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <returns>An array of IDataParameterParameters</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
public virtual IDataParameter[] GetSpParameterSet(string connectionString, string spName)
{
return GetSpParameterSet(connectionString, spName, false);
}
/// <summary>
/// Retrieves the set of IDataParameters appropriate for the stored procedure
/// </summary>
/// <remarks>
/// This method will query the database for this information, and then store it in a cache for future requests.
/// </remarks>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="includeReturnValueParameter">A bool value indicating whether the return value parameter should be included in the results</param>
/// <returns>An array of IDataParameters</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
public virtual IDataParameter[] GetSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
using (IDbConnection connection = GetConnection(connectionString))
{
return GetSpParameterSetInternal(connection, spName, includeReturnValueParameter);
}
}
/// <summary>
/// Retrieves the set of IDataParameters appropriate for the stored procedure
/// </summary>
/// <remarks>
/// This method will query the database for this information, and then store it in a cache for future requests.
/// </remarks>
/// <param name="connection">A valid IDataConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <returns>An array of IDataParameters</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual IDataParameter[] GetSpParameterSet(IDbConnection connection, string spName)
{
return GetSpParameterSet(connection, spName, false);
}
/// <summary>
/// Retrieves the set of IDataParameters appropriate for the stored procedure
/// </summary>
/// <remarks>
/// This method will query the database for this information, and then store it in a cache for future requests.
/// </remarks>
/// <param name="connection">A valid IDbConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="includeReturnValueParameter">A bool value indicating whether the return value parameter should be included in the results</param>
/// <returns>An array of IDataParameters</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public virtual IDataParameter[] GetSpParameterSet(IDbConnection connection, string spName, bool includeReturnValueParameter)
{
if (connection == null) throw new ArgumentNullException("connection");
if (connection as ICloneable == null) throw new ArgumentException("can磘 discover parameters if the connection doesn磘 implement the ICloneable interface", "connection");
IDbConnection clonedConnection = (IDbConnection) ((ICloneable) connection).Clone();
return GetSpParameterSetInternal(clonedConnection, spName, includeReturnValueParameter);
}
/// <summary>
/// Retrieves the set of IDataParameters appropriate for the stored procedure
/// </summary>
/// <param name="connection">A valid IDbConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="includeReturnValueParameter">A bool value indicating whether the return value parameter should be included in the results</param>
/// <returns>An array of IDataParameters</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
private IDataParameter[] GetSpParameterSetInternal(IDbConnection connection, string spName, bool includeReturnValueParameter)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
// string hashKey = connection.ConnectionString + " :" + spName + (includeReturnValueParameter ? " :include ReturnValue Parameter" :"");
IDataParameter[] cachedParameters;
cachedParameters = GetCachedParameterSet(connection,
spName + (includeReturnValueParameter ? " :include ReturnValue Parameter" : ""));
if (cachedParameters == null)
{
IDataParameter[] spParameters = DiscoverSpParameterSet(connection, spName, includeReturnValueParameter);
CacheParameterSet(connection,
spName + (includeReturnValueParameter ? " :include ReturnValue Parameter" : ""), spParameters);
cachedParameters = ADOHelperParameterCache.CloneParameters(spParameters);
}
return cachedParameters;
}
/// <summary>
/// Retrieve a parameter array from the cache
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>An array of IDataParameters</returns>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
public IDataParameter[] GetCachedParameterSet(string connectionString, string commandText)
{
using (IDbConnection connection = GetConnection(connectionString))
{
return GetCachedParameterSetInternal(connection, commandText);
}
}
/// <summary>
/// Retrieve a parameter array from the cache
/// </summary>
/// <param name="connection">A valid IDbConnection object</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>An array of IDataParameters</returns>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public IDataParameter[] GetCachedParameterSet(IDbConnection connection, string commandText)
{
return GetCachedParameterSetInternal(connection, commandText);
}
/// <summary>
/// Retrieve a parameter array from the cache
/// </summary>
/// <param name="connection">A valid IDbConnection object</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>An array of IDataParameters</returns>
private IDataParameter[] GetCachedParameterSetInternal(IDbConnection connection, string commandText)
{
bool mustCloseConnection = false;
// this way we control the connection, and therefore the connection string that gets saved as a hash key
if (connection.State != ConnectionState.Open)
{
connection.Open();
mustCloseConnection = true;
}
IDataParameter[] parameters = ADOHelperParameterCache.GetCachedParameterSet(connection.ConnectionString, commandText);
if (mustCloseConnection)
{
connection.Close();
}
return parameters;
}
/// <summary>
/// Add parameter array to the cache
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters to be cached</param>
public void CacheParameterSet(string connectionString, string commandText, params IDataParameter[] commandParameters)
{
using (IDbConnection connection = GetConnection(connectionString))
{
CacheParameterSetInternal(connection, commandText, commandParameters);
}
}
/// <summary>
/// Add parameter array to the cache
/// </summary>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters to be cached</param>
public void CacheParameterSet(IDbConnection connection, string commandText, params IDataParameter[] commandParameters)
{
if (connection is ICloneable)
{
using (IDbConnection clonedConnection = (IDbConnection) ((ICloneable) connection).Clone())
{
CacheParameterSetInternal(clonedConnection, commandText, commandParameters);
}
}
else
{
throw new InvalidCastException();
}
}
/// <summary>
/// Add parameter array to the cache
/// </summary>
/// <param name="connection">A valid IDbConnection</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters to be cached</param>
private void CacheParameterSetInternal(IDbConnection connection, string commandText, params IDataParameter[] commandParameters)
{
// this way we control the connection, and therefore the connection string that gets saved as a hask key
connection.Open();
ADOHelperParameterCache.CacheParameterSet(connection.ConnectionString, commandText, commandParameters);
connection.Close();
}
/// <summary>
/// Resolve at run time the appropriate set of IDataParameters for a stored procedure
/// </summary>
/// <param name="connection">A valid IDbConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="includeReturnValueParameter">Whether or not to include their return value parameter</param>
/// <returns>The parameter array discovered.</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
private IDataParameter[] DiscoverSpParameterSet(IDbConnection connection, string spName, bool includeReturnValueParameter)
{
if (connection == null) throw new ArgumentNullException("connection");
if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
IDbCommand cmd = connection.CreateCommand();
cmd.CommandText = spName;
cmd.CommandType = CommandType.StoredProcedure;
connection.Open();
DeriveParameters(cmd);
connection.Close();
if (!includeReturnValueParameter)
{
// not all providers have return value parameters...don't just remove this parameter indiscriminately
if (cmd.Parameters.Count > 0 && ((IDataParameter) cmd.Parameters[0]).Direction == ParameterDirection.ReturnValue)
{
cmd.Parameters.RemoveAt(0);
}
}
IDataParameter[] discoveredParameters = new IDataParameter[cmd.Parameters.Count];
cmd.Parameters.CopyTo(discoveredParameters, 0);
// Init the parameters with a DBNull value
foreach (IDataParameter discoveredParameter in discoveredParameters)
{
discoveredParameter.Value = DBNull.Value;
}
return discoveredParameters;
}
#endregion Parameter Discovery Functions
}
#region ParameterCache
/// <summary>
/// ADOHelperParameterCache provides functions to leverage a static cache of procedure parameters, and the
/// ability to discover parameters for stored procedures at run-time.
/// </summary>
public sealed class ADOHelperParameterCache
{
private static Hashtable paramCache = Hashtable.Synchronized(new Hashtable());
/// <summary>
/// Deep copy of cached IDataParameter array
/// </summary>
/// <param name="originalParameters"></param>
/// <returns></returns>
internal static IDataParameter[] CloneParameters(IDataParameter[] originalParameters)
{
IDataParameter[] clonedParameters = new IDataParameter[originalParameters.Length];
for (int i = 0, j = originalParameters.Length; i < j; i++)
{
clonedParameters[i] = (IDataParameter) ((ICloneable) originalParameters[i]).Clone();
}
return clonedParameters;
}
#region caching functions
/// <summary>
/// Add parameter array to the cache
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <param name="commandParameters">An array of IDataParameters to be cached</param>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
internal static void CacheParameterSet(string connectionString, string commandText, params IDataParameter[] commandParameters)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
string hashKey = connectionString + " :" + commandText;
paramCache[hashKey] = commandParameters;
}
/// <summary>
/// Retrieve a parameter array from the cache
/// </summary>
/// <param name="connectionString">A valid connection string for an IDbConnection</param>
/// <param name="commandText">The stored procedure name or SQL command</param>
/// <returns>An array of IDataParameters</returns>
/// <exception cref="System.ArgumentNullException">Thrown if commandText is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connectionString is null</exception>
internal static IDataParameter[] GetCachedParameterSet(string connectionString, string commandText)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
string hashKey = connectionString + " :" + commandText;
IDataParameter[] cachedParameters = paramCache[hashKey] as IDataParameter[];
if (cachedParameters == null)
{
return null;
}
else
{
return CloneParameters(cachedParameters);
}
}
#endregion caching functions
}
#endregion
public class DAABSectionHandler :
IConfigurationSectionHandler
{
#region IConfigurationSectionHandler Members
/// <summary>
/// Evaluates the given XML section and returns a Hashtable that contains the results of the evaluation.
/// </summary>
/// <param name="parent">The configuration settings in a corresponding parent configuration section. </param>
/// <param name="configContext">An HttpConfigurationContext when Create is called from the ASP.NET configuration system. Otherwise, this parameter is reserved and is a null reference (Nothing in Visual Basic). </param>
/// <param name="section">The XmlNode that contains the configuration information to be handled. Provides direct access to the XML contents of the configuration section. </param>
/// <returns>A Hashtable that contains the section's configuration settings.</returns>
public object Create(object parent, object configContext, XmlNode section)
{
Hashtable ht = new Hashtable();
XmlNodeList list = section.SelectNodes("daabProvider");
foreach (XmlNode prov in list)
{
if (prov.Attributes["alias"] == null)
throw new InvalidOperationException("The 'daabProvider' node must contain an attribute named 'alias' with the alias name for the provider.");
if (prov.Attributes["assembly"] == null)
throw new InvalidOperationException("The 'daabProvider' node must contain an attribute named 'assembly' with the name of the assembly containing the provider.");
if (prov.Attributes["type"] == null)
throw new InvalidOperationException("The 'daabProvider' node must contain an attribute named 'type' with the full name of the type for the provider.");
ht[prov.Attributes["alias"].Value] = new ProviderAlias(prov.Attributes["assembly"].Value, prov.Attributes["type"].Value);
}
return ht;
}
#endregion
}
/// <summary>
/// This class is for reading the 'ProviderAlias' tag from the 'daabProviders' section of the App.Config file
/// </summary>
public class ProviderAlias
{
#region Member variables
private string _assemblyName;
private string _typeName;
#endregion
#region Constructor
/// <summary>
/// Constructor required by IConfigurationSectionHandler
/// </summary>
/// <param name="assemblyName">The Assembly where this provider can be found</param>
/// <param name="typeName">The type of the provider</param>
public ProviderAlias(string assemblyName, string typeName)
{
_assemblyName = assemblyName;
_typeName = typeName;
}
#endregion
#region Properties
/// <summary>
/// Returns the Assembly name for this provider
/// </summary>
/// <value>The Assembly name for the specified provider</value>
public string AssemblyName
{
get { return _assemblyName; }
}
/// <summary>
/// Returns the type name of this provider
/// </summary>
/// <value>The type name of the specified provider</value>
public string TypeName
{
get { return _typeName; }
}
#endregion
}
/// <summary>
/// The SqlServer class is intended to encapsulate high performance, scalable best practices for
/// common uses of the SqlClient ADO.NET provider. It is created using the abstract factory in AdoHelper.
/// </summary>
public class SqlServer : AdoHelper
{
/// <summary>
/// Create a SQL Helper. Needs to be a default constructor so that the Factory can create it
/// </summary>
public SqlServer()
{
}
#region Overrides
/// <summary>
/// Returns an array of SqlParameters of the specified size
/// </summary>
/// <param name="size">size of the array</param>
/// <returns>The array of SqlParameters</returns>
protected override IDataParameter[] GetDataParameters(int size)
{
return new SqlParameter[size];
}
/// <summary>
/// Returns a SqlConnection object for the given connection string
/// </summary>
/// <param name="connectionString">The connection string to be used to create the connection</param>
/// <returns>A SqlConnection object</returns>
public override IDbConnection GetConnection(string connectionString)
{
return new SqlConnection(connectionString);
}
/// <summary>
/// Returns a SqlDataAdapter object
/// </summary>
/// <returns>The SqlDataAdapter</returns>
public override IDbDataAdapter GetDataAdapter()
{
return new SqlDataAdapter();
}
/// <summary>
/// Calls the CommandBuilder.DeriveParameters method for the specified provider, doing any setup and cleanup necessary
/// </summary>
/// <param name="cmd">The IDbCommand referencing the stored procedure from which the parameter information is to be derived. The derived parameters are added to the Parameters collection of the IDbCommand. </param>
public override void DeriveParameters(IDbCommand cmd)
{
bool mustCloseConnection = false;
if (!(cmd is SqlCommand))
throw new ArgumentException("The command provided is not a SqlCommand instance.", "cmd");
if (cmd.Connection.State != ConnectionState.Open)
{
cmd.Connection.Open();
mustCloseConnection = true;
}
SqlDeriveParameters.DeriveParameters((SqlCommand) cmd);
if (mustCloseConnection)
{
cmd.Connection.Close();
}
}
/// <summary>
/// Returns a SqlParameter object
/// </summary>
/// <returns>The SqlParameter object</returns>
public override IDataParameter GetParameter()
{
return new SqlParameter();
}
/// <summary>
/// Detach the IDataParameters from the command object, so they can be used again.
/// </summary>
/// <param name="command">command object to clear</param>
protected override void ClearCommand(IDbCommand command)
{
// HACK: There is a problem here, the output parameter values are fletched
// when the reader is closed, so if the parameters are detached from the command
// then the IDataReader can磘 set its values.
// When this happen, the parameters can磘 be used again in other command.
bool canClear = true;
foreach (IDataParameter commandParameter in command.Parameters)
{
if (commandParameter.Direction != ParameterDirection.Input)
canClear = false;
}
if (canClear)
{
command.Parameters.Clear();
}
}
/// <summary>
/// This cleans up the parameter syntax for an SQL Server call. This was split out from PrepareCommand so that it could be called independently.
/// </summary>
/// <param name="command">An IDbCommand object containing the CommandText to clean.</param>
public override void CleanParameterSyntax(IDbCommand command)
{
// do nothing for SQL
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the provided SqlConnection.
/// </summary>
/// <example>
/// <code>
/// XmlReader r = helper.ExecuteXmlReader(command);
/// </code></example>
/// <param name="command">The IDbCommand to execute</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public override XmlReader ExecuteXmlReader(IDbCommand command)
{
bool mustCloseConnection = false;
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
mustCloseConnection = true;
}
CleanParameterSyntax(command);
// Create the DataAdapter & DataSet
XmlReader retval = ((SqlCommand) command).ExecuteXmlReader();
// Detach the SqlParameters from the command object, so they can be used again
// don't do this...screws up output parameters -- cjbreisch
// cmd.Parameters.Clear();
if (mustCloseConnection)
{
command.Connection.Close();
}
return retval;
}
/// <summary>
/// Provider specific code to set up the updating/ed event handlers used by UpdateDataset
/// </summary>
/// <param name="dataAdapter">DataAdapter to attach the event handlers to</param>
/// <param name="rowUpdatingHandler">The handler to be called when a row is updating</param>
/// <param name="rowUpdatedHandler">The handler to be called when a row is updated</param>
protected override void AddUpdateEventHandlers(IDbDataAdapter dataAdapter, RowUpdatingHandler rowUpdatingHandler, RowUpdatedHandler rowUpdatedHandler)
{
if (rowUpdatingHandler != null)
{
this.m_rowUpdating = rowUpdatingHandler;
((SqlDataAdapter) dataAdapter).RowUpdating += new SqlRowUpdatingEventHandler(RowUpdating);
}
if (rowUpdatedHandler != null)
{
this.m_rowUpdated = rowUpdatedHandler;
((SqlDataAdapter) dataAdapter).RowUpdated += new SqlRowUpdatedEventHandler(RowUpdated);
}
}
/// <summary>
/// Handles the RowUpdating event
/// </summary>
/// <param name="obj">The object that published the event</param>
/// <param name="e">The SqlRowUpdatingEventArgs</param>
protected void RowUpdating(object obj, SqlRowUpdatingEventArgs e)
{
base.RowUpdating(obj, e);
}
/// <summary>
/// Handles the RowUpdated event
/// </summary>
/// <param name="obj">The object that published the event</param>
/// <param name="e">The SqlRowUpdatedEventArgs</param>
protected void RowUpdated(object obj, SqlRowUpdatedEventArgs e)
{
base.RowUpdated(obj, e);
}
/// <summary>
/// Handle any provider-specific issues with BLOBs here by "washing" the IDataParameter and returning a new one that is set up appropriately for the provider.
/// </summary>
/// <param name="connection">The IDbConnection to use in cleansing the parameter</param>
/// <param name="p">The parameter before cleansing</param>
/// <returns>The parameter after it's been cleansed.</returns>
protected override IDataParameter GetBlobParameter(IDbConnection connection, IDataParameter p)
{
// do nothing special for BLOBs...as far as we know now.
return p;
}
#endregion
}
#region Derive Parameters
// We create our own class to do this because the existing ADO.NET 1.1 implementation is broken.
internal class SqlDeriveParameters
{
internal static void DeriveParameters(SqlCommand cmd)
{
string cmdText;
SqlCommand newCommand;
SqlDataReader reader;
ArrayList parameterList;
SqlParameter sqlParam;
CommandType cmdType;
string procedureSchema;
string procedureName;
int groupNumber;
SqlTransaction trnSql = cmd.Transaction;
cmdType = cmd.CommandType;
if ((cmdType == CommandType.Text))
{
throw new InvalidOperationException();
}
else if ((cmdType == CommandType.TableDirect))
{
throw new InvalidOperationException();
}
else if ((cmdType != CommandType.StoredProcedure))
{
throw new InvalidOperationException();
}
procedureName = cmd.CommandText;
string server = null;
string database = null;
procedureSchema = null;
// split out the procedure name to get the server, database, etc.
GetProcedureTokens(ref procedureName, ref server, ref database, ref procedureSchema);
// look for group numbers
groupNumber = ParseGroupNumber(ref procedureName);
newCommand = null;
// set up the command string. We use sp_procuedure_params_rowset to get the parameters
if (database != null)
{
cmdText = string.Concat("[", database, "]..sp_procedure_params_rowset");
if (server != null)
{
cmdText = string.Concat(server, ".", cmdText);
}
// be careful of transactions
if (trnSql != null)
{
newCommand = new SqlCommand(cmdText, cmd.Connection, trnSql);
}
else
{
newCommand = new SqlCommand(cmdText, cmd.Connection);
}
}
else
{
// be careful of transactions
if (trnSql != null)
{
newCommand = new SqlCommand("sp_procedure_params_rowset", cmd.Connection, trnSql);
}
else
{
newCommand = new SqlCommand("sp_procedure_params_rowset", cmd.Connection);
}
}
newCommand.CommandType = CommandType.StoredProcedure;
newCommand.Parameters.Add(new SqlParameter("@procedure_name", SqlDbType.NVarChar, 255));
newCommand.Parameters[0].Value = procedureName;
// make sure we specify
if (! IsEmptyString(procedureSchema))
{
newCommand.Parameters.Add(new SqlParameter("@procedure_schema", SqlDbType.NVarChar, 255));
newCommand.Parameters[1].Value = procedureSchema;
}
// make sure we specify the groupNumber if we were given one
if (groupNumber != 0)
{
newCommand.Parameters.Add(new SqlParameter("@group_number", groupNumber));
}
reader = null;
parameterList = new ArrayList();
try
{
// get a reader full of our params
reader = newCommand.ExecuteReader();
sqlParam = null;
while (reader.Read())
{
// get all the parameter properties that we can get, Name, type, length, direction, precision
sqlParam = new SqlParameter();
sqlParam.ParameterName = (string) (reader["PARAMETER_NAME"]);
sqlParam.SqlDbType = GetSqlDbType((short) (reader["DATA_TYPE"]), (string) (reader["TYPE_NAME"]));
if (reader["CHARACTER_MAXIMUM_LENGTH"] != DBNull.Value)
{
sqlParam.Size = (int) (reader["CHARACTER_MAXIMUM_LENGTH"]);
}
sqlParam.Direction = GetParameterDirection((short) (reader["PARAMETER_TYPE"]));
if ((sqlParam.SqlDbType == SqlDbType.Decimal))
{
sqlParam.Scale = (byte) (((short) (reader["NUMERIC_SCALE"]) & 255));
sqlParam.Precision = (byte) (((short) (reader["NUMERIC_PRECISION"]) & 255));
}
parameterList.Add(sqlParam);
}
}
finally
{
// close our reader and connection when we're done
if (reader != null)
{
reader.Close();
}
newCommand.Connection = null;
}
// we didn't get any parameters
if ((parameterList.Count == 0))
{
throw new InvalidOperationException();
}
cmd.Parameters.Clear();
// add the parameters to the command object
foreach (object parameter in parameterList)
{
cmd.Parameters.Add(parameter);
}
}
/// <summary>
/// Checks to see if the stored procedure being called is part of a group, then gets the group number if necessary
/// </summary>
/// <param name="procedure">Stored procedure being called. This method may change this parameter by removing the group number if it exists.</param>
/// <returns>the group number</returns>
private static int ParseGroupNumber(ref string procedure)
{
string newProcName;
int groupPos = procedure.IndexOf(';');
int groupIndex = 0;
if (groupPos > 0)
{
newProcName = procedure.Substring(0, groupPos);
try
{
groupIndex = int.Parse(procedure.Substring(groupPos + 1));
}
catch
{
throw new InvalidOperationException();
}
}
else
{
newProcName = procedure;
groupIndex = 0;
}
procedure = newProcName;
return groupIndex;
}
/// <summary>
/// Tokenize the procedure string
/// </summary>
/// <param name="procedure">The procedure name</param>
/// <param name="server">The server name</param>
/// <param name="database">The database name</param>
/// <param name="owner">The owner name</param>
private static void GetProcedureTokens(ref string procedure, ref string server, ref string database, ref string owner)
{
string[] spNameTokens;
int arrIndex;
int nextPos;
int currPos;
int tokenCount;
server = null;
database = null;
owner = null;
spNameTokens = new string[4];
if (! IsEmptyString(procedure))
{
arrIndex = 0;
nextPos = 0;
currPos = 0;
while ((arrIndex < 4))
{
currPos = procedure.IndexOf('.', nextPos);
if ((-1 == currPos))
{
spNameTokens[arrIndex] = procedure.Substring(nextPos);
break;
}
spNameTokens[arrIndex] = procedure.Substring(nextPos, (currPos - nextPos));
nextPos = (currPos + 1);
if ((procedure.Length <= nextPos))
{
break;
}
arrIndex = (arrIndex + 1);
}
tokenCount = arrIndex + 1;
// based on how many '.' we found, we know what tokens we found
switch (tokenCount)
{
case 1:
procedure = spNameTokens[0];
break;
case 2:
procedure = spNameTokens[1];
owner = spNameTokens[0];
break;
case 3:
procedure = spNameTokens[2];
owner = spNameTokens[1];
database = spNameTokens[0];
break;
case 4:
procedure = spNameTokens[3];
owner = spNameTokens[2];
database = spNameTokens[1];
server = spNameTokens[0];
break;
}
}
}
/// <summary>
/// Checks for an empty string
/// </summary>
/// <param name="str">String to check</param>
/// <returns>boolean value indicating whether string is empty</returns>
private static bool IsEmptyString(string str)
{
if (str != null)
{
return (0 == str.Length);
}
return true;
}
/// <summary>
/// Convert OleDbType to SQlDbType
/// </summary>
/// <param name="paramType">The OleDbType to convert</param>
/// <param name="typeName">The typeName to convert for items such as Money and SmallMoney which both map to OleDbType.Currency</param>
/// <returns>The converted SqlDbType</returns>
private static SqlDbType GetSqlDbType(short paramType, string typeName)
{
SqlDbType cmdType;
OleDbType oleDbType;
cmdType = SqlDbType.Variant;
oleDbType = (OleDbType) (paramType);
switch (oleDbType)
{
case OleDbType.SmallInt:
cmdType = SqlDbType.SmallInt;
break;
case OleDbType.Integer:
cmdType = SqlDbType.Int;
break;
case OleDbType.Single:
cmdType = SqlDbType.Real;
break;
case OleDbType.Double:
cmdType = SqlDbType.Float;
break;
case OleDbType.Currency:
cmdType = (typeName == "money") ? SqlDbType.Money : SqlDbType.SmallMoney;
break;
case OleDbType.Date:
cmdType = (typeName == "datetime") ? SqlDbType.DateTime : SqlDbType.SmallDateTime;
break;
case OleDbType.BSTR:
cmdType = (typeName == "nchar") ? SqlDbType.NChar : SqlDbType.NVarChar;
break;
case OleDbType.Boolean:
cmdType = SqlDbType.Bit;
break;
case OleDbType.Variant:
cmdType = SqlDbType.Variant;
break;
case OleDbType.Decimal:
cmdType = SqlDbType.Decimal;
break;
case OleDbType.TinyInt:
cmdType = SqlDbType.TinyInt;
break;
case OleDbType.UnsignedTinyInt:
cmdType = SqlDbType.TinyInt;
break;
case OleDbType.UnsignedSmallInt:
cmdType = SqlDbType.SmallInt;
break;
case OleDbType.BigInt:
cmdType = SqlDbType.BigInt;
break;
case OleDbType.Filetime:
cmdType = (typeName == "datetime") ? SqlDbType.DateTime : SqlDbType.SmallDateTime;
break;
case OleDbType.Guid:
cmdType = SqlDbType.UniqueIdentifier;
break;
case OleDbType.Binary:
cmdType = (typeName == "binary") ? SqlDbType.Binary : SqlDbType.VarBinary;
break;
case OleDbType.Char:
cmdType = (typeName == "char") ? SqlDbType.Char : SqlDbType.VarChar;
break;
case OleDbType.WChar:
cmdType = (typeName == "nchar") ? SqlDbType.NChar : SqlDbType.NVarChar;
break;
case OleDbType.Numeric:
cmdType = SqlDbType.Decimal;
break;
case OleDbType.DBDate:
cmdType = (typeName == "datetime") ? SqlDbType.DateTime : SqlDbType.SmallDateTime;
break;
case OleDbType.DBTime:
cmdType = (typeName == "datetime") ? SqlDbType.DateTime : SqlDbType.SmallDateTime;
break;
case OleDbType.DBTimeStamp:
cmdType = (typeName == "datetime") ? SqlDbType.DateTime : SqlDbType.SmallDateTime;
break;
case OleDbType.VarChar:
cmdType = (typeName == "char") ? SqlDbType.Char : SqlDbType.VarChar;
break;
case OleDbType.LongVarChar:
cmdType = SqlDbType.Text;
break;
case OleDbType.VarWChar:
cmdType = (typeName == "nchar") ? SqlDbType.NChar : SqlDbType.NVarChar;
break;
case OleDbType.LongVarWChar:
cmdType = SqlDbType.NText;
break;
case OleDbType.VarBinary:
cmdType = (typeName == "binary") ? SqlDbType.Binary : SqlDbType.VarBinary;
break;
case OleDbType.LongVarBinary:
cmdType = SqlDbType.Image;
break;
}
return cmdType;
}
/// <summary>
/// Converts the OleDb parameter direction
/// </summary>
/// <param name="oledbDirection">The integer parameter direction</param>
/// <returns>A ParameterDirection</returns>
private static ParameterDirection GetParameterDirection(short oledbDirection)
{
ParameterDirection pd;
switch (oledbDirection)
{
case 1:
pd = ParameterDirection.Input;
break;
case 2: //或者干脆注释掉 case 2 的全部
pd = ParameterDirection.Output; //是这里的问题
goto default; //我加的这句话
//break; //我注释掉的这句话
case 4:
pd = ParameterDirection.ReturnValue;
break;
default:
pd = ParameterDirection.InputOutput;
break;
}
return pd;
}
}
#endregion
/// <summary>
/// The SqlHelper class is intended to encapsulate high performance, scalable best practices for
/// common uses of SqlClient
/// </summary>
public sealed class SqlHelper
{
/// <summary>
/// Calls the SqlCommandBuilder.DeriveParameters, doing any setup and cleanup necessary
/// </summary>
/// <param name="cmd">The SqlCommand referencing the stored procedure from which the parameter information is to be derived. The derived parameters are added to the Parameters collection of the SqlCommand. </param>
public static void DeriveParameters(SqlCommand cmd)
{
new SqlServer().DeriveParameters(cmd);
}
#region Private constructor
// Since this class provides only static methods, make the default constructor private to prevent
// instances from being created with "new SqlHelper()"
private SqlHelper()
{
}
#endregion Private constructor
#region GetParameter
/// <summary>
/// Get a SqlParameter for use in a SQL command
/// </summary>
/// <param name="name">The name of the parameter to create</param>
/// <param name="value">The value of the specified parameter</param>
/// <returns>A SqlParameter object</returns>
public static SqlParameter GetParameter(string name, object value)
{
return (SqlParameter) (new SqlServer().GetParameter(name, value));
}
/// <summary>
/// Get a SqlParameter for use in a SQL command
/// </summary>
/// <param name="name">The name of the parameter to create</param>
/// <param name="dbType">The System.Data.DbType of the parameter</param>
/// <param name="size">The size of the parameter</param>
/// <param name="direction">The System.Data.ParameterDirection of the parameter</param>
/// <returns>A SqlParameter object</returns>
public static SqlParameter GetParameter(string name, DbType dbType, int size, ParameterDirection direction)
{
return (SqlParameter) (new SqlServer().GetParameter(name, dbType, size, direction));
}
/// <summary>
/// Get a SqlParameter for use in a SQL command
/// </summary>
/// <param name="name">The name of the parameter to create</param>
/// <param name="dbType">The System.Data.DbType of the parameter</param>
/// <param name="size">The size of the parameter</param>
/// <param name="sourceColumn">The source column of the parameter</param>
/// <param name="sourceVersion">The System.Data.DataRowVersion of the parameter</param>
/// <returns>A SqlParameter object</returns>
public static SqlParameter GetParameter(string name, DbType dbType, int size, string sourceColumn, DataRowVersion sourceVersion)
{
return (SqlParameter) new SqlServer().GetParameter(name, dbType, size, sourceColumn, sourceVersion);
}
#endregion
#region ExecuteNonQuery
/// <summary>
/// Execute a SqlCommand (that returns no resultset) against the database specified in
/// the connection string
/// </summary>
/// <remarks>
/// e.g.:
/// int result = ExecuteNonQuery(command);
/// </remarks>
/// <param name="command">The SqlCommand to execute</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(SqlCommand command)
{
return new SqlServer().ExecuteNonQuery(command);
}
/// <summary>
/// Execute a SqlCommand (that returns no resultset and takes no parameters) against the database specified in
/// the connection string
/// </summary>
/// <remarks>
/// e.g.:
/// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders");
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteNonQuery(connectionString, commandType, commandText);
}
/// <summary>
/// Execute a SqlCommand (that returns no resultset) against the database specified in the connection string
/// using the provided parameters
/// </summary>
/// <remarks>
/// e.g.:
/// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteNonQuery(connectionString, commandType, commandText, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns no resultset) against the database specified in
/// the connection string using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36);
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored prcedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(string connectionString, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteNonQuery(connectionString, spName, parameterValues);
}
/// <summary>
/// Execute a SqlCommand (that returns no resultset and takes no parameters) against the provided SqlConnection.
/// </summary>
/// <remarks>
/// e.g.:
/// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders");
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteNonQuery(connection, commandType, commandText);
}
/// <summary>
/// Execute a SqlCommand (that returns no resultset) against the specified SqlConnection
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteNonQuery(connection, commandType, commandText, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified SqlConnection
/// using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36);
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(SqlConnection connection, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteNonQuery(connection, spName, parameterValues);
}
/// <summary>
/// Execute a SqlCommand (that returns no resultset and takes no parameters) against the provided SqlTransaction.
/// </summary>
/// <remarks>
/// e.g.:
/// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders");
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteNonQuery(transaction, commandType, commandText);
}
/// <summary>
/// Execute a SqlCommand (that returns no resultset) against the specified SqlTransaction
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteNonQuery(transaction, commandType, commandText, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified
/// SqlTransaction using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36);
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(SqlTransaction transaction, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteNonQuery(transaction, spName, parameterValues);
}
#endregion ExecuteNonQuery
#region ExecuteDataset
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the database specified in
/// the connection string.
/// </summary>
/// <remarks>
/// e.g.:
/// DataSet ds = ExecuteDataset(command);
/// </remarks>
/// <param name="command">The SqlCommand to execute</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(SqlCommand command)
{
return new SqlServer().ExecuteDataset(command);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in
/// the connection string.
/// </summary>
/// <remarks>
/// e.g.:
/// DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteDataset(connectionString, commandType, commandText);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the database specified in the connection string
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteDataset(connectionString, commandType, commandText, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in
/// the connection string using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36);
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(string connectionString, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteDataset(connectionString, spName, parameterValues);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection.
/// </summary>
/// <remarks>
/// e.g.:
/// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteDataset(connection, commandType, commandText);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the specified SqlConnection
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteDataset(connection, commandType, commandText, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection
/// using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// DataSet ds = ExecuteDataset(conn, "GetOrders", 24, 36);
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(SqlConnection connection, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteDataset(connection, spName, parameterValues);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction.
/// </summary>
/// <remarks>
/// e.g.:
/// DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteDataset(transaction, commandType, commandText);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteDataset(transaction, commandType, commandText, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified
/// SqlTransaction using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// DataSet ds = ExecuteDataset(trans, "GetOrders", 24, 36);
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(SqlTransaction transaction, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteDataset(transaction, spName, parameterValues);
}
#endregion ExecuteDataset
#region ExecuteReader
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the database specified in
/// the connection string.
/// </summary>
/// <remarks>
/// e.g.:
/// SqlDataReader dr = ExecuteReader(command);
/// </remarks>
/// <param name="command">The SqlCommand to execute</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReader(SqlCommand command)
{
return new SqlServer().ExecuteReader(command) as SqlDataReader;
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in
/// the connection string.
/// </summary>
/// <remarks>
/// e.g.:
/// SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteReader(connectionString, commandType, commandText) as SqlDataReader;
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the database specified in the connection string
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteReader(connectionString, commandType, commandText, commandParameters) as SqlDataReader;
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in
/// the connection string using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// SqlDataReader dr = ExecuteReader(connString, "GetOrders", 24, 36);
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReader(string connectionString, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteReader(connectionString, spName, parameterValues) as SqlDataReader;
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection.
/// </summary>
/// <remarks>
/// e.g.:
/// SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteReader(connection, commandType, commandText) as SqlDataReader;
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the specified SqlConnection
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteReader(connection, commandType, commandText, commandParameters) as SqlDataReader;
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection
/// using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// SqlDataReader dr = ExecuteReader(conn, "GetOrders", 24, 36);
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReader(SqlConnection connection, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteReader(connection, spName, parameterValues) as SqlDataReader;
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction.
/// </summary>
/// <remarks>
/// e.g.:
/// SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteReader(transaction, commandType, commandText) as SqlDataReader;
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteReader(transaction, commandType, commandText, commandParameters) as SqlDataReader;
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified
/// SqlTransaction using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// SqlDataReader dr = ExecuteReader(trans, "GetOrders", 24, 36);
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReader(SqlTransaction transaction, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteReader(transaction, spName, parameterValues) as SqlDataReader;
}
#endregion ExecuteReader
#region ExecuteScalar
/// <summary>
/// Execute a SqlCommand (that returns a 1x1 resultset) against the database specified in
/// the connection string.
/// </summary>
/// <remarks>
/// e.g.:
/// int orderCount = (int)ExecuteScalar(command);
/// </remarks>
/// <param name="command">The SqlCommand to execute</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalar(SqlCommand command)
{
// Pass through the call providing null for the set of SqlParameters
return new SqlServer().ExecuteScalar(command);
}
/// <summary>
/// Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the database specified in
/// the connection string.
/// </summary>
/// <remarks>
/// e.g.:
/// int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount");
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText)
{
// Pass through the call providing null for the set of SqlParameters
return new SqlServer().ExecuteScalar(connectionString, commandType, commandText);
}
/// <summary>
/// Execute a SqlCommand (that returns a 1x1 resultset) against the database specified in the connection string
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteScalar(connectionString, commandType, commandText, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the database specified in
/// the connection string using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// int orderCount = (int)ExecuteScalar(connString, "GetOrderCount", 24, 36);
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalar(string connectionString, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteScalar(connectionString, spName, parameterValues);
}
/// <summary>
/// Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the provided SqlConnection.
/// </summary>
/// <remarks>
/// e.g.:
/// int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount");
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteScalar(connection, commandType, commandText);
}
/// <summary>
/// Execute a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteScalar(connection, commandType, commandText, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection
/// using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// int orderCount = (int)ExecuteScalar(conn, "GetOrderCount", 24, 36);
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalar(SqlConnection connection, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteScalar(connection, spName, parameterValues);
}
/// <summary>
/// Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the provided SqlTransaction.
/// </summary>
/// <remarks>
/// e.g.:
/// int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount");
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteScalar(transaction, commandType, commandText);
}
/// <summary>
/// Execute a SqlCommand (that returns a 1x1 resultset) against the specified SqlTransaction
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteScalar(transaction, commandType, commandText, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified
/// SqlTransaction using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// int orderCount = (int)ExecuteScalar(trans, "GetOrderCount", 24, 36);
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalar(SqlTransaction transaction, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteScalar(transaction, spName, parameterValues);
}
#endregion ExecuteScalar
#region ExecuteXmlReader
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the provided SqlConnection.
/// </summary>
/// <remarks>
/// e.g.:
/// XmlReader r = ExecuteXmlReader(SqlCommand command);
/// </remarks>
/// <param name="command">The SqlCommand to execute</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public static XmlReader ExecuteXmlReader(SqlCommand command)
{
return new SqlServer().ExecuteXmlReader(command);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection.
/// </summary>
/// <remarks>
/// e.g.:
/// XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command using "FOR XML AUTO"</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteXmlReader(connection, commandType, commandText);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the specified SqlConnection
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command using "FOR XML AUTO"</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteXmlReader(connection, commandType, commandText, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection
/// using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// XmlReader r = ExecuteXmlReader(conn, "GetOrders", 24, 36);
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="spName">The name of the stored procedure using "FOR XML AUTO"</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public static XmlReader ExecuteXmlReader(SqlConnection connection, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteXmlReader(connection, spName, parameterValues);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction.
/// </summary>
/// <remarks>
/// e.g.:
/// XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command using "FOR XML AUTO"</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText)
{
return new SqlServer().ExecuteXmlReader(transaction, commandType, commandText);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command using "FOR XML AUTO"</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
{
return new SqlServer().ExecuteXmlReader(transaction, commandType, commandText, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified
/// SqlTransaction using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// XmlReader r = ExecuteXmlReader(trans, "GetOrders", 24, 36);
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static XmlReader ExecuteXmlReader(SqlTransaction transaction, string spName, params object[] parameterValues)
{
return new SqlServer().ExecuteXmlReader(transaction, spName, parameterValues);
}
#endregion ExecuteXmlReader
#region FillDataset
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the database specified in
/// the connection string.
/// </summary>
/// <remarks>
/// e.g.:
/// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
/// </remarks>
/// <param name="command">The SqlCommand to execute</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)</param>
public static void FillDataset(SqlCommand command, DataSet dataSet, string[] tableNames)
{
new SqlServer().FillDataset(command, dataSet, tableNames);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in
/// the connection string.
/// </summary>
/// <remarks>
/// e.g.:
/// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)</param>
public static void FillDataset(string connectionString, CommandType commandType, string commandText, DataSet dataSet, string[] tableNames)
{
new SqlServer().FillDataset(connectionString, commandType, commandText, dataSet, tableNames);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the database specified in the connection string
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
public static void FillDataset(string connectionString, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames,
params SqlParameter[] commandParameters)
{
new SqlServer().FillDataset(connectionString, commandType, commandText, dataSet, tableNames, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in
/// the connection string using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, 24);
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
public static void FillDataset(string connectionString, string spName,
DataSet dataSet, string[] tableNames, params object[] parameterValues)
{
new SqlServer().FillDataset(connectionString, spName, dataSet, tableNames, parameterValues);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection.
/// </summary>
/// <remarks>
/// e.g.:
/// FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
public static void FillDataset(SqlConnection connection, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames)
{
new SqlServer().FillDataset(connection, commandType, commandText, dataSet, tableNames);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the specified SqlConnection
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
public static void FillDataset(SqlConnection connection, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames, params SqlParameter[] commandParameters)
{
new SqlServer().FillDataset(connection, commandType, commandText, dataSet, tableNames, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection
/// using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// FillDataset(conn, "GetOrders", ds, new string[] {"orders"}, 24, 36);
/// </remarks>
/// <param name="connection">A valid SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
public static void FillDataset(SqlConnection connection, string spName,
DataSet dataSet, string[] tableNames, params object[] parameterValues)
{
new SqlServer().FillDataset(connection, spName, dataSet, tableNames, parameterValues);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction.
/// </summary>
/// <remarks>
/// e.g.:
/// FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
public static void FillDataset(SqlTransaction transaction, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames)
{
new SqlServer().FillDataset(transaction, commandType, commandText, dataSet, tableNames);
}
/// <summary>
/// Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <param name="commandParameters">An array of SqlParamters used to execute the command</param>
public static void FillDataset(SqlTransaction transaction, CommandType commandType,
string commandText, DataSet dataSet, string[] tableNames, params SqlParameter[] commandParameters)
{
new SqlServer().FillDataset(transaction, commandType, commandText, dataSet, tableNames, commandParameters);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified
/// SqlTransaction using the provided parameter values. This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <remarks>
/// This method provides no access to output parameters or the stored procedure's return value parameter.
///
/// e.g.:
/// FillDataset(trans, "GetOrders", ds, new string[]{"orders"}, 24, 36);
/// </remarks>
/// <param name="transaction">A valid SqlTransaction</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
/// <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
/// by a user defined name (probably the actual table name)
/// </param>
/// <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
public static void FillDataset(SqlTransaction transaction, string spName,
DataSet dataSet, string[] tableNames, params object[] parameterValues)
{
new SqlServer().FillDataset(transaction, spName, dataSet, tableNames, parameterValues);
}
#endregion
#region UpdateDataset
/// <summary>
/// Executes the respective command for each inserted, updated, or deleted row in the DataSet.
/// </summary>
/// <remarks>
/// e.g.:
/// UpdateDataset(conn, insertCommand, deleteCommand, updateCommand, dataSet, "Order");
/// </remarks>
/// <param name="insertCommand">A valid transact-SQL statement or stored procedure to insert new records into the data source</param>
/// <param name="deleteCommand">A valid transact-SQL statement or stored procedure to delete records from the data source</param>
/// <param name="updateCommand">A valid transact-SQL statement or stored procedure used to update records in the data source</param>
/// <param name="dataSet">The DataSet used to update the data source</param>
/// <param name="tableName">The DataTable used to update the data source.</param>
public static void UpdateDataset(SqlCommand insertCommand, SqlCommand deleteCommand, SqlCommand updateCommand, DataSet dataSet, string tableName)
{
new SqlServer().UpdateDataset(insertCommand, deleteCommand, updateCommand, dataSet, tableName);
}
/// <summary>
/// Executes the System.Data.SqlClient.SqlCommand for each inserted, updated, or deleted row in the DataSet also implementing RowUpdating and RowUpdated Event Handlers
/// </summary>
/// <remarks>
/// e.g.:
/// SqlRowUpdatingEventHandler rowUpdating = new SqlRowUpdatingEventHandler( OnRowUpdating );
/// SqlRowUpdatedEventHandler rowUpdated = new SqlRowUpdatedEventHandler( OnRowUpdated );
/// adoHelper.UpdateDataSet(sqlInsertCommand, sqlDeleteCommand, sqlUpdateCommand, dataSet, "Order", rowUpdating, rowUpdated);
/// </remarks>
/// <param name="insertCommand">A valid transact-SQL statement or stored procedure to insert new records into the data source</param>
/// <param name="deleteCommand">A valid transact-SQL statement or stored procedure to delete records from the data source</param>
/// <param name="updateCommand">A valid transact-SQL statement or stored procedure used to update records in the data source</param>
/// <param name="dataSet">The DataSet used to update the data source</param>
/// <param name="tableName">The DataTable used to update the data source.</param>
/// <param name="rowUpdating">The AdoHelper.RowUpdatingEventHandler or null</param>
/// <param name="rowUpdated">The AdoHelper.RowUpdatedEventHandler or null</param>
public static void UpdateDataset(IDbCommand insertCommand, IDbCommand deleteCommand, IDbCommand updateCommand,
DataSet dataSet, string tableName, AdoHelper.RowUpdatingHandler rowUpdating, AdoHelper.RowUpdatedHandler rowUpdated)
{
new SqlServer().UpdateDataset(insertCommand, deleteCommand, updateCommand, dataSet, tableName, rowUpdating, rowUpdated);
}
#endregion
#region CreateCommand
/// <summary>
/// Simplify the creation of a Sql command object by allowing
/// a stored procedure and optional parameters to be provided
/// </summary>
/// <remarks>
/// e.g.:
/// SqlCommand command = CreateCommand(connenctionString, "AddCustomer", "CustomerID", "CustomerName");
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="sourceColumns">An array of string to be assigned as the source columns of the stored procedure parameters</param>
/// <returns>A valid SqlCommand object</returns>
public static SqlCommand CreateCommand(string connectionString, string spName, params string[] sourceColumns)
{
return new SqlServer().CreateCommand(connectionString, spName, sourceColumns) as SqlCommand;
}
/// <summary>
/// Simplify the creation of a Sql command object by allowing
/// a stored procedure and optional parameters to be provided
/// </summary>
/// <remarks>
/// e.g.:
/// SqlCommand command = CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName");
/// </remarks>
/// <param name="connection">A valid SqlConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="sourceColumns">An array of string to be assigned as the source columns of the stored procedure parameters</param>
/// <returns>A valid SqlCommand object</returns>
public static SqlCommand CreateCommand(SqlConnection connection, string spName, params string[] sourceColumns)
{
return new SqlServer().CreateCommand(connection, spName, sourceColumns) as SqlCommand;
}
/// <summary>
/// Simplify the creation of a Sql command object by allowing
/// a stored procedure and optional parameters to be provided
/// </summary>
/// <remarks>
/// e.g.:
/// SqlCommand command = CreateCommand(connenctionString, "AddCustomer", "CustomerID", "CustomerName");
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandText">A valid SQL string to execute</param>
/// <param name="commandType">The CommandType to execute (i.e. StoredProcedure, Text)</param>
/// <param name="commandParameters">The SqlParameters to pass to the command</param>
/// <returns>A valid SqlCommand object</returns>
public static SqlCommand CreateCommand(string connectionString, string commandText, CommandType commandType, params SqlParameter[] commandParameters)
{
return new SqlServer().CreateCommand(connectionString, commandText, commandType, commandParameters) as SqlCommand;
}
/// <summary>
/// Simplify the creation of a Sql command object by allowing
/// a stored procedure and optional parameters to be provided
/// </summary>
/// <remarks>
/// e.g.:
/// SqlCommand command = CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName");
/// </remarks>
/// <param name="connection">A valid SqlConnection object</param>
/// <param name="commandText">A valid SQL string to execute</param>
/// <param name="commandType">The CommandType to execute (i.e. StoredProcedure, Text)</param>
/// <param name="commandParameters">The SqlParameters to pass to the command</param>
/// <returns>A valid SqlCommand object</returns>
public static SqlCommand CreateCommand(SqlConnection connection, string commandText, CommandType commandType, params SqlParameter[] commandParameters)
{
return new SqlServer().CreateCommand(connection, commandText, commandType, commandParameters) as SqlCommand;
}
#endregion
#region ExecuteNonQueryTypedParams
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns no resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will assign the parameter values based on row values.
/// </summary>
/// <param name="command">The SqlCommand to execute</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQueryTypedParams(SqlCommand command, DataRow dataRow)
{
return new SqlServer().ExecuteNonQueryTypedParams(command, dataRow);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns no resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on row values.
/// </summary>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQueryTypedParams(String connectionString, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteNonQueryTypedParams(connectionString, spName, dataRow);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified SqlConnection
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on row values.
/// </summary>
/// <param name="connection">A valid SqlConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQueryTypedParams(SqlConnection connection, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteNonQueryTypedParams(connection, spName, dataRow);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified
/// SqlTransaction using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on row values.
/// </summary>
/// <param name="transaction">A valid SqlTransaction object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An int representing the number of rows affected by the command</returns>
public static int ExecuteNonQueryTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteNonQueryTypedParams(transaction, spName, dataRow);
}
#endregion
#region ExecuteDatasetTypedParams
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will assign the parameter values based on row values.
/// </summary>
/// <param name="command">The SqlCommand to execute</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDatasetTypedParams(SqlCommand command, DataRow dataRow)
{
return new SqlServer().ExecuteDatasetTypedParams(command, dataRow);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on row values.
/// </summary>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDatasetTypedParams(string connectionString, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteDatasetTypedParams(connectionString, spName, dataRow);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection
/// using the dataRow column values as the store procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on row values.
/// </summary>
/// <param name="connection">A valid SqlConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDatasetTypedParams(SqlConnection connection, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteDatasetTypedParams(connection, spName, dataRow);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlTransaction
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on row values.
/// </summary>
/// <param name="transaction">A valid SqlTransaction object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDatasetTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteDatasetTypedParams(transaction, spName, dataRow);
}
#endregion
#region ExecuteReaderTypedParams
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will assign the parameter values based on parameter order.
/// </summary>
/// <param name="command">The SqlCommand toe execute</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReaderTypedParams(SqlCommand command, DataRow dataRow)
{
return new SqlServer().ExecuteReaderTypedParams(command, dataRow) as SqlDataReader;
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReaderTypedParams(String connectionString, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteReaderTypedParams(connectionString, spName, dataRow) as SqlDataReader;
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="connection">A valid SqlConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteReaderTypedParams(connection, spName, dataRow) as SqlDataReader;
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlTransaction
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="transaction">A valid SqlTransaction object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>A SqlDataReader containing the resultset generated by the command</returns>
public static SqlDataReader ExecuteReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteReaderTypedParams(transaction, spName, dataRow) as SqlDataReader;
}
#endregion
#region ExecuteScalarTypedParams
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will assign the parameter values based on parameter order.
/// </summary>
/// <param name="command">The SqlCommand to execute</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalarTypedParams(SqlCommand command, DataRow dataRow)
{
return new SqlServer().ExecuteScalarTypedParams(command, dataRow);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the database specified in
/// the connection string using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalarTypedParams(String connectionString, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteScalarTypedParams(connectionString, spName, dataRow);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="connection">A valid SqlConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalarTypedParams(SqlConnection connection, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteScalarTypedParams(connection, spName, dataRow);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified SqlTransaction
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="transaction">A valid SqlTransaction object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalarTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteScalarTypedParams(transaction, spName, dataRow);
}
#endregion
#region ExecuteXmlReaderTypedParams
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will assign the parameter values based on parameter order.
/// </summary>
/// <param name="command">The SqlCommand to execute</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public static XmlReader ExecuteXmlReaderTypedParams(SqlCommand command, DataRow dataRow)
{
return new SqlServer().ExecuteXmlReaderTypedParams(command, dataRow);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="connection">A valid SqlConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public static XmlReader ExecuteXmlReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteXmlReaderTypedParams(connection, spName, dataRow);
}
/// <summary>
/// Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlTransaction
/// using the dataRow column values as the stored procedure's parameters values.
/// This method will query the database to discover the parameters for the
/// stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
/// </summary>
/// <param name="transaction">A valid SqlTransaction object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public static XmlReader ExecuteXmlReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
{
return new SqlServer().ExecuteXmlReaderTypedParams(transaction, spName, dataRow);
}
#endregion
}
/// <summary>
/// SqlHelperParameterCache provides functions to leverage a static cache of procedure parameters, and the
/// ability to discover parameters for stored procedures at run-time.
/// </summary>
public sealed class SqlHelperParameterCache
{
#region private constructor
//Since this class provides only static methods, make the default constructor private to prevent
//instances from being created with "new SqlHelperParameterCache()"
private SqlHelperParameterCache()
{
}
#endregion constructor
#region caching functions
/// <summary>
/// Add parameter array to the cache
/// </summary>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <param name="commandParameters">An array of SqlParamters to be cached</param>
public static void CacheParameterSet(string connectionString, string commandText, params SqlParameter[] commandParameters)
{
new SqlServer().CacheParameterSet(connectionString, commandText, commandParameters);
}
/// <summary>
/// Retrieve a parameter array from the cache
/// </summary>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="commandText">The stored procedure name or T-SQL command</param>
/// <returns>An array of SqlParamters</returns>
public static SqlParameter[] GetCachedParameterSet(string connectionString, string commandText)
{
ArrayList tempValue = new ArrayList();
IDataParameter[] sqlP = new SqlServer().GetCachedParameterSet(connectionString, commandText);
foreach (IDataParameter parameter in sqlP)
{
tempValue.Add(parameter);
}
return (SqlParameter[]) tempValue.ToArray(typeof (SqlParameter));
}
#endregion caching functions
#region Parameter Discovery Functions
/// <summary>
/// Retrieves the set of SqlParameters appropriate for the stored procedure
/// </summary>
/// <remarks>
/// This method will query the database for this information, and then store it in a cache for future requests.
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <returns>An array of SqlParameters</returns>
public static SqlParameter[] GetSpParameterSet(string connectionString, string spName)
{
ArrayList tempValue = new ArrayList();
foreach (IDataParameter parameter in new SqlServer().GetSpParameterSet(connectionString, spName))
{
tempValue.Add(parameter);
}
return (SqlParameter[]) tempValue.ToArray(typeof (SqlParameter));
}
/// <summary>
/// Retrieves the set of SqlParameters appropriate for the stored procedure
/// </summary>
/// <remarks>
/// This method will query the database for this information, and then store it in a cache for future requests.
/// </remarks>
/// <param name="connectionString">A valid connection string for a SqlConnection</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="includeReturnValueParameter">A bool value indicating whether the return value parameter should be included in the results</param>
/// <returns>An array of SqlParameters</returns>
public static SqlParameter[] GetSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter)
{
ArrayList tempValue = new ArrayList();
foreach (IDataParameter parameter in new SqlServer().GetSpParameterSet(connectionString, spName, includeReturnValueParameter))
{
tempValue.Add(parameter);
}
return (SqlParameter[]) tempValue.ToArray(typeof (SqlParameter));
}
/// <summary>
/// Retrieves the set of SqlParameters appropriate for the stored procedure
/// </summary>
/// <remarks>
/// This method will query the database for this information, and then store it in a cache for future requests.
/// </remarks>
/// <param name="connection">A valid SqlConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <returns>An array of SqlParameters</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public static SqlParameter[] GetSpParameterSet(IDbConnection connection, string spName)
{
return GetSpParameterSet(connection, spName, false);
}
/// <summary>
/// Retrieves the set of SqlParameters appropriate for the stored procedure
/// </summary>
/// <remarks>
/// This method will query the database for this information, and then store it in a cache for future requests.
/// </remarks>
/// <param name="connection">A valid SqlConnection object</param>
/// <param name="spName">The name of the stored procedure</param>
/// <param name="includeReturnValueParameter">A bool value indicating whether the return value parameter should be included in the results</param>
/// <returns>An array of SqlParameters</returns>
/// <exception cref="System.ArgumentNullException">Thrown if spName is null</exception>
/// <exception cref="System.ArgumentNullException">Thrown if connection is null</exception>
public static SqlParameter[] GetSpParameterSet(IDbConnection connection, string spName, bool includeReturnValueParameter)
{
ArrayList tempValue = new ArrayList();
foreach (IDataParameter parameter in new SqlServer().GetSpParameterSet(connection, spName, includeReturnValueParameter))
{
tempValue.Add(parameter);
}
return (SqlParameter[]) tempValue.ToArray(typeof (SqlParameter));
}
#endregion Parameter Discovery Functions
}
/// <summary>
/// The Odbc class is intended to encapsulate high performance, scalable best practices for
/// common uses of the Odbc ADO.NET provider. It is created using the abstract factory in AdoHelper
/// </summary>
public class Odbc : AdoHelper
{
// used for correcting Call syntax for stored procedures in ODBC
private static Regex _regExpr = new Regex(@"\{.*call|CALL\s\w+.*}", RegexOptions.Compiled);
/// <summary>
/// Create an Odbc Helper. Needs to be a default constructor so that the Factory can create it
/// </summary>
public Odbc()
{
}
#region Overrides
/// <summary>
/// Returns an array of OdbcParameters of the specified size
/// </summary>
/// <param name="size">size of the array</param>
/// <returns>The array of OdbcParameters</returns>
protected override IDataParameter[] GetDataParameters(int size)
{
return new OdbcParameter[size];
}
/// <summary>
/// Returns an OdbcConnection object for the given connection string
/// </summary>
/// <param name="connectionString">The connection string to be used to create the connection</param>
/// <returns>An OdbcConnection object</returns>
public override IDbConnection GetConnection(string connectionString)
{
return new OdbcConnection(connectionString);
}
/// <summary>
/// Returns an OdbcDataAdapter object
/// </summary>
/// <returns>The OdbcDataAdapter</returns>
public override IDbDataAdapter GetDataAdapter()
{
return new OdbcDataAdapter();
}
/// <summary>
/// Calls the CommandBuilder.DeriveParameters method for the specified provider, doing any setup and cleanup necessary
/// </summary>
/// <param name="cmd">The IDbCommand referencing the stored procedure from which the parameter information is to be derived. The derived parameters are added to the Parameters collection of the IDbCommand. </param>
public override void DeriveParameters(IDbCommand cmd)
{
bool mustCloseConnection = false;
if (!(cmd is OdbcCommand))
throw new ArgumentException("The command provided is not a OdbcCommand instance.", "cmd");
if (cmd.Connection.State != ConnectionState.Open)
{
cmd.Connection.Open();
mustCloseConnection = true;
}
OdbcCommandBuilder.DeriveParameters((OdbcCommand) cmd);
if (mustCloseConnection)
{
cmd.Connection.Close();
}
}
/// <summary>
/// Returns an OdbcParameter object
/// </summary>
/// <returns>The OdbcParameter object</returns>
public override IDataParameter GetParameter()
{
return new OdbcParameter();
}
/// <summary>
/// This cleans up the parameter syntax for an ODBC call. This was split out from PrepareCommand so that it could be called independently.
/// </summary>
/// <param name="command">An IDbCommand object containing the CommandText to clean.</param>
public override void CleanParameterSyntax(IDbCommand command)
{
string call = " call ";
if (command.CommandType == CommandType.StoredProcedure)
{
if (!_regExpr.Match(command.CommandText).Success && // It does not like like {call sp_name() }
command.CommandText.Trim().IndexOf(" ") == -1) // If there's only a stored procedure name
{
// If there's only a stored procedure name
StringBuilder par = new StringBuilder();
if (command.Parameters.Count != 0)
{
bool isFirst = true;
bool hasParameters = false;
for (int i = 0; i < command.Parameters.Count; i++)
{
OdbcParameter p = command.Parameters[i] as OdbcParameter;
if (p.Direction != ParameterDirection.ReturnValue)
{
if (isFirst)
{
isFirst = false;
par.Append("(?");
}
else
{
par.Append(",?");
}
hasParameters = true;
}
else
{
call = " ? = call ";
}
}
if (hasParameters)
{
par.Append(")");
}
}
command.CommandText = "{" + call + command.CommandText + par.ToString() + " }";
}
}
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the provided IDbConnection.
/// </summary>
/// <example>
/// <code>
/// XmlReader r = helper.ExecuteXmlReader(command);
/// </code></example>
/// <param name="command">The IDbCommand to execute</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public override XmlReader ExecuteXmlReader(IDbCommand command)
{
bool mustCloseConnection = false;
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
mustCloseConnection = true;
}
CleanParameterSyntax(command);
OdbcDataAdapter da = new OdbcDataAdapter((OdbcCommand) command);
DataSet ds = new DataSet();
da.MissingSchemaAction = MissingSchemaAction.AddWithKey;
da.Fill(ds);
StringReader stream = new StringReader(ds.GetXml());
if (mustCloseConnection)
{
command.Connection.Close();
}
return new XmlTextReader(stream);
}
/// <summary>
/// Provider specific code to set up the updating/ed event handlers used by UpdateDataset
/// </summary>
/// <param name="dataAdapter">DataAdapter to attach the event handlers to</param>
/// <param name="rowUpdatingHandler">The handler to be called when a row is updating</param>
/// <param name="rowUpdatedHandler">The handler to be called when a row is updated</param>
protected override void AddUpdateEventHandlers(IDbDataAdapter dataAdapter, RowUpdatingHandler rowUpdatingHandler, RowUpdatedHandler rowUpdatedHandler)
{
if (rowUpdatingHandler != null)
{
this.m_rowUpdating = rowUpdatingHandler;
((OdbcDataAdapter) dataAdapter).RowUpdating += new OdbcRowUpdatingEventHandler(RowUpdating);
}
if (rowUpdatedHandler != null)
{
this.m_rowUpdated = rowUpdatedHandler;
((OdbcDataAdapter) dataAdapter).RowUpdated += new OdbcRowUpdatedEventHandler(RowUpdated);
}
}
/// <summary>
/// Handles the RowUpdating event
/// </summary>
/// <param name="obj">The object that published the event</param>
/// <param name="e">The OdbcRowUpdatingEventArgs</param>
protected void RowUpdating(object obj, OdbcRowUpdatingEventArgs e)
{
base.RowUpdating(obj, e);
}
/// <summary>
/// Handles the RowUpdated event
/// </summary>
/// <param name="obj">The object that published the event</param>
/// <param name="e">The OdbcRowUpdatedEventArgs</param>
protected void RowUpdated(object obj, OdbcRowUpdatedEventArgs e)
{
base.RowUpdated(obj, e);
}
/// <summary>
/// Handle any provider-specific issues with BLOBs here by "washing" the IDataParameter and returning a new one that is set up appropriately for the provider.
/// </summary>
/// <param name="connection">The IDbConnection to use in cleansing the parameter</param>
/// <param name="p">The parameter before cleansing</param>
/// <returns>The parameter after it's been cleansed.</returns>
protected override IDataParameter GetBlobParameter(IDbConnection connection, IDataParameter p)
{
// nothing special needed for ODBC...so far as we know now.
return p;
}
#endregion
}
/// <summary>
/// The OleDb class is intended to encapsulate high performance, scalable best practices for
/// common uses of the OleDb ADO.NET provider. It is created using the abstract factory in AdoHelper
/// </summary>
public class OleDb : AdoHelper
{
/// <summary>
/// Create an OleDb Helper. Needs to be a default constructor so that the Factory can create it
/// </summary>
public OleDb()
{
}
#region Overrides
/// <summary>
/// Returns an array of OleDbParameters of the specified size
/// </summary>
/// <param name="size">size of the array</param>
/// <returns>The array of OdbcParameters</returns>
protected override IDataParameter[] GetDataParameters(int size)
{
return new OleDbParameter[size];
}
/// <summary>
/// Returns an OleDbConnection object for the given connection string
/// </summary>
/// <param name="connectionString">The connection string to be used to create the connection</param>
/// <returns>An OleDbConnection object</returns>
public override IDbConnection GetConnection(string connectionString)
{
return new OleDbConnection(connectionString);
}
/// <summary>
/// Returns an OleDbDataAdapter object
/// </summary>
/// <returns>The OleDbDataAdapter</returns>
public override IDbDataAdapter GetDataAdapter()
{
return new OleDbDataAdapter();
}
/// <summary>
/// Calls the CommandBuilder.DeriveParameters method for the specified provider, doing any setup and cleanup necessary
/// </summary>
/// <param name="cmd">The IDbCommand referencing the stored procedure from which the parameter information is to be derived. The derived parameters are added to the Parameters collection of the IDbCommand. </param>
public override void DeriveParameters(IDbCommand cmd)
{
bool mustCloseConnection = false;
if (!(cmd is OleDbCommand))
throw new ArgumentException("The command provided is not a OleDbCommand instance.", "cmd");
if (cmd.Connection.State != ConnectionState.Open)
{
cmd.Connection.Open();
mustCloseConnection = true;
}
OleDbCommandBuilder.DeriveParameters((OleDbCommand) cmd);
if (mustCloseConnection)
{
cmd.Connection.Close();
}
}
/// <summary>
/// Returns an OleDbParameter object
/// </summary>
/// <returns>The OleDbParameter object</returns>
public override IDataParameter GetParameter()
{
return new OleDbParameter();
}
/// <summary>
/// This cleans up the parameter syntax for an OleDb call. This was split out from PrepareCommand so that it could be called independently.
/// </summary>
/// <param name="command">An IDbCommand object containing the CommandText to clean.</param>
public override void CleanParameterSyntax(IDbCommand command)
{
}
/// <summary>
/// Execute an IDbCommand (that returns a resultset) against the provided IDbConnection.
/// </summary>
/// <example>
/// <code>
/// XmlReader r = helper.ExecuteXmlReader(command);
/// </code></example>
/// <param name="command">The IDbCommand to execute</param>
/// <returns>An XmlReader containing the resultset generated by the command</returns>
public override XmlReader ExecuteXmlReader(IDbCommand command)
{
bool mustCloseConnection = false;
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
mustCloseConnection = true;
}
CleanParameterSyntax(command);
OleDbDataAdapter da = new OleDbDataAdapter((OleDbCommand) command);
DataSet ds = new DataSet();
da.MissingSchemaAction = MissingSchemaAction.AddWithKey;
da.Fill(ds);
StringReader stream = new StringReader(ds.GetXml());
if (mustCloseConnection)
{
command.Connection.Close();
}
return new XmlTextReader(stream);
}
/// <summary>
/// Provider specific code to set up the updating/ed event handlers used by UpdateDataset
/// </summary>
/// <param name="dataAdapter">DataAdapter to attach the event handlers to</param>
/// <param name="rowUpdatingHandler">The handler to be called when a row is updating</param>
/// <param name="rowUpdatedHandler">The handler to be called when a row is updated</param>
protected override void AddUpdateEventHandlers(IDbDataAdapter dataAdapter, RowUpdatingHandler rowUpdatingHandler, RowUpdatedHandler rowUpdatedHandler)
{
if (rowUpdatingHandler != null)
{
this.m_rowUpdating = rowUpdatingHandler;
((OleDbDataAdapter) dataAdapter).RowUpdating += new OleDbRowUpdatingEventHandler(RowUpdating);
}
if (rowUpdatedHandler != null)
{
this.m_rowUpdated = rowUpdatedHandler;
((OleDbDataAdapter) dataAdapter).RowUpdated += new OleDbRowUpdatedEventHandler(RowUpdated);
}
}
/// <summary>
/// Handles the RowUpdating event
/// </summary>
/// <param name="obj">The object that published the event</param>
/// <param name="e">The OleDbRowUpdatingEventArgs</param>
protected void RowUpdating(object obj, OleDbRowUpdatingEventArgs e)
{
base.RowUpdating(obj, e);
}
/// <summary>
/// Handles the RowUpdated event
/// </summary>
/// <param name="obj">The object that published the event</param>
/// <param name="e">The OleDbRowUpdatedEventArgs</param>
protected void RowUpdated(object obj, OleDbRowUpdatedEventArgs e)
{
base.RowUpdated(obj, e);
}
/// <summary>
/// Handle any provider-specific issues with BLOBs here by "washing" the IDataParameter and returning a new one that is set up appropriately for the provider.
/// </summary>
/// <param name="connection">The IDbConnection to use in cleansing the parameter</param>
/// <param name="p">The parameter before cleansing</param>
/// <returns>The parameter after it's been cleansed.</returns>
protected override IDataParameter GetBlobParameter(IDbConnection connection, IDataParameter p)
{
// nothing special needed for OleDb...as far as we know now
return p;
}
#endregion
}
/// <summary>
/// The Oracle class is intended to encapsulate high performance, scalable best practices for
/// common uses of the Oracle ADO.NET provider. It is created using the abstract factory in AdoHelper.
/// </summary>
public class Oracle : AdoHelper
{
/// <summary>
/// Create an Oracle Helper. Needs to be a default constructor so that the Factory can create it
/// </summary>
public Oracle()
{
}
#region Overrides
/// <summary>
/// Returns an array of OracleParameters of the specified size
/// </summary>
/// <param name="size">size of the array</param>
/// <returns>The array of OracleParameters</returns>
protected override IDataParameter[] GetDataParameters(int size)
{
return new OracleParameter[size];
}
/// <summary>
/// Returns an OracleConnection object for the given connection string
/// </summary>
/// <param name="connectionString">The connection string to be used to create the connection</param>
/// <returns>An OracleConnection object</returns>
public override IDbConnection GetConnection(string connectionString)
{
return new OracleConnection(connectionString);
}
/// <summary>
/// Returns an OracleDataAdapter object
/// </summary>
/// <returns>The OracleDataAdapter</returns>
public override IDbDataAdapter GetDataAdapter()
{
return new OracleDataAdapter();
}
/// <summary>
/// Calls the CommandBuilder.DeriveParameters method for the specified provider, doing any setup and cleanup necessary
/// </summary>
/// <param name="cmd">The IDbCommand referencing the stored procedure from which the parameter information is to be derived. The derived parameters are added to the Parameters collection of the IDbCommand. </param>
public override void DeriveParameters(IDbCommand cmd)
{
bool mustCloseConnection = false;
if (!(cmd is OracleCommand))
throw new ArgumentException("The command provided is not an OracleCommand instance.", "cmd");
if (cmd.Connection.State != ConnectionState.Open)
{
cmd.Connection.Open();
mustCloseConnection = true;
}
OracleCommandBuilder.DeriveParameters((OracleCommand) cmd);
if (mustCloseConnection)
{
cmd.Connection.Close();
}
}
/// <summary>
/// Returns an OracleParameter object
/// </summary>
/// <returns>The OracleParameter object</returns>
public override IDataParameter GetParameter()
{
OracleParameter parameter = new OracleParameter();
parameter.Size = 255;
return parameter;
}
/// <summary>
/// Get an IDataParameter for use in a SQL command
/// </summary>
/// <param name="parameterName">The name of the parameter to create</param>
/// <param name="value">The value of the specified parameter</param>
/// <returns>An IDataParameter object</returns>
public override IDataParameter GetParameter(string parameterName, object value)
{
OracleParameter parameter = new OracleParameter();
parameter.ParameterName = parameterName;
parameter.Value = value;
parameter.Size
