mcs/class/System.Data.OracleClient/Test/TestOracleClient.cs

   1 //
   2 // TestOracleClient.cs - Tests Sytem.Data.OracleClient
   3 //                       data provider in Mono.
   4 //
   5 // Part of managed C#/.NET library System.Data.OracleClient.dll
   6 //
   7 // Part of the Mono class libraries at
   8 // mcs/class/System.Data.OracleClient/System.Data.OracleClient.OCI
   9 //
  10 // Tests:
  11 //     Assembly: System.Data.OracleClient.dll
  12 //     Namespace: System.Data.OracleClient
  13 //
  14 // To Compile:
  15 // mcs TestOracleClient.cs /r:System.Data.dll /r:System.Data.OracleClient.dll /nowarn:0168
  16 //
  17 // Author:
  18 //     Daniel Morgan <danielmorgan@verizon.net>
  19 //
  20 // Copyright (C) Daniel Morgan, 2002, 2004-2005
  21 //
  22
  23 using System;
  24 using System.IO;
  25 using System.Runtime.InteropServices;
  26 using System.Data;
  27 using System.Data.OracleClient;
  28 using System.Text;
  29 using System.Threading;
  30
  31 namespace Test.OracleClient
  32 {
  33         public class OracleTest
  34         {
  35                 private static Thread t = null;\r
  36                 private static string conStr;\r
  37                 public static readonly int MAX_CONNECTIONS = 30; // max connections default to 100, but I will set to 30.\r
  38
  39                 public OracleTest()
  40                 {
  41
  42                 }
  43
  44                 static void MonoTest(OracleConnection con)
  45                 {
  46                         Console.WriteLine ("  Drop table MONO_ORACLE_TEST ...");
  47                         try {
  48                                 OracleCommand cmd2 = con.CreateCommand ();
  49                                 cmd2.CommandText = "DROP TABLE MONO_ORACLE_TEST";
  50                                 cmd2.ExecuteNonQuery ();
  51                         }
  52                         catch (OracleException oe1) {
  53                                 // ignore if table already exists
  54                         }
  55
  56                         OracleCommand cmd = null;
  57
  58                         Console.WriteLine("  Creating table MONO_ORACLE_TEST...");
  59                         cmd = new OracleCommand();
  60                         cmd.Connection = con;
  61                         cmd.CommandText = "CREATE TABLE MONO_ORACLE_TEST ( " +
  62                                 " varchar2_value VarChar2(32),  " +
  63                                 " long_value long, " +
  64                                 " number_whole_value Number(18), " +
  65                                 " number_scaled_value Number(18,2), " +
  66                                 " number_integer_value Integer, " +
  67                                 " float_value Float, " +
  68                                 " date_value Date, " +
  69                                 " char_value Char(32), " +
  70                                 " clob_value Clob, " +
  71                                 " blob_value Blob, " +
  72                                 " clob_empty_value Clob, " +
  73                                 " blob_empty_value Blob, " +
  74                                 " varchar2_null_value VarChar2(32),  " +
  75                                 " number_whole_null_value Number(18), " +
  76                                 " number_scaled_null_value Number(18,2), " +
  77                                 " number_integer_null_value Integer, " +
  78                                 " float_null_value Float, " +
  79                                 " date_null_value Date, " +
  80                                 " char_null_value Char(32), " +
  81                                 " clob_null_value Clob, " +
  82                                 " blob_null_value Blob " +
  83                                 ")";
  84
  85                         cmd.ExecuteNonQuery();
  86
  87                         Console.WriteLine("  Begin Trans for table MONO_ORACLE_TEST...");
  88                         OracleTransaction trans = con.BeginTransaction ();
  89
  90                         Console.WriteLine("  Inserting value into MONO_ORACLE_TEST...");
  91                         cmd = new OracleCommand();
  92                         cmd.Connection = con;
  93                         cmd.Transaction = trans;
  94                         cmd.CommandText = "INSERT INTO mono_oracle_test " +
  95                                 " ( varchar2_value,  " +
  96                                 "  long_value, " +
  97                                 "  number_whole_value, " +
  98                                 "  number_scaled_value, " +
  99                                 "  number_integer_value, " +
 100                                 "  float_value, " +
 101                                 "  date_value, " +
 102                                 "  char_value, " +
 103                                 "  clob_value, " +
 104                                 "  blob_value, " +
 105                                 "  clob_empty_value, " +
 106                                 "  blob_empty_value " +
 107                                 ") " +
 108                                 " VALUES( " +
 109                                 "  'Mono', " +
 110                                 "  'This is a LONG column', " +
 111                                 "  123, " +
 112                                 "  456.78, " +
 113                                 "  8765, " +
 114                                 "  235.2, " +
 115                                 "  TO_DATE( '2004-12-31', 'YYYY-MM-DD' ), " +
 116                                 "  'US', " +
 117                                 "  EMPTY_CLOB(), " +
 118                                 "  EMPTY_BLOB()," +
 119                                 "  EMPTY_CLOB(), " +
 120                                 "  EMPTY_BLOB()" +
 121                                 ")";
 122
 123                         cmd.ExecuteNonQuery();
 124
 125                         Console.WriteLine("  Select/Update CLOB columns on table MONO_ORACLE_TEST...");
 126
 127                         // update BLOB and CLOB columns
 128                         OracleCommand select = con.CreateCommand ();
 129                         select.Transaction = trans;
 130                         select.CommandText = "SELECT CLOB_VALUE, BLOB_VALUE FROM MONO_ORACLE_TEST FOR UPDATE";
 131                         OracleDataReader reader = select.ExecuteReader ();
 132                         if (!reader.Read ())
 133                                 Console.WriteLine ("ERROR: RECORD NOT FOUND");
 134                         // update clob_value
 135                         Console.WriteLine("     Update CLOB column on table MONO_ORACLE_TEST...");
 136                         OracleLob clob = reader.GetOracleLob (0);
 137                         byte[] bytes = null;
 138                         UnicodeEncoding encoding = new UnicodeEncoding ();
 139                         bytes = encoding.GetBytes ("Mono is fun!");
 140                         clob.Write (bytes, 0, bytes.Length);
 141                         clob.Close ();
 142                         // update blob_value
 143                         Console.WriteLine("     Update BLOB column on table MONO_ORACLE_TEST...");
 144                         OracleLob blob = reader.GetOracleLob (1);
 145                         bytes = new byte[6] { 0x31, 0x32, 0x33, 0x34, 0x35, 0x036 };
 146                         blob.Write (bytes, 0, bytes.Length);
 147                         blob.Close ();
 148
 149                         Console.WriteLine("  Commit trans for table MONO_ORACLE_TEST...");
 150                         trans.Commit ();
 151
 152                         // OracleCommand.ExecuteReader of MONO_ORACLE_TEST table
 153                         Console.WriteLine("  Read simple test for table MONO_ORACLE_TEST...");
 154                         ReadSimpleTest(con, "SELECT * FROM MONO_ORACLE_TEST");
 155
 156                         // OracleCommand.ExecuteScalar
 157                         Console.WriteLine(" -ExecuteScalar tests...");
 158                         string varchar2_value = (string) ReadScalar (con,"SELECT MAX(varchar2_value) FROM MONO_ORACLE_TEST");
 159                         Console.WriteLine("     String Value: " + varchar2_value);
 160
 161                         Console.WriteLine("  Read Scalar: number_whole_value");
 162                         decimal number_whole_value = (decimal)
 163                         ReadScalar (con,"SELECT MAX(number_whole_value) FROM MONO_ORACLE_TEST");
 164                         Console.WriteLine("     Int32 Value: " + number_whole_value.ToString());
 165
 166                         Console.WriteLine("  Read Scalar: number_scaled_value");
 167                         decimal number_scaled_value = (decimal)
 168                         ReadScalar (con,"SELECT number_scaled_value FROM MONO_ORACLE_TEST");
 169                         Console.WriteLine("     Decimal Value: " + number_scaled_value.ToString());
 170
 171                         Console.WriteLine("  Read Scalar: date_value");
 172                         DateTime date_value = (DateTime)
 173                         ReadScalar (con,"SELECT date_value FROM MONO_ORACLE_TEST");
 174                         Console.WriteLine("     DateTime Value: " + date_value.ToString());
 175
 176                         Console.WriteLine("  Read Scalar: clob_value");
 177                         string clob_value = (string)
 178                         ReadScalar (con,"SELECT clob_value FROM MONO_ORACLE_TEST");
 179                         Console.WriteLine("     CLOB Value: " + clob_value);
 180
 181                         Console.WriteLine("  Read Scalar: blob_value");
 182                         byte[] blob_value = (byte[])
 183                         ReadScalar (con,"SELECT blob_value FROM MONO_ORACLE_TEST");
 184                         string sblob_value = GetHexString (blob_value);
 185                         Console.WriteLine("     BLOB Value: " + sblob_value);
 186
 187                         // OracleCommand.ExecuteOracleScalar
 188                         Console.WriteLine(" -ExecuteOracleScalar tests...");
 189                         Console.WriteLine("  Read Oracle Scalar: varchar2_value");
 190                         ReadOracleScalar (con,"SELECT MAX(varchar2_value) FROM MONO_ORACLE_TEST");
 191
 192                         Console.WriteLine("  Read Oracle Scalar: number_whole_value");
 193                         ReadOracleScalar (con,"SELECT MAX(number_whole_value) FROM MONO_ORACLE_TEST");
 194
 195                         Console.WriteLine("  Read Oracle Scalar: number_scaled_value");
 196                         ReadOracleScalar (con,"SELECT number_scaled_value FROM MONO_ORACLE_TEST");
 197
 198                         Console.WriteLine("  Read Oracle Scalar: date_value");
 199                         ReadOracleScalar (con,"SELECT date_value FROM MONO_ORACLE_TEST");
 200
 201                         Console.WriteLine("  Read Oracle Scalar: clob_value");
 202                         ReadOracleScalar (con,"SELECT clob_value FROM MONO_ORACLE_TEST");
 203
 204                         Console.WriteLine("  Read Oracle Scalar: blob_value");
 205                         ReadOracleScalar (con,"SELECT blob_value FROM MONO_ORACLE_TEST");
 206                 }
 207
 208                 static object ReadScalar (OracleConnection con, string selectSql)
 209                 {
 210                         OracleCommand cmd = null;
 211                         cmd = con.CreateCommand();
 212                         cmd.CommandText = selectSql;
 213
 214                         object o = cmd.ExecuteScalar ();
 215
 216                         string dataType = o.GetType ().ToString ();
 217                         Console.WriteLine ("       DataType: " + dataType);
 218                         return o;
 219                 }
 220
 221                 static void ReadOracleScalar (OracleConnection con, string selectSql)
 222                 {
 223                         OracleCommand cmd = null;
 224                         cmd = con.CreateCommand();
 225                         cmd.CommandText = selectSql;
 226
 227                         object o = cmd.ExecuteOracleScalar ();
 228
 229                         string dataType = o.GetType ().ToString ();
 230                         Console.WriteLine ("       DataType: " + dataType);
 231                         if (dataType.Equals("System.Data.OracleClient.OracleLob"))
 232                                 o = ((OracleLob) o).Value;
 233                         if (o.GetType ().ToString ().Equals ("System.Byte[]"))
 234                                 o = GetHexString ((byte[])o);
 235
 236                         Console.WriteLine ("          Value: " + o.ToString ());
 237                 }
 238
 239                 static void ReadSimpleTest(OracleConnection con, string selectSql)
 240                 {
 241                         OracleCommand cmd = null;
 242                         OracleDataReader reader = null;
 243
 244                         cmd = con.CreateCommand();
 245                         cmd.CommandText = selectSql;
 246                         reader = cmd.ExecuteReader();
 247
 248                         Console.WriteLine("  Results...");
 249                         Console.WriteLine("    Schema");
 250                         DataTable table;
 251                         table = reader.GetSchemaTable();
 252                         for(int c = 0; c < reader.FieldCount; c++) {
 253                                 Console.WriteLine("  Column " + c.ToString());
 254                                 DataRow row = table.Rows[c];
 255
 256                                 string strColumnName = row["ColumnName"].ToString();
 257                                 string strBaseColumnName = row["BaseColumnName"].ToString();
 258                                 string strColumnSize = row["ColumnSize"].ToString();
 259                                 string strNumericScale = row["NumericScale"].ToString();
 260                                 string strNumericPrecision = row["NumericPrecision"].ToString();
 261                                 string strDataType = row["DataType"].ToString();
 262
 263                                 Console.WriteLine("      ColumnName: " + strColumnName);
 264                                 Console.WriteLine("      BaseColumnName: " + strBaseColumnName);
 265                                 Console.WriteLine("      ColumnSize: " + strColumnSize);
 266                                 Console.WriteLine("      NumericScale: " + strNumericScale);
 267                                 Console.WriteLine("      NumericPrecision: " + strNumericPrecision);
 268                                 Console.WriteLine("      DataType: " + strDataType);
 269                         }
 270
 271                         int r = 0;
 272                         Console.WriteLine ("    Data");
 273                         while (reader.Read ()) {
 274                                 r++;
 275                                 Console.WriteLine ("       Row: " + r.ToString ());
 276                                 for (int f = 0; f < reader.FieldCount; f++) {
 277                                         string sname = "";
 278                                         object ovalue = "";
 279                                         string svalue = "";
 280                                         string sDataType = "";
 281                                         string sFieldType = "";
 282                                         string sDataTypeName = "";
 283                                         string sOraDataType = "";
 284
 285                                         sname = reader.GetName (f);
 286
 287                                         if (reader.IsDBNull (f)) {
 288                                                 ovalue = DBNull.Value;
 289                                                 svalue = "";
 290                                                 sDataType = "DBNull.Value";
 291                                                 sOraDataType = "DBNull.Value";
 292                                         }
 293                                         else {
 294                                                 ovalue = reader.GetValue (f);
 295                                                 //ovalue = reader.GetOracleValue (f);
 296                                                 object oravalue = null;
 297
 298                                                 sDataType = ovalue.GetType ().ToString ();
 299                                                 switch (sDataType) {
 300                                                 case "System.Data.OracleClient.OracleString":
 301                                                         oravalue = ((OracleString) ovalue).Value;
 302                                                         break;
 303                                                 case "System.Data.OracleClient.OracleNumber":
 304                                                         oravalue = ((OracleNumber) ovalue).Value;
 305                                                         break;
 306                                                 case "System.Data.OracleClient.OracleLob":
 307                                                         OracleLob lob = (OracleLob) ovalue;
 308                                                         oravalue = lob.Value;
 309                                                         lob.Close ();
 310                                                         break;
 311                                                 case "System.Data.OracleClient.OracleDateTime":
 312                                                         oravalue = ((OracleDateTime) ovalue).Value;
 313                                                         break;
 314                                                 case "System.Byte[]":
 315                                                         oravalue = GetHexString((byte[])ovalue);
 316                                                         break;
 317                                                 case "System.Decimal":
 318                                                         Console.WriteLine("           *** Get Decimal, Int16, Int32, Int64, Float, Double, ...");
 319                                                         decimal dec = reader.GetDecimal (f);
 320                                                         Console.WriteLine("             GetDecimal: " + dec.ToString ());
 321
 322                                                         oravalue = (object) dec;
 323
 324                                                         try {
 325                                                                 reader.GetInt16 (f);
 326                                                         } catch (NotSupportedException e) {
 327                                                                 Console.WriteLine ("            ** Expected exception caught for GetInt16: NotSupportedException: " + e.Message);
 328                                                         }
 329
 330                                                         try {
 331                                                                 long lng = reader.GetInt64 (f);
 332                                                                 Console.WriteLine("           GetInt64: " + lng.ToString ());
 333                                                                 int n = reader.GetInt32 (f);
 334                                                                 Console.WriteLine("           GetInt32: " + n.ToString ());
 335                                                                 float flt = reader.GetFloat (f);
 336                                                                 Console.WriteLine("           GetFloat: " + flt.ToString ());
 337                                                                 double dbl = reader.GetDouble (f);
 338                                                                 Console.WriteLine("           GetDouble: " + dbl.ToString ());
 339                                                         } catch (OverflowException oe1) {
 340                                                                 Console.WriteLine ("            ** Overflow exception for numbers to big or too small: " + oe1.Message);
 341                                                                 }
 342
 343                                                         break;
 344                                                 default:
 345                                                         oravalue = ovalue.ToString ();
 346
 347                                                         break;
 348                                                 }
 349
 350                                                 sOraDataType = oravalue.GetType ().ToString ();
 351                                                 if (sOraDataType.Equals ("System.Byte[]"))
 352                                                         svalue = GetHexString ((byte[]) oravalue);
 353                                                 else
 354                                                         svalue = oravalue.ToString();
 355
 356                                         }
 357                                         sFieldType = reader.GetFieldType(f).ToString();
 358                                         sDataTypeName = reader.GetDataTypeName(f);
 359
 360                                         Console.WriteLine("           Field: " + f.ToString());
 361                                         Console.WriteLine("               Name: " + sname);
 362                                         Console.WriteLine("               Value: " + svalue);
 363                                         Console.WriteLine("               Oracle Data Type: " + sOraDataType);
 364                                         Console.WriteLine("               Data Type: " + sDataType);
 365                                         Console.WriteLine("               Field Type: " + sFieldType);
 366                                         Console.WriteLine("               Data Type Name: " + sDataTypeName);
 367                                 }
 368                         }
 369                         if(r == 0)
 370                                 Console.WriteLine("  No data returned.");
 371                 }
 372
 373                 static void DataAdapterTest (OracleConnection connection)
 374                 {
 375                         Console.WriteLine("  Create select command...");
 376                         OracleCommand command = connection.CreateCommand ();
 377                         command.CommandText = "SELECT * FROM EMP";
 378
 379                         Console.WriteLine("  Create data adapter...");
 380                         OracleDataAdapter adapter = new OracleDataAdapter (command);
 381
 382                         Console.WriteLine("  Create DataSet...");
 383                         DataSet dataSet = new DataSet ("EMP");
 384
 385                         Console.WriteLine("  Fill DataSet via data adapter...");
 386                         adapter.Fill (dataSet);
 387
 388                         Console.WriteLine("  Get DataTable...");
 389                         DataTable table = dataSet.Tables [0];
 390
 391                         Console.WriteLine("  Display each row...");
 392                         int rowCount = 0;
 393                         foreach (DataRow row in table.Rows) {
 394                                 Console.WriteLine ("    row {0}", rowCount + 1);
 395                                 for (int i = 0; i < table.Columns.Count; i += 1) {
 396                                         Console.WriteLine ("      {0}: {1}", table.Columns [i].ColumnName, row [i]);
 397                                 }
 398                                 Console.WriteLine ();
 399                                 rowCount += 1;
 400                         }
 401                 }
 402
 403                 static void RollbackTest (OracleConnection connection)
 404                 {
 405                         OracleTransaction transaction = connection.BeginTransaction ();
 406
 407                         OracleCommand insert = connection.CreateCommand ();
 408                         insert.Transaction = transaction;
 409                         insert.CommandText = "INSERT INTO EMP (EMPNO, ENAME, JOB) VALUES (8787, 'T Coleman', 'Monoist')";
 410
 411                         Console.WriteLine ("  Inserting record ...");
 412
 413                         insert.ExecuteNonQuery ();
 414
 415                         OracleCommand select = connection.CreateCommand ();
 416                         select.CommandText = "SELECT COUNT(*) FROM EMP WHERE EMPNO = 8787";
 417                         select.Transaction = transaction;
 418                         OracleDataReader reader = select.ExecuteReader ();
 419                         reader.Read ();
 420
 421                         Console.WriteLine ("  Row count SHOULD BE 1, VALUE IS {0}", reader.GetValue (0));
 422                         reader.Close ();
 423
 424                         Console.WriteLine ("  Rolling back transaction ...");
 425
 426                         transaction.Rollback ();
 427
 428                         select = connection.CreateCommand ();
 429                         select.CommandText = "SELECT COUNT(*) FROM EMP WHERE EMPNO = 8787";
 430
 431                         reader = select.ExecuteReader ();
 432                         reader.Read ();
 433                         Console.WriteLine ("  Row count SHOULD BE 0, VALUE IS {0}", reader.GetValue (0));
 434                         reader.Close ();
 435                 }
 436
 437                 static void CommitTest (OracleConnection connection)
 438                 {
 439                         OracleTransaction transaction = connection.BeginTransaction ();
 440
 441                         OracleCommand insert = connection.CreateCommand ();
 442                         insert.Transaction = transaction;
 443                         insert.CommandText = "INSERT INTO EMP (EMPNO, ENAME, JOB) VALUES (8787, 'T Coleman', 'Monoist')";
 444
 445                         Console.WriteLine ("  Inserting record ...");
 446
 447                         insert.ExecuteNonQuery ();
 448
 449                         OracleCommand select = connection.CreateCommand ();
 450                         select.CommandText = "SELECT COUNT(*) FROM EMP WHERE EMPNO = 8787";
 451                         select.Transaction = transaction;
 452
 453                         Console.WriteLine ("  Row count SHOULD BE 1, VALUE IS {0}", select.ExecuteScalar ());
 454
 455                         Console.WriteLine ("  Committing transaction ...");
 456
 457                         transaction.Commit ();
 458
 459                         select = connection.CreateCommand ();
 460                         select.CommandText = "SELECT COUNT(*) FROM EMP WHERE EMPNO = 8787";
 461
 462                         Console.WriteLine ("Row count SHOULD BE 1, VALUE IS {0}", select.ExecuteScalar ());
 463                         transaction = connection.BeginTransaction ();
 464                         OracleCommand delete = connection.CreateCommand ();
 465                         delete.Transaction = transaction;
 466                         delete.CommandText = "DELETE FROM EMP WHERE EMPNO = 8787";
 467                         delete.ExecuteNonQuery ();
 468                         transaction.Commit ();
 469                 }
 470
 471                 public static void ParameterTest (OracleConnection connection)
 472                 {
 473                         Console.WriteLine("  Setting NLS_DATE_FORMAT...");\r
 474 \r
 475                         OracleCommand cmd2 = connection.CreateCommand();\r
 476                         cmd2.CommandText = "ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'";\r
 477                 \r
 478                         cmd2.ExecuteNonQuery ();\r
 479 \r
 480                         Console.WriteLine("  Drop table MONO_TEST_TABLE2...");
 481                         try {
 482                                 cmd2.CommandText = "DROP TABLE MONO_TEST_TABLE7";
 483                                 cmd2.ExecuteNonQuery ();
 484                         }
 485                         catch(OracleException oe1) {
 486                                 // ignore if table already exists
 487                         }
 488
 489                         Console.WriteLine("  Create table MONO_TEST_TABLE7...");
 490
 491                         cmd2.CommandText = "CREATE TABLE MONO_TEST_TABLE7(" +
 492                                 " COL1 VARCHAR2(8) NOT NULL, " +
 493                                 " COL2 VARCHAR2(32), " +
 494                                 " COL3 NUMBER(18,2) NOT NULL, " +
 495                                 " COL4 NUMBER(18,2), " +
 496                                 " COL5 DATE NOT NULL, " +
 497                                 " COL6 DATE, " +
 498                                 " COL7 BLOB NOT NULL, " +
 499                                 " COL8 BLOB, " +
 500                                 " COL9 CLOB NOT NULL, " +
 501                                 " COL10 CLOB " +
 502                                 ")";
 503                         cmd2.ExecuteNonQuery ();
 504
 505                         Console.WriteLine("  COMMIT...");
 506                         cmd2.CommandText = "COMMIT";
 507                         cmd2.ExecuteNonQuery ();
 508
 509                         Console.WriteLine("  create insert command...");
 510 \r
 511                         OracleTransaction trans = connection.BeginTransaction ();\r
 512                         OracleCommand cmd = connection.CreateCommand ();\r
 513                         cmd.Transaction = trans;\r
 514
 515                         cmd.CommandText = "INSERT INTO MONO_TEST_TABLE7 " + \r
 516                                 "(COL1,COL2,COL3,COL4,COL5,COL6,COL7,COL8,COL9,COL10) " + \r
 517                                 "VALUES(:P1,:P2,:P3,:P4,:P5,:P6,:P7,:P8,:P9,:P10)";\r
 518                 \r
 519                         Console.WriteLine("  Add parameters...");\r
 520 \r
 521                         OracleParameter parm1 = cmd.Parameters.Add (":P1", OracleType.VarChar, 8);\r
 522                         OracleParameter parm2 = cmd.Parameters.Add (":P2", OracleType.VarChar, 32);\r
 523                 \r
 524                         OracleParameter parm3 = cmd.Parameters.Add (":P3", OracleType.Number);\r
 525                         OracleParameter parm4 = cmd.Parameters.Add (":P4", OracleType.Number);\r
 526                 \r
 527                         OracleParameter parm5 = cmd.Parameters.Add (":P5", OracleType.DateTime);\r
 528                         OracleParameter parm6 = cmd.Parameters.Add (":P6", OracleType.DateTime);\r
 529 \r
 530                         // FIXME: fix BLOBs and CLOBs in OracleParameter\r
 531 \r
 532                         OracleParameter parm7 = cmd.Parameters.Add (":P7", OracleType.Blob);\r
 533                         OracleParameter parm8 = cmd.Parameters.Add (":P8", OracleType.Blob);\r
 534 \r
 535                         OracleParameter parm9 = cmd.Parameters.Add (":P9", OracleType.Clob);\r
 536                         OracleParameter parm10 = cmd.Parameters.Add (":P10", OracleType.Clob);\r
 537 \r
 538                         // TODO: implement out, return, and ref parameters\r
 539 \r
 540                         string s = "Mono";\r
 541                         decimal d = 123456789012345.678M;\r
 542                         DateTime dt = DateTime.Now;\r
 543 \r
 544                         string clob = "Clob";\r
 545                         byte[] blob = new byte[] { 0x31, 0x32, 0x33, 0x34, 0x35 };\r
 546                 \r
 547                         Console.WriteLine("  Set Values...");\r
 548 \r
 549                         parm1.Value = s;\r
 550                         parm2.Value = DBNull.Value;\r
 551                 \r
 552                         parm3.Value = d;\r
 553                         parm4.Value = DBNull.Value;\r
 554                 \r
 555                         parm5.Value = dt;\r
 556                         parm6.Value = DBNull.Value;\r
 557                 \r
 558                         parm7.Value = blob;\r
 559                         parm8.Value = DBNull.Value;\r
 560 \r
 561                         parm9.Value = clob;\r
 562                         parm10.Value = DBNull.Value;\r
 563                 \r
 564                         Console.WriteLine("  ExecuteNonQuery...");\r
 565 \r
 566                         cmd.ExecuteNonQuery ();\r
 567                         trans.Commit();
 568                 }
 569
 570                 public static void CLOBTest (OracleConnection connection)
 571                 {
 572                         Console.WriteLine ("  BEGIN TRANSACTION ...");
 573
 574                         OracleTransaction transaction = connection.BeginTransaction ();
 575
 576                         Console.WriteLine ("  Drop table CLOBTEST ...");
 577                         try {
 578                                 OracleCommand cmd2 = connection.CreateCommand ();
 579                                 cmd2.Transaction = transaction;
 580                                 cmd2.CommandText = "DROP TABLE CLOBTEST";
 581                                 cmd2.ExecuteNonQuery ();
 582                         }
 583                         catch (OracleException oe1) {
 584                                 // ignore if table already exists
 585                         }
 586
 587                         Console.WriteLine ("  CREATE TABLE ...");
 588
 589                         OracleCommand create = connection.CreateCommand ();
 590                         create.Transaction = transaction;
 591                         create.CommandText = "CREATE TABLE CLOBTEST (CLOB_COLUMN CLOB)";
 592                         create.ExecuteNonQuery ();
 593
 594                         Console.WriteLine ("  INSERT RECORD ...");
 595
 596                         OracleCommand insert = connection.CreateCommand ();
 597                         insert.Transaction = transaction;
 598                         insert.CommandText = "INSERT INTO CLOBTEST VALUES (EMPTY_CLOB())";
 599                         insert.ExecuteNonQuery ();
 600
 601                         OracleCommand select = connection.CreateCommand ();
 602                         select.Transaction = transaction;
 603                         select.CommandText = "SELECT CLOB_COLUMN FROM CLOBTEST FOR UPDATE";
 604                         Console.WriteLine ("  SELECTING A CLOB (CHARACTER) VALUE FROM CLOBTEST");
 605
 606                         OracleDataReader reader = select.ExecuteReader ();
 607                         if (!reader.Read ())
 608                                 Console.WriteLine ("ERROR: RECORD NOT FOUND");
 609
 610                         Console.WriteLine ("  TESTING OracleLob OBJECT ...");
 611                         OracleLob lob = reader.GetOracleLob (0);
 612                         Console.WriteLine ("  LENGTH: {0}", lob.Length);
 613                         Console.WriteLine ("  CHUNK SIZE: {0}", lob.ChunkSize);
 614
 615                         UnicodeEncoding encoding = new UnicodeEncoding ();
 616
 617                         byte[] value = new byte [lob.Length * 2];
 618
 619                         Console.WriteLine ("  CURRENT POSITION: {0}", lob.Position);
 620                         Console.WriteLine ("  UPDATING VALUE TO 'TEST ME!'");
 621                         value = encoding.GetBytes ("TEST ME!");
 622                         lob.Write (value, 0, value.Length);
 623
 624                         Console.WriteLine ("  CURRENT POSITION: {0}", lob.Position);
 625                         Console.WriteLine ("  RE-READ VALUE...");
 626                         lob.Seek (1, SeekOrigin.Begin);
 627
 628                         Console.WriteLine ("  CURRENT POSITION: {0}", lob.Position);
 629                         value = new byte [lob.Length * 2];
 630                         lob.Read (value, 0, value.Length);
 631                         Console.WriteLine ("  VALUE: {0}", encoding.GetString (value));
 632                         Console.WriteLine ("  CURRENT POSITION: {0}", lob.Position);
 633
 634                         Console.WriteLine ("  CLOSE OracleLob...");
 635                         lob.Close ();
 636
 637                         Console.WriteLine ("  CLOSING READER...");
 638
 639                         reader.Close ();
 640                         transaction.Commit ();
 641                 }
 642
 643                 public static void BLOBTest (OracleConnection connection)
 644                 {
 645                         Console.WriteLine ("  BEGIN TRANSACTION ...");
 646
 647                         OracleTransaction transaction = connection.BeginTransaction ();
 648
 649                         Console.WriteLine ("  Drop table BLOBTEST ...");
 650                         try {
 651                                 OracleCommand cmd2 = connection.CreateCommand ();
 652                                 cmd2.Transaction = transaction;
 653                                 cmd2.CommandText = "DROP TABLE BLOBTEST";
 654                                 cmd2.ExecuteNonQuery ();
 655                         }
 656                         catch (OracleException oe1) {
 657                                 // ignore if table already exists
 658                         }
 659
 660                         Console.WriteLine ("  CREATE TABLE ...");
 661
 662                         OracleCommand create = connection.CreateCommand ();
 663                         create.Transaction = transaction;
 664                         create.CommandText = "CREATE TABLE BLOBTEST (BLOB_COLUMN BLOB)";
 665                         create.ExecuteNonQuery ();
 666
 667                         Console.WriteLine ("  INSERT RECORD ...");
 668
 669                         OracleCommand insert = connection.CreateCommand ();
 670                         insert.Transaction = transaction;
 671                         insert.CommandText = "INSERT INTO BLOBTEST VALUES (EMPTY_BLOB())";
 672                         insert.ExecuteNonQuery ();
 673
 674                         OracleCommand select = connection.CreateCommand ();
 675                         select.Transaction = transaction;
 676                         select.CommandText = "SELECT BLOB_COLUMN FROM BLOBTEST FOR UPDATE";
 677                         Console.WriteLine ("  SELECTING A BLOB (Binary) VALUE FROM BLOBTEST");
 678
 679                         OracleDataReader reader = select.ExecuteReader ();
 680                         if (!reader.Read ())
 681                                 Console.WriteLine ("ERROR: RECORD NOT FOUND");
 682
 683                         Console.WriteLine ("  TESTING OracleLob OBJECT ...");
 684                         OracleLob lob = reader.GetOracleLob (0);
 685
 686                         byte[] value = null;
 687                         string bvalue = "";
 688
 689                         Console.WriteLine ("  UPDATING VALUE");
 690
 691                         byte[] bytes = new byte[6];
 692                         bytes[0] = 0x31;
 693                         bytes[1] = 0x32;
 694                         bytes[2] = 0x33;
 695                         bytes[3] = 0x34;
 696                         bytes[4] = 0x35;
 697                         bytes[5] = 0x36;
 698
 699                         lob.Write (bytes, 0, bytes.Length);
 700
 701                         Console.WriteLine ("  CURRENT POSITION: {0}", lob.Position);
 702                         Console.WriteLine ("  RE-READ VALUE...");
 703                         lob.Seek (1, SeekOrigin.Begin);
 704
 705                         Console.WriteLine ("  CURRENT POSITION: {0}", lob.Position);
 706                         value = new byte [lob.Length];
 707                         lob.Read (value, 0, value.Length);
 708
 709                         bvalue = "";
 710                         if (value.GetType ().ToString ().Equals ("System.Byte[]"))
 711                                 bvalue = GetHexString (value);
 712                         Console.WriteLine ("  Bytes: " + bvalue);
 713
 714                         Console.WriteLine ("  CURRENT POSITION: {0}", lob.Position);
 715
 716                         Console.WriteLine ("  CLOSE OracleLob...");
 717                         lob.Close ();
 718
 719                         Console.WriteLine ("  CLOSING READER...");
 720
 721                         reader.Close ();
 722                         transaction.Commit ();
 723                 }
 724
 725                 static void Wait(string msg)
 726                 {
 727                         Console.WriteLine(msg);
 728                         if (msg.Equals(""))
 729                                 Console.WriteLine("Waiting...  Press Enter to continue...");
 730                         Console.ReadLine();
 731                 }
 732
 733                 // use this function to read a byte array into a string
 734                 // for easy display of binary data, such as, a BLOB value
 735                 public static string GetHexString (byte[] bytes)
 736                 {
 737                         string bvalue = "";
 738
 739                         StringBuilder sb2 = new StringBuilder();
 740                         for (int z = 0; z < bytes.Length; z++) {
 741                                 byte byt = bytes[z];
 742                                 sb2.Append (byt.ToString("x"));
 743                         }
 744                         if (sb2.Length > 0)
 745                                 bvalue = "0x" + sb2.ToString ();
 746
 747                         return bvalue;
 748                 }
 749
 750                 static void StoredProcedureTest1 (OracleConnection con)
 751                 {
 752                         // test stored procedure with no parameters
 753
 754
 755                         OracleCommand cmd2 = con.CreateCommand ();
 756
 757                         Console.WriteLine("  Drop table MONO_TEST_TABLE1...");
 758                         try {
 759                                 cmd2.CommandText = "DROP TABLE MONO_TEST_TABLE1";
 760                                 cmd2.ExecuteNonQuery ();
 761                         }
 762                         catch(OracleException oe1) {
 763                                 // ignore if table did not exist
 764                         }
 765
 766                         Console.WriteLine("  Drop procedure SP_TEST1...");
 767                         try {
 768                                 cmd2.CommandText = "DROP PROCEDURE SP_TEST1";
 769                                 cmd2.ExecuteNonQuery ();
 770                         }
 771                         catch(OracleException oe1) {
 772                                 // ignore if procedure did not exist
 773                         }
 774
 775                         Console.WriteLine("  Create table MONO_TEST_TABLE1...");
 776                         cmd2.CommandText = "CREATE TABLE MONO_TEST_TABLE1 (" +
 777                                         " COL1 VARCHAR2(8), "+
 778                                         " COL2 VARCHAR2(32))";
 779                         cmd2.ExecuteNonQuery ();
 780
 781                         Console.WriteLine("  Create stored procedure SP_TEST1...");
 782                         cmd2.CommandText = "CREATE PROCEDURE SP_TEST1 " +
 783                                 " IS " +
 784                                 " BEGIN " +
 785                                 "       INSERT INTO MONO_TEST_TABLE1 (COL1,COL2) VALUES ('aaa','bbbb');" +
 786                                 "       COMMIT;" +
 787                                 " END;";
 788                         cmd2.ExecuteNonQuery ();
 789
 790                         Console.WriteLine("COMMIT...");
 791                         cmd2.CommandText = "COMMIT";
 792                         cmd2.ExecuteNonQuery ();
 793
 794                         Console.WriteLine("  Call stored procedure sp_test1...");
 795                         OracleCommand cmd3 = con.CreateCommand ();\r
 796                         cmd3.CommandType = CommandType.StoredProcedure;\r
 797                         cmd3.CommandText = "sp_test1";\r
 798                         cmd3.ExecuteNonQuery ();
 799                 }
 800
 801                 static void StoredProcedureTest2 (OracleConnection con)
 802                 {
 803                         // test stored procedure with 2 parameters
 804
 805                         Console.WriteLine("  Drop table MONO_TEST_TABLE2...");
 806                         OracleCommand cmd2 = con.CreateCommand ();
 807
 808                         try {
 809                                 cmd2.CommandText = "DROP TABLE MONO_TEST_TABLE2";
 810                                 cmd2.ExecuteNonQuery ();
 811                         }
 812                         catch(OracleException oe1) {
 813                                 // ignore if table already exists
 814                         }
 815
 816                         Console.WriteLine("  Drop procedure SP_TEST2...");
 817                         try {
 818                                 cmd2.CommandText = "DROP PROCEDURE SP_TEST2";
 819                                 cmd2.ExecuteNonQuery ();
 820                         }
 821                         catch(OracleException oe1) {
 822                                 // ignore if table already exists
 823                         }
 824
 825                         Console.WriteLine("  Create table MONO_TEST_TABLE2...");
 826
 827                         cmd2.CommandText = "CREATE TABLE MONO_TEST_TABLE2 (" +
 828                                 " COL1 VARCHAR2(8), "+
 829                                 " COL2 VARCHAR2(32))";
 830                         cmd2.ExecuteNonQuery ();
 831
 832                         Console.WriteLine("  Create stored procedure SP_TEST2...");
 833                         cmd2.CommandText = "CREATE PROCEDURE SP_TEST2(parm1 VARCHAR2,parm2 VARCHAR2) " +
 834                                 " IS " +
 835                                 " BEGIN " +
 836                                 "       INSERT INTO MONO_TEST_TABLE2 (COL1,COL2) VALUES (parm1,parm2);" +
 837                                 "       COMMIT;" +
 838                                 " END;";
 839                         cmd2.ExecuteNonQuery ();
 840
 841                         Console.WriteLine("  COMMIT...");
 842                         cmd2.CommandText = "COMMIT";
 843                         cmd2.ExecuteNonQuery ();
 844
 845                         Console.WriteLine("  Call stored procedure SP_TEST2 with two parameters...");
 846                         OracleCommand cmd3 = con.CreateCommand ();\r
 847                         cmd3.CommandType = CommandType.StoredProcedure;\r
 848                         cmd3.CommandText = "sp_test2";\r
 849 \r
 850                         OracleParameter myParameter1 = new OracleParameter("parm1", OracleType.VarChar);\r
 851                         myParameter1.Value = "yyy13";\r
 852                         myParameter1.Size = 8;\r
 853                         myParameter1.Direction = ParameterDirection.Input;\r
 854                 \r
 855                         OracleParameter myParameter2 = new OracleParameter("parm2", OracleType.VarChar);\r
 856                         myParameter2.Value = "iii13";\r
 857                         myParameter2.Size = 32;\r
 858                         myParameter2.Direction = ParameterDirection.Input;\r
 859 \r
 860                         cmd3.Parameters.Add (myParameter1);\r
 861                         cmd3.Parameters.Add (myParameter2);\r
 862
 863                         cmd3.ExecuteNonQuery ();
 864                 }
 865
 866                 static void ShowConnectionProperties (OracleConnection con)
 867                 {
 868                         try {
 869                                 Console.WriteLine ("ServerVersion: " + con.ServerVersion);
 870                         } catch (System.InvalidOperationException ioe) {\r
 871                                 Console.WriteLine ("InvalidOperationException caught.");\r
 872                                 Console.WriteLine ("Message: " + ioe.Message);\r
 873                         }
 874
 875                         Console.WriteLine ("DataSource: " + con.DataSource);
 876                 }
 877
 878                 static void NullAggregateTest (OracleConnection con)
 879                 {
 880                         Console.WriteLine("  Drop table MONO_TEST_TABLE3...");
 881                         OracleCommand cmd2 = con.CreateCommand ();
 882
 883                         try {
 884                                 cmd2.CommandText = "DROP TABLE MONO_TEST_TABLE3";
 885                                 cmd2.ExecuteNonQuery ();
 886                         }
 887                         catch(OracleException oe1) {
 888                                 // ignore if table already exists
 889                         }
 890
 891                         Console.WriteLine("  Create table MONO_TEST_TABLE3...");
 892
 893                         cmd2.CommandText = "CREATE TABLE MONO_TEST_TABLE3 (" +
 894                                 " COL1 VARCHAR2(8), "+
 895                                 " COL2 VARCHAR2(32))";
 896
 897                         cmd2.ExecuteNonQuery ();
 898
 899                         Console.WriteLine("  Insert some rows into table MONO_TEST_TABLE3...");
 900                         cmd2.CommandText = "INSERT INTO MONO_TEST_TABLE3 (COL1, COL2) VALUES ('1','one')";
 901                         cmd2.ExecuteNonQuery ();
 902
 903                         cmd2.CommandText = "INSERT INTO MONO_TEST_TABLE3 (COL1, COL2) VALUES ('1','uno')";
 904                         cmd2.ExecuteNonQuery ();
 905
 906                         cmd2.CommandText = "INSERT INTO MONO_TEST_TABLE3 (COL1, COL2) VALUES ('3','three')";
 907                         cmd2.ExecuteNonQuery ();
 908
 909                         cmd2.CommandText = "INSERT INTO MONO_TEST_TABLE3 (COL1, COL2) VALUES ('3', null)";
 910                         cmd2.ExecuteNonQuery ();
 911
 912                         cmd2.CommandText = "INSERT INTO MONO_TEST_TABLE3 (COL1, COL2) VALUES ('3','few')";
 913                         cmd2.ExecuteNonQuery ();
 914
 915                         Console.WriteLine("  ExecuteScalar...");
 916                         cmd2.CommandText = "SELECT COL1, COUNT(COL2) AS MAX_COL1 FROM MONO_TEST_TABLE3 GROUP BY COL1";
 917                         OracleDataReader reader = cmd2.ExecuteReader ();
 918                         Console.WriteLine (" Read...");
 919                         while (reader.Read ()) {
 920
 921                                 object obj0 = reader.GetValue (0);
 922                                 Console.WriteLine("Value 0: " + obj0.ToString ());
 923                                 object obj1 = reader.GetValue (1);
 924                                 Console.WriteLine("Value 1: " + obj1.ToString ());
 925
 926                                 Console.WriteLine (" Read...");
 927                         }
 928
 929                         Console.WriteLine (" No more records.");
 930                 }
 931
 932                 static void OnInfoMessage (object sender, OracleInfoMessageEventArgs e) \r
 933                 {\r
 934                         Console.WriteLine("InfoMessage Message: " + e.Message.ToString());\r
 935                         Console.WriteLine("InfoMessage Code: " + e.Code.ToString());\r
 936                         Console.WriteLine("InfoMessage Source: " + e.Source.ToString());\r
 937                 }
 938
 939                 static void OnStateChange (object sender, StateChangeEventArgs e) \r
 940                 {\r
 941                         Console.WriteLine("StateChange CurrentSate:" + e.CurrentState.ToString ());\r
 942                         Console.WriteLine("StateChange OriginalState:" + e.OriginalState.ToString ());\r
 943                 }
 944
 945                 public static void ConnectionPoolingTest1 () {\r
 946                         Console.WriteLine("Start Connection Pooling Test 1...");\r
 947                         OracleConnection[] connections = null;\r
 948                         int maxCon = MAX_CONNECTIONS + 1; // add 1 more over the max connections to cause it to wait for the next available connection\r
 949                         int i = 0;\r
 950 \r
 951                         try {\r
 952                                 connections = new OracleConnection[maxCon];                     \r
 953                 \r
 954                                 for (i = 0; i < maxCon; i++) {\r
 955                                         Console.WriteLine("   Open connection: {0}", i);\r
 956                                         connections[i] = new OracleConnection(conStr);\r
 957                                         connections[i].Open ();\r
 958                                 }\r
 959                         } catch (InvalidOperationException e) {\r
 960                                 Console.WriteLine("Expected exception InvalidOperationException caught.");\r
 961                                 Console.WriteLine(e);\r
 962                         }\r
 963 \r
 964                         for (i = 0; i < maxCon; i++) {\r
 965                                 if (connections[i] != null) {\r
 966                                         Console.WriteLine("   Close connection: {0}", i);\r
 967                                         if (connections[i].State == ConnectionState.Open)\r
 968                                                 connections[i].Close ();\r
 969                                         connections[i].Dispose ();\r
 970                                         connections[i] = null;\r
 971                                 }\r
 972                         }\r
 973 \r
 974                         connections = null;\r
 975 \r
 976                         Console.WriteLine("Done Connection Pooling Test 1.");\r
 977                 }\r
 978 \r
 979                 public static void ConnectionPoolingTest2 () {\r
 980                         Console.WriteLine("Start Connection Pooling Test 2...");\r
 981                         OracleConnection[] connections = null;\r
 982                         int maxCon = MAX_CONNECTIONS;\r
 983                         int i = 0;\r
 984 \r
 985                         connections = new OracleConnection[maxCon];                     \r
 986                 \r
 987                         for (i = 0; i < maxCon; i++) {\r
 988                                 Console.WriteLine("   Open connection: {0}", i);\r
 989                                 connections[i] = new OracleConnection(conStr);\r
 990                                 connections[i].Open ();\r
 991                         }\r
 992                 \r
 993                         Console.WriteLine("Start another thread...");\r
 994                         t = new Thread(new ThreadStart(AnotherThreadProc));\r
 995                         t.Start ();\r
 996 \r
 997                         Console.WriteLine("Sleep...");\r
 998                         Thread.Sleep(100);\r
 999 \r
1000                         Console.WriteLine("Closing...");\r
1001                         for (i = 0; i < maxCon; i++) {\r
1002                                 if (connections[i] != null) {\r
1003                                         Console.WriteLine("   Close connection: {0}", i);\r
1004                                         if (connections[i].State == ConnectionState.Open)\r
1005                                                 connections[i].Close ();\r
1006                                         connections[i].Dispose ();\r
1007                                         connections[i] = null;\r
1008                                 }\r
1009                         }\r
1010 \r
1011                         connections = null;\r
1012                 }\r
1013 \r
1014                 private static void AnotherThreadProc () {\r
1015                         Console.WriteLine("Open connection via another thread...");\r
1016                         OracleConnection[] connections = null;\r
1017                         int maxCon = MAX_CONNECTIONS; \r
1018                         int i = 0;\r
1019 \r
1020                         connections = new OracleConnection[maxCon];                     \r
1021                 \r
1022                         for (i = 0; i < maxCon; i++) {\r
1023                                 Console.WriteLine("   Open connection: {0}", i);\r
1024                                 connections[i] = new OracleConnection(conStr);\r
1025                                 connections[i].Open ();\r
1026                         }\r
1027 \r
1028                         Console.WriteLine("Done Connection Pooling Test 2.");\r
1029                         System.Environment.Exit (0);\r
1030                 }
1031
1032                 [STAThread]
1033                 static void Main(string[] args)
1034                 {
1035                         if(args.Length != 3) {
1036                                 Console.WriteLine("Usage: mono TestOracleClient database userid password");
1037                                 return;
1038                         }
1039
1040                         string connectionString = String.Format(
1041                                 "Data Source={0};" +
1042                                 "User ID={1};" +
1043                                 "Password={2}",
1044                                 args[0], args[1], args[2]);
1045
1046                         conStr = connectionString;
1047
1048                         OracleConnection con1 = new OracleConnection();
1049
1050                         ShowConnectionProperties (con1);
1051
1052                         con1.ConnectionString = connectionString;
1053
1054                         con1.InfoMessage += new OracleInfoMessageEventHandler (OnInfoMessage);
1055                         con1.StateChange += new StateChangeEventHandler (OnStateChange);
1056                         Console.WriteLine("Opening...");
1057                         con1.Open ();
1058                         Console.WriteLine("Opened.");
1059
1060                         ShowConnectionProperties (con1);
1061
1062                         Console.WriteLine ("Mono Oracle Test BEGIN ...");
1063                         MonoTest (con1);
1064                         Console.WriteLine ("Mono Oracle Test END ...");
1065
1066                         Wait ("");
1067
1068                         Console.WriteLine ("LOB Test BEGIN...");
1069                         CLOBTest (con1);
1070                         BLOBTest (con1);
1071                         Console.WriteLine ("LOB Test END.");
1072                         Wait ("");
1073
1074                         Console.WriteLine ("Read Simple Test BEGIN - scott.emp...");
1075                         ReadSimpleTest(con1, "SELECT e.*, e.rowid FROM scott.emp e");
1076                         Console.WriteLine ("Read Simple Test END - scott.emp");
1077
1078                         Wait ("");
1079
1080                         Console.WriteLine ("DataAdapter Test BEGIN...");
1081                         DataAdapterTest(con1);
1082                         Console.WriteLine ("DataAdapter Test END.");
1083
1084                         Wait ("");
1085
1086                         Console.WriteLine ("Rollback Test BEGIN...");
1087                         RollbackTest(con1);
1088                         Console.WriteLine ("Rollback Test END.");
1089
1090                         Wait ("");
1091
1092                         Console.WriteLine ("Commit Test BEGIN...");
1093                         CommitTest(con1);
1094                         Console.WriteLine ("Commit Test END.");
1095
1096                         Wait ("");
1097
1098                         Console.WriteLine ("Parameter Test BEGIN...");
1099                         ParameterTest(con1);
1100                         ReadSimpleTest(con1, "SELECT * FROM MONO_TEST_TABLE7");
1101                         Console.WriteLine ("Parameter Test END.");
1102
1103                         Wait ("");
1104
1105                         Console.WriteLine ("Stored Proc Test 1 BEGIN...");
1106                         StoredProcedureTest1 (con1);
1107                         ReadSimpleTest(con1, "SELECT * FROM MONO_TEST_TABLE1");
1108                         Console.WriteLine ("Stored Proc Test 1 END...");
1109
1110                         Wait ("");
1111
1112                         Console.WriteLine ("Stored Proc Test 2 BEGIN...");
1113                         StoredProcedureTest2 (con1);
1114                         ReadSimpleTest(con1, "SELECT * FROM MONO_TEST_TABLE2");
1115                         Console.WriteLine ("Stored Proc Test 2 END...");
1116
1117                         Wait ("");
1118
1119                         Console.WriteLine ("Null Aggregate Warning BEGIN test...");
1120                         NullAggregateTest (con1);
1121                         Console.WriteLine ("Null Aggregate Warning END test...");
1122
1123                         Console.WriteLine("Closing...");
1124                         con1.Close ();
1125                         Console.WriteLine("Closed.");
1126
1127                         conStr = conStr + ";pooling=true;min pool size=4;max pool size=" + MAX_CONNECTIONS.ToString ();\r
1128                         ConnectionPoolingTest1 ();\r
1129                         ConnectionPoolingTest2 ();\r
1130
1131                         Console.WriteLine("Done.");
1132                 }
1133         }
1134 }
1135