Oracle操作数据库oracleHelper

1 Oracle OracleHelper

//===============================================================================
// OracleHelper based on Microsoft Data Access Application Block (DAAB) for .NET
// http://msdn.microsoft.com/library/en-us/dnbda/html/daab-rm.asp //
// OracleHelper.cs
//
// This file contains the implementations of the OracleHelper and OracleHelperParameterCache
// classes.
//
// The DAAB for MS .NET Provider for Oracle has been tested in the context of this Nile implementation,
// but has not undergone the generic functional testing that the SQL version has gone through.
// You can use it in other .NET applications using Oracle databases.  For complete docs explaining how to use
// and how it's built go to the originl appblock link.
// For this sample, the code resides in the Nile namespaces not the Microsoft.ApplicationBlocks namespace
//==============================================================================

using System.Globalization;
using Oracle.DataAccess.Client;
using System;
using System.Collections;
using System.Data;

namespace Oracle.Access
{
/// <summary>
/// The OracleHelper class is intended to encapsulate high performance, scalable best practices for
/// common uses of OracleClient.
/// </summary>
public sealed class OracleHelper
{
#region private utility methods & constructors

//Since this class provides only static methods, make the default constructor private to prevent
//instances from being created with "new OracleHelper()".
private OracleHelper()
{
}

/// <summary>
/// This method is used to attach array's of OracleParameters to an OracleCommand.
///
/// 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 OracleParameters tho be added to command</param>
private static void AttachParameters(OracleCommand command, OracleParameter[] commandParameters)
{
foreach (OracleParameter p in commandParameters)
{
//check for derived output value with no value assigned
if ((p.Direction == ParameterDirection.InputOutput) && (p.Value == null))
{
p.Value = DBNull.Value;
}

command.Parameters.Add(p);
}
}

/// <summary>
/// This method assigns an array of values to an array of OracleParameters.
/// </summary>
/// <param name="commandParameters">array of OracleParameters to be assigned values</param>
/// <param name="parameterValues">array of objects holding the values to be assigned</param>
private static void AssignParameterValues(OracleParameter[] 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 OracleParameters, assigning the values from the corresponding position in the
//value array
for (int i = 0, j = commandParameters.Length; i < j; i++)
{
commandParameters[i].Value = parameterValues[i];
}
}

/// <summary>
/// This method opens (if necessary) and assigns a connection, transaction, command type and parameters
/// to the provided command.
/// </summary>
/// <param name="command">the OracleCommand to be prepared</param>
/// <param name="connection">a valid OracleConnection, on which to execute this command</param>
/// <param name="transaction">a valid OracleTransaction, or 'null'</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <param name="commandParameters">an array of OracleParameters to be associated with the command or 'null' if no parameters are required</param>
private static void PrepareCommand(OracleCommand command, OracleConnection connection, OracleTransaction transaction, CommandType commandType, string commandText, OracleParameter[] commandParameters)
{
//if the provided connection is not open, we will open it
if (connection.State != ConnectionState.Open)
{
connection.Open();
}

//associate the connection with the command
command.Connection = connection;

//set the command text (stored procedure name or Oracle statement)
command.CommandText = commandText;

//if we were provided a transaction, assign it.
if (transaction != null)
{
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>初始化OracleCommand 对象</summary>
/// <param name="conn">Connection 对象</param>
/// <param name="cmdType">CommandType 值之一。</param>
/// <param name="cmdText">已重写。 获取或设置要对数据源执行的 Transact-SQL 语句或存储过程。</param>
/// <param name="commandParameters">参数</param>
private static OracleCommand PrepareCommand(OracleConnection conn, CommandType cmdType, string cmdText, OracleParameter[] commandParameters)
{
//Open the connection if required
if (conn.State != ConnectionState.Open)
conn.Open();
OracleCommand cmd = new OracleCommand(cmdText, conn);
//Set up the command
cmd.CommandType = cmdType;
//Bind it to the transaction if it exists
//if (trans != null)
//    cmd.Transaction = trans;
// Bind the parameters passed in
if (commandParameters != null && commandParameters.Length > 0)
{
foreach (OracleParameter parm in commandParameters)
cmd.Parameters.Add(parm);
}
return cmd;
}
/// <summary>初始化SqlCommand 对象</summary>
/// <param name="trans">Optional transaction object</param>
/// <param name="cmdType">CommandType 值之一。</param>
/// <param name="cmdText">已重写。 获取或设置要对数据源执行的 Transact-SQL 语句或存储过程。 </param>
/// <param name="commandParameters">参数</param>
private static OracleCommand PrepareCommand(OracleTransaction trans, CommandType cmdType, string cmdText, OracleParameter[] commandParameters)
{
if (trans == null)
throw new ArgumentNullException("transaction");
if (trans != null && trans.Connection == null)
throw new ArgumentException("The transaction was rollbacked     or commited, please     provide an open transaction.", "transaction");
//Open the connection if required
if (trans.Connection.State != ConnectionState.Open)
trans.Connection.Open();
OracleCommand cmd = new OracleCommand(cmdText, trans.Connection);
//Set up the command
cmd.CommandType = cmdType;
//Bind it to the transaction if it exists
//if (trans != null)
//    cmd.Transaction = trans;
// Bind the parameters passed in
if (commandParameters != null)
{
foreach (OracleParameter parm in commandParameters)
cmd.Parameters.Add(parm);
}
return cmd;
}
*/

#endregion private utility methods & constructors

#region ExecuteNonQuery

/// <summary>
/// Execute an OracleCommand (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 an OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/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)
{
//pass through the call providing null for the set of OracleParameters
return ExecuteNonQuery(connectionString, commandType, commandText, (OracleParameter[])null);
}

/// <summary>
/// Execute an OracleCommand (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 OracleParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">a valid connection string for an OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <param name="commandParameters">an array of OracleParameters 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 OracleParameter[] commandParameters)
{
//create & open an OracleConnection, and dispose of it after we are done.
using (OracleConnection cn = new OracleConnection(connectionString))
{
cn.Open();

//call the overload that takes a connection in place of the connection string
return ExecuteNonQuery(cn, commandType, commandText, commandParameters);
}
}

/// <summary>
/// Execute a stored procedure via an OracleCommand (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 an OracleConnection</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(string connectionString, string spName, params object[] parameterValues)
{
//if we got 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)
OracleParameter[] commandParameters = OracleHelperParameterCache.GetSpParameterSet(connectionString, spName);

//assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);

//call the overload that takes an array of OracleParameters
return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
//otherwise we can just call the SP without params
else
{
return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
}
}

/// <summary>
/// Execute an OracleCommand (that returns no resultset and takes no parameters) against the provided OracleConnection.
/// </summary>
/// <remarks>
/// e.g.:
///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders");
/// </remarks>
/// <param name="connection">a valid OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <returns>an int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(OracleConnection connection, CommandType commandType, string commandText)
{
//pass through the call providing null for the set of OracleParameters
return ExecuteNonQuery(connection, commandType, commandText, (OracleParameter[])null);
}

/// <summary>
/// Execute an OracleCommand (that returns no resultset) against the specified OracleConnection
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new OracleParameter("@prodid", 24));
/// </remarks>
/// <param name="connection">a valid OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <param name="commandParameters">an array of OracleParameters used to execute the command</param>
/// <returns>an int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(OracleConnection connection, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
{
//create a command and prepare it for execution
OracleCommand cmd = new OracleCommand();
PrepareCommand(cmd, connection, (OracleTransaction)null, commandType, commandText, commandParameters);

//finally, execute the command.
return cmd.ExecuteNonQuery();
}

/// <summary>
/// Execute a stored procedure via an OracleCommand (that returns no resultset) against the specified OracleConnection
/// 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 OracleConnection</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(OracleConnection connection, string spName, params object[] parameterValues)
{
//if we got 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)
OracleParameter[] commandParameters = OracleHelperParameterCache.GetSpParameterSet(connection.ConnectionString, spName);

//assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);

//call the overload that takes an array of OracleParameters
return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
}
//otherwise we can just call the SP without params
else
{
return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
}
}

/// <summary>
/// Execute an OracleCommand (that returns no resultset and takes no parameters) against the provided OracleTransaction.
/// </summary>
/// <remarks>
/// e.g.:
///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders");
/// </remarks>
/// <param name="transaction">a valid OracleTransaction</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <returns>an int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(OracleTransaction transaction, CommandType commandType, string commandText)
{
//pass through the call providing null for the set of OracleParameters
return ExecuteNonQuery(transaction, commandType, commandText, (OracleParameter[])null);
}

/// <summary>
/// Execute an OracleCommand (that returns no resultset) against the specified OracleTransaction
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new OracleParameter("@prodid", 24));
/// </remarks>
/// <param name="transaction">a valid OracleTransaction</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <param name="commandParameters">an array of OracleParameters used to execute the command</param>
/// <returns>an int representing the number of rows affected by the command</returns>
public static int ExecuteNonQuery(OracleTransaction transaction, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
{
//create a command and prepare it for execution
OracleCommand cmd = new OracleCommand();
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);

//finally, execute the command.
return cmd.ExecuteNonQuery();
}

/// <summary>
/// Execute a stored procedure via an OracleCommand (that returns no resultset) against the specified
/// OracleTransaction 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 OracleTransaction</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(OracleTransaction transaction, string spName, params object[] parameterValues)
{
//if we got 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 & populet the cache)
OracleParameter[] commandParameters = OracleHelperParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName);

//assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);

//call the overload that takes an array of OracleParameters
return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
//otherwise we can just call the SP without params
else
{
return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
}
}

