using System;

using System.Data;

using System.Xml;

namespace SiteServer.Plugin

{

public interface IDbHelper

{

#region Provider specific 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>

IDbConnection GetConnection(string connectionString);

/// <summary>

/// Returns an IDbDataAdapter object

/// </summary>

/// <returns>The IDbDataAdapter</returns>

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>

void DeriveParameters(IDbCommand cmd);

/// <summary>

/// Returns an IDataParameter object

/// </summary>

/// <returns>The IDataParameter object</returns>

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>

XmlReader ExecuteXmlReader(IDbCommand cmd);

#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>

IDataParameter GetParameter(string name, object value);

/// <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>

IDataParameter GetParameter(string name, DbType dbType, int size, ParameterDirection direction);

/// <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>

IDataParameter GetParameter(string name, DbType dbType, int size, string sourceColumn, DataRowVersion sourceVersion);

#endregion

#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>

DataSet ExecuteDataset(IDbCommand command);

/// <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>

DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText);

/// <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>

DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params IDataParameter[] 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>

DataSet ExecuteDataset(string connectionString, string spName, params object[] parameterValues);

/// <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>

DataSet ExecuteDataset(IDbConnection connection, CommandType commandType, string commandText);

/// <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>

DataSet ExecuteDataset(IDbConnection connection, CommandType commandType, string commandText, params IDataParameter[] 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>

/// 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>

DataSet ExecuteDataset(IDbConnection connection, string spName, params object[] parameterValues);

/// <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>

DataSet ExecuteDataset(IDbTransaction transaction, CommandType commandType, string commandText);

/// <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>

DataSet ExecuteDataset(IDbTransaction transaction, CommandType commandType, string commandText, params IDataParameter[] 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>

/// 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>

DataSet ExecuteDataset(IDbTransaction transaction, string spName, params object[] parameterValues);

#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>

int ExecuteNonQuery(IDbCommand command);

/// <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>

int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText);

/// <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>

int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params IDataParameter[] 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>

int ExecuteNonQuery(string connectionString, string spName, params object[] parameterValues);

/// <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>

int ExecuteNonQuery(IDbConnection connection, CommandType commandType, string commandText);

/// <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>

int ExecuteNonQuery(IDbConnection connection, CommandType commandType, string commandText, params IDataParameter[] commandParameters);

/// <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>

int ExecuteNonQuery(IDbConnection connection, string spName, params object[] parameterValues);

/// <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>

int ExecuteNonQuery(IDbTransaction transaction, CommandType commandType, string commandText);

/// <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>

int ExecuteNonQuery(IDbTransaction transaction, CommandType commandType, string commandText, params IDataParameter[] commandParameters);

/// <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>

int ExecuteNonQuery(IDbTransaction transaction, string spName, params object[] parameterValues);

#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>

IDataReader ExecuteReader(IDbCommand command);

/// <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>

IDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText);

/// <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>

IDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params IDataParameter[] 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>

/// 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>

IDataReader ExecuteReader(string connectionString, string spName, params object[] parameterValues);

/// <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>

IDataReader ExecuteReader(IDbConnection connection, CommandType commandType, string commandText);

/// <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>

IDataReader ExecuteReader(IDbConnection connection, CommandType commandType, string commandText, params IDataParameter[] 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>

/// 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>

IDataReader ExecuteReader(IDbConnection connection, string spName, params object[] parameterValues);

/// <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>

IDataReader ExecuteReader(IDbTransaction transaction, CommandType commandType, string commandText);

/// <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>

IDataReader ExecuteReader(IDbTransaction transaction, CommandType commandType, string commandText, params IDataParameter[] 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>

/// 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>

IDataReader ExecuteReader(IDbTransaction transaction, string spName, params object[] parameterValues);

#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>

object ExecuteScalar(IDbCommand command);

/// <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>

object ExecuteScalar(string connectionString, CommandType commandType, string commandText);

/// <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>

object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params IDataParameter[] commandParameters);

/// <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>

object ExecuteScalar(string connectionString, string spName, params object[] parameterValues);

/// <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>

object ExecuteScalar(IDbConnection connection, CommandType commandType, string commandText);

/// <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>

object ExecuteScalar(IDbConnection connection, CommandType commandType, string commandText, params IDataParameter[] commandParameters);

/// <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>

object ExecuteScalar(IDbConnection connection, string spName, params object[] parameterValues);

/// <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>

object ExecuteScalar(IDbTransaction transaction, CommandType commandType, string commandText);

/// <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>

object ExecuteScalar(IDbTransaction transaction, CommandType commandType, string commandText, params IDataParameter[] commandParameters);

/// <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>

object ExecuteScalar(IDbTransaction transaction, string spName, params object[] parameterValues);

#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>

XmlReader ExecuteXmlReader(IDbConnection connection, CommandType commandType, string commandText);

/// <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>

XmlReader ExecuteXmlReader(IDbConnection connection, CommandType commandType, string commandText, params IDataParameter[] 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>

/// 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>

XmlReader ExecuteXmlReader(IDbConnection connection, string spName, params object[] parameterValues);

/// <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>

XmlReader ExecuteXmlReader(IDbTransaction transaction, CommandType commandType, string commandText);

/// <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>

XmlReader ExecuteXmlReader(IDbTransaction transaction, CommandType commandType, string commandText, params IDataParameter[] 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>

/// 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>

XmlReader ExecuteXmlReader(IDbTransaction transaction, string spName, params object[] parameterValues);

#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>

XmlReader ExecuteXmlReaderTypedParams(IDbCommand command, DataRow dataRow);

/// <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>

XmlReader ExecuteXmlReaderTypedParams(IDbConnection connection, String spName, DataRow dataRow);

/// <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>

XmlReader ExecuteXmlReaderTypedParams(IDbTransaction transaction, String spName, DataRow dataRow);

#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>

void FillDataset(IDbCommand command, DataSet dataSet, string[] tableNames);

/// <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>

void FillDataset(string connectionString, CommandType commandType, string commandText, DataSet dataSet, string[] tableNames);

/// <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>

void FillDataset(string connectionString, CommandType commandType,

string commandText, DataSet dataSet, string[] tableNames,

params IDataParameter[] 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>

/// 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>

void FillDataset(string connectionString, string spName,

DataSet dataSet, string[] tableNames,

params object[] parameterValues);

/// <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>

void FillDataset(IDbConnection connection, CommandType commandType,

string commandText, DataSet dataSet, string[] tableNames);

/// <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