mcs/class/System.Data/Test/ProviderTests/System.Data.Odbc/OdbcParameterTest.cs

   1 // OdbcCommandTest.cs - NUnit Test Cases for testing the
   2 // OdbcCommand class
   3 //
   4 // Authors:
   5 //      Sureshkumar T (TSureshkumar@novell.com)
   6 //      Gert Driesen (drieseng@users.sourceforge.net)
   7 //
   8 // Copyright (c) 2005-2008 Novell Inc., and the individuals listed
   9 // on the ChangeLog entries.
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 #if !NO_ODBC
  32
  33 using System;
  34 using System.Data;
  35 using System.Data.Common;
  36 using System.Data.Odbc;
  37 using System.Globalization;
  38 using System.Text;
  39 using System.Threading;
  40 using NUnit.Framework;
  41
  42
  43 namespace MonoTests.System.Data.Connected.Odbc
  44 {
  45         [TestFixture]
  46         [Category ("odbc")]
  47         public class OdbcParameterTest
  48         {
  49                 private CultureInfo _originalCulture;
  50
  51                 [SetUp]
  52                 public void Setup ()
  53                 {
  54                         _originalCulture = Thread.CurrentThread.CurrentCulture;
  55                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("nl-BE");
  56                 }
  57
  58                 [TearDown]
  59                 public void TearDown ()
  60                 {
  61                         Thread.CurrentThread.CurrentCulture = _originalCulture;
  62                 }
  63
  64                 [Test]
  65                 public void IntegerParamTest ()
  66                 {
  67                         string insert_data = "insert into numeric_family (id, type_int) values (6000, ?)";
  68                         string select_data = "select id, type_int from numeric_family where type_int = ? and id = ?";
  69                         string select_by_id = "select id, type_int from numeric_family where id = ?";
  70                         string delete_data = "delete from numeric_family where id = 6000";
  71
  72                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
  73
  74                         IDataReader dr = null;
  75                         OdbcCommand cmd = null;
  76                         OdbcParameter param;
  77
  78                         try {
  79                                 cmd = (OdbcCommand) conn.CreateCommand ();
  80                                 cmd.CommandText = select_data;
  81                                 param = cmd.Parameters.Add ("type_int", OdbcType.Int);
  82                                 param.Value = int.MaxValue;
  83                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
  84                                 param.Value = 1;
  85                                 dr = cmd.ExecuteReader ();
  86                                 Assert.IsTrue (dr.Read (), "#A1");
  87                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
  88                                 Assert.AreEqual (1, dr.GetValue (0), "#A2");
  89                                 Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#A3");
  90                                 Assert.AreEqual (int.MaxValue, dr.GetValue (1), "#A4");
  91                                 Assert.IsFalse (dr.Read (), "#A5");
  92                                 dr.Close ();
  93                                 cmd.Dispose ();
  94
  95                                 cmd = (OdbcCommand) conn.CreateCommand ();
  96                                 cmd.CommandText = select_data;
  97                                 param = cmd.Parameters.Add ("type_int", OdbcType.Int);
  98                                 param.Value = int.MinValue;
  99                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 100                                 param.Value = 2;
 101                                 dr = cmd.ExecuteReader ();
 102                                 Assert.IsTrue (dr.Read (), "#B1");
 103                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
 104                                 Assert.AreEqual (2, dr.GetValue (0), "#B2");
 105                                 Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#B3");
 106                                 Assert.AreEqual (int.MinValue, dr.GetValue (1), "#B4");
 107                                 Assert.IsFalse (dr.Read (), "#B5");
 108                                 dr.Close ();
 109                                 cmd.Dispose ();
 110
 111                                 cmd = (OdbcCommand) conn.CreateCommand ();
 112                                 cmd.CommandText = select_data;
 113                                 param = cmd.Parameters.Add ("type_int", OdbcType.Int);
 114                                 param.Value = 0;
 115                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 116                                 param.Value = 3;
 117                                 dr = cmd.ExecuteReader ();
 118                                 Assert.IsTrue (dr.Read (), "#C1");
 119                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
 120                                 Assert.AreEqual (3, dr.GetValue (0), "#C2");
 121                                 Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#C3");
 122                                 Assert.AreEqual (0, dr.GetValue (1), "#C4");
 123                                 Assert.IsFalse (dr.Read (), "#C5");
 124                                 dr.Close ();
 125                                 cmd.Dispose ();
 126
 127                                 cmd = (OdbcCommand) conn.CreateCommand ();
 128                                 cmd.CommandText = select_by_id;
 129                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 130                                 param.Value = 4;
 131                                 dr = cmd.ExecuteReader ();
 132                                 Assert.IsTrue (dr.Read (), "#D1");
 133                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
 134                                 Assert.AreEqual (4, dr.GetValue (0), "#D3");
 135                                 Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#D4");
 136                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
 137                                 Assert.IsFalse (dr.Read (), "#D6");
 138                                 dr.Close ();
 139                                 cmd.Dispose ();
 140
 141                                 cmd = (OdbcCommand) conn.CreateCommand ();
 142                                 cmd.CommandText = insert_data;
 143                                 param = cmd.Parameters.Add ("type_int", OdbcType.Int);
 144                                 param.Value = int.MaxValue;
 145                                 cmd.ExecuteNonQuery ();
 146                                 cmd.Dispose ();
 147
 148                                 cmd = (OdbcCommand) conn.CreateCommand ();
 149                                 cmd.CommandText = select_by_id;
 150                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 151                                 param.Value = 6000;
 152                                 dr = cmd.ExecuteReader ();
 153                                 Assert.IsTrue (dr.Read (), "#E1");
 154                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
 155                                 Assert.AreEqual (6000, dr.GetValue (0), "#E3");
 156                                 Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#E4");
 157                                 Assert.AreEqual (int.MaxValue, dr.GetValue (1), "#E5");
 158                                 Assert.IsFalse (dr.Read (), "#E6");
 159                                 dr.Close ();
 160                                 cmd.Dispose ();
 161
 162                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 163
 164                                 cmd = (OdbcCommand) conn.CreateCommand ();
 165                                 cmd.CommandText = insert_data;
 166                                 param = cmd.Parameters.Add ("type_int", OdbcType.Int);
 167                                 param.Value = int.MinValue;
 168                                 cmd.ExecuteNonQuery ();
 169                                 cmd.Dispose ();
 170
 171                                 cmd = (OdbcCommand) conn.CreateCommand ();
 172                                 cmd.CommandText = select_by_id;
 173                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 174                                 param.Value = 6000;
 175                                 dr = cmd.ExecuteReader ();
 176                                 Assert.IsTrue (dr.Read (), "#F1");
 177                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
 178                                 Assert.AreEqual (6000, dr.GetValue (0), "#F3");
 179                                 Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#F4");
 180                                 Assert.AreEqual (int.MinValue, dr.GetValue (1), "#F5");
 181                                 Assert.IsFalse (dr.Read (), "#F6");
 182                                 dr.Close ();
 183                                 cmd.Dispose ();
 184
 185                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 186
 187                                 cmd = (OdbcCommand) conn.CreateCommand ();
 188                                 cmd.CommandText = insert_data;
 189                                 param = cmd.Parameters.Add ("type_int", OdbcType.Int);
 190                                 param.Value = 0;
 191                                 cmd.ExecuteNonQuery ();
 192                                 cmd.Dispose ();
 193
 194                                 cmd = (OdbcCommand) conn.CreateCommand ();
 195                                 cmd.CommandText = select_by_id;
 196                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 197                                 param.Value = 6000;
 198                                 dr = cmd.ExecuteReader ();
 199                                 Assert.IsTrue (dr.Read (), "#G1");
 200                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
 201                                 Assert.AreEqual (6000, dr.GetValue (0), "#G3");
 202                                 Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#G4");
 203                                 Assert.AreEqual (0, dr.GetValue (1), "#G5");
 204                                 Assert.IsFalse (dr.Read (), "#G6");
 205                                 dr.Close ();
 206                                 cmd.Dispose ();
 207
 208                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 209
 210                                 cmd = (OdbcCommand) conn.CreateCommand ();
 211                                 cmd.CommandText = insert_data;
 212                                 param = cmd.Parameters.Add ("type_int", OdbcType.Int);
 213                                 param.Value = DBNull.Value;
 214                                 cmd.ExecuteNonQuery ();
 215                                 cmd.Dispose ();
 216
 217                                 cmd = (OdbcCommand) conn.CreateCommand ();
 218                                 cmd.CommandText = select_by_id;
 219                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 220                                 param.Value = 6000;
 221                                 dr = cmd.ExecuteReader ();
 222                                 Assert.IsTrue (dr.Read (), "#H1");
 223                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
 224                                 Assert.AreEqual (6000, dr.GetValue (0), "#H3");
 225                                 Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#H4");
 226                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
 227                                 Assert.IsFalse (dr.Read (), "#H6");
 228                                 dr.Close ();
 229                                 cmd.Dispose ();
 230                         } finally {
 231                                 if (dr != null)
 232                                         dr.Close ();
 233                                 if (cmd != null)
 234                                         cmd.Dispose ();
 235                                 conn.Close ();
 236                                 conn.Open ();
 237                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 238                                 conn.Close ();
 239                         }
 240                 }
 241
 242                 [Test]
 243                 public void BigIntParamTest ()
 244                 {
 245                         string insert_data = "insert into numeric_family (id, type_bigint) values (6000, ?)";
 246                         string select_data = "select id, type_bigint from numeric_family where type_bigint = ? and id = ?";
 247                         string select_by_id = "select id, type_bigint from numeric_family where id = ?";
 248                         string delete_data = "delete from numeric_family where id = 6000";
 249
 250                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 251
 252                         IDataReader dr = null;
 253                         OdbcCommand cmd = null;
 254                         OdbcParameter param;
 255
 256                         try {
 257                                 cmd = (OdbcCommand) conn.CreateCommand ();
 258                                 cmd.CommandText = select_data;
 259                                 param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
 260                                 param.Value = 9223372036854775807L;
 261                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 262                                 param.Value = 1;
 263                                 dr = cmd.ExecuteReader ();
 264                                 Assert.IsTrue (dr.Read (), "#A1");
 265                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
 266                                 Assert.AreEqual (1, dr.GetValue (0), "#A3");
 267                                 Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#A4");
 268                                 Assert.AreEqual (9223372036854775807L, dr.GetValue (1), "#A5");
 269                                 Assert.IsFalse (dr.Read (), "#A6");
 270                                 dr.Close ();
 271                                 cmd.Dispose ();
 272
 273                                 cmd = (OdbcCommand) conn.CreateCommand ();
 274                                 cmd.CommandText = select_data;
 275                                 param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
 276                                 param.Value = -9223372036854775808L;
 277                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 278                                 param.Value = 2;
 279                                 dr = cmd.ExecuteReader ();
 280                                 Assert.IsTrue (dr.Read (), "#A1");
 281                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
 282                                 Assert.AreEqual (2, dr.GetValue (0), "#B3");
 283                                 Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#B4");
 284                                 Assert.AreEqual (-9223372036854775808L, dr.GetValue (1), "#B5");
 285                                 Assert.IsFalse (dr.Read (), "#B6");
 286                                 dr.Close ();
 287                                 cmd.Dispose ();
 288
 289                                 cmd = (OdbcCommand) conn.CreateCommand ();
 290                                 cmd.CommandText = select_data;
 291                                 param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
 292                                 param.Value = 0L;
 293                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 294                                 param.Value = 3;
 295                                 dr = cmd.ExecuteReader ();
 296                                 Assert.IsTrue (dr.Read (), "#C1");
 297                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
 298                                 Assert.AreEqual (3, dr.GetValue (0), "#C3");
 299                                 Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#C4");
 300                                 Assert.AreEqual (0L, dr.GetValue (1), "#C5");
 301                                 Assert.IsFalse (dr.Read (), "#C6");
 302                                 dr.Close ();
 303                                 cmd.Dispose ();
 304
 305                                 cmd = (OdbcCommand) conn.CreateCommand ();
 306                                 cmd.CommandText = select_by_id;
 307                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 308                                 param.Value = 4;
 309                                 dr = cmd.ExecuteReader ();
 310                                 Assert.IsTrue (dr.Read (), "#D1");
 311                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
 312                                 Assert.AreEqual (4, dr.GetValue (0), "#D3");
 313                                 Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#D4");
 314                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
 315                                 Assert.IsFalse (dr.Read (), "#D6");
 316                                 dr.Close ();
 317                                 cmd.Dispose ();
 318
 319                                 cmd = (OdbcCommand) conn.CreateCommand ();
 320                                 cmd.CommandText = insert_data;
 321                                 param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
 322                                 param.Value = 8223372036854775805L;
 323                                 cmd.ExecuteNonQuery ();
 324                                 cmd.Dispose ();
 325
 326                                 cmd = (OdbcCommand) conn.CreateCommand ();
 327                                 cmd.CommandText = select_data;
 328                                 param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
 329                                 param.Value = 8223372036854775805L;
 330                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 331                                 param.Value = 6000;
 332                                 dr = cmd.ExecuteReader ();
 333                                 Assert.IsTrue (dr.Read (), "#E1");
 334                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
 335                                 Assert.AreEqual (6000, dr.GetValue (0), "#E3");
 336                                 Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#E4");
 337                                 Assert.AreEqual (8223372036854775805L, dr.GetValue (1), "#E5");
 338                                 Assert.IsFalse (dr.Read (), "#E6");
 339                                 dr.Close ();
 340                                 cmd.Dispose ();
 341
 342                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 343
 344                                 cmd = (OdbcCommand) conn.CreateCommand ();
 345                                 cmd.CommandText = insert_data;
 346                                 param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
 347                                 param.Value = -8223372036854775805L;
 348                                 cmd.ExecuteNonQuery ();
 349                                 cmd.Dispose ();
 350
 351                                 cmd = (OdbcCommand) conn.CreateCommand ();
 352                                 cmd.CommandText = select_data;
 353                                 param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
 354                                 param.Value = -8223372036854775805L;
 355                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 356                                 param.Value = 6000;
 357                                 dr = cmd.ExecuteReader ();
 358                                 Assert.IsTrue (dr.Read (), "#F1");
 359                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
 360                                 Assert.AreEqual (6000, dr.GetValue (0), "#F3");
 361                                 Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#F4");
 362                                 Assert.AreEqual (-8223372036854775805L, dr.GetValue (1), "#F5");
 363                                 Assert.IsFalse (dr.Read (), "#F6");
 364                                 dr.Close ();
 365                                 cmd.Dispose ();
 366
 367                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 368
 369                                 cmd = (OdbcCommand) conn.CreateCommand ();
 370                                 cmd.CommandText = insert_data;
 371                                 param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
 372                                 param.Value = 0L;
 373                                 cmd.ExecuteNonQuery ();
 374                                 cmd.Dispose ();
 375
 376                                 cmd = (OdbcCommand) conn.CreateCommand ();
 377                                 cmd.CommandText = select_data;
 378                                 param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
 379                                 param.Value = 0;
 380                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 381                                 param.Value = 6000;
 382                                 dr = cmd.ExecuteReader ();
 383                                 Assert.IsTrue (dr.Read (), "#G1");
 384                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
 385                                 Assert.AreEqual (6000, dr.GetValue (0), "#G3");
 386                                 Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#G4");
 387                                 Assert.AreEqual (0L, dr.GetValue (1), "#G5");
 388                                 Assert.IsFalse (dr.Read (), "#G6");
 389                                 dr.Close ();
 390                                 cmd.Dispose ();
 391
 392                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 393
 394                                 cmd = (OdbcCommand) conn.CreateCommand ();
 395                                 cmd.CommandText = insert_data;
 396                                 param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
 397                                 param.Value = DBNull.Value;
 398                                 cmd.ExecuteNonQuery ();
 399                                 cmd.Dispose ();
 400
 401                                 cmd = (OdbcCommand) conn.CreateCommand ();
 402                                 cmd.CommandText = select_by_id;
 403                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 404                                 param.Value = 6000;
 405                                 dr = cmd.ExecuteReader ();
 406                                 Assert.IsTrue (dr.Read (), "#H1");
 407                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
 408                                 Assert.AreEqual (6000, dr.GetValue (0), "#H3");
 409                                 Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#H4");
 410                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
 411                                 Assert.IsFalse (dr.Read (), "#H6");
 412                                 dr.Close ();
 413                                 cmd.Dispose ();
 414                         } finally {
 415                                 if (dr != null)
 416                                         dr.Close ();
 417                                 if (cmd != null)
 418                                         cmd.Dispose ();
 419                                 conn.Close ();
 420                                 conn.Open ();
 421                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 422                                 conn.Close ();
 423                         }
 424                 }
 425
 426                 [Test]
 427                 public void BinaryParameterTest ()
 428                 {
 429                         string insert_data = "insert into binary_family (id, type_binary) values (6000, ?)";
 430                         string select_data = "select id, type_binary from binary_family where type_binary = ? and id = ?";
 431                         string select_by_id = "select id, type_binary from binary_family where id = ?";
 432                         string delete_data = "delete from binary_family where id = 6000";
 433
 434                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 435
 436                         IDataReader dr = null;
 437                         OdbcCommand cmd = null;
 438                         OdbcParameter param;
 439
 440                         try {
 441                                 byte [] bytes = new byte [] { 0x35, 0x00, 0x00,
 442                                         0x00, 0x00, 0x00, 0x00, 0x00 };
 443
 444                                 cmd = conn.CreateCommand ();
 445                                 cmd.CommandText = select_data;
 446                                 param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
 447                                 param.Value = bytes;
 448                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 449                                 param.Value = 1;
 450                                 dr = cmd.ExecuteReader ();
 451                                 Assert.IsTrue (dr.Read (), "#A1");
 452                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
 453                                 Assert.AreEqual (1, dr.GetValue (0), "#A3");
 454                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#A4");
 455                                 Assert.AreEqual (bytes, dr.GetValue (1), "#A5");
 456                                 Assert.IsFalse (dr.Read (), "#A6");
 457                                 dr.Close ();
 458                                 cmd.Dispose ();
 459
 460                                 bytes = new byte [] { 0x00, 0x33, 0x34, 0x00,
 461                                         0x33, 0x30, 0x35, 0x31 };
 462
 463                                 cmd = conn.CreateCommand ();
 464                                 cmd.CommandText = select_data;
 465                                 param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
 466                                 param.Value = bytes;
 467                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 468                                 param.Value = 2;
 469                                 dr = cmd.ExecuteReader ();
 470                                 Assert.IsTrue (dr.Read (), "#B1");
 471                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
 472                                 Assert.AreEqual (2, dr.GetValue (0), "#B3");
 473                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#B4");
 474                                 Assert.AreEqual (bytes, dr.GetValue (1), "#B5");
 475                                 Assert.IsFalse (dr.Read (), "#B6");
 476                                 dr.Close ();
 477                                 cmd.Dispose ();
 478
 479                                 bytes = new byte [8];
 480
 481                                 cmd = conn.CreateCommand ();
 482                                 cmd.CommandText = select_data;
 483                                 param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
 484                                 param.Value = bytes;
 485                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 486                                 param.Value = 3;
 487                                 dr = cmd.ExecuteReader ();
 488                                 Assert.IsTrue (dr.Read (), "#C1");
 489                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
 490                                 Assert.AreEqual (3, dr.GetValue (0), "#C3");
 491                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#C4");
 492                                 Assert.AreEqual (bytes, dr.GetValue (1), "#C5");
 493                                 Assert.IsFalse (dr.Read (), "#C6");
 494                                 dr.Close ();
 495                                 cmd.Dispose ();
 496
 497                                 cmd = conn.CreateCommand ();
 498                                 cmd.CommandText = select_by_id;
 499                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 500                                 param.Value = 4;
 501                                 dr = cmd.ExecuteReader ();
 502                                 Assert.IsTrue (dr.Read (), "#D1");
 503                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
 504                                 Assert.AreEqual (4, dr.GetValue (0), "#D3");
 505                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#D4");
 506                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
 507                                 Assert.IsFalse (dr.Read (), "#D6");
 508                                 dr.Close ();
 509                                 cmd.Dispose ();
 510
 511                                 bytes = new byte [0];
 512
 513                                 cmd = conn.CreateCommand ();
 514                                 cmd.CommandText = insert_data;
 515                                 param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
 516                                 param.Value = bytes;
 517                                 cmd.ExecuteNonQuery ();
 518                                 cmd.Dispose ();
 519
 520                                 cmd = conn.CreateCommand ();
 521                                 cmd.CommandText = select_by_id;
 522                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 523                                 param.Value = 6000;
 524                                 dr = cmd.ExecuteReader ();
 525                                 Assert.IsTrue (dr.Read (), "#E1");
 526                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
 527                                 Assert.AreEqual (6000, dr.GetValue (0), "#E3");
 528                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#E4");
 529                                 Assert.AreEqual (new byte [8], dr.GetValue (1), "#E5");
 530                                 Assert.IsFalse (dr.Read (), "#E6");
 531                                 dr.Close ();
 532                                 cmd.Dispose ();
 533
 534                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 535
 536                                 bytes = new byte [] { 0x05 };
 537
 538                                 cmd = conn.CreateCommand ();
 539                                 cmd.CommandText = insert_data;
 540                                 param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
 541                                 param.Value = bytes;
 542                                 cmd.ExecuteNonQuery ();
 543                                 cmd.Dispose ();
 544
 545                                 cmd = conn.CreateCommand ();
 546                                 cmd.CommandText = select_by_id;
 547                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 548                                 param.Value = 6000;
 549                                 dr = cmd.ExecuteReader ();
 550                                 Assert.IsTrue (dr.Read (), "#F1");
 551                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
 552                                 Assert.AreEqual (6000, dr.GetValue (0), "#F3");
 553                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#F4");
 554                                 Assert.AreEqual (new byte [] { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, dr.GetValue (1), "#F5");
 555                                 Assert.IsFalse (dr.Read (), "#F6");
 556                                 dr.Close ();
 557                                 cmd.Dispose ();
 558
 559                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 560
 561                                 bytes = new byte [] { 0x34, 0x00, 0x32 };
 562
 563                                 cmd = conn.CreateCommand ();
 564                                 cmd.CommandText = insert_data;
 565                                 param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
 566                                 param.Value = bytes;
 567                                 cmd.ExecuteNonQuery ();
 568                                 cmd.Dispose ();
 569
 570                                 cmd = conn.CreateCommand ();
 571                                 cmd.CommandText = select_by_id;
 572                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 573                                 param.Value = 6000;
 574                                 dr = cmd.ExecuteReader ();
 575                                 Assert.IsTrue (dr.Read (), "#G1");
 576                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
 577                                 Assert.AreEqual (6000, dr.GetValue (0), "#G3");
 578                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#G4");
 579                                 Assert.AreEqual (new byte [] { 0x34, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00 }, dr.GetValue (1), "#G5");
 580                                 Assert.IsFalse (dr.Read (), "#G6");
 581                                 dr.Close ();
 582                                 cmd.Dispose ();
 583
 584                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 585
 586                                 bytes = new byte [] { 0x34, 0x00, 0x32, 0x05, 0x07, 0x13 };
 587
 588                                 cmd = conn.CreateCommand ();
 589                                 cmd.CommandText = insert_data;
 590                                 param = cmd.Parameters.Add ("type_binary", OdbcType.Binary, 4);
 591                                 param.Value = bytes;
 592                                 cmd.ExecuteNonQuery ();
 593                                 cmd.Dispose ();
 594
 595                                 cmd = conn.CreateCommand ();
 596                                 cmd.CommandText = select_by_id;
 597                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 598                                 param.Value = 6000;
 599                                 dr = cmd.ExecuteReader ();
 600                                 Assert.IsTrue (dr.Read (), "#H1");
 601                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
 602                                 Assert.AreEqual (6000, dr.GetValue (0), "#H3");
 603                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#H4");
 604                                 Assert.AreEqual (new byte [] { 0x34, 0x00, 0x32, 0x05, 0x00, 0x00, 0x00, 0x00 }, dr.GetValue (1), "#H5");
 605                                 Assert.IsFalse (dr.Read (), "#H6");
 606                                 dr.Close ();
 607                                 cmd.Dispose ();
 608
 609                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 610
 611                                 cmd = conn.CreateCommand ();
 612                                 cmd.CommandText = insert_data;
 613                                 param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
 614                                 param.Value = DBNull.Value;
 615                                 cmd.ExecuteNonQuery ();
 616                                 cmd.Dispose ();
 617
 618                                 cmd = conn.CreateCommand ();
 619                                 cmd.CommandText = select_by_id;
 620                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 621                                 param.Value = 6000;
 622                                 dr = cmd.ExecuteReader ();
 623                                 Assert.IsTrue (dr.Read (), "#I1");
 624                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#I2");
 625                                 Assert.AreEqual (6000, dr.GetValue (0), "#I3");
 626                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#I4");
 627                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#I5");
 628                                 Assert.IsFalse (dr.Read (), "#I6");
 629                                 dr.Close ();
 630                                 cmd.Dispose ();
 631                         } finally {
 632                                 if (dr != null)
 633                                         dr.Close ();
 634                                 if (cmd != null)
 635                                         cmd.Dispose ();
 636                                 conn.Close ();
 637                                 conn.Open ();
 638                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 639                                 conn.Close ();
 640                         }
 641                 }
 642
 643                 [Test]
 644                 public void SmallIntParamTest ()
 645                 {
 646                         string insert_data = "insert into numeric_family (id, type_smallint) values (6000, ?)";
 647                         string select_data = "select id, type_smallint from numeric_family where type_smallint = ? and id = ?";
 648                         string select_by_id = "select id, type_smallint from numeric_family where id = ?";
 649                         string delete_data = "delete from numeric_family where id = 6000";
 650
 651                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 652
 653                         IDataReader dr = null;
 654                         OdbcCommand cmd = null;
 655                         OdbcParameter param;
 656
 657                         try {
 658                                 cmd = (OdbcCommand) conn.CreateCommand ();
 659                                 cmd.CommandText = select_data;
 660                                 param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
 661                                 param.Value = short.MaxValue;
 662                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 663                                 param.Value = 1;
 664                                 dr = cmd.ExecuteReader ();
 665                                 Assert.IsTrue (dr.Read (), "#A1");
 666                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
 667                                 Assert.AreEqual (1, dr.GetValue (0), "#A2");
 668                                 Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#A3");
 669                                 Assert.AreEqual (short.MaxValue, dr.GetValue (1), "#A4");
 670                                 Assert.IsFalse (dr.Read (), "#A5");
 671                                 dr.Close ();
 672                                 cmd.Dispose ();
 673
 674                                 cmd = (OdbcCommand) conn.CreateCommand ();
 675                                 cmd.CommandText = select_data;
 676                                 param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
 677                                 param.Value = short.MinValue;
 678                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 679                                 param.Value = 2;
 680                                 dr = cmd.ExecuteReader ();
 681                                 Assert.IsTrue (dr.Read (), "#B1");
 682                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
 683                                 Assert.AreEqual (2, dr.GetValue (0), "#B2");
 684                                 Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#B3");
 685                                 Assert.AreEqual (short.MinValue, dr.GetValue (1), "#B4");
 686                                 Assert.IsFalse (dr.Read (), "#B5");
 687                                 dr.Close ();
 688                                 cmd.Dispose ();
 689
 690                                 cmd = (OdbcCommand) conn.CreateCommand ();
 691                                 cmd.CommandText = select_data;
 692                                 param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
 693                                 param.Value = (short) 0;
 694                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 695                                 param.Value = 3;
 696                                 dr = cmd.ExecuteReader ();
 697                                 Assert.IsTrue (dr.Read (), "#C1");
 698                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
 699                                 Assert.AreEqual (3, dr.GetValue (0), "#C2");
 700                                 Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#C3");
 701                                 Assert.AreEqual (0, dr.GetValue (1), "#C4");
 702                                 Assert.IsFalse (dr.Read (), "#C5");
 703                                 dr.Close ();
 704                                 cmd.Dispose ();
 705
 706                                 cmd = (OdbcCommand) conn.CreateCommand ();
 707                                 cmd.CommandText = select_by_id;
 708                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 709                                 param.Value = 4;
 710                                 dr = cmd.ExecuteReader ();
 711                                 Assert.IsTrue (dr.Read (), "#D1");
 712                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
 713                                 Assert.AreEqual (4, dr.GetValue (0), "#D3");
 714                                 Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#D4");
 715                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
 716                                 Assert.IsFalse (dr.Read (), "#D6");
 717                                 dr.Close ();
 718                                 cmd.Dispose ();
 719
 720                                 cmd = (OdbcCommand) conn.CreateCommand ();
 721                                 cmd.CommandText = insert_data;
 722                                 param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
 723                                 param.Value = short.MaxValue;
 724                                 cmd.ExecuteNonQuery ();
 725                                 cmd.Dispose ();
 726
 727                                 cmd = (OdbcCommand) conn.CreateCommand ();
 728                                 cmd.CommandText = select_by_id;
 729                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 730                                 param.Value = 6000;
 731                                 dr = cmd.ExecuteReader ();
 732                                 Assert.IsTrue (dr.Read (), "#E1");
 733                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
 734                                 Assert.AreEqual (6000, dr.GetValue (0), "#E3");
 735                                 Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#E4");
 736                                 Assert.AreEqual (short.MaxValue, dr.GetValue (1), "#E5");
 737                                 Assert.IsFalse (dr.Read (), "#E6");
 738                                 dr.Close ();
 739                                 cmd.Dispose ();
 740
 741                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 742
 743                                 cmd = (OdbcCommand) conn.CreateCommand ();
 744                                 cmd.CommandText = insert_data;
 745                                 param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
 746                                 param.Value = short.MinValue;
 747                                 cmd.ExecuteNonQuery ();
 748                                 cmd.Dispose ();
 749
 750                                 cmd = (OdbcCommand) conn.CreateCommand ();
 751                                 cmd.CommandText = select_by_id;
 752                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 753                                 param.Value = 6000;
 754                                 dr = cmd.ExecuteReader ();
 755                                 Assert.IsTrue (dr.Read (), "#F1");
 756                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
 757                                 Assert.AreEqual (6000, dr.GetValue (0), "#F3");
 758                                 Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#F4");
 759                                 Assert.AreEqual (short.MinValue, dr.GetValue (1), "#F5");
 760                                 Assert.IsFalse (dr.Read (), "#F6");
 761                                 dr.Close ();
 762                                 cmd.Dispose ();
 763
 764                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 765
 766                                 cmd = (OdbcCommand) conn.CreateCommand ();
 767                                 cmd.CommandText = insert_data;
 768                                 param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
 769                                 param.Value = 0;
 770                                 cmd.ExecuteNonQuery ();
 771                                 cmd.Dispose ();
 772
 773                                 cmd = (OdbcCommand) conn.CreateCommand ();
 774                                 cmd.CommandText = select_by_id;
 775                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 776                                 param.Value = 6000;
 777                                 dr = cmd.ExecuteReader ();
 778                                 Assert.IsTrue (dr.Read (), "#G1");
 779                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
 780                                 Assert.AreEqual (6000, dr.GetValue (0), "#G3");
 781                                 Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#G4");
 782                                 Assert.AreEqual ((short) 0, dr.GetValue (1), "#G5");
 783                                 Assert.IsFalse (dr.Read (), "#G6");
 784                                 dr.Close ();
 785                                 cmd.Dispose ();
 786
 787                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 788
 789                                 cmd = (OdbcCommand) conn.CreateCommand ();
 790                                 cmd.CommandText = insert_data;
 791                                 param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
 792                                 param.Value = DBNull.Value;
 793                                 cmd.ExecuteNonQuery ();
 794                                 cmd.Dispose ();
 795
 796                                 cmd = (OdbcCommand) conn.CreateCommand ();
 797                                 cmd.CommandText = select_by_id;
 798                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 799                                 param.Value = 6000;
 800                                 dr = cmd.ExecuteReader ();
 801                                 Assert.IsTrue (dr.Read (), "#H1");
 802                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
 803                                 Assert.AreEqual (6000, dr.GetValue (0), "#H3");
 804                                 Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#H4");
 805                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
 806                                 Assert.IsFalse (dr.Read (), "#H6");
 807                                 dr.Close ();
 808                                 cmd.Dispose ();
 809                         } finally {
 810                                 if (dr != null)
 811                                         dr.Close ();
 812                                 if (cmd != null)
 813                                         cmd.Dispose ();
 814                                 conn.Close ();
 815                                 conn.Open ();
 816                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 817                                 conn.Close ();
 818                         }
 819                 }
 820
 821                 [Test]
 822                 public void TimestampParameterTest ()
 823                 {
 824                         // the value for the timestamp column is determined by
 825                         // the RDBMS upon insert/update and cannot be specified
 826                         // by the user
 827
 828                         string insert_data = "insert into binary_family (id) values (6000)";
 829                         string select_by_id = "select id, type_timestamp from binary_family where id = ?";
 830                         string delete_data = "delete from binary_family where id = 6000";
 831
 832                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 833
 834                         IDataReader dr = null;
 835                         OdbcCommand cmd = null;
 836                         OdbcParameter param;
 837
 838                         try {
 839                                 if (!ConnectionManager.Instance.Odbc.EngineConfig.SupportsTimestamp)
 840                                         Assert.Ignore ("Timestamp test does not apply to the current driver (" + conn.Driver + ").");
 841
 842                                 cmd = conn.CreateCommand ();
 843                                 cmd.CommandText = insert_data;
 844                                 cmd.ExecuteNonQuery ();
 845                                 cmd.Dispose ();
 846
 847                                 byte [] timestamp;
 848
 849                                 cmd = conn.CreateCommand ();
 850                                 cmd.CommandText = "SELECT @@DBTS";
 851                                 dr = cmd.ExecuteReader ();
 852                                 Assert.IsTrue (dr.Read (), "#A1");
 853                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#A2");
 854                                 timestamp = (byte []) dr.GetValue (0);
 855                                 Assert.IsFalse (dr.Read (), "#A3");
 856                                 dr.Close ();
 857                                 cmd.Dispose ();
 858
 859                                 cmd = conn.CreateCommand ();
 860                                 cmd.CommandText = select_by_id;
 861                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 862                                 param.Value = 6000;
 863                                 dr = cmd.ExecuteReader ();
 864                                 Assert.IsTrue (dr.Read (), "#B1");
 865                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
 866                                 Assert.AreEqual (6000, dr.GetValue (0), "#B3");
 867                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#B4");
 868                                 Assert.AreEqual (timestamp, dr.GetValue (1), "#B5");
 869                                 Assert.IsFalse (dr.Read (), "#B6");
 870                                 dr.Close ();
 871                                 cmd.Dispose ();
 872                         } finally {
 873                                 if (dr != null)
 874                                         dr.Close ();
 875                                 if (cmd != null)
 876                                         cmd.Dispose ();
 877
 878                                 conn.Close ();
 879                                 conn.Open ();
 880                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 881                                 conn.Close ();
 882                         }
 883                 }
 884
 885                 [Test]
 886                 public void TinyIntParamTest ()
 887                 {
 888                         string insert_data = "insert into numeric_family (id, type_tinyint) values (6000, ?)";
 889                         string select_data = "select id, type_tinyint from numeric_family where type_tinyint = ? and id = ?";
 890                         string select_by_id = "select id, type_tinyint from numeric_family where id = ?";
 891                         string delete_data = "delete from numeric_family where id = 6000";
 892
 893                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
 894
 895                         IDataReader dr = null;
 896                         OdbcCommand cmd = null;
 897                         OdbcParameter param;
 898
 899                         try {
 900                                 cmd = (OdbcCommand) conn.CreateCommand ();
 901                                 cmd.CommandText = select_data;
 902                                 param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
 903                                 param.Value = byte.MaxValue;
 904                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 905                                 param.Value = 1;
 906                                 dr = cmd.ExecuteReader ();
 907                                 Assert.IsTrue (dr.Read (), "#A1");
 908                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
 909                                 Assert.AreEqual (1, dr.GetValue (0), "#A2");
 910                                 Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#A3");
 911                                 Assert.AreEqual (byte.MaxValue, dr.GetValue (1), "#A4");
 912                                 Assert.IsFalse (dr.Read (), "#A5");
 913                                 dr.Close ();
 914                                 cmd.Dispose ();
 915
 916                                 cmd = (OdbcCommand) conn.CreateCommand ();
 917                                 cmd.CommandText = select_data;
 918                                 param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
 919                                 param.Value = byte.MinValue;
 920                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 921                                 param.Value = 2;
 922                                 dr = cmd.ExecuteReader ();
 923                                 Assert.IsTrue (dr.Read (), "#B1");
 924                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
 925                                 Assert.AreEqual (2, dr.GetValue (0), "#B2");
 926                                 Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#B3");
 927                                 Assert.AreEqual (byte.MinValue, dr.GetValue (1), "#B4");
 928                                 Assert.IsFalse (dr.Read (), "#B5");
 929                                 dr.Close ();
 930                                 cmd.Dispose ();
 931
 932                                 cmd = (OdbcCommand) conn.CreateCommand ();
 933                                 cmd.CommandText = select_data;
 934                                 param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
 935                                 param.Value = 0x00;
 936                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 937                                 param.Value = 3;
 938                                 dr = cmd.ExecuteReader ();
 939                                 Assert.IsTrue (dr.Read (), "#C1");
 940                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
 941                                 Assert.AreEqual (3, dr.GetValue (0), "#C2");
 942                                 Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#C3");
 943                                 Assert.AreEqual (0x00, dr.GetValue (1), "#C4");
 944                                 Assert.IsFalse (dr.Read (), "#C5");
 945                                 dr.Close ();
 946                                 cmd.Dispose ();
 947
 948                                 cmd = (OdbcCommand) conn.CreateCommand ();
 949                                 cmd.CommandText = select_by_id;
 950                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 951                                 param.Value = 4;
 952                                 dr = cmd.ExecuteReader ();
 953                                 Assert.IsTrue (dr.Read (), "#D1");
 954                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
 955                                 Assert.AreEqual (4, dr.GetValue (0), "#D3");
 956                                 Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#D4");
 957                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
 958                                 Assert.IsFalse (dr.Read (), "#D6");
 959                                 dr.Close ();
 960                                 cmd.Dispose ();
 961
 962                                 cmd = (OdbcCommand) conn.CreateCommand ();
 963                                 cmd.CommandText = insert_data;
 964                                 param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
 965                                 param.Value = byte.MaxValue;
 966                                 cmd.ExecuteNonQuery ();
 967                                 cmd.Dispose ();
 968
 969                                 cmd = (OdbcCommand) conn.CreateCommand ();
 970                                 cmd.CommandText = select_by_id;
 971                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 972                                 param.Value = 6000;
 973                                 dr = cmd.ExecuteReader ();
 974                                 Assert.IsTrue (dr.Read (), "#E1");
 975                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
 976                                 Assert.AreEqual (6000, dr.GetValue (0), "#E3");
 977                                 Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#E4");
 978                                 Assert.AreEqual (byte.MaxValue, dr.GetValue (1), "#E5");
 979                                 Assert.IsFalse (dr.Read (), "#E6");
 980                                 dr.Close ();
 981                                 cmd.Dispose ();
 982
 983                                 DBHelper.ExecuteNonQuery (conn, delete_data);
 984
 985                                 cmd = (OdbcCommand) conn.CreateCommand ();
 986                                 cmd.CommandText = insert_data;
 987                                 param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
 988                                 param.Value = byte.MinValue;
 989                                 cmd.ExecuteNonQuery ();
 990                                 cmd.Dispose ();
 991
 992                                 cmd = (OdbcCommand) conn.CreateCommand ();
 993                                 cmd.CommandText = select_by_id;
 994                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
 995                                 param.Value = 6000;
 996                                 dr = cmd.ExecuteReader ();
 997                                 Assert.IsTrue (dr.Read (), "#F1");
 998                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
 999                                 Assert.AreEqual (6000, dr.GetValue (0), "#F3");
1000                                 Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#F4");
1001                                 Assert.AreEqual (byte.MinValue, dr.GetValue (1), "#F5");
1002                                 Assert.IsFalse (dr.Read (), "#F6");
1003                                 dr.Close ();
1004                                 cmd.Dispose ();
1005
1006                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1007
1008                                 cmd = (OdbcCommand) conn.CreateCommand ();
1009                                 cmd.CommandText = insert_data;
1010                                 param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
1011                                 param.Value = 0x00;
1012                                 cmd.ExecuteNonQuery ();
1013                                 cmd.Dispose ();
1014
1015                                 cmd = (OdbcCommand) conn.CreateCommand ();
1016                                 cmd.CommandText = select_by_id;
1017                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1018                                 param.Value = 6000;
1019                                 dr = cmd.ExecuteReader ();
1020                                 Assert.IsTrue (dr.Read (), "#G1");
1021                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
1022                                 Assert.AreEqual (6000, dr.GetValue (0), "#G3");
1023                                 Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#G4");
1024                                 Assert.AreEqual (0x00, dr.GetValue (1), "#G5");
1025                                 Assert.IsFalse (dr.Read (), "#G6");
1026                                 dr.Close ();
1027                                 cmd.Dispose ();
1028
1029                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1030
1031                                 cmd = (OdbcCommand) conn.CreateCommand ();
1032                                 cmd.CommandText = insert_data;
1033                                 param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
1034                                 param.Value = DBNull.Value;
1035                                 cmd.ExecuteNonQuery ();
1036                                 cmd.Dispose ();
1037
1038                                 cmd = (OdbcCommand) conn.CreateCommand ();
1039                                 cmd.CommandText = select_by_id;
1040                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1041                                 param.Value = 6000;
1042                                 dr = cmd.ExecuteReader ();
1043                                 Assert.IsTrue (dr.Read (), "#H1");
1044                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
1045                                 Assert.AreEqual (6000, dr.GetValue (0), "#H3");
1046                                 Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#H4");
1047                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
1048                                 Assert.IsFalse (dr.Read (), "#H6");
1049                                 dr.Close ();
1050                                 cmd.Dispose ();
1051                         } finally {
1052                                 if (dr != null)
1053                                         dr.Close ();
1054                                 if (cmd != null)
1055                                         cmd.Dispose ();
1056                                 conn.Close ();
1057                                 conn.Open ();
1058                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1059                                 conn.Close ();
1060                         }
1061                 }
1062
1063                 [Test]
1064                 public void StringParamTest ()
1065                 {
1066                         string query = "select id, fname from employee where fname = ?";
1067                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
1068                         try {
1069                                 OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
1070                                 cmd.CommandText = query;
1071
1072                                 OdbcParameter param = cmd.Parameters.Add ("fname", OdbcType.VarChar);
1073                                 param.Value = "suresh";
1074                                 OdbcDataReader dr = cmd.ExecuteReader ();
1075                                 Assert.IsTrue (dr.Read (), "#1 no data to test");
1076                                 Assert.AreEqual (1, (int) dr [0], "#2 value not matching");
1077                         } finally {
1078                                 ConnectionManager.Instance.Odbc.CloseConnection ();
1079                         }
1080                 }
1081
1082
1083                 [Test]
1084                 public void BitParameterTest ()
1085                 {
1086                         string insert_data = "insert into numeric_family (id, type_bit) values (6000, ?)";
1087                         string select_data = "select id, type_bit from numeric_family where type_bit = ? and id = ?";
1088                         string select_by_id = "select id, type_bit from numeric_family where id = ?";
1089                         string delete_data = "delete from numeric_family where id = 6000";
1090
1091                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
1092
1093                         IDataReader dr = null;
1094                         OdbcCommand cmd = null;
1095                         OdbcParameter param;
1096
1097                         try {
1098                                 cmd = (OdbcCommand) conn.CreateCommand ();
1099                                 cmd.CommandText = select_data;
1100                                 param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
1101                                 param.Value = true;
1102                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1103                                 param.Value = 1;
1104                                 dr = cmd.ExecuteReader ();
1105                                 Assert.IsTrue (dr.Read (), "#A1");
1106                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
1107                                 Assert.AreEqual (1, dr.GetValue (0), "#A2");
1108                                 Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#A3");
1109                                 Assert.AreEqual (true, dr.GetValue (1), "#A4");
1110                                 Assert.IsFalse (dr.Read (), "#A5");
1111                                 dr.Close ();
1112                                 cmd.Dispose ();
1113
1114                                 cmd = (OdbcCommand) conn.CreateCommand ();
1115                                 cmd.CommandText = select_data;
1116                                 param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
1117                                 param.Value = false;
1118                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1119                                 param.Value = 2;
1120                                 dr = cmd.ExecuteReader ();
1121                                 Assert.IsTrue (dr.Read (), "#B1");
1122                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
1123                                 Assert.AreEqual (2, dr.GetValue (0), "#B2");
1124                                 Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#B3");
1125                                 Assert.AreEqual (false, dr.GetValue (1), "#B4");
1126                                 Assert.IsFalse (dr.Read (), "#B5");
1127                                 dr.Close ();
1128                                 cmd.Dispose ();
1129
1130                                 cmd = (OdbcCommand) conn.CreateCommand ();
1131                                 cmd.CommandText = select_by_id;
1132                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1133                                 param.Value = 4;
1134                                 dr = cmd.ExecuteReader ();
1135                                 Assert.IsTrue (dr.Read (), "#C1");
1136                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
1137                                 Assert.AreEqual (4, dr.GetValue (0), "#C3");
1138                                 Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#C4");
1139                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#C5");
1140                                 Assert.IsFalse (dr.Read (), "#C6");
1141                                 dr.Close ();
1142                                 cmd.Dispose ();
1143
1144                                 cmd = (OdbcCommand) conn.CreateCommand ();
1145                                 cmd.CommandText = insert_data;
1146                                 param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
1147                                 param.Value = true;
1148                                 cmd.ExecuteNonQuery ();
1149                                 cmd.Dispose ();
1150
1151                                 cmd = (OdbcCommand) conn.CreateCommand ();
1152                                 cmd.CommandText = select_data;
1153                                 param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
1154                                 param.Value = true;
1155                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1156                                 param.Value = 6000;
1157                                 dr = cmd.ExecuteReader ();
1158                                 Assert.IsTrue (dr.Read (), "#D1");
1159                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
1160                                 Assert.AreEqual (6000, dr.GetValue (0), "#D3");
1161                                 Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#D4");
1162                                 Assert.AreEqual (true, dr.GetValue (1), "#D5");
1163                                 Assert.IsFalse (dr.Read (), "#D6");
1164                                 dr.Close ();
1165                                 cmd.Dispose ();
1166
1167                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1168
1169                                 cmd = (OdbcCommand) conn.CreateCommand ();
1170                                 cmd.CommandText = insert_data;
1171                                 param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
1172                                 param.Value = false;
1173                                 cmd.ExecuteNonQuery ();
1174                                 cmd.Dispose ();
1175
1176                                 cmd = (OdbcCommand) conn.CreateCommand ();
1177                                 cmd.CommandText = select_data;
1178                                 param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
1179                                 param.Value = false;
1180                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1181                                 param.Value = 6000;
1182                                 dr = cmd.ExecuteReader ();
1183                                 Assert.IsTrue (dr.Read (), "#E1");
1184                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
1185                                 Assert.AreEqual (6000, dr.GetValue (0), "#E3");
1186                                 Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#E4");
1187                                 Assert.AreEqual (false, dr.GetValue (1), "#E5");
1188                                 Assert.IsFalse (dr.Read (), "#E6");
1189                                 dr.Close ();
1190                                 cmd.Dispose ();
1191
1192                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1193
1194                                 cmd = (OdbcCommand) conn.CreateCommand ();
1195                                 cmd.CommandText = insert_data;
1196                                 param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
1197                                 param.Value = DBNull.Value;
1198                                 cmd.ExecuteNonQuery ();
1199                                 cmd.Dispose ();
1200
1201                                 cmd = (OdbcCommand) conn.CreateCommand ();
1202                                 cmd.CommandText = select_by_id;
1203                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1204                                 param.Value = 6000;
1205                                 dr = cmd.ExecuteReader ();
1206                                 Assert.IsTrue (dr.Read (), "#F1");
1207                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
1208                                 Assert.AreEqual (6000, dr.GetValue (0), "#F3");
1209                                 Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#F4");
1210                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#F5");
1211                                 Assert.IsFalse (dr.Read (), "#F6");
1212                                 dr.Close ();
1213                                 cmd.Dispose ();
1214                         } finally {
1215                                 if (dr != null)
1216                                         dr.Close ();
1217                                 if (cmd != null)
1218                                         cmd.Dispose ();
1219                                 conn.Close ();
1220                                 conn.Open ();
1221                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1222                                 conn.Close ();
1223                         }
1224                 }
1225
1226                 [Test]
1227                 public void CharParameterTest ()
1228                 {
1229                         string insert_data = "insert into string_family (id, type_char) values (6000, ?)";
1230                         string select_data = "select id, type_char from string_family where type_char = ? and id = ?";
1231                         string select_by_id = "select id, type_char from string_family where id = ?";
1232                         string delete_data = "delete from string_family where id = 6000";
1233
1234                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
1235
1236                         IDataReader dr = null;
1237                         OdbcCommand cmd = null;
1238                         OdbcParameter param;
1239
1240                         try {
1241                                 cmd = conn.CreateCommand ();
1242                                 cmd.CommandText = select_data;
1243                                 param = cmd.Parameters.Add ("type_char", OdbcType.Char);
1244                                 param.Value = "char";
1245                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1246                                 param.Value = 1;
1247                                 dr = cmd.ExecuteReader ();
1248                                 Assert.IsTrue (dr.Read (), "#A1");
1249                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
1250                                 Assert.AreEqual (1, dr.GetValue (0), "#A3");
1251                                 Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#A4");
1252                                 if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
1253                                         Assert.AreEqual ("char", dr.GetValue (1), "#A5");
1254                                 else
1255                                         Assert.AreEqual ("char      ", dr.GetValue (1), "#A5");
1256                                 Assert.IsFalse (dr.Read (), "#A6");
1257                                 dr.Close ();
1258                                 cmd.Dispose ();
1259
1260                                 cmd = conn.CreateCommand ();
1261                                 cmd.CommandText = select_data;
1262                                 param = cmd.Parameters.Add ("type_char", OdbcType.Char);
1263                                 param.Value = "0123456789";
1264                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1265                                 param.Value = 2;
1266                                 dr = cmd.ExecuteReader ();
1267                                 Assert.IsTrue (dr.Read (), "#B1");
1268                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
1269                                 Assert.AreEqual (2, dr.GetValue (0), "#B3");
1270                                 Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#B4");
1271                                 Assert.AreEqual ("0123456789", dr.GetValue (1), "#B5");
1272                                 Assert.IsFalse (dr.Read (), "#B6");
1273                                 dr.Close ();
1274                                 cmd.Dispose ();
1275
1276                                 cmd = conn.CreateCommand ();
1277                                 cmd.CommandText = select_data;
1278                                 param = cmd.Parameters.Add ("type_char", OdbcType.Char);
1279                                 param.Value = string.Empty;
1280                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1281                                 param.Value = 3;
1282                                 dr = cmd.ExecuteReader ();
1283                                 Assert.IsTrue (dr.Read (), "#C1");
1284                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
1285                                 Assert.AreEqual (3, dr.GetValue (0), "#C3");
1286                                 Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#C4");
1287                                 if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
1288                                         Assert.AreEqual (string.Empty, dr.GetValue (1), "#C5");
1289                                 else
1290                                         Assert.AreEqual ("          ", dr.GetValue (1), "#C5");
1291                                 Assert.IsFalse (dr.Read (), "#C6");
1292                                 dr.Close ();
1293                                 cmd.Dispose ();
1294
1295                                 cmd = conn.CreateCommand ();
1296                                 cmd.CommandText = select_by_id;
1297                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1298                                 param.Value = 4;
1299                                 dr = cmd.ExecuteReader ();
1300                                 Assert.IsTrue (dr.Read (), "#D1");
1301                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
1302                                 Assert.AreEqual (4, dr.GetValue (0), "#D3");
1303                                 Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#D4");
1304                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
1305                                 Assert.IsFalse (dr.Read (), "#D6");
1306                                 dr.Close ();
1307                                 cmd.Dispose ();
1308
1309                                 cmd = conn.CreateCommand ();
1310                                 cmd.CommandText = insert_data;
1311                                 param = cmd.Parameters.Add ("type_char", OdbcType.Char, 3);
1312                                 param.Value = "ABCD";
1313                                 cmd.ExecuteNonQuery ();
1314                                 cmd.Dispose ();
1315
1316                                 cmd = conn.CreateCommand ();
1317                                 cmd.CommandText = select_data;
1318                                 param = cmd.Parameters.Add ("type_char", OdbcType.Char, 3);
1319                                 param.Value = "ABCE ";
1320                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1321                                 param.Value = 6000;
1322                                 dr = cmd.ExecuteReader ();
1323                                 Assert.IsTrue (dr.Read (), "#E1");
1324                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
1325                                 Assert.AreEqual (6000, dr.GetValue (0), "#E3");
1326                                 Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#E4");
1327                                 if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
1328                                         Assert.AreEqual ("ABC", dr.GetValue (1), "#E5");
1329                                 else
1330                                         Assert.AreEqual ("ABC       ", dr.GetValue (1), "#E5");
1331                                 Assert.IsFalse (dr.Read (), "#E6");
1332                                 dr.Close ();
1333                                 cmd.Dispose ();
1334
1335                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1336
1337                                 cmd = conn.CreateCommand ();
1338                                 cmd.CommandText = insert_data;
1339                                 param = cmd.Parameters.Add ("type_char", OdbcType.Char, 20);
1340                                 param.Value = "ABCDEFGHIJ";
1341                                 cmd.ExecuteNonQuery ();
1342                                 cmd.Dispose ();
1343
1344                                 cmd = conn.CreateCommand ();
1345                                 cmd.CommandText = select_data;
1346                                 param = cmd.Parameters.Add ("type_char", OdbcType.Char);
1347                                 param.Value = "ABCDEFGHIJ";
1348                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1349                                 param.Value = 6000;
1350                                 dr = cmd.ExecuteReader ();
1351                                 Assert.IsTrue (dr.Read (), "#F1");
1352                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
1353                                 Assert.AreEqual (6000, dr.GetValue (0), "#F3");
1354                                 Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#F4");
1355                                 Assert.AreEqual ("ABCDEFGHIJ", dr.GetValue (1), "#F5");
1356                                 Assert.IsFalse (dr.Read (), "#F6");
1357                                 dr.Close ();
1358                                 cmd.Dispose ();
1359
1360                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1361
1362                                 cmd = conn.CreateCommand ();
1363                                 cmd.CommandText = insert_data;
1364                                 param = cmd.Parameters.Add ("type_char", OdbcType.Char, 20);
1365                                 param.Value = string.Empty;
1366                                 cmd.ExecuteNonQuery ();
1367                                 cmd.Dispose ();
1368
1369                                 cmd = conn.CreateCommand ();
1370                                 cmd.CommandText = select_data;
1371                                 param = cmd.Parameters.Add ("type_char", OdbcType.Char);
1372                                 param.Value = string.Empty;
1373                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1374                                 param.Value = 6000;
1375                                 dr = cmd.ExecuteReader ();
1376                                 Assert.IsTrue (dr.Read (), "#G1");
1377                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
1378                                 Assert.AreEqual (6000, dr.GetValue (0), "#G3");
1379                                 Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#G4");
1380                                 if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
1381                                         Assert.AreEqual (string.Empty, dr.GetValue (1), "#G5");
1382                                 else
1383                                         Assert.AreEqual ("          ", dr.GetValue (1), "#G5");
1384                                 Assert.IsFalse (dr.Read (), "#G6");
1385                                 dr.Close ();
1386                                 cmd.Dispose ();
1387
1388                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1389
1390                                 cmd = conn.CreateCommand ();
1391                                 cmd.CommandText = insert_data;
1392                                 param = cmd.Parameters.Add ("type_char", OdbcType.Char);
1393                                 param.Value = DBNull.Value;
1394                                 cmd.ExecuteNonQuery ();
1395                                 cmd.Dispose ();
1396
1397                                 cmd = conn.CreateCommand ();
1398                                 cmd.CommandText = select_by_id;
1399                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1400                                 param.Value = 4;
1401                                 dr = cmd.ExecuteReader ();
1402                                 Assert.IsTrue (dr.Read (), "#H1");
1403                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
1404                                 Assert.AreEqual (4, dr.GetValue (0), "#H3");
1405                                 Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#H4");
1406                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
1407                                 Assert.IsFalse (dr.Read (), "#H6");
1408                                 dr.Close ();
1409                                 cmd.Dispose ();
1410                         } finally {
1411                                 if (dr != null)
1412                                         dr.Close ();
1413                                 if (cmd != null)
1414                                         cmd.Dispose ();
1415                                 conn.Close ();
1416                                 conn.Open ();
1417                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1418                                 conn.Close ();
1419                         }
1420                 }
1421
1422                 [Test]
1423                 public void DecimalParameterTest ()
1424                 {
1425                         string select_data1 = "select id, type_decimal1 from numeric_family where type_decimal1 = ? and id = ?";
1426                         string select_data2 = "select id, type_decimal2 from numeric_family where type_decimal2 = ? and id = ?";
1427                         string select_by_id = "select id, type_decimal1, type_decimal2 from numeric_family where id = ?";
1428                         string insert_data = "insert into numeric_family (id, type_decimal1, type_decimal2) values (6000, ?, ?)";
1429                         string delete_data = "delete from numeric_family where id = 6000";
1430
1431                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
1432
1433                         IDataReader dr = null;
1434                         OdbcCommand cmd = null;
1435                         OdbcParameter param;
1436
1437                         try {
1438                                 cmd = (OdbcCommand) conn.CreateCommand ();
1439                                 cmd.CommandText = select_data1;
1440                                 param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
1441                                 param.Value = 1000.00m;
1442                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1443                                 param.Value = 1;
1444                                 dr = cmd.ExecuteReader ();
1445                                 Assert.IsTrue (dr.Read (), "#A1");
1446                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
1447                                 Assert.AreEqual (1, dr.GetValue (0), "#A3");
1448                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#A4");
1449                                 Assert.AreEqual (1000m, dr.GetValue (1), "#A5");
1450                                 Assert.IsFalse (dr.Read (), "#A6");
1451                                 dr.Close ();
1452                                 cmd.Dispose ();
1453
1454                                 cmd = (OdbcCommand) conn.CreateCommand ();
1455                                 cmd.CommandText = select_data1;
1456                                 param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
1457                                 param.Value = -1000.00m;
1458                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1459                                 param.Value = 2;
1460                                 dr = cmd.ExecuteReader ();
1461                                 Assert.IsTrue (dr.Read (), "#B1");
1462                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
1463                                 Assert.AreEqual (2, dr.GetValue (0), "#B3");
1464                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#B4");
1465                                 Assert.AreEqual (-1000m, dr.GetValue (1), "#B5");
1466                                 Assert.IsFalse (dr.Read (), "#B6");
1467                                 dr.Close ();
1468                                 cmd.Dispose ();
1469
1470                                 cmd = (OdbcCommand) conn.CreateCommand ();
1471                                 cmd.CommandText = select_data2;
1472                                 param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
1473                                 param.Value = 4456.432m;
1474                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1475                                 param.Value = 1;
1476                                 dr = cmd.ExecuteReader ();
1477                                 Assert.IsTrue (dr.Read (), "#C1");
1478                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
1479                                 Assert.AreEqual (1, dr.GetValue (0), "#C3");
1480                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#C4");
1481                                 Assert.AreEqual (4456.432m, dr.GetValue (1), "#C5");
1482                                 Assert.IsFalse (dr.Read (), "#C6");
1483                                 dr.Close ();
1484                                 cmd.Dispose ();
1485
1486                                 cmd = (OdbcCommand) conn.CreateCommand ();
1487                                 cmd.CommandText = select_data2;
1488                                 param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
1489                                 param.Value = -4456.432m;
1490                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1491                                 param.Value = 2;
1492                                 dr = cmd.ExecuteReader ();
1493                                 Assert.IsTrue (dr.Read (), "#D1");
1494                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
1495                                 Assert.AreEqual (2, dr.GetValue (0), "#D3");
1496                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#D4");
1497                                 Assert.AreEqual (-4456.432m, dr.GetValue (1), "#D5");
1498                                 Assert.IsFalse (dr.Read (), "#D6");
1499                                 dr.Close ();
1500                                 cmd.Dispose ();
1501
1502                                 cmd = (OdbcCommand) conn.CreateCommand ();
1503                                 cmd.CommandText = select_data1;
1504                                 param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
1505                                 param.Value = 0m;
1506                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1507                                 param.Value = 3;
1508                                 dr = cmd.ExecuteReader ();
1509                                 Assert.IsTrue (dr.Read (), "#E1");
1510                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
1511                                 Assert.AreEqual (3, dr.GetValue (0), "#E3");
1512                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#E4");
1513                                 Assert.AreEqual (0m, dr.GetValue (1), "#E5");
1514                                 Assert.IsFalse (dr.Read (), "#E6");
1515                                 dr.Close ();
1516                                 cmd.Dispose ();
1517
1518                                 cmd = (OdbcCommand) conn.CreateCommand ();
1519                                 cmd.CommandText = select_data1;
1520                                 param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
1521                                 param.Value = DBNull.Value;
1522                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1523                                 param.Value = 4;
1524                                 dr = cmd.ExecuteReader ();
1525                                 Assert.IsFalse (dr.Read (), "#F");
1526                                 dr.Close ();
1527                                 cmd.Dispose ();
1528
1529                                 cmd = (OdbcCommand) conn.CreateCommand ();
1530                                 cmd.CommandText = select_by_id;
1531                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1532                                 param.Value = 4;
1533                                 dr = cmd.ExecuteReader ();
1534                                 Assert.IsTrue (dr.Read (), "#G1");
1535                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
1536                                 Assert.AreEqual (4, dr.GetValue (0), "#G3");
1537                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#G4");
1538                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#G5");
1539                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#G6");
1540                                 Assert.AreEqual (DBNull.Value, dr.GetValue (2), "#G7");
1541                                 Assert.IsFalse (dr.Read (), "#G8");
1542                                 dr.Close ();
1543                                 cmd.Dispose ();
1544
1545                                 cmd = (OdbcCommand) conn.CreateCommand ();
1546                                 cmd.CommandText = insert_data;
1547                                 param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
1548                                 param.Value = -1000.5678m;
1549                                 param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
1550                                 param.Value = -1000.5678m;
1551                                 cmd.ExecuteNonQuery ();
1552                                 cmd.Dispose ();
1553
1554                                 cmd = (OdbcCommand) conn.CreateCommand ();
1555                                 cmd.CommandText = select_data1;
1556                                 param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
1557                                 param.Value = -1000.5678m;
1558                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1559                                 param.Value = 6000;
1560                                 dr = cmd.ExecuteReader ();
1561                                 Assert.IsFalse (dr.Read (), "#H");
1562                                 dr.Close ();
1563                                 cmd.Dispose ();
1564
1565                                 cmd = (OdbcCommand) conn.CreateCommand ();
1566                                 cmd.CommandText = select_data1;
1567                                 param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
1568                                 param.Value = -1001;
1569                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1570                                 param.Value = 6000;
1571                                 dr = cmd.ExecuteReader ();
1572                                 Assert.IsTrue (dr.Read (), "#I1");
1573                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#I2");
1574                                 Assert.AreEqual (6000, dr.GetValue (0), "#I3");
1575                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#I4");
1576                                 Assert.AreEqual (-1001m, dr.GetValue (1), "#I5");
1577                                 Assert.IsFalse (dr.Read (), "#I6");
1578                                 dr.Close ();
1579                                 cmd.Dispose ();
1580
1581                                 cmd = (OdbcCommand) conn.CreateCommand ();
1582                                 cmd.CommandText = select_data2;
1583                                 param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
1584                                 param.Value = -1000.5678m;
1585                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1586                                 param.Value = 6000;
1587                                 dr = cmd.ExecuteReader ();
1588                                 Assert.IsFalse (dr.Read (), "#J");
1589                                 dr.Close ();
1590                                 cmd.Dispose ();
1591
1592                                 cmd = (OdbcCommand) conn.CreateCommand ();
1593                                 cmd.CommandText = select_data2;
1594                                 param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
1595                                 param.Value = -1000.568m;
1596                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1597                                 param.Value = 6000;
1598                                 dr = cmd.ExecuteReader ();
1599                                 Assert.IsTrue (dr.Read (), "#K1");
1600                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#K2");
1601                                 Assert.AreEqual (6000, dr.GetValue (0), "#K3");
1602                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#K4");
1603                                 Assert.AreEqual (-1000.568m, dr.GetValue (1), "#K5");
1604                                 Assert.IsFalse (dr.Read (), "#K6");
1605                                 dr.Close ();
1606                                 cmd.Dispose ();
1607
1608                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1609
1610                                 cmd = (OdbcCommand) conn.CreateCommand ();
1611                                 cmd.CommandText = insert_data;
1612                                 param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
1613                                 param.Value = 56789m;
1614                                 param.Precision = 7;
1615                                 param.Scale = 2;
1616                                 param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
1617                                 param.Value = 98765.5678m;
1618                                 param.Precision = 10;
1619                                 param.Scale = 2;
1620                                 cmd.ExecuteNonQuery ();
1621                                 cmd.Dispose ();
1622
1623                                 cmd = (OdbcCommand) conn.CreateCommand ();
1624                                 cmd.CommandText = select_by_id;
1625                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1626                                 param.Value = 6000;
1627                                 dr = cmd.ExecuteReader ();
1628                                 Assert.IsTrue (dr.Read (), "#L1");
1629                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#L2");
1630                                 Assert.AreEqual (6000, dr.GetValue (0), "#L3");
1631                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#L4");
1632                                 Assert.AreEqual (56789m, dr.GetValue (1), "#L5");
1633                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#L6");
1634                                 if (ConnectionManager.Instance.Odbc.EngineConfig.Type == EngineType.MySQL)
1635                                         Assert.AreEqual (9876556.780m, dr.GetValue (2), "#L7");
1636                                 else
1637                                         Assert.AreEqual (98765.570m, dr.GetValue (2), "#L7");
1638                                 Assert.IsFalse (dr.Read (), "#L8");
1639                                 dr.Close ();
1640                                 cmd.Dispose ();
1641
1642                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1643
1644                                 cmd = (OdbcCommand) conn.CreateCommand ();
1645                                 cmd.CommandText = insert_data;
1646                                 param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
1647                                 param.Value = DBNull.Value;
1648                                 param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
1649                                 param.Value = DBNull.Value;
1650                                 cmd.ExecuteNonQuery ();
1651                                 cmd.Dispose ();
1652
1653                                 cmd = (OdbcCommand) conn.CreateCommand ();
1654                                 cmd.CommandText = select_by_id;
1655                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1656                                 param.Value = 6000;
1657                                 dr = cmd.ExecuteReader ();
1658                                 Assert.IsTrue (dr.Read (), "#M1");
1659                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#M2");
1660                                 Assert.AreEqual (6000, dr.GetValue (0), "#M3");
1661                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#M4");
1662                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#M5");
1663                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#M6");
1664                                 Assert.AreEqual (DBNull.Value, dr.GetValue(1), "#M7");
1665                                 Assert.AreEqual (DBNull.Value, dr.GetValue (2), "#M8");
1666                                 Assert.IsFalse (dr.Read (), "#M9");
1667                                 dr.Close ();
1668                                 cmd.Dispose ();
1669                         } finally {
1670                                 if (cmd != null)
1671                                         cmd.Dispose ();
1672                                 if (dr != null)
1673                                         dr.Close ();
1674                                 conn.Close ();
1675                                 conn.Open ();
1676                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1677                                 conn.Close ();
1678                         }
1679                 }
1680
1681                 [Test]
1682                 public void DoubleParameterTest ()
1683                 {
1684                         string insert_data = "insert into numeric_family (id, type_double) values (6000, ?)";
1685                         string select_data = "select id, type_double from numeric_family where type_double = ? and id = ?";
1686                         string select_by_id = "select id, type_double from numeric_family where id = ?";
1687                         string delete_data = "delete from numeric_family where id = 6000";
1688
1689                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
1690
1691                         IDataReader dr = null;
1692                         OdbcCommand cmd = null;
1693                         OdbcParameter param;
1694
1695                         try {
1696                                 cmd = (OdbcCommand) conn.CreateCommand ();
1697                                 cmd.CommandText = select_data;
1698                                 param = cmd.Parameters.Add ("type_double", OdbcType.Double);
1699                                 param.Value = 1.79E+308;
1700                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1701                                 param.Value = 1;
1702                                 dr = cmd.ExecuteReader ();
1703                                 Assert.IsTrue (dr.Read (), "#A1");
1704                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
1705                                 Assert.AreEqual (1, dr.GetValue (0), "#A3");
1706                                 Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#A4");
1707                                 Assert.AreEqual (1.79E+308, dr.GetValue (1), "#A5");
1708                                 Assert.IsFalse (dr.Read (), "#A6");
1709                                 dr.Close ();
1710                                 cmd.Dispose ();
1711
1712                                 cmd = (OdbcCommand) conn.CreateCommand ();
1713                                 cmd.CommandText = select_data;
1714                                 param = cmd.Parameters.Add ("type_double", OdbcType.Double);
1715                                 param.Value = -1.79E+308;
1716                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1717                                 param.Value = 2;
1718                                 dr = cmd.ExecuteReader ();
1719                                 Assert.IsTrue (dr.Read (), "#B1");
1720                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
1721                                 Assert.AreEqual (2, dr.GetValue (0), "#B3");
1722                                 Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#B4");
1723                                 Assert.AreEqual (-1.79E+308, dr.GetValue (1), "#B5");
1724                                 Assert.IsFalse (dr.Read (), "#B6");
1725                                 dr.Close ();
1726                                 cmd.Dispose ();
1727
1728                                 cmd = (OdbcCommand) conn.CreateCommand ();
1729                                 cmd.CommandText = select_data;
1730                                 param = cmd.Parameters.Add ("type_double", OdbcType.Double);
1731                                 param.Value = 0d;
1732                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1733                                 param.Value = 3;
1734                                 dr = cmd.ExecuteReader ();
1735                                 Assert.IsTrue (dr.Read (), "#C1");
1736                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
1737                                 Assert.AreEqual (3, dr.GetValue (0), "#C3");
1738                                 Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#C4");
1739                                 Assert.AreEqual (0d, dr.GetValue (1), "#C5");
1740                                 Assert.IsFalse (dr.Read (), "#C6");
1741                                 dr.Close ();
1742                                 cmd.Dispose ();
1743
1744                                 cmd = (OdbcCommand) conn.CreateCommand ();
1745                                 cmd.CommandText = select_by_id;
1746                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1747                                 param.Value = 4;
1748                                 dr = cmd.ExecuteReader ();
1749                                 Assert.IsTrue (dr.Read (), "#D1");
1750                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
1751                                 Assert.AreEqual (4, dr.GetValue (0), "#D3");
1752                                 Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#D4");
1753                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
1754                                 Assert.IsFalse (dr.Read (), "#D6");
1755                                 dr.Close ();
1756                                 cmd.Dispose ();
1757
1758                                 cmd = (OdbcCommand) conn.CreateCommand ();
1759                                 cmd.CommandText = insert_data;
1760                                 param = cmd.Parameters.Add ("type_double", OdbcType.Double);
1761                                 param.Value = 1.79E+308;
1762                                 cmd.ExecuteNonQuery ();
1763                                 cmd.Dispose ();
1764
1765                                 cmd = (OdbcCommand) conn.CreateCommand ();
1766                                 cmd.CommandText = select_data;
1767                                 param = cmd.Parameters.Add ("type_double", OdbcType.Double);
1768                                 param.Value = 1.79E+308;
1769                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1770                                 param.Value = 6000;
1771                                 dr = cmd.ExecuteReader ();
1772                                 Assert.IsTrue (dr.Read (), "#E1");
1773                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
1774                                 Assert.AreEqual (6000, dr.GetValue (0), "#E3");
1775                                 Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#E4");
1776                                 Assert.AreEqual (1.79E+308, dr.GetValue (1), "#E5");
1777                                 Assert.IsFalse (dr.Read (), "#E6");
1778                                 dr.Close ();
1779                                 cmd.Dispose ();
1780
1781                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1782
1783                                 cmd = (OdbcCommand) conn.CreateCommand ();
1784                                 cmd.CommandText = insert_data;
1785                                 param = cmd.Parameters.Add ("type_double", OdbcType.Double);
1786                                 param.Value = -1.79E+308;
1787                                 cmd.ExecuteNonQuery ();
1788                                 cmd.Dispose ();
1789
1790                                 cmd = (OdbcCommand) conn.CreateCommand ();
1791                                 cmd.CommandText = select_data;
1792                                 param = cmd.Parameters.Add ("type_double", OdbcType.Double);
1793                                 param.Value = -1.79E+308;
1794                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1795                                 param.Value = 6000;
1796                                 dr = cmd.ExecuteReader ();
1797                                 Assert.IsTrue (dr.Read (), "#F1");
1798                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
1799                                 Assert.AreEqual (6000, dr.GetValue (0), "#F3");
1800                                 Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#F4");
1801                                 Assert.AreEqual (-1.79E+308, dr.GetValue (1), "#F5");
1802                                 Assert.IsFalse (dr.Read (), "#F6");
1803                                 dr.Close ();
1804                                 cmd.Dispose ();
1805
1806                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1807
1808                                 cmd = (OdbcCommand) conn.CreateCommand ();
1809                                 cmd.CommandText = insert_data;
1810                                 param = cmd.Parameters.Add ("type_double", OdbcType.Double);
1811                                 param.Value = "45543,55";
1812                                 cmd.ExecuteNonQuery ();
1813                                 cmd.Dispose ();
1814
1815                                 cmd = (OdbcCommand) conn.CreateCommand ();
1816                                 cmd.CommandText = select_data;
1817                                 param = cmd.Parameters.Add ("type_double", OdbcType.Double);
1818                                 param.Value = "45543,55";
1819                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1820                                 param.Value = 6000;
1821                                 dr = cmd.ExecuteReader ();
1822                                 Assert.IsTrue (dr.Read (), "#G1");
1823                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
1824                                 Assert.AreEqual (6000, dr.GetValue (0), "#G3");
1825                                 Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#G4");
1826                                 Assert.AreEqual (45543.55d, dr.GetValue (1), "#G5");
1827                                 Assert.IsFalse (dr.Read (), "#G6");
1828                                 dr.Close ();
1829                                 cmd.Dispose ();
1830
1831                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1832
1833                                 cmd = (OdbcCommand) conn.CreateCommand ();
1834                                 cmd.CommandText = insert_data;
1835                                 param = cmd.Parameters.Add ("type_double", OdbcType.Double);
1836                                 param.Value = DBNull.Value;
1837                                 cmd.ExecuteNonQuery ();
1838                                 cmd.Dispose ();
1839
1840                                 cmd = (OdbcCommand) conn.CreateCommand ();
1841                                 cmd.CommandText = select_by_id;
1842                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1843                                 param.Value = 6000;
1844                                 dr = cmd.ExecuteReader ();
1845                                 Assert.IsTrue (dr.Read (), "#H1");
1846                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
1847                                 Assert.AreEqual (6000, dr.GetValue (0), "#H3");
1848                                 Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#H4");
1849                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
1850                                 Assert.IsFalse (dr.Read (), "#H6");
1851                                 dr.Close ();
1852                                 cmd.Dispose ();
1853                         } finally {
1854                                 if (dr != null)
1855                                         dr.Close ();
1856                                 if (cmd != null)
1857                                         cmd.Dispose ();
1858                                 conn.Close ();
1859                                 conn.Open ();
1860                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1861                                 conn.Close ();
1862                         }
1863                 }
1864
1865                 [Test]
1866                 public void ImageParameterTest ()
1867                 {
1868                         string insert_data = "insert into binary_family (id, type_blob) values (6000, ?)";
1869                         string select_data = "select type_blob from binary_family where id = ?";
1870                         string delete_data = "delete from binary_family where id = 6000";
1871
1872                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
1873
1874                         IDataReader dr = null;
1875                         OdbcCommand cmd = null;
1876                         OdbcParameter param;
1877
1878                         try {
1879                                 byte [] bytes = new byte [] { 0x32, 0x56, 0x00,
1880                                         0x44, 0x22 };
1881
1882                                 cmd = (OdbcCommand) conn.CreateCommand ();
1883                                 cmd.CommandText = select_data;
1884                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1885                                 param.Value = 1;
1886                                 dr = cmd.ExecuteReader ();
1887                                 Assert.IsTrue (dr.Read (), "#A1");
1888                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#A2");
1889                                 Assert.AreEqual (bytes, dr.GetValue (0), "#A3");
1890                                 Assert.IsFalse (dr.Read (), "#A4");
1891                                 dr.Close ();
1892                                 cmd.Dispose ();
1893
1894                                 bytes = new byte [] { 0x00, 0x66, 0x06, 0x66,
1895                                         0x97, 0x00, 0x66, 0x06, 0x66, 0x97, 0x06,
1896                                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
1897                                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
1898                                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
1899                                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
1900                                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
1901                                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
1902                                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
1903                                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
1904                                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
1905                                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
1906                                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
1907                                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
1908                                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
1909                                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
1910                                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
1911                                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
1912                                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
1913                                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
1914                                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
1915                                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
1916                                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
1917                                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
1918                                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
1919                                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
1920                                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
1921                                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
1922                                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
1923                                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
1924                                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
1925                                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
1926                                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
1927                                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
1928                                         0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
1929                                         0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
1930                                         0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
1931                                         0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
1932                                         0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
1933                                         0x06, 0x66, 0x06, 0x66, 0x98};
1934
1935                                 cmd = (OdbcCommand) conn.CreateCommand ();
1936                                 cmd.CommandText = select_data;
1937                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1938                                 param.Value = 2;
1939                                 dr = cmd.ExecuteReader ();
1940                                 Assert.IsTrue (dr.Read (), "#B1");
1941                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#B2");
1942                                 Assert.AreEqual (bytes, dr.GetValue (0), "#B3");
1943                                 Assert.IsFalse (dr.Read (), "#B4");
1944                                 dr.Close ();
1945                                 cmd.Dispose ();
1946
1947                                 bytes = new byte [8];
1948
1949                                 cmd = (OdbcCommand) conn.CreateCommand ();
1950                                 cmd.CommandText = select_data;
1951                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1952                                 param.Value = 3;
1953                                 dr = cmd.ExecuteReader ();
1954                                 Assert.IsTrue (dr.Read (), "#C1");
1955                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#C2");
1956                                 Assert.AreEqual (new byte [0], dr.GetValue (0), "#C3");
1957                                 Assert.IsFalse (dr.Read (), "#C4");
1958                                 dr.Close ();
1959                                 cmd.Dispose ();
1960
1961                                 cmd = (OdbcCommand) conn.CreateCommand ();
1962                                 cmd.CommandText = select_data;
1963                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1964                                 param.Value = 4;
1965                                 dr = cmd.ExecuteReader ();
1966                                 Assert.IsTrue (dr.Read (), "#D1");
1967                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#D2");
1968                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
1969                                 Assert.IsFalse (dr.Read (), "#D4");
1970                                 dr.Close ();
1971                                 cmd.Dispose ();
1972
1973                                 bytes = new byte [0];
1974
1975                                 cmd = (OdbcCommand) conn.CreateCommand ();
1976                                 cmd.CommandText = insert_data;
1977                                 param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
1978                                 param.Value = bytes;
1979                                 cmd.ExecuteNonQuery ();
1980                                 cmd.Dispose ();
1981
1982                                 cmd = (OdbcCommand) conn.CreateCommand ();
1983                                 cmd.CommandText = select_data;
1984                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
1985                                 param.Value = 6000;
1986                                 dr = cmd.ExecuteReader ();
1987                                 Assert.IsTrue (dr.Read (), "#E1");
1988                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#E2");
1989                                 Assert.AreEqual (bytes, dr.GetValue (0), "#E3");
1990                                 Assert.IsFalse (dr.Read (), "#E4");
1991                                 dr.Close ();
1992                                 cmd.Dispose ();
1993
1994                                 DBHelper.ExecuteNonQuery (conn, delete_data);
1995
1996                                 bytes = new byte [] { 0x05 };
1997
1998                                 cmd = (OdbcCommand) conn.CreateCommand ();
1999                                 cmd.CommandText = insert_data;
2000                                 param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
2001                                 param.Value = bytes;
2002                                 cmd.ExecuteNonQuery ();
2003                                 cmd.Dispose ();
2004
2005                                 cmd = (OdbcCommand) conn.CreateCommand ();
2006                                 cmd.CommandText = select_data;
2007                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2008                                 param.Value = 6000;
2009                                 dr = cmd.ExecuteReader ();
2010                                 Assert.IsTrue (dr.Read (), "#F1");
2011                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#F2");
2012                                 Assert.AreEqual (bytes, dr.GetValue (0), "#F3");
2013                                 Assert.IsFalse (dr.Read (), "#F4");
2014                                 dr.Close ();
2015                                 cmd.Dispose ();
2016
2017                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2018
2019                                 bytes = new byte [] { 0x34, 0x00, 0x32 };
2020
2021                                 cmd = (OdbcCommand) conn.CreateCommand ();
2022                                 cmd.CommandText = insert_data;
2023                                 param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
2024                                 param.Value = bytes;
2025                                 cmd.ExecuteNonQuery ();
2026                                 cmd.Dispose ();
2027
2028                                 cmd = (OdbcCommand) conn.CreateCommand ();
2029                                 cmd.CommandText = select_data;
2030                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2031                                 param.Value = 6000;
2032                                 dr = cmd.ExecuteReader ();
2033                                 Assert.IsTrue (dr.Read (), "#G1");
2034                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#G2");
2035                                 Assert.AreEqual (bytes, dr.GetValue (0), "#G3");
2036                                 Assert.IsFalse (dr.Read (), "#G4");
2037                                 dr.Close ();
2038                                 cmd.Dispose ();
2039
2040                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2041
2042                                 bytes = new byte [] { 0x34, 0x00, 0x32, 0x05, 0x07, 0x13 };
2043
2044                                 cmd = (OdbcCommand) conn.CreateCommand ();
2045                                 cmd.CommandText = insert_data;
2046                                 param = cmd.Parameters.Add ("type_blob", OdbcType.Image, 4);
2047                                 param.Value = bytes;
2048                                 cmd.ExecuteNonQuery ();
2049                                 cmd.Dispose ();
2050
2051                                 cmd = (OdbcCommand) conn.CreateCommand ();
2052                                 cmd.CommandText = select_data;
2053                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2054                                 param.Value = 6000;
2055                                 dr = cmd.ExecuteReader ();
2056                                 Assert.IsTrue (dr.Read (), "#H1");
2057                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#H2");
2058                                 Assert.AreEqual (new byte [] { 0x34, 0x00, 0x32, 0x05 }, dr.GetValue (0), "#H3");
2059                                 Assert.IsFalse (dr.Read (), "#H4");
2060                                 dr.Close ();
2061                                 cmd.Dispose ();
2062
2063                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2064
2065                                 cmd = (OdbcCommand) conn.CreateCommand ();
2066                                 cmd.CommandText = insert_data;
2067                                 param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
2068                                 param.Value = DBNull.Value;
2069                                 cmd.ExecuteNonQuery ();
2070                                 cmd.Dispose ();
2071
2072                                 cmd = (OdbcCommand) conn.CreateCommand ();
2073                                 cmd.CommandText = select_data;
2074                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2075                                 param.Value = 6000;
2076                                 dr = cmd.ExecuteReader ();
2077                                 Assert.IsTrue (dr.Read (), "#I1");
2078                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#I2");
2079                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#I3");
2080                                 Assert.IsFalse (dr.Read (), "#I4");
2081                                 dr.Close ();
2082                                 cmd.Dispose ();
2083                         } finally {
2084                                 if (dr != null)
2085                                         dr.Close ();
2086                                 if (cmd != null)
2087                                         cmd.Dispose ();
2088                                 conn.Close ();
2089                                 conn.Open ();
2090                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2091                                 conn.Close ();
2092                         }
2093                 }
2094
2095                 [Test]
2096                 public void NCharParameterTest ()
2097                 {
2098                         string insert_data = "insert into string_family (id, type_nchar) values (6000, ?)";
2099                         string select_data = "select type_nchar from string_family where type_nchar = ? and id = ?";
2100                         string select_by_id = "select type_nchar from string_family where id = ?";
2101                         string delete_data = "delete from string_family where id = 6000";
2102
2103                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
2104
2105                         IDataReader dr = null;
2106                         OdbcCommand cmd = null;
2107                         OdbcParameter param;
2108
2109                         try {
2110                                 cmd = conn.CreateCommand ();
2111                                 cmd.CommandText = select_data;
2112                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
2113                                 param.Value = "nch\u092d\u093er";
2114                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2115                                 param.Value = 1;
2116                                 dr = cmd.ExecuteReader ();
2117                                 Assert.IsTrue (dr.Read (), "#A1");
2118                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
2119                                 if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
2120                                         Assert.AreEqual ("nch\u092d\u093er", dr.GetValue (0), "#A3");
2121                                 else
2122                                         Assert.AreEqual ("nch\u092d\u093er    ", dr.GetValue (0), "#A3");
2123                                 Assert.IsFalse (dr.Read (), "#A4");
2124                                 dr.Close ();
2125                                 cmd.Dispose ();
2126
2127                                 cmd = conn.CreateCommand ();
2128                                 cmd.CommandText = select_data;
2129                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
2130                                 param.Value = "0123456789";
2131                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2132                                 param.Value = 2;
2133                                 dr = cmd.ExecuteReader ();
2134                                 Assert.IsTrue (dr.Read (), "#B1");
2135                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
2136                                 Assert.AreEqual ("0123456789", dr.GetValue (0), "#B3");
2137                                 Assert.IsFalse (dr.Read (), "#B4");
2138                                 dr.Close ();
2139                                 cmd.Dispose ();
2140
2141                                 cmd = conn.CreateCommand ();
2142                                 cmd.CommandText = select_data;
2143                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
2144                                 param.Value = string.Empty;
2145                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2146                                 param.Value = 3;
2147                                 dr = cmd.ExecuteReader ();
2148                                 Assert.IsTrue (dr.Read (), "#C1");
2149                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
2150                                 if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
2151                                         Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
2152                                 else
2153                                         Assert.AreEqual ("          ", dr.GetValue (0), "#C3");
2154                                 Assert.IsFalse (dr.Read (), "#C4");
2155                                 dr.Close ();
2156                                 cmd.Dispose ();
2157
2158                                 cmd = conn.CreateCommand ();
2159                                 cmd.CommandText = select_by_id;
2160                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2161                                 param.Value = 4;
2162                                 dr = cmd.ExecuteReader ();
2163                                 Assert.IsTrue (dr.Read (), "#D1");
2164                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
2165                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
2166                                 Assert.IsFalse (dr.Read (), "#D4");
2167                                 dr.Close ();
2168                                 cmd.Dispose ();
2169
2170                                 cmd = conn.CreateCommand ();
2171                                 cmd.CommandText = insert_data;
2172                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
2173                                 param.Value = "nchar";
2174                                 cmd.ExecuteNonQuery ();
2175                                 cmd.Dispose ();
2176
2177                                 cmd = conn.CreateCommand ();
2178                                 cmd.CommandText = select_data;
2179                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
2180                                 param.Value = "nchar";
2181                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2182                                 param.Value = 6000;
2183                                 dr = cmd.ExecuteReader ();
2184                                 Assert.IsTrue (dr.Read (), "#E1");
2185                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
2186                                 if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
2187                                         Assert.AreEqual ("nchar", dr.GetValue (0), "#E3");
2188                                 else
2189                                         Assert.AreEqual ("nchar     ", dr.GetValue (0), "#E3");
2190                                 Assert.IsFalse (dr.Read (), "#E4");
2191                                 dr.Close ();
2192                                 cmd.Dispose ();
2193
2194                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2195
2196                                 cmd = conn.CreateCommand ();
2197                                 cmd.CommandText = insert_data;
2198                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 4);
2199                                 param.Value = "nch\u0488r";
2200                                 cmd.ExecuteNonQuery ();
2201                                 cmd.Dispose ();
2202
2203                                 cmd = conn.CreateCommand ();
2204                                 cmd.CommandText = select_data;
2205                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 4);
2206                                 param.Value = "nch\u0488r";
2207                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2208                                 param.Value = 6000;
2209                                 dr = cmd.ExecuteReader ();
2210                                 Assert.IsTrue (dr.Read (), "#F1");
2211                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
2212                                 if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
2213                                         Assert.AreEqual ("nch\u0488", dr.GetValue (0), "#F3");
2214                                 else
2215                                         Assert.AreEqual ("nch\u0488      ", dr.GetValue (0), "#F3");
2216                                 Assert.IsFalse (dr.Read (), "#F4");
2217                                 dr.Close ();
2218                                 cmd.Dispose ();
2219
2220                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2221
2222                                 cmd = conn.CreateCommand ();
2223                                 cmd.CommandText = insert_data;
2224                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 8);
2225                                 param.Value = "ch\u0488r";
2226                                 cmd.ExecuteNonQuery ();
2227                                 cmd.Dispose ();
2228
2229                                 cmd = conn.CreateCommand ();
2230                                 cmd.CommandText = select_data;
2231                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
2232                                 param.Value = "ch\u0488r";
2233                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2234                                 param.Value = 6000;
2235                                 dr = cmd.ExecuteReader ();
2236                                 Assert.IsTrue (dr.Read (), "#G1");
2237                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
2238                                 if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
2239                                         Assert.AreEqual ("ch\u0488r", dr.GetValue (0), "#G3");
2240                                 else
2241                                         Assert.AreEqual ("ch\u0488r      ", dr.GetValue (0), "#G3");
2242                                 Assert.IsFalse (dr.Read (), "#G4");
2243                                 dr.Close ();
2244                                 cmd.Dispose ();
2245
2246                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2247
2248                                 cmd = conn.CreateCommand ();
2249                                 cmd.CommandText = insert_data;
2250                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 15);
2251                                 param.Value = "0123456789";
2252                                 cmd.ExecuteNonQuery ();
2253                                 cmd.Dispose ();
2254
2255                                 cmd = conn.CreateCommand ();
2256                                 cmd.CommandText = select_data;
2257                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
2258                                 param.Value = "0123456789";
2259                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2260                                 param.Value = 6000;
2261                                 dr = cmd.ExecuteReader ();
2262                                 Assert.IsTrue (dr.Read (), "#H1");
2263                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
2264                                 Assert.AreEqual ("0123456789", dr.GetValue (0), "#H3");
2265                                 Assert.IsFalse (dr.Read (), "#H4");
2266                                 dr.Close ();
2267                                 cmd.Dispose ();
2268
2269                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2270
2271                                 cmd = conn.CreateCommand ();
2272                                 cmd.CommandText = insert_data;
2273                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 15);
2274                                 param.Value = string.Empty;
2275                                 cmd.ExecuteNonQuery ();
2276                                 cmd.Dispose ();
2277
2278                                 cmd = conn.CreateCommand ();
2279                                 cmd.CommandText = select_data;
2280                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
2281                                 param.Value = string.Empty;
2282                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2283                                 param.Value = 6000;
2284                                 dr = cmd.ExecuteReader ();
2285                                 Assert.IsTrue (dr.Read (), "#I1");
2286                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#I2");
2287                                 if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
2288                                         Assert.AreEqual (string.Empty, dr.GetValue (0), "#I3");
2289                                 else
2290                                         Assert.AreEqual ("          ", dr.GetValue (0), "#I3");
2291                                 Assert.IsFalse (dr.Read (), "#I4");
2292                                 dr.Close ();
2293                                 cmd.Dispose ();
2294
2295                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2296
2297                                 cmd = conn.CreateCommand ();
2298                                 cmd.CommandText = insert_data;
2299                                 param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
2300                                 param.Value = DBNull.Value;
2301                                 cmd.ExecuteNonQuery ();
2302                                 cmd.Dispose ();
2303
2304                                 cmd = conn.CreateCommand ();
2305                                 cmd.CommandText = select_by_id;
2306                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2307                                 param.Value = 6000;
2308                                 dr = cmd.ExecuteReader ();
2309                                 Assert.IsTrue (dr.Read (), "#J1");
2310                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#J2");
2311                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#J3");
2312                                 Assert.IsFalse (dr.Read (), "#J4");
2313                                 dr.Close ();
2314                                 cmd.Dispose ();
2315                         } finally {
2316                                 if (dr != null)
2317                                         dr.Close ();
2318                                 if (cmd != null)
2319                                         cmd.Dispose ();
2320                                 conn.Close ();
2321                                 conn.Open ();
2322                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2323                                 conn.Close ();;
2324                         }
2325                 }
2326
2327                 [Test]
2328                 public void NTextParameterTest ()
2329                 {
2330                         string insert_data = "insert into string_family (id, type_ntext) values (6000, ?)";
2331                         string select_by_id = "select type_ntext from string_family where id = ?";
2332                         string delete_data = "delete from string_family where id = 6000";
2333
2334                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
2335
2336                         IDataReader dr = null;
2337                         OdbcCommand cmd = null;
2338                         OdbcParameter param;
2339
2340                         try {
2341                                 cmd = conn.CreateCommand ();
2342                                 cmd.CommandText = select_by_id;
2343                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2344                                 param.Value = 1;
2345                                 dr = cmd.ExecuteReader ();
2346                                 Assert.IsTrue (dr.Read (), "#A1");
2347                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
2348                                 Assert.AreEqual ("nt\u092d\u093ext", dr.GetValue (0), "#A3");
2349                                 Assert.IsFalse (dr.Read (), "#A4");
2350                                 dr.Close ();
2351                                 cmd.Dispose ();
2352
2353                                 cmd = conn.CreateCommand ();
2354                                 cmd.CommandText = select_by_id;
2355                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2356                                 param.Value = 2;
2357                                 dr = cmd.ExecuteReader ();
2358                                 Assert.IsTrue (dr.Read (), "#B1");
2359                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
2360                                 Assert.AreEqual ("nt\u092d\u093ext ", dr.GetValue (0), "#B3");
2361                                 Assert.IsFalse (dr.Read (), "#B4");
2362                                 dr.Close ();
2363                                 cmd.Dispose ();
2364
2365                                 cmd = conn.CreateCommand ();
2366                                 cmd.CommandText = select_by_id;
2367                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2368                                 param.Value = 3;
2369                                 dr = cmd.ExecuteReader ();
2370                                 Assert.IsTrue (dr.Read (), "#C1");
2371                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
2372                                 Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
2373                                 Assert.IsFalse (dr.Read (), "#C4");
2374                                 dr.Close ();
2375                                 cmd.Dispose ();
2376
2377                                 cmd = conn.CreateCommand ();
2378                                 cmd.CommandText = select_by_id;
2379                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2380                                 param.Value = 4;
2381                                 dr = cmd.ExecuteReader ();
2382                                 Assert.IsTrue (dr.Read (), "#D1");
2383                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
2384                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
2385                                 Assert.IsFalse (dr.Read (), "#D4");
2386                                 dr.Close ();
2387                                 cmd.Dispose ();
2388
2389                                 cmd = conn.CreateCommand ();
2390                                 cmd.CommandText = insert_data;
2391                                 param = cmd.Parameters.Add ("type_ntext", OdbcType.NText, 4);
2392                                 param.Value = "nt\u0488xt";
2393                                 cmd.ExecuteNonQuery ();
2394                                 cmd.Dispose ();
2395
2396                                 cmd = (OdbcCommand) conn.CreateCommand ();
2397                                 cmd.CommandText = select_by_id;
2398                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2399                                 param.Value = 6000;
2400                                 dr = cmd.ExecuteReader ();
2401                                 Assert.IsTrue (dr.Read (), "#E1");
2402                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
2403                                 Assert.AreEqual ("nt\u0488x", dr.GetValue (0), "#E3");
2404                                 Assert.IsFalse (dr.Read (), "#E4");
2405                                 dr.Close ();
2406                                 cmd.Dispose ();
2407
2408                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2409
2410                                 cmd = conn.CreateCommand ();
2411                                 cmd.CommandText = insert_data;
2412                                 param = cmd.Parameters.Add ("type_ntext", OdbcType.NText, 15);
2413                                 param.Value = "nt\u0488xt ";
2414                                 cmd.ExecuteNonQuery ();
2415                                 cmd.Dispose ();
2416
2417                                 cmd = (OdbcCommand) conn.CreateCommand ();
2418                                 cmd.CommandText = select_by_id;
2419                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2420                                 param.Value = 6000;
2421                                 dr = cmd.ExecuteReader ();
2422                                 Assert.IsTrue (dr.Read (), "#F1");
2423                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
2424                                 Assert.AreEqual ("nt\u0488xt ", dr.GetValue (0), "#F3");
2425                                 Assert.IsFalse (dr.Read (), "#F4");
2426                                 dr.Close ();
2427                                 cmd.Dispose ();
2428
2429                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2430
2431                                 cmd = (OdbcCommand) conn.CreateCommand ();
2432                                 cmd.CommandText = insert_data;
2433                                 param = cmd.Parameters.Add ("type_ntext", OdbcType.NText, 8);
2434                                 param.Value = string.Empty;
2435                                 cmd.ExecuteNonQuery ();
2436                                 cmd.Dispose ();
2437
2438                                 cmd = (OdbcCommand) conn.CreateCommand ();
2439                                 cmd.CommandText = select_by_id;
2440                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2441                                 param.Value = 6000;
2442                                 dr = cmd.ExecuteReader ();
2443                                 Assert.IsTrue (dr.Read (), "#G1");
2444                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
2445                                 Assert.AreEqual (string.Empty, dr.GetValue (0), "#G3");
2446                                 Assert.IsFalse (dr.Read (), "#G4");
2447                                 dr.Close ();
2448                                 cmd.Dispose ();
2449
2450                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2451
2452                                 cmd = (OdbcCommand) conn.CreateCommand ();
2453                                 cmd.CommandText = insert_data;
2454                                 param = cmd.Parameters.Add ("type_ntext", OdbcType.NText, 8);
2455                                 param.Value = DBNull.Value;
2456                                 cmd.ExecuteNonQuery ();
2457                                 cmd.Dispose ();
2458
2459                                 cmd = (OdbcCommand) conn.CreateCommand ();
2460                                 cmd.CommandText = select_by_id;
2461                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2462                                 param.Value = 6000;
2463                                 dr = cmd.ExecuteReader ();
2464                                 Assert.IsTrue (dr.Read (), "#H1");
2465                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
2466                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#H3");
2467                                 Assert.IsFalse (dr.Read (), "#H4");
2468                                 dr.Close ();
2469                                 cmd.Dispose ();
2470                         } finally {
2471                                 if (dr != null)
2472                                         dr.Close ();
2473                                 if (cmd != null)
2474                                         cmd.Dispose ();
2475                                 conn.Close ();
2476                                 conn.Open ();
2477                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2478                                 conn.Close ();
2479                         }
2480                 }
2481
2482                 [Test]
2483                 public void TextParameterTest ()
2484                 {
2485                         string insert_data = "insert into string_family (id, type_text) values (6000, ?)";
2486                         string select_by_id = "select type_text from string_family where id = ?";
2487                         string delete_data = "delete from string_family where id = 6000";
2488
2489                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
2490
2491                         IDataReader dr = null;
2492                         OdbcCommand cmd = null;
2493                         OdbcParameter param;
2494
2495                         try {
2496                                 cmd = conn.CreateCommand ();
2497                                 cmd.CommandText = select_by_id;
2498                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2499                                 param.Value = 1;
2500                                 dr = cmd.ExecuteReader ();
2501                                 Assert.IsTrue (dr.Read (), "#A1");
2502                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
2503                                 Assert.AreEqual ("text", dr.GetValue (0), "#A3");
2504                                 Assert.IsFalse (dr.Read (), "#A4");
2505                                 dr.Close ();
2506                                 cmd.Dispose ();
2507
2508                                 StringBuilder sb = new StringBuilder ();
2509                                 for (int i = 0; i < 30; i++)
2510                                         sb.Append ("longtext ");
2511
2512                                 cmd = conn.CreateCommand ();
2513                                 cmd.CommandText = select_by_id;
2514                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2515                                 param.Value = 2;
2516                                 dr = cmd.ExecuteReader ();
2517                                 Assert.IsTrue (dr.Read (), "#B1");
2518                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
2519                                 Assert.AreEqual (sb.ToString (), dr.GetValue (0), "#B3");
2520                                 Assert.IsFalse (dr.Read (), "#B4");
2521                                 dr.Close ();
2522                                 cmd.Dispose ();
2523
2524                                 cmd = conn.CreateCommand ();
2525                                 cmd.CommandText = select_by_id;
2526                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2527                                 param.Value = 3;
2528                                 dr = cmd.ExecuteReader ();
2529                                 Assert.IsTrue (dr.Read (), "#C1");
2530                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
2531                                 Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
2532                                 Assert.IsFalse (dr.Read (), "#C4");
2533                                 dr.Close ();
2534                                 cmd.Dispose ();
2535
2536                                 cmd = conn.CreateCommand ();
2537                                 cmd.CommandText = select_by_id;
2538                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2539                                 param.Value = 4;
2540                                 dr = cmd.ExecuteReader ();
2541                                 Assert.IsTrue (dr.Read (), "#D1");
2542                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
2543                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
2544                                 Assert.IsFalse (dr.Read (), "#D4");
2545                                 dr.Close ();
2546                                 cmd.Dispose ();
2547
2548                                 cmd = conn.CreateCommand ();
2549                                 cmd.CommandText = insert_data;
2550                                 param = cmd.Parameters.Add ("type_text", OdbcType.Text);
2551                                 param.Value = sb.ToString ();
2552                                 cmd.ExecuteNonQuery ();
2553                                 cmd.Dispose ();
2554
2555                                 cmd = (OdbcCommand) conn.CreateCommand ();
2556                                 cmd.CommandText = select_by_id;
2557                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2558                                 param.Value = 6000;
2559                                 dr = cmd.ExecuteReader ();
2560                                 Assert.IsTrue (dr.Read (), "#E1");
2561                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
2562                                 Assert.AreEqual (sb.ToString (), dr.GetValue (0), "#E3");
2563                                 Assert.IsFalse (dr.Read (), "#E4");
2564                                 dr.Close ();
2565                                 cmd.Dispose ();
2566
2567                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2568
2569                                 cmd = conn.CreateCommand ();
2570                                 cmd.CommandText = insert_data;
2571                                 param = cmd.Parameters.Add ("type_text", OdbcType.Text, 2);
2572                                 param.Value = "text";
2573                                 cmd.ExecuteNonQuery ();
2574                                 cmd.Dispose ();
2575
2576                                 cmd = (OdbcCommand) conn.CreateCommand ();
2577                                 cmd.CommandText = select_by_id;
2578                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2579                                 param.Value = 6000;
2580                                 dr = cmd.ExecuteReader ();
2581                                 Assert.IsTrue (dr.Read (), "#F1");
2582                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
2583                                 Assert.AreEqual ("te", dr.GetValue (0), "#F3");
2584                                 Assert.IsFalse (dr.Read (), "#F4");
2585                                 dr.Close ();
2586                                 cmd.Dispose ();
2587
2588                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2589
2590                                 cmd = (OdbcCommand) conn.CreateCommand ();
2591                                 cmd.CommandText = insert_data;
2592                                 param = cmd.Parameters.Add ("type_text", OdbcType.Text, 8);
2593                                 param.Value = string.Empty;
2594                                 cmd.ExecuteNonQuery ();
2595                                 cmd.Dispose ();
2596
2597                                 cmd = (OdbcCommand) conn.CreateCommand ();
2598                                 cmd.CommandText = select_by_id;
2599                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2600                                 param.Value = 6000;
2601                                 dr = cmd.ExecuteReader ();
2602                                 Assert.IsTrue (dr.Read (), "#G1");
2603                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
2604                                 Assert.AreEqual (string.Empty, dr.GetValue (0), "#G3");
2605                                 Assert.IsFalse (dr.Read (), "#G4");
2606                                 dr.Close ();
2607                                 cmd.Dispose ();
2608
2609                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2610
2611                                 cmd = (OdbcCommand) conn.CreateCommand ();
2612                                 cmd.CommandText = insert_data;
2613                                 param = cmd.Parameters.Add ("type_text", OdbcType.Text, 8);
2614                                 param.Value = DBNull.Value;
2615                                 cmd.ExecuteNonQuery ();
2616                                 cmd.Dispose ();
2617
2618                                 cmd = (OdbcCommand) conn.CreateCommand ();
2619                                 cmd.CommandText = select_by_id;
2620                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2621                                 param.Value = 6000;
2622                                 dr = cmd.ExecuteReader ();
2623                                 Assert.IsTrue (dr.Read (), "#H1");
2624                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
2625                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#H3");
2626                                 Assert.IsFalse (dr.Read (), "#H4");
2627                                 dr.Close ();
2628                                 cmd.Dispose ();
2629                         } finally {
2630                                 if (dr != null)
2631                                         dr.Close ();
2632                                 if (cmd != null)
2633                                         cmd.Dispose ();
2634                                 conn.Close ();
2635                                 conn.Open ();
2636                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2637                                 conn.Close ();
2638                         }
2639                 }
2640
2641                 [Test]
2642                 public void NumericParameterTest ()
2643                 {
2644                         string select_data1 = "select id, type_numeric1 from numeric_family where type_numeric1 = ? and id = ?";
2645                         string select_data2 = "select id, type_numeric2 from numeric_family where type_numeric2 = ? and id = ?";
2646                         string select_by_id = "select id, type_numeric1, type_numeric2 from numeric_family where id = ?";
2647                         string insert_data = "insert into numeric_family (id, type_numeric1, type_numeric2) values (6000, ?, ?)";
2648                         string delete_data = "delete from numeric_family where id = 6000";
2649
2650                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
2651
2652                         IDataReader dr = null;
2653                         OdbcCommand cmd = null;
2654                         OdbcParameter param;
2655
2656                         try {
2657                                 cmd = (OdbcCommand) conn.CreateCommand ();
2658                                 cmd.CommandText = select_data1;
2659                                 param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
2660                                 param.Value = 1000.00m;
2661                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2662                                 param.Value = 1;
2663                                 dr = cmd.ExecuteReader ();
2664                                 Assert.IsTrue (dr.Read (), "#A1");
2665                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
2666                                 Assert.AreEqual (1, dr.GetValue (0), "#A3");
2667                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#A4");
2668                                 Assert.AreEqual (1000m, dr.GetValue (1), "#A5");
2669                                 Assert.IsFalse (dr.Read (), "#A6");
2670                                 dr.Close ();
2671                                 cmd.Dispose ();
2672
2673                                 cmd = (OdbcCommand) conn.CreateCommand ();
2674                                 cmd.CommandText = select_data1;
2675                                 param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
2676                                 param.Value = -1000.00m;
2677                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2678                                 param.Value = 2;
2679                                 dr = cmd.ExecuteReader ();
2680                                 Assert.IsTrue (dr.Read (), "#B1");
2681                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
2682                                 Assert.AreEqual (2, dr.GetValue (0), "#B3");
2683                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#B4");
2684                                 Assert.AreEqual (-1000m, dr.GetValue (1), "#B5");
2685                                 Assert.IsFalse (dr.Read (), "#B6");
2686                                 dr.Close ();
2687                                 cmd.Dispose ();
2688
2689                                 cmd = (OdbcCommand) conn.CreateCommand ();
2690                                 cmd.CommandText = select_data2;
2691                                 param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
2692                                 param.Value = 4456.432m;
2693                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2694                                 param.Value = 1;
2695                                 dr = cmd.ExecuteReader ();
2696                                 Assert.IsTrue (dr.Read (), "#C1");
2697                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
2698                                 Assert.AreEqual (1, dr.GetValue (0), "#C3");
2699                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#C4");
2700                                 Assert.AreEqual (4456.432m, dr.GetValue (1), "#C5");
2701                                 Assert.IsFalse (dr.Read (), "#C6");
2702                                 dr.Close ();
2703                                 cmd.Dispose ();
2704
2705                                 cmd = (OdbcCommand) conn.CreateCommand ();
2706                                 cmd.CommandText = select_data2;
2707                                 param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
2708                                 param.Value = -4456.432m;
2709                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2710                                 param.Value = 2;
2711                                 dr = cmd.ExecuteReader ();
2712                                 Assert.IsTrue (dr.Read (), "#D1");
2713                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
2714                                 Assert.AreEqual (2, dr.GetValue (0), "#D3");
2715                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#D4");
2716                                 Assert.AreEqual (-4456.432m, dr.GetValue (1), "#D5");
2717                                 Assert.IsFalse (dr.Read (), "#D6");
2718                                 dr.Close ();
2719                                 cmd.Dispose ();
2720
2721                                 cmd = (OdbcCommand) conn.CreateCommand ();
2722                                 cmd.CommandText = select_data1;
2723                                 param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
2724                                 param.Value = 0m;
2725                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2726                                 param.Value = 3;
2727                                 dr = cmd.ExecuteReader ();
2728                                 Assert.IsTrue (dr.Read (), "#E1");
2729                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
2730                                 Assert.AreEqual (3, dr.GetValue (0), "#E3");
2731                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#E4");
2732                                 Assert.AreEqual (0m, dr.GetValue (1), "#E5");
2733                                 Assert.IsFalse (dr.Read (), "#E6");
2734                                 dr.Close ();
2735                                 cmd.Dispose ();
2736
2737                                 cmd = (OdbcCommand) conn.CreateCommand ();
2738                                 cmd.CommandText = select_data1;
2739                                 param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
2740                                 param.Value = DBNull.Value;
2741                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2742                                 param.Value = 4;
2743                                 dr = cmd.ExecuteReader ();
2744                                 Assert.IsFalse (dr.Read (), "#F");
2745                                 dr.Close ();
2746                                 cmd.Dispose ();
2747
2748                                 cmd = (OdbcCommand) conn.CreateCommand ();
2749                                 cmd.CommandText = select_by_id;
2750                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2751                                 param.Value = 4;
2752                                 dr = cmd.ExecuteReader ();
2753                                 Assert.IsTrue (dr.Read (), "#G1");
2754                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
2755                                 Assert.AreEqual (4, dr.GetValue (0), "#G3");
2756                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#G4");
2757                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#G5");
2758                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#G6");
2759                                 Assert.AreEqual (DBNull.Value, dr.GetValue (2), "#G7");
2760                                 Assert.IsFalse (dr.Read (), "#G8");
2761                                 dr.Close ();
2762                                 cmd.Dispose ();
2763
2764                                 cmd = (OdbcCommand) conn.CreateCommand ();
2765                                 cmd.CommandText = insert_data;
2766                                 param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
2767                                 param.Value = -1000.5678m;
2768                                 param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
2769                                 param.Value = -1000.5678m;
2770                                 cmd.ExecuteNonQuery ();
2771                                 cmd.Dispose ();
2772
2773                                 cmd = (OdbcCommand) conn.CreateCommand ();
2774                                 cmd.CommandText = select_data1;
2775                                 param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
2776                                 param.Value = -1000.5678m;
2777                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2778                                 param.Value = 6000;
2779                                 dr = cmd.ExecuteReader ();
2780                                 Assert.IsFalse (dr.Read (), "#H");
2781                                 dr.Close ();
2782                                 cmd.Dispose ();
2783
2784                                 cmd = (OdbcCommand) conn.CreateCommand ();
2785                                 cmd.CommandText = select_data1;
2786                                 param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
2787                                 param.Value = -1001;
2788                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2789                                 param.Value = 6000;
2790                                 dr = cmd.ExecuteReader ();
2791                                 Assert.IsTrue (dr.Read (), "#I1");
2792                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#I2");
2793                                 Assert.AreEqual (6000, dr.GetValue (0), "#I3");
2794                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#I4");
2795                                 Assert.AreEqual (-1001m, dr.GetValue (1), "#I5");
2796                                 Assert.IsFalse (dr.Read (), "#I6");
2797                                 dr.Close ();
2798                                 cmd.Dispose ();
2799
2800                                 cmd = (OdbcCommand) conn.CreateCommand ();
2801                                 cmd.CommandText = select_data2;
2802                                 param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
2803                                 param.Value = -1000.5678m;
2804                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2805                                 param.Value = 6000;
2806                                 dr = cmd.ExecuteReader ();
2807                                 Assert.IsFalse (dr.Read (), "#J");
2808                                 dr.Close ();
2809                                 cmd.Dispose ();
2810
2811                                 cmd = (OdbcCommand) conn.CreateCommand ();
2812                                 cmd.CommandText = select_data2;
2813                                 param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
2814                                 param.Value = -1000.568m;
2815                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2816                                 param.Value = 6000;
2817                                 dr = cmd.ExecuteReader ();
2818                                 Assert.IsTrue (dr.Read (), "#K1");
2819                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#K2");
2820                                 Assert.AreEqual (6000, dr.GetValue (0), "#K3");
2821                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#K4");
2822                                 Assert.AreEqual (-1000.568m, dr.GetValue (1), "#K5");
2823                                 Assert.IsFalse (dr.Read (), "#K6");
2824                                 dr.Close ();
2825                                 cmd.Dispose ();
2826
2827                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2828
2829                                 cmd = (OdbcCommand) conn.CreateCommand ();
2830                                 cmd.CommandText = insert_data;
2831                                 param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
2832                                 param.Value = 56789m;
2833                                 param.Precision = 7;
2834                                 param.Scale = 2;
2835                                 param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
2836                                 param.Value = 98765.5678m;
2837                                 param.Precision = 10;
2838                                 param.Scale = 2;
2839                                 cmd.ExecuteNonQuery ();
2840                                 cmd.Dispose ();
2841
2842                                 cmd = (OdbcCommand) conn.CreateCommand ();
2843                                 cmd.CommandText = select_by_id;
2844                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2845                                 param.Value = 6000;
2846                                 dr = cmd.ExecuteReader ();
2847                                 Assert.IsTrue (dr.Read (), "#L1");
2848                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#L2");
2849                                 Assert.AreEqual (6000, dr.GetValue (0), "#L3");
2850                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#L4");
2851                                 Assert.AreEqual (56789m, dr.GetValue (1), "#L5");
2852                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#L6");
2853                                 if (ConnectionManager.Instance.Odbc.EngineConfig.Type == EngineType.MySQL)
2854                                         Assert.AreEqual (9876556.780m, dr.GetValue (2), "#L7");
2855                                 else
2856                                         Assert.AreEqual (98765.570m, dr.GetValue (2), "#L7");
2857                                 Assert.IsFalse (dr.Read (), "#L8");
2858                                 dr.Close ();
2859                                 cmd.Dispose ();
2860
2861                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2862
2863                                 cmd = (OdbcCommand) conn.CreateCommand ();
2864                                 cmd.CommandText = insert_data;
2865                                 param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
2866                                 param.Value = DBNull.Value;
2867                                 param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
2868                                 param.Value = DBNull.Value;
2869                                 cmd.ExecuteNonQuery ();
2870                                 cmd.Dispose ();
2871
2872                                 cmd = (OdbcCommand) conn.CreateCommand ();
2873                                 cmd.CommandText = select_by_id;
2874                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2875                                 param.Value = 6000;
2876                                 dr = cmd.ExecuteReader ();
2877                                 Assert.IsTrue (dr.Read (), "#M1");
2878                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#M2");
2879                                 Assert.AreEqual (6000, dr.GetValue (0), "#M3");
2880                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#M4");
2881                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#M5");
2882                                 Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#M6");
2883                                 Assert.AreEqual (DBNull.Value, dr.GetValue(1), "#M7");
2884                                 Assert.AreEqual (DBNull.Value, dr.GetValue (2), "#M7");
2885                                 Assert.IsFalse (dr.Read (), "#M8");
2886                                 dr.Close ();
2887                                 cmd.Dispose ();
2888                         } finally {
2889                                 if (cmd != null)
2890                                         cmd.Dispose ();
2891                                 if (dr != null)
2892                                         dr.Close ();
2893                                 conn.Close ();
2894                                 conn.Open ();
2895                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2896                                 conn.Close ();
2897                         }
2898                 }
2899
2900                 [Test]
2901                 public void NVarCharParameterTest ()
2902                 {
2903                         string insert_data = "insert into string_family (id, type_nvarchar) values (6000, ?)";
2904                         string select_data = "select type_nvarchar from string_family where type_nvarchar = ? and id = ?";
2905                         string select_by_id = "select type_nvarchar from string_family where id = ?";
2906                         string delete_data = "delete from string_family where id = 6000";
2907
2908                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
2909
2910                         IDataReader dr = null;
2911                         OdbcCommand cmd = null;
2912                         OdbcParameter param;
2913
2914                         try {
2915                                 cmd = conn.CreateCommand ();
2916                                 cmd.CommandText = select_data;
2917                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
2918                                 param.Value = "nv\u092d\u093e\u0930\u0924r";
2919                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2920                                 param.Value = 1;
2921                                 dr = cmd.ExecuteReader ();
2922                                 Assert.IsTrue (dr.Read (), "#A1");
2923                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
2924                                 Assert.AreEqual ("nv\u092d\u093e\u0930\u0924r", dr.GetValue (0), "#A3");
2925                                 Assert.IsFalse (dr.Read (), "#A4");
2926                                 dr.Close ();
2927                                 cmd.Dispose ();
2928
2929                                 cmd = conn.CreateCommand ();
2930                                 cmd.CommandText = select_data;
2931                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
2932                                 param.Value = "nv\u092d\u093e\u0930\u0924r ";
2933                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2934                                 param.Value = 2;
2935                                 dr = cmd.ExecuteReader ();
2936                                 Assert.IsTrue (dr.Read (), "#B1");
2937                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
2938                                 Assert.AreEqual ("nv\u092d\u093e\u0930\u0924r ", dr.GetValue (0), "#B3");
2939                                 Assert.IsFalse (dr.Read (), "#B4");
2940                                 dr.Close ();
2941                                 cmd.Dispose ();
2942
2943                                 cmd = conn.CreateCommand ();
2944                                 cmd.CommandText = select_data;
2945                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
2946                                 param.Value = string.Empty;
2947                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2948                                 param.Value = 3;
2949                                 dr = cmd.ExecuteReader ();
2950                                 Assert.IsTrue (dr.Read (), "#C1");
2951                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
2952                                 Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
2953                                 Assert.IsFalse (dr.Read (), "#C4");
2954                                 dr.Close ();
2955                                 cmd.Dispose ();
2956
2957                                 cmd = conn.CreateCommand ();
2958                                 cmd.CommandText = select_by_id;
2959                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2960                                 param.Value = 4;
2961                                 dr = cmd.ExecuteReader ();
2962                                 Assert.IsTrue (dr.Read (), "#D1");
2963                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
2964                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
2965                                 Assert.IsFalse (dr.Read (), "#D4");
2966                                 dr.Close ();
2967                                 cmd.Dispose ();
2968
2969                                 cmd = conn.CreateCommand ();
2970                                 cmd.CommandText = insert_data;
2971                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
2972                                 param.Value = "nvarchar ";
2973                                 cmd.ExecuteNonQuery ();
2974                                 cmd.Dispose ();
2975
2976                                 cmd = conn.CreateCommand ();
2977                                 cmd.CommandText = select_data;
2978                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
2979                                 param.Value = "nvarchar ";
2980                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
2981                                 param.Value = 6000;
2982                                 dr = cmd.ExecuteReader ();
2983                                 Assert.IsTrue (dr.Read (), "#E1");
2984                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
2985                                 Assert.AreEqual ("nvarchar ", dr.GetValue (0), "#E3");
2986                                 Assert.IsFalse (dr.Read (), "#E4");
2987                                 dr.Close ();
2988                                 cmd.Dispose ();
2989
2990                                 DBHelper.ExecuteNonQuery (conn, delete_data);
2991
2992                                 cmd = conn.CreateCommand ();
2993                                 cmd.CommandText = insert_data;
2994                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 6);
2995                                 param.Value = "nv\u0488rchar";
2996                                 cmd.ExecuteNonQuery ();
2997                                 cmd.Dispose ();
2998
2999                                 cmd = conn.CreateCommand ();
3000                                 cmd.CommandText = select_data;
3001                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 6);
3002                                 param.Value = "nv\u0488rchar";
3003                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3004                                 param.Value = 6000;
3005                                 dr = cmd.ExecuteReader ();
3006                                 Assert.IsTrue (dr.Read (), "#F1");
3007                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
3008                                 Assert.AreEqual ("nv\u0488rch", dr.GetValue (0), "#F3");
3009                                 Assert.IsFalse (dr.Read (), "#F4");
3010                                 dr.Close ();
3011                                 cmd.Dispose ();
3012
3013                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3014
3015                                 cmd = conn.CreateCommand ();
3016                                 cmd.CommandText = insert_data;
3017                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 12);
3018                                 param.Value = "nvarch\u0488r ";
3019                                 cmd.ExecuteNonQuery ();
3020                                 cmd.Dispose ();
3021
3022                                 cmd = conn.CreateCommand ();
3023                                 cmd.CommandText = select_data;
3024                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 12);
3025                                 param.Value = "nvarch\u0488r ";
3026                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3027                                 param.Value = 6000;
3028                                 dr = cmd.ExecuteReader ();
3029                                 Assert.IsTrue (dr.Read (), "#G1");
3030                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
3031                                 Assert.AreEqual ("nvarch\u0488r ", dr.GetValue (0), "#G3");
3032                                 Assert.IsFalse (dr.Read (), "#G4");
3033                                 dr.Close ();
3034                                 cmd.Dispose ();
3035
3036                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3037
3038                                 cmd = conn.CreateCommand ();
3039                                 cmd.CommandText = insert_data;
3040                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 12);
3041                                 param.Value = string.Empty;
3042                                 cmd.ExecuteNonQuery ();
3043                                 cmd.Dispose ();
3044
3045                                 cmd = conn.CreateCommand ();
3046                                 cmd.CommandText = select_data;
3047                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 12);
3048                                 param.Value = string.Empty;
3049                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3050                                 param.Value = 6000;
3051                                 dr = cmd.ExecuteReader ();
3052                                 Assert.IsTrue (dr.Read (), "#H1");
3053                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
3054                                 Assert.AreEqual (string.Empty, dr.GetValue (0), "#H3");
3055                                 Assert.IsFalse (dr.Read (), "#H4");
3056                                 dr.Close ();
3057                                 cmd.Dispose ();
3058
3059                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3060
3061                                 cmd = conn.CreateCommand ();
3062                                 cmd.CommandText = insert_data;
3063                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
3064                                 param.Value = DBNull.Value;
3065                                 cmd.ExecuteNonQuery ();
3066                                 cmd.Dispose ();
3067
3068                                 cmd = conn.CreateCommand ();
3069                                 cmd.CommandText = select_by_id;
3070                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3071                                 param.Value = 6000;
3072                                 dr = cmd.ExecuteReader ();
3073                                 Assert.IsTrue (dr.Read (), "#I1");
3074                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#I2");
3075                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#I3");
3076                                 Assert.IsFalse (dr.Read (), "#I4");
3077                                 dr.Close ();
3078                                 cmd.Dispose ();
3079                         } finally {
3080                                 if (cmd != null)
3081                                         cmd.Dispose ();
3082                                 if (dr != null)
3083                                         dr.Close ();
3084                                 conn.Close ();
3085                                 conn.Open ();
3086                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3087                                 conn.Close ();
3088                         }
3089                 }
3090
3091                 [Test]
3092                 public void VarBinaryParameterTest ()
3093                 {
3094                         string insert_data = "insert into binary_family (id, type_varbinary) values (6000, ?)";
3095                         string select_data = "select id, type_varbinary from binary_family where type_varbinary = ? and id = ?";
3096                         string select_by_id = "select id, type_varbinary from binary_family where id = ?";
3097                         string delete_data = "delete from binary_family where id = 6000";
3098
3099                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
3100
3101                         IDataReader dr = null;
3102                         OdbcCommand cmd = null;
3103                         OdbcParameter param;
3104
3105                         try {
3106                                 byte [] bytes = new byte [] { 0x30, 0x31, 0x32,
3107                                         0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
3108                                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
3109                                         0x37, 0x38, 0x39, 0x30, 0x31, 0x32, 0x33,
3110                                         0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x00,
3111                                         0x44, 0x53};
3112
3113                                 cmd = (OdbcCommand) conn.CreateCommand ();
3114                                 cmd.CommandText = select_data;
3115                                 param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
3116                                 param.Value = bytes;
3117                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3118                                 param.Value = 1;
3119                                 dr = cmd.ExecuteReader ();
3120                                 Assert.IsTrue (dr.Read (), "#A1");
3121                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
3122                                 Assert.AreEqual (1, dr.GetValue (0), "#A3");
3123                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#A4");
3124                                 Assert.AreEqual (bytes, dr.GetValue (1), "#A5");
3125                                 Assert.IsFalse (dr.Read (), "#A6");
3126                                 dr.Close ();
3127                                 cmd.Dispose ();
3128
3129                                 bytes = new byte [] { 0x00, 0x39, 0x38, 0x37,
3130                                         0x36, 0x35, 0x00, 0x33, 0x32, 0x31, 0x30,
3131                                         0x31, 0x32, 0x33, 0x34 };
3132
3133                                 cmd = (OdbcCommand) conn.CreateCommand ();
3134                                 cmd.CommandText = select_data;
3135                                 param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
3136                                 param.Value = bytes;
3137                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3138                                 param.Value = 2;
3139                                 dr = cmd.ExecuteReader ();
3140                                 Assert.IsTrue (dr.Read (), "#B1");
3141                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
3142                                 Assert.AreEqual (2, dr.GetValue (0), "#B3");
3143                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#B4");
3144                                 Assert.AreEqual (bytes, dr.GetValue (1), "#B5");
3145                                 Assert.IsFalse (dr.Read (), "#B6");
3146                                 dr.Close ();
3147                                 cmd.Dispose ();
3148
3149                                 bytes = new byte [0];
3150
3151                                 cmd = (OdbcCommand) conn.CreateCommand ();
3152                                 cmd.CommandText = select_data;
3153                                 param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
3154                                 param.Value = bytes;
3155                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3156                                 param.Value = 3;
3157                                 dr = cmd.ExecuteReader ();
3158                                 Assert.IsTrue (dr.Read (), "#C1");
3159                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
3160                                 Assert.AreEqual (3, dr.GetValue (0), "#C3");
3161                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#C4");
3162                                 Assert.AreEqual (bytes, dr.GetValue (1), "#C5");
3163                                 Assert.IsFalse (dr.Read (), "#C6");
3164                                 dr.Close ();
3165                                 cmd.Dispose ();
3166
3167                                 cmd = (OdbcCommand) conn.CreateCommand ();
3168                                 cmd.CommandText = select_by_id;
3169                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3170                                 param.Value = 4;
3171                                 dr = cmd.ExecuteReader ();
3172                                 Assert.IsTrue (dr.Read (), "#D1");
3173                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
3174                                 Assert.AreEqual (4, dr.GetValue (0), "#D3");
3175                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#D4");
3176                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
3177                                 Assert.IsFalse (dr.Read (), "#D6");
3178                                 dr.Close ();
3179                                 cmd.Dispose ();
3180
3181                                 bytes = new byte [0];
3182
3183                                 cmd = (OdbcCommand) conn.CreateCommand ();
3184                                 cmd.CommandText = insert_data;
3185                                 param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
3186                                 param.Value = bytes;
3187                                 cmd.ExecuteNonQuery ();
3188                                 cmd.Dispose ();
3189
3190                                 cmd = (OdbcCommand) conn.CreateCommand ();
3191                                 cmd.CommandText = select_data;
3192                                 param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
3193                                 param.Value = bytes;
3194                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3195                                 param.Value = 6000;
3196                                 dr = cmd.ExecuteReader ();
3197                                 Assert.IsTrue (dr.Read (), "#E1");
3198                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
3199                                 Assert.AreEqual (6000, dr.GetValue (0), "#E3");
3200                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#E4");
3201                                 Assert.AreEqual (bytes, dr.GetValue (1), "#E5");
3202                                 Assert.IsFalse (dr.Read (), "#E6");
3203                                 dr.Close ();
3204                                 cmd.Dispose ();
3205
3206                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3207
3208                                 bytes = new byte [] { 0x05 };
3209
3210                                 cmd = (OdbcCommand) conn.CreateCommand ();
3211                                 cmd.CommandText = insert_data;
3212                                 param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
3213                                 param.Value = bytes;
3214                                 cmd.ExecuteNonQuery ();
3215                                 cmd.Dispose ();
3216
3217                                 cmd = (OdbcCommand) conn.CreateCommand ();
3218                                 cmd.CommandText = select_data;
3219                                 param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
3220                                 param.Value = bytes;
3221                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3222                                 param.Value = 6000;
3223                                 dr = cmd.ExecuteReader ();
3224                                 Assert.IsTrue (dr.Read (), "#F1");
3225                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
3226                                 Assert.AreEqual (6000, dr.GetValue (0), "#F3");
3227                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#F4");
3228                                 Assert.AreEqual (bytes, dr.GetValue (1), "#F5");
3229                                 Assert.IsFalse (dr.Read (), "#F6");
3230                                 dr.Close ();
3231                                 cmd.Dispose ();
3232
3233                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3234
3235                                 bytes = new byte [] { 0x34, 0x00, 0x32 };
3236
3237                                 cmd = (OdbcCommand) conn.CreateCommand ();
3238                                 cmd.CommandText = insert_data;
3239                                 param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
3240                                 param.Value = bytes;
3241                                 cmd.ExecuteNonQuery ();
3242                                 cmd.Dispose ();
3243
3244                                 cmd = (OdbcCommand) conn.CreateCommand ();
3245                                 cmd.CommandText = select_data;
3246                                 param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
3247                                 param.Value = bytes;
3248                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3249                                 param.Value = 6000;
3250                                 dr = cmd.ExecuteReader ();
3251                                 Assert.IsTrue (dr.Read (), "#G1");
3252                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
3253                                 Assert.AreEqual (6000, dr.GetValue (0), "#G3");
3254                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#G4");
3255                                 Assert.AreEqual (bytes, dr.GetValue (1), "#G5");
3256                                 Assert.IsFalse (dr.Read (), "#G6");
3257                                 dr.Close ();
3258                                 cmd.Dispose ();
3259
3260                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3261
3262                                 bytes = new byte [] { 0x34, 0x00, 0x32, 0x05, 0x07, 0x13 };
3263
3264                                 cmd = (OdbcCommand) conn.CreateCommand ();
3265                                 cmd.CommandText = insert_data;
3266                                 param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary, 4);
3267                                 param.Value = bytes;
3268                                 cmd.ExecuteNonQuery ();
3269                                 cmd.Dispose ();
3270
3271                                 cmd = (OdbcCommand) conn.CreateCommand ();
3272                                 cmd.CommandText = select_data;
3273                                 param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary, 4);
3274                                 param.Value = bytes;
3275                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3276                                 param.Value = 6000;
3277                                 dr = cmd.ExecuteReader ();
3278                                 Assert.IsTrue (dr.Read (), "#H1");
3279                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
3280                                 Assert.AreEqual (6000, dr.GetValue (0), "#H3");
3281                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#H4");
3282                                 Assert.AreEqual (new byte [] { 0x34, 0x00, 0x32, 0x05 }, dr.GetValue (1), "#H5");
3283                                 Assert.IsFalse (dr.Read (), "#H6");
3284                                 dr.Close ();
3285                                 cmd.Dispose ();
3286
3287                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3288
3289                                 cmd = (OdbcCommand) conn.CreateCommand ();
3290                                 cmd.CommandText = insert_data;
3291                                 param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
3292                                 param.Value = DBNull.Value;
3293                                 cmd.ExecuteNonQuery ();
3294                                 cmd.Dispose ();
3295
3296                                 cmd = (OdbcCommand) conn.CreateCommand ();
3297                                 cmd.CommandText = select_by_id;
3298                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3299                                 param.Value = 6000;
3300                                 dr = cmd.ExecuteReader ();
3301                                 Assert.IsTrue (dr.Read (), "#I1");
3302                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#I2");
3303                                 Assert.AreEqual (6000, dr.GetValue (0), "#I3");
3304                                 Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#I4");
3305                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#I5");
3306                                 Assert.IsFalse (dr.Read (), "#I6");
3307                                 dr.Close ();
3308                                 cmd.Dispose ();
3309                         } finally {
3310                                 if (dr != null)
3311                                         dr.Close ();
3312                                 if (cmd != null)
3313                                         cmd.Dispose ();
3314                                 conn.Close ();
3315                                 conn.Open ();
3316                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3317                                 conn.Close ();
3318                         }
3319                 }
3320
3321                 [Test]
3322                 public void VarCharParameterTest ()
3323                 {
3324                         string insert_data = "insert into string_family (id, type_varchar) values (6000, ?)";
3325                         string select_data = "select type_varchar from string_family where type_varchar = ? and id = ?";
3326                         string select_by_id = "select type_varchar from string_family where id = ?";
3327                         string delete_data = "delete from string_family where id = 6000";
3328
3329                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
3330
3331                         IDataReader dr = null;
3332                         OdbcCommand cmd = null;
3333                         OdbcParameter param;
3334
3335                         try {
3336                                 cmd = conn.CreateCommand ();
3337                                 cmd.CommandText = select_data;
3338                                 param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
3339                                 param.Value = "varchar";
3340                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3341                                 param.Value = 1;
3342                                 dr = cmd.ExecuteReader ();
3343                                 Assert.IsTrue (dr.Read (), "#A1");
3344                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
3345                                 Assert.AreEqual ("varchar", dr.GetValue (0), "#A3");
3346                                 Assert.IsFalse (dr.Read (), "#A4");
3347                                 dr.Close ();
3348                                 cmd.Dispose ();
3349
3350                                 cmd = conn.CreateCommand ();
3351                                 cmd.CommandText = select_data;
3352                                 param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
3353                                 param.Value = "varchar ";
3354                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3355                                 param.Value = 2;
3356                                 dr = cmd.ExecuteReader ();
3357                                 Assert.IsTrue (dr.Read (), "#B1");
3358                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
3359                                 Assert.AreEqual ("varchar ", dr.GetValue (0), "#B3");
3360                                 Assert.IsFalse (dr.Read (), "#B4");
3361                                 dr.Close ();
3362                                 cmd.Dispose ();
3363
3364                                 cmd = conn.CreateCommand ();
3365                                 cmd.CommandText = select_data;
3366                                 param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
3367                                 param.Value = string.Empty;
3368                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3369                                 param.Value = 3;
3370                                 dr = cmd.ExecuteReader ();
3371                                 Assert.IsTrue (dr.Read (), "#C1");
3372                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
3373                                 Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
3374                                 Assert.IsFalse (dr.Read (), "#C4");
3375                                 dr.Close ();
3376                                 cmd.Dispose ();
3377
3378                                 cmd = conn.CreateCommand ();
3379                                 cmd.CommandText = select_by_id;
3380                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3381                                 param.Value = 4;
3382                                 dr = cmd.ExecuteReader ();
3383                                 Assert.IsTrue (dr.Read (), "#D1");
3384                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
3385                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
3386                                 Assert.IsFalse (dr.Read (), "#D4");
3387                                 dr.Close ();
3388                                 cmd.Dispose ();
3389
3390                                 cmd = conn.CreateCommand ();
3391                                 cmd.CommandText = insert_data;
3392                                 param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar, 30);
3393                                 param.Value = "varchar ";
3394                                 cmd.ExecuteNonQuery ();
3395                                 cmd.Dispose ();
3396
3397                                 cmd = conn.CreateCommand ();
3398                                 cmd.CommandText = select_data;
3399                                 param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
3400                                 param.Value = "varchar ";
3401                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3402                                 param.Value = 6000;
3403                                 dr = cmd.ExecuteReader ();
3404                                 Assert.IsTrue (dr.Read (), "#E1");
3405                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
3406                                 Assert.AreEqual ("varchar ", dr.GetValue (0), "#E3");
3407                                 Assert.IsFalse (dr.Read (), "#E4");
3408                                 dr.Close ();
3409                                 cmd.Dispose ();
3410
3411                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3412
3413                                 cmd = conn.CreateCommand ();
3414                                 cmd.CommandText = insert_data;
3415                                 param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar, 3);
3416                                 param.Value = "vchar";
3417                                 cmd.ExecuteNonQuery ();
3418                                 cmd.Dispose ();
3419
3420                                 cmd = conn.CreateCommand ();
3421                                 cmd.CommandText = select_data;
3422                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.VarChar, 3);
3423                                 param.Value = "vcharxzer";
3424                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3425                                 param.Value = 6000;
3426                                 dr = cmd.ExecuteReader ();
3427                                 Assert.IsTrue (dr.Read (), "#F1");
3428                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
3429                                 Assert.AreEqual ("vch", dr.GetValue (0), "#F3");
3430                                 Assert.IsFalse (dr.Read (), "#F4");
3431                                 dr.Close ();
3432                                 cmd.Dispose ();
3433
3434                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3435
3436                                 cmd = conn.CreateCommand ();
3437                                 cmd.CommandText = insert_data;
3438                                 param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar, 3);
3439                                 param.Value = string.Empty;
3440                                 cmd.ExecuteNonQuery ();
3441                                 cmd.Dispose ();
3442
3443                                 cmd = conn.CreateCommand ();
3444                                 cmd.CommandText = select_data;
3445                                 param = cmd.Parameters.Add ("type_nvarchar", OdbcType.VarChar, 3);
3446                                 param.Value = string.Empty;
3447                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3448                                 param.Value = 6000;
3449                                 dr = cmd.ExecuteReader ();
3450                                 Assert.IsTrue (dr.Read (), "#G1");
3451                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
3452                                 Assert.AreEqual (string.Empty, dr.GetValue (0), "#G3");
3453                                 Assert.IsFalse (dr.Read (), "#G4");
3454                                 dr.Close ();
3455                                 cmd.Dispose ();
3456
3457                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3458
3459                                 cmd = conn.CreateCommand ();
3460                                 cmd.CommandText = insert_data;
3461                                 param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar, 5);
3462                                 param.Value = DBNull.Value;
3463                                 cmd.ExecuteNonQuery ();
3464                                 cmd.Dispose ();
3465
3466                                 cmd = conn.CreateCommand ();
3467                                 cmd.CommandText = select_by_id;
3468                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3469                                 param.Value = 6000;
3470                                 dr = cmd.ExecuteReader ();
3471                                 Assert.IsTrue (dr.Read (), "#H1");
3472                                 Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
3473                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#H3");
3474                                 Assert.IsFalse (dr.Read (), "#H4");
3475                                 dr.Close ();
3476                                 cmd.Dispose ();
3477                         } finally {
3478                                 if (cmd != null)
3479                                         cmd.Dispose ();
3480                                 if (dr != null)
3481                                         dr.Close ();
3482                                 conn.Close ();
3483                                 conn.Open ();
3484                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3485                                 conn.Close ();
3486                         }
3487                 }
3488
3489                 [Test]
3490                 public void RealParameterTest ()
3491                 {
3492                         string insert_data = "insert into numeric_family (id, type_float) values (6000, ?)";
3493                         string select_data = "select id, type_float from numeric_family where type_float = ? and id = ?";
3494                         string select_by_id = "select id, type_float from numeric_family where id = ?";
3495                         string delete_data = "delete from numeric_family where id = 6000";
3496
3497                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
3498
3499                         IDataReader dr = null;
3500                         OdbcCommand cmd = null;
3501                         OdbcParameter param;
3502
3503                         try {
3504
3505                                 cmd = (OdbcCommand) conn.CreateCommand ();
3506                                 cmd.CommandText = select_by_id;
3507                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3508                                 param.Value = 1;
3509                                 dr = cmd.ExecuteReader ();
3510                                 Assert.IsTrue (dr.Read (), "#D1");
3511                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
3512                                 Assert.AreEqual (1, dr.GetValue (0), "#D3");
3513                                 Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#D4");
3514                                 Assert.AreEqual (3.39999995E+38f, dr.GetValue (1), "#D5");
3515                                 Assert.IsFalse (dr.Read (), "#D6");
3516                                 dr.Close ();
3517                                 cmd.Dispose ();
3518
3519
3520                                 cmd = (OdbcCommand) conn.CreateCommand ();
3521                                 cmd.CommandText = select_data;
3522                                 param = cmd.Parameters.Add ("type_float", OdbcType.Real);
3523                                 param.Value = 3.40E+38;
3524                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3525                                 param.Value = 1;
3526                                 dr = cmd.ExecuteReader ();
3527                                 Assert.IsTrue (dr.Read (), "#A1");
3528                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
3529                                 Assert.AreEqual (1, dr.GetValue (0), "#A2");
3530                                 Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#A3");
3531                                 Assert.AreEqual (3.40E+38f, (float)dr.GetValue (1), 0.0000001f, "#A4");
3532                                 Assert.IsFalse (dr.Read (), "#A5");
3533                                 dr.Close ();
3534                                 cmd.Dispose ();
3535
3536                                 cmd = (OdbcCommand) conn.CreateCommand ();
3537                                 cmd.CommandText = select_data;
3538                                 param = cmd.Parameters.Add ("type_float", OdbcType.Real);
3539                                 param.Value = -3.40E+38;
3540                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3541                                 param.Value = 2;
3542                                 dr = cmd.ExecuteReader ();
3543                                 Assert.IsTrue (dr.Read (), "#B1");
3544                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
3545                                 Assert.AreEqual (2, dr.GetValue (0), "#B2");
3546                                 Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#B3");
3547                                 Assert.AreEqual(-3.40E+38f, (float)dr.GetValue(1), 0.0000001f, "#B4");
3548                                 Assert.IsFalse (dr.Read (), "#B5");
3549                                 dr.Close ();
3550                                 cmd.Dispose ();
3551
3552                                 cmd = (OdbcCommand) conn.CreateCommand ();
3553                                 cmd.CommandText = select_data;
3554                                 param = cmd.Parameters.Add ("type_float", OdbcType.Real);
3555                                 param.Value = 0F;
3556                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3557                                 param.Value = 3;
3558                                 dr = cmd.ExecuteReader ();
3559                                 Assert.IsTrue (dr.Read (), "#C1");
3560                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
3561                                 Assert.AreEqual (3, dr.GetValue (0), "#C2");
3562                                 Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#C3");
3563                                 Assert.AreEqual (0F, dr.GetValue (1), "#C4");
3564                                 Assert.IsFalse (dr.Read (), "#C5");
3565                                 dr.Close ();
3566                                 cmd.Dispose ();
3567
3568                                 cmd = (OdbcCommand) conn.CreateCommand ();
3569                                 cmd.CommandText = select_by_id;
3570                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3571                                 param.Value = 4;
3572                                 dr = cmd.ExecuteReader ();
3573                                 Assert.IsTrue (dr.Read (), "#D1");
3574                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
3575                                 Assert.AreEqual (4, dr.GetValue (0), "#D3");
3576                                 Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#D4");
3577                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
3578                                 Assert.IsFalse (dr.Read (), "#D6");
3579                                 dr.Close ();
3580                                 cmd.Dispose ();
3581
3582                                 cmd = (OdbcCommand) conn.CreateCommand ();
3583                                 cmd.CommandText = insert_data;
3584                                 param = cmd.Parameters.Add ("type_float", OdbcType.Real);
3585                                 param.Value = 3.40E+38;
3586                                 cmd.ExecuteNonQuery ();
3587                                 cmd.Dispose ();
3588
3589                                 cmd = (OdbcCommand) conn.CreateCommand ();
3590                                 cmd.CommandText = select_by_id;
3591                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3592                                 param.Value = 6000;
3593                                 dr = cmd.ExecuteReader ();
3594                                 Assert.IsTrue (dr.Read (), "#E1");
3595                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
3596                                 Assert.AreEqual (6000, dr.GetValue (0), "#E3");
3597                                 Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#E4");
3598                                 Assert.AreEqual(3.40E+38f, (float)dr.GetValue(1), 0.0000001f, "#E4");
3599                                 Assert.IsFalse (dr.Read (), "#E6");
3600                                 dr.Close ();
3601                                 cmd.Dispose ();
3602
3603                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3604
3605                                 cmd = (OdbcCommand) conn.CreateCommand ();
3606                                 cmd.CommandText = insert_data;
3607                                 param = cmd.Parameters.Add ("type_float", OdbcType.Real);
3608                                 param.Value = -3.40E+38;
3609                                 cmd.ExecuteNonQuery ();
3610                                 cmd.Dispose ();
3611
3612                                 cmd = (OdbcCommand) conn.CreateCommand ();
3613                                 cmd.CommandText = select_by_id;
3614                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3615                                 param.Value = 6000;
3616                                 dr = cmd.ExecuteReader ();
3617                                 Assert.IsTrue (dr.Read (), "#F1");
3618                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
3619                                 Assert.AreEqual (6000, dr.GetValue (0), "#F3");
3620                                 Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#F4");
3621                                 Assert.AreEqual (-3.40E+38f, (float)dr.GetValue(1), 0.0000001f, "#F4");
3622                                 Assert.IsFalse (dr.Read (), "#F6");
3623                                 dr.Close ();
3624                                 cmd.Dispose ();
3625
3626                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3627
3628                                 cmd = (OdbcCommand) conn.CreateCommand ();
3629                                 cmd.CommandText = insert_data;
3630                                 param = cmd.Parameters.Add ("type_float", OdbcType.Real);
3631                                 param.Value = 0F;
3632                                 cmd.ExecuteNonQuery ();
3633                                 cmd.Dispose ();
3634
3635                                 cmd = (OdbcCommand) conn.CreateCommand ();
3636                                 cmd.CommandText = select_by_id;
3637                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3638                                 param.Value = 6000;
3639                                 dr = cmd.ExecuteReader ();
3640                                 Assert.IsTrue (dr.Read (), "#G1");
3641                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
3642                                 Assert.AreEqual (6000, dr.GetValue (0), "#G3");
3643                                 Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#G4");
3644                                 Assert.AreEqual (0F, dr.GetValue (1), "#G5");
3645                                 Assert.IsFalse (dr.Read (), "#G6");
3646                                 dr.Close ();
3647                                 cmd.Dispose ();
3648
3649                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3650
3651                                 cmd = (OdbcCommand) conn.CreateCommand ();
3652                                 cmd.CommandText = insert_data;
3653                                 param = cmd.Parameters.Add ("type_float", OdbcType.Real);
3654                                 param.Value = DBNull.Value;
3655                                 cmd.ExecuteNonQuery ();
3656                                 cmd.Dispose ();
3657
3658                                 cmd = (OdbcCommand) conn.CreateCommand ();
3659                                 cmd.CommandText = select_by_id;
3660                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3661                                 param.Value = 6000;
3662                                 dr = cmd.ExecuteReader ();
3663                                 Assert.IsTrue (dr.Read (), "#H1");
3664                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
3665                                 Assert.AreEqual (6000, dr.GetValue (0), "#H3");
3666                                 Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#H4");
3667                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
3668                                 Assert.IsFalse (dr.Read (), "#H6");
3669                                 dr.Close ();
3670                                 cmd.Dispose ();
3671                         } finally {
3672                                 if (dr != null)
3673                                         dr.Close ();
3674                                 if (cmd != null)
3675                                         cmd.Dispose ();
3676                                 conn.Close ();
3677                                 conn.Open ();
3678                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3679                                 conn.Close ();
3680                         }
3681                 }
3682
3683                 [Test]
3684                 public void SmallDateTimeParameterTest ()
3685                 {
3686                         string insert_data = "insert into datetime_family (id, type_smalldatetime) values (6000, ?)";
3687                         string select_data = "select id, type_smalldatetime from datetime_family where type_smalldatetime = ? and id = ?";
3688                         string select_by_id = "select id, type_smalldatetime from datetime_family where id = ?";
3689                         string delete_data = "delete from datetime_family where id = 6000";
3690
3691                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
3692
3693                         IDataReader dr = null;
3694                         OdbcCommand cmd = null;
3695                         OdbcParameter param;
3696
3697                         try {
3698                                 DateTime date = DateTime.Parse ("2037-12-31 23:59:00");
3699
3700                                 cmd = (OdbcCommand) conn.CreateCommand ();
3701                                 cmd.CommandText = select_data;
3702                                 param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
3703                                 param.Value = date;
3704                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3705                                 param.Value = 1;
3706                                 dr = cmd.ExecuteReader ();
3707                                 Assert.IsTrue (dr.Read (), "#A1");
3708                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
3709                                 Assert.AreEqual (1, dr.GetValue (0), "#A3");
3710                                 Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#A4");
3711                                 Assert.AreEqual (date, dr.GetValue (1), "#A5");
3712                                 Assert.IsFalse (dr.Read (), "#A6");
3713                                 dr.Close ();
3714                                 cmd.Dispose ();
3715
3716                                 cmd = (OdbcCommand) conn.CreateCommand ();
3717                                 cmd.CommandText = select_by_id;
3718                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3719                                 param.Value = 4;
3720                                 dr = cmd.ExecuteReader ();
3721                                 Assert.IsTrue (dr.Read (), "#B1");
3722                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
3723                                 Assert.AreEqual (4, dr.GetValue (0), "#B3");
3724                                 Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#B4");
3725                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#B5");
3726                                 Assert.IsFalse (dr.Read (), "#B6");
3727                                 dr.Close ();
3728                                 cmd.Dispose ();
3729
3730                                 date = new DateTime (1973, 8, 13, 17, 55, 00);
3731
3732                                 cmd = (OdbcCommand) conn.CreateCommand ();
3733                                 cmd.CommandText = insert_data;
3734                                 param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
3735                                 param.Value = date;
3736                                 cmd.ExecuteNonQuery ();
3737                                 cmd.Dispose ();
3738
3739                                 cmd = (OdbcCommand) conn.CreateCommand ();
3740                                 cmd.CommandText = select_data;
3741                                 param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
3742                                 param.Value = date;
3743                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3744                                 param.Value = 6000;
3745                                 dr = cmd.ExecuteReader ();
3746                                 Assert.IsTrue (dr.Read (), "#C1");
3747                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
3748                                 Assert.AreEqual (6000, dr.GetValue (0), "#C3");
3749                                 Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#C4");
3750                                 Assert.AreEqual (date, dr.GetValue (1), "#C5");
3751                                 Assert.IsFalse (dr.Read (), "#C6");
3752                                 dr.Close ();
3753                                 cmd.Dispose ();
3754
3755                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3756
3757                                 cmd = (OdbcCommand) conn.CreateCommand ();
3758                                 cmd.CommandText = insert_data;
3759                                 param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
3760                                 param.Value = DBNull.Value;
3761                                 cmd.ExecuteNonQuery ();
3762                                 cmd.Dispose ();
3763
3764                                 cmd = (OdbcCommand) conn.CreateCommand ();
3765                                 cmd.CommandText = select_by_id;
3766                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3767                                 param.Value = 6000;
3768                                 dr = cmd.ExecuteReader ();
3769                                 Assert.IsTrue (dr.Read (), "#D1");
3770                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
3771                                 Assert.AreEqual (6000, dr.GetValue (0), "#D3");
3772                                 Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#D4");
3773                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
3774                                 Assert.IsFalse (dr.Read (), "#D6");
3775                                 dr.Close ();
3776                                 cmd.Dispose ();
3777                         } finally {
3778                                 if (dr != null)
3779                                         dr.Close ();
3780                                 if (cmd != null)
3781                                         cmd.Dispose ();
3782
3783                                 conn.Close ();
3784                                 conn.Open ();
3785                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3786                                 conn.Close ();
3787                         }
3788                 }
3789
3790                 [Test]
3791                 public void DateTimeParameterTest ()
3792                 {
3793                         string insert_data = "insert into datetime_family (id, type_datetime) values (6000, ?)";
3794                         string select_data = "select id, type_datetime from datetime_family where type_datetime = ? and id = ?";
3795                         string select_by_id = "select id, type_datetime from datetime_family where id = ?";
3796                         string delete_data = "delete from datetime_family where id = 6000";
3797
3798                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
3799
3800                         IDataReader dr = null;
3801                         OdbcCommand cmd = null;
3802                         OdbcParameter param;
3803
3804                         try {
3805                                 DateTime date = DateTime.ParseExact ("9999-12-31 23:59:59",
3806                                         "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
3807
3808                                 cmd = conn.CreateCommand ();
3809                                 cmd.CommandText = select_data;
3810                                 param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
3811                                 param.Value = date;
3812                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3813                                 param.Value = 1;
3814                                 dr = cmd.ExecuteReader ();
3815                                 Assert.IsTrue (dr.Read (), "#A1");
3816                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
3817                                 Assert.AreEqual (1, dr [0], "#A3");
3818                                 Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#A4");
3819                                 if (ConnectionManager.Instance.Odbc.EngineConfig.SupportsMicroseconds)
3820                                         Assert.AreEqual (date, dr [1], "#A5");
3821                                 else
3822                                         Assert.AreEqual (new DateTime (9999, 12, 31, 23, 59, 59), dr [1], "#A5");
3823                                 Assert.IsFalse (dr.Read (), "#A6");
3824                                 dr.Close ();
3825                                 cmd.Dispose ();
3826
3827                                 cmd = conn.CreateCommand ();
3828                                 cmd.CommandText = select_by_id;
3829                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3830                                 param.Value = 4;
3831                                 dr = cmd.ExecuteReader ();
3832                                 Assert.IsTrue (dr.Read (), "#B1");
3833                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
3834                                 Assert.AreEqual (4, dr.GetValue (0), "#B3");
3835                                 Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#B4");
3836                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#B5");
3837                                 Assert.IsFalse (dr.Read (), "#B6");
3838                                 dr.Close ();
3839                                 cmd.Dispose ();
3840
3841                                 date = new DateTime (1973, 8, 13, 17, 54, 34);
3842
3843                                 cmd = conn.CreateCommand ();
3844                                 cmd.CommandText = insert_data;
3845                                 param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
3846                                 param.Value = date;
3847                                 cmd.ExecuteNonQuery ();
3848                                 cmd.Dispose ();
3849
3850                                 cmd = conn.CreateCommand ();
3851                                 cmd.CommandText = select_data;
3852                                 param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
3853                                 param.Value = date;
3854                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3855                                 param.Value = 6000;
3856                                 dr = cmd.ExecuteReader ();
3857                                 Assert.IsTrue (dr.Read (), "#C1");
3858                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
3859                                 Assert.AreEqual (6000, dr.GetValue (0), "#C3");
3860                                 Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#C4");
3861                                 Assert.AreEqual (new DateTime (1973, 8, 13, 17, 54, 34), dr.GetValue (1), "#C5");
3862                                 Assert.IsFalse (dr.Read (), "#C6");
3863                                 dr.Close ();
3864                                 cmd.Dispose ();
3865
3866                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3867
3868                                 cmd = conn.CreateCommand ();
3869                                 cmd.CommandText = insert_data;
3870                                 param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
3871                                 param.Value = DBNull.Value;
3872                                 cmd.ExecuteNonQuery ();
3873                                 cmd.Dispose ();
3874
3875                                 cmd = conn.CreateCommand ();
3876                                 cmd.CommandText = select_by_id;
3877                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3878                                 param.Value = 6000;
3879                                 dr = cmd.ExecuteReader ();
3880                                 Assert.IsTrue (dr.Read (), "#D1");
3881                                 Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
3882                                 Assert.AreEqual (6000, dr.GetValue (0), "#D3");
3883                                 Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#D4");
3884                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
3885                                 Assert.IsFalse (dr.Read (), "#D6");
3886                                 dr.Close ();
3887                                 cmd.Dispose ();
3888                         } finally {
3889                                 if (dr != null)
3890                                         dr.Close ();
3891                                 if (cmd != null)
3892                                         cmd.Dispose ();
3893                                 conn.Close ();
3894                                 conn.Open ();
3895                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3896                                 conn.Close ();
3897                         }
3898                 }
3899
3900                 [Test]
3901                 public void DateParameterTest ()
3902                 {
3903                         string insert_data = "insert into datetime_family (id, type_date) values (6000, ?)";
3904                         string select_data = "select type_date from datetime_family where type_date = ? and id = 1";
3905                         string select_by_id = "select type_date from datetime_family where id = ?";
3906                         string delete_data = "delete from datetime_family where id = 6000";
3907
3908                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
3909
3910                         IDataReader dr = null;
3911                         OdbcCommand cmd = null;
3912                         OdbcParameter param;
3913
3914                         try {
3915                                 if (!ConnectionManager.Instance.Odbc.EngineConfig.SupportsDate)
3916                                         Assert.Ignore ("Date test does not apply to the current driver (" + conn.Driver + ").");
3917
3918                                 DateTime date = new DateTime (9999, 12, 31);
3919
3920                                 cmd = conn.CreateCommand ();
3921                                 cmd.CommandText = select_data;
3922                                 param = cmd.Parameters.Add ("type_date", OdbcType.DateTime);
3923                                 param.Value = date;
3924                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3925                                 param.Value = 1;
3926                                 dr = cmd.ExecuteReader ();
3927                                 Assert.IsTrue (dr.Read (), "#A1");
3928                                 Assert.AreEqual (typeof (DateTime), dr.GetFieldType (0), "#A2");
3929                                 Assert.AreEqual (date, dr.GetValue (0), "#A3");
3930                                 Assert.IsFalse (dr.Read (), "#A4");
3931                                 dr.Close ();
3932                                 cmd.Dispose ();
3933
3934                                 cmd = conn.CreateCommand ();
3935                                 cmd.CommandText = select_by_id;
3936                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3937                                 param.Value = 4;
3938                                 dr = cmd.ExecuteReader ();
3939                                 Assert.IsTrue (dr.Read (), "#B1");
3940                                 Assert.AreEqual (typeof (DateTime), dr.GetFieldType (0), "#B2");
3941                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#B3");
3942                                 Assert.IsFalse (dr.Read (), "#B4");
3943                                 dr.Close ();
3944                                 cmd.Dispose ();
3945
3946                                 date = new DateTime (2004, 2, 21, 4, 50, 7);
3947
3948                                 cmd = conn.CreateCommand ();
3949                                 cmd.CommandText = insert_data;
3950                                 param = cmd.Parameters.Add ("type_date", OdbcType.Date);
3951                                 param.Value = date;
3952                                 cmd.ExecuteNonQuery ();
3953                                 cmd.Dispose ();
3954
3955                                 cmd = conn.CreateCommand ();
3956                                 cmd.CommandText = select_by_id;
3957                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3958                                 param.Value = 6000;
3959                                 dr = cmd.ExecuteReader ();
3960                                 Assert.IsTrue (dr.Read (), "#C1");
3961                                 Assert.AreEqual (typeof (DateTime), dr.GetFieldType (0), "#C2");
3962                                 Assert.AreEqual (new DateTime (2004, 2, 21), dr.GetValue (0), "#C3");
3963                                 Assert.IsFalse (dr.Read (), "#C4");
3964                                 dr.Close ();
3965                                 cmd.Dispose ();
3966
3967                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3968
3969                                 cmd = conn.CreateCommand ();
3970                                 cmd.CommandText = insert_data;
3971                                 param = cmd.Parameters.Add ("type_date", OdbcType.Date);
3972                                 param.Value = DBNull.Value;
3973                                 cmd.ExecuteNonQuery ();
3974                                 cmd.Dispose ();
3975
3976                                 cmd = conn.CreateCommand ();
3977                                 cmd.CommandText = select_by_id;
3978                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
3979                                 param.Value = 6000;
3980                                 dr = cmd.ExecuteReader ();
3981                                 Assert.IsTrue (dr.Read (), "#D1");
3982                                 Assert.AreEqual (typeof (DateTime), dr.GetFieldType (0), "#D2");
3983                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
3984                                 Assert.IsFalse (dr.Read (), "#D4");
3985                                 dr.Close ();
3986                                 cmd.Dispose ();
3987                         } finally {
3988                                 if (dr != null)
3989                                         dr.Close ();
3990                                 if (cmd != null)
3991                                         cmd.Dispose ();
3992                                 conn.Close ();
3993                                 conn.Open ();
3994                                 DBHelper.ExecuteNonQuery (conn, delete_data);
3995                                 conn.Close ();
3996                         }
3997                 }
3998
3999                 [Test]
4000                 public void TimeParameterTest ()
4001                 {
4002                         string insert_data = "insert into datetime_family (id, type_time) values (6000, ?)";
4003                         string select_data = "select type_time from datetime_family where type_time = ? and id = 1";
4004                         string select_by_id = "select type_time from datetime_family where id = ?";
4005                         string delete_data = "delete from datetime_family where id = 6000";
4006
4007                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
4008
4009                         IDataReader dr = null;
4010                         OdbcCommand cmd = null;
4011                         OdbcParameter param;
4012
4013                         try {
4014                                 if (!ConnectionManager.Instance.Odbc.EngineConfig.SupportsTime)
4015                                         Assert.Ignore ("Time test does not apply to the current driver (" + conn.Driver + ").");
4016
4017                                 TimeSpan time = ConnectionManager.Instance.Odbc.EngineConfig.SupportsMicroseconds ?
4018                                         new TimeSpan (23, 58, 59, 953) : new TimeSpan (23, 58, 59);
4019
4020                                 cmd = conn.CreateCommand ();
4021                                 cmd.CommandText = select_data;
4022                                 param = cmd.Parameters.Add ("type_time", OdbcType.Time);
4023                                 param.Value = time;
4024                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
4025                                 param.Value = 1;
4026                                 dr = cmd.ExecuteReader ();
4027                                 Assert.IsTrue (dr.Read (), "#A1");
4028                                 Assert.AreEqual (typeof (TimeSpan), dr.GetFieldType (0), "#A2");
4029                                 Assert.AreEqual (time, dr.GetValue (0), "#A3");
4030                                 Assert.IsFalse (dr.Read (), "#A4");
4031                                 dr.Close ();
4032                                 cmd.Dispose ();
4033
4034                                 cmd = conn.CreateCommand ();
4035                                 cmd.CommandText = select_by_id;
4036                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
4037                                 param.Value = 4;
4038                                 dr = cmd.ExecuteReader ();
4039                                 Assert.IsTrue (dr.Read (), "#B1");
4040                                 Assert.AreEqual (typeof (TimeSpan), dr.GetFieldType (0), "#B2");
4041                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#B3");
4042                                 Assert.IsFalse (dr.Read (), "#B4");
4043                                 dr.Close ();
4044                                 cmd.Dispose ();
4045
4046                                 time = new TimeSpan (23, 56, 43);
4047
4048                                 cmd = conn.CreateCommand ();
4049                                 cmd.CommandText = insert_data;
4050                                 param = cmd.Parameters.Add ("type_time", OdbcType.Time);
4051                                 param.Value = time;
4052                                 cmd.ExecuteNonQuery ();
4053                                 cmd.Dispose ();
4054
4055                                 cmd = conn.CreateCommand ();
4056                                 cmd.CommandText = select_by_id;
4057                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
4058                                 param.Value = 6000;
4059                                 dr = cmd.ExecuteReader ();
4060                                 Assert.IsTrue (dr.Read (), "#C1");
4061                                 Assert.AreEqual (typeof (TimeSpan), dr.GetFieldType (0), "#C2");
4062                                 Assert.AreEqual (time, dr.GetValue (0), "#C3");
4063                                 Assert.IsFalse (dr.Read (), "#C4");
4064                                 dr.Close ();
4065                                 cmd.Dispose ();
4066
4067                                 DBHelper.ExecuteNonQuery (conn, delete_data);
4068
4069                                 cmd = conn.CreateCommand ();
4070                                 cmd.CommandText = insert_data;
4071                                 param = cmd.Parameters.Add ("type_time", OdbcType.Date);
4072                                 param.Value = DBNull.Value;
4073                                 cmd.ExecuteNonQuery ();
4074                                 cmd.Dispose ();
4075
4076                                 cmd = conn.CreateCommand ();
4077                                 cmd.CommandText = select_by_id;
4078                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
4079                                 param.Value = 6000;
4080                                 dr = cmd.ExecuteReader ();
4081                                 Assert.IsTrue (dr.Read (), "#D1");
4082                                 Assert.AreEqual (typeof (TimeSpan), dr.GetFieldType (0), "#D2");
4083                                 Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
4084                                 Assert.IsFalse (dr.Read (), "#D4");
4085                                 dr.Close ();
4086                                 cmd.Dispose ();
4087                         } finally {
4088                                 if (dr != null)
4089                                         dr.Close ();
4090                                 if (cmd != null)
4091                                         cmd.Dispose ();
4092                                 conn.Close ();
4093                                 conn.Open ();
4094                                 DBHelper.ExecuteNonQuery (conn, delete_data);
4095                                 conn.Close ();
4096                         }
4097                 }
4098
4099                 [Test]
4100                 public void UniqueIdentifierParameterTest ()
4101                 {
4102                         string insert_data = "insert into string_family (id, type_guid) values (6000, ?)";
4103                         string select_data = "select id, type_guid from string_family where type_guid = ? and id = ?";
4104                         string select_by_id = "select id, type_guid from string_family where id = ?";
4105                         string delete_data = "delete from string_family where id = 6000";
4106
4107                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
4108
4109                         IDataReader dr = null;
4110                         OdbcCommand cmd = null;
4111                         OdbcParameter param;
4112
4113                         try {
4114                                 if (!ConnectionManager.Instance.Odbc.EngineConfig.SupportsUniqueIdentifier)
4115                                         Assert.Ignore ("UniqueIdentifier test does not apply to the current driver (" + conn.Driver + ").");
4116
4117                                 cmd = conn.CreateCommand ();
4118                                 cmd.CommandText = select_data;
4119                                 param = cmd.Parameters.Add ("type_guid", OdbcType.UniqueIdentifier);
4120                                 param.Value = new Guid ("d222a130-6383-4d36-ac5e-4e6b2591aabf");
4121                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
4122                                 param.Value = 1;
4123                                 dr = cmd.ExecuteReader ();
4124                                 Assert.IsTrue (dr.Read (), "#A1");
4125                                 Assert.AreEqual (1, dr.GetValue (0), "#A2");
4126                                 Assert.AreEqual (new Guid ("d222a130-6383-4d36-ac5e-4e6b2591aabf"), dr.GetValue (1), "#A3");
4127                                 Assert.IsFalse (dr.Read (), "#A4");
4128                                 dr.Close ();
4129                                 cmd.Dispose ();
4130
4131                                 cmd = conn.CreateCommand ();
4132                                 cmd.CommandText = select_by_id;
4133                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
4134                                 param.Value = 4;
4135                                 dr = cmd.ExecuteReader ();
4136                                 Assert.IsTrue (dr.Read (), "#B1");
4137                                 Assert.AreEqual (4, dr.GetValue (0), "#B2");
4138                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#B3");
4139                                 Assert.IsFalse (dr.Read (), "#B4");
4140                                 dr.Close ();
4141                                 cmd.Dispose ();
4142
4143                                 cmd = (OdbcCommand) conn.CreateCommand ();
4144                                 cmd.CommandText = insert_data;
4145                                 param = cmd.Parameters.Add ("type_guid", OdbcType.UniqueIdentifier);
4146                                 param.Value = new Guid ("e222a130-6383-4d36-ac5e-4e6b2591aabe");
4147                                 cmd.ExecuteNonQuery ();
4148                                 cmd.Dispose ();
4149
4150                                 cmd = conn.CreateCommand ();
4151                                 cmd.CommandText = select_data;
4152                                 param = cmd.Parameters.Add ("type_guid", OdbcType.UniqueIdentifier);
4153                                 param.Value = new Guid ("e222a130-6383-4d36-ac5e-4e6b2591aabe");
4154                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
4155                                 param.Value = 6000;
4156                                 dr = cmd.ExecuteReader ();
4157                                 Assert.IsTrue (dr.Read (), "#C1");
4158                                 Assert.AreEqual (6000, dr.GetValue (0), "#C2");
4159                                 Assert.AreEqual (new Guid ("e222a130-6383-4d36-ac5e-4e6b2591aabe"), dr.GetValue (1), "#C3");
4160                                 Assert.IsFalse (dr.Read (), "#C4");
4161                                 dr.Close ();
4162                                 cmd.Dispose ();
4163
4164                                 DBHelper.ExecuteNonQuery (conn, delete_data);
4165
4166                                 cmd = (OdbcCommand) conn.CreateCommand ();
4167                                 cmd.CommandText = insert_data;
4168                                 param = cmd.Parameters.Add ("type_guid", OdbcType.UniqueIdentifier);
4169                                 param.Value = DBNull.Value;
4170                                 cmd.ExecuteNonQuery ();
4171                                 cmd.Dispose ();
4172
4173                                 cmd = conn.CreateCommand ();
4174                                 cmd.CommandText = select_by_id;
4175                                 param = cmd.Parameters.Add ("id", OdbcType.Int);
4176                                 param.Value = 6000;
4177                                 dr = cmd.ExecuteReader ();
4178                                 Assert.IsTrue (dr.Read (), "#D1");
4179                                 Assert.AreEqual (6000, dr.GetValue (0), "#D2");
4180                                 Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D3");
4181                                 Assert.IsFalse (dr.Read (), "#D4");
4182                                 dr.Close ();
4183                                 cmd.Dispose ();
4184                         } finally {
4185                                 if (dr != null)
4186                                         dr.Close ();
4187                                 if (cmd != null)
4188                                         cmd.Dispose ();
4189
4190                                 conn.Close ();
4191                                 conn.Open ();
4192                                 DBHelper.ExecuteNonQuery (conn, delete_data);
4193                                 conn.Close ();
4194                         }
4195                 }
4196
4197                 [Test]
4198                 public void DBNullParameterTest()
4199                 {
4200                         OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
4201                         try
4202                         {
4203                                 OdbcDataAdapter Adaptador = new OdbcDataAdapter ();
4204                                 DataSet Lector = new DataSet ();
4205
4206                                 Adaptador.SelectCommand = new OdbcCommand ("SELECT ?;", (OdbcConnection) conn);
4207                                 Adaptador.SelectCommand.Parameters.AddWithValue("@un", DBNull.Value);
4208                                 Adaptador.Fill (Lector);
4209                                 Assert.AreEqual (Lector.Tables[0].Rows[0][0], DBNull.Value, "#1 DBNull parameter not passed correctly");
4210                         } finally {
4211                                 ConnectionManager.Instance.Odbc.CloseConnection ();
4212                         }
4213                 }
4214
4215                 [Test]
4216                 public void ParameterName ()
4217                 {
4218                         OdbcParameter p = new OdbcParameter ();
4219                         p.ParameterName = "foo1";
4220                         Assert.AreEqual ("foo1", p.ParameterName, "#1");
4221                         p.ParameterName = null;
4222                         Assert.AreEqual (string.Empty, p.ParameterName, "#2");
4223                         p.ParameterName = "foo2";
4224                         Assert.AreEqual ("foo2", p.ParameterName, "#3");
4225                         p.ParameterName = string.Empty;
4226                         Assert.AreEqual (string.Empty, p.ParameterName, "#4");
4227                 }
4228
4229                 [Test]
4230                 public void SourceColumn ()
4231                 {
4232                         OdbcParameter p = new OdbcParameter ();
4233                         p.SourceColumn = "foo1";
4234                         Assert.AreEqual ("foo1", p.SourceColumn, "#1");
4235                         p.SourceColumn = null;
4236                         Assert.AreEqual (string.Empty, p.SourceColumn, "#2");
4237                         p.SourceColumn = "foo2";
4238                         Assert.AreEqual ("foo2", p.SourceColumn, "#3");
4239                         p.SourceColumn = string.Empty;
4240                         Assert.AreEqual (string.Empty, p.SourceColumn, "#4");
4241                 }
4242
4243                 [Test]
4244                 public void DefaultValuesTest ()
4245                 {
4246                         OdbcParameter p;
4247
4248                         p = new OdbcParameter();
4249                         Assert.AreEqual (DbType.String, p.DbType, "#A:DbType");
4250                         Assert.AreEqual (ParameterDirection.Input, p.Direction, "#A:Direction");
4251                         Assert.IsFalse (p.IsNullable, "#A:IsNullable");
4252                         Assert.AreEqual (OdbcType.NVarChar, p.OdbcType, "#A:OdbcType");
4253                         Assert.AreEqual (String.Empty, p.ParameterName, "#A:ParameterName");
4254                         Assert.AreEqual (0, p.Precision, "#A:Precision");
4255                         Assert.AreEqual (0, p.Scale, "#A:Scale");
4256                         Assert.AreEqual (0, p.Size, "#A:Size");
4257                         Assert.AreEqual (String.Empty, p.SourceColumn, "#A:SourceColumn");
4258                         Assert.IsFalse (p.SourceColumnNullMapping, "#A:SourceColumnNullMapping");
4259                         Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "#A:SourceVersion");
4260                         Assert.IsNull (p.Value, "#A:Value");
4261
4262                         p = new OdbcParameter(null, 2);
4263                         Assert.AreEqual (DbType.String, p.DbType, "#B:DbType");
4264                         Assert.AreEqual (ParameterDirection.Input, p.Direction, "#B:Direction");
4265                         Assert.IsFalse (p.IsNullable, "#B:IsNullable");
4266                         Assert.AreEqual (OdbcType.NVarChar, p.OdbcType, "#B:OdbcType");
4267                         Assert.AreEqual (String.Empty, p.ParameterName, "#B:ParameterName");
4268                         Assert.AreEqual (0, p.Precision, "#B:Precision");
4269                         Assert.AreEqual (0, p.Scale, "#B:Scale");
4270                         Assert.AreEqual (0, p.Size, "#B:Size");
4271                         Assert.AreEqual (String.Empty, p.SourceColumn, "#B:SourceColumn");
4272                         Assert.IsFalse (p.SourceColumnNullMapping, "#B:SourceColumnNullMapping");
4273                         Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "#B:SourceVersion");
4274                         Assert.AreEqual (2, p.Value, "#B:Value");
4275
4276                         p = new OdbcParameter("foo", 2);
4277                         Assert.AreEqual (DbType.String, p.DbType, "#C:DbType");
4278                         Assert.AreEqual (ParameterDirection.Input, p.Direction, "#C:Direction");
4279                         Assert.IsFalse (p.IsNullable, "#C:IsNullable");
4280                         Assert.AreEqual (OdbcType.NVarChar, p.OdbcType, "#C:OdbcType");
4281                         Assert.AreEqual ("foo", p.ParameterName, "#C:ParameterName");
4282                         Assert.AreEqual (0, p.Precision, "#C:Precision");
4283                         Assert.AreEqual (0, p.Scale, "#C:Scale");
4284                         Assert.AreEqual (0, p.Size, "#C:Size");
4285                         Assert.AreEqual (String.Empty, p.SourceColumn, "#C:SourceColumn");
4286                         Assert.IsFalse (p.SourceColumnNullMapping, "#C:SourceColumnNullMapping");
4287                         Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "#C:SourceVersion");
4288                         Assert.AreEqual (2, p.Value, "#C:Value");
4289
4290                         p = new OdbcParameter("foo1", OdbcType.Int);
4291                         Assert.AreEqual (DbType.Int32, p.DbType, "#D:DbType");
4292                         Assert.AreEqual (ParameterDirection.Input, p.Direction, "#D:Direction");
4293                         Assert.IsFalse (p.IsNullable, "#D:IsNullable");
4294                         Assert.AreEqual (OdbcType.Int, p.OdbcType, "#D:OdbcType");
4295                         Assert.AreEqual ("foo1", p.ParameterName, "#D:ParameterName");
4296                         Assert.AreEqual (0, p.Precision, "#D:Precision");
4297                         Assert.AreEqual (0, p.Scale, "#D:Scale");
4298                         Assert.AreEqual (0, p.Size, "#D:Size");
4299                         Assert.AreEqual (String.Empty, p.SourceColumn, "#D:SourceColumn");
4300                         Assert.IsFalse (p.SourceColumnNullMapping, "#D:SourceColumnNullMapping");
4301                         Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "#D:SourceVersion");
4302                         Assert.IsNull (p.Value, "#D:Value");
4303                 }
4304         }
4305 }
4306
4307 #endif