transactd 2.1.0 → 2.2.0

data/source/bzs/netsvc/server/serverCpt.cpp

@@ -47,7 +47,7 @@ namespace cpt // connection per thread
 unsigned int g_connections = 0;
 unsigned int g_waitThread = 0;
 // ---------------------------------------------------------------------------
-//		connection
+//      connection
 // ---------------------------------------------------------------------------
 #define READBUF_SIZE 66000
 #define WRITEBUF_SIZE 66000
@@ -85,9 +85,15 @@ class connection : public iconnection, private boost::noncopyable
                     m_optionalBuffes.clear();
                 vecBuffer vbuf(m_result);
                 bzs::netsvc::server::IResultBuffer& buf = vbuf;
-                if (m_module->execute(buf, size, &m_optionalBuffes) ==
-                    EXECUTE_RESULT_QUIT)
+                int ret = m_module->execute(buf, size, &m_optionalBuffes);
+                if (ret == EXECUTE_RESULT_QUIT)
                     return;
+                else if(ret == EXECUTE_RESULT_ACCESS_DNIED)
+                {
+                    boost::asio::write(m_socket,  buffer(&m_result[0], size),
+                           boost::asio::transfer_all());
+                    return;
+                }
                 else
                 {
                     m_readLen = 0;
@@ -200,6 +206,7 @@ public:
         m_socket.set_option(
             boost::asio::socket_base::send_buffer_size(1024 * 1024 * 10), ec);
 
+        //send handshake packet
         size_t n = m_module->onAccept(&m_result[0], WRITEBUF_SIZE);
         if (n)
             boost::asio::write(m_socket, buffer(&m_result[0], n),
@@ -235,7 +242,7 @@ std::vector<connection*> connection::connections;
 mutex connection::m_mutex;
 
 // ---------------------------------------------------------------------------
-//		worker
+//      worker
 // ---------------------------------------------------------------------------
 
 class worker : private boost::noncopyable
@@ -323,7 +330,7 @@ public:
                         ((IAppModuleBuilder*)app)->createSessionModule(
                             endpoint, m_connection.get(), SERVER_TYPE_CPT));
                     m_connection->setModule(mod);
-                    if (mod->checkHost(hostCheckName))
+                    if (mod->checkHost(hostCheckName, NULL, 0))
                     {
                         m_connection->sendConnectAccept();
                         m_connection->start(); // It does not return, unless a
@@ -372,7 +379,7 @@ std::vector<boost::shared_ptr<boost::thread> > worker::m_threads;
 std::vector<worker*> worker::m_workers;
 
 // ---------------------------------------------------------------------------
-//		listener
+//      listener
 // ---------------------------------------------------------------------------
 
 class listener
@@ -429,13 +436,13 @@ public:
 };
 
 // ---------------------------------------------------------------------------
-//		server
+//      server
 // ---------------------------------------------------------------------------
 inotifyHandler* server::erh = NULL;
 
 /** server
- *	If it starts, a server will create the exclusive thread for accpter
- *	and will go into an infinite loop.
+ *  If it starts, a server will create the exclusive thread for accpter
+ *  and will go into an infinite loop.
  */
 server::server(std::size_t max_connections, const char* hostCheckName)
     : m_timer(m_ios), m_maxConnections(max_connections), m_stopped(false)
@@ -467,7 +474,7 @@ bool server::checkConnections()
 {
     while (connection::connections.size() > m_maxConnections)
     {
-        Sleep(100 * MCRTOMM);
+        Sleep(100);
         if (m_stopped)
             return false;
     }

data/source/bzs/netsvc/server/serverPipe.cpp

@@ -92,14 +92,10 @@ void acceptor::accept(platform_stream& pipe)
     m_fd = CreateNamedPipe(pipeName, // pipe name
                            PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
                            PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
-                           PIPE_UNLIMITED_INSTANCES // max. instances
-                           ,
-                           BUFSIZE // output buffer size
-                           ,
-                           BUFSIZE // input buffer size
-                           ,
-                           0 // client time-out
-                           ,
+                           PIPE_UNLIMITED_INSTANCES, // max. instances
+                           BUFSIZE, // output buffer size
+                           BUFSIZE, // input buffer size
+                           0, // client time-out
                            &sa); // default security attribute
     if (m_fd == INVALID_HANDLE_VALUE)
         THROW_BZS_ERROR_WITH_MSG(getWindowsErrMsg(GetLastError()));
@@ -190,9 +186,10 @@ public:
             return true;
         DWORD ExitCode;
         if (m_procHandle && GetExitCodeProcess(m_procHandle, &ExitCode))
-
+        {
             if (STILL_ACTIVE != ExitCode)
                 return true;
+        }
         if (m_module && m_module->isShutDown())
             return true;
         return false;
@@ -235,11 +232,13 @@ public:
 
     bool recv(int checkTimeSpan, IExitCheckHandler* handler)
     {
-        DWORD wait;
+        DWORD wait = WAIT_TIMEOUT;
         do
         {
+            if (wait == WAIT_ABANDONED)
+                return false;    
             if (m_cancel || (handler && (handler->isExit())))
-                return 0;
+                return false;
         } while (WAIT_OBJECT_0 !=
                  (wait = WaitForSingleObject(m_recv, checkTimeSpan)));
         m_sent = false;
@@ -341,19 +340,23 @@ class connection : public iconnection, private noncopyable
                 return;
             bool complete = false;
             m_readLen = *((unsigned int*)m_sharedMem->readBuffer());
+            //When readLen = 0 , close connection
             if (m_readLen == 0)
                 return;
             m_module->onRead(m_sharedMem->readBuffer(), m_readLen, complete);
             if (complete)
             {
                 size_t size = 0;
-                if (m_module->execute(sharedMemBuffer(*m_sharedMem), size,
-                                      NULL) == EXECUTE_RESULT_QUIT)
+                int ret = m_module->execute(sharedMemBuffer(*m_sharedMem), size, NULL);
+                if (ret == EXECUTE_RESULT_QUIT)
                     return;
                 else
                     m_readLen = 0;
 
                 sentResult = m_comm->send();
+                //When named pipe, dissconnect from local client.
+                //if (ret == EXECUTE_RESULT_ACCESS_DNIED)
+                //    return;
                 m_module->cleanup();
             }
         }
@@ -434,10 +437,15 @@ public:
         m_exitHandler.reset(new exitCheckHnadler(clinetProcessID));
         if (m_module)
             m_exitHandler->setModule(m_module.get());
-        m_module->onAccept(tmp, 50);
-
-        strcpy(tmp, "OK");
-        memcpy(tmp + 3, &m_shareMemSize, 4);
+        tmp[0] = 0x00; // signe of handshakable
+        memcpy(tmp + 3, &m_shareMemSize, sizeof(unsigned int));// sharemem size
+        //asio::write(m_socket, buffer(tmp, 7), e);
+        //len = asio::read(m_socket, buffer(buf, 9), e);
+        //if (len != 9)
+        //    THROW_BZS_ERROR_WITH_MSG("handshake error");
+        //send handshake packet
+        m_module->onAccept(m_sharedMem->writeBuffer(), m_sharedMem->size());
+        m_comm->send();
         asio::write(m_socket, buffer(tmp, 7), e);
         run();
     }
@@ -522,7 +530,6 @@ public:
      */
     static worker* worker::get(const IAppModuleBuilder* app)
     {
-
         worker* p = findWaitThread();
         if (p == NULL)
         {
@@ -565,7 +572,7 @@ public:
                         ((IAppModuleBuilder*)app)->createSessionModule(
                             endpoint, m_connection.get(), SERVER_TYPE_CPT));
                     m_connection->setModule(mod);
-                    if (mod->checkHost(hostCheckName))
+                    if (mod->checkHost(hostCheckName, NULL, 0))
                         m_connection->start(); // It does not return, unless a
                     // connection is close.
                     m_connection.reset();

data/source/bzs/netsvc/server/serverTpool.cpp

@@ -153,6 +153,12 @@ class connection : public boost::enable_shared_from_this<connection>,
 
                 if (ret == EXECUTE_RESULT_QUIT)
                     return;
+                else if(ret == EXECUTE_RESULT_ACCESS_DNIED)
+                {
+                    boost::asio::write(m_socket,  buffer(&m_result[0], size),
+                           boost::asio::transfer_all());
+                    return;
+                }
 
                 m_optionalBuffes.insert(m_optionalBuffes.begin(),
                                         buffer(&m_result[0], size));
@@ -170,7 +176,6 @@ class connection : public boost::enable_shared_from_this<connection>,
                             boost::bind(&connection::handle_write,
                                         shared_from_this(),
                                         boost::asio::placeholders::error));
-
                 return;
             }
 