#endregion ExecuteNonQuery

#region ExecuteDataSet

/// <summary>
/// Execute an OracleCommand (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 an OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <returns>a dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText)
{
//pass through the call providing null for the set of OracleParameters
return ExecuteDataset(connectionString, commandType, commandText, (OracleParameter[])null);
}

/// <summary>
/// Execute an OracleCommand (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 OracleParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">a valid connection string for an OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <param name="commandParameters">an array of OracleParameters 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 OracleParameter[] commandParameters)
{
//create & open an OracleConnection, and dispose of it after we are done.
using (OracleConnection cn = new OracleConnection(connectionString))
{
cn.Open();

//call the overload that takes a connection in place of the connection string
return ExecuteDataset(cn, commandType, commandText, commandParameters);
}
}

/// <summary>
/// Execute a stored procedure via an OracleCommand (that returns a resultset) against the database specified in
/// the conneciton 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 an OracleConnection</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)
{
//if we got 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 & populet the cache)
OracleParameter[] commandParameters = OracleHelperParameterCache.GetSpParameterSet(connectionString, spName);

//assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);

//call the overload that takes an array of OracleParameters
return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
//otherwise we can just call the SP without params
else
{
return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
}
}

/// <summary>
/// Execute an OracleCommand (that returns a resultset and takes no parameters) against the provided OracleConnection.
/// </summary>
/// <remarks>
/// e.g.:
///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="connection">a valid OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <returns>a dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(OracleConnection connection, CommandType commandType, string commandText)
{
//pass through the call providing null for the set of OracleParameters
return ExecuteDataset(connection, commandType, commandText, (OracleParameter[])null);
}

