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