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

// OdbcCommandTest.cs - NUnit Test Cases for testing the
// OdbcCommand class
//
// Authors:
//      Sureshkumar T ([email protected])
//      Gert Driesen ([email protected])
// 
// Copyright (c) 2005-2008 Novell Inc., and the individuals listed
// on the ChangeLog entries.
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

#if !NO_ODBC

using System;
using System.Data;
using System.Data.Common;
using System.Data.Odbc;
using System.Globalization;
using System.Text;
using System.Threading;
using NUnit.Framework;


namespace MonoTests.System.Data.Connected.Odbc
{
	[TestFixture]
	[Category ("odbc")]
	public class OdbcParameterTest
	{
		private CultureInfo _originalCulture;

		[SetUp]
		public void Setup ()
		{
			_originalCulture = Thread.CurrentThread.CurrentCulture;
			Thread.CurrentThread.CurrentCulture = new CultureInfo ("nl-BE");
		}

		[TearDown]
		public void TearDown ()
		{
			Thread.CurrentThread.CurrentCulture = _originalCulture;
		}

		[Test]
		public void IntegerParamTest ()
		{
			string insert_data = "insert into numeric_family (id, type_int) values (6000, ?)";
			string select_data = "select id, type_int from numeric_family where type_int = ? and id = ?";
			string select_by_id = "select id, type_int from numeric_family where id = ?";
			string delete_data = "delete from numeric_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
				param.Value = int.MaxValue;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A2");
				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#A3");
				Assert.AreEqual (int.MaxValue, dr.GetValue (1), "#A4");
				Assert.IsFalse (dr.Read (), "#A5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
				param.Value = int.MinValue;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (2, dr.GetValue (0), "#B2");
				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#B3");
				Assert.AreEqual (int.MinValue, dr.GetValue (1), "#B4");
				Assert.IsFalse (dr.Read (), "#B5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
				param.Value = 0;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (3, dr.GetValue (0), "#C2");
				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#C3");
				Assert.AreEqual (0, dr.GetValue (1), "#C4");
				Assert.IsFalse (dr.Read (), "#C5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (4, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
				param.Value = int.MaxValue;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#E4");
				Assert.AreEqual (int.MaxValue, dr.GetValue (1), "#E5");
				Assert.IsFalse (dr.Read (), "#E6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
				param.Value = int.MinValue;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#F4");
				Assert.AreEqual (int.MinValue, dr.GetValue (1), "#F5");
				Assert.IsFalse (dr.Read (), "#F6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
				param.Value = 0;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#G4");
				Assert.AreEqual (0, dr.GetValue (1), "#G5");
				Assert.IsFalse (dr.Read (), "#G6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_int", OdbcType.Int);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
				Assert.AreEqual (typeof (int), dr.GetFieldType (1), "#H4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
				Assert.IsFalse (dr.Read (), "#H6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void BigIntParamTest ()
		{
			string insert_data = "insert into numeric_family (id, type_bigint) values (6000, ?)";
			string select_data = "select id, type_bigint from numeric_family where type_bigint = ? and id = ?";
			string select_by_id = "select id, type_bigint from numeric_family where id = ?";
			string delete_data = "delete from numeric_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
				param.Value = 9223372036854775807L;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A3");
				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#A4");
				Assert.AreEqual (9223372036854775807L, dr.GetValue (1), "#A5");
				Assert.IsFalse (dr.Read (), "#A6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
				param.Value = -9223372036854775808L;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (2, dr.GetValue (0), "#B3");
				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#B4");
				Assert.AreEqual (-9223372036854775808L, dr.GetValue (1), "#B5");
				Assert.IsFalse (dr.Read (), "#B6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
				param.Value = 0L;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (3, dr.GetValue (0), "#C3");
				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#C4");
				Assert.AreEqual (0L, dr.GetValue (1), "#C5");
				Assert.IsFalse (dr.Read (), "#C6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (4, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
				param.Value = 8223372036854775805L;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
				param.Value = 8223372036854775805L;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#E4");
				Assert.AreEqual (8223372036854775805L, dr.GetValue (1), "#E5");
				Assert.IsFalse (dr.Read (), "#E6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
				param.Value = -8223372036854775805L;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
				param.Value = -8223372036854775805L;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#F4");
				Assert.AreEqual (-8223372036854775805L, dr.GetValue (1), "#F5");
				Assert.IsFalse (dr.Read (), "#F6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
				param.Value = 0L;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
				param.Value = 0;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#G4");
				Assert.AreEqual (0L, dr.GetValue (1), "#G5");
				Assert.IsFalse (dr.Read (), "#G6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_bigint", OdbcType.BigInt);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
				Assert.AreEqual (typeof (long), dr.GetFieldType (1), "#H4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
				Assert.IsFalse (dr.Read (), "#H6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void BinaryParameterTest ()
		{
			string insert_data = "insert into binary_family (id, type_binary) values (6000, ?)";
			string select_data = "select id, type_binary from binary_family where type_binary = ? and id = ?";
			string select_by_id = "select id, type_binary from binary_family where id = ?";
			string delete_data = "delete from binary_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				byte [] bytes = new byte [] { 0x35, 0x00, 0x00,
					0x00, 0x00, 0x00, 0x00, 0x00 };

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
				param.Value = bytes;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#A4");
				Assert.AreEqual (bytes, dr.GetValue (1), "#A5");
				Assert.IsFalse (dr.Read (), "#A6");
				dr.Close ();
				cmd.Dispose ();

				bytes = new byte [] { 0x00, 0x33, 0x34, 0x00,
					0x33, 0x30, 0x35, 0x31 };

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
				param.Value = bytes;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (2, dr.GetValue (0), "#B3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#B4");
				Assert.AreEqual (bytes, dr.GetValue (1), "#B5");
				Assert.IsFalse (dr.Read (), "#B6");
				dr.Close ();
				cmd.Dispose ();

				bytes = new byte [8];

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
				param.Value = bytes;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (3, dr.GetValue (0), "#C3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#C4");
				Assert.AreEqual (bytes, dr.GetValue (1), "#C5");
				Assert.IsFalse (dr.Read (), "#C6");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int); 
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (4, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();

				bytes = new byte [0];

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
				param.Value = bytes;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#E4");
				Assert.AreEqual (new byte [8], dr.GetValue (1), "#E5");
				Assert.IsFalse (dr.Read (), "#E6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				bytes = new byte [] { 0x05 };

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
				param.Value = bytes;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#F4");
				Assert.AreEqual (new byte [] { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, dr.GetValue (1), "#F5");
				Assert.IsFalse (dr.Read (), "#F6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				bytes = new byte [] { 0x34, 0x00, 0x32 };

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
				param.Value = bytes;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#G4");
				Assert.AreEqual (new byte [] { 0x34, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00 }, dr.GetValue (1), "#G5");
				Assert.IsFalse (dr.Read (), "#G6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				bytes = new byte [] { 0x34, 0x00, 0x32, 0x05, 0x07, 0x13 };

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary, 4);
				param.Value = bytes;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#H4");
				Assert.AreEqual (new byte [] { 0x34, 0x00, 0x32, 0x05, 0x00, 0x00, 0x00, 0x00 }, dr.GetValue (1), "#H5");
				Assert.IsFalse (dr.Read (), "#H6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_binary", OdbcType.Binary);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#I1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#I2");
				Assert.AreEqual (6000, dr.GetValue (0), "#I3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#I4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#I5");
				Assert.IsFalse (dr.Read (), "#I6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void SmallIntParamTest ()
		{
			string insert_data = "insert into numeric_family (id, type_smallint) values (6000, ?)";
			string select_data = "select id, type_smallint from numeric_family where type_smallint = ? and id = ?";
			string select_by_id = "select id, type_smallint from numeric_family where id = ?";
			string delete_data = "delete from numeric_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
				param.Value = short.MaxValue;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A2");
				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#A3");
				Assert.AreEqual (short.MaxValue, dr.GetValue (1), "#A4");
				Assert.IsFalse (dr.Read (), "#A5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
				param.Value = short.MinValue;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (2, dr.GetValue (0), "#B2");
				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#B3");
				Assert.AreEqual (short.MinValue, dr.GetValue (1), "#B4");
				Assert.IsFalse (dr.Read (), "#B5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
				param.Value = (short) 0;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (3, dr.GetValue (0), "#C2");
				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#C3");
				Assert.AreEqual (0, dr.GetValue (1), "#C4");
				Assert.IsFalse (dr.Read (), "#C5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (4, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
				param.Value = short.MaxValue;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#E4");
				Assert.AreEqual (short.MaxValue, dr.GetValue (1), "#E5");
				Assert.IsFalse (dr.Read (), "#E6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
				param.Value = short.MinValue;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#F4");
				Assert.AreEqual (short.MinValue, dr.GetValue (1), "#F5");
				Assert.IsFalse (dr.Read (), "#F6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
				param.Value = 0;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#G4");
				Assert.AreEqual ((short) 0, dr.GetValue (1), "#G5");
				Assert.IsFalse (dr.Read (), "#G6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_smallint", OdbcType.SmallInt);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
				Assert.AreEqual (typeof (short), dr.GetFieldType (1), "#H4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
				Assert.IsFalse (dr.Read (), "#H6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void TimestampParameterTest ()
		{
			// the value for the timestamp column is determined by
			// the RDBMS upon insert/update and cannot be specified
			// by the user

			string insert_data = "insert into binary_family (id) values (6000)";
			string select_by_id = "select id, type_timestamp from binary_family where id = ?";
			string delete_data = "delete from binary_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				if (!ConnectionManager.Instance.Odbc.EngineConfig.SupportsTimestamp)
					Assert.Ignore ("Timestamp test does not apply to the current driver (" + conn.Driver + ").");

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				byte [] timestamp;

				cmd = conn.CreateCommand ();
				cmd.CommandText = "SELECT @@DBTS";
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#A2");
				timestamp = (byte []) dr.GetValue (0);
				Assert.IsFalse (dr.Read (), "#A3");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (6000, dr.GetValue (0), "#B3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#B4");
				Assert.AreEqual (timestamp, dr.GetValue (1), "#B5");
				Assert.IsFalse (dr.Read (), "#B6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();

				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void TinyIntParamTest ()
		{
			string insert_data = "insert into numeric_family (id, type_tinyint) values (6000, ?)";
			string select_data = "select id, type_tinyint from numeric_family where type_tinyint = ? and id = ?";
			string select_by_id = "select id, type_tinyint from numeric_family where id = ?";
			string delete_data = "delete from numeric_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
				param.Value = byte.MaxValue;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A2");
				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#A3");
				Assert.AreEqual (byte.MaxValue, dr.GetValue (1), "#A4");
				Assert.IsFalse (dr.Read (), "#A5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
				param.Value = byte.MinValue;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (2, dr.GetValue (0), "#B2");
				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#B3");
				Assert.AreEqual (byte.MinValue, dr.GetValue (1), "#B4");
				Assert.IsFalse (dr.Read (), "#B5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
				param.Value = 0x00;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (3, dr.GetValue (0), "#C2");
				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#C3");
				Assert.AreEqual (0x00, dr.GetValue (1), "#C4");
				Assert.IsFalse (dr.Read (), "#C5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (4, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
				param.Value = byte.MaxValue;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#E4");
				Assert.AreEqual (byte.MaxValue, dr.GetValue (1), "#E5");
				Assert.IsFalse (dr.Read (), "#E6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
				param.Value = byte.MinValue;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#F4");
				Assert.AreEqual (byte.MinValue, dr.GetValue (1), "#F5");
				Assert.IsFalse (dr.Read (), "#F6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
				param.Value = 0x00;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#G4");
				Assert.AreEqual (0x00, dr.GetValue (1), "#G5");
				Assert.IsFalse (dr.Read (), "#G6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_tinyint", OdbcType.TinyInt);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
				Assert.AreEqual (typeof (byte), dr.GetFieldType (1), "#H4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
				Assert.IsFalse (dr.Read (), "#H6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void StringParamTest ()
		{
			string query = "select id, fname from employee where fname = ?";
			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
			try {
				OdbcCommand cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = query;

				OdbcParameter param = cmd.Parameters.Add ("fname", OdbcType.VarChar);
				param.Value = "suresh";
				OdbcDataReader dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#1 no data to test");
				Assert.AreEqual (1, (int) dr [0], "#2 value not matching");
			} finally {
				ConnectionManager.Instance.Odbc.CloseConnection ();
			}
		}


		[Test]
		public void BitParameterTest ()
		{
			string insert_data = "insert into numeric_family (id, type_bit) values (6000, ?)";
			string select_data = "select id, type_bit from numeric_family where type_bit = ? and id = ?";
			string select_by_id = "select id, type_bit from numeric_family where id = ?";
			string delete_data = "delete from numeric_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
				param.Value = true;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A2");
				Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#A3");
				Assert.AreEqual (true, dr.GetValue (1), "#A4");
				Assert.IsFalse (dr.Read (), "#A5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
				param.Value = false;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (2, dr.GetValue (0), "#B2");
				Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#B3");
				Assert.AreEqual (false, dr.GetValue (1), "#B4");
				Assert.IsFalse (dr.Read (), "#B5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (4, dr.GetValue (0), "#C3");
				Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#C4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#C5");
				Assert.IsFalse (dr.Read (), "#C6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
				param.Value = true;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
				param.Value = true;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (6000, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (true, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
				param.Value = false;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
				param.Value = false;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
				Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#E4");
				Assert.AreEqual (false, dr.GetValue (1), "#E5");
				Assert.IsFalse (dr.Read (), "#E6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_bit", OdbcType.Bit);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
				Assert.AreEqual (typeof (bool), dr.GetFieldType (1), "#F4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#F5");
				Assert.IsFalse (dr.Read (), "#F6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void CharParameterTest ()
		{
			string insert_data = "insert into string_family (id, type_char) values (6000, ?)";
			string select_data = "select id, type_char from string_family where type_char = ? and id = ?";
			string select_by_id = "select id, type_char from string_family where id = ?";
			string delete_data = "delete from string_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_char", OdbcType.Char);
				param.Value = "char";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A3");
				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#A4");
				if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
					Assert.AreEqual ("char", dr.GetValue (1), "#A5");
				else
					Assert.AreEqual ("char      ", dr.GetValue (1), "#A5");
				Assert.IsFalse (dr.Read (), "#A6");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_char", OdbcType.Char);
				param.Value = "0123456789";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (2, dr.GetValue (0), "#B3");
				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#B4");
				Assert.AreEqual ("0123456789", dr.GetValue (1), "#B5");
				Assert.IsFalse (dr.Read (), "#B6");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_char", OdbcType.Char);
				param.Value = string.Empty;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (3, dr.GetValue (0), "#C3");
				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#C4");
				if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
					Assert.AreEqual (string.Empty, dr.GetValue (1), "#C5");
				else
					Assert.AreEqual ("          ", dr.GetValue (1), "#C5");
				Assert.IsFalse (dr.Read (), "#C6");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (4, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_char", OdbcType.Char, 3);
				param.Value = "ABCD";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_char", OdbcType.Char, 3);
				param.Value = "ABCE ";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#E4");
				if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
					Assert.AreEqual ("ABC", dr.GetValue (1), "#E5");
				else
					Assert.AreEqual ("ABC       ", dr.GetValue (1), "#E5");
				Assert.IsFalse (dr.Read (), "#E6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_char", OdbcType.Char, 20);
				param.Value = "ABCDEFGHIJ";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_char", OdbcType.Char);
				param.Value = "ABCDEFGHIJ";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#F4");
				Assert.AreEqual ("ABCDEFGHIJ", dr.GetValue (1), "#F5");
				Assert.IsFalse (dr.Read (), "#F6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_char", OdbcType.Char, 20);
				param.Value = string.Empty;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_char", OdbcType.Char);
				param.Value = string.Empty;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#G4");
				if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
					Assert.AreEqual (string.Empty, dr.GetValue (1), "#G5");
				else
					Assert.AreEqual ("          ", dr.GetValue (1), "#G5");
				Assert.IsFalse (dr.Read (), "#G6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_char", OdbcType.Char);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (4, dr.GetValue (0), "#H3");
				Assert.AreEqual (typeof (string), dr.GetFieldType (1), "#H4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
				Assert.IsFalse (dr.Read (), "#H6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void DecimalParameterTest ()
		{
			string select_data1 = "select id, type_decimal1 from numeric_family where type_decimal1 = ? and id = ?";
			string select_data2 = "select id, type_decimal2 from numeric_family where type_decimal2 = ? and id = ?";
			string select_by_id = "select id, type_decimal1, type_decimal2 from numeric_family where id = ?";
			string insert_data = "insert into numeric_family (id, type_decimal1, type_decimal2) values (6000, ?, ?)";
			string delete_data = "delete from numeric_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data1;
				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
				param.Value = 1000.00m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#A4");
				Assert.AreEqual (1000m, dr.GetValue (1), "#A5");
				Assert.IsFalse (dr.Read (), "#A6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data1;
				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
				param.Value = -1000.00m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (2, dr.GetValue (0), "#B3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#B4");
				Assert.AreEqual (-1000m, dr.GetValue (1), "#B5");
				Assert.IsFalse (dr.Read (), "#B6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data2;
				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
				param.Value = 4456.432m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (1, dr.GetValue (0), "#C3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#C4");
				Assert.AreEqual (4456.432m, dr.GetValue (1), "#C5");
				Assert.IsFalse (dr.Read (), "#C6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data2;
				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
				param.Value = -4456.432m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (2, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (-4456.432m, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data1;
				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
				param.Value = 0m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (3, dr.GetValue (0), "#E3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#E4");
				Assert.AreEqual (0m, dr.GetValue (1), "#E5");
				Assert.IsFalse (dr.Read (), "#E6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data1;
				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
				param.Value = DBNull.Value;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsFalse (dr.Read (), "#F");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (4, dr.GetValue (0), "#G3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#G4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#G5");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#G6");
				Assert.AreEqual (DBNull.Value, dr.GetValue (2), "#G7");
				Assert.IsFalse (dr.Read (), "#G8");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
				param.Value = -1000.5678m;
				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
				param.Value = -1000.5678m;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data1;
				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
				param.Value = -1000.5678m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsFalse (dr.Read (), "#H");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data1;
				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
				param.Value = -1001;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#I1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#I2");
				Assert.AreEqual (6000, dr.GetValue (0), "#I3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#I4");
				Assert.AreEqual (-1001m, dr.GetValue (1), "#I5");
				Assert.IsFalse (dr.Read (), "#I6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data2;
				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
				param.Value = -1000.5678m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsFalse (dr.Read (), "#J");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data2;
				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
				param.Value = -1000.568m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#K1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#K2");
				Assert.AreEqual (6000, dr.GetValue (0), "#K3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#K4");
				Assert.AreEqual (-1000.568m, dr.GetValue (1), "#K5");
				Assert.IsFalse (dr.Read (), "#K6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
				param.Value = 56789m;
				param.Precision = 7;
				param.Scale = 2;
				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
				param.Value = 98765.5678m;
				param.Precision = 10;
				param.Scale = 2;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#L1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#L2");
				Assert.AreEqual (6000, dr.GetValue (0), "#L3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#L4");
				Assert.AreEqual (56789m, dr.GetValue (1), "#L5");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#L6");
				if (ConnectionManager.Instance.Odbc.EngineConfig.Type == EngineType.MySQL)
					Assert.AreEqual (9876556.780m, dr.GetValue (2), "#L7");
				else
					Assert.AreEqual (98765.570m, dr.GetValue (2), "#L7");
				Assert.IsFalse (dr.Read (), "#L8");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_decimal1", OdbcType.Decimal);
				param.Value = DBNull.Value;
				param = cmd.Parameters.Add ("type_decimal2", OdbcType.Decimal);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#M1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#M2");
				Assert.AreEqual (6000, dr.GetValue (0), "#M3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#M4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#M5");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#M6");
				Assert.AreEqual (DBNull.Value, dr.GetValue(1), "#M7");
				Assert.AreEqual (DBNull.Value, dr.GetValue (2), "#M8");
				Assert.IsFalse (dr.Read (), "#M9");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (cmd != null)
					cmd.Dispose ();
				if (dr != null)
					dr.Close ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}
		
		[Test]
		public void DoubleParameterTest ()
		{
			string insert_data = "insert into numeric_family (id, type_double) values (6000, ?)";
			string select_data = "select id, type_double from numeric_family where type_double = ? and id = ?";
			string select_by_id = "select id, type_double from numeric_family where id = ?";
			string delete_data = "delete from numeric_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
				param.Value = 1.79E+308;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A3");
				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#A4");
				Assert.AreEqual (1.79E+308, dr.GetValue (1), "#A5");
				Assert.IsFalse (dr.Read (), "#A6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
				param.Value = -1.79E+308;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (2, dr.GetValue (0), "#B3");
				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#B4");
				Assert.AreEqual (-1.79E+308, dr.GetValue (1), "#B5");
				Assert.IsFalse (dr.Read (), "#B6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
				param.Value = 0d;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (3, dr.GetValue (0), "#C3");
				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#C4");
				Assert.AreEqual (0d, dr.GetValue (1), "#C5");
				Assert.IsFalse (dr.Read (), "#C6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (4, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
				param.Value = 1.79E+308;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
				param.Value = 1.79E+308;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#E4");
				Assert.AreEqual (1.79E+308, dr.GetValue (1), "#E5");
				Assert.IsFalse (dr.Read (), "#E6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
				param.Value = -1.79E+308;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
				param.Value = -1.79E+308;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#F4");
				Assert.AreEqual (-1.79E+308, dr.GetValue (1), "#F5");
				Assert.IsFalse (dr.Read (), "#F6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
				param.Value = "45543,55";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
				param.Value = "45543,55";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#G4");
				Assert.AreEqual (45543.55d, dr.GetValue (1), "#G5");
				Assert.IsFalse (dr.Read (), "#G6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_double", OdbcType.Double);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
				Assert.AreEqual (typeof (double), dr.GetFieldType (1), "#H4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
				Assert.IsFalse (dr.Read (), "#H6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void ImageParameterTest ()
		{
			string insert_data = "insert into binary_family (id, type_blob) values (6000, ?)";
			string select_data = "select type_blob from binary_family where id = ?";
			string delete_data = "delete from binary_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				byte [] bytes = new byte [] { 0x32, 0x56, 0x00,
					0x44, 0x22 };

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (bytes, dr.GetValue (0), "#A3");
				Assert.IsFalse (dr.Read (), "#A4");
				dr.Close ();
				cmd.Dispose ();

				bytes = new byte [] { 0x00, 0x66, 0x06, 0x66,
					0x97, 0x00, 0x66, 0x06, 0x66, 0x97, 0x06,
					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
					0x06, 0x66, 0x06, 0x66, 0x97, 0x06, 0x66,
					0x06, 0x66, 0x97, 0x06, 0x66, 0x06, 0x66,
					0x97, 0x06, 0x66, 0x06, 0x66, 0x97, 0x06,
					0x66, 0x06, 0x66, 0x97, 0x06, 0x66, 0x06,
					0x66, 0x97, 0x06, 0x66, 0x06, 0x66, 0x97,
					0x06, 0x66, 0x06, 0x66, 0x98};

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (bytes, dr.GetValue (0), "#B3");
				Assert.IsFalse (dr.Read (), "#B4");
				dr.Close ();
				cmd.Dispose ();

				bytes = new byte [8];

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (new byte [0], dr.GetValue (0), "#C3");
				Assert.IsFalse (dr.Read (), "#C4");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
				Assert.IsFalse (dr.Read (), "#D4");
				dr.Close ();
				cmd.Dispose ();

				bytes = new byte [0];

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
				param.Value = bytes;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (bytes, dr.GetValue (0), "#E3");
				Assert.IsFalse (dr.Read (), "#E4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				bytes = new byte [] { 0x05 };

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
				param.Value = bytes;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#F2");
				Assert.AreEqual (bytes, dr.GetValue (0), "#F3");
				Assert.IsFalse (dr.Read (), "#F4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				bytes = new byte [] { 0x34, 0x00, 0x32 };

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
				param.Value = bytes;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (bytes, dr.GetValue (0), "#G3");
				Assert.IsFalse (dr.Read (), "#G4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				bytes = new byte [] { 0x34, 0x00, 0x32, 0x05, 0x07, 0x13 };

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_blob", OdbcType.Image, 4);
				param.Value = bytes;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (new byte [] { 0x34, 0x00, 0x32, 0x05 }, dr.GetValue (0), "#H3");
				Assert.IsFalse (dr.Read (), "#H4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_blob", OdbcType.Image);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#I1");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (0), "#I2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#I3");
				Assert.IsFalse (dr.Read (), "#I4");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void NCharParameterTest ()
		{
			string insert_data = "insert into string_family (id, type_nchar) values (6000, ?)";
			string select_data = "select type_nchar from string_family where type_nchar = ? and id = ?";
			string select_by_id = "select type_nchar from string_family where id = ?";
			string delete_data = "delete from string_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
				param.Value = "nch\u092d\u093er";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
				if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
					Assert.AreEqual ("nch\u092d\u093er", dr.GetValue (0), "#A3");
				else
					Assert.AreEqual ("nch\u092d\u093er    ", dr.GetValue (0), "#A3");
				Assert.IsFalse (dr.Read (), "#A4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
				param.Value = "0123456789";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
				Assert.AreEqual ("0123456789", dr.GetValue (0), "#B3");
				Assert.IsFalse (dr.Read (), "#B4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
				param.Value = string.Empty;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
				if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
					Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
				else
					Assert.AreEqual ("          ", dr.GetValue (0), "#C3");
				Assert.IsFalse (dr.Read (), "#C4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
				Assert.IsFalse (dr.Read (), "#D4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
				param.Value = "nchar";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
				param.Value = "nchar";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
				if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
					Assert.AreEqual ("nchar", dr.GetValue (0), "#E3");
				else
					Assert.AreEqual ("nchar     ", dr.GetValue (0), "#E3");
				Assert.IsFalse (dr.Read (), "#E4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 4);
				param.Value = "nch\u0488r";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 4);
				param.Value = "nch\u0488r";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
				if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
					Assert.AreEqual ("nch\u0488", dr.GetValue (0), "#F3");
				else
					Assert.AreEqual ("nch\u0488      ", dr.GetValue (0), "#F3");
				Assert.IsFalse (dr.Read (), "#F4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 8);
				param.Value = "ch\u0488r";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
				param.Value = "ch\u0488r";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
				if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
					Assert.AreEqual ("ch\u0488r", dr.GetValue (0), "#G3");
				else
					Assert.AreEqual ("ch\u0488r      ", dr.GetValue (0), "#G3");
				Assert.IsFalse (dr.Read (), "#G4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 15);
				param.Value = "0123456789";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
				param.Value = "0123456789";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
				Assert.AreEqual ("0123456789", dr.GetValue (0), "#H3");
				Assert.IsFalse (dr.Read (), "#H4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar, 15);
				param.Value = string.Empty;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
				param.Value = string.Empty;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#I1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#I2");
				if (ConnectionManager.Instance.Odbc.EngineConfig.RemovesTrailingSpaces)
					Assert.AreEqual (string.Empty, dr.GetValue (0), "#I3");
				else
					Assert.AreEqual ("          ", dr.GetValue (0), "#I3");
				Assert.IsFalse (dr.Read (), "#I4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_nchar", OdbcType.NChar);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#J1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#J2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#J3");
				Assert.IsFalse (dr.Read (), "#J4");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();;
			}
		}

		[Test]
		public void NTextParameterTest ()
		{
			string insert_data = "insert into string_family (id, type_ntext) values (6000, ?)";
			string select_by_id = "select type_ntext from string_family where id = ?";
			string delete_data = "delete from string_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
				Assert.AreEqual ("nt\u092d\u093ext", dr.GetValue (0), "#A3");
				Assert.IsFalse (dr.Read (), "#A4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
				Assert.AreEqual ("nt\u092d\u093ext ", dr.GetValue (0), "#B3");
				Assert.IsFalse (dr.Read (), "#B4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
				Assert.IsFalse (dr.Read (), "#C4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
				Assert.IsFalse (dr.Read (), "#D4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_ntext", OdbcType.NText, 4);
				param.Value = "nt\u0488xt";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
				Assert.AreEqual ("nt\u0488x", dr.GetValue (0), "#E3");
				Assert.IsFalse (dr.Read (), "#E4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_ntext", OdbcType.NText, 15);
				param.Value = "nt\u0488xt ";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
				Assert.AreEqual ("nt\u0488xt ", dr.GetValue (0), "#F3");
				Assert.IsFalse (dr.Read (), "#F4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_ntext", OdbcType.NText, 8);
				param.Value = string.Empty;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (string.Empty, dr.GetValue (0), "#G3");
				Assert.IsFalse (dr.Read (), "#G4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_ntext", OdbcType.NText, 8);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#H3");
				Assert.IsFalse (dr.Read (), "#H4");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void TextParameterTest ()
		{
			string insert_data = "insert into string_family (id, type_text) values (6000, ?)";
			string select_by_id = "select type_text from string_family where id = ?";
			string delete_data = "delete from string_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
				Assert.AreEqual ("text", dr.GetValue (0), "#A3");
				Assert.IsFalse (dr.Read (), "#A4");
				dr.Close ();
				cmd.Dispose ();

				StringBuilder sb = new StringBuilder ();
				for (int i = 0; i < 30; i++)
					sb.Append ("longtext ");

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (sb.ToString (), dr.GetValue (0), "#B3");
				Assert.IsFalse (dr.Read (), "#B4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
				Assert.IsFalse (dr.Read (), "#C4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
				Assert.IsFalse (dr.Read (), "#D4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_text", OdbcType.Text);
				param.Value = sb.ToString ();
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (sb.ToString (), dr.GetValue (0), "#E3");
				Assert.IsFalse (dr.Read (), "#E4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_text", OdbcType.Text, 2);
				param.Value = "text";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
				Assert.AreEqual ("te", dr.GetValue (0), "#F3");
				Assert.IsFalse (dr.Read (), "#F4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_text", OdbcType.Text, 8);
				param.Value = string.Empty;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (string.Empty, dr.GetValue (0), "#G3");
				Assert.IsFalse (dr.Read (), "#G4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_text", OdbcType.Text, 8);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#H3");
				Assert.IsFalse (dr.Read (), "#H4");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void NumericParameterTest ()
		{
			string select_data1 = "select id, type_numeric1 from numeric_family where type_numeric1 = ? and id = ?";
			string select_data2 = "select id, type_numeric2 from numeric_family where type_numeric2 = ? and id = ?";
			string select_by_id = "select id, type_numeric1, type_numeric2 from numeric_family where id = ?";
			string insert_data = "insert into numeric_family (id, type_numeric1, type_numeric2) values (6000, ?, ?)";
			string delete_data = "delete from numeric_family where id = 6000";
			
			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data1;
				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
				param.Value = 1000.00m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#A4");
				Assert.AreEqual (1000m, dr.GetValue (1), "#A5");
				Assert.IsFalse (dr.Read (), "#A6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data1;
				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
				param.Value = -1000.00m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (2, dr.GetValue (0), "#B3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#B4");
				Assert.AreEqual (-1000m, dr.GetValue (1), "#B5");
				Assert.IsFalse (dr.Read (), "#B6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data2;
				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
				param.Value = 4456.432m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (1, dr.GetValue (0), "#C3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#C4");
				Assert.AreEqual (4456.432m, dr.GetValue (1), "#C5");
				Assert.IsFalse (dr.Read (), "#C6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data2;
				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
				param.Value = -4456.432m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (2, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (-4456.432m, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data1;
				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
				param.Value = 0m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (3, dr.GetValue (0), "#E3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#E4");
				Assert.AreEqual (0m, dr.GetValue (1), "#E5");
				Assert.IsFalse (dr.Read (), "#E6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data1;
				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
				param.Value = DBNull.Value;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsFalse (dr.Read (), "#F");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (4, dr.GetValue (0), "#G3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#G4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#G5");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#G6");
				Assert.AreEqual (DBNull.Value, dr.GetValue (2), "#G7");
				Assert.IsFalse (dr.Read (), "#G8");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
				param.Value = -1000.5678m;
				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
				param.Value = -1000.5678m;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data1;
				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
				param.Value = -1000.5678m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsFalse (dr.Read (), "#H");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data1;
				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
				param.Value = -1001;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#I1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#I2");
				Assert.AreEqual (6000, dr.GetValue (0), "#I3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#I4");
				Assert.AreEqual (-1001m, dr.GetValue (1), "#I5");
				Assert.IsFalse (dr.Read (), "#I6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data2;
				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
				param.Value = -1000.5678m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsFalse (dr.Read (), "#J");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data2;
				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
				param.Value = -1000.568m;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#K1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#K2");
				Assert.AreEqual (6000, dr.GetValue (0), "#K3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#K4");
				Assert.AreEqual (-1000.568m, dr.GetValue (1), "#K5");
				Assert.IsFalse (dr.Read (), "#K6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
				param.Value = 56789m;
				param.Precision = 7;
				param.Scale = 2;
				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
				param.Value = 98765.5678m;
				param.Precision = 10;
				param.Scale = 2;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#L1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#L2");
				Assert.AreEqual (6000, dr.GetValue (0), "#L3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#L4");
				Assert.AreEqual (56789m, dr.GetValue (1), "#L5");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#L6");
				if (ConnectionManager.Instance.Odbc.EngineConfig.Type == EngineType.MySQL)
					Assert.AreEqual (9876556.780m, dr.GetValue (2), "#L7");
				else
					Assert.AreEqual (98765.570m, dr.GetValue (2), "#L7");
				Assert.IsFalse (dr.Read (), "#L8");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_numeric1", OdbcType.Numeric);
				param.Value = DBNull.Value;
				param = cmd.Parameters.Add ("type_numeric2", OdbcType.Numeric);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#M1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#M2");
				Assert.AreEqual (6000, dr.GetValue (0), "#M3");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (1), "#M4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#M5");
				Assert.AreEqual (typeof (decimal), dr.GetFieldType (2), "#M6");
				Assert.AreEqual (DBNull.Value, dr.GetValue(1), "#M7");
				Assert.AreEqual (DBNull.Value, dr.GetValue (2), "#M7");
				Assert.IsFalse (dr.Read (), "#M8");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (cmd != null)
					cmd.Dispose ();
				if (dr != null)
					dr.Close ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void NVarCharParameterTest ()
		{
			string insert_data = "insert into string_family (id, type_nvarchar) values (6000, ?)";
			string select_data = "select type_nvarchar from string_family where type_nvarchar = ? and id = ?";
			string select_by_id = "select type_nvarchar from string_family where id = ?";
			string delete_data = "delete from string_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
				param.Value = "nv\u092d\u093e\u0930\u0924r";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
				Assert.AreEqual ("nv\u092d\u093e\u0930\u0924r", dr.GetValue (0), "#A3");
				Assert.IsFalse (dr.Read (), "#A4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
				param.Value = "nv\u092d\u093e\u0930\u0924r ";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
				Assert.AreEqual ("nv\u092d\u093e\u0930\u0924r ", dr.GetValue (0), "#B3");
				Assert.IsFalse (dr.Read (), "#B4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
				param.Value = string.Empty;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
				Assert.IsFalse (dr.Read (), "#C4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
				Assert.IsFalse (dr.Read (), "#D4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
				param.Value = "nvarchar ";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
				param.Value = "nvarchar ";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
				Assert.AreEqual ("nvarchar ", dr.GetValue (0), "#E3");
				Assert.IsFalse (dr.Read (), "#E4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 6);
				param.Value = "nv\u0488rchar";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 6);
				param.Value = "nv\u0488rchar";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
				Assert.AreEqual ("nv\u0488rch", dr.GetValue (0), "#F3");
				Assert.IsFalse (dr.Read (), "#F4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 12);
				param.Value = "nvarch\u0488r ";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 12);
				param.Value = "nvarch\u0488r ";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
				Assert.AreEqual ("nvarch\u0488r ", dr.GetValue (0), "#G3");
				Assert.IsFalse (dr.Read (), "#G4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 12);
				param.Value = string.Empty;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar, 12);
				param.Value = string.Empty;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (string.Empty, dr.GetValue (0), "#H3");
				Assert.IsFalse (dr.Read (), "#H4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.NVarChar);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#I1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#I2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#I3");
				Assert.IsFalse (dr.Read (), "#I4");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (cmd != null)
					cmd.Dispose ();
				if (dr != null)
					dr.Close ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void VarBinaryParameterTest ()
		{
			string insert_data = "insert into binary_family (id, type_varbinary) values (6000, ?)";
			string select_data = "select id, type_varbinary from binary_family where type_varbinary = ? and id = ?";
			string select_by_id = "select id, type_varbinary from binary_family where id = ?";
			string delete_data = "delete from binary_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				byte [] bytes = new byte [] { 0x30, 0x31, 0x32,
					0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
					0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
					0x37, 0x38, 0x39, 0x30, 0x31, 0x32, 0x33,
					0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x00,
					0x44, 0x53};

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
				param.Value = bytes;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#A4");
				Assert.AreEqual (bytes, dr.GetValue (1), "#A5");
				Assert.IsFalse (dr.Read (), "#A6");
				dr.Close ();
				cmd.Dispose ();

				bytes = new byte [] { 0x00, 0x39, 0x38, 0x37,
					0x36, 0x35, 0x00, 0x33, 0x32, 0x31, 0x30,
					0x31, 0x32, 0x33, 0x34 };

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
				param.Value = bytes;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (2, dr.GetValue (0), "#B3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#B4");
				Assert.AreEqual (bytes, dr.GetValue (1), "#B5");
				Assert.IsFalse (dr.Read (), "#B6");
				dr.Close ();
				cmd.Dispose ();

				bytes = new byte [0];

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
				param.Value = bytes;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (3, dr.GetValue (0), "#C3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#C4");
				Assert.AreEqual (bytes, dr.GetValue (1), "#C5");
				Assert.IsFalse (dr.Read (), "#C6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (4, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();

				bytes = new byte [0];

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
				param.Value = bytes;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
				param.Value = bytes;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#E4");
				Assert.AreEqual (bytes, dr.GetValue (1), "#E5");
				Assert.IsFalse (dr.Read (), "#E6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				bytes = new byte [] { 0x05 };

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
				param.Value = bytes;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
				param.Value = bytes;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#F4");
				Assert.AreEqual (bytes, dr.GetValue (1), "#F5");
				Assert.IsFalse (dr.Read (), "#F6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				bytes = new byte [] { 0x34, 0x00, 0x32 };

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
				param.Value = bytes;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
				param.Value = bytes;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#G4");
				Assert.AreEqual (bytes, dr.GetValue (1), "#G5");
				Assert.IsFalse (dr.Read (), "#G6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				bytes = new byte [] { 0x34, 0x00, 0x32, 0x05, 0x07, 0x13 };

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary, 4);
				param.Value = bytes;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary, 4);
				param.Value = bytes;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#H4");
				Assert.AreEqual (new byte [] { 0x34, 0x00, 0x32, 0x05 }, dr.GetValue (1), "#H5");
				Assert.IsFalse (dr.Read (), "#H6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_varbinary", OdbcType.VarBinary);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#I1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#I2");
				Assert.AreEqual (6000, dr.GetValue (0), "#I3");
				Assert.AreEqual (typeof (byte []), dr.GetFieldType (1), "#I4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#I5");
				Assert.IsFalse (dr.Read (), "#I6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void VarCharParameterTest ()
		{
			string insert_data = "insert into string_family (id, type_varchar) values (6000, ?)";
			string select_data = "select type_varchar from string_family where type_varchar = ? and id = ?";
			string select_by_id = "select type_varchar from string_family where id = ?";
			string delete_data = "delete from string_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
				param.Value = "varchar";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#A2");
				Assert.AreEqual ("varchar", dr.GetValue (0), "#A3");
				Assert.IsFalse (dr.Read (), "#A4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
				param.Value = "varchar ";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#B2");
				Assert.AreEqual ("varchar ", dr.GetValue (0), "#B3");
				Assert.IsFalse (dr.Read (), "#B4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
				param.Value = string.Empty;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (string.Empty, dr.GetValue (0), "#C3");
				Assert.IsFalse (dr.Read (), "#C4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
				Assert.IsFalse (dr.Read (), "#D4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar, 30);
				param.Value = "varchar ";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar);
				param.Value = "varchar ";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#E2");
				Assert.AreEqual ("varchar ", dr.GetValue (0), "#E3");
				Assert.IsFalse (dr.Read (), "#E4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar, 3);
				param.Value = "vchar";
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.VarChar, 3);
				param.Value = "vcharxzer";
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#F2");
				Assert.AreEqual ("vch", dr.GetValue (0), "#F3");
				Assert.IsFalse (dr.Read (), "#F4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar, 3);
				param.Value = string.Empty;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_nvarchar", OdbcType.VarChar, 3);
				param.Value = string.Empty;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (string.Empty, dr.GetValue (0), "#G3");
				Assert.IsFalse (dr.Read (), "#G4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_varchar", OdbcType.VarChar, 5);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (string), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#H3");
				Assert.IsFalse (dr.Read (), "#H4");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (cmd != null)
					cmd.Dispose ();
				if (dr != null)
					dr.Close ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void RealParameterTest ()
		{
			string insert_data = "insert into numeric_family (id, type_float) values (6000, ?)";
			string select_data = "select id, type_float from numeric_family where type_float = ? and id = ?";
			string select_by_id = "select id, type_float from numeric_family where id = ?";
			string delete_data = "delete from numeric_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (1, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (3.39999995E+38f, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();


				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
				param.Value = 3.40E+38;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A2");
				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#A3");
				Assert.AreEqual (3.40E+38f, (float)dr.GetValue (1), 0.0000001f, "#A4");
				Assert.IsFalse (dr.Read (), "#A5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
				param.Value = -3.40E+38;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 2;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (2, dr.GetValue (0), "#B2");
				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#B3");
				Assert.AreEqual(-3.40E+38f, (float)dr.GetValue(1), 0.0000001f, "#B4");
				Assert.IsFalse (dr.Read (), "#B5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
				param.Value = 0F;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 3;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (3, dr.GetValue (0), "#C2");
				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#C3");
				Assert.AreEqual (0F, dr.GetValue (1), "#C4");
				Assert.IsFalse (dr.Read (), "#C5");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (4, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
				param.Value = 3.40E+38;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#E1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#E2");
				Assert.AreEqual (6000, dr.GetValue (0), "#E3");
				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#E4");
				Assert.AreEqual(3.40E+38f, (float)dr.GetValue(1), 0.0000001f, "#E4");
				Assert.IsFalse (dr.Read (), "#E6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
				param.Value = -3.40E+38;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#F1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#F2");
				Assert.AreEqual (6000, dr.GetValue (0), "#F3");
				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#F4");
				Assert.AreEqual (-3.40E+38f, (float)dr.GetValue(1), 0.0000001f, "#F4");
				Assert.IsFalse (dr.Read (), "#F6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
				param.Value = 0F;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#G1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#G2");
				Assert.AreEqual (6000, dr.GetValue (0), "#G3");
				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#G4");
				Assert.AreEqual (0F, dr.GetValue (1), "#G5");
				Assert.IsFalse (dr.Read (), "#G6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_float", OdbcType.Real);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#H1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#H2");
				Assert.AreEqual (6000, dr.GetValue (0), "#H3");
				Assert.AreEqual (typeof (float), dr.GetFieldType (1), "#H4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#H5");
				Assert.IsFalse (dr.Read (), "#H6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void SmallDateTimeParameterTest ()
		{
			string insert_data = "insert into datetime_family (id, type_smalldatetime) values (6000, ?)";
			string select_data = "select id, type_smalldatetime from datetime_family where type_smalldatetime = ? and id = ?";
			string select_by_id = "select id, type_smalldatetime from datetime_family where id = ?";
			string delete_data = "delete from datetime_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				DateTime date = DateTime.Parse ("2037-12-31 23:59:00");

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
				param.Value = date;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr.GetValue (0), "#A3");
				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#A4");
				Assert.AreEqual (date, dr.GetValue (1), "#A5");
				Assert.IsFalse (dr.Read (), "#A6");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (4, dr.GetValue (0), "#B3");
				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#B4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#B5");
				Assert.IsFalse (dr.Read (), "#B6");
				dr.Close ();
				cmd.Dispose ();

				date = new DateTime (1973, 8, 13, 17, 55, 00);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
				param.Value = date;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
				param.Value = date;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (6000, dr.GetValue (0), "#C3");
				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#C4");
				Assert.AreEqual (date, dr.GetValue (1), "#C5");
				Assert.IsFalse (dr.Read (), "#C6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_smalldatetime", OdbcType.SmallDateTime);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (6000, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();

				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void DateTimeParameterTest ()
		{
			string insert_data = "insert into datetime_family (id, type_datetime) values (6000, ?)";
			string select_data = "select id, type_datetime from datetime_family where type_datetime = ? and id = ?";
			string select_by_id = "select id, type_datetime from datetime_family where id = ?";
			string delete_data = "delete from datetime_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				DateTime date = DateTime.ParseExact ("9999-12-31 23:59:59",
					"yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
				param.Value = date;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (1, dr [0], "#A3");
				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#A4");
				if (ConnectionManager.Instance.Odbc.EngineConfig.SupportsMicroseconds)
					Assert.AreEqual (date, dr [1], "#A5");
				else
					Assert.AreEqual (new DateTime (9999, 12, 31, 23, 59, 59), dr [1], "#A5");
				Assert.IsFalse (dr.Read (), "#A6");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (4, dr.GetValue (0), "#B3");
				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#B4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#B5");
				Assert.IsFalse (dr.Read (), "#B6");
				dr.Close ();
				cmd.Dispose ();

				date = new DateTime (1973, 8, 13, 17, 54, 34);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
				param.Value = date;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
				param.Value = date;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (6000, dr.GetValue (0), "#C3");
				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#C4");
				Assert.AreEqual (new DateTime (1973, 8, 13, 17, 54, 34), dr.GetValue (1), "#C5");
				Assert.IsFalse (dr.Read (), "#C6");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_datetime", OdbcType.DateTime);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (int), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (6000, dr.GetValue (0), "#D3");
				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (1), "#D4");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D5");
				Assert.IsFalse (dr.Read (), "#D6");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void DateParameterTest ()
		{
			string insert_data = "insert into datetime_family (id, type_date) values (6000, ?)";
			string select_data = "select type_date from datetime_family where type_date = ? and id = 1";
			string select_by_id = "select type_date from datetime_family where id = ?";
			string delete_data = "delete from datetime_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				if (!ConnectionManager.Instance.Odbc.EngineConfig.SupportsDate)
					Assert.Ignore ("Date test does not apply to the current driver (" + conn.Driver + ").");

				DateTime date = new DateTime (9999, 12, 31);

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_date", OdbcType.DateTime);
				param.Value = date;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (date, dr.GetValue (0), "#A3");
				Assert.IsFalse (dr.Read (), "#A4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#B3");
				Assert.IsFalse (dr.Read (), "#B4");
				dr.Close ();
				cmd.Dispose ();

				date = new DateTime (2004, 2, 21, 4, 50, 7);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_date", OdbcType.Date);
				param.Value = date;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (new DateTime (2004, 2, 21), dr.GetValue (0), "#C3");
				Assert.IsFalse (dr.Read (), "#C4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_date", OdbcType.Date);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (DateTime), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
				Assert.IsFalse (dr.Read (), "#D4");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void TimeParameterTest ()
		{
			string insert_data = "insert into datetime_family (id, type_time) values (6000, ?)";
			string select_data = "select type_time from datetime_family where type_time = ? and id = 1";
			string select_by_id = "select type_time from datetime_family where id = ?";
			string delete_data = "delete from datetime_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				if (!ConnectionManager.Instance.Odbc.EngineConfig.SupportsTime)
					Assert.Ignore ("Time test does not apply to the current driver (" + conn.Driver + ").");

				TimeSpan time = ConnectionManager.Instance.Odbc.EngineConfig.SupportsMicroseconds ?
					new TimeSpan (23, 58, 59, 953) : new TimeSpan (23, 58, 59);

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_time", OdbcType.Time);
				param.Value = time;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (typeof (TimeSpan), dr.GetFieldType (0), "#A2");
				Assert.AreEqual (time, dr.GetValue (0), "#A3");
				Assert.IsFalse (dr.Read (), "#A4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (typeof (TimeSpan), dr.GetFieldType (0), "#B2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#B3");
				Assert.IsFalse (dr.Read (), "#B4");
				dr.Close ();
				cmd.Dispose ();

				time = new TimeSpan (23, 56, 43);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_time", OdbcType.Time);
				param.Value = time;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (typeof (TimeSpan), dr.GetFieldType (0), "#C2");
				Assert.AreEqual (time, dr.GetValue (0), "#C3");
				Assert.IsFalse (dr.Read (), "#C4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_time", OdbcType.Date);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (typeof (TimeSpan), dr.GetFieldType (0), "#D2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (0), "#D3");
				Assert.IsFalse (dr.Read (), "#D4");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();
				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void UniqueIdentifierParameterTest ()
		{
			string insert_data = "insert into string_family (id, type_guid) values (6000, ?)";
			string select_data = "select id, type_guid from string_family where type_guid = ? and id = ?";
			string select_by_id = "select id, type_guid from string_family where id = ?";
			string delete_data = "delete from string_family where id = 6000";

			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;

			IDataReader dr = null;
			OdbcCommand cmd = null;
			OdbcParameter param;

			try {
				if (!ConnectionManager.Instance.Odbc.EngineConfig.SupportsUniqueIdentifier)
					Assert.Ignore ("UniqueIdentifier test does not apply to the current driver (" + conn.Driver + ").");

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_guid", OdbcType.UniqueIdentifier);
				param.Value = new Guid ("d222a130-6383-4d36-ac5e-4e6b2591aabf");
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 1;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#A1");
				Assert.AreEqual (1, dr.GetValue (0), "#A2");
				Assert.AreEqual (new Guid ("d222a130-6383-4d36-ac5e-4e6b2591aabf"), dr.GetValue (1), "#A3");
				Assert.IsFalse (dr.Read (), "#A4");
				dr.Close ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 4;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#B1");
				Assert.AreEqual (4, dr.GetValue (0), "#B2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#B3");
				Assert.IsFalse (dr.Read (), "#B4");
				dr.Close ();
				cmd.Dispose ();

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_guid", OdbcType.UniqueIdentifier);
				param.Value = new Guid ("e222a130-6383-4d36-ac5e-4e6b2591aabe");
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_data;
				param = cmd.Parameters.Add ("type_guid", OdbcType.UniqueIdentifier);
				param.Value = new Guid ("e222a130-6383-4d36-ac5e-4e6b2591aabe");
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#C1");
				Assert.AreEqual (6000, dr.GetValue (0), "#C2");
				Assert.AreEqual (new Guid ("e222a130-6383-4d36-ac5e-4e6b2591aabe"), dr.GetValue (1), "#C3");
				Assert.IsFalse (dr.Read (), "#C4");
				dr.Close ();
				cmd.Dispose ();

				DBHelper.ExecuteNonQuery (conn, delete_data);

				cmd = (OdbcCommand) conn.CreateCommand ();
				cmd.CommandText = insert_data;
				param = cmd.Parameters.Add ("type_guid", OdbcType.UniqueIdentifier);
				param.Value = DBNull.Value;
				cmd.ExecuteNonQuery ();
				cmd.Dispose ();

				cmd = conn.CreateCommand ();
				cmd.CommandText = select_by_id;
				param = cmd.Parameters.Add ("id", OdbcType.Int);
				param.Value = 6000;
				dr = cmd.ExecuteReader ();
				Assert.IsTrue (dr.Read (), "#D1");
				Assert.AreEqual (6000, dr.GetValue (0), "#D2");
				Assert.AreEqual (DBNull.Value, dr.GetValue (1), "#D3");
				Assert.IsFalse (dr.Read (), "#D4");
				dr.Close ();
				cmd.Dispose ();
			} finally {
				if (dr != null)
					dr.Close ();
				if (cmd != null)
					cmd.Dispose ();

				conn.Close ();
				conn.Open ();
				DBHelper.ExecuteNonQuery (conn, delete_data);
				conn.Close ();
			}
		}

		[Test]
		public void DBNullParameterTest()
		{
			OdbcConnection conn = ConnectionManager.Instance.Odbc.Connection;
			try
			{
				OdbcDataAdapter Adaptador = new OdbcDataAdapter ();
				DataSet Lector = new DataSet ();

				Adaptador.SelectCommand = new OdbcCommand ("SELECT ?;", (OdbcConnection) conn);
				Adaptador.SelectCommand.Parameters.AddWithValue("@un", DBNull.Value);
				Adaptador.Fill (Lector);
				Assert.AreEqual (Lector.Tables[0].Rows[0][0], DBNull.Value, "#1 DBNull parameter not passed correctly");
			} finally {
				ConnectionManager.Instance.Odbc.CloseConnection ();
			}
		}

		[Test]
		public void ParameterName ()
		{
			OdbcParameter p = new OdbcParameter ();
			p.ParameterName = "foo1";
			Assert.AreEqual ("foo1", p.ParameterName, "#1");
			p.ParameterName = null;
			Assert.AreEqual (string.Empty, p.ParameterName, "#2");
			p.ParameterName = "foo2";
			Assert.AreEqual ("foo2", p.ParameterName, "#3");
			p.ParameterName = string.Empty;
			Assert.AreEqual (string.Empty, p.ParameterName, "#4");
		}

		[Test]
		public void SourceColumn ()
		{
			OdbcParameter p = new OdbcParameter ();
			p.SourceColumn = "foo1";
			Assert.AreEqual ("foo1", p.SourceColumn, "#1");
			p.SourceColumn = null;
			Assert.AreEqual (string.Empty, p.SourceColumn, "#2");
			p.SourceColumn = "foo2";
			Assert.AreEqual ("foo2", p.SourceColumn, "#3");
			p.SourceColumn = string.Empty;
			Assert.AreEqual (string.Empty, p.SourceColumn, "#4");
		}

		[Test]
		public void DefaultValuesTest ()
		{
			OdbcParameter p;

			p = new OdbcParameter();
			Assert.AreEqual (DbType.String, p.DbType, "#A:DbType");
			Assert.AreEqual (ParameterDirection.Input, p.Direction, "#A:Direction");
			Assert.IsFalse (p.IsNullable, "#A:IsNullable");
			Assert.AreEqual (OdbcType.NVarChar, p.OdbcType, "#A:OdbcType");
			Assert.AreEqual (String.Empty, p.ParameterName, "#A:ParameterName");
			Assert.AreEqual (0, p.Precision, "#A:Precision");
			Assert.AreEqual (0, p.Scale, "#A:Scale");
			Assert.AreEqual (0, p.Size, "#A:Size");
			Assert.AreEqual (String.Empty, p.SourceColumn, "#A:SourceColumn");
			Assert.IsFalse (p.SourceColumnNullMapping, "#A:SourceColumnNullMapping");
			Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "#A:SourceVersion");
			Assert.IsNull (p.Value, "#A:Value");

			p = new OdbcParameter(null, 2);
			Assert.AreEqual (DbType.String, p.DbType, "#B:DbType");
			Assert.AreEqual (ParameterDirection.Input, p.Direction, "#B:Direction");
			Assert.IsFalse (p.IsNullable, "#B:IsNullable");
			Assert.AreEqual (OdbcType.NVarChar, p.OdbcType, "#B:OdbcType");
			Assert.AreEqual (String.Empty, p.ParameterName, "#B:ParameterName");
			Assert.AreEqual (0, p.Precision, "#B:Precision");
			Assert.AreEqual (0, p.Scale, "#B:Scale");
			Assert.AreEqual (0, p.Size, "#B:Size");
			Assert.AreEqual (String.Empty, p.SourceColumn, "#B:SourceColumn");
			Assert.IsFalse (p.SourceColumnNullMapping, "#B:SourceColumnNullMapping");
			Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "#B:SourceVersion");
			Assert.AreEqual (2, p.Value, "#B:Value");

			p = new OdbcParameter("foo", 2);
			Assert.AreEqual (DbType.String, p.DbType, "#C:DbType");
			Assert.AreEqual (ParameterDirection.Input, p.Direction, "#C:Direction");
			Assert.IsFalse (p.IsNullable, "#C:IsNullable");
			Assert.AreEqual (OdbcType.NVarChar, p.OdbcType, "#C:OdbcType");
			Assert.AreEqual ("foo", p.ParameterName, "#C:ParameterName");
			Assert.AreEqual (0, p.Precision, "#C:Precision");
			Assert.AreEqual (0, p.Scale, "#C:Scale");
			Assert.AreEqual (0, p.Size, "#C:Size");
			Assert.AreEqual (String.Empty, p.SourceColumn, "#C:SourceColumn");
			Assert.IsFalse (p.SourceColumnNullMapping, "#C:SourceColumnNullMapping");
			Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "#C:SourceVersion");
			Assert.AreEqual (2, p.Value, "#C:Value");

			p = new OdbcParameter("foo1", OdbcType.Int);
			Assert.AreEqual (DbType.Int32, p.DbType, "#D:DbType");
			Assert.AreEqual (ParameterDirection.Input, p.Direction, "#D:Direction");
			Assert.IsFalse (p.IsNullable, "#D:IsNullable");
			Assert.AreEqual (OdbcType.Int, p.OdbcType, "#D:OdbcType");
			Assert.AreEqual ("foo1", p.ParameterName, "#D:ParameterName");
			Assert.AreEqual (0, p.Precision, "#D:Precision");
			Assert.AreEqual (0, p.Scale, "#D:Scale");
			Assert.AreEqual (0, p.Size, "#D:Size");
			Assert.AreEqual (String.Empty, p.SourceColumn, "#D:SourceColumn");
			Assert.IsFalse (p.SourceColumnNullMapping, "#D:SourceColumnNullMapping");
			Assert.AreEqual (DataRowVersion.Current, p.SourceVersion, "#D:SourceVersion");
			Assert.IsNull (p.Value, "#D:Value");
		}
	}
}

#endif