/// <summary>
/// Execute an OracleCommand (that returns a resultset) against the specified OracleConnection
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new OracleParameter("@prodid", 24));
/// </remarks>
/// <param name="connection">a valid OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <param name="commandParameters">an array of OracleParameters used to execute the command</param>
/// <returns>a dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(OracleConnection connection, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
{
//create a command and prepare it for execution
OracleCommand cmd = new OracleCommand();
PrepareCommand(cmd, connection, (OracleTransaction)null, commandType, commandText, commandParameters);

//create the DataAdapter & DataSet
OracleDataAdapter da = new OracleDataAdapter(cmd);
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
//fill the DataSet using default values for DataTable names, etc.
da.Fill(ds);

//return the dataset
return ds;
}

/// <summary>
/// Execute a stored procedure via an OracleCommand (that returns a resultset) against the specified OracleConnection
/// 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 OracleConnection</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(OracleConnection connection, string spName, params object[] parameterValues)
{
//if we got 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)
OracleParameter[] commandParameters = OracleHelperParameterCache.GetSpParameterSet(connection.ConnectionString, spName);

//assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);

//call the overload that takes an array of OracleParameters
return ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
}
//otherwise we can just call the SP without params
else
{
return ExecuteDataset(connection, CommandType.StoredProcedure, spName);
}
}

/// <summary>
/// Execute an OracleCommand (that returns a resultset and takes no parameters) against the provided OracleTransaction.
/// </summary>
/// <remarks>
/// e.g.:
///  DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="transaction">a valid OracleTransaction</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <returns>a dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(OracleTransaction transaction, CommandType commandType, string commandText)
{
//pass through the call providing null for the set of OracleParameters
return ExecuteDataset(transaction, commandType, commandText, (OracleParameter[])null);
}

/// <summary>
/// Execute an OracleCommand (that returns a resultset) against the specified OracleTransaction
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
///  DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new OracleParameter("@prodid", 24));
/// </remarks>
/// <param name="transaction">a valid OracleTransaction</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <param name="commandParameters">an array of OracleParameters used to execute the command</param>
/// <returns>a dataset containing the resultset generated by the command</returns>
public static DataSet ExecuteDataset(OracleTransaction transaction, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
{
//create a command and prepare it for execution
OracleCommand cmd = new OracleCommand();
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);

//create the DataAdapter & DataSet
OracleDataAdapter da = new OracleDataAdapter(cmd);
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
//fill the DataSet using default values for DataTable names, etc.
da.Fill(ds);

//return the dataset
return ds;
}

/// <summary>
/// Execute a stored procedure via an OracleCommand (that returns a resultset) against the specified
/// OracleTransaction 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 OracleTransaction</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(OracleTransaction transaction, string spName, params object[] parameterValues)
{
//if we got 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)
OracleParameter[] commandParameters = OracleHelperParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName);

//assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);

//call the overload that takes an array of OracleParameters
return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
//otherwise we can just call the SP without params
else
{
return ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
}
}
public static DataSet ExecuteDataset(string connectionString, int pageIndex, int pageSize, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
{
//create & open an OracleConnection, and dispose of it after we are done.
using (OracleConnection cn = new OracleConnection(connectionString))
{
cn.Open();

//call the overload that takes a connection in place of the connection string
return ExecuteDataset(cn, pageIndex, pageSize, commandType, commandText, commandParameters);
}
}
public static DataSet ExecuteDataset(OracleConnection connection, int pageIndex, int pageSize, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
{
//create a command and prepare it for execution
OracleCommand cmd = new OracleCommand();
PrepareCommand(cmd, connection, (OracleTransaction)null, commandType, commandText, commandParameters);

//create the DataAdapter & DataSet
OracleDataAdapter da = new OracleDataAdapter(cmd);
DataSet ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
//fill the DataSet using default values for DataTable names, etc.
da.Fill(ds, (pageIndex - 1) * pageSize, pageSize, "pageTable");

//return the dataset
return ds;
}

#endregion ExecuteDataSet

#region ExecuteReader

/// <summary>
/// this enum is used to indicate weather the connection was provided by the caller, or created by OracleHelper, so that
/// we can set the appropriate CommandBehavior when calling ExecuteReader()
/// </summary>
private enum OracleConnectionOwnership
{
/// <summary>Connection is owned and managed by OracleHelper</summary>
Internal,

/// <summary>Connection is owned and managed by the caller</summary>
External
}

/// <summary>
/// Create and prepare an OracleCommand, 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 OracleConnection, on which to execute this command</param>
/// <param name="transaction">a valid OracleTransaction, or 'null'</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <param name="commandParameters">an array of OracleParameters 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 OracleHelper</param>
/// <returns>OracleDataReader containing the results of the command</returns>
private static OracleDataReader ExecuteReader(OracleConnection connection, OracleTransaction transaction, CommandType commandType, string commandText, OracleParameter[] commandParameters, OracleConnectionOwnership connectionOwnership)
{
//create a command and prepare it for execution
OracleCommand cmd = new OracleCommand();
PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters);

//create a reader
OracleDataReader dr;

// call ExecuteReader with the appropriate CommandBehavior
if (connectionOwnership == OracleConnectionOwnership.External)
{
dr = cmd.ExecuteReader();
}
else
{
dr = cmd.ExecuteReader((CommandBehavior)((int)CommandBehavior.CloseConnection));
}

return (OracleDataReader)dr;
}

/// <summary>
/// Execute an OracleCommand (that returns a resultset and takes no parameters) against the database specified in
/// the connection string.
/// </summary>
/// <remarks>
/// e.g.:
///  OracleDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="connectionString">a valid connection string for an OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <returns>an OracleDataReader containing the resultset generated by the command</returns>
public static OracleDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText)
{
//pass through the call providing null for the set of OracleParameters
return ExecuteReader(connectionString, commandType, commandText, (OracleParameter[])null);
}

