transactd 1.2.0 → 2.0.0

data/source/bzs/test/transactdBench/workerMySQLImple.h

@@ -0,0 +1,333 @@
+#ifndef BZS_TEST_BENCH_WORKERMYSQLIMPLE_H
+#define BZS_TEST_BENCH_WORKERMYSQLIMPLE_H
+/* =================================================================
+ Copyright (C) 20014 BizStation Corp All rights reserved.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+ ================================================================= */
+#include <mysql.h>
+
+namespace bzs
+{
+namespace test
+{
+namespace worker
+{
+
+namespace mysql
+{
+
+#define USE_SHARED_PREPAREDSTATEMENT
+
+#define MYSQL_READ_ONE 10
+#define MYSQL_INSERT_ONE 11
+#define MYSQL_QUERY 12
+#define MYSQL_RECORDSET_COUNT 50
+
+class connectParam
+{
+public:
+    connectParam(){};
+    connectParam(const _TCHAR* host, const _TCHAR* dbname, const _TCHAR* user,
+                 const _TCHAR* pass = _T(""))
+
+    {
+        port = 0;
+#ifdef _UNICODE
+        char tmp[256];
+        WideCharToMultiByte(CP_UTF8, 0, host, -1, tmp, 256, NULL, NULL);
+        hostname = tmp;
+        WideCharToMultiByte(CP_UTF8, 0, dbname, -1, tmp, 256, NULL, NULL);
+        database = tmp;
+        WideCharToMultiByte(CP_UTF8, 0, user, -1, tmp, 256, NULL, NULL);
+        username = tmp;
+        WideCharToMultiByte(CP_UTF8, 0, pass, -1, tmp, 256, NULL, NULL);
+        passwd = tmp;
+#else
+        hostname = host;
+        database = dbname;
+        username = user;
+        passwd = pass;
+#endif
+    }
+
+    std::string hostname;
+    std::string username;
+    std::string passwd;
+    std::string database;
+    unsigned long port;
+};
+
+const char* readOneQuery = "select * from user where id = ? \n";
+/*const char* queryOneQuery = "select `user`.`id` \n"
+                                        ",`user`.`%s` as `name`  \n"
+                                        ",`extention`.`comment` \n"
+                                        ",`groups`.`name` as `group_name` \n"
+                                        " from `user` INNER JOIN `extention` \n"
+                                                        " ON `user`.`id`  =
+   `extention`.`id` \n"
+                                        " LEFT JOIN `groups` \n"
+                                                        " ON `user`.`group`  =
+   `groups`.`code` \n"
+                                        " where `user`.`id` >= ? \n"
+                                        "and `user`.`id` < ?";
+*/
+const char* queryOneQuery =
+    "select `user`.`id` ,`user`.`%s` as `name`"
+    ",`groups`.`name` as `group_name`"
+    " from `user` LEFT JOIN `groups` ON `user`.`group`  = `groups`.`code`"
+    "where `user`.`id` >= ? and `user`.`id` < ?";
+
+/*
+const char* queryOneQuery = "select `user`.`id` ,`user`.`%s` as `name`"
+        " from `user`"
+        " where `user`.`id` >= ? and `user`.`id` < ?";
+*/
+class worker : public workerBase
+{
+    struct readResult
+    {
+        int id;
+        char name[41];
+        int group;
+        union
+        {
+            char tel[43];
+            char group_name[43];
+        };
+        char comment[256];
+    };
+
+    const connectParam& m_parmas;
+    MYSQL* m_mysql;
+    readResult m_result;
+    int m_bindParam;
+    int m_bindParam2;
+    MYSQL_STMT* m_stmt;
+    std::vector<readResult> m_resultset;
+
+    void bindParam(MYSQL_STMT* stmt)
+    {
+        if (m_functionNumber == MYSQL_READ_ONE)
+        {
+            MYSQL_BIND bind[1];
+            memset(bind, 0, sizeof(MYSQL_BIND));
+            bind[0].buffer_type = MYSQL_TYPE_LONG;
+            bind[0].buffer = &m_bindParam;
+            bind[0].is_null = 0;
+            if (mysql_stmt_bind_param(stmt, bind))
+                printf("error: %s\n", mysql_stmt_error(stmt));
+        }
+        else if (m_functionNumber == MYSQL_QUERY)
+        {
+            MYSQL_BIND bind[2];
+            memset(bind, 0, sizeof(MYSQL_BIND) * 2);
+            bind[0].buffer_type = MYSQL_TYPE_LONG;
+            bind[0].buffer = &m_bindParam;
+            bind[0].is_null = 0;
+            bind[1].buffer_type = MYSQL_TYPE_LONG;
+            bind[1].buffer = &m_bindParam2;
+            bind[1].is_null = 0;
+            if (mysql_stmt_bind_param(stmt, bind))
+                printf("error: %s\n", mysql_stmt_error(stmt));
+        }
+    }
+
+    void bindOutput(MYSQL_STMT* stmt)
+    {
+
+        MYSQL_BIND result[4];
+        memset(result, 0, sizeof(MYSQL_BIND) * 4);
+
+        result[0].buffer_type = MYSQL_TYPE_LONG;
+        result[0].buffer = &m_result.id;
+        result[0].is_null = 0;
+        result[1].buffer_type = MYSQL_TYPE_VAR_STRING;
+        result[1].buffer = m_result.name;
+        result[1].buffer_length = 41;
+        result[1].is_null = 0;
+        if (m_functionNumber == MYSQL_QUERY)
+        {
+            result[2].buffer_type = MYSQL_TYPE_VAR_STRING;
+            result[2].buffer = &m_result.comment;
+            result[2].buffer_length = 256;
+        }
+        else
+        {
+            result[2].buffer_type = MYSQL_TYPE_LONG;
+            result[2].buffer = &m_result.group;
+        }
+        result[2].is_null = 0;
+        result[3].buffer_type = MYSQL_TYPE_VAR_STRING;
+        result[3].buffer = m_result.tel; // or group_name
+        result[3].buffer_length = 43;
+        result[3].is_null = 0;
+
+        if (mysql_stmt_bind_result(stmt, result))
+            printf("error: %s\n", mysql_stmt_error(stmt));
+    }
+
+    MYSQL_STMT* init(const char* query)
+    {
+#ifdef LINUX
+        const char* fd_name = "���O";
+#else
+        char fd_name[30];
+        WideCharToMultiByte(CP_UTF8, 0, L"���O", -1, fd_name, 30, NULL, NULL);
+#endif
+        char tmp[512];
+        if (m_functionNumber == MYSQL_QUERY)
+        {
+            sprintf_s(tmp, 512, query, fd_name);
+            query = tmp;
+        }
+
+        MYSQL_STMT* stmt = mysql_stmt_init(m_mysql);
+        if (!stmt)
+            printf("error: %s\n", mysql_error(m_mysql));
+        if (mysql_stmt_prepare(stmt, query, (unsigned long)strlen(query)))
+            printf("error: %s\n", mysql_error(m_mysql));
+        bindParam(stmt);
+        bindOutput(stmt);
+        return stmt;
+    }
+
+    void readOne(MYSQL_STMT* stmt)
+    {
+        m_bindParam = m_id % 20000 + 1;
+        mysql_stmt_execute(stmt);
+        int ret;
+        ret = mysql_stmt_fetch(stmt);
+        if (ret)
+            printf("error: %s\n", mysql_error(m_mysql));
+    }
+
+    void insertOne()
+    {
+        char tmp[256];
+        sprintf_s(tmp, 256, "insert into cache (value) values(%d)", m_id);
+        int ret;
+        ret = mysql_query(m_mysql, tmp);
+        if (ret)
+            printf("error: %s\n", mysql_error(m_mysql));
+    }
+
+    void queryOne(MYSQL_STMT* stmt)
+    {
+        int v = rand() % 15000 + 1;
+        m_bindParam = v;
+        m_bindParam2 = v + MYSQL_RECORDSET_COUNT;
+        int ret;
+        ret = mysql_stmt_execute(stmt);
+        if (ret)
+            printf("error: %s\n", mysql_error(m_mysql));
+        int count = 0;
+        m_resultset.clear();
+        while ((ret = mysql_stmt_fetch(stmt)) == 0)
+        {
+            m_resultset.push_back(m_result);
+            ++count;
+        }
+        if (count != MYSQL_RECORDSET_COUNT)
+            printf("query read error! id = %d \n", m_id);
+    }
+
+public:
+    worker(int id, int loopCount, int functionNumber, const connectParam& param,
+           boost::barrier& sync)
+        : workerBase(id, loopCount, functionNumber, sync), m_parmas(param)
+    {
+        boost::mutex::scoped_lock lck(m_mutex);
+        mysql_thread_init();
+
+        m_mysql = mysql_init(NULL);
+        int v = 1;
+        if (NULL == mysql_real_connect(
+                        m_mysql, m_parmas.hostname.c_str(),
+                        m_parmas.username.c_str(), m_parmas.passwd.c_str(),
+                        m_parmas.database.c_str(), m_parmas.port, NULL, 0))
+            printf("error: %s\n", mysql_error(m_mysql));
+    }
+
+    void initExecute()
+    {
+#ifdef USE_SHARED_PREPAREDSTATEMENT
+        if (m_functionNumber == MYSQL_READ_ONE)
+            m_stmt = init(readOneQuery);
+        else if (m_functionNumber == MYSQL_QUERY)
+            m_stmt = init(queryOneQuery);
+#endif
+    }
+
+    void endExecute()
+    {
+#ifdef USE_SHARED_PREPAREDSTATEMENT
+        if (m_functionNumber != MYSQL_INSERT_ONE)
+            mysql_stmt_close(m_stmt);
+#endif
+        mysql_close(m_mysql);
+        mysql_thread_end();
+    }
+
+    void doExecute()
+    {
+        if (m_functionNumber == MYSQL_READ_ONE)
+        {
+            for (int i = 0; i < m_loopCount; ++i)
+            {
+#ifndef USE_SHARED_PREPAREDSTATEMENT
+                m_stmt = init(readOneQuery);
+#endif
+                readOne(m_stmt);
+#ifndef USE_SHARED_PREPAREDSTATEMENT
+                mysql_stmt_close(m_stmt);
+#endif
+            }
+        }
+        else if (m_functionNumber == MYSQL_INSERT_ONE)
+        {
+            for (int i = 0; i < m_loopCount; ++i)
+                insertOne();
+        }
+        else
+        {
+            for (int i = 0; i < m_loopCount; ++i)
+            {
+#ifndef USE_SHARED_PREPAREDSTATEMENT
+                m_stmt = init(queryOneQuery);
+#endif
+                queryOne(m_stmt);
+#ifndef USE_SHARED_PREPAREDSTATEMENT
+                mysql_stmt_close(m_stmt);
+#endif
+            }
+        }
+    }
+};
+
+class mysqlInit
+{
+public:
+    mysqlInit() { mysql_library_init(0, NULL, NULL); }
+    ~mysqlInit() { mysql_library_end(); }
+};
+
+} // namespace transactd
+} // namespace worker
+} // namespace test
+} // namespace bzs
+
+#endif // BZS_TEST_BENCH_WORKERMYSQLIMPLE_H

