C# CUBRIDConnection.BeginTransaction方法代码示例

    /// <summary>
    /// Test CUBRIDTransaction class
    /// </summary>
    private static void Test_Transaction()
    {
      using (CUBRIDConnection conn = new CUBRIDConnection())
      {
        conn.ConnectionString = TestCases.connString;
        conn.Open();

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

        conn.BeginTransaction();

        string sql = "create table t(idx integer)";
        using (CUBRIDCommand command = new CUBRIDCommand(sql, conn))
        {
          command.ExecuteNonQuery();
        }

        int tablesCount = GetTablesCount("t", conn);
        Debug.Assert(tablesCount == 1);

        conn.Rollback();

        //Verify the table does not exist
        tablesCount = GetTablesCount("t", conn);
        Debug.Assert(tablesCount == 0);

        conn.BeginTransaction();

        sql = "create table t(idx integer)";
        using (CUBRIDCommand command = new CUBRIDCommand(sql, conn))
        {
          command.ExecuteNonQuery();
        }

        tablesCount = GetTablesCount("t", conn);
        Debug.Assert(tablesCount == 1);

        conn.Commit();

        tablesCount = GetTablesCount("t", conn);
        Debug.Assert(tablesCount == 1);

        conn.BeginTransaction();

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

        conn.Commit();

        tablesCount = GetTablesCount("t", conn);
        Debug.Assert(tablesCount == 0);
      }
    }

    /// <summary>
    /// Test CUBRIDTransaction class, using parameters
    /// </summary>
    private static void Test_Transaction_Parameters()
    {
      DbTransaction tran = null;

      using (CUBRIDConnection conn = new CUBRIDConnection())
      {
        conn.ConnectionString = TestCases.connString;
        conn.Open();

        CreateTestTable(conn);

        tran = conn.BeginTransaction();

        string sql = "insert into t values(?, ?, ?, ?, ?, ?)";
        using (CUBRIDCommand cmd = new CUBRIDCommand(sql, conn))
        {
          CUBRIDParameter p1 = new CUBRIDParameter("?p1", CUBRIDDataType.CCI_U_TYPE_INT);
          p1.Value = 1;
          cmd.Parameters.Add(p1);

          CUBRIDParameter p2 = new CUBRIDParameter("?p2", CUBRIDDataType.CCI_U_TYPE_CHAR);
          p2.Value = 'A';
          cmd.Parameters.Add(p2);

          CUBRIDParameter p3 = new CUBRIDParameter("?p3", CUBRIDDataType.CCI_U_TYPE_STRING);
          p3.Value = "cubrid";
          cmd.Parameters.Add(p3);

          CUBRIDParameter p4 = new CUBRIDParameter("?p4", CUBRIDDataType.CCI_U_TYPE_FLOAT);
          p4.Value = 1.1f;
          cmd.Parameters.Add(p4);

          CUBRIDParameter p5 = new CUBRIDParameter("?p5", CUBRIDDataType.CCI_U_TYPE_DOUBLE);
          p5.Value = 2.2d;
          cmd.Parameters.Add(p5);

          CUBRIDParameter p6 = new CUBRIDParameter("?p6", CUBRIDDataType.CCI_U_TYPE_DATE);
          p6.Value = DateTime.Now;
          cmd.Parameters.Add(p6);

          cmd.ExecuteNonQuery();

          tran.Commit();
        }

        Debug.Assert(GetTableRowsCount("t", conn) == 1);

        CleanupTestTable(conn);
      }
    }

    /// <summary>
    /// Test CUBRID Isolation Levels
    /// </summary>
    private static void Test_IsolationLevel()
    {
      string sqlTablesCount = "select count(*) from db_class";
      int tablesCount, newTableCount;

      using (CUBRIDConnection conn = new CUBRIDConnection())
      {
        conn.ConnectionString = TestCases.connString;
        conn.Open();

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

        conn.SetIsolationLevel(CUBRIDIsolationLevel.TRAN_REP_READ);
        Debug.Assert(conn.GetIsolationLevel() == CUBRIDIsolationLevel.TRAN_REP_READ);

        tablesCount = (int)TestCases.GetSingleValue(sqlTablesCount, conn);
        TestCases.ExecuteSQL("create table isol(id int)", conn);
        newTableCount = (int)TestCases.GetSingleValue(sqlTablesCount, conn);
        //Verify table was created
        Debug.Assert(newTableCount == tablesCount + 1);

        using (CUBRIDConnection connOut = new CUBRIDConnection())
        {
          connOut.ConnectionString = TestCases.connString;
          connOut.Open();

          newTableCount = (int)TestCases.GetSingleValue(sqlTablesCount, connOut);
          //CREATE TABLE is visible from another connection
          Debug.Assert(newTableCount == tablesCount + 1);
        }

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

      using (CUBRIDConnection conn = new CUBRIDConnection())
      {
        conn.ConnectionString = TestCases.connString;
        conn.Open();

        conn.SetIsolationLevel(CUBRIDIsolationLevel.TRAN_REP_CLASS_COMMIT_INSTANCE);
        Debug.Assert(conn.GetIsolationLevel() == CUBRIDIsolationLevel.TRAN_REP_CLASS_COMMIT_INSTANCE);

        tablesCount = (int)TestCases.GetSingleValue(sqlTablesCount, conn);
        conn.BeginTransaction();
        TestCases.ExecuteSQL("create table isol(id int)", conn);
        newTableCount = (int)TestCases.GetSingleValue(sqlTablesCount, conn);
        //Verify table was created
        Debug.Assert(newTableCount == tablesCount + 1);

        using (CUBRIDConnection connOut = new CUBRIDConnection())
        {
          connOut.ConnectionString = TestCases.connString;
          connOut.Open();
          newTableCount = (int)TestCases.GetSingleValue(sqlTablesCount, connOut);
          Debug.Assert(newTableCount == tablesCount + 1);
        }

        conn.Commit();

        newTableCount = (int)TestCases.GetSingleValue(sqlTablesCount, conn);
        //Verify table was created
        Debug.Assert(newTableCount == tablesCount + 1);

        TestCases.ExecuteSQL("drop table if exists isol", conn);
        newTableCount = (int)TestCases.GetSingleValue(sqlTablesCount, conn);
        Debug.Assert(newTableCount == tablesCount);
      }
    }

    /// <summary>
    /// Test BLOB INSERT in a transaction
    /// </summary>
    private static void Test_Blob_InsertTransaction()
    {
      DbTransaction tran = null;
      using (CUBRIDConnection conn = new CUBRIDConnection())
      {
        conn.ConnectionString = TestCases.connString;
        conn.Open();

        CreateTestTableLOB(conn);

        tran = conn.BeginTransaction(IsolationLevel.ReadUncommitted);
        string sql = "insert into t (b) values(?)";
        using (CUBRIDCommand cmd = new CUBRIDCommand(sql, conn))
        {
          CUBRIDBlob Blob = new CUBRIDBlob(conn);

          byte[] bytes = new byte[256];
          bytes[0] = 69;
          bytes[1] = 98;
          bytes[2] = 99;
          bytes[255] = 122;

          Blob.SetBytes(1, bytes);

          CUBRIDParameter param = new CUBRIDParameter();
          param.ParameterName = "?";
          param.CUBRIDDataType = CUBRIDDataType.CCI_U_TYPE_BLOB;
          param.Value = Blob;
          cmd.Parameters.Add(param);
          cmd.Parameters[0].DbType = DbType.Binary;
          cmd.ExecuteNonQuery();
        }

        tran.Rollback();
      }

      //We have to close and reopen connection. Otherwise we get an invalid buffer position.
      using (CUBRIDConnection conn = new CUBRIDConnection())
      {
        conn.ConnectionString = TestCases.connString;
        conn.Open();
        string sql2 = "SELECT b from t";
        using (CUBRIDCommand cmd2 = new CUBRIDCommand(sql2, conn))
        {
          DbDataReader reader = cmd2.ExecuteReader();
          Debug.Assert(reader.HasRows == false, "Transaction did not rollback!");
        }

        CleanupTestTableLOB(conn);
      }
    }

    /// <summary>
    /// Test BLOB DELETE in a transaction
    /// </summary>
    private static void Test_Blob_DeleteTransaction()
    {
      DbTransaction tran = null;
      byte[] bytes1 = new byte[256];

      using (CUBRIDConnection conn = new CUBRIDConnection())
      {
        conn.ConnectionString = TestCases.connString;
        conn.Open();

        CreateTestTableLOB(conn);

        string sql1 = "insert into t (b) values(?)";
        using (CUBRIDCommand cmd1 = new CUBRIDCommand(sql1, conn))
        {
          CUBRIDBlob Blob = new CUBRIDBlob(conn);

          bytes1[0] = 69;
          bytes1[1] = 98;
          bytes1[2] = 99;
          bytes1[255] = 122;

          Blob.SetBytes(1, bytes1);

          CUBRIDParameter param = new CUBRIDParameter();
          param.ParameterName = "?";
          param.CUBRIDDataType = CUBRIDDataType.CCI_U_TYPE_BLOB;
          param.Value = Blob;
          cmd1.Parameters.Add(param);
          cmd1.Parameters[0].DbType = DbType.Binary;
          cmd1.ExecuteNonQuery();
          cmd1.Close();

          tran = conn.BeginTransaction(IsolationLevel.ReadUncommitted);
          string sql2 = "DELETE from t";
          CUBRIDCommand cmd2 = new CUBRIDCommand(sql2, conn);
          cmd2.ExecuteNonQuery();
        }

        tran.Rollback();
      }

      //We have to close and reopen connection. Otherwise we get an invalid buffer position.
      using (CUBRIDConnection conn = new CUBRIDConnection())
      {
        conn.ConnectionString = TestCases.connString;
        conn.Open();

        string sql = "SELECT b from t";
        using (CUBRIDCommand cmd = new CUBRIDCommand(sql, conn))
        {
          DbDataReader reader = cmd.ExecuteReader();
          while (reader.Read())
          {
            Debug.Assert(reader.HasRows == true);

            CUBRIDBlob bImage = (CUBRIDBlob)reader[0];
            byte[] bytes = new byte[(int)bImage.BlobLength];
            bytes = bImage.GetBytes(1, (int)bImage.BlobLength);

            Debug.Assert(bytes1.Length == bytes.Length);

            bool ok = true;
            for (int i = 0; i < bytes.Length; i++)
            {
              if (bytes1[i] != bytes[i])
                ok = false;
            }

            Debug.Assert(ok == true, "The BLOB DELETE command was not rolled-back correctly!");
          }
        }

        CleanupTestTableLOB(conn);
      }
    }

        public void Transaction_Test()
        {
            using (CUBRIDConnection conn = new CUBRIDConnection())
            {
                conn.ConnectionString = DBHelper.connString;
                conn.Open();

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

                LogTestStep("Begin a transaction, then rollback");
                conn.BeginTransaction();
                DBHelper.ExecuteSQL("create table t(idx integer)", conn);
                int tablesCount = DBHelper.GetTablesCount("t", conn);
                Assert.AreEqual(1, tablesCount);

                conn.Rollback();
                //Verify the table does not exist
                tablesCount = DBHelper.GetTablesCount("t", conn);
                Assert.AreEqual(0, tablesCount);
                LogStepPass();

                LogTestStep("Begin a transaction, then commit, then rollback");
                conn.BeginTransaction();
                DBHelper.ExecuteSQL("create table t(idx integer)", conn);
                tablesCount = DBHelper.GetTablesCount("t", conn);
                Assert.AreEqual(1, tablesCount);

                conn.Commit();
                tablesCount = DBHelper.GetTablesCount("t", conn);
                Assert.AreEqual(1, tablesCount);

                conn.Rollback();
                tablesCount = DBHelper.GetTablesCount("t", conn);
                Assert.AreEqual(1, tablesCount);

                LogStepPass();
                Console.WriteLine();
                //revert the test db                
                DBHelper.ExecuteSQL("drop table t", conn);
                conn.Commit();

                LogTestResult();
            }
        }

        public void APIS_485()
        {
            LogTestStep("Test the lockTimeout is set successfully");
            CUBRIDConnection conn = new CUBRIDConnection();
            conn.ConnectionString = DBHelper.connString;
            Assert.AreEqual(-1, conn.LockTimeout);
            
            conn.Open();
            int timeout = 20;
            conn.SetLockTimeout(timeout);
            Assert.AreEqual(timeout, conn.LockTimeout);

            DBHelper.ExecuteSQL("drop table if exists t", conn);
            DBHelper.ExecuteSQL("create table t(id integer)", conn);
            DBHelper.ExecuteSQL("insert into t values (1)", conn);

            conn.SetAutoCommit(false);
            CUBRIDConnection conn2 = null;
            double elapseTime = 0;
            var stopwatch = new Stopwatch();
            try
            {
                Thread thread2 = new Thread(delegate()
                {
                    conn2 = new CUBRIDConnection();
                    conn2.ConnectionString = DBHelper.connString;
                    conn2.Open();
                    conn2.SetAutoCommit(false);

                    conn2.BeginTransaction();
                    DBHelper.ExecuteSQL("update t set id=2", conn2);
                });
                conn.BeginTransaction();
                thread2.Start();
                Thread.Sleep(5000);

                stopwatch.Start();
                DBHelper.ExecuteSQL("update t set id=3", conn);
                thread2.Join();
            }
            catch (Exception ex)
            {
                stopwatch.Stop();
                elapseTime = (double)stopwatch.ElapsedMilliseconds / 1000;
                double diffTime = elapseTime - (double)(timeout / 1000);
                Console.WriteLine("different time = " + stopwatch.ElapsedMilliseconds);
                Console.WriteLine("different time = " + diffTime);
                Log(ex.Message);
                Assert.AreEqual(timeout, conn.LockTimeout);

                if (diffTime >= 0 && diffTime < 10)
                {
                    LogStepPass();
                }
                else
                {
                    LogStepFail();
                }
            }
            finally
            {
                LogTestResult();
                //DBHelper.ExecuteSQL("drop table t", conn);
                conn.Close();
                conn2.Close();
            }
        }

    public static void Test_BeginDbTransaction()
    {
        try
        {
            conn.SetConnectionTimeout(30);
        }
        catch (Exception e)
        {
            Debug.Assert(e.ToString() == "Not allowed to change the 'ConnectionTimeout'");
        }
        using (CUBRIDConnection conn = new CUBRIDConnection())
        {
            conn.ConnectionString = TestCases.connString;
            conn.Open();

            string source = conn.DataSource;
            TestCases.ExecuteSQL("drop table if exists t", conn);

            conn.BeginTransaction();

            string sql = "create table t(idx integer)";
            using (CUBRIDCommand command = new CUBRIDCommand(sql, conn))
            {
                command.ExecuteNonQuery();
            }

            int tablesCount = GetTablesCount("t", conn);
            Debug.Assert(tablesCount == 1);

            conn.Rollback();

            //Verify the table does not exist
            tablesCount = GetTablesCount("t", conn);
            Debug.Assert(tablesCount == 0);

            conn.BeginTransaction();

            sql = "create table t(idx integer)";
            using (CUBRIDCommand command = new CUBRIDCommand(sql, conn))
            {
                command.ExecuteNonQuery();
            }

            tablesCount = GetTablesCount("t", conn);
            Debug.Assert(tablesCount == 1);

            conn.Commit();

            tablesCount = GetTablesCount("t", conn);
            Debug.Assert(tablesCount == 1);

            conn.BeginTransaction();

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

            conn.Commit();

            tablesCount = GetTablesCount("t", conn);
            Debug.Assert(tablesCount == 0);


            //IsolationLevel.Chaos
            try
            {
                conn.BeginTransaction(IsolationLevel.Chaos);
            }
            catch (Exception e)
            {
                Debug.Assert(e.Message == "Not supported in CUBRID!");
            }


            //IsolationLevel.ReadCommitted
            conn.BeginTransaction(IsolationLevel.ReadCommitted);
            sql = "create table t(idx integer)";
            using (CUBRIDCommand command = new CUBRIDCommand(sql, conn))
            {
                command.ExecuteNonQuery();
            }

            tablesCount = GetTablesCount("t", conn);
            Debug.Assert(tablesCount == 1);

            conn.Commit();

            tablesCount = GetTablesCount("t", conn);
            Debug.Assert(tablesCount == 1);

            conn.BeginTransaction();

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

            conn.Commit();

            tablesCount = GetTablesCount("t", conn);
            Debug.Assert(tablesCount == 0);


            //IsolationLevel.RepeatableRead
            conn.BeginTransaction(IsolationLevel.RepeatableRead);
//.........这里部分代码省略.........

        public void Close_Test()
        {
            using (CUBRIDConnection conn = new CUBRIDConnection())
            {
                LogTestStep("Close DB before connected");
                try
                {
                    conn.ConnectionString = DBHelper.connString;
                    conn.Close();
                }
                catch (Exception ex)
                {
                    Assert.AreEqual("The connection is not open!", ex.Message);
                    LogStepPass();
                }

                LogTestStep("Close a valid DB Connection, and check: (1)the connection is closed (2)the transaction which is not committed is rolled back");
                Log("Connect to a DB");
                conn.Open();

                Log("Verify the Connection is OK by feching some data");
                Assert.IsTrue(DBHelper.GetTableRowsCount("db_class", conn) > 0);

                Log("Update the DB in a transaction, and close the connection before commit");
                DBHelper.ExecuteSQL("drop table if exists t", conn);

                conn.BeginTransaction();
                DBHelper.ExecuteSQL("create table t(idx integer)", conn);
                int tablesCount = DBHelper.GetTablesCount("t", conn);
                Assert.AreEqual(1, tablesCount);

                conn.Close();

                Log("Verify the Connection is closed by feching some data");
                try
                {
                    int count = DBHelper.GetTableRowsCount("db_class", conn);
                }
                catch (Exception ex)
                {
                    Assert.AreEqual("The connection is not open!", ex.Message);
                }

                Log("Verify the transaction is rolled back");
                conn.Open();
                tablesCount = DBHelper.GetTablesCount("t", conn);
                Assert.AreEqual(0, tablesCount);
                LogStepPass();
                conn.Close();

                LogTestStep("Close a valid DB Connection twice, check no exception is generated");
                conn.Close();
                LogStepPass();
                LogTestResult();
            }
        }

        public void CUBRIDTransaction_CUBRIDIsolationLevel_Test()
        {
            LogTestStep("Test CUBRIDTransaction.CUBRIDConnection");
            CUBRIDConnection conn = new CUBRIDConnection(DBHelper.connString);
            conn.Open();

            CUBRIDTransaction transaction = conn.BeginTransaction(CUBRIDIsolationLevel.TRAN_DEFAULT_ISOLATION);
            Console.WriteLine(transaction.CUBRIDIsolationLevel);

            Assert.AreEqual(CUBRIDIsolationLevel.TRAN_DEFAULT_ISOLATION, transaction.CUBRIDIsolationLevel);
            LogStepPass();


            LogTestResult();
        }

        public void CUBRIDTransaction_CUBRIDConnection_Test()
        {
            LogTestStep("Test CUBRIDTransaction.CUBRIDConnection");
            CUBRIDConnection conn = new CUBRIDConnection(DBHelper.connString);
            conn.Open();

            CUBRIDTransaction transaction = conn.BeginTransaction();
            transaction.Connection.Close();

            try
            {
                DBHelper.ExecuteSQL("drop table if exists t", conn);
                LogStepFail();
            }
            catch(Exception ex)
            {
                Assert.AreEqual("The connection is not open!", ex.Message);
                LogStepPass();
            }
            
            LogTestResult();
        }

        public void CUBRIDTransaction_Commit_Rollback_Negtive2_Test()
        {
            using (CUBRIDConnection conn = new CUBRIDConnection(DBHelper.connString))
            {
                conn.Open();
                DBHelper.ExecuteSQL("drop table if exists t", conn);

                LogTestStep("Begin a transaction, commit after close the connection");
                CUBRIDTransaction transaction = conn.BeginTransaction();
                DBHelper.ExecuteSQL("create table t(idx integer)", conn);

                try
                {
                    conn.Close();
                    transaction.Commit();
                    LogStepFail();
                }
                catch (Exception ex)
                {
                    Assert.AreEqual("Connection must be valid and open to commit transaction!", ex.Message);
                    LogStepPass();
                }

                conn.Open();
                LogTestStep("Begin a transaction, rollback after close the connection");
                CUBRIDTransaction transaction2 = conn.BeginTransaction();
                DBHelper.ExecuteSQL("drop table if exists t", conn);

                try
                {
                    conn.Close();
                    transaction2.Rollback();
                    LogStepFail();
                }
                catch (Exception ex)
                {
                    Assert.AreEqual("Connection must be valid and open to rollback transaction!", ex.Message);
                    LogStepPass();
                }     
                LogTestResult();
            }
        }

        public void CUBRIDTransaction_Commit_Rollback_Negtive1_Test()
        {
            using (CUBRIDConnection conn = new CUBRIDConnection(DBHelper.connString))
            {
                conn.Open();
                DBHelper.ExecuteSQL("drop table if exists t", conn);

                LogTestStep("Begin a transaction, commit twice");                
                CUBRIDTransaction transaction = conn.BeginTransaction();
                DBHelper.ExecuteSQL("create table t(idx integer)", conn);

                transaction.Commit();
                int tablesCount = DBHelper.GetTablesCount("t", conn);
                Assert.AreEqual(1, tablesCount);

                try
                {
                    transaction.Commit();
                    LogStepFail();
                }
                catch (Exception ex)
                {
                    Assert.AreEqual("Transaction has already been committed or is not pending!", ex.Message);
                    tablesCount = DBHelper.GetTablesCount("t", conn); 
                    Assert.AreEqual(1, tablesCount);
                    LogStepPass();
                }

                LogTestStep("Begin a transaction, rollback twice");
                CUBRIDTransaction transaction2 = conn.BeginTransaction();
                DBHelper.ExecuteSQL("drop table if exists t", conn);

                transaction2.Rollback();
                tablesCount = DBHelper.GetTablesCount("t", conn);
                Assert.AreEqual(1, tablesCount);

                try
                {
                    transaction.Rollback();
                    LogStepFail();
                }
                catch (Exception ex)
                {
                    Assert.AreEqual("Transaction has already been committed or is not pending!", ex.Message);
                    tablesCount = DBHelper.GetTablesCount("t", conn);
                    Assert.AreEqual(1, tablesCount);
                    LogStepPass();
                }

                LogTestStep("Begin a transaction, commit, then rollback");
                CUBRIDTransaction transaction3 = conn.BeginTransaction();
                DBHelper.ExecuteSQL("drop table if exists t", conn);
                transaction3.Commit();
                tablesCount = DBHelper.GetTablesCount("t", conn);
                Assert.AreEqual(0, tablesCount);

                try
                {
                    transaction3.Rollback();
                    LogStepFail();
                }
                catch (Exception ex)
                {
                    Assert.AreEqual("Transaction has already been committed or is not pending!", ex.Message);
                    tablesCount = DBHelper.GetTablesCount("t", conn);
                    Assert.AreEqual(0, tablesCount);
                    LogStepPass();
                }

                LogTestStep("Begin a transaction, rollback, then commit");
                CUBRIDTransaction transaction4 = conn.BeginTransaction();
                DBHelper.ExecuteSQL("create table t(idx integer)", conn);
                transaction4.Rollback();
                tablesCount = DBHelper.GetTablesCount("t", conn);
                Assert.AreEqual(0, tablesCount);

                try
                {
                    transaction4.Commit();
                    LogStepFail();
                }
                catch (Exception ex)
                {
                    Assert.AreEqual("Transaction has already been committed or is not pending!", ex.Message);
                    tablesCount = DBHelper.GetTablesCount("t", conn);
                    Assert.AreEqual(0, tablesCount);
                    LogStepPass();
                }

                LogTestResult();
            }
        }

        public void CUBRIDCommand_Constructor_SQLAndConnAndTran_Test()
        {
            CUBRIDConnection conn = new CUBRIDConnection();
            conn.ConnectionString = DBHelper.connString;
            conn.Open();
            conn.SetAutoCommit(false);

            string sql = "drop table if exists t";
            CUBRIDTransaction transaction = new CUBRIDTransaction(conn, CUBRIDIsolationLevel.TRAN_DEFAULT_ISOLATION);
            CUBRIDCommand cmd = new CUBRIDCommand(sql, conn, transaction);

            conn.BeginTransaction();
            cmd.ExecuteNonQuery();
            cmd.CommandText = "create table t (id int, name varchar(50))";
            cmd.ExecuteNonQuery();
            cmd.CommandText = "insert into t values(1, 'Nancy')";
            cmd.ExecuteNonQuery();
            conn.Commit();

            cmd.CommandText = "select * from t";
            CUBRIDDataReader reader = (CUBRIDDataReader)cmd.ExecuteReader();
            reader.Read();
            Assert.AreEqual(2, reader.FieldCount);
            Assert.AreEqual("1", reader.GetString(0));
            Assert.AreEqual("Nancy", reader.GetString(1));

            cmd.Close();
            reader.Close();
            conn.Close();
        }