/// <summary>
/// Execute an OracleCommand (that returns a resultset) against the database specified in the connection string
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
///  OracleDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new OracleParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">a valid connection string for an OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <param name="commandParameters">an array of OracleParameters used to execute the command</param>
/// <returns>an OracleDataReader containing the resultset generated by the command</returns>
public static OracleDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
{
//create & open an OraclebConnection
OracleConnection cn = new OracleConnection(connectionString);
cn.Open();

try
{
//call the private overload that takes an internally owned connection in place of the connection string
return ExecuteReader(cn, null, commandType, commandText, commandParameters, OracleConnectionOwnership.Internal);
}
catch
{
//if we fail to return the OracleDataReader, we need to close the connection ourselves
cn.Close();
throw;
}
}

/// <summary>
/// Execute a stored procedure via an OracleCommand (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.:
///  OracleDataReader dr = ExecuteReader(connString, "GetOrders", 24, 36);
/// </remarks>
/// <param name="connectionString">a valid connection string for an OracleConnection</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 OracleDataReader containing the resultset generated by the command</returns>
public static OracleDataReader ExecuteReader(string connectionString, string spName, params object[] parameterValues)
{
//if we got 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)
OracleParameter[] commandParameters = OracleHelperParameterCache.GetSpParameterSet(connectionString, spName);

//assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);

//call the overload that takes an array of OracleParameters
return ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
//otherwise we can just call the SP without params
else
{
return ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
}
}

/// <summary>
/// Execute an OracleCommand (that returns a resultset and takes no parameters) against the provided OracleConnection.
/// </summary>
/// <remarks>
/// e.g.:
///  OracleDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="connection">a valid OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <returns>an OracleDataReader containing the resultset generated by the command</returns>
public static OracleDataReader ExecuteReader(OracleConnection connection, CommandType commandType, string commandText)
{
//pass through the call providing null for the set of OracleParameters
return ExecuteReader(connection, commandType, commandText, (OracleParameter[])null);
}

/// <summary>
/// Execute an OracleCommand (that returns a resultset) against the specified OracleConnection
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
///  OracleDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new OracleParameter("@prodid", 24));
/// </remarks>
/// <param name="connection">a valid OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <param name="commandParameters">an array of OracleParameters used to execute the command</param>
/// <returns>an OracleDataReader containing the resultset generated by the command</returns>
public static OracleDataReader ExecuteReader(OracleConnection connection, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
{
//pass through the call to the private overload using a null transaction value and an externally owned connection
return ExecuteReader(connection, (OracleTransaction)null, commandType, commandText, commandParameters, OracleConnectionOwnership.External);
}

/// <summary>
/// Execute a stored procedure via an OracleCommand (that returns a resultset) against the specified OracleConnection
/// 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.:
///  OracleDataReader dr = ExecuteReader(conn, "GetOrders", 24, 36);
/// </remarks>
/// <param name="connection">a valid OracleConnection</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 OracleDataReader containing the resultset generated by the command</returns>
public static OracleDataReader ExecuteReader(OracleConnection connection, string spName, params object[] parameterValues)
{
//if we got parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
OracleParameter[] commandParameters = OracleHelperParameterCache.GetSpParameterSet(connection.ConnectionString, spName);

AssignParameterValues(commandParameters, parameterValues);

return ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
}
//otherwise we can just call the SP without params
else
{
return ExecuteReader(connection, CommandType.StoredProcedure, spName);
}
}

/// <summary>
/// Execute an OracleCommand (that returns a resultset and takes no parameters) against the provided OracleTransaction.
/// </summary>
/// <remarks>
/// e.g.:
///  OracleDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders");
/// </remarks>
/// <param name="transaction">a valid OracleTransaction</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <returns>an OracleDataReader containing the resultset generated by the command</returns>
public static OracleDataReader ExecuteReader(OracleTransaction transaction, CommandType commandType, string commandText)
{
//pass through the call providing null for the set of OracleParameters
return ExecuteReader(transaction, commandType, commandText, (OracleParameter[])null);
}

