Files
mono/mcs/class/System.Data.OracleClient/Test/TestOracleClient.cs
T
Daniel Morgan dc0406b44d 2005-07-17 Daniel Morgan <[email protected]>
* System.Data.OracleClient/OracleCommandBuilder.cs:
    implemented a working OracleCommandBuilder based on
    current SqlCommandBuilder	

	* System.Data.OracleClient/OracleCommand.cs: added 
	placeholder for DeriveParamters

	* System.Data.OracleClient/OracleDataReader.cs:
		- sometimes trying to get records affected 
		  throws an exception
		- set BaseColumnName to the ColumnName 
		  in the Schema table
		  if the command behavior is KeyInfo
		- only try to Read if there are rows to read

	* Test/OracleAdapterTest.cs: removed file
	because adapter tests added to TestOracleClient.cs
		  
	* Test/TestOracleClient.cs: added tests
		- test ExecuteReader and records affected
		  executing a Non-Query
		- test Inserts/Updates/Deletes with a
		  DataSet, Data Adapter, and Command Builder

svn path=/trunk/mcs/; revision=47362
2005-07-17 08:23:27 +00:00

1841 lines
57 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();
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();
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();
// 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();
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 ());
}
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("Closing...");
con1.Close ();
Console.WriteLine("Closed.");
//conStr = conStr + ";pooling=true;min pool size=4;max pool size=" + MAX_CONNECTIONS.ToString ();
//ConnectionPoolingTest1 ();
//ConnectionPoolingTest2 ();
Console.WriteLine("Done.");
}
}
}