Académique Documents
Professionnel Documents
Culture Documents
Transaction
Parameter Binding
Statement Caching
Transaction
The Oracle Database starts a transaction only in the context of a connection. Once a transaction starts, all the
successive command execution on that connection run in the context of that transaction. Transactions can only
be started on a OracleConnection object and the read-only Transaction property on the
OracleCommand object is implicitly set by the OracleConnection object. Therefore, the application
cannot set the Transaction property, nor does it need to.
Parameter Binding
ODP.NET allows applications to retrieve data as either a .NET Framework type or an ODP.NET type.
How the data is retrieved depends on whether application sets the OUT parameter to the DbType property
(.NET type) or OracleDbType property (ODP.NET type) of the OracleParameter.
For example, if the output parameter is bound as an DbType.String, the output data is returned as a .NET
String. On the other hand, if the parameter is bound as OracleDbType.Char, the output data is
returned as OracleString type.
Lastly, an application can simply bind the data and have ODP.NET infer both the DbType and
OracleDbType from the .NET type of the parameter value.
ODP.NET populates InputOutput, Output, and ReturnValue parameters with the Oracle data,
through the execution of the following OracleCommand methods:
ExecuteReader
ExecuteNonQuery
ExecuteScalar
An application should not bind a value for output parameters; it is the responsibility of ODP.NET to create the
value object and populate the OracleParameter Value property with the object.
Array Binding
See Also:
"OracleDbType Enumeration"
Starting from Oracle Database 10g, the database supports two new native datatypes, BINARY_FLOAT and
BINARY_DOUBLE.
See Also:
"GetDouble"
"GetFloat"
Table 3-2 lists all the OracleDbType enumeration values with a description of each enumerated value.
This section explains the inference from the System.Data.DbType, OracleDbType, and Value
properties in the OracleParameter class.
In the OracleParameter class, DbType, OracleDbType, and Value properties are linked.
Specifying the value of any of these properties infers the value of one or more of the other properties.
Inference of DbType from OracleDbType
In the OracleParameter class, specifying the value of OracleDbType infers the value of DbType as
shown in Table 3-3.
OracleDbType System.Data.DbType
BFile Object
Blob Object
Byte Byte
Char StringFixedLength
Clob Object
Date Date
Decimal Decimal
Double Double
Int16 Int16
Int32 Int32
Int64 Int64
IntervalDS TimeSpan
IntervalYM Int64
Long String
LongRaw Binary
NChar StringFixedLength
NClob Object
NVarchar2 String
Raw Binary
RefCursor Object
Single Single
TimeStamp DateTime
TimeStampLTZ DateTime
TimeStampTZ DateTime
Varchar2 String
XmlType String
Inference of OracleDbType from DbType
In the OracleParameter class, specifying the value of DbType infers the value of OracleDbType as
shown in Table 3-4.
System.Data.DbType OracleDbType
Binary Raw
Boolean Not Supported
Byte Byte
Currency Not Supported
Date Date
DateTime TimeStamp
Decimal Decimal
Double Double
Guid Not Supported
Int16 Int16
Int32 Int32
Int64 Int64
Object Not Supported
Sbyte Not Supported
Single Single
String Varchar2
StringFixedLength Char
Time TimeStamp
UInt16 Not Supported
UInt32 Not Supported
Uint64 Not Supported
VarNumeric Not Supported
In the OracleParameter class, Value is an object type which can be of any .NET Framework datatype
or ODP.NET type. If the OracleDbType and DbType in the OracleParameter object are not
specified, OracleDbType is inferred from the type of the Value property.
Table 3-5 shows the inference of DbType and OracleDbType from Value when the type of Value is
one of the .NET Framework datatypes.
Table 3-5 Inference of DbType and OracleDbType from Value (.NET Datatypes)
Note:
Table 3-6 shows the inference of DbType and OracleDbType from Value when type of Value is one
of Oracle.DataAccess.Types.
Table 3-6 Inference of DbType and OracleDbType from Value (ODP.NET Types)
ODP.NET supports PL/SQL Associative Array (formerly known as PL/SQL Index-By Tables) binding.
CollectionType
ArrayBindSize
This property is ignored for the fixed-length element types (such as Int32).
For variable-length element types (such as Varchar2), each element in the ArrayBindSize
property specifies the size of the corresponding element in the Value property.
For Output parameters, InputOutput parameters, and return values, this property must be set for
variable-length variables.
ArrayBindStatus
This property specifies the execution status of each element in the OracleParameter.Value
property.
Size
This property specifies the maximum number of elements to be bound in the PL/SQL Associative Array.
Value
Code Example
This example binds three OracleParameter objects as PL/SQL Associative Arrays: Param1 as an In
parameter, Param2 as an InputOutput parameter, and Param3 as an Output parameter.
// C#
using System;
using System.Data;
using Oracle.DataAccess.Client;
class AssociativeArraySample
{
static void Main()
{
OracleConnection con = new OracleConnection();
con.ConnectionString = "User Id=scott;Password=tiger;Data Source=oracle";
con.Open();
Console.WriteLine("Connected to Oracle" + con.ServerVersion);
Param1.Direction = ParameterDirection.Input;
Param2.Direction = ParameterDirection.InputOutput;
Param3.Direction = ParameterDirection.Output;
Array Binding
The array bind feature enables applications to bind arrays of a type using the OracleParameter class.
Using the array bind feature, an application can insert multiple rows into a table in a single database round-trip.
The following code example inserts three rows into the Dept table with a single database round-trip. The
OracleCommand ArrayBindCount property defines the number of elements of the array to use when
executing the statement.
// C#
using System;
using System.Data;
using Oracle.DataAccess.Client;
class ArrayBindSample
{
static void Main()
{
OracleConnection con = new OracleConnection();
con.ConnectionString = "User Id=scott;Password=tiger;Data Source=oracle;";
con.Open();
Console.WriteLine("Connected successfully");
prm.Direction = ParameterDirection.Input;
prm.Value = myArrayDeptNo;
The OracleParameter object provides two properties for granular control when using the array bind
feature:
ArrayBindSize Property
The ArrayBindSize property is an array of integers specifying the maximum size for each
corresponding value in an array. The ArrayBindSize property is similar to the Size property of
an OracleParameter except ArrayBindSize specifies the size for each value in an array.
Before the execution, the application must populate ArrayBindSize; after the execution, ODP.NET
populates the ArrayBindSize.
ArrayBindSize is used only for parameter types that have variable length such as Clob, Blob
and Varchar2. The size is represented in bytes for binary datatypes and characters for the Unicode
string types. The count for string types does not include the terminating character. The size is inferred
from the actual size of the value, if it is not explicitly set. For an output parameter, the size of each value
is set by ODP.NET. The ArrayBindSize property is ignored for fixed length datatypes.
ArrayBindStatus Property
Before the execution, the application must populate the ArrayBindStatus property and after the
execution, ODP.NET populates it. Before the execution, an application using ArrayBindStatus
can specify a NULL value for the corresponding element in the array for a parameter. After the
execution, ODP.NET populates the ArrayBindStatus array, indicating whether the corresponding
element in the array has a NULL value or if data truncation occurred when the value was fetched.
If an error occurs during an Array Bind execution, it can be difficult to determine which element in the Value
property caused the error. ODP.NET provides a way to determine the row where the error occurred, making it
easier to find the element in the row that caused the error.
// C#
using System;
using System.Data;
using Oracle.DataAccess.Client;
class ArrayBindExceptionSample
{
static void Main()
{
OracleConnection con = new OracleConnection();
con.ConnectionString = "User Id=scott;Password=tiger;Data Source=oracle;";
con.Open();
// Start a transaction
OracleTransaction txn = con.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
int[] myArrayDeptNo = new int[3] { 10, 200000, 30 };
// int[] myArrayDeptNo = new int[3]{ 10,20,30};
prm.Direction = ParameterDirection.Input;
prm.Value = myArrayDeptNo;
txn.Commit();
}
cmd.Parameters.Clear();
cmd.CommandText = "select count(*) from depttest";
See Also:
For output parameters, it indicates that the provider assigned an intact value to the
parameter.
NullFetched Indicates that a NULL value has been fetched from a column or an OUT parameter.
NullInsert Indicates that a NULL value is to be inserted into a column.
Truncation Indicates that truncation has occurred when fetching the data from the column.