/// <summary>
/// Execute an OracleCommand (that returns a resultset) against the specified OracleTransaction
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
///   OracleDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new OracleParameter("@prodid", 24));
/// </remarks>
/// <param name="transaction">a valid OracleTransaction</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or PL/SQL command</param>
/// <param name="commandParameters">an array of OracleParameters used to execute the command</param>
/// <returns>an OracleDataReader containing the resultset generated by the command</returns>
public static OracleDataReader ExecuteReader(OracleTransaction transaction, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
{
//pass through to private overload, indicating that the connection is owned by the caller
return ExecuteReader(transaction.Connection, transaction, commandType, commandText, commandParameters, OracleConnectionOwnership.External);
}

/// <summary>
/// Execute a stored procedure via an OracleCommand (that returns a resultset) against the specified
/// OracleTransaction 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.:
///  OracleDataReader dr = ExecuteReader(trans, "GetOrders", 24, 36);
/// </remarks>
/// <param name="transaction">a valid OracleTransaction</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 OracleDataReader containing the resultset generated by the command</returns>
public static OracleDataReader ExecuteReader(OracleTransaction transaction, string spName, params object[] parameterValues)
{
//if we got parameter values, we need to figure out where they go
if ((parameterValues != null) && (parameterValues.Length > 0))
{
OracleParameter[] commandParameters = OracleHelperParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName);

AssignParameterValues(commandParameters, parameterValues);

return ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
//otherwise we can just call the SP without params
else
{
return ExecuteReader(transaction, CommandType.StoredProcedure, spName);
}
}

/// <summary>分页返回执行结果</summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="pageIndex">页数</param>
/// <param name="pageSize">页大小</param>
/// <param name="totalRecords">当此方法返回时，此参数包含在集合中返回的记录的总数。该参数未经初始化即被传递。</param>
/// <param name="tblName">要显示的表或多个表的连接</param>
/// <param name="fldName">要显示的字段列表</param>
/// <param name="strCondition">查询条件,不包括WHERE</param>
/// <param name="fldSort">排序字段列表或条件,不包括ORDER BY</param>
/// <param name="commandParameters">传入的参数集</param>
/// <returns></returns>
public static OracleDataReader ExecuteReader(OracleConnection connection,
int pageIndex, int pageSize, string tblName, string fldName, string strCondition, string fldSort,
OracleParameter[] commandParameters)
{
string commandText = "";
int PageLowerBound = (pageIndex /*- 1*/) * pageSize;
int PageUpperBound = PageLowerBound + pageSize;
string sTemp = "";
if (!string.IsNullOrEmpty(strCondition))
{
sTemp += " WHERE " + strCondition;
}
if (!string.IsNullOrEmpty(fldSort))
{
sTemp += " ORDER BY " + fldSort;
}
if (pageIndex == 0)
commandText = string.Format("SELECT * FROM (SELECT {0} FROM {1}{2}) WHERE ROWNUM<={3}", fldName, tblName, sTemp, PageUpperBound);
else
commandText = string.Format("SELECT * FROM (SELECT A.*,ROWNUM RNM FROM (SELECT {0} FROM {1}{2}) A WHERE ROWNUM <= {3}) WHERE RNM > {4}", fldName, tblName, sTemp, PageUpperBound, PageLowerBound);
try
{
//Prepare the command to execute
OracleCommand cmd = new OracleCommand();
PrepareCommand(cmd, connection, (OracleTransaction)null, CommandType.Text, commandText, commandParameters);
//OracleCommand cmd = PrepareCommand(conn, CommandType.Text, select, commandParameters);
//Execute the query, stating that the connection should close when the resulting datareader has been read
OracleDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
cmd.Parameters.Clear();
return rdr;
}
catch
{
//If an error occurs close the connection as the reader will not be used and we expect it to close the connection
connection.Close();
throw;
//Log(e.Message + "\n" + select, commandParameters);
}
}

public static OracleDataReader ExecuteReader(OracleConnection connection,
int pageIndex, int pageSize, out int totalRecords, string tblName, string fldName, string strCondition, string fldSort,
OracleParameter[] commandParameters)
{
string commandText = "";
int PageLowerBound = (pageIndex /*- 1*/) * pageSize;
int PageUpperBound = PageLowerBound + pageSize;
totalRecords = 0;
string sTemp = "";
if (!string.IsNullOrEmpty(strCondition))
{
sTemp += " WHERE " + strCondition;
}
string stotalRecords = "SELECT COUNT(*) FROM {0}{1}";
object obj = ExecuteScalar(connection, CommandType.Text, string.Format(stotalRecords, tblName, sTemp), commandParameters);
if (obj != null && obj is decimal)
{
totalRecords = Convert.ToInt32(obj);
}
if (totalRecords < 1 || totalRecords < (PageLowerBound + 1))
{
return null;
}
if (!string.IsNullOrEmpty(fldSort))
{
sTemp += " ORDER BY " + fldSort;
}
if (pageIndex == 0)
commandText = string.Format("SELECT * FROM (SELECT {0} FROM {1}{2}) WHERE ROWNUM<={3}", fldName, tblName, sTemp, PageUpperBound);
else
commandText = string.Format("SELECT * FROM (SELECT A.*,ROWNUM RNM FROM (SELECT {0} FROM {1}{2}) A WHERE ROWNUM <= {3}) WHERE RNM > {4}", fldName, tblName, sTemp, PageUpperBound, PageLowerBound);
try
{
//Prepare the command to execute
OracleCommand cmd = new OracleCommand();
PrepareCommand(cmd, connection, (OracleTransaction)null, CommandType.Text, commandText, commandParameters);
//OracleCommand cmd = PrepareCommand(conn, CommandType.Text, select, commandParameters);
//Execute the query, stating that the connection should close when the resulting datareader has been read
OracleDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
cmd.Parameters.Clear();
return rdr;
}
catch
{
//If an error occurs close the connection as the reader will not be used and we expect it to close the connection
connection.Close();
throw;
//Log(e.Message + "\n" + select, commandParameters);
}
}

#endregion ExecuteReader

#region ExecuteScalar

/// <summary>
/// Execute an OracleCommand (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 an OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or T-Oracle 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 OracleParameters
return ExecuteScalar(connectionString, commandType, commandText, (OracleParameter[])null);
}