data/source/bzs/test/transactdBench/workerTransactdImple.h

@@ -0,0 +1,201 @@
+#ifndef BZS_TEST_BENCH_WORKERTRANSACTDIMPLE_H
+#define BZS_TEST_BENCH_WORKERTRANSACTDIMPLE_H
+/* =================================================================
+ Copyright (C) 20014 BizStation Corp All rights reserved.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+ ================================================================= */
+#include <bzs/test/transactdBench/workerBase.h>
+#include <bzs/db/protocol/tdap/client/connectionPool.h>
+#include <bzs/db/protocol/tdap/client/pooledDatabaseManager.h>
+#include <bzs/example/queryData.h>
+#include <bzs/db/protocol/tdap/client/activeTable.h>
+#include <tchar.h>
+using namespace bzs::db::protocol::tdap::client;
+using namespace bzs::db::protocol::tdap;
+
+namespace bzs
+{
+namespace test
+{
+namespace worker
+{
+namespace transactd
+{
+
+#define USE_CONNECTION_POOL
+#define TRD_READ_ONE 0
+#define TRD_INSERT_ONE 1
+#define TRD_QUERY 2
+#define TRD_RECORDSET_COUNT 50
+
+class worker : public workerBase
+{
+    const connectParams& m_parmas;
+#ifdef USE_CONNECTION_POOL
+    pooledDbManager m_db_real;
+    pooledDbManager* m_db;
+#else
+    database_ptr m_db;
+
+#endif
+    table_ptr m_tb;
+    boost::shared_ptr<activeTable> m_atu;
+    boost::shared_ptr<activeTable> m_atg;
+    boost::shared_ptr<activeTable> m_ate;
+    recordset m_rs;
+    void readOne(table_ptr& tb)
+    {
+        int v = (rand() % 15000) + 1;
+        tb->setFV((short)0, v);
+        tb->seek();
+        if (tb->stat() != 0)
+            printf("readOne error! stat = %d  id = %ld\n", tb->stat(), m_id);
+    }
+
+    void insertOne(table_ptr& tb)
+    {
+        tb->clearBuffer();
+        tb->setFV(1, m_id);
+        insertRecord(tb);
+    }
+
+    void queryOne()
+    {
+        m_rs.clear();
+        query q;
+        int v = (rand() % 15000) + 1;
+        q.select(_T("id"), _T("name"), _T("group"))
+            .where(_T("id"), _T("<"), v + TRD_RECORDSET_COUNT);
+        m_atu->index(0).keyValue(v).read(m_rs, q);
+        q.reset();
+
+        // m_ate->index(0).join(m_rs,
+        // q.select(_T("comment")).optimize(queryBase::joinHasOneOrHasMany),
+        // _T("id"));
+
+        // Join group::name
+        /*recordset rs2;
+
+        q.select(_T("group_name"));
+        for (int i=0;i<m_rs.size();++i)
+                q.addSeekKeyValuePtr(m_rs[i][(short)0].ptr());
+        m_atg->table()->setQuery(&q);
+        m_atg->index(0).keyValue(0).read(rs2, q);
+        */
+        m_atg->index(0).join(m_rs, q.select(_T("group_name")), _T("group"));
+        if (m_rs.size() != TRD_RECORDSET_COUNT)
+            printf("query read error! id = %d size = %d\n", m_id, m_rs.size());
+    }
+
+public:
+    worker(int id, int loopCount, int functionNumber,
+           const connectParams& param, boost::barrier& sync)
+        : workerBase(id, loopCount, functionNumber, sync), m_parmas(param)
+    {
+        m_db = &m_db_real;
+    }
+
+    void initExecute()
+    {
+#ifdef USE_CONNECTION_POOL
+        m_db->use(&m_parmas);
+        const _TCHAR* tbName =
+            (m_functionNumber == TRD_READ_ONE) ? _T("user") : _T("cache");
+        m_tb = m_db->table(tbName);
+#else
+        try
+        {
+            m_db = createDatabaseObject();
+            connectOpen(m_db, m_parmas, true);
+            const _TCHAR* tbName =
+                (m_functionNumber == TRD_READ_ONE) ? _T("user") : _T("cache");
+            m_tb = openTable(m_db, tbName);
+            m_tb->setKeyNum(0);
+        }
+        catch (bzs::rtl::exception& e)
+        {
+            std::_tstring msg;
+            msg = *bzs::rtl::getMsg(e);
+            boost::mutex::scoped_lock lck(m_mutex);
+            std::tcout << _T("[ERROR] ") << msg.c_str() << std::endl;
+        }
+#endif // USE_CONNECTION_POOL
+        if (m_functionNumber == TRD_QUERY)
+        {
+            m_atu.reset(new activeTable(m_db, _T("user")));
+            m_atg.reset(new activeTable(m_db, _T("groups")));
+            m_ate.reset(new activeTable(m_db, _T("extention")));
+
+            _TCHAR tmp[30];
+            m_atu->alias(name_field_str(tmp), _T("name"));
+            m_atg->alias(_T("name"), _T("group_name"));
+        }
+    }
+
+    void endExecute()
+    {
+        m_tb.reset();
+#ifdef USE_CONNECTION_POOL
+        m_db->unUse();
+#else
+        m_db.reset();
+#endif
+    }
+
+    void doExecute()
+    {
+        try
+        {
+            if (m_functionNumber == TRD_READ_ONE)
+            {
+                for (int i = 0; i < m_loopCount; ++i)
+                    readOne(m_tb);
+            }
+            else if (m_functionNumber == TRD_INSERT_ONE)
+            {
+                for (int i = 0; i < m_loopCount; ++i)
+                    insertOne(m_tb);
+            }
+            else
+            {
+                for (int i = 0; i < m_loopCount; ++i)
+                    queryOne();
+            }
+        }
+
+        catch (bzs::rtl::exception& e)
+        {
+            std::_tstring msg;
+            msg = *bzs::rtl::getMsg(e);
+            boost::mutex::scoped_lock lck(m_mutex);
+            std::tcout << _T("[ERROR] ") << msg.c_str() << std::endl;
+        }
+
+        catch (...)
+        {
+            boost::mutex::scoped_lock lck(m_mutex);
+            std::cout << "worker error id = " << m_id << std::endl;
+        }
+    }
+};
+
+} // namespace transactd
+} // namespace worker
+} // namespace test
+} // namespace bzs
+
+#endif // BZS_TEST_BENCH_WORKERTRANSACTDIMPLE_H