Oracle操作数据库oracleHelper
Posted 名扬博客
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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 res以上是关于Oracle操作数据库oracleHelper的主要内容，如果未能解决你的问题，请参考以下文章