/// <summary>
/// Execute an OracleCommand (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 OracleParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">a valid connection string for an OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or T-Oracle command</param>
/// <param name="commandParameters">an array of OracleParameters 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 OracleParameter[] commandParameters)
{
//create & open an OracleConnection, and dispose of it after we are done.
using (OracleConnection cn = new OracleConnection(connectionString))
{
cn.Open();

//call the overload that takes a connection in place of the connection string
return ExecuteScalar(cn, commandType, commandText, commandParameters);
}
}

/// <summary>
/// Execute a stored procedure via an OracleCommand (that returns a 1x1 resultset) against the database specified in
/// the conneciton 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 an OracleConnection</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)
{
//if we got 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 & populet the cache)
OracleParameter[] commandParameters = OracleHelperParameterCache.GetSpParameterSet(connectionString, spName);

//assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);

//call the overload that takes an array of OracleParameters
return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
}
//otherwise we can just call the SP without params
else
{
return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
}
}

/// <summary>
/// Execute an OracleCommand (that returns a 1x1 resultset and takes no parameters) against the provided OracleConnection.
/// </summary>
/// <remarks>
/// e.g.:
///  int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount");
/// </remarks>
/// <param name="connection">a valid OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or T-Oracle command</param>
/// <returns>an object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalar(OracleConnection connection, CommandType commandType, string commandText)
{
//pass through the call providing null for the set of OracleParameters
return ExecuteScalar(connection, commandType, commandText, (OracleParameter[])null);
}

/// <summary>
/// Execute an OracleCommand (that returns a 1x1 resultset) against the specified OracleConnection
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
///  int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new OracleParameter("@prodid", 24));
/// </remarks>
/// <param name="connection">a valid OracleConnection</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or T-OleDb command</param>
/// <param name="commandParameters">an array of OracleParameters 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(OracleConnection connection, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
{
//create a command and prepare it for execution
OracleCommand cmd = new OracleCommand();
PrepareCommand(cmd, connection, (OracleTransaction)null, commandType, commandText, commandParameters);

//execute the command & return the results
return cmd.ExecuteScalar();
}

/// <summary>
/// Execute a stored procedure via an OracleCommand (that returns a 1x1 resultset) against the specified OracleConnection
/// 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 OracleConnection</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(OracleConnection connection, string spName, params object[] parameterValues)
{
//if we got 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 & populet the cache)
OracleParameter[] commandParameters = OracleHelperParameterCache.GetSpParameterSet(connection.ConnectionString, spName);

//assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);

//call the overload that takes an array of OracleParameters
return ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
}
//otherwise we can just call the SP without params
else
{
return ExecuteScalar(connection, CommandType.StoredProcedure, spName);
}
}

/// <summary>
/// Execute an OracleCommand (that returns a 1x1 resultset and takes no parameters) against the provided OracleTransaction.
/// </summary>
/// <remarks>
/// e.g.:
///  int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount");
/// </remarks>
/// <param name="transaction">a valid OracleTransaction</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or T-OleDb command</param>
/// <returns>an object containing the value in the 1x1 resultset generated by the command</returns>
public static object ExecuteScalar(OracleTransaction transaction, CommandType commandType, string commandText)
{
//pass through the call providing null for the set of OracleParameters
return ExecuteScalar(transaction, commandType, commandText, (OracleParameter[])null);
}

/// <summary>
/// Execute an OracleCommand (that returns a 1x1 resultset) against the specified OracleTransaction
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
///  int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount", new OracleParameter("@prodid", 24));
/// </remarks>
/// <param name="transaction">a valid OracleTransaction</param>
/// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
/// <param name="commandText">the stored procedure name or T-OleDb command</param>
/// <param name="commandParameters">an array of OracleParameters 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(OracleTransaction transaction, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
{
//create a command and prepare it for execution
OracleCommand cmd = new OracleCommand();
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);

//execute the command & return the results
return cmd.ExecuteScalar();
}

/// <summary>
/// Execute a stored procedure via an OracleCommand (that returns a 1x1 resultset) against the specified
/// OracleTransaction 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 OracleTransaction</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(OracleTransaction transaction, string spName, params object[] parameterValues)
{
//if we got 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 & populet the cache)
OracleParameter[] commandParameters = OracleHelperParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName);

//assign the provided values to these parameters based on parameter order
AssignParameterValues(commandParameters, parameterValues);

//call the overload that takes an array of OracleParameters
return ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
}
//otherwise we can just call the SP without params
else
{
return ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
}
}

#endregion ExecuteScalar
}