@@ -231,6 +236,7 @@ public:
 
     void sendConnectAccept()
     {
+        //send handshake packet
         size_t n = m_module->onAccept(&m_result[0], WRITEBUF_SIZE);
         if (n)
             boost::asio::write(m_socket, buffer(&m_result[0], n),
@@ -313,7 +319,7 @@ public:
             boost::shared_ptr<IAppModule> mod(m_app->createSessionModule(
                 endpoint, m_newConnection.get(), SERVER_TYPE_TPOOL));
             m_newConnection->setModule(mod);
-            if (mod->checkHost(m_srv->hostCheckName()))
+            if (mod->checkHost(m_srv->hostCheckName(), NULL, 0))
             {
                 m_newConnection->sendConnectAccept();
                 m_newConnection->start();

data/source/bzs/rtl/debuglog.cpp

@@ -74,12 +74,26 @@ void debuglog::dump(FILE* fp, const char* p, int size, int limit)
     size = std::min<int>(size, limit);
     for (int i = 0; i < size; i += 16)
     {
-
-        for (int j = 0; j < 16; j++)
-            fprintf(fp, "%02X ", *((unsigned char*)(p + i + j)));
+        const char* pp = p + i;
+        int max = std::min<int>(size - i, 16);
+        for (int j = 0; j < max; j++)
+            fprintf(fp, "%02X ", *((unsigned char*)(pp + j)));
+        
+        if (max != 16)
+        {
+            for (int j = 0; j < 16 - max; j++)
+                fprintf(fp, "   ");
+        }
+        
         fprintf(fp, " ");
-        for (int j = 0; j < 16; j++)
-            fprintf(fp, "%c", *((unsigned char*)(p + i + j)));
+        for (int j = 0; j < max; j++)
+        {
+            const char* p1 = pp + j;
+            if (*p1 >= ' ' && *p1 <= '~')
+                fprintf(fp, "%c", *p1);
+            else
+                fprintf(fp, " ");
+        }
         fprintf(fp, "\n");
     }
     fprintf(fp, "\n");
@@ -91,6 +105,8 @@ void debuglog::writeDump(const char* msg, const char* ptr, int size)
     FILE* fp = fileOpen(logfilename, "a+");
     if (fp)
     {
+        fputs(dateTime(), fp);
+        fputs(" ", fp);
         fputs(msg, fp);
         fputs("\n", fp);
         dump(fp, ptr, size, INT_MAX);

data/source/bzs/rtl/debuglog.h

@@ -61,7 +61,7 @@ public:
 #define DEBUG_WRITELOG(MSG)
 #endif // DEBUG_LOG
 
-#if defined(DEBUG_PROFILE) || defined(DEBUG_LOG)
+#if defined(DEBUG_PROFILE) || defined(DEBUG_LOG) || defined(DEBUG_LOG_ERR)
 #define DEBUG_PROFILE_INIT() bzs::rtl::debuglog::get()->init();
 #define DEBUG_PROFILE_DEINIT() bzs::rtl::debuglog::get()->stop();
 #else

data/source/bzs/test/tdclphp/transactd_Test.php

@@ -42,7 +42,32 @@ define("FDI_NAMEW", 2);
 define("BULKBUFSIZE", 65535 - 1000);
 define("TEST_COUNT", 20000);
 define("FIVE_PERCENT_OF_TEST_COUNT", TEST_COUNT / 20);
-define("ALLOWABLE_ERROR_DISTANCE_IN_ESTIMATE_COUNT", TEST_COUNT / 4);
+
+// multi thread test if `php_pthreads` exists.
+if(class_exists('Thread')){
+    class SeekLessThanWorker extends Thread
+    {
+        public function __construct()
+        {
+            $this->value = -1;
+        }
+        public function run()
+        {
+            $dbm = new Bz\pooledDbManager(new Bz\connectParams(URL));
+            $tb = $dbm->table('user');
+            $tb->setFV(FDI_ID, 300000);
+            $tb->seekLessThan(false, Bz\transactd::ROW_LOCK_X);
+            $this->value = $tb->getFVint(FDI_ID);
+            $tb->unlock();
+            $tb->close();
+            $dbm->unUse();
+        }
+        public function getResult()
+        {
+            return $this->value;
+        }
+    }
+}
 
 class transactdTest extends PHPUnit_Framework_TestCase
 {
@@ -263,8 +288,9 @@ class transactdTest extends PHPUnit_Framework_TestCase
         $this->assertEquals($client_ver->majorVersion, Bz\transactd::CPP_INTERFACE_VER_MAJOR);
         $this->assertEquals($client_ver->minorVersion, Bz\transactd::CPP_INTERFACE_VER_MINOR);
         $this->assertEquals(chr($client_ver->type), 'N');
-        $this->assertTrue($server_ver->majorVersion >= 5);
-        $this->assertTrue($server_ver->majorVersion != 5 || $server_ver->minorVersion >= 5);
+        $my5x = ($server_ver->majorVersion == 5) && ($server_ver->minorVersion >= 5);
+        $maria10 = ($server_ver->majorVersion == 10) && ($server_ver->minorVersion == 0);
+        $this->assertTrue($my5x || $maria10);
         $this->assertEquals(chr($server_ver->type), 'M');
         $this->assertEquals($engine_ver->majorVersion, Bz\transactd::TRANSACTD_VER_MAJOR);
         $this->assertEquals($engine_ver->minorVersion, Bz\transactd::TRANSACTD_VER_MINOR);
@@ -756,6 +782,9 @@ class transactdTest extends PHPUnit_Framework_TestCase
         $this->assertEquals($tb->stat(), Bz\transactd::STATUS_NOT_FOUND_TI);
         
         // clean up
+        $tb2->setFV(FDI_ID, 29999);
+        $tb2->seek();
+        $this->assertEquals($tb2->stat(), 0);
         $tb2->del();
         $this->assertEquals($tb2->stat(), 0);
         
@@ -784,6 +813,24 @@ class transactdTest extends PHPUnit_Framework_TestCase
         $this->assertEquals($tb2->stat(), Bz\transactd::STATUS_LOCK_ERROR);
         
         $db->endSnapshot();
+        
+        // gap lock
+        $db->beginSnapshot(Bz\transactd::MULTILOCK_NOGAP_SHARE);
+        $tb->seekLast(); // id = 30000
+        $this->assertEquals($tb->stat(), 0);
+        $tb->seekPrev(); // id = 20002
+        $this->assertEquals($tb->stat(), 0);
+        $tb->seekPrev(); // id = 20001
+        $this->assertEquals($tb->stat(), 0);
+        
+        $tb2->setFV(FDI_ID, 20002);
+        $tb2->seek(Bz\transactd::ROW_LOCK_X);
+        $this->assertEquals($tb2->stat(), Bz\transactd::STATUS_LOCK_ERROR);
+        
+        $tb2->seekLast(Bz\transactd::ROW_LOCK_X);
+        $this->assertEquals($tb2->stat(), Bz\transactd::STATUS_LOCK_ERROR);
+        
+        $db->endSnapshot();
     }
     public function testConflict()
     {
@@ -954,6 +1001,37 @@ class transactdTest extends PHPUnit_Framework_TestCase
         $this->assertEquals($tb->getFVint(FDI_ID), $last2);
         $db->endTrn();
         
+        // ----------------------------------------------------
+        //  Test use shared lock option
+        // ----------------------------------------------------
+        $db->beginTrn(Bz\transactd::MULTILOCK_REPEATABLE_READ);
+        $this->assertEquals(0, $db->stat());
+        
+        $db2->beginTrn(Bz\transactd::MULTILOCK_REPEATABLE_READ);
+        $this->assertEquals(0, $db2->stat());
+        
+        $tb->seekLast(Bz\transactd::ROW_LOCK_S);
+        $this->assertEquals(0, $tb->stat());
+        $tb2->seekLast(Bz\transactd::ROW_LOCK_S);
+        $this->assertEquals(0, $tb2->stat());
+        
+        $tb->seekPrev(); // Lock(X)
+        $this->assertEquals(0, $tb->stat());
+        
+        $tb2->seekPrev(Bz\transactd::ROW_LOCK_S);
+        $this->assertEquals(Bz\transactd::STATUS_LOCK_ERROR, $tb2->stat());
+        
+        $tb->seekPrev(Bz\transactd::ROW_LOCK_S);
+        $this->assertEquals(0, $tb->stat());
+        $id = $tb->getFVint(FDI_ID);
+        
+        $tb2->setFV(FDI_ID, $id);
+        $tb2->seek(Bz\transactd::ROW_LOCK_S);
+        $this->assertEquals(0, $tb2->stat());
+        
+        $db2->endTrn();
+        $db->endTrn();
+        
         // ----------------------------------------------------
         //  Test Abort
         // ----------------------------------------------------
@@ -1255,6 +1333,9 @@ class transactdTest extends PHPUnit_Framework_TestCase
         // No match records are unlocked.
         $tb2->setFV(FDI_ID, 100);
         $tb2->seek(Bz\transactd::ROW_LOCK_X);
+        $this->assertEquals(0, $tb2->stat());
+        $tb2->setFV(FDI_ID, 101);
+        $tb2->seek(Bz\transactd::ROW_LOCK_X);
         $this->assertEquals($tb2->stat(), 0);
         $tb2->unlock();
         $db->endTrn();
@@ -1318,8 +1399,11 @@ class transactdTest extends PHPUnit_Framework_TestCase
         $tb2->seekNext(Bz\transactd::ROW_LOCK_X); // lock(X) third, second lock freed
         $this->assertEquals($tb2->stat(), 0);
         
-        $tb->seekNext(); // nobody lock second.
-        $this->assertEquals($tb->stat(), 0);
+        $tb->seekNext(); // nobody lock second. But REPEATABLE_READ tb2 lock all(no unlock)
+        if ($db->trxIsolationServer() == Bz\transactd::SRV_ISO_REPEATABLE_READ)
+            $this->assertEquals($tb->stat(), Bz\transactd::STATUS_LOCK_ERROR);
+        else
+            $this->assertEquals($tb->stat(), 0);
         $tb->seekNext(Bz\transactd::ROW_LOCK_X); // Try lock(X) third
         $this->assertEquals($tb->stat(), Bz\transactd::STATUS_LOCK_ERROR);
         
@@ -1345,10 +1429,15 @@ class transactdTest extends PHPUnit_Framework_TestCase
         $tb->setFV(FDI_ID, 21000);
         $tb->insert();
         $this->assertEquals($tb->stat(), 0);
+        
+        //cleanup
+        $tb->setFV(FDI_ID, 21000);
+        $tb->seek();
+        $this->assertEquals($tb->stat(), 0);
         $tb->del();
         $this->assertEquals($tb->stat(), 0);
         
-        // ---------   Unlock test ----------------------------
+        // --------- Unlock test ---------------------------
         // 1 unlock()
         $tb->seekFirst(Bz\transactd::ROW_LOCK_X);
         $this->assertEquals($tb->stat(), 0);
@@ -1404,7 +1493,11 @@ class transactdTest extends PHPUnit_Framework_TestCase
         $tb2->seekFirst(Bz\transactd::ROW_LOCK_X);
         $this->assertEquals($tb2->stat(), 0);
         $tb2->unlock();
-        // ---------   End Unlock test ----------------------------
+        // --------- End Unlock test -----------------------
+        
+        // --------- Invalid lock type test ----------------
+        $tb2->seekFirst(Bz\transactd::ROW_LOCK_S);
+        $this->assertEquals(Bz\transactd::STATUS_INVALID_LOCKTYPE, $tb2->stat());
     }
     public function testExclusive()
     {
@@ -1423,23 +1516,21 @@ class transactdTest extends PHPUnit_Framework_TestCase
         $db2->connect(PROTOCOL . HOSTNAME . DBNAME, true);
         $this->assertEquals($db2->stat(), 0);
         $db2->open(URL, Bz\transactd::TYPE_SCHEMA_BDF);
+        // database open error. Check database::stat()
         $this->assertEquals($db2->stat(), Bz\transactd::STATUS_CANNOT_LOCK_TABLE);
         $tb->close();
         $db->close();
         $db2->close();
         
         // ------------------------------------------------------
-        // database WRITE EXCLUSIVE
+        // database READ EXCLUSIVE
         // ------------------------------------------------------
-        // table mode exclusive
-        $db = new Bz\database();
         $db->open(URL, Bz\transactd::TYPE_SCHEMA_BDF, Bz\transactd::TD_OPEN_READONLY_EXCLUSIVE);
         $this->assertEquals($db->stat(), 0);
         $tb = $db->openTable(TABLENAME, Bz\transactd::TD_OPEN_READONLY_EXCLUSIVE);
         $this->assertEquals($db->stat(), 0);
         
         // Read only open
-        $db2 = new Bz\database();
         $db2->open(URL, Bz\transactd::TYPE_SCHEMA_BDF);
         $this->assertEquals($db2->stat(), 0);
         $db2->close();
@@ -1459,6 +1550,7 @@ class transactdTest extends PHPUnit_Framework_TestCase
         $db2->open(URL, Bz\transactd::TYPE_SCHEMA_BDF, Bz\transactd::TD_OPEN_READONLY_EXCLUSIVE);
         $this->assertEquals($db2->stat(), 0);
         $db2->close();
+        $tb->close();
         $db->close();
         
         // ------------------------------------------------------
@@ -1473,10 +1565,10 @@ class transactdTest extends PHPUnit_Framework_TestCase
         
         $tb2 = $db->openTable('group', Bz\transactd::TD_OPEN_EXCLUSIVE);
         $this->assertEquals($db->stat(), 0);
+        
         // Check tb2 Exclusive
         $tb3 = $db2->openTable('group', Bz\transactd::TD_OPEN_NORMAL);
         $this->assertEquals($db2->stat(), Bz\transactd::STATUS_CANNOT_LOCK_TABLE);
-        
         for ($i = 1; $i < 5; $i++)
         {
             $tb2->setFV(FDI_ID, $i + 1);
@@ -1517,10 +1609,10 @@ class transactdTest extends PHPUnit_Framework_TestCase
         $this->assertEquals($tb->stat(), 0);
         
         // ------------------------------------------------------
-        // Normal and Exclusive opend tables mix transaction
+        // Normal and Exclusive open tables mix transaction
         // ------------------------------------------------------
         $tb2 = $db->openTable('group', Bz\transactd::TD_OPEN_EXCLUSIVE);
-        $this->assertEquals($tb2->stat(), 0);
+        $this->assertEquals($db->stat(), 0);
         // Check tb2 Exclusive
         $tb3 = $db2->openTable('group', Bz\transactd::TD_OPEN_NORMAL);
         $this->assertEquals($db2->stat(), Bz\transactd::STATUS_CANNOT_LOCK_TABLE);
@@ -1586,6 +1678,70 @@ class transactdTest extends PHPUnit_Framework_TestCase
         $v2 = $tb->getFVstr(FDI_NAME);
         $this->assertEquals($v, $v2);
     }
+    public function testMissingUpdate()
+    {
+        if(! class_exists('Thread'))
+        {
+            echo(' * class Thread not found! * ');
+            return;
+        }
+        $db = new Bz\database();
+        $tb = $this->openTable($db);
+        Bz\pooledDbManager::setMaxConnections(3);
+        // Lock last record and insert to next of it
+        $w = new SeekLessThanWorker();
+        $tb->setFV(FDI_ID, 300000);
+        $tb->seekLessThan(false, Bz\transactd::ROW_LOCK_X);
+        $this->assertEquals($tb->stat(), 0);
+        if ($tb->stat() == 0)
+        {
+            // Get lock(X) same record in parallel.
+            $w->start();
+            usleep(5000);
+            $v = $tb->getFVint(FDI_ID);
+            $tb->setFV(FDI_ID, ++$v);
+            $tb->insert();
+            $this->assertEquals($tb->stat(), 0);
+            $w->join();
+            $v2 = $w->getResult();
+            
+            if ($db->trxIsolationServer() == Bz\transactd::SRV_ISO_REPEATABLE_READ)
+            {   // $tb can not insert because $tb2 got gap lock with SRV_ISO_REPEATABLE_READ.
+                // It is deadlock!
+                $this->assertEquals($tb->stat(), Bz\transactd::STATUS_LOCK_ERROR);
+            }
+            else
+            {   // When SRV_ISO_READ_COMMITED set, $tb2 get lock after $tb->insert.
+                // But this is not READ_COMMITED !
+                $this->assertEquals($tb->stat(), 0);
+                $this->assertEquals($v2, $v - 1);
+                // cleanup
+                $tb->setFV(FDI_ID, $v);
+                $tb->seek();
+                $this->assertEquals($tb->stat(), 0);
+                $tb->del();
+                $this->assertEquals($tb->stat(), 0);
+            }
+        }
+        // Lock last record and delete it
+        $w = new SeekLessThanWorker();
+        $tb->setFV(FDI_ID, 300000);
+        $tb->seekLessThan(false, Bz\transactd::ROW_LOCK_X);
+        $this->assertEquals($tb->stat(), 0);
+        if ($tb->stat() == 0)
+        {
+            // Get lock(X) same record in parallel.
+            $w->start();
+            usleep(5000);
+            $v = $tb->getFVint(FDI_ID);
+            $tb->del();
+            $this->assertEquals($tb->stat(), 0);
+            $w->join();
+            $v2 = $w->getResult();
+            $this->assertNotEquals($v, $v2);
+        }
+        (new Bz\pooledDbManager())->reset(0);
+    }
     public function testInsert2()
     {
         $db = new Bz\database();
@@ -1611,13 +1767,16 @@ class transactdTest extends PHPUnit_Framework_TestCase
         $db = new Bz\database();
         $tb = $this->openTable($db);
         $this->assertNotEquals($tb, NULL);
+        $expected_count = 20003;
+        if(! class_exists('Thread'))
+          $expected_count = $expected_count + 1;
         // estimate count
         $count = $tb->recordCount(true);
-        $is_valid_count = (abs($count - TEST_COUNT) < ALLOWABLE_ERROR_DISTANCE_IN_ESTIMATE_COUNT);
+        $is_valid_count = (abs($count - $expected_count) < 5000);
         $this->assertTrue($is_valid_count);
         if (! $is_valid_count)
-          print("true record count = " . (TEST_COUNT + 3) . " and estimate recordCount count = " . $count);
-        $this->assertEquals($tb->recordCount(false), TEST_COUNT + 3); // true count
+          print("true record count = " . $expected_count . " and estimate recordCount count = " . $count);
+        $this->assertEquals($tb->recordCount(false), $expected_count); // true count
         $vv = TEST_COUNT * 3 / 4 + 1;
         $tb->clearBuffer();
         $tb->setFV(FDI_ID, $vv);
@@ -1684,7 +1843,7 @@ class transactdTest extends PHPUnit_Framework_TestCase
             $db2->connect(PROTOCOL . HOSTNAME, true);
             $this->assertEquals($db2->stat(), 0);
             unset($db2);
-            $db->disconnect(PROTOCOL . HOSTNAME);
+            $db->disconnect();
             $this->assertEquals($db->stat(), 0);
         }
         // invalid host name
@@ -1696,24 +1855,24 @@ class transactdTest extends PHPUnit_Framework_TestCase
             print('bad host $db->stat() = ' . $db->stat());
         $this->createDatabase($db);
         $this->createTable($db);
-        $db->disconnect(PROTOCOL . HOSTNAME . DBNAME);
+        $db->close();
         $this->assertEquals($db->stat(), 0);
         // true database name
         $db->connect(PROTOCOL . HOSTNAME . DBNAME);
         $this->assertEquals($db->stat(), 0);
         if ($db->stat() == 0)
         {
-            $db->disconnect(PROTOCOL . HOSTNAME . DBNAME);
+            $db->disconnect();
             $this->assertEquals($db->stat(), 0);
         }
         // invalid database name
         $this->dropDatabase($db);
-        $db->disconnect(PROTOCOL . HOSTNAME . DBNAME);
+        $db->disconnect();
         $this->assertEquals($db->stat(), 0);
         $db->connect(PROTOCOL . HOSTNAME . DBNAME);
-        $this->assertEquals($db->stat(), 25000 + 1049);
-        $db->disconnect(PROTOCOL . HOSTNAME . DBNAME);
-        $this->assertEquals($db->stat(), 0);
+        $this->assertEquals($db->stat(), Bz\transactd::ERROR_NO_DATABASE);
+        $db->disconnect();
+        $this->assertEquals($db->stat(), 1);
     }
     
     /* -----------------------------------------------------
@@ -3242,19 +3401,6 @@ class transactdTest extends PHPUnit_Framework_TestCase
         // $rs[0];
         $this->assertEquals($rs[0]['group_name'], '1 group');
         
-/*
-        sortFields orderRv;
-        orderRv.add('group_name', false);
-        rs.orderBy(orderRv);
-
-        sortFields order;
-        order.add('group_name', true);
-        rs.orderBy(order);
-        BOOST_CHECK_MESSAGE(_tstring(rs[(size_t)0]['group_name'].c_str()) ==
-                                _tstring('1 group'),
-                            "group_name = 1 group "
-                                << string(rs[(size_t)0]['group_name'].a_str()));
-*/
         // All fields
         $rs->clear();
         $q->reset()->all();

data/source/bzs/test/tdclphp/transactd_pool_Test.php

@@ -90,7 +90,6 @@ class transactdPoolTest extends PHPUnit_Framework_TestCase
         $dbm = new Bz\pooledDbManager($cp);
         $atu = new Bz\ActiveTable($dbm, 'user');
         $q = new Bz\query();
-        $rs = new Bz\RecordSet();
         $atu->alias('名前', 'name');
         $q->select('id', 'name', 'group')->where('id', '<=', 15000);
         $rs = $atu->index(0)->keyValue(1)->read($q);
@@ -105,7 +104,7 @@ class transactdPoolTest extends PHPUnit_Framework_TestCase
     public function testMultiThreads()
     {
         if(! class_exists('Thread')){
-            echo(' * class Tread not found! * ');
+            echo(' * class Thread not found! * ');
             return;
         }
         Bz\pooledDbManager::setMaxConnections(5);