transactd 1.2.0 → 2.0.0

data/source/global/ormsrcgen/srcgen.h

@@ -0,0 +1,72 @@
+#ifndef SRCGENH
+#define SRCGENH
+/*=================================================================
+   Copyright (C) 2014 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/db/protocol/tdap/client/table.h>
+#include <bzs/db/protocol/tdap/client/dbDef.h>
+#include <vector>
+#include "confParam.h"
+#include "fieldName.h"
+
+using namespace bzs::db::protocol::tdap;
+typedef std::vector<std::string> strings;
+
+class cppSrcGen
+{
+    const tabledef* m_tabledef;
+    conf_parmas& m_pm;
+    CFiledNameResolver m_fnames;
+    int typeNum(int type);
+    std::string typeName(int typeNum, int len);
+    std::string membaName(fielddef* fielddef);
+    void replace(std::string& source, const char* convTgtStr,
+                 const std::string& replaceStr);
+    std::string makeFdiMembaString();
+    std::string makeFdiResolverString();
+    std::string makeDataMembaString();
+    std::string makeDataMembaFuncString();
+    std::string makeDataMembaFuncDecString();
+    std::string makeDataMembaInitString();
+    std::string makeMapReadString();
+    std::string makeMapReadStringLine(int index);
+    std::string makeMapKeyCompString();
+    std::string makeMapKeyValueString();
+    std::string makeMapWriteString();
+    std::string makeMapWriteStringLine(int index);
+    std::string makeMapAutoIncString();
+    std::string makeMapKeyEnumString();
+
+    std::string makeNameSpaceBegin(const std::vector<std::string>& list);
+    std::string makeNameSpaceEnd(const std::vector<std::string>& list);
+    std::string makeIncludeGurdeString(bool data);
+    std::string makeFileName(bool data, bool header);
+    const char* typeString(int type, int size);
+    std::string membaNameSet(std::string s);
+    std::string membaNameGet(std::string s);
+    bool doMake(const std::string templeHeader, const std::string templeCpp,
+                bool data);
+
+public:
+    cppSrcGen(const tabledef* tabledef, conf_parmas& pm);
+
+    void make();
+};
+
+#endif // SRCGENH

data/source/global/ormsrcgen/template/fieldNameList_sample.txt

@@ -0,0 +1,2 @@
+customer_id=id
+customer_name=name

data/source/global/ormsrcgen/template/ormDataClass_template.cpp

@@ -0,0 +1,48 @@
+
+#pragma hdrstop
+#include "%className%.h"
+using namespace std;
+
+% nameSpaceBegin %
+
+    struct imple
+{
+    % datamemba % imple() : % menbaInit %
+};
+
+% className % :: % className % (void* owner)
+    : m_impl(new imple()){
+
+      }
+
+      %
+      className % :: % className % (const % className % &rt)
+    : m_impl(new imple())
+{
+    *m_impl = *(rt.m_impl);
+}
+
+% className % ::~ % className % () { delete m_impl; }
+
+% className % & % className % ::operator=(const % className % &rt)
+{
+    if (this != &rt)
+    {
+        *m_impl = *(rt.m_impl);
+    }
+    return *this;
+}
+
+% dataClassMembaFunc %
+
+    % className % * % className % ::create(void* owner)
+{
+    return new % className % (owner);
+}
+
+% className % *create(% className % _ptr_list & mdls, int)
+{
+    return % className % ::create(&mdls);
+}
+
+% nameSpaceEnd %

data/source/global/ormsrcgen/template/ormDataClass_template.h

@@ -0,0 +1,34 @@
+#ifndef % includegurde % H
+#define % includegurde % H
+
+#include <bzs/env/tstring.h>
+#include <boost/shared_ptr.hpp>
+#include <vector>
+#include <bzs/db/protocol/tdap/btrDate.h>
+namespace td = bzs::db::protocol::tdap;
+
+% nameSpaceBegin %
+
+    class % extern % % className %
+{
+  protected:
+    struct imple* m_impl;
+
+  public:
+    % className % (void* owner);
+    % className % (const % className % &rt);
+    ~ % className % ();
+    % className % &operator=(const % className % &rt);
+    % dataClassMembaFuncDec % static % className % *create(void* owner);
+};
+
+typedef boost::shared_ptr< % className % > % className % _ptr;
+typedef std::vector< % className % _ptr> % className % _ptr_list;
+typedef std::vector< % className % *> % className % _list;
+typedef boost::shared_ptr< % className % _list> % className % _list_ptr;
+
+% className % *create(% className % _ptr_list & mdls, int);
+
+% nameSpaceEnd %
+
+#endif //%includegurde%H

data/source/global/ormsrcgen/template/ormMapClass_template.cpp

@@ -0,0 +1,51 @@
+
+#pragma hdrstop
+#include "%className%_map.h"
+#include <bzs/env/tstring.h>
+using namespace std;
+using namespace bzs::db::protocol::tdap::client;
+
+% nameSpaceMapBegin %
+
+    /*  class %className%_fdi */
+    void % className % _fdi::init(table* tb){ % fdiResolver % }
+
+    % className % _fdi* createFdi(% className % _fdi*)
+{
+    return new % className % _fdi();
+}
+void destroyFdi(% className % _fdi * p) { delete p; }
+void initFdi(% className % _fdi * fdi, td::client::table * tb)
+{
+    fdi->init(tb);
+}
+
+/*  class %className%_orm */
+bool % className %
+    _orm::compKeyValue(% className % &l, % className % &r, int keyNum) const
+{
+    % keyComp %
+}
+
+void % className %
+    _orm::setKeyValues(% className % &m, const fields& fds, int keyNum)
+{
+    % writeKeyValue %
+}
+
+void % className %
+    _orm::writeMap(% className % &m, const fields& fds, int optipn)
+{
+    % write %
+}
+
+void % className %
+    _orm::readMap(% className % &m, const fields& fds, int optipn)
+{
+    % read %
+}
+
+void % className % _orm::readAuntoincValue(% className % &m, const fields& fds,
+                                           int optipn){ % autoinc % }
+
+% nameSpaceMapEnd %