/// <summary>
/// OracleHelperParameterCache 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 OracleHelperParameterCache
{
#region private methods, variables, and constructors

//Since this class provides only static methods, make the default constructor private to prevent
//instances from being created with "new OracleHelperParameterCache()".
private OracleHelperParameterCache()
{
}

private static Hashtable paramCache = Hashtable.Synchronized(new Hashtable());

/// <summary>
/// resolve at run-time the appropriate set of OracleParameters for a stored procedure
/// </summary>
/// <param name="connectionString">a valid connection string for an OracleConnection</param>
/// <param name="spName">the name of the stored procedure</param>
/// <param name="includeReturnValueParameter">whether or not to include ther return value parameter</param>
/// <returns></returns>
private static OracleParameter[] DiscoverSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter)
{
using (OracleConnection cn = new OracleConnection(connectionString))
using (OracleCommand cmd = new OracleCommand(spName, cn))
{
cn.Open();
cmd.CommandType = CommandType.StoredProcedure;

OracleCommandBuilder.DeriveParameters(cmd);

if (!includeReturnValueParameter)
{
if (ParameterDirection.ReturnValue == cmd.Parameters[0].Direction)
cmd.Parameters.RemoveAt(0);
}

OracleParameter[] discoveredParameters = new OracleParameter[cmd.Parameters.Count];

cmd.Parameters.CopyTo(discoveredParameters, 0);

return discoveredParameters;
}
}

//deep copy of cached OracleParameter array
private static OracleParameter[] CloneParameters(OracleParameter[] originalParameters)
{
OracleParameter[] clonedParameters = new OracleParameter[originalParameters.Length];

for (int i = 0, j = originalParameters.Length; i < j; i++)
{
clonedParameters[i] = (OracleParameter)((ICloneable)originalParameters[i]).Clone();
}

return clonedParameters;
}

#endregion private methods, variables, and constructors

#region caching functions

/// <summary>
/// add parameter array to the cache
/// </summary>
/// <param name="connectionString">a valid connection string for an OracleConnection</param>
/// <param name="commandText">the stored procedure name or T-OleDb command</param>
/// <param name="commandParameters">an array of OracleParameters to be cached</param>
public static void CacheParameterSet(string connectionString, string commandText, params OracleParameter[] commandParameters)
{
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 OracleConnection</param>
/// <param name="commandText">the stored procedure name or T-OleDb command</param>
/// <returns>an array of OracleParameters</returns>
public static OracleParameter[] GetCachedParameterSet(string connectionString, string commandText)
{
string hashKey = connectionString + ":" + commandText;

OracleParameter[] cachedParameters = (OracleParameter[])paramCache[hashKey];

if (cachedParameters == null)
{
return null;
}
else
{
return CloneParameters(cachedParameters);
}
}

#endregion caching functions

#region Parameter Discovery Functions

/// <summary>
/// Retrieves the set of OracleParameters 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 OracleConnection</param>
/// <param name="spName">the name of the stored procedure</param>
/// <returns>an array of OracleParameters</returns>
public static OracleParameter[] GetSpParameterSet(string connectionString, string spName)
{
return GetSpParameterSet(connectionString, spName, false);
}

/// <summary>
/// Retrieves the set of OracleParameters 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 OracleConnection</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 OracleParameters</returns>
public static OracleParameter[] GetSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter)
{
string hashKey = connectionString + ":" + spName + (includeReturnValueParameter ? ":include ReturnValue Parameter" : "");

OracleParameter[] cachedParameters;

cachedParameters = (OracleParameter[])paramCache[hashKey];

if (cachedParameters == null)
{
cachedParameters = (OracleParameter[])(paramCache[hashKey] = DiscoverSpParameterSet(connectionString, spName, includeReturnValueParameter));
}

return CloneParameters(cachedParameters);
}

#endregion Parameter Discovery Functions
}
}

　2使用

using System.Collections.Generic;
using Oracle.DataAccess.Client;
using System;
using System.Data;
using System.ServiceModel;
using System.IO;
using System.Text;

