public int inserir(Voos voo)
 {
     OdbcCommand comando;
     int result = 0;
     String comand = "INSERT INTO voo(codigo, data, origem, destino) VALUES(?, ?, ?, ?)";
     OdbcParameter codigo = new OdbcParameter("?", voo.Codigo);
     OdbcParameter data = new OdbcParameter("?", voo.Data);
     OdbcParameter origem = new OdbcParameter("?", voo.Origem);
     OdbcParameter destino = new OdbcParameter("?", voo.Destino);
     try
     {
         comando = new OdbcCommand(comand, conexao);
         comando.Connection.Open();
         comando.Parameters.Add(codigo);
         comando.Parameters.Add(data);
         comando.Parameters.Add(origem);
         comando.Parameters.Add(destino);
         result = comando.ExecuteNonQuery();
     }
     catch (Exception e)
     {
         MessageBox.Show(e.Message);
     }
     finally
     {
         conexao.Close();
     }
     return result;
 }

 public int inserir(Aviao aviao)
 {
     OdbcCommand comando;
     int result = 0;
     String comand = "INSERT INTO aviao(numeroSerie, modelo) VALUES(?, ?)";
     OdbcParameter numeroSerie = new OdbcParameter("?", aviao.NumeroSerie);
     OdbcParameter modelo = new OdbcParameter("?", aviao.Modelo);
     try
     {
         comando = new OdbcCommand(comand, conexao);
         comando.Connection.Open();
         comando.Parameters.Add(numeroSerie);
         comando.Parameters.Add(modelo);
         result = comando.ExecuteNonQuery();
     }
     catch (Exception e)
     {
         MessageBox.Show(e.Message);
     }
     finally
     {
         conexao.Close();
     }
     return result;
 }

        /// <summary>
        /// ����
        /// </summary>
        /// <param name="sql"></param>
        public static int Execute(string sql, string connstr, OdbcParameter[] parameters)
        {
            int n = -1;
            OdbcConnection conn = null;
            try
            {
                conn = GetConnection(connstr);
                OdbcCommand cmd = new OdbcCommand();//sql, conn);
                cmd.CommandText = sql;
                cmd.Connection = conn;
                for (int i = 0; i < parameters.Length; i++)
                {
                    cmd.Parameters.AddWithValue(parameters[i].ParameterName, parameters[i].Value);
                }
                conn.Open();
                n = cmd.ExecuteNonQuery();

            }
            catch (Exception e)
            {
                //MessageBox.Show( sql, "ϵͳ�����������Ա��ϵ", MessageBoxButtons.OK, MessageBoxIcon.Error);
                throw new DatabaseException(sql + "\n" + e.Message);
            }
            finally
            {
                try { conn.Close(); }
                catch { }
            }
            conn = null;
            return n;
        }

 public void add_parameter(long value)
 {
     OdbcParameter param = new OdbcParameter();
     param.DbType = DbType.Int64;
     param.Value = value;
     _parameters.Add(param);
 }

 public int inserir(Cliente cliente)
 {
     OdbcCommand comando;
     int result = 0;
     String comand = "INSERT INTO cliente(nome, cpf, cidade) VALUES(?, ?, ?)";
     OdbcParameter nome = new OdbcParameter("?", cliente.Nome);
     OdbcParameter cpf = new OdbcParameter("?", cliente.Cpf);
     OdbcParameter cidade = new OdbcParameter("?", cliente.Cidade);
     try
     {
         comando = new OdbcCommand(comand, conexao);
         comando.Connection.Open();
         comando.Parameters.Add(nome);
         comando.Parameters.Add(cpf);
         comando.Parameters.Add(cidade);
         result = comando.ExecuteNonQuery();
     }
     catch (Exception e)
     {
         MessageBox.Show(e.Message);
     }
     finally
     {
         conexao.Close();
     }
     return result;
 }

 public int inserir(Aeroportos aeroporto)
 {
     OdbcCommand comando;
     int result = 0;
     String comand = "INSERT INTO aeroporto(nome, cidade, codigo) VALUES(?, ?, ?)";
     OdbcParameter nome = new OdbcParameter("?", aeroporto.Nome);
     OdbcParameter cidade = new OdbcParameter("?", aeroporto.Cidade);
     OdbcParameter codigo = new OdbcParameter("?", aeroporto.Codigo);
     try
     {
         comando = new OdbcCommand(comand, conexao);
         comando.Connection.Open();
         comando.Parameters.Add(nome);
         comando.Parameters.Add(cidade);
         comando.Parameters.Add(codigo);
         result = comando.ExecuteNonQuery();
     }
     catch (Exception e)
     {
         MessageBox.Show(e.Message);
     }
     finally
     {
         conexao.Close();
     }
     return result;
 }

        /// <summary>
        /// Sobrescreve o metodo de Paramatro Retorno,adiciona o parametro de "@RETURN_VALUE".
        /// </summary>
        /// <returns>Retorna uma colecao de parametros com o parametro "@RETURN_VALUE" </returns>
        internal override IDataParameter GetParametroRetorno()
        {
            OdbcParameter p = new OdbcParameter("@RETURN_VALUE",OdbcType.Int);
            p.Direction = ParameterDirection.ReturnValue;

            return p;
        }

 public int inserir(Reservas reserva)
 {
     OdbcCommand comando;
     int result = 0;
     String comand = "INSERT INTO reserva(voo, assento, cpf_cliente) VALUES(?, ?, ?)";
     OdbcParameter voo = new OdbcParameter("?", reserva.Voo);
     OdbcParameter assento = new OdbcParameter("?", reserva.Assento);
     OdbcParameter cpf = new OdbcParameter("?", reserva.Cpf_cliente);
     try
     {
         comando = new OdbcCommand(comand, conexao);
         comando.Connection.Open();
         comando.Parameters.Add(voo);
         comando.Parameters.Add(assento);
         comando.Parameters.Add(cpf);
         result = comando.ExecuteNonQuery();
     }
     catch (Exception e)
     {
         MessageBox.Show(e.Message);
     }
     finally
     {
         conexao.Close();
     }
     return result;
 }

 /// <summary>
 ///  ��ȡһ���²�������
 /// </summary>
 /// <param name="paraName">������</param>
 /// <param name="dbType">������������</param>
 /// <param name="size">������С</param>
 /// <returns>�ض�������Դ�IJ�������</returns>
 public override IDataParameter GetParameter(string paraName,System.Data.DbType dbType,int size)
 {
     OdbcParameter para=new OdbcParameter();
     para.ParameterName=paraName;
     para.DbType=dbType;
     para.Size=size;
     return para;
 }

 private OdbcParameter(OdbcParameter source) : this()
 {
     ADP.CheckArgumentNull(source, "source");
     source.CloneHelper(this);
     ICloneable cloneable = this._value as ICloneable;
     if (cloneable != null)
     {
         this._value = cloneable.Clone();
     }
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="name"></param>
 /// <param name="dbType"></param>
 /// <returns></returns>
 public override DbParameter CreateParameter(string name, Enum dbType, byte? precision, byte? scale)
 {
     if (dbType is OdbcType)
     {
         var p = new OdbcParameter(name, (OdbcType)dbType);
         if (precision.HasValue == true) p.Precision = precision.Value;
         if (scale.HasValue == true) p.Scale = scale.Value;
         return p;
     }
     throw new ArgumentException("dbType must be OdbcType.");
 }

        public DbParameter MakeParam(string ParamName, DbType DbType, Int32 Size)
        {
            OdbcParameter param;

            if (Size > 0)
                param = new OdbcParameter(ParamName, (OdbcType)DbType, Size);
            else
                param = new OdbcParameter(ParamName, (OdbcType)DbType);

            return param;
        }

 protected void AddParameter(string key, string val, int value)
 {
     if (lstDbParameters == null)
     {
         lstDbParameters = new List<DbParameter>();
     }
     OdbcParameter oParam = new OdbcParameter();
     oParam.ParameterName = key;
     oParam.Value = val;
     lstDbParameters.Add(oParam);
 }

 public override DbParameter CréerDBParameter()
 {
     if (this.options.ConnexionODBC == true)
     {
         OdbcParameter param = new OdbcParameter();
         return param;
     }
     else
     {
         SqlParameter param = new SqlParameter();
         return param;
     }
 }

        private static IDbDataParameter ConvertToNativeParameter(DbParameter dbParameter)
        {
            IDbDataParameter clone = new OdbcParameter();
            ((OdbcParameter)clone).IsNullable = dbParameter.IsNullable;
            clone.ParameterName = parameterRenderer.RenderParameterName(dbParameter);

            clone.DbType = dbParameter.DbType;
            clone.Direction = dbParameter.Direction;
            clone.Precision = dbParameter.Precision;
            clone.Scale = dbParameter.Scale;
            clone.Size = dbParameter.Size;
            clone.SourceColumn = dbParameter.SourceColumn;
            clone.SourceVersion = dbParameter.SourceVersion;
            clone.Value = dbParameter.Value;

            return clone;
        }

    public bool InsertReport()
    {
        bool result = false;

        using (OdbcConnection connection = new OdbcConnection(connectionString))
        {
            using (OdbcCommand command = new OdbcCommand())
            {

                command.Connection = connection;
                command.CommandText = "{CALL Report_insert(?,?,?,?,?)}";
                command.CommandType = CommandType.StoredProcedure;

                OdbcParameter paramColModel = new OdbcParameter("@ColModel", OdbcType.VarChar, 5000);
                paramColModel.Value = this.ColModel;
                command.Parameters.Add(paramColModel);

                OdbcParameter paramColNames = new OdbcParameter("@ColNames", OdbcType.VarChar, 500);
                paramColNames.Value = this.ColNames;
                command.Parameters.Add(paramColNames);

                OdbcParameter paramCurrentData = new OdbcParameter("@CurrentData", OdbcType.VarChar, 5000);
                paramCurrentData.Value = this.ReportName;
                command.Parameters.Add(paramCurrentData);

                OdbcParameter paramReportName = new OdbcParameter("@ReportName", OdbcType.VarChar, 200);
                paramReportName.Value = this.ReportName;
                command.Parameters.Add(paramReportName);

                OdbcParameter paramTableName = new OdbcParameter("@TableName", OdbcType.VarChar, 50);
                paramTableName.Value = this.TableName;
                command.Parameters.Add(paramTableName);

                connection.Open();
                int n = command.ExecuteNonQuery();
                if (n == 1)
                    result = true;
                else
                    result = false;
            }
        }

        return result;
    }

		public void InsertTest ()
		{
			OdbcConnection conn = (OdbcConnection) ConnectionManager.Singleton.Connection;
			ConnectionManager.Singleton.OpenConnection ();

			try {
				OdbcCommand OdbcCmd = conn.CreateCommand ();
				OdbcCmd.CommandType = CommandType.Text;
				OdbcCmd.CommandText = "SELECT fname FROM employee WHERE lname=? AND age=?";

				/*OdbcParameter p1Lname = */OdbcCmd.Parameters.Add ("@lname", OdbcType.Text, 15);
				OdbcParameter p2Age = new OdbcParameter (); //not initialized and not yet added
				OdbcParameter p3Tmp = new OdbcParameter ("p3", "abc"); //not added

				Assert.AreEqual (1, OdbcCmd.Parameters.Count, "#1 Initialization error, the collection does not contain desired no. of parameters");
				OdbcCmd.Parameters.Insert (1, p2Age); //Inserting the second parameter
				Assert.AreEqual (2, OdbcCmd.Parameters.Count, "#2 The collection should contain 2 parameters");
				
				//inserting at upper boundary
				OdbcCmd.Parameters.Insert (OdbcCmd.Parameters.Count, p3Tmp); //Inserting the third parameter, with name and value at index = count
				Assert.AreEqual (3, OdbcCmd.Parameters.Count, "#3 The collection should contain 2 parameters");

				//check the inserted positions
				Assert.AreEqual (0, OdbcCmd.Parameters.IndexOf ("@lname"), "#4 The first parameter must be at index 0");
				Assert.AreEqual (1, OdbcCmd.Parameters.IndexOf (p2Age), "#5 The inserted parameter p2Age must be at index 1");
				Assert.AreEqual (2, OdbcCmd.Parameters.IndexOf (p3Tmp), "#6 The inserted parameter p3Tmp must be at index 2");
				Assert.AreEqual (2, OdbcCmd.Parameters.IndexOf ("p3"), "#7 The inserted parameter p3 must be at index 2");
				Assert.AreEqual (-1, OdbcCmd.Parameters.IndexOf ("non-existing-parameter"), "#8 Non-existing parameters should return -1");
				
				//check for default names and default values
				Assert.AreEqual ("Parameter1", OdbcCmd.Parameters[1].ParameterName, "#9 Parameters inserted without any name must get a default name");
				Assert.AreEqual (null, OdbcCmd.Parameters[1].Value, "#10 Parameters inserted without any value must have null value");
				
				Assert.AreEqual ("p3", OdbcCmd.Parameters[2].ParameterName, "#11 Parameters inserted without any name must get a default name");
				Assert.AreEqual ("abc", OdbcCmd.Parameters[2].Value, "#12 Parameters inserted without any value must have null value");
				
				Assert.AreEqual (OdbcType.NVarChar,OdbcCmd.Parameters[1].OdbcType, "#13 Parameters with null value must be of type NVarChar");
				Assert.AreEqual (OdbcType.Text,OdbcCmd.Parameters[0].OdbcType, "#14 Parameter at index 0 is of type Text");
			} finally {
				ConnectionManager.Singleton.CloseConnection ();
			}
		}

                public void OdbcTypeTest ()
                {
			OdbcParameter param = new OdbcParameter ();
			Assert.AreEqual (OdbcType.NVarChar, param.OdbcType, "#1");

			// change test
			param.OdbcType = OdbcType.Int;
			Assert.AreEqual (OdbcType.Int, param.OdbcType, "#2");

			param = new OdbcParameter ("test", 10);
			Assert.AreEqual (OdbcType.Int, param.OdbcType, "#3");
			param.OdbcType = OdbcType.Real;
			Assert.AreEqual (OdbcType.Real, param.OdbcType, "#4");
			Assert.AreEqual (10, param.Value, "#5");

			param = new OdbcParameter ("test", OdbcType.NText);
			Assert.AreEqual (null, param.Value, "#6");
			Assert.AreEqual (OdbcType.NText, param.OdbcType, "#7");

			param = new OdbcParameter ("test", OdbcType.Binary);
			Assert.AreEqual (null, param.Value, "#8");
			Assert.AreEqual (OdbcType.Binary, param.OdbcType, "#9");
                }

        public static void Test_Various_DataTypes2()
        {

            TestCases.ExecuteSQL("drop table if exists t", conn);

            string sql = "create table t(";
            sql += "c_integer_ai integer AUTO_INCREMENT, "; //1
            sql += "c_smallint smallint, "; //2
            sql += "c_integer integer, "; //3
            sql += "c_bigint bigint, "; //4
            sql += "c_numeric numeric(15,1), "; //5
            sql += "c_float float, ";//6
            sql += "c_decimal decimal(15,3), ";//7
            sql += "c_double double, ";//8
            sql += "c_char char, ";//9
            sql += "c_varchar varchar(4096), ";//10
            sql += "c_time time, ";//11
            sql += "c_date date, ";//12
            sql += "c_timestamp timestamp, ";//13
            sql += "c_datetime datetime, ";//14
            sql += "c_bit bit(1), ";//15
            sql += "c_varbit bit varying(4096), ";//16
            sql += "c_monetary monetary, ";//17
            sql += "c_string string";//18
            sql += ")";
            TestCases.ExecuteSQL(sql, conn);

            using (OdbcCommand cmd = new OdbcCommand(null, conn))
            {
                sql = "insert into t values(?, ?, ?, ?, ?, ?,";
                sql += "?, ?, ?, ?, ?, ?,";
                sql += "?, ?, ?, ?, ?, ?";
                sql += ")";

                OdbcParameter p1 = new OdbcParameter("?p1", OdbcType.Int);
                p1.Value = 1;
                cmd.Parameters.Add(p1);

                OdbcParameter p2 = new OdbcParameter("?p2", OdbcType.SmallInt);
                p2.Value = 11;
                cmd.Parameters.Add(p2);

                OdbcParameter p3 = new OdbcParameter("?p3", OdbcType.Int);
                p3.Value = 111;
                cmd.Parameters.Add(p3);

                OdbcParameter p4 = new OdbcParameter("?p4", OdbcType.BigInt);
                p4.Value = 1111;
                cmd.Parameters.Add(p4);

                OdbcParameter p5 = new OdbcParameter("?p5", OdbcType.Numeric);
                p5.Value = 1.1;
                cmd.Parameters.Add(p5);

                OdbcParameter p6 = new OdbcParameter("?p6", OdbcType.Double);
                p6.Value = 1.11;
                cmd.Parameters.Add(p6);

                OdbcParameter p7 = new OdbcParameter("?p7", OdbcType.Decimal);
                p7.Value = 1.111;
                cmd.Parameters.Add(p7);

                OdbcParameter p8 = new OdbcParameter("?p8", OdbcType.Double);
                p8.Value = 1.1111;
                cmd.Parameters.Add(p8);

                OdbcParameter p9 = new OdbcParameter("?p9", OdbcType.Char);
                p9.Value = 'a';
                cmd.Parameters.Add(p9);

                OdbcParameter p10 = new OdbcParameter("?p10", OdbcType.VarChar);
                p10.Value = "abcdfghijk";
                cmd.Parameters.Add(p10);

                cmd.CommandText = sql;

                cmd.ExecuteNonQuery();
            }

            sql = "select * from t";
            using (OdbcCommand cmd = new OdbcCommand(sql, conn))
            {
                OdbcDataReader reader = cmd.ExecuteReader();
                while (reader.Read()) //only one row will be available
                {
                    Assert.IsTrue(reader.GetInt32(0) == 1);
                    Assert.IsTrue(reader.GetInt16(1) == 11);
                    Assert.IsTrue(reader.GetInt32(2) == 111);
                    Assert.IsTrue(reader.GetInt64(3) == 1111);
                    Assert.IsTrue(reader.GetDecimal(4) == (decimal)1.1);
                    Assert.IsTrue(reader.GetFloat(5) == (float)1.11); //"Single"
                    Assert.IsTrue(reader.GetDecimal(6) == (decimal)1.111);
                    Assert.IsTrue(reader.GetDouble(7) == (double)1.1111);
                    Assert.IsTrue(reader.GetString(8) == "a"); //"String" ("Char" in CUBRID)

                    Assert.IsTrue(reader.GetString(9) == "abcdfghijk"); //"String" ("String in CUBRID)
                }
            }

            TestCases.ExecuteSQL("drop table if exists t", conn);
//.........这里部分代码省略.........

 public override OdbcCommand GetOdbcCommand(string cmdsql, OdbcParameter[] paras)
 {
     OdbcCommand cmd = new OdbcCommand(cmdsql, mysqlconn);
     if (paras != null)
         for (int i = 0; i < paras.Length; i++)
         {
             cmd.Parameters.Add(paras[i]);
         }
     return cmd;
 }