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
Oracle操作数据库oracleHelper的更多相关文章
- ADO.NET和ORACLE操作数据库传参数赋值的方式
在使用.Net使用OracleParameter进行Oracle数据库操作的时候,因为Oracle和SQLServer针对查询参数化的语法不同, 在操作SQLServer的时候使用的是@Paramet ...
- Oracle 操作数据库（增删改语句）
对数据库的操作除了查询,还包括插入.更新和删除等数据操作.后3种数据操作使用的 SQL 语言也称为数据操纵语言(DML). 一.插入数据(insert 语句) 插入数据就是将数据记录添加到已经存在的数 ...
- Oracle -操作数据库
删除数据: delete:用delete删除记录,Oracle系统会产生回滚记录,所以这种操作可以使用ROLLBACK来撤销 truncate:删除数据时,不会产生回滚记录.所以执行速度相对较快些 可 ...
- 吴裕雄 python oracle操作数据库（4）
import cx_Oracle conn = cx_Oracle.connect("scott/admin@localhost:1521/orcl")cursor = conn. ...
- JDBC（用Eclipse操作数据库Oracle）的基础操作集合
JDBC: JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编 ...
- 非常不错的ASP操作数据库类，支持多数据库MSSQL,ACCESS,ORACLE,MYSQL等
可同时操作多个不同类型的数据库. 完全不用考虑数据类型的差别,再也不用想字符型字段加不加单引号. 调用非常简单,对数据库的主要操作一般只需要一行代码. 支持mssql事务回滚. 可自动生成和输出sql ...
- Oracle 10g数据库备份与恢复操作手册
Oracle 10g数据库备份与恢复操作手册 目录 Oracle 10g数据库备份与恢复操作手册... 前言... 文档目的... 文档范围... 目标读者... 其他说明... 冷备份... 热备份 ...
- Oracle相关数据库操作
1.进入oracle后台操作 su - oracle 2.数据库备份的指定位置 Oracle用sys用户登录查询数据库 select * from dba_directories a where a. ...
- 菜鸡之NetCore 使用EF操作数据库 Oracle & Sqlserver （一）
摘要: 该篇文章主要记录netCore EFCore 如何操作Oracle和SqlServer 数据库,采用Codefirst方式创建数据库以及表. 一, 项目建立 项目采用DDD领域驱动设计模式[学 ...
随机推荐
- java.lang.OutOfMemoryError: PermGen space 解决方案
只需两步: 将值改为512或者1024,然后CTRL+S,重启tomcat 和eclipse即可.
- Codeforces 475C Kamal-ol-molk's Painting 模拟
主题链接:点击打开链接 意甲冠军:特定n*m矩阵 X代表色 .代表无色 随着x*y形刷子去涂色. 刷子每次能够→或↓移动随意步. 若可以染出给定的矩阵,则输出最小的刷子的面积 若不能输出-1 思路: ...
- 《think in python》学习-6
think in python 有返回函数 我们使用过的内置函数中,有一部分会返回结果,比如 math的 返回值 我们写一个有返回值的函数,计算给定半径的圆的面积,例如这个: def area(rad ...
- 查询EBS在线用户SQL(R12)
SELECT U.USER_NAME, APP.APPLICATION_SHORT_NAME, FAT.APPLICATION_NAME, FR.RESPONSIBILITY_KEY, FRT.RES ...
- mysql性能监控工具Innotop
mysql监控管理工具--innotop 1.innotop安装参考官网:http://innotop.googlecode.com/svn/html/installing.html # wget h ...
- JQuery easyui （4）LinkButtion（按钮）组件
居然还有button组件 - - linkButton组件的加载方式 1,class加载 <a class='easyui-linkbtuton'>按钮<a> 2,js加载 $ ...
- 如何正确理解正则表达式中的分隔符 \b
前言:好久不见,博客园. 最近在学习研究regex,其中有个特迷惑自己的知识点是分隔符 ( word boundary) [\b] (注:为了方便,后文都以[]来包含字符,并不是reg规则里面的[] ...
- placeholder颜色
::-moz-placeholder{color:#b9bfc1;} // Firefox::-webkit-input-placeholder{color:#b9bfc1;} // Chrome, ...
- PHP fopen和fwrite函数实现创建html页面
思路 用fopen函数和fread函数得到模板,然后用str_replace函数替换模板标签为变量,最后用fwrite函数输出新的HTML页面 index.html模板页面 <!DOCTYPE ...
- php部分学习笔记
[web 开发分为]1. 静态web 开发(html 页面) 如果我们的一个页面,始终是一成不变的,则就是属于静态web 开发,一般讲用html 技术就ok2. 动态web 开发 比如: 我们需要发帖 ...