namespace Oracle.Access
{

public class OracleService
{
public string ConnectionString { get; set; }

public OracleService()
{
ConnectionString = System.Configuration.ConfigurationManager.AppSettings["ConnectionString"];
}
//多表连接查询和传参写法以及分页
public DataTable GetWorkOrderList(int pageIndex, int pageSize, int index1 = 0, int index2 = 0, DateTime? starttime = null, DateTime? stoptime = null)
{
string sql = @"SELECT W.*, D.*, AH.*, A.Fied1, A.Fied2, A.Fied3
FROM  Table1 W, Table2 A,
(SELECT * FROM
(SELECT ROW_NUMBER() OVER (PARTITION BY H.Fied1 ORDER BY H.Fied2 DESC) N,
H.* FROM Table3 H)
WHERE N = 1) AH,
(SELECT * FROM Table4 C, Table5 B
WHERE C.Fied1 = B.Fied1 AND C.Fied1 = 1) D
WHERE W.Fied1 = D.Fied1(+) AND W.Fied1 = AH.Fied1(+) AND
A.Fied1 = W.Fied1 AND ";

if (index1 == 0 && index2 == 0)
{

}
else
{

if (providerindex != 0)
sql += "w.providerindex = " +index1 + " and ";
if (businessindex != 0)
sql += "w.businessindex = " + index2 + " and ";
if (starttime != null)
sql += "to_char(w.createtime, 'yyyy-mm-dd hh24:mi:ss') >= '" + starttime.Value.ToString("yyyy-MM-dd HH:mm:ss") + "' and ";
if (stoptime != null)
sql += "to_char(w.createtime, 'yyyy-mm-dd hh24:mi:ss') <= '" + stoptime.Value.ToString("yyyy-MM-dd HH:mm:ss") + "' and ";

}
sql = sql.Trim(new char[] { ' ', 'a', 'n', 'd', ' ' });
sql += " order by d.entityindex ";

string connstr = System.Configuration.ConfigurationManager.AppSettings["ConnectionString"];
DataTable dt = OracleHelper.ExecuteDataset(connstr, pageIndex, pageSize, CommandType.Text, sql).Tables[0];
return dt;
}

public string InsertTableInfo(int index1, int index2, string index3, DateTime? createTime)
{
string entityIndex = string.Empty;
string sqlInsert = "INSERT INTO Table (Field1, Field2, Field3, Field4) ";
sqlInsert += "VALUES (:Field1, :Field2, :Field3, :Field4)";

string connstr = System.Configuration.ConfigurationManager.AppSettings["ConnectionString"];
OracleConnection conn = new OracleConnection(connstr);
conn.Open();
OracleTransaction trans = conn.BeginTransaction(IsolationLevel.ReadCommitted);
try
{

OracleParameter[] inParms = {
new OracleParameter(":Field1", OracleDbType.Decimal),
new OracleParameter(":Field2", OracleDbType.Decimal),
new OracleParameter(":Field3", OracleDbType.NVarchar2, 32),
new OracleParameter(":Field4", OracleDbType.Date),
};

inParms[0].Value = index1;
inParms[1].Value = index2;
inParms[2].Value = index3;
inParms[3].Value = createTime;
OracleHelper.ExecuteNonQuery(trans, CommandType.Text, sqlInsert, inParms);
string sqlInsertHandle = "INSERT INTO Table (ENTITY_SEQ, Field) ";
//ENTITY_SEQ.currval是序列的当前值，与SQL取序列当前值不同，oracle比较直观，
sqlInsertHandle += "VALUES ('" + System.Configuration.ConfigurationManager.AppSettings["OrderPrefixString"] + "' || trim(to_char(ENTITY_SEQ.currval, '00000000')) , :Field1)";
OracleParameter[] inParmsHandle = {

new OracleParameter(":Field1", OracleDbType.Decimal),
};

inParmsHandle[0].Value = Field2;
OracleHelper.ExecuteNonQuery(trans, CommandType.Text, sqlInsertHandle, inParmsHandle);

string sqlSearchIndex = "SELECT ENTITY_SEQ.currval FROM DUAL";//类似sql取序列当前值
object obj = OracleHelper.ExecuteScalar(trans, CommandType.Text, sqlSearchIndex);
entityIndex = System.Configuration.ConfigurationManager.AppSettings["OrderPrefixString"] + int.Parse(obj.ToString()).ToString("00000000");

trans.Commit();
}
catch (System.Exception e)
{
trans.Rollback();
throw new Exception(e.Message);
}
finally
{
conn.Close();
}

return entityIndex;
}
public DataTable GetTablwHandles(string index)
{
string sql = "select * from Table where index = '" + index + "'";
string connstr = System.Configuration.ConfigurationManager.AppSettings["ConnectionString"];
DataTable dr = OracleHelper.ExecuteDataset(connstr, CommandType.Text, sql).Tables[0];
return dr;
}

public void UpdateBusinessEntityInfo(string index, string code, string name)
{
string sqlUpdate = "UPDATE Table SET NAME = :name, Code = :code, WHERE INDEX = :INDEX";

string connstr = System.Configuration.ConfigurationManager.AppSettings["ConnectionString"];

OracleParameter[] upParms = {
new OracleParameter(":name", OracleDbType.NVarchar2, 32),
new OracleParameter(":code", OracleDbType.NVarchar2, 32),
new OracleParameter(":INDEX", OracleDbType.NVarchar2, 32),
};

upParms[0].Value = index;
upParms[1].Value = code;
upParms[2].Value = name;

OracleHelper.ExecuteNonQuery(connstr, CommandType.Text, sqlUpdate, upParms);
}

public void DeleteTableInfo(string index)
{
string sql = "delete from Table where index = '" + index + "'";
string connstr = System.Configuration.ConfigurationManager.AppSettings["ConnectionString"];

OracleHelper.ExecuteNonQuery(connstr, CommandType.Text, sql);
}

public DataTable GetMaintenanceReportData(int Index, DateTime startTime, DateTime endTime)
{
var procedureName = "PT_Test_REPORT";//自定义存储过程的名字
var parameters = new OracleParameter[]
{
new OracleParameter("INDEX", OracleDbType.Decimal),
new OracleParameter("START_TIME", OracleDbType.Date),
new OracleParameter("END_TIME", OracleDbType.Date),
new OracleParameter("DS_CUR", OracleDbType.RefCursor),//游标
};
parameters[0].Direction = ParameterDirection.Input;
parameters[1].Direction = ParameterDirection.Input;
parameters[2].Direction = ParameterDirection.Input;
parameters[3].Direction = ParameterDirection.Output;

parameters[0].Value = Index;
parameters[1].Value = startTime;
parameters[2].Value = endTime;

DataTable dt = OracleHelper.ExecuteDataset(
ConnectionString, CommandType.StoredProcedure, procedureName, parameters).Tables[0];

return dt;
}

}
}

　*oracle非微软的古需要几个组件网上非常多自己找，另外其与上文的SqlHelper区别还是有的，比如左右连接(+)---left join on/right join on,传参 ：---@,传游标，序列的取值， 由于oracle与sqlserver存储过程返回值方法不同，sql直接select即可，而oracle有事需要借助游标，oracle游标返回值是一个表，而sql则是类似一条数据一个表，并且C#中

SqlHelper没有游标类型，

oracle所需组件

Oracle.Access.dll

Oracle.DataAccess.dll

Ora0ps11w.dll