mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-17 01:41:17 -10:00
* System.Data.OracleClient/OracleConnection.cs: dispose of the connection string and other fields * Test/TestOracleClient.cs: tests for Intergrated Security and Persist Secuirty Info connection string parameters svn path=/trunk/mcs/; revision=54951
2301 lines
73 KiB
C#
2301 lines
73 KiB
C#
//
|
|
// TestOracleClient.cs - Tests Sytem.Data.OracleClient
|
|
// data provider in Mono.
|
|
//
|
|
// Part of managed C#/.NET library System.Data.OracleClient.dll
|
|
//
|
|
// Part of the Mono class libraries at
|
|
// mcs/class/System.Data.OracleClient/System.Data.OracleClient.OCI
|
|
//
|
|
// Tests:
|
|
// Assembly: System.Data.OracleClient.dll
|
|
// Namespace: System.Data.OracleClient
|
|
//
|
|
// To Compile:
|
|
// mcs TestOracleClient.cs /r:System.Data.dll /r:System.Data.OracleClient.dll /nowarn:0168
|
|
//
|
|
// Author:
|
|
// Daniel Morgan <[email protected]>
|
|
//
|
|
// Copyright (C) Daniel Morgan, 2002, 2004-2005
|
|
//
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using System.Data;
|
|
using System.Data.OracleClient;
|
|
using System.Text;
|
|
using System.Threading;
|
|
|
|
namespace Test.OracleClient
|
|
{
|
|
public class OracleTest
|
|
{
|
|
private static Thread t = null;
|
|
private static string conStr;
|
|
public static readonly int MAX_CONNECTIONS = 30; // max connections default to 100, but I will set to 30.
|
|
|
|
public OracleTest()
|
|
{
|
|
|
|
}
|
|
|
|
static void MonoTest(OracleConnection con)
|
|
{
|
|
Console.WriteLine (" Drop table MONO_ORACLE_TEST ...");
|
|
try {
|
|
OracleCommand cmd2 = con.CreateCommand ();
|
|
cmd2.CommandText = "DROP TABLE MONO_ORACLE_TEST";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch (OracleException oe1) {
|
|
// ignore if table already exists
|
|
}
|
|
|
|
OracleCommand cmd = null;
|
|
|
|
Console.WriteLine(" Creating table MONO_ORACLE_TEST...");
|
|
cmd = new OracleCommand();
|
|
cmd.Connection = con;
|
|
cmd.CommandText = "CREATE TABLE MONO_ORACLE_TEST ( " +
|
|
" varchar2_value VarChar2(32), " +
|
|
" long_value long, " +
|
|
" number_whole_value Number(18), " +
|
|
" number_scaled_value Number(18,2), " +
|
|
" number_integer_value Integer, " +
|
|
" float_value Float, " +
|
|
" date_value Date, " +
|
|
" char_value Char(32), " +
|
|
" clob_value Clob, " +
|
|
" blob_value Blob, " +
|
|
" clob_empty_value Clob, " +
|
|
" blob_empty_value Blob, " +
|
|
" varchar2_null_value VarChar2(32), " +
|
|
" number_whole_null_value Number(18), " +
|
|
" number_scaled_null_value Number(18,2), " +
|
|
" number_integer_null_value Integer, " +
|
|
" float_null_value Float, " +
|
|
" date_null_value Date, " +
|
|
" char_null_value Char(32), " +
|
|
" clob_null_value Clob, " +
|
|
" blob_null_value Blob " +
|
|
")";
|
|
|
|
cmd.ExecuteNonQuery();
|
|
|
|
Console.WriteLine(" Begin Trans for table MONO_ORACLE_TEST...");
|
|
OracleTransaction trans = con.BeginTransaction ();
|
|
|
|
Console.WriteLine(" Inserting value into MONO_ORACLE_TEST...");
|
|
cmd = new OracleCommand();
|
|
cmd.Connection = con;
|
|
cmd.Transaction = trans;
|
|
cmd.CommandText = "INSERT INTO mono_oracle_test " +
|
|
" ( varchar2_value, " +
|
|
" long_value, " +
|
|
" number_whole_value, " +
|
|
" number_scaled_value, " +
|
|
" number_integer_value, " +
|
|
" float_value, " +
|
|
" date_value, " +
|
|
" char_value, " +
|
|
" clob_value, " +
|
|
" blob_value, " +
|
|
" clob_empty_value, " +
|
|
" blob_empty_value " +
|
|
") " +
|
|
" VALUES( " +
|
|
" 'Mono', " +
|
|
" 'This is a LONG column', " +
|
|
" 123, " +
|
|
" 456.78, " +
|
|
" 8765, " +
|
|
" 235.2, " +
|
|
" TO_DATE( '2004-12-31', 'YYYY-MM-DD' ), " +
|
|
" 'US', " +
|
|
" EMPTY_CLOB(), " +
|
|
" EMPTY_BLOB()," +
|
|
" EMPTY_CLOB(), " +
|
|
" EMPTY_BLOB()" +
|
|
")";
|
|
|
|
cmd.ExecuteNonQuery();
|
|
|
|
Console.WriteLine(" Select/Update CLOB columns on table MONO_ORACLE_TEST...");
|
|
|
|
// update BLOB and CLOB columns
|
|
OracleCommand select = con.CreateCommand ();
|
|
select.Transaction = trans;
|
|
select.CommandText = "SELECT CLOB_VALUE, BLOB_VALUE FROM MONO_ORACLE_TEST FOR UPDATE";
|
|
OracleDataReader reader = select.ExecuteReader ();
|
|
if (!reader.Read ())
|
|
Console.WriteLine ("ERROR: RECORD NOT FOUND");
|
|
// update clob_value
|
|
Console.WriteLine(" Update CLOB column on table MONO_ORACLE_TEST...");
|
|
OracleLob clob = reader.GetOracleLob (0);
|
|
byte[] bytes = null;
|
|
UnicodeEncoding encoding = new UnicodeEncoding ();
|
|
bytes = encoding.GetBytes ("Mono is fun!");
|
|
clob.Write (bytes, 0, bytes.Length);
|
|
clob.Close ();
|
|
// update blob_value
|
|
Console.WriteLine(" Update BLOB column on table MONO_ORACLE_TEST...");
|
|
OracleLob blob = reader.GetOracleLob (1);
|
|
bytes = new byte[6] { 0x31, 0x32, 0x33, 0x34, 0x35, 0x036 };
|
|
blob.Write (bytes, 0, bytes.Length);
|
|
blob.Close ();
|
|
|
|
Console.WriteLine(" Commit trans for table MONO_ORACLE_TEST...");
|
|
trans.Commit ();
|
|
|
|
// OracleCommand.ExecuteReader of MONO_ORACLE_TEST table
|
|
Console.WriteLine(" Read simple test for table MONO_ORACLE_TEST...");
|
|
ReadSimpleTest(con, "SELECT * FROM MONO_ORACLE_TEST");
|
|
|
|
// OracleCommand.ExecuteScalar
|
|
Console.WriteLine(" -ExecuteScalar tests...");
|
|
string varchar2_value = (string) ReadScalar (con,"SELECT MAX(varchar2_value) FROM MONO_ORACLE_TEST");
|
|
Console.WriteLine(" String Value: " + varchar2_value);
|
|
|
|
Console.WriteLine(" Read Scalar: number_whole_value");
|
|
decimal number_whole_value = (decimal)
|
|
ReadScalar (con,"SELECT MAX(number_whole_value) FROM MONO_ORACLE_TEST");
|
|
Console.WriteLine(" Int32 Value: " + number_whole_value.ToString());
|
|
|
|
Console.WriteLine(" Read Scalar: number_scaled_value");
|
|
decimal number_scaled_value = (decimal)
|
|
ReadScalar (con,"SELECT number_scaled_value FROM MONO_ORACLE_TEST");
|
|
Console.WriteLine(" Decimal Value: " + number_scaled_value.ToString());
|
|
|
|
Console.WriteLine(" Read Scalar: date_value");
|
|
DateTime date_value = (DateTime)
|
|
ReadScalar (con,"SELECT date_value FROM MONO_ORACLE_TEST");
|
|
Console.WriteLine(" DateTime Value: " + date_value.ToString());
|
|
|
|
Console.WriteLine(" Read Scalar: clob_value");
|
|
string clob_value = (string)
|
|
ReadScalar (con,"SELECT clob_value FROM MONO_ORACLE_TEST");
|
|
Console.WriteLine(" CLOB Value: " + clob_value);
|
|
|
|
Console.WriteLine(" Read Scalar: blob_value");
|
|
byte[] blob_value = (byte[])
|
|
ReadScalar (con,"SELECT blob_value FROM MONO_ORACLE_TEST");
|
|
string sblob_value = GetHexString (blob_value);
|
|
Console.WriteLine(" BLOB Value: " + sblob_value);
|
|
|
|
// OracleCommand.ExecuteOracleScalar
|
|
Console.WriteLine(" -ExecuteOracleScalar tests...");
|
|
Console.WriteLine(" Read Oracle Scalar: varchar2_value");
|
|
ReadOracleScalar (con,"SELECT MAX(varchar2_value) FROM MONO_ORACLE_TEST");
|
|
|
|
Console.WriteLine(" Read Oracle Scalar: number_whole_value");
|
|
ReadOracleScalar (con,"SELECT MAX(number_whole_value) FROM MONO_ORACLE_TEST");
|
|
|
|
Console.WriteLine(" Read Oracle Scalar: number_scaled_value");
|
|
ReadOracleScalar (con,"SELECT number_scaled_value FROM MONO_ORACLE_TEST");
|
|
|
|
Console.WriteLine(" Read Oracle Scalar: date_value");
|
|
ReadOracleScalar (con,"SELECT date_value FROM MONO_ORACLE_TEST");
|
|
|
|
Console.WriteLine(" Read Oracle Scalar: clob_value");
|
|
ReadOracleScalar (con,"SELECT clob_value FROM MONO_ORACLE_TEST");
|
|
|
|
Console.WriteLine(" Read Oracle Scalar: blob_value");
|
|
ReadOracleScalar (con,"SELECT blob_value FROM MONO_ORACLE_TEST");
|
|
}
|
|
|
|
static object ReadScalar (OracleConnection con, string selectSql)
|
|
{
|
|
OracleCommand cmd = null;
|
|
cmd = con.CreateCommand();
|
|
cmd.CommandText = selectSql;
|
|
|
|
object o = cmd.ExecuteScalar ();
|
|
|
|
string dataType = o.GetType ().ToString ();
|
|
Console.WriteLine (" DataType: " + dataType);
|
|
return o;
|
|
}
|
|
|
|
static void ReadOracleScalar (OracleConnection con, string selectSql)
|
|
{
|
|
OracleCommand cmd = null;
|
|
cmd = con.CreateCommand();
|
|
cmd.CommandText = selectSql;
|
|
|
|
object o = cmd.ExecuteOracleScalar ();
|
|
|
|
string dataType = o.GetType ().ToString ();
|
|
Console.WriteLine (" DataType: " + dataType);
|
|
if (dataType.Equals("System.Data.OracleClient.OracleLob"))
|
|
o = ((OracleLob) o).Value;
|
|
if (o.GetType ().ToString ().Equals ("System.Byte[]"))
|
|
o = GetHexString ((byte[])o);
|
|
|
|
Console.WriteLine (" Value: " + o.ToString ());
|
|
}
|
|
|
|
static void ReadSimpleTest(OracleConnection con, string selectSql)
|
|
{
|
|
OracleCommand cmd = null;
|
|
OracleDataReader reader = null;
|
|
|
|
cmd = con.CreateCommand();
|
|
cmd.CommandText = selectSql;
|
|
reader = cmd.ExecuteReader();
|
|
|
|
Console.WriteLine(" Results...");
|
|
Console.WriteLine(" Schema");
|
|
DataTable table;
|
|
table = reader.GetSchemaTable();
|
|
for(int c = 0; c < reader.FieldCount; c++) {
|
|
Console.WriteLine(" Column " + c.ToString());
|
|
DataRow row = table.Rows[c];
|
|
|
|
string strColumnName = row["ColumnName"].ToString();
|
|
string strBaseColumnName = row["BaseColumnName"].ToString();
|
|
string strColumnSize = row["ColumnSize"].ToString();
|
|
string strNumericScale = row["NumericScale"].ToString();
|
|
string strNumericPrecision = row["NumericPrecision"].ToString();
|
|
string strDataType = row["DataType"].ToString();
|
|
|
|
Console.WriteLine(" ColumnName: " + strColumnName);
|
|
Console.WriteLine(" BaseColumnName: " + strBaseColumnName);
|
|
Console.WriteLine(" ColumnSize: " + strColumnSize);
|
|
Console.WriteLine(" NumericScale: " + strNumericScale);
|
|
Console.WriteLine(" NumericPrecision: " + strNumericPrecision);
|
|
Console.WriteLine(" DataType: " + strDataType);
|
|
}
|
|
|
|
int r = 0;
|
|
Console.WriteLine (" Data");
|
|
while (reader.Read ()) {
|
|
r++;
|
|
Console.WriteLine (" Row: " + r.ToString ());
|
|
for (int f = 0; f < reader.FieldCount; f++) {
|
|
string sname = "";
|
|
object ovalue = "";
|
|
string svalue = "";
|
|
string sDataType = "";
|
|
string sFieldType = "";
|
|
string sDataTypeName = "";
|
|
string sOraDataType = "";
|
|
|
|
sname = reader.GetName (f);
|
|
|
|
if (reader.IsDBNull (f)) {
|
|
ovalue = DBNull.Value;
|
|
svalue = "";
|
|
sDataType = "DBNull.Value";
|
|
sOraDataType = "DBNull.Value";
|
|
}
|
|
else {
|
|
//ovalue = reader.GetValue (f);
|
|
ovalue = reader.GetOracleValue (f);
|
|
object oravalue = null;
|
|
|
|
sDataType = ovalue.GetType ().ToString ();
|
|
switch (sDataType) {
|
|
case "System.Data.OracleClient.OracleString":
|
|
oravalue = ((OracleString) ovalue).Value;
|
|
break;
|
|
case "System.Data.OracleClient.OracleNumber":
|
|
oravalue = ((OracleNumber) ovalue).Value;
|
|
break;
|
|
case "System.Data.OracleClient.OracleLob":
|
|
OracleLob lob = (OracleLob) ovalue;
|
|
oravalue = lob.Value;
|
|
lob.Close ();
|
|
break;
|
|
case "System.Data.OracleClient.OracleDateTime":
|
|
oravalue = ((OracleDateTime) ovalue).Value;
|
|
break;
|
|
case "System.Byte[]":
|
|
oravalue = GetHexString((byte[])ovalue);
|
|
break;
|
|
case "System.Decimal":
|
|
//Console.WriteLine(" *** Get Decimal, Int16, Int32, Int64, Float, Double, ...");
|
|
decimal dec = reader.GetDecimal (f);
|
|
//Console.WriteLine(" GetDecimal: " + dec.ToString ());
|
|
|
|
oravalue = (object) dec;
|
|
/*
|
|
try {
|
|
reader.GetInt16 (f);
|
|
} catch (NotSupportedException e) {
|
|
Console.WriteLine (" ** Expected exception caught for GetInt16: NotSupportedException: " + e.Message);
|
|
}
|
|
|
|
try {
|
|
long lng = reader.GetInt64 (f);
|
|
Console.WriteLine(" GetInt64: " + lng.ToString ());
|
|
int n = reader.GetInt32 (f);
|
|
Console.WriteLine(" GetInt32: " + n.ToString ());
|
|
float flt = reader.GetFloat (f);
|
|
Console.WriteLine(" GetFloat: " + flt.ToString ());
|
|
double dbl = reader.GetDouble (f);
|
|
Console.WriteLine(" GetDouble: " + dbl.ToString ());
|
|
} catch (OverflowException oe1) {
|
|
Console.WriteLine (" ** Overflow exception for numbers to big or too small: " + oe1.Message);
|
|
}
|
|
*/
|
|
break;
|
|
default:
|
|
oravalue = ovalue.ToString ();
|
|
|
|
break;
|
|
}
|
|
|
|
sOraDataType = oravalue.GetType ().ToString ();
|
|
if (sOraDataType.Equals ("System.Byte[]"))
|
|
svalue = GetHexString ((byte[]) oravalue);
|
|
else
|
|
svalue = oravalue.ToString();
|
|
|
|
}
|
|
sFieldType = reader.GetFieldType(f).ToString();
|
|
sDataTypeName = reader.GetDataTypeName(f);
|
|
|
|
Console.WriteLine(" Field: " + f.ToString());
|
|
Console.WriteLine(" Name: " + sname);
|
|
Console.WriteLine(" Value: " + svalue);
|
|
Console.WriteLine(" Oracle Data Type: " + sOraDataType);
|
|
Console.WriteLine(" Data Type: " + sDataType);
|
|
Console.WriteLine(" Field Type: " + sFieldType);
|
|
Console.WriteLine(" Data Type Name: " + sDataTypeName);
|
|
}
|
|
}
|
|
if(r == 0)
|
|
Console.WriteLine(" No data returned.");
|
|
}
|
|
|
|
static void DataAdapterTest (OracleConnection connection)
|
|
{
|
|
Console.WriteLine(" Create select command...");
|
|
OracleCommand command = connection.CreateCommand ();
|
|
command.CommandText = "SELECT * FROM EMP";
|
|
|
|
Console.WriteLine(" Create data adapter...");
|
|
OracleDataAdapter adapter = new OracleDataAdapter (command);
|
|
|
|
Console.WriteLine(" Create DataSet...");
|
|
DataSet dataSet = new DataSet ("EMP");
|
|
|
|
Console.WriteLine(" Fill DataSet via data adapter...");
|
|
adapter.Fill (dataSet);
|
|
|
|
Console.WriteLine(" Get DataTable...");
|
|
DataTable table = dataSet.Tables [0];
|
|
|
|
Console.WriteLine(" Display each row...");
|
|
int rowCount = 0;
|
|
foreach (DataRow row in table.Rows) {
|
|
Console.WriteLine (" row {0}", rowCount + 1);
|
|
for (int i = 0; i < table.Columns.Count; i += 1) {
|
|
Console.WriteLine (" {0}: {1}", table.Columns [i].ColumnName, row [i]);
|
|
}
|
|
Console.WriteLine ();
|
|
rowCount += 1;
|
|
}
|
|
}
|
|
|
|
public static void DataAdapterTest2 (OracleConnection con)
|
|
{
|
|
DataAdapterTest2_Setup (con);
|
|
ReadSimpleTest (con, "SELECT * FROM mono_adapter_test");
|
|
|
|
GetMetaData (con, "SELECT * FROM mono_adapter_test");
|
|
|
|
DataAdapterTest2_Insert (con);
|
|
ReadSimpleTest (con, "SELECT * FROM mono_adapter_test");
|
|
|
|
DataAdapterTest2_Update (con);
|
|
ReadSimpleTest (con, "SELECT * FROM mono_adapter_test");
|
|
|
|
DataAdapterTest2_Delete (con);
|
|
ReadSimpleTest (con, "SELECT * FROM mono_adapter_test");
|
|
}
|
|
|
|
public static void GetMetaData (OracleConnection con, string sql)
|
|
{
|
|
OracleCommand cmd = null;
|
|
OracleDataReader rdr = null;
|
|
|
|
cmd = con.CreateCommand();
|
|
cmd.CommandText = sql;
|
|
|
|
Console.WriteLine("Read Schema With KeyInfo");
|
|
rdr = cmd.ExecuteReader(CommandBehavior.KeyInfo | CommandBehavior.SchemaOnly);
|
|
|
|
DataTable dt;
|
|
dt = rdr.GetSchemaTable();
|
|
foreach (DataRow schemaRow in dt.Rows) {
|
|
foreach (DataColumn schemaCol in dt.Columns) {
|
|
Console.WriteLine(schemaCol.ColumnName +
|
|
" = " +
|
|
schemaRow[schemaCol]);
|
|
Console.WriteLine("---Type: " + schemaRow[schemaCol].GetType ().ToString());
|
|
}
|
|
Console.WriteLine("");
|
|
}
|
|
|
|
Console.WriteLine("Read Schema with No KeyInfo");
|
|
|
|
rdr = cmd.ExecuteReader();
|
|
|
|
dt = rdr.GetSchemaTable();
|
|
foreach (DataRow schemaRow in dt.Rows) {
|
|
foreach (DataColumn schemaCol in dt.Columns) {
|
|
Console.WriteLine(schemaCol.ColumnName +
|
|
" = " +
|
|
schemaRow[schemaCol]);
|
|
Console.WriteLine("---Type: " + schemaRow[schemaCol].GetType ().ToString());
|
|
Console.WriteLine();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static void DataAdapterTest2_Setup (OracleConnection con)
|
|
{
|
|
Console.WriteLine (" Drop table mono_adapter_test ...");
|
|
try {
|
|
OracleCommand cmd2 = con.CreateCommand ();
|
|
cmd2.CommandText = "DROP TABLE mono_adapter_test";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch (OracleException oe1) {
|
|
// ignore if table already exists
|
|
}
|
|
|
|
OracleCommand cmd = null;
|
|
int rowsAffected = 0;
|
|
|
|
Console.WriteLine(" Creating table mono_adapter_test...");
|
|
cmd = new OracleCommand ();
|
|
cmd.Connection = con;
|
|
cmd.CommandText = "CREATE TABLE mono_adapter_test ( " +
|
|
" varchar2_value VarChar2(32), " +
|
|
" number_whole_value Number(18) PRIMARY KEY, " +
|
|
" number_scaled_value Number(18,2), " +
|
|
" number_integer_value Integer, " +
|
|
" float_value Float, " +
|
|
" date_value Date, " +
|
|
" clob_value Clob, " +
|
|
" blob_value Blob ) ";
|
|
|
|
// FIXME: char_value does not work
|
|
/*
|
|
cmd.CommandText = "CREATE TABLE mono_adapter_test ( " +
|
|
" varchar2_value VarChar2(32), " +
|
|
" number_whole_value Number(18) PRIMARY KEY, " +
|
|
" number_scaled_value Number(18,2), " +
|
|
" number_integer_value Integer, " +
|
|
" float_value Float, " +
|
|
" date_value Date, " +
|
|
" char_value Char(32), " +
|
|
" clob_value Clob, " +
|
|
" blob_value Blob ) ";
|
|
*/
|
|
|
|
rowsAffected = cmd.ExecuteNonQuery();
|
|
|
|
Console.WriteLine(" Begin Trans for table mono_adapter_test...");
|
|
OracleTransaction trans = con.BeginTransaction ();
|
|
|
|
Console.WriteLine(" Inserting value into mono_adapter_test...");
|
|
cmd = new OracleCommand();
|
|
cmd.Connection = con;
|
|
cmd.Transaction = trans;
|
|
|
|
cmd.CommandText = "INSERT INTO mono_adapter_test " +
|
|
" ( varchar2_value, " +
|
|
" number_whole_value, " +
|
|
" number_scaled_value, " +
|
|
" number_integer_value, " +
|
|
" float_value, " +
|
|
" date_value, " +
|
|
" clob_value, " +
|
|
" blob_value " +
|
|
") " +
|
|
" VALUES( " +
|
|
" 'Mono', " +
|
|
" 11, " +
|
|
" 456.78, " +
|
|
" 8765, " +
|
|
" 235.2, " +
|
|
" TO_DATE( '2004-12-31', 'YYYY-MM-DD' ), " +
|
|
" EMPTY_CLOB(), " +
|
|
" EMPTY_BLOB() " +
|
|
")";
|
|
|
|
/*
|
|
cmd.CommandText = "INSERT INTO mono_adapter_test " +
|
|
" ( varchar2_value, " +
|
|
" number_whole_value, " +
|
|
" number_scaled_value, " +
|
|
" number_integer_value, " +
|
|
" float_value, " +
|
|
" date_value, " +
|
|
" char_value, " +
|
|
" clob_value, " +
|
|
" blob_value " +
|
|
") " +
|
|
" VALUES( " +
|
|
" 'Mono', " +
|
|
" 11, " +
|
|
" 456.78, " +
|
|
" 8765, " +
|
|
" 235.2, " +
|
|
" TO_DATE( '2004-12-31', 'YYYY-MM-DD' ), " +
|
|
" 'US', " +
|
|
" EMPTY_CLOB(), " +
|
|
" EMPTY_BLOB() " +
|
|
")";
|
|
*/
|
|
rowsAffected = cmd.ExecuteNonQuery();
|
|
|
|
Console.WriteLine(" Select/Update CLOB columns on table mono_adapter_test...");
|
|
|
|
// update BLOB and CLOB columns
|
|
OracleCommand select = con.CreateCommand ();
|
|
select.Transaction = trans;
|
|
select.CommandText = "SELECT CLOB_VALUE, BLOB_VALUE FROM mono_adapter_test FOR UPDATE";
|
|
OracleDataReader reader = select.ExecuteReader ();
|
|
if (!reader.Read ())
|
|
Console.WriteLine ("ERROR: RECORD NOT FOUND");
|
|
|
|
// update clob_value
|
|
Console.WriteLine(" Update CLOB column on table mono_adapter_test...");
|
|
OracleLob clob = reader.GetOracleLob (0);
|
|
byte[] bytes = null;
|
|
UnicodeEncoding encoding = new UnicodeEncoding ();
|
|
bytes = encoding.GetBytes ("Mono is fun!");
|
|
clob.Write (bytes, 0, bytes.Length);
|
|
clob.Close ();
|
|
|
|
// update blob_value
|
|
Console.WriteLine(" Update BLOB column on table mono_adapter_test...");
|
|
OracleLob blob = reader.GetOracleLob (1);
|
|
bytes = new byte[6] { 0x31, 0x32, 0x33, 0x34, 0x35, 0x036 };
|
|
blob.Write (bytes, 0, bytes.Length);
|
|
blob.Close ();
|
|
|
|
Console.WriteLine(" Commit trans for table mono_adapter_test...");
|
|
trans.Commit ();
|
|
|
|
CommitCursor (con);
|
|
}
|
|
|
|
public static void DataAdapterTest2_Insert (OracleConnection con)
|
|
{
|
|
Console.WriteLine("================================");
|
|
Console.WriteLine("=== Adapter Insert =============");
|
|
Console.WriteLine("================================");
|
|
OracleTransaction transaction = con.BeginTransaction ();
|
|
|
|
Console.WriteLine(" Create adapter...");
|
|
OracleDataAdapter da = new OracleDataAdapter("select * from mono_adapter_test", con);
|
|
da.SelectCommand.Transaction = transaction;
|
|
|
|
Console.WriteLine(" Create command builder...");
|
|
OracleCommandBuilder mycb = new OracleCommandBuilder(da);
|
|
|
|
Console.WriteLine(" Create data set ...");
|
|
DataSet ds = new DataSet();
|
|
|
|
Console.WriteLine(" Fill data set via adapter...");
|
|
da.Fill(ds, "mono_adapter_test");
|
|
|
|
Console.WriteLine(" New Row...");
|
|
DataRow myRow;
|
|
myRow = ds.Tables["mono_adapter_test"].NewRow();
|
|
|
|
byte[] bytes = new byte[] { 0x45,0x46,0x47,0x48,0x49,0x50 };
|
|
|
|
Console.WriteLine(" Set values in the new DataRow...");
|
|
myRow["varchar2_value"] = "OracleClient";
|
|
myRow["number_whole_value"] = 22;
|
|
myRow["number_scaled_value"] = 12.34;
|
|
myRow["number_integer_value"] = 456;
|
|
myRow["float_value"] = 98.76;
|
|
myRow["date_value"] = new DateTime(2001,07,09);
|
|
Console.WriteLine(" *** FIXME; char value not working");
|
|
//myRow["char_value"] = "Romeo";
|
|
myRow["clob_value"] = "clobtest";
|
|
myRow["blob_value"] = bytes;
|
|
|
|
Console.WriteLine(" Add DataRow to DataTable...");
|
|
ds.Tables["mono_adapter_test"].Rows.Add(myRow);
|
|
|
|
Console.WriteLine("da.Update(ds...");
|
|
da.Update(ds, "mono_adapter_test");
|
|
|
|
transaction.Commit();
|
|
}
|
|
|
|
public static void DataAdapterTest2_Update (OracleConnection con)
|
|
{
|
|
Console.WriteLine("================================");
|
|
Console.WriteLine("=== Adapter Update =============");
|
|
Console.WriteLine("================================");
|
|
|
|
OracleTransaction transaction = con.BeginTransaction ();
|
|
|
|
Console.WriteLine(" Create adapter...");
|
|
OracleCommand selectCmd = con.CreateCommand ();
|
|
selectCmd.Transaction = transaction;
|
|
selectCmd.CommandText = "SELECT * FROM mono_adapter_test";
|
|
OracleDataAdapter da = new OracleDataAdapter(selectCmd);
|
|
Console.WriteLine(" Create command builder...");
|
|
OracleCommandBuilder mycb = new OracleCommandBuilder(da);
|
|
Console.WriteLine(" Create data set ...");
|
|
DataSet ds = new DataSet();
|
|
|
|
Console.WriteLine(" Set missing schema action...");
|
|
|
|
Console.WriteLine(" Fill data set via adapter...");
|
|
da.Fill(ds, "mono_adapter_test");
|
|
DataRow myRow;
|
|
|
|
Console.WriteLine(" New Row...");
|
|
myRow = ds.Tables["mono_adapter_test"].Rows[0];
|
|
|
|
Console.WriteLine("Tables Count: " + ds.Tables.Count.ToString());
|
|
|
|
DataTable table = ds.Tables["mono_adapter_test"];
|
|
DataRowCollection rows;
|
|
rows = table.Rows;
|
|
Console.WriteLine(" Row Count: " + rows.Count.ToString());
|
|
myRow = rows[0];
|
|
|
|
byte[] bytes = new byte[] { 0x62,0x63,0x64,0x65,0x66,0x67 };
|
|
|
|
Console.WriteLine(" Set values in the new DataRow...");
|
|
|
|
myRow["varchar2_value"] = "Super Power!";
|
|
|
|
myRow["number_scaled_value"] = 12.35;
|
|
myRow["number_integer_value"] = 457;
|
|
myRow["float_value"] = 198.76;
|
|
myRow["date_value"] = new DateTime(2002,08,09);
|
|
//myRow["char_value"] = "Juliet";
|
|
myRow["clob_value"] = "this is a clob";
|
|
myRow["blob_value"] = bytes;
|
|
|
|
Console.WriteLine("da.Update(ds...");
|
|
da.Update(ds, "mono_adapter_test");
|
|
|
|
transaction.Commit();
|
|
}
|
|
|
|
public static void DataAdapterTest2_Delete (OracleConnection con)
|
|
{
|
|
Console.WriteLine("================================");
|
|
Console.WriteLine("=== Adapter Delete =============");
|
|
Console.WriteLine("================================");
|
|
OracleTransaction transaction = con.BeginTransaction ();
|
|
|
|
Console.WriteLine(" Create adapter...");
|
|
OracleDataAdapter da = new OracleDataAdapter("SELECT * FROM mono_adapter_test", con);
|
|
Console.WriteLine(" Create command builder...");
|
|
OracleCommandBuilder mycb = new OracleCommandBuilder(da);
|
|
Console.WriteLine(" set transr...");
|
|
da.SelectCommand.Transaction = transaction;
|
|
|
|
Console.WriteLine(" Create data set ...");
|
|
DataSet ds = new DataSet();
|
|
|
|
Console.WriteLine("Fill data set via adapter...");
|
|
da.Fill(ds, "mono_adapter_test");
|
|
|
|
Console.WriteLine("delete row...");
|
|
ds.Tables["mono_adapter_test"].Rows[0].Delete();
|
|
|
|
Console.WriteLine("da.Update(table...");
|
|
da.Update(ds, "mono_adapter_test");
|
|
|
|
Console.WriteLine("Commit...");
|
|
transaction.Commit();
|
|
}
|
|
|
|
static void TestNonQueryUsingExecuteReader(OracleConnection con)
|
|
{
|
|
OracleDataReader reader = null;
|
|
OracleTransaction trans = null;
|
|
|
|
Console.WriteLine(" drop table mono_adapter_test...");
|
|
OracleCommand cmd = con.CreateCommand();
|
|
|
|
cmd.CommandText = "DROP TABLE MONO_ADAPTER_TEST";
|
|
trans = con.BeginTransaction();
|
|
cmd.Transaction = trans;
|
|
try {
|
|
reader = cmd.ExecuteReader();
|
|
Console.WriteLine(" RowsAffected before read: " + reader.RecordsAffected.ToString());
|
|
reader.Read();
|
|
Console.WriteLine(" RowsAffected after read: " + reader.RecordsAffected.ToString());
|
|
reader.Close();
|
|
Console.WriteLine(" RowsAffected after close: " + reader.RecordsAffected.ToString());
|
|
trans.Commit();
|
|
}
|
|
catch(OracleException e) {
|
|
Console.WriteLine(" OracleException caught: " + e.Message);
|
|
trans.Commit();
|
|
}
|
|
|
|
Console.WriteLine(" Create table mono_adapter_test...");
|
|
cmd.CommandText = "CREATE TABLE MONO_ADAPTER_TEST ( " +
|
|
" varchar2_value VarChar2(32), " +
|
|
" number_whole_value Number(18,0) PRIMARY KEY ) ";
|
|
trans = con.BeginTransaction();
|
|
cmd.Transaction = trans;
|
|
reader = cmd.ExecuteReader();
|
|
Console.WriteLine(" RowsAffected before read: " + reader.RecordsAffected.ToString());
|
|
reader.Read();
|
|
Console.WriteLine(" RowsAffected after read: " + reader.RecordsAffected.ToString());
|
|
reader.Close();
|
|
Console.WriteLine(" RowsAffected after close: " + reader.RecordsAffected.ToString());
|
|
trans.Commit();
|
|
|
|
Console.WriteLine("Insert into table mono_adapter_test...");
|
|
|
|
string sql =
|
|
"INSERT INTO MONO_ADAPTER_TEST " +
|
|
"(VARCHAR2_VALUE,NUMBER_WHOLE_VALUE) " +
|
|
"VALUES(:p1,:p2)";
|
|
|
|
OracleCommand cmd2 = con.CreateCommand();
|
|
trans = con.BeginTransaction();
|
|
cmd2.Transaction = trans;
|
|
cmd2.CommandText = sql;
|
|
|
|
OracleParameter myParameter1 = new OracleParameter("p1", OracleType.VarChar, 32);
|
|
myParameter1.Direction = ParameterDirection.Input;
|
|
|
|
OracleParameter myParameter2 = new OracleParameter("p2", OracleType.Number);
|
|
myParameter2.Direction = ParameterDirection.Input;
|
|
|
|
myParameter2.Value = 182;
|
|
myParameter1.Value = "Mono";
|
|
|
|
cmd2.Parameters.Add (myParameter1);
|
|
cmd2.Parameters.Add (myParameter2);
|
|
|
|
// insert 1 record
|
|
reader = cmd2.ExecuteReader();
|
|
Console.WriteLine(" RowsAffected before read: " + reader.RecordsAffected.ToString());
|
|
reader.Read();
|
|
Console.WriteLine(" RowsAffected after read: " + reader.RecordsAffected.ToString());
|
|
reader.Close();
|
|
Console.WriteLine(" RowsAffected after close: " + reader.RecordsAffected.ToString());
|
|
|
|
// insert another record
|
|
Console.WriteLine(" Insert another record...");
|
|
myParameter2.Value = 183;
|
|
myParameter1.Value = "Oracle";
|
|
reader = cmd2.ExecuteReader();
|
|
Console.WriteLine(" RowsAffected before read: " + reader.RecordsAffected.ToString());
|
|
reader.Read();
|
|
Console.WriteLine(" RowsAffected after read: " + reader.RecordsAffected.ToString());
|
|
reader.Close();
|
|
Console.WriteLine(" RowsAffected after close: " + reader.RecordsAffected.ToString());
|
|
|
|
trans.Commit();
|
|
trans = null;
|
|
|
|
ReadSimpleTest(con, "SELECT * FROM MONO_ADAPTER_TEST");
|
|
}
|
|
|
|
static void CommitCursor (OracleConnection con)
|
|
{
|
|
OracleCommand cmd = con.CreateCommand ();
|
|
cmd.CommandText = "COMMIT";
|
|
cmd.ExecuteNonQuery ();
|
|
cmd.Dispose ();
|
|
cmd = null;
|
|
}
|
|
|
|
static void RollbackTest (OracleConnection connection)
|
|
{
|
|
OracleTransaction transaction = connection.BeginTransaction ();
|
|
|
|
OracleCommand insert = connection.CreateCommand ();
|
|
insert.Transaction = transaction;
|
|
insert.CommandText = "INSERT INTO EMP (EMPNO, ENAME, JOB) VALUES (8787, 'T Coleman', 'Monoist')";
|
|
|
|
Console.WriteLine (" Inserting record ...");
|
|
|
|
insert.ExecuteNonQuery ();
|
|
|
|
OracleCommand select = connection.CreateCommand ();
|
|
select.CommandText = "SELECT COUNT(*) FROM EMP WHERE EMPNO = 8787";
|
|
select.Transaction = transaction;
|
|
OracleDataReader reader = select.ExecuteReader ();
|
|
reader.Read ();
|
|
|
|
Console.WriteLine (" Row count SHOULD BE 1, VALUE IS {0}", reader.GetValue (0));
|
|
reader.Close ();
|
|
|
|
Console.WriteLine (" Rolling back transaction ...");
|
|
|
|
transaction.Rollback ();
|
|
|
|
select = connection.CreateCommand ();
|
|
select.CommandText = "SELECT COUNT(*) FROM EMP WHERE EMPNO = 8787";
|
|
|
|
reader = select.ExecuteReader ();
|
|
reader.Read ();
|
|
Console.WriteLine (" Row count SHOULD BE 0, VALUE IS {0}", reader.GetValue (0));
|
|
reader.Close ();
|
|
}
|
|
|
|
static void CommitTest (OracleConnection connection)
|
|
{
|
|
OracleTransaction transaction = connection.BeginTransaction ();
|
|
|
|
OracleCommand insert = connection.CreateCommand ();
|
|
insert.Transaction = transaction;
|
|
insert.CommandText = "INSERT INTO EMP (EMPNO, ENAME, JOB) VALUES (8787, 'T Coleman', 'Monoist')";
|
|
|
|
Console.WriteLine (" Inserting record ...");
|
|
|
|
insert.ExecuteNonQuery ();
|
|
|
|
OracleCommand select = connection.CreateCommand ();
|
|
select.CommandText = "SELECT COUNT(*) FROM EMP WHERE EMPNO = 8787";
|
|
select.Transaction = transaction;
|
|
|
|
Console.WriteLine (" Row count SHOULD BE 1, VALUE IS {0}", select.ExecuteScalar ());
|
|
|
|
Console.WriteLine (" Committing transaction ...");
|
|
|
|
transaction.Commit ();
|
|
|
|
select = connection.CreateCommand ();
|
|
select.CommandText = "SELECT COUNT(*) FROM EMP WHERE EMPNO = 8787";
|
|
|
|
Console.WriteLine ("Row count SHOULD BE 1, VALUE IS {0}", select.ExecuteScalar ());
|
|
transaction = connection.BeginTransaction ();
|
|
OracleCommand delete = connection.CreateCommand ();
|
|
delete.Transaction = transaction;
|
|
delete.CommandText = "DELETE FROM EMP WHERE EMPNO = 8787";
|
|
delete.ExecuteNonQuery ();
|
|
transaction.Commit ();
|
|
}
|
|
|
|
public static void ParameterTest2 (OracleConnection connection)
|
|
{
|
|
Console.WriteLine(" Setting NLS_DATE_FORMAT...");
|
|
|
|
OracleCommand cmd2 = connection.CreateCommand();
|
|
cmd2.CommandText = "ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'";
|
|
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" Drop table MONO_TEST_TABLE2...");
|
|
try {
|
|
cmd2.CommandText = "DROP TABLE MONO_TEST_TABLE7";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch(OracleException oe1) {
|
|
// ignore if table already exists
|
|
}
|
|
|
|
Console.WriteLine(" Create table MONO_TEST_TABLE7...");
|
|
|
|
cmd2.CommandText = "CREATE TABLE MONO_TEST_TABLE7(" +
|
|
" COL1 VARCHAR2(8) NOT NULL, " +
|
|
" COL2 VARCHAR2(32), " +
|
|
" COL3 NUMBER(18,2), " +
|
|
" COL4 NUMBER(18,2), " +
|
|
" COL5 DATE NOT NULL, " +
|
|
" COL6 DATE, " +
|
|
" COL7 BLOB NOT NULL, " +
|
|
" COL8 BLOB, " +
|
|
" COL9 CLOB NOT NULL, " +
|
|
" COL10 CLOB " +
|
|
")";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" COMMIT...");
|
|
cmd2.CommandText = "COMMIT";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" create insert command...");
|
|
|
|
OracleTransaction trans = connection.BeginTransaction ();
|
|
OracleCommand cmd = connection.CreateCommand ();
|
|
cmd.Transaction = trans;
|
|
|
|
cmd.CommandText = "INSERT INTO MONO_TEST_TABLE7 " +
|
|
"(COL1,COL2,COL3,COL4,COL5,COL6,COL7,COL8,COL9,COL10) " +
|
|
"VALUES(:P1,:P2,:P3,:P4,:P5,:P6,:P7,:P8,:P9,:P10)";
|
|
|
|
Console.WriteLine(" Add parameters...");
|
|
|
|
OracleParameter parm1 = cmd.Parameters.Add (":P1", OracleType.VarChar, 8);
|
|
OracleParameter parm2 = cmd.Parameters.Add (":P2", OracleType.VarChar, 32);
|
|
|
|
OracleParameter parm3 = cmd.Parameters.Add (":P3", OracleType.Number);
|
|
OracleParameter parm4 = cmd.Parameters.Add (":P4", OracleType.Number);
|
|
|
|
OracleParameter parm5 = cmd.Parameters.Add (":P5", OracleType.DateTime);
|
|
OracleParameter parm6 = cmd.Parameters.Add (":P6", OracleType.DateTime);
|
|
|
|
// FIXME: fix BLOBs and CLOBs in OracleParameter
|
|
|
|
OracleParameter parm7 = cmd.Parameters.Add (":P7", OracleType.Blob);
|
|
OracleParameter parm8 = cmd.Parameters.Add (":P8", OracleType.Blob);
|
|
|
|
OracleParameter parm9 = cmd.Parameters.Add (":P9", OracleType.Clob);
|
|
OracleParameter parm10 = cmd.Parameters.Add (":P10", OracleType.Clob);
|
|
|
|
// TODO: implement out, return, and ref parameters
|
|
|
|
string s = "Mono";
|
|
decimal d = 123456789012345.678M;
|
|
DateTime dt = DateTime.Now;
|
|
|
|
string clob = "Clob";
|
|
byte[] blob = new byte[] { 0x31, 0x32, 0x33, 0x34, 0x35 };
|
|
|
|
Console.WriteLine(" Set Values...");
|
|
|
|
parm1.Value = s;
|
|
parm2.Value = DBNull.Value;
|
|
|
|
parm3.Value = d;
|
|
parm4.Value = DBNull.Value;
|
|
|
|
parm5.Value = dt;
|
|
parm6.Value = DBNull.Value;
|
|
|
|
parm7.Value = blob;
|
|
parm8.Value = DBNull.Value;
|
|
|
|
parm9.Value = clob;
|
|
parm10.Value = DBNull.Value;
|
|
|
|
Console.WriteLine(" ExecuteNonQuery...");
|
|
|
|
cmd.ExecuteNonQuery ();
|
|
trans.Commit();
|
|
}
|
|
|
|
public static void ParameterTest (OracleConnection connection)
|
|
{
|
|
Console.WriteLine(" Setting NLS_DATE_FORMAT...");
|
|
|
|
OracleCommand cmd2 = connection.CreateCommand();
|
|
cmd2.CommandText = "ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'";
|
|
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" Drop table MONO_TEST_TABLE2...");
|
|
try {
|
|
cmd2.CommandText = "DROP TABLE MONO_TEST_TABLE7";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch(OracleException oe1) {
|
|
// ignore if table already exists
|
|
}
|
|
|
|
Console.WriteLine(" Create table MONO_TEST_TABLE7...");
|
|
|
|
cmd2.CommandText = "CREATE TABLE MONO_TEST_TABLE7(" +
|
|
" COL1 VARCHAR2(8) NOT NULL, " +
|
|
" COL2 VARCHAR2(32), " +
|
|
" COL3 NUMBER(18,2) NOT NULL, " +
|
|
" COL4 NUMBER(18,2), " +
|
|
" COL5 DATE NOT NULL, " +
|
|
" COL6 DATE, " +
|
|
" COL7 BLOB NOT NULL, " +
|
|
" COL8 BLOB, " +
|
|
" COL9 CLOB NOT NULL, " +
|
|
" COL10 CLOB " +
|
|
")";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" COMMIT...");
|
|
cmd2.CommandText = "COMMIT";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" create insert command...");
|
|
|
|
OracleTransaction trans = connection.BeginTransaction ();
|
|
OracleCommand cmd = connection.CreateCommand ();
|
|
cmd.Transaction = trans;
|
|
|
|
cmd.CommandText = "INSERT INTO MONO_TEST_TABLE7 " +
|
|
"(COL1,COL2,COL3,COL4,COL5,COL6,COL7,COL8,COL9,COL10) " +
|
|
"VALUES(:P1,:P2,:P3,:P4,:P5,:P6,:P7,:P8,:P9,:P10)";
|
|
|
|
Console.WriteLine(" Add parameters...");
|
|
|
|
OracleParameter parm1 = cmd.Parameters.Add (":P1", OracleType.VarChar, 8);
|
|
OracleParameter parm2 = cmd.Parameters.Add (":P2", OracleType.VarChar, 32);
|
|
|
|
OracleParameter parm3 = cmd.Parameters.Add (":P3", OracleType.Number);
|
|
OracleParameter parm4 = cmd.Parameters.Add (":P4", OracleType.Number);
|
|
|
|
OracleParameter parm5 = cmd.Parameters.Add (":P5", OracleType.DateTime);
|
|
OracleParameter parm6 = cmd.Parameters.Add (":P6", OracleType.DateTime);
|
|
|
|
// FIXME: fix BLOBs and CLOBs in OracleParameter
|
|
|
|
OracleParameter parm7 = cmd.Parameters.Add (":P7", OracleType.Blob);
|
|
OracleParameter parm8 = cmd.Parameters.Add (":P8", OracleType.Blob);
|
|
|
|
OracleParameter parm9 = cmd.Parameters.Add (":P9", OracleType.Clob);
|
|
OracleParameter parm10 = cmd.Parameters.Add (":P10", OracleType.Clob);
|
|
|
|
// TODO: implement out, return, and ref parameters
|
|
|
|
string s = "Mono";
|
|
decimal d = 123456789012345.678M;
|
|
DateTime dt = DateTime.Now;
|
|
|
|
string clob = "Clob";
|
|
byte[] blob = new byte[] { 0x31, 0x32, 0x33, 0x34, 0x35 };
|
|
|
|
Console.WriteLine(" Set Values...");
|
|
|
|
parm1.Value = s;
|
|
parm2.Value = DBNull.Value;
|
|
|
|
parm3.Value = d;
|
|
parm4.Value = DBNull.Value;
|
|
|
|
parm5.Value = dt;
|
|
parm6.Value = DBNull.Value;
|
|
|
|
parm7.Value = blob;
|
|
parm8.Value = DBNull.Value;
|
|
|
|
parm9.Value = clob;
|
|
parm10.Value = DBNull.Value;
|
|
|
|
Console.WriteLine(" ExecuteNonQuery...");
|
|
|
|
cmd.ExecuteNonQuery ();
|
|
trans.Commit();
|
|
}
|
|
|
|
public static void CLOBTest (OracleConnection connection)
|
|
{
|
|
Console.WriteLine (" BEGIN TRANSACTION ...");
|
|
|
|
OracleTransaction transaction = connection.BeginTransaction ();
|
|
|
|
Console.WriteLine (" Drop table CLOBTEST ...");
|
|
try {
|
|
OracleCommand cmd2 = connection.CreateCommand ();
|
|
cmd2.Transaction = transaction;
|
|
cmd2.CommandText = "DROP TABLE CLOBTEST";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch (OracleException oe1) {
|
|
// ignore if table already exists
|
|
}
|
|
|
|
Console.WriteLine (" CREATE TABLE ...");
|
|
|
|
OracleCommand create = connection.CreateCommand ();
|
|
create.Transaction = transaction;
|
|
create.CommandText = "CREATE TABLE CLOBTEST (CLOB_COLUMN CLOB)";
|
|
create.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine (" INSERT RECORD ...");
|
|
|
|
OracleCommand insert = connection.CreateCommand ();
|
|
insert.Transaction = transaction;
|
|
insert.CommandText = "INSERT INTO CLOBTEST VALUES (EMPTY_CLOB())";
|
|
insert.ExecuteNonQuery ();
|
|
|
|
OracleCommand select = connection.CreateCommand ();
|
|
select.Transaction = transaction;
|
|
select.CommandText = "SELECT CLOB_COLUMN FROM CLOBTEST FOR UPDATE";
|
|
Console.WriteLine (" SELECTING A CLOB (CHARACTER) VALUE FROM CLOBTEST");
|
|
|
|
OracleDataReader reader = select.ExecuteReader ();
|
|
if (!reader.Read ())
|
|
Console.WriteLine ("ERROR: RECORD NOT FOUND");
|
|
|
|
Console.WriteLine (" TESTING OracleLob OBJECT ...");
|
|
OracleLob lob = reader.GetOracleLob (0);
|
|
Console.WriteLine (" LENGTH: {0}", lob.Length);
|
|
Console.WriteLine (" CHUNK SIZE: {0}", lob.ChunkSize);
|
|
|
|
UnicodeEncoding encoding = new UnicodeEncoding ();
|
|
|
|
byte[] value = new byte [lob.Length * 2];
|
|
|
|
Console.WriteLine (" CURRENT POSITION: {0}", lob.Position);
|
|
Console.WriteLine (" UPDATING VALUE TO 'TEST ME!'");
|
|
value = encoding.GetBytes ("TEST ME!");
|
|
lob.Write (value, 0, value.Length);
|
|
|
|
Console.WriteLine (" CURRENT POSITION: {0}", lob.Position);
|
|
Console.WriteLine (" RE-READ VALUE...");
|
|
lob.Seek (1, SeekOrigin.Begin);
|
|
|
|
Console.WriteLine (" CURRENT POSITION: {0}", lob.Position);
|
|
value = new byte [lob.Length * 2];
|
|
lob.Read (value, 0, value.Length);
|
|
Console.WriteLine (" VALUE: {0}", encoding.GetString (value));
|
|
Console.WriteLine (" CURRENT POSITION: {0}", lob.Position);
|
|
|
|
Console.WriteLine (" CLOSE OracleLob...");
|
|
lob.Close ();
|
|
|
|
Console.WriteLine (" CLOSING READER...");
|
|
|
|
reader.Close ();
|
|
transaction.Commit ();
|
|
}
|
|
|
|
public static void BLOBTest (OracleConnection connection)
|
|
{
|
|
Console.WriteLine (" BEGIN TRANSACTION ...");
|
|
|
|
OracleTransaction transaction = connection.BeginTransaction ();
|
|
|
|
Console.WriteLine (" Drop table BLOBTEST ...");
|
|
try {
|
|
OracleCommand cmd2 = connection.CreateCommand ();
|
|
cmd2.Transaction = transaction;
|
|
cmd2.CommandText = "DROP TABLE BLOBTEST";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch (OracleException oe1) {
|
|
// ignore if table already exists
|
|
}
|
|
|
|
Console.WriteLine (" CREATE TABLE ...");
|
|
|
|
OracleCommand create = connection.CreateCommand ();
|
|
create.Transaction = transaction;
|
|
create.CommandText = "CREATE TABLE BLOBTEST (BLOB_COLUMN BLOB)";
|
|
create.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine (" INSERT RECORD ...");
|
|
|
|
OracleCommand insert = connection.CreateCommand ();
|
|
insert.Transaction = transaction;
|
|
insert.CommandText = "INSERT INTO BLOBTEST VALUES (EMPTY_BLOB())";
|
|
insert.ExecuteNonQuery ();
|
|
|
|
OracleCommand select = connection.CreateCommand ();
|
|
select.Transaction = transaction;
|
|
select.CommandText = "SELECT BLOB_COLUMN FROM BLOBTEST FOR UPDATE";
|
|
Console.WriteLine (" SELECTING A BLOB (Binary) VALUE FROM BLOBTEST");
|
|
|
|
OracleDataReader reader = select.ExecuteReader ();
|
|
if (!reader.Read ())
|
|
Console.WriteLine ("ERROR: RECORD NOT FOUND");
|
|
|
|
Console.WriteLine (" TESTING OracleLob OBJECT ...");
|
|
OracleLob lob = reader.GetOracleLob (0);
|
|
|
|
byte[] value = null;
|
|
string bvalue = "";
|
|
|
|
Console.WriteLine (" UPDATING VALUE");
|
|
|
|
byte[] bytes = new byte[6];
|
|
bytes[0] = 0x31;
|
|
bytes[1] = 0x32;
|
|
bytes[2] = 0x33;
|
|
bytes[3] = 0x34;
|
|
bytes[4] = 0x35;
|
|
bytes[5] = 0x36;
|
|
|
|
lob.Write (bytes, 0, bytes.Length);
|
|
|
|
Console.WriteLine (" CURRENT POSITION: {0}", lob.Position);
|
|
Console.WriteLine (" RE-READ VALUE...");
|
|
lob.Seek (1, SeekOrigin.Begin);
|
|
|
|
Console.WriteLine (" CURRENT POSITION: {0}", lob.Position);
|
|
value = new byte [lob.Length];
|
|
lob.Read (value, 0, value.Length);
|
|
|
|
bvalue = "";
|
|
if (value.GetType ().ToString ().Equals ("System.Byte[]"))
|
|
bvalue = GetHexString (value);
|
|
Console.WriteLine (" Bytes: " + bvalue);
|
|
|
|
Console.WriteLine (" CURRENT POSITION: {0}", lob.Position);
|
|
|
|
Console.WriteLine (" CLOSE OracleLob...");
|
|
lob.Close ();
|
|
|
|
Console.WriteLine (" CLOSING READER...");
|
|
|
|
reader.Close ();
|
|
transaction.Commit ();
|
|
}
|
|
|
|
static void Wait(string msg)
|
|
{
|
|
Console.WriteLine(msg);
|
|
if (msg.Equals(""))
|
|
Console.WriteLine("Waiting... Press Enter to continue...");
|
|
Console.ReadLine();
|
|
}
|
|
|
|
// use this function to read a byte array into a string
|
|
// for easy display of binary data, such as, a BLOB value
|
|
public static string GetHexString (byte[] bytes)
|
|
{
|
|
string bvalue = "";
|
|
|
|
StringBuilder sb2 = new StringBuilder();
|
|
for (int z = 0; z < bytes.Length; z++) {
|
|
byte byt = bytes[z];
|
|
sb2.Append (byt.ToString("x"));
|
|
}
|
|
if (sb2.Length > 0)
|
|
bvalue = "0x" + sb2.ToString ();
|
|
|
|
return bvalue;
|
|
}
|
|
|
|
static void StoredProcedureTest1 (OracleConnection con)
|
|
{
|
|
// test stored procedure with no parameters
|
|
|
|
|
|
OracleCommand cmd2 = con.CreateCommand ();
|
|
|
|
Console.WriteLine(" Drop table MONO_TEST_TABLE1...");
|
|
try {
|
|
cmd2.CommandText = "DROP TABLE MONO_TEST_TABLE1";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch(OracleException oe1) {
|
|
// ignore if table did not exist
|
|
}
|
|
|
|
Console.WriteLine(" Drop procedure SP_TEST1...");
|
|
try {
|
|
cmd2.CommandText = "DROP PROCEDURE SP_TEST1";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch(OracleException oe1) {
|
|
// ignore if procedure did not exist
|
|
}
|
|
|
|
Console.WriteLine(" Create table MONO_TEST_TABLE1...");
|
|
cmd2.CommandText = "CREATE TABLE MONO_TEST_TABLE1 (" +
|
|
" COL1 VARCHAR2(8), "+
|
|
" COL2 VARCHAR2(32))";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" Create stored procedure SP_TEST1...");
|
|
cmd2.CommandText = "CREATE PROCEDURE SP_TEST1 " +
|
|
" IS " +
|
|
" BEGIN " +
|
|
" INSERT INTO MONO_TEST_TABLE1 (COL1,COL2) VALUES ('aaa','bbbb');" +
|
|
" COMMIT;" +
|
|
" END;";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine("COMMIT...");
|
|
cmd2.CommandText = "COMMIT";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" Call stored procedure sp_test1...");
|
|
OracleCommand cmd3 = con.CreateCommand ();
|
|
cmd3.CommandType = CommandType.StoredProcedure;
|
|
cmd3.CommandText = "sp_test1";
|
|
cmd3.ExecuteNonQuery ();
|
|
}
|
|
|
|
static void StoredProcedureTest2 (OracleConnection con)
|
|
{
|
|
// test stored procedure with 2 parameters
|
|
|
|
Console.WriteLine(" Drop table MONO_TEST_TABLE2...");
|
|
OracleCommand cmd2 = con.CreateCommand ();
|
|
|
|
try {
|
|
cmd2.CommandText = "DROP TABLE MONO_TEST_TABLE2";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch(OracleException oe1) {
|
|
// ignore if table already exists
|
|
}
|
|
|
|
Console.WriteLine(" Drop procedure SP_TEST2...");
|
|
try {
|
|
cmd2.CommandText = "DROP PROCEDURE SP_TEST2";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch(OracleException oe1) {
|
|
// ignore if table already exists
|
|
}
|
|
|
|
Console.WriteLine(" Create table MONO_TEST_TABLE2...");
|
|
|
|
cmd2.CommandText = "CREATE TABLE MONO_TEST_TABLE2 (" +
|
|
" COL1 VARCHAR2(8), "+
|
|
" COL2 VARCHAR2(32))";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" Create stored procedure SP_TEST2...");
|
|
cmd2.CommandText = "CREATE PROCEDURE SP_TEST2(parm1 VARCHAR2,parm2 VARCHAR2) " +
|
|
" IS " +
|
|
" BEGIN " +
|
|
" INSERT INTO MONO_TEST_TABLE2 (COL1,COL2) VALUES (parm1,parm2);" +
|
|
" COMMIT;" +
|
|
" END;";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" COMMIT...");
|
|
cmd2.CommandText = "COMMIT";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" Call stored procedure SP_TEST2 with two parameters...");
|
|
OracleCommand cmd3 = con.CreateCommand ();
|
|
cmd3.CommandType = CommandType.StoredProcedure;
|
|
cmd3.CommandText = "sp_test2";
|
|
|
|
OracleParameter myParameter1 = new OracleParameter("parm1", OracleType.VarChar);
|
|
myParameter1.Value = "yyy13";
|
|
myParameter1.Size = 8;
|
|
myParameter1.Direction = ParameterDirection.Input;
|
|
|
|
OracleParameter myParameter2 = new OracleParameter("parm2", OracleType.VarChar);
|
|
myParameter2.Value = "iii13";
|
|
myParameter2.Size = 32;
|
|
myParameter2.Direction = ParameterDirection.Input;
|
|
|
|
cmd3.Parameters.Add (myParameter1);
|
|
cmd3.Parameters.Add (myParameter2);
|
|
|
|
cmd3.ExecuteNonQuery ();
|
|
}
|
|
|
|
static void OutParmTest1 (OracleConnection con)
|
|
{
|
|
// test stored procedure with 2 parameters
|
|
// 1. input varchar2
|
|
// 2. output varchar
|
|
|
|
OracleCommand cmd2 = null;
|
|
Console.WriteLine(" Drop procedure SP_OUTPUTPARMTEST1...");
|
|
try {
|
|
cmd2 = con.CreateCommand ();
|
|
cmd2.CommandText = "DROP PROCEDURE SP_OUTPUTPARMTEST1";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch(OracleException oe1) {
|
|
// ignore if table already exists
|
|
}
|
|
|
|
Console.WriteLine(" Create stored procedure SP_OUTPUTPARMTEST1...");
|
|
// stored procedure concatenates strings
|
|
cmd2.CommandText =
|
|
"CREATE OR REPLACE PROCEDURE SP_TESTOUTPARM1(parm1 IN VARCHAR2,parm2 OUT VARCHAR2) " +
|
|
"IS " +
|
|
"BEGIN " +
|
|
" parm2 := 'one' || parm1 || 'three';" +
|
|
"END;";
|
|
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" COMMIT...");
|
|
cmd2.CommandText = "COMMIT";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" Call stored procedure SP_TESTOUTPARM1 with two parameters...");
|
|
OracleCommand cmd3 = con.CreateCommand ();
|
|
cmd3.CommandType = CommandType.Text;
|
|
cmd3.CommandText =
|
|
"BEGIN " +
|
|
" SP_TESTOUTPARM1(:p1, :p2);" +
|
|
"END;";
|
|
OracleParameter myParameter1 = new OracleParameter("p1", OracleType.VarChar);
|
|
myParameter1.Value = "two";
|
|
myParameter1.Size = 4;
|
|
myParameter1.Direction = ParameterDirection.Input;
|
|
|
|
OracleParameter myParameter2 = new OracleParameter("p2", OracleType.VarChar);
|
|
myParameter2.Size = 12;
|
|
myParameter2.Direction = ParameterDirection.Output;
|
|
|
|
cmd3.Parameters.Add (myParameter1);
|
|
cmd3.Parameters.Add (myParameter2);
|
|
|
|
cmd3.ExecuteNonQuery ();
|
|
string outValue = (string) myParameter2.Value;
|
|
Console.WriteLine (" Out Value should be: onetwothree");
|
|
Console.WriteLine (" Out Value: " + outValue);
|
|
}
|
|
|
|
static void OutParmTest2 (OracleConnection con)
|
|
{
|
|
// test stored procedure with 2 parameters
|
|
// 1. input number(18,2)
|
|
// 2. output number(18,2)
|
|
|
|
OracleCommand cmd2 = null;
|
|
Console.WriteLine(" Drop procedure SP_OUTPUTPARMTEST2...");
|
|
try {
|
|
cmd2 = con.CreateCommand ();
|
|
cmd2.CommandText = "DROP PROCEDURE SP_OUTPUTPARMTEST2";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch(OracleException oe1) {
|
|
// ignore if table already exists
|
|
}
|
|
|
|
Console.WriteLine(" Create stored procedure SP_OUTPUTPARMTEST2...");
|
|
|
|
// stored procedure addes two numbers
|
|
cmd2.CommandText =
|
|
"CREATE OR REPLACE PROCEDURE SP_TESTOUTPARM2(parm1 IN NUMBER,parm2 OUT NUMBER) " +
|
|
"IS " +
|
|
"BEGIN " +
|
|
" parm2 := parm1 + 3; " +
|
|
"END;";
|
|
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" COMMIT...");
|
|
cmd2.CommandText = "COMMIT";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" Call stored procedure SP_TESTOUTPARM2 with two parameters...");
|
|
OracleCommand cmd3 = con.CreateCommand ();
|
|
cmd3.CommandType = CommandType.Text;
|
|
cmd3.CommandText =
|
|
"BEGIN " +
|
|
" SP_TESTOUTPARM2(:p1, :p2);" +
|
|
"END;";
|
|
OracleParameter myParameter1 = new OracleParameter("p1", OracleType.Number);
|
|
myParameter1.Value = 2;
|
|
myParameter1.Direction = ParameterDirection.Input;
|
|
|
|
OracleParameter myParameter2 = new OracleParameter("p2", OracleType.Number);
|
|
myParameter2.Direction = ParameterDirection.Output;
|
|
|
|
cmd3.Parameters.Add (myParameter1);
|
|
cmd3.Parameters.Add (myParameter2);
|
|
|
|
cmd3.ExecuteNonQuery ();
|
|
decimal outValue = (decimal) myParameter2.Value;
|
|
Console.WriteLine (" Out Value should be: 5");
|
|
Console.WriteLine (" Out Value: {0}", outValue);
|
|
}
|
|
|
|
static void OutParmTest3 (OracleConnection con)
|
|
{
|
|
// test stored procedure with 2 parameters
|
|
// 1. input date
|
|
// 2. output date
|
|
|
|
OracleCommand cmd2 = null;
|
|
Console.WriteLine(" Drop procedure SP_OUTPUTPARMTEST3...");
|
|
try {
|
|
cmd2 = con.CreateCommand ();
|
|
cmd2.CommandText = "DROP PROCEDURE SP_OUTPUTPARMTEST3";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch(OracleException oe1) {
|
|
// ignore if table already exists
|
|
}
|
|
|
|
Console.WriteLine(" Create stored procedure SP_OUTPUTPARMTEST3...");
|
|
|
|
// stored procedure adds 3 days to date
|
|
cmd2.CommandText =
|
|
"CREATE OR REPLACE PROCEDURE SP_TESTOUTPARM3(parm1 IN DATE,parm2 OUT DATE) " +
|
|
"IS " +
|
|
"BEGIN " +
|
|
" parm2 := parm1 + 3; " +
|
|
"END;";
|
|
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" COMMIT...");
|
|
cmd2.CommandText = "COMMIT";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" Call stored procedure SP_TESTOUTPARM3 with two parameters...");
|
|
OracleCommand cmd3 = con.CreateCommand ();
|
|
cmd3.CommandType = CommandType.Text;
|
|
cmd3.CommandText =
|
|
"BEGIN " +
|
|
" SP_TESTOUTPARM3(:p1, :p2);" +
|
|
"END;";
|
|
OracleParameter myParameter1 = new OracleParameter("p1", OracleType.DateTime);
|
|
myParameter1.Value = new DateTime(2004,12,15);
|
|
myParameter1.Direction = ParameterDirection.Input;
|
|
|
|
OracleParameter myParameter2 = new OracleParameter("p2", OracleType.DateTime);
|
|
myParameter2.Direction = ParameterDirection.Output;
|
|
|
|
cmd3.Parameters.Add (myParameter1);
|
|
cmd3.Parameters.Add (myParameter2);
|
|
|
|
cmd3.ExecuteNonQuery ();
|
|
DateTime outValue = (DateTime) myParameter2.Value;
|
|
Console.WriteLine (" Out Value should be: 2004-12-18");
|
|
Console.WriteLine (" Out Value: {0}", outValue.ToString ("yyyy-mm-dd"));
|
|
}
|
|
|
|
static void ShowConnectionProperties (OracleConnection con)
|
|
{
|
|
try {
|
|
Console.WriteLine ("ServerVersion: " + con.ServerVersion);
|
|
} catch (System.InvalidOperationException ioe) {
|
|
Console.WriteLine ("InvalidOperationException caught.");
|
|
Console.WriteLine ("Message: " + ioe.Message);
|
|
}
|
|
|
|
Console.WriteLine ("DataSource: " + con.DataSource);
|
|
}
|
|
|
|
static void NullAggregateTest (OracleConnection con)
|
|
{
|
|
Console.WriteLine(" Drop table MONO_TEST_TABLE3...");
|
|
OracleCommand cmd2 = con.CreateCommand ();
|
|
|
|
try {
|
|
cmd2.CommandText = "DROP TABLE MONO_TEST_TABLE3";
|
|
cmd2.ExecuteNonQuery ();
|
|
}
|
|
catch(OracleException oe1) {
|
|
// ignore if table already exists
|
|
}
|
|
|
|
Console.WriteLine(" Create table MONO_TEST_TABLE3...");
|
|
|
|
cmd2.CommandText = "CREATE TABLE MONO_TEST_TABLE3 (" +
|
|
" COL1 VARCHAR2(8), "+
|
|
" COL2 VARCHAR2(32))";
|
|
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" Insert some rows into table MONO_TEST_TABLE3...");
|
|
cmd2.CommandText = "INSERT INTO MONO_TEST_TABLE3 (COL1, COL2) VALUES ('1','one')";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
cmd2.CommandText = "INSERT INTO MONO_TEST_TABLE3 (COL1, COL2) VALUES ('1','uno')";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
cmd2.CommandText = "INSERT INTO MONO_TEST_TABLE3 (COL1, COL2) VALUES ('3','three')";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
cmd2.CommandText = "INSERT INTO MONO_TEST_TABLE3 (COL1, COL2) VALUES ('3', null)";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
cmd2.CommandText = "INSERT INTO MONO_TEST_TABLE3 (COL1, COL2) VALUES ('3','few')";
|
|
cmd2.ExecuteNonQuery ();
|
|
|
|
Console.WriteLine(" ExecuteScalar...");
|
|
cmd2.CommandText = "SELECT COL1, COUNT(COL2) AS MAX_COL1 FROM MONO_TEST_TABLE3 GROUP BY COL1";
|
|
OracleDataReader reader = cmd2.ExecuteReader ();
|
|
Console.WriteLine (" Read...");
|
|
while (reader.Read ()) {
|
|
|
|
object obj0 = reader.GetValue (0);
|
|
Console.WriteLine("Value 0: " + obj0.ToString ());
|
|
object obj1 = reader.GetValue (1);
|
|
Console.WriteLine("Value 1: " + obj1.ToString ());
|
|
|
|
Console.WriteLine (" Read...");
|
|
}
|
|
|
|
Console.WriteLine (" No more records.");
|
|
}
|
|
|
|
static void OnInfoMessage (object sender, OracleInfoMessageEventArgs e)
|
|
{
|
|
Console.WriteLine("InfoMessage Message: " + e.Message.ToString());
|
|
Console.WriteLine("InfoMessage Code: " + e.Code.ToString());
|
|
Console.WriteLine("InfoMessage Source: " + e.Source.ToString());
|
|
}
|
|
|
|
static void OnStateChange (object sender, StateChangeEventArgs e)
|
|
{
|
|
Console.WriteLine("StateChange CurrentSate:" + e.CurrentState.ToString ());
|
|
Console.WriteLine("StateChange OriginalState:" + e.OriginalState.ToString ());
|
|
}
|
|
|
|
static void RefCursorTests(OracleConnection con)
|
|
{
|
|
SetupRefCursorTests(con); // for ref cursor tests 1 thru 3
|
|
RefCursorTest1(con); // using BEGIN/END
|
|
RefCursorTest2(con); // using call
|
|
RefCursorTest3(con); // using CommandType.StoredProcedure
|
|
|
|
RefCursorTest4(con);
|
|
}
|
|
|
|
static void SetupRefCursorTests(OracleConnection con)
|
|
{
|
|
Console.WriteLine("Setup Oracle package curspkg_join...");
|
|
|
|
OracleCommand cmd = con.CreateCommand();
|
|
|
|
cmd.CommandText =
|
|
"CREATE OR REPLACE PACKAGE curspkg_join AS\n" +
|
|
"TYPE t_cursor IS REF CURSOR;\n" +
|
|
"Procedure open_join_cursor1 (n_EMPNO IN NUMBER, io_cursor IN OUT t_cursor);\n" +
|
|
"END curspkg_join;";
|
|
|
|
cmd.CommandText =
|
|
"CREATE OR REPLACE PACKAGE BODY curspkg_join AS\n" +
|
|
" Procedure open_join_cursor1 (n_EMPNO IN NUMBER, io_cursor IN OUT t_cursor)\n" +
|
|
" IS\n" +
|
|
" v_cursor t_cursor;\n" +
|
|
" BEGIN\n" +
|
|
" IF n_EMPNO <> 0 THEN\n" +
|
|
" OPEN v_cursor FOR\n" +
|
|
" SELECT EMP.EMPNO, EMP.ENAME, DEPT.DEPTNO, DEPT.DNAME\n" +
|
|
" FROM EMP, DEPT\n" +
|
|
" WHERE EMP.DEPTNO = DEPT.DEPTNO\n" +
|
|
" AND EMP.EMPNO = n_EMPNO;\n" +
|
|
"\n" +
|
|
" ELSE\n" +
|
|
" OPEN v_cursor FOR\n" +
|
|
" SELECT EMP.EMPNO, EMP.ENAME, DEPT.DEPTNO, DEPT.DNAME\n" +
|
|
" FROM EMP, DEPT\n" +
|
|
" WHERE EMP.DEPTNO = DEPT.DEPTNO;\n" +
|
|
"\n" +
|
|
" END IF;\n" +
|
|
" io_cursor := v_cursor;\n" +
|
|
" END open_join_cursor1;\n" +
|
|
"END curspkg_join;";
|
|
cmd.ExecuteNonQuery();
|
|
}
|
|
|
|
public static void RefCursorTest4(OracleConnection connection)
|
|
{
|
|
Console.WriteLine("Setup test package and data...");
|
|
OracleCommand cmddrop = connection.CreateCommand();
|
|
|
|
cmddrop.CommandText = "DROP TABLE TESTTABLE";
|
|
try {
|
|
cmddrop.ExecuteNonQuery();
|
|
}
|
|
catch(OracleException e) {
|
|
Console.WriteLine("Ignore this error: " + e.Message);
|
|
}
|
|
cmddrop.Dispose();
|
|
cmddrop = null;
|
|
|
|
OracleCommand cmd = connection.CreateCommand();
|
|
|
|
// create table TESTTABLE
|
|
cmd.CommandText =
|
|
"create table TESTTABLE (\n" +
|
|
" col1 numeric(18,0),\n" +
|
|
" col2 varchar(32),\n" +
|
|
" col3 date)";
|
|
cmd.ExecuteNonQuery();
|
|
|
|
// insert some rows into TESTTABLE
|
|
cmd.CommandText =
|
|
"insert into TESTTABLE\n" +
|
|
"(col1, col2, col3)\n" +
|
|
"values(45, 'Mono', sysdate)";
|
|
cmd.ExecuteNonQuery();
|
|
|
|
cmd.CommandText =
|
|
"insert into TESTTABLE\n" +
|
|
"(col1, col2, col3)\n" +
|
|
"values(136, 'Fun', sysdate)";
|
|
cmd.ExecuteNonQuery();
|
|
|
|
cmd.CommandText =
|
|
"insert into TESTTABLE\n" +
|
|
"(col1, col2, col3)\n" +
|
|
"values(526, 'System.Data.OracleClient', sysdate)";
|
|
cmd.ExecuteNonQuery();
|
|
|
|
cmd.CommandText = "commit";
|
|
cmd.ExecuteNonQuery();
|
|
|
|
// create Oracle package TestTablePkg
|
|
cmd.CommandText =
|
|
"CREATE OR REPLACE PACKAGE TestTablePkg\n" +
|
|
"AS\n" +
|
|
" TYPE T_CURSOR IS REF CURSOR;\n" +
|
|
"\n" +
|
|
" PROCEDURE GetData(tableCursor OUT T_CURSOR);\n" +
|
|
"END TestTablePkg;";
|
|
cmd.ExecuteNonQuery();
|
|
|
|
// create Oracle package body for package TestTablePkg
|
|
cmd.CommandText =
|
|
"CREATE OR REPLACE PACKAGE BODY TestTablePkg AS\n" +
|
|
" PROCEDURE GetData(tableCursor OUT T_CURSOR)\n" +
|
|
" IS\n" +
|
|
" BEGIN\n" +
|
|
" OPEN tableCursor FOR\n" +
|
|
" SELECT *\n" +
|
|
" FROM TestTable;\n" +
|
|
" END GetData;\n" +
|
|
"END TestTablePkg;";
|
|
cmd.ExecuteNonQuery();
|
|
|
|
cmd.Dispose();
|
|
cmd = null;
|
|
|
|
Console.WriteLine("Set up command and parameters to call stored proc...");
|
|
OracleCommand command = new OracleCommand("TestTablePkg.GetData", connection);
|
|
command.CommandType = CommandType.StoredProcedure;
|
|
OracleParameter parameter = new OracleParameter("tableCursor", OracleType.Cursor);
|
|
parameter.Direction = ParameterDirection.Output;
|
|
command.Parameters.Add(parameter);
|
|
|
|
Console.WriteLine("Execute...");
|
|
command.ExecuteNonQuery();
|
|
|
|
Console.WriteLine("Get OracleDataReader for cursor output parameter...");
|
|
OracleDataReader reader = (OracleDataReader) parameter.Value;
|
|
|
|
Console.WriteLine("Read data...");
|
|
int r = 0;
|
|
while (reader.Read()) {
|
|
Console.WriteLine("Row {0}", r);
|
|
for (int f = 0; f < reader.FieldCount; f ++) {
|
|
object val = reader.GetValue(f);
|
|
Console.WriteLine(" Field {0} Value: {1}", f, val);
|
|
}
|
|
r ++;
|
|
}
|
|
Console.WriteLine("Rows retrieved: {0}", r);
|
|
|
|
Console.WriteLine("Clean up...");
|
|
reader.Close();
|
|
reader = null;
|
|
command.Dispose();
|
|
command = null;
|
|
}
|
|
|
|
static void RefCursorTest1(OracleConnection con)
|
|
{
|
|
Console.WriteLine("Ref Cursor Test 1 - using BEGIN/END for proc - Begin...");
|
|
|
|
Console.WriteLine("Create command...");
|
|
OracleCommand cmd = new OracleCommand();
|
|
cmd.Connection = con;
|
|
|
|
cmd.CommandText =
|
|
"BEGIN\n" +
|
|
" curspkg_join.open_join_cursor1(:n_Empno,:io_cursor);\n" +
|
|
"END;";
|
|
|
|
// PL/SQL definition of stored procedure in package curspkg_join
|
|
// open_join_cursor1 (n_EMPNO IN NUMBER, io_cursor IN OUT t_cursor)
|
|
|
|
Console.WriteLine("Create parameters...");
|
|
|
|
OracleParameter parm1 = new OracleParameter("n_Empno", OracleType.Number);
|
|
parm1.Direction = ParameterDirection.Input;
|
|
parm1.Value = 7902;
|
|
|
|
OracleParameter parm2 = new OracleParameter("io_cursor", OracleType.Cursor);
|
|
parm2.Direction = ParameterDirection.Output;
|
|
|
|
cmd.Parameters.Add(parm1);
|
|
cmd.Parameters.Add(parm2);
|
|
|
|
// positional parm
|
|
//cmd.Parameters.Add(new OracleParameter("io_cursor", OracleType.Cursor)).Direction = ParameterDirection.Output;
|
|
// named parm
|
|
//cmd.Parameters.Add("n_Empno", OracleType.Number, 4).Value = 7902;
|
|
|
|
OracleDataReader reader;
|
|
Console.WriteLine("Execute Non Query...");
|
|
cmd.ExecuteNonQuery();
|
|
|
|
Console.WriteLine("Get data reader (ref cursor) from out parameter...");
|
|
reader = (OracleDataReader) cmd.Parameters["io_cursor"].Value;
|
|
|
|
int x, count;
|
|
count = 0;
|
|
|
|
Console.WriteLine("Get data from ref cursor...");
|
|
while (reader.Read()) {
|
|
for (x = 0; x < reader.FieldCount; x++)
|
|
Console.Write(reader[x] + " ");
|
|
|
|
Console.WriteLine();
|
|
count += 1;
|
|
}
|
|
Console.WriteLine(count.ToString() + " Rows Returned.");
|
|
|
|
reader.Close();
|
|
}
|
|
|
|
static void RefCursorTest2(OracleConnection con)
|
|
{
|
|
Console.WriteLine("Ref Cursor Test 2 - using call - Begin...");
|
|
|
|
Console.WriteLine("Create command...");
|
|
OracleCommand cmd = new OracleCommand();
|
|
cmd.Connection = con;
|
|
cmd.CommandText = "call curspkg_join.open_join_cursor1(:n_Empno,:io_cursor)";
|
|
|
|
// PL/SQL definition of stored procedure in package curspkg_join
|
|
// open_join_cursor1 (n_EMPNO IN NUMBER, io_cursor IN OUT t_cursor)
|
|
|
|
Console.WriteLine("Create parameters...");
|
|
|
|
OracleParameter parm1 = new OracleParameter("n_Empno", OracleType.Number);
|
|
parm1.Direction = ParameterDirection.Input;
|
|
parm1.Value = 7902;
|
|
|
|
OracleParameter parm2 = new OracleParameter("io_cursor", OracleType.Cursor);
|
|
parm2.Direction = ParameterDirection.Output;
|
|
|
|
cmd.Parameters.Add(parm1);
|
|
cmd.Parameters.Add(parm2);
|
|
|
|
// positional parm
|
|
//cmd.Parameters.Add(new OracleParameter("io_cursor", OracleType.Cursor)).Direction = ParameterDirection.Output;
|
|
// named parm
|
|
//cmd.Parameters.Add("n_Empno", OracleType.Number, 4).Value = 7902;
|
|
|
|
OracleDataReader reader;
|
|
Console.WriteLine("Execute Non Query...");
|
|
cmd.ExecuteNonQuery();
|
|
|
|
Console.WriteLine("Get data reader (ref cursor) from out parameter...");
|
|
reader = (OracleDataReader) cmd.Parameters["io_cursor"].Value;
|
|
|
|
int x, count;
|
|
count = 0;
|
|
|
|
Console.WriteLine("Get data from ref cursor...");
|
|
while (reader.Read()) {
|
|
for (x = 0; x < reader.FieldCount; x++)
|
|
Console.Write(reader[x] + " ");
|
|
|
|
Console.WriteLine();
|
|
count += 1;
|
|
}
|
|
Console.WriteLine(count.ToString() + " Rows Returned.");
|
|
|
|
reader.Close();
|
|
}
|
|
|
|
static void RefCursorTest3(OracleConnection con)
|
|
{
|
|
Console.WriteLine("Ref Cursor Test 3 - CommandType.StoredProcedure - Begin...");
|
|
|
|
Console.WriteLine("Create command...");
|
|
OracleCommand cmd = new OracleCommand();
|
|
cmd.Connection = con;
|
|
cmd.CommandText = "curspkg_join.open_join_cursor1";
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
|
|
// PL/SQL definition of stored procedure in package curspkg_join
|
|
// open_join_cursor1 (n_EMPNO IN NUMBER, io_cursor IN OUT t_cursor)
|
|
|
|
Console.WriteLine("Create parameters...");
|
|
|
|
OracleParameter parm1 = new OracleParameter("n_Empno", OracleType.Number);
|
|
parm1.Direction = ParameterDirection.Input;
|
|
parm1.Value = 7902;
|
|
|
|
OracleParameter parm2 = new OracleParameter("io_cursor", OracleType.Cursor);
|
|
parm2.Direction = ParameterDirection.Output;
|
|
|
|
cmd.Parameters.Add(parm1);
|
|
cmd.Parameters.Add(parm2);
|
|
|
|
// positional parm
|
|
//cmd.Parameters.Add(new OracleParameter("io_cursor", OracleType.Cursor)).Direction = ParameterDirection.Output;
|
|
// named parm
|
|
//cmd.Parameters.Add("n_Empno", OracleType.Number, 4).Value = 7902;
|
|
|
|
OracleDataReader reader;
|
|
Console.WriteLine("Execute Non Query...");
|
|
cmd.ExecuteNonQuery();
|
|
|
|
Console.WriteLine("Get data reader (ref cursor) from out parameter...");
|
|
reader = (OracleDataReader) cmd.Parameters["io_cursor"].Value;
|
|
|
|
int x, count;
|
|
count = 0;
|
|
|
|
Console.WriteLine("Get data from ref cursor...");
|
|
while (reader.Read()) {
|
|
for (x = 0; x < reader.FieldCount; x++)
|
|
Console.Write(reader[x] + " ");
|
|
|
|
Console.WriteLine();
|
|
count += 1;
|
|
}
|
|
Console.WriteLine(count.ToString() + " Rows Returned.");
|
|
|
|
reader.Close();
|
|
}
|
|
|
|
static void ExternalAuthenticationTest ()
|
|
{
|
|
string user = Environment.UserName;
|
|
if (!Environment.UserDomainName.Equals(String.Empty))
|
|
user = Environment.UserDomainName + "\\" + Environment.UserName;
|
|
Console.WriteLine("Environment UserDomainName and UserName: " + user);
|
|
Console.WriteLine("Open connection using external authentication...");
|
|
OracleConnection con = new OracleConnection("Data Source=palis;Integrated Security=true");
|
|
try {
|
|
con.Open();
|
|
OracleCommand cmd = con.CreateCommand();
|
|
cmd.CommandText = "SELECT USER FROM DUAL";
|
|
OracleDataReader reader = cmd.ExecuteReader();
|
|
if (reader.Read())
|
|
Console.WriteLine("User: " + reader.GetString(reader.GetOrdinal("USER")));
|
|
con.Close();
|
|
}
|
|
catch (Exception e) {
|
|
Console.WriteLine("Exception caught: " + e.Message);
|
|
Console.WriteLine("Probably not setup for external authentication.");
|
|
}
|
|
con.Dispose();
|
|
con = null;
|
|
}
|
|
|
|
public static void TestPersistSucurityInfo1()
|
|
{
|
|
Console.WriteLine("\nTestPersistSucurityInfo1 - persist security info=false");
|
|
OracleConnection con = new OracleConnection("data source=palis;user id=scott;password=tiger;persist security info=false");
|
|
Console.WriteLine("ConnectionString before open: " + con.ConnectionString);
|
|
con.Open();
|
|
Console.WriteLine("ConnectionString after open: " + con.ConnectionString);
|
|
con.Close();
|
|
Console.WriteLine("ConnectionString after close: " + con.ConnectionString);
|
|
con = null;
|
|
}
|
|
|
|
public static void TestPersistSucurityInfo2()
|
|
{
|
|
Console.WriteLine("\nTestPersistSucurityInfo2 - persist security info=true");
|
|
OracleConnection con = new OracleConnection("data source=palis;user id=scott;password=tiger;persist security info=true");
|
|
Console.WriteLine("ConnectionString before open: " + con.ConnectionString);
|
|
con.Open();
|
|
Console.WriteLine("ConnectionString after open: " + con.ConnectionString);
|
|
con.Close();
|
|
Console.WriteLine("ConnectionString after close: " + con.ConnectionString);
|
|
con = null;
|
|
}
|
|
|
|
public static void TestPersistSucurityInfo3()
|
|
{
|
|
Console.WriteLine("\nTestPersistSucurityInfo3 - use default for persist security info which is false");
|
|
OracleConnection con = new OracleConnection("data source=palis;user id=scott;password=tiger");
|
|
Console.WriteLine("ConnectionString before open: " + con.ConnectionString);
|
|
con.Open();
|
|
Console.WriteLine("ConnectionString after open: " + con.ConnectionString);
|
|
con.Close();
|
|
Console.WriteLine("ConnectionString after close: " + con.ConnectionString);
|
|
con = null;
|
|
}
|
|
|
|
public static void TestPersistSucurityInfo4()
|
|
{
|
|
Console.WriteLine("\nTestPersistSucurityInfo4 - persist security info=false with password at front");
|
|
OracleConnection con = new OracleConnection(";password=tiger;data source=palis;user id=scott;persist security info=false");
|
|
Console.WriteLine("ConnectionString before open: " + con.ConnectionString);
|
|
con.Open();
|
|
Console.WriteLine("ConnectionString after open: " + con.ConnectionString);
|
|
con.Close();
|
|
Console.WriteLine("ConnectionString after close: " + con.ConnectionString);
|
|
con = null;
|
|
}
|
|
|
|
public static void TestPersistSucurityInfo5()
|
|
{
|
|
Console.WriteLine("\nTestPersistSucurityInfo5 - persist security info=false");
|
|
OracleConnection con = new OracleConnection("data source=palis;user id=scott;password=tiger;persist security info=false");
|
|
Console.WriteLine("ConnectionString before open: " + con.ConnectionString);
|
|
con.Open();
|
|
Console.WriteLine("ConnectionString after open: " + con.ConnectionString);
|
|
Console.WriteLine("ConnectionState for con: " + con.State.ToString() + "\n");
|
|
|
|
Console.WriteLine("Clone OracleConnection...");
|
|
OracleConnection con2 = (OracleConnection) ((ICloneable) con).Clone();
|
|
|
|
Console.WriteLine("ConnectionState for con2: " + con2.State.ToString());
|
|
Console.WriteLine("con2 ConnectionString before open: " + con2.ConnectionString);
|
|
con2.Open();
|
|
Console.WriteLine("con2 ConnectionString after open: " + con2.ConnectionString);
|
|
con2.Close();
|
|
Console.WriteLine("con2 ConnectionString after close: " + con2.ConnectionString);
|
|
|
|
con.Close();
|
|
}
|
|
|
|
public static void TestPersistSucurityInfo6()
|
|
{
|
|
Console.WriteLine("\nTestPersistSucurityInfo6 - external auth using persist security info");
|
|
|
|
string user = Environment.UserName;
|
|
if (!Environment.UserDomainName.Equals(String.Empty))
|
|
user = Environment.UserDomainName + "\\" + Environment.UserName;
|
|
Console.WriteLine("Environment UserDomainName and UserName: " + user);
|
|
Console.WriteLine("Open connection using external authentication...");
|
|
OracleConnection con = new OracleConnection("Data Source=palis;Integrated Security=true");
|
|
Console.WriteLine("ConnectionString before open: " + con.ConnectionString);
|
|
try {
|
|
con.Open();
|
|
OracleCommand cmd = con.CreateCommand();
|
|
cmd.CommandText = "SELECT USER FROM DUAL";
|
|
OracleDataReader reader = cmd.ExecuteReader();
|
|
if (reader.Read())
|
|
Console.WriteLine("User: " + reader.GetString(reader.GetOrdinal("USER")));
|
|
con.Close();
|
|
Console.WriteLine("ConnectionString after close: " + con.ConnectionString);
|
|
}
|
|
catch (Exception e) {
|
|
Console.WriteLine("Exception caught: " + e.Message);
|
|
Console.WriteLine("Probably not setup for external authentication. This is fine.");
|
|
}
|
|
con.Dispose();
|
|
Console.WriteLine("ConnectionString after dispose: " + con.ConnectionString);
|
|
con = null;
|
|
Console.WriteLine("\n\n");
|
|
}
|
|
|
|
public static void ConnectionPoolingTest1 ()
|
|
{
|
|
Console.WriteLine("Start Connection Pooling Test 1...");
|
|
OracleConnection[] connections = null;
|
|
int maxCon = MAX_CONNECTIONS + 1; // add 1 more over the max connections to cause it to wait for the next available connection
|
|
int i = 0;
|
|
|
|
try {
|
|
connections = new OracleConnection[maxCon];
|
|
|
|
for (i = 0; i < maxCon; i++) {
|
|
Console.WriteLine(" Open connection: {0}", i);
|
|
connections[i] = new OracleConnection(conStr);
|
|
connections[i].Open ();
|
|
}
|
|
} catch (InvalidOperationException e) {
|
|
Console.WriteLine("Expected exception InvalidOperationException caught.");
|
|
Console.WriteLine(e);
|
|
}
|
|
|
|
for (i = 0; i < maxCon; i++) {
|
|
if (connections[i] != null) {
|
|
Console.WriteLine(" Close connection: {0}", i);
|
|
if (connections[i].State == ConnectionState.Open)
|
|
connections[i].Close ();
|
|
connections[i].Dispose ();
|
|
connections[i] = null;
|
|
}
|
|
}
|
|
|
|
connections = null;
|
|
|
|
Console.WriteLine("Done Connection Pooling Test 1.");
|
|
}
|
|
|
|
public static void ConnectionPoolingTest2 ()
|
|
{
|
|
Console.WriteLine("Start Connection Pooling Test 2...");
|
|
OracleConnection[] connections = null;
|
|
int maxCon = MAX_CONNECTIONS;
|
|
int i = 0;
|
|
|
|
connections = new OracleConnection[maxCon];
|
|
|
|
for (i = 0; i < maxCon; i++) {
|
|
Console.WriteLine(" Open connection: {0}", i);
|
|
connections[i] = new OracleConnection(conStr);
|
|
connections[i].Open ();
|
|
}
|
|
|
|
Console.WriteLine("Start another thread...");
|
|
t = new Thread(new ThreadStart(AnotherThreadProc));
|
|
t.Start ();
|
|
|
|
Console.WriteLine("Sleep...");
|
|
Thread.Sleep(100);
|
|
|
|
Console.WriteLine("Closing...");
|
|
for (i = 0; i < maxCon; i++) {
|
|
if (connections[i] != null) {
|
|
Console.WriteLine(" Close connection: {0}", i);
|
|
if (connections[i].State == ConnectionState.Open)
|
|
connections[i].Close ();
|
|
connections[i].Dispose ();
|
|
connections[i] = null;
|
|
}
|
|
}
|
|
|
|
connections = null;
|
|
}
|
|
|
|
private static void AnotherThreadProc ()
|
|
{
|
|
Console.WriteLine("Open connection via another thread...");
|
|
OracleConnection[] connections = null;
|
|
int maxCon = MAX_CONNECTIONS;
|
|
int i = 0;
|
|
|
|
connections = new OracleConnection[maxCon];
|
|
|
|
for (i = 0; i < maxCon; i++) {
|
|
Console.WriteLine(" Open connection: {0}", i);
|
|
connections[i] = new OracleConnection(conStr);
|
|
connections[i].Open ();
|
|
}
|
|
|
|
Console.WriteLine("Done Connection Pooling Test 2.");
|
|
System.Environment.Exit (0);
|
|
}
|
|
|
|
[STAThread]
|
|
static void Main(string[] args)
|
|
{
|
|
if(args.Length != 3) {
|
|
Console.WriteLine("Usage: mono TestOracleClient database userid password");
|
|
return;
|
|
}
|
|
|
|
string connectionString = String.Format(
|
|
"Data Source={0};" +
|
|
"User ID={1};" +
|
|
"Password={2}",
|
|
args[0], args[1], args[2]);
|
|
|
|
conStr = connectionString;
|
|
|
|
OracleConnection con1 = new OracleConnection();
|
|
|
|
ShowConnectionProperties (con1);
|
|
|
|
con1.ConnectionString = connectionString;
|
|
|
|
con1.InfoMessage += new OracleInfoMessageEventHandler (OnInfoMessage);
|
|
con1.StateChange += new StateChangeEventHandler (OnStateChange);
|
|
Console.WriteLine("Opening...");
|
|
con1.Open ();
|
|
Console.WriteLine("Opened.");
|
|
|
|
ShowConnectionProperties (con1);
|
|
|
|
Console.WriteLine ("Mono Oracle Test BEGIN ...");
|
|
MonoTest (con1);
|
|
Console.WriteLine ("Mono Oracle Test END ...");
|
|
|
|
Wait ("");
|
|
|
|
Console.WriteLine ("LOB Test BEGIN...");
|
|
CLOBTest (con1);
|
|
BLOBTest (con1);
|
|
Console.WriteLine ("LOB Test END.");
|
|
Wait ("");
|
|
|
|
Console.WriteLine ("Read Simple Test BEGIN - scott.emp...");
|
|
ReadSimpleTest(con1, "SELECT e.*, e.rowid FROM scott.emp e");
|
|
Console.WriteLine ("Read Simple Test END - scott.emp");
|
|
|
|
Wait ("");
|
|
|
|
Console.WriteLine ("DataAdapter Test BEGIN...");
|
|
DataAdapterTest(con1);
|
|
Console.WriteLine ("DataAdapter Test END.");
|
|
|
|
Wait ("");
|
|
|
|
Console.WriteLine ("DataAdapter Test 2 BEGIN...");
|
|
DataAdapterTest2(con1);
|
|
Console.WriteLine ("DataAdapter Test 2 END.");
|
|
|
|
Wait ("");
|
|
|
|
Console.WriteLine ("Rollback Test BEGIN...");
|
|
RollbackTest(con1);
|
|
Console.WriteLine ("Rollback Test END.");
|
|
|
|
Wait ("");
|
|
|
|
Console.WriteLine ("Commit Test BEGIN...");
|
|
CommitTest(con1);
|
|
Console.WriteLine ("Commit Test END.");
|
|
|
|
Wait ("");
|
|
|
|
Console.WriteLine ("Parameter Test BEGIN...");
|
|
ParameterTest(con1);
|
|
ReadSimpleTest(con1, "SELECT * FROM MONO_TEST_TABLE7");
|
|
Console.WriteLine ("Parameter Test END.");
|
|
|
|
Wait ("");
|
|
|
|
Console.WriteLine ("Stored Proc Test 1 BEGIN...");
|
|
StoredProcedureTest1 (con1);
|
|
ReadSimpleTest(con1, "SELECT * FROM MONO_TEST_TABLE1");
|
|
Console.WriteLine ("Stored Proc Test 1 END...");
|
|
|
|
Wait ("");
|
|
|
|
Console.WriteLine ("Stored Proc Test 2 BEGIN...");
|
|
StoredProcedureTest2 (con1);
|
|
ReadSimpleTest(con1, "SELECT * FROM MONO_TEST_TABLE2");
|
|
Console.WriteLine ("Stored Proc Test 2 END...");
|
|
|
|
Console.WriteLine ("Out Parameter and PL/SQL Block Test 1 BEGIN...");
|
|
OutParmTest1 (con1);
|
|
Console.WriteLine ("Out Parameter and PL/SQL Block Test 1 END...");
|
|
|
|
Console.WriteLine ("Out Parameter and PL/SQL Block Test 2 BEGIN...");
|
|
OutParmTest2 (con1);
|
|
Console.WriteLine ("Out Parameter and PL/SQL Block Test 2 END...");
|
|
|
|
Console.WriteLine ("Out Parameter and PL/SQL Block Test 3 BEGIN...");
|
|
OutParmTest3 (con1);
|
|
Console.WriteLine ("Out Parameter and PL/SQL Block Test 3 END...");
|
|
|
|
Wait ("");
|
|
|
|
Console.WriteLine ("Test a Non Query using Execute Reader BEGIN...");
|
|
TestNonQueryUsingExecuteReader (con1);
|
|
Console.WriteLine ("Test a Non Query using Execute Reader END...");
|
|
|
|
Wait ("");
|
|
|
|
Console.WriteLine ("Null Aggregate Warning BEGIN test...");
|
|
NullAggregateTest (con1);
|
|
Console.WriteLine ("Null Aggregate Warning END test...");
|
|
|
|
Console.WriteLine ("Ref Cursor BEGIN tests...");
|
|
RefCursorTests (con1);
|
|
Console.WriteLine ("Ref Cursor END tests...");
|
|
|
|
Console.WriteLine("Closing...");
|
|
con1.Close ();
|
|
Console.WriteLine("Closed.");
|
|
|
|
ExternalAuthenticationTest();
|
|
|
|
TestPersistSucurityInfo1();
|
|
TestPersistSucurityInfo2();
|
|
TestPersistSucurityInfo3();
|
|
TestPersistSucurityInfo4();
|
|
TestPersistSucurityInfo5();
|
|
TestPersistSucurityInfo6();
|
|
|
|
//conStr = conStr + ";pooling=true;min pool size=4;max pool size=" + MAX_CONNECTIONS.ToString ();
|
|
//ConnectionPoolingTest1 ();
|
|
//ConnectionPoolingTest2 ();
|
|
|
|
Console.WriteLine("Done.");
|
|
}
|
|
}
|
|
}
|
|
|