data/source/global/ormsrcgen/template/ormMapClass_template.h

@@ -0,0 +1,62 @@
+#ifndef % includegurde % _MAPH
+#define % includegurde % _MAPH
+
+#include "%className%.h"
+#include <bzs/db/protocol/tdap/client/trdboostapi.h>
+
+% nameSpaceMapBegin %
+
+    class % extern % % className % _fdi
+{
+  public:
+    % fdiMemba %
+
+        void init(td::client::table * tb);
+};
+
+% className % _fdi* createFdi(% className % _fdi*);
+void destroyFdi(% className % _fdi * p);
+void initFdi(% className % _fdi * fdi, td::client::table * tb);
+
+class % extern % % className % _orm
+{
+    const % className % _fdi& m_fdi;
+
+    // noncopyable
+    % className % _orm(const % className % _orm&);
+    % className % _orm& operator=(const % className % _orm&);
+
+  public:
+    enum key
+    {
+        % keyEnum %
+    };
+    % className % _orm(const % className % _fdi & fdi) : m_fdi(fdi) {}
+    bool compKeyValue(% className % &l, % className % &r, int keyNum) const;
+    void setKeyValues(% className % &m, const td::client::fields& fds,
+                      int keyNum);
+    void writeMap(% className % &m, const td::client::fields& fds, int optipn);
+    void readMap(% className % &m, const td::client::fields& fds, int optipn);
+    void readAuntoincValue(% className % &m, const td::client::fields& fds,
+                           int optipn);
+    const _TCHAR* getTableName() { return _T("%tableName%"); }
+
+    /* must define mdl_typename */
+    typedef % className % mdl_typename;
+
+    /* must define  fdi_typename
+     If fdi is not used, It is considered as default
+                                        "typedef fdibase fdi_typename"
+     If using different FDI(s),In this case, the class of fdi is specified like
+      "activeTable<group, group_fdi>" at the instance creation of activeTable.
+    */
+    typedef % className % _fdi fdi_typename;
+
+    /* if use not vector collection, please spcecify your_collection_type */
+    /* typedef mdlsHandler<%className%_orm, your_collection_type>
+                                               collection_orm_typename;*/
+};
+
+% nameSpaceMapEnd %
+
+#endif //%includegurde%_ORMH

data/source/global/ormsrcgen/template/template.cnf

@@ -0,0 +1,38 @@
+###                                                             ###
+###  Transactd O/R mapper source code generator configurations  ###
+###                                                             ###
+
+## Programing language of the source code which will be generated
+lang = cpp
+
+## Number of the template files
+files = 2
+
+## Paths of the template files
+##  Remove extensions (ex:".cpp" ".h") if the template is C++.
+file1 = ormDataClass_template
+file2 = ormMapClass_template
+
+## Output directory
+saveDir = 
+
+## Prefix of setter
+setPrefix = set
+
+## Prefix of getter
+getPrefix = get
+
+## Export keyword macro for export classes
+##  Uncomment to enable the macro which wraps export keywords
+##  (such as __declspec(dllexport)). If you use the generated
+##  classes in DLL, uncomment below.
+#externWord=AGRPACK
+
+## Path of the file which includes field aliases list
+#fieldRenameList = c:\xxx or ~/xxx
+
+## Namespace of the data class (ex:name_space = bzs)
+#name_space = 
+
+## Namespace of the map class (ex:name_space = bzs/map)
+#name_space_map = 

data/source/global/querystmts/querystmts.cpp

@@ -0,0 +1,237 @@
+/*=================================================================
+   Copyright (C) 2014 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.
+=================================================================*/
+#pragma hdrstop
+
+#include <bzs/db/protocol/tdap/client/serializer.h>
+#include <bzs/db/protocol/tdap/client/databaseManager.h>
+#include <bzs/rtl/benchmark.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <locale.h>
+#include <iostream>
+#include <boost/program_options.hpp>
+
+#ifdef __BCPLUSPLUS__
+#define BZS_LINK_BOOST_PROGRAM_OPTIONS
+#include <bzs/env/boost_bcb_link.h>
+#endif
+
+using namespace bzs::db::protocol::tdap::client;
+using namespace boost::program_options;
+
+//---------------------------------------------------------------------------
+struct cmd_parmas
+{
+    std::string query;
+    std::string ivalues;
+    bool print;
+    cmd_parmas() : print(false) {}
+};
+
+enum eEncoding
+{
+    eEAuto = 0,
+    eEAnsi = 1,
+    eEUnicode = 2,
+    eEUtf8 = 3
+};
+
+void analyzeBom(unsigned char* p, eEncoding& type)
+{
+    if ((p[0] == 0xFF) && (p[1] == 0xFE))
+        type = eEUnicode;
+    else if ((p[0] == 0xEF) && (p[1] == 0xBB) && (p[2] == 0xBF))
+        type = eEUtf8;
+    else
+        type = eEAnsi;
+}
+
+bool readInputValues(const char* filename,
+                     std::vector<std::_tstring>& inputValues)
+{
+    // Linux            : A input file encording is utf8.
+    // Windows multibyte: A input file encording is utf8.
+    // Windows unicode  : A input file encording is locale charset.
+    FILE* fp = fopen(filename, "rt");
+    if (!fp)
+    {
+        _ftprintf(stderr, _T("Error ! Can not open the input file (%s)\n"),
+                  filename);
+        return false;
+    }
+    char tmp[5];
+    eEncoding encodeing = eEAnsi;
+    fseek(fp, 0L, SEEK_SET);
+
+    if (fgets(tmp, 4, fp))
+    {
+        analyzeBom((unsigned char*)tmp, encodeing);
+        if (encodeing == eEAnsi)
+            fseek(fp, 0L, SEEK_SET);
+        else if (encodeing == eEUnicode)
+            fseek(fp, 2L, SEEK_SET);
+        else if (encodeing == eEUtf8)
+            fseek(fp, 3L, SEEK_SET);
+    }
+    if ((encodeing == eEAnsi) || (encodeing == eEUtf8))
+    {
+        char buf[512];
+        while (fgets(buf, 512, fp))
+        {
+            buf[strlen(buf) - 1] = 0x00;
+#ifdef _UNICODE
+            wchar_t wbuf[1024];
+            UINT codePage = (encodeing == eEUtf8) ? CP_UTF8 : CP_ACP;
+            MultiByteToWideChar(codePage,
+                                (codePage == CP_UTF8) ? 0 : MB_PRECOMPOSED, buf,
+                                -1, wbuf, 1024);
+            inputValues.push_back(wbuf);
+#else
+            inputValues.push_back(buf);
+#endif //_UNICODE
+        }
+    }
+    else
+    {
+#ifndef _WIN32
+        _ftprintf(
+            stderr,
+            _T("Error ! Can not read the unicode encording input file(%s).\n"),
+            filename);
+#else
+        wchar_t wbuf[512];
+        while (fgetws(wbuf, 512, fp))
+        {
+            wbuf[wcslen(wbuf) - 1] = 0x00;
+#ifdef _UNICODE
+            inputValues.push_back(wbuf);
+#else
+            char buf[1024];
+            WideCharToMultiByte(CP_UTF8, 0, wbuf, -1, buf, 1024, NULL, NULL);
+            inputValues.push_back(buf);
+#endif //_UNICODE
+        }
+
+#endif
+    }
+    fclose(fp);
+    return true;
+}
+
+void printResult(recordset& rs)
+{
+    const fielddefs& fields = *rs.fieldDefs();
+    for (int j = 0; j < (int)fields.size(); ++j)
+        _tprintf(_T("%s\t"), fields[j].name());
+    _tprintf(_T("\n"));
+
+    for (int i = 0; i < (int)rs.size(); ++i)
+    {
+        row& m = rs[i];
+        for (int j = 0; j < (int)m.size(); ++j)
+        {
+            _tprintf(_T("%s\t"), m[(short)j].c_str());
+            if (j == (int)m.size() - 1)
+                _tprintf(_T("\n"));
+        }
+    }
+}
+
+void execute(queryStatements* qs, recordset* rs,
+             std::vector<std::_tstring>* values)
+{
+    qs->execute(*rs, values);
+}
+
+#pragma argsused
+int _tmain(int argc, _TCHAR* argv[])
+{
+#ifdef _WIN32
+    // set locale to current user locale.
+    std::locale::global(std::locale(""));
+#endif
+
+    // setup command line options
+    cmd_parmas pm;
+    options_description opt("command line option");
+    opt.add_options()("query,q", value<std::string>(&pm.query),
+                      "prepared query file path")(
+        "values,v", value<std::string>(&pm.ivalues),
+        "prepared input values file path")("print,p", value<bool>(&pm.print),
+                                           "print out result");
+    variables_map values;
+    try
+    {
+        store(parse_command_line(argc, argv, opt), values);
+        notify(values);
+        if (!values.count("query")
+             /*|| !values.count("values")*/)
+        {
+            std::cout << opt << std::endl;
+            return 1;
+        }
+
+        disbDbManager dbm;
+        // boost::shared_ptr<queryStatements> qs(queryStatements::create(dbm),
+        //	boost::bind(&queryStatements::release, qs.get()));
+        queryStatements qs(dbm);
+        recordset rs;
+        std::vector<std::_tstring> inputValues;
+
+        if (values.count("values") &&
+            !readInputValues(pm.ivalues.c_str(), inputValues))
+            return 1;
+
+        const _TCHAR* path;
+#ifdef _UNICODE
+        wchar_t buf[2048];
+        MultiByteToWideChar(CP_UTF8, 0, pm.query.c_str(), -1, buf, 2048);
+        path = buf;
+#else
+        path = pm.query.c_str();
+#endif
+        qs.load(path);
+        // bzs::rtl::benchmark::report2(boost::bind(execute, &qs, &rs,
+        // &inputValues), "execute");
+        bzs::rtl::benchmark::start();
+        execute(&qs, &rs, &inputValues);
+        int t = bzs::rtl::benchmark::stop();
+        if (pm.print)
+            printResult(rs);
+        char tmp[120];
+        sprintf_s(tmp, 120, "OK, %lu record(s) :", rs.size());
+        bzs::rtl::benchmark::showTimes(t, tmp);
+
+        fflush(stdout);
+
+        return 0;
+    }
+
+    catch (bzs::rtl::exception& e)
+    {
+        _ftprintf(stderr, _T("Error ! %s\n"), getMsg(e)->c_str());
+    }
+
+    catch (std::exception& e)
+    {
+        std::cout << e.what() << std::endl;
+    }
+    return 1;
+}
+//---------------------------------------------------------------------------

data/source/global/tdclatl/ConnectParams.cpp

@@ -0,0 +1,77 @@
+/*=================================================================
+   Copyright (C) 2014 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 "stdafx.h"
+#include "ConnectParams.h"
+
+using namespace bzs::db::protocol::tdap::client;
+
+STDMETHODIMP CConnectParams::Init(BSTR protocol, BSTR hostOrIp, BSTR dbname,
+                                  BSTR schemaTable)
+{
+    if (m_param)
+        delete m_param;
+    m_param = new connectParams(protocol, hostOrIp, dbname, schemaTable);
+    return S_OK;
+}
+STDMETHODIMP CConnectParams::put_Uri(BSTR val)
+{
+    if (m_param)
+        delete m_param;
+    m_param = new connectParams(val);
+    return S_OK;
+}
+
+STDMETHODIMP CConnectParams::get_Uri(BSTR* retVal)
+{
+    if (m_param)
+    {
+        CComBSTR ret;
+        ret = m_param->uri();
+        *retVal = ret.Copy();
+    }
+    return S_OK;
+}
+
+STDMETHODIMP CConnectParams::put_Mode(short val)
+{
+    if (m_param)
+        m_param->setMode((char_td)val);
+    return S_OK;
+}
+
+STDMETHODIMP CConnectParams::get_Mode(short* retVal)
+{
+    if (m_param)
+        *retVal = m_param->mode();
+    return S_OK;
+}
+
+STDMETHODIMP CConnectParams::put_Type(short val)
+{
+    if (m_param)
+        m_param->setType(val);
+    return S_OK;
+}
+
+STDMETHODIMP CConnectParams::get_Type(short* retVal)
+{
+    if (m_param)
+        *retVal = m_param->type();
+    return S_OK;
+}

data/source/global/tdclatl/ConnectParams.h

@@ -0,0 +1,70 @@
+#pragma once
+/*=================================================================
+   Copyright (C) 2014 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 "resource.h"
+#include "tdclatl_i.h"
+#include <bzs/db/protocol/tdap/client/trdboostapi.h>
+
+using namespace ATL;
+
+class ATL_NO_VTABLE CConnectParams
+    : public CComObjectRootEx<CComSingleThreadModel>,
+      public CComCoClass<CConnectParams, &CLSID_ConnectParams>,
+      public IDispatchImpl<IConnectParams, &IID_IConnectParams,
+                           &LIBID_transactd, /* wMajor = */ 1, /* wMinor = */ 0>
+{
+
+    bzs::db::protocol::tdap::client::connectParams* m_param;
+
+public:
+    CConnectParams() : m_param(NULL) {}
+
+    bzs::db::protocol::tdap::client::connectParams* internalConnectParams()
+    {
+        return m_param;
+    }
+    DECLARE_REGISTRY_RESOURCEID(IDR_CONNECTPARAM)
+
+    BEGIN_COM_MAP(CConnectParams)
+    COM_INTERFACE_ENTRY(IConnectParams)
+    COM_INTERFACE_ENTRY(IDispatch)
+    END_COM_MAP()
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    HRESULT FinalConstruct()
+    {
+        delete m_param;
+        return S_OK;
+    }
+
+    void FinalRelease(){};
+
+public:
+    STDMETHOD(Init)(BSTR protocol, BSTR hostOrIp, BSTR dbname,
+                    BSTR schemaTable);
+    STDMETHOD(put_Uri)(BSTR val);
+    STDMETHOD(get_Uri)(BSTR* retVal);
+    STDMETHOD(put_Mode)(short val);
+    STDMETHOD(get_Mode)(short* retVal);
+    STDMETHOD(put_Type)(short val);
+    STDMETHOD(get_Type)(short* retVal);
+};
+
+OBJECT_ENTRY_AUTO(__uuidof(ConnectParams), CConnectParams)