transactd 1.2.0 → 2.0.0

data/source/bzs/db/protocol/tdap/client/serializer.cpp

@@ -0,0 +1,1288 @@
+/*=================================================================
+   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 "serializer.h"
+
+#pragma package(smart_init)
+#ifdef BCB_32
+#pragma option push
+#pragma option -Vbr-
+#pragma option -vi-
+#endif
+
+#include <bzs/db/protocol/tdap/client/groupQuery.h>
+#include <bzs/db/protocol/tdap/client/activeTable.h>
+#include <boost/serialization/vector.hpp>
+#include <boost/serialization/shared_ptr.hpp>
+#include <boost/serialization/export.hpp>
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+#include <fstream>
+
+#ifdef __BCPLUSPLUS__
+#define BZS_LINK_BOOST_SERIALIZATION
+#include <bzs/env/boost_bcb_link.h>
+#endif
+
+using namespace boost::archive;
+using namespace boost::serialization;
+
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::sum, "sum");
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::count, "count");
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::avg, "avg");
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::min, "min");
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::max, "max");
+
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::readStatement,
+                        "readStatement");
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::readHasMany,
+                        "readHasMany");
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::orderByStatement,
+                        "orderByStatement");
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::matchByStatement,
+                        "matchByStatement");
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::groupByStatement,
+                        "groupByStatement");
+BOOST_CLASS_EXPORT_GUID(bzs::db::protocol::tdap::client::reverseOrderStatement,
+                        "reverseOrderStatement");
+
+BOOST_CLASS_VERSION(bzs::db::protocol::tdap::client::groupFuncBase, 1)
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+client::query* replaceQueryParams(client::query* tq, client::query& tmpq,
+                                  struct queryStatementsImple* parent);
+
+void toU8(std::_tstring& src, std::string& dst)
+{
+#ifdef _UNICODE
+    char buf[2048];
+    WideCharToMultiByte(CP_UTF8, 0, src.c_str(), -1, buf, 2048, NULL, NULL);
+    dst = buf;
+
+#else
+    dst = src;
+#endif
+}
+
+void fromU8(std::string& src, std::_tstring& dst)
+{
+#ifdef _UNICODE
+    wchar_t buf[2048];
+    MultiByteToWideChar(CP_UTF8, 0, src.c_str(), -1, buf, 2048);
+    dst = buf;
+#else
+    dst = src;
+#endif
+}
+
+template <class Archive>
+void serialize_string(Archive& ar, const char* name, std::_tstring& v)
+{
+    std::string s;
+    if (!Archive::is_loading::value)
+        toU8(v, s);
+    ar& boost::serialization::make_nvp(name, s);
+    if (Archive::is_loading::value)
+        fromU8(s, v);
+}
+
+template <class Archive>
+void serialize(Archive&, executable&, const unsigned int)
+{
+}
+
+template <class Archive>
+void serialize(Archive& ar, sortField& q, const unsigned int)
+{
+
+    serialize_string(ar, "name", q.name);
+    ar& boost::serialization::make_nvp("asc", q.asc);
+}
+
+template <class Archive>
+void serialize(Archive& ar, sortFields& q, const unsigned int)
+{
+    int count = (int)q.m_params.size();
+    ar& boost::serialization::make_nvp("count", count);
+    for (int i = 0; i < count; i++)
+    {
+        if (Archive::is_loading::value)
+        {
+            sortField f;
+            ar& boost::serialization::make_nvp("field", f);
+            q.m_params.push_back(f);
+        }
+        else
+            ar& boost::serialization::make_nvp("field", q.m_params[i]);
+    }
+}
+
+template <class Archive>
+void serialize(Archive& ar, groupByStatement& q, const unsigned int /*version*/)
+{
+    boost::serialization::base_object<executable>(q);
+    ar& boost::serialization::make_nvp(
+        "keyFields", boost::serialization::base_object<fieldNames>(q));
+    ar& boost::serialization::make_nvp("functions", *q.m_statements);
+}
+
+template <class Archive>
+void serialize(Archive& ar, matchByStatement& q, const unsigned int /*version*/)
+{
+    boost::serialization::base_object<executable>(q);
+    ar& make_nvp("matchByStatement",
+                 boost::serialization::base_object<recordsetQuery>(q));
+}
+
+template <class Archive>
+void serialize(Archive& ar, orderByStatement& q, const unsigned int /*version*/)
+{
+    boost::serialization::base_object<executable>(q);
+    ar& boost::serialization::make_nvp("sortFields", *q.m_sortFields);
+}
+
+template <class Archive>
+void serialize(Archive& /*ar*/, reverseOrderStatement& q,
+               const unsigned int /*version*/)
+{
+    boost::serialization::base_object<executable>(q);
+}
+
+template <class Archive>
+void serialize(Archive& ar, readStatement& q, const unsigned int /*version*/)
+{
+    boost::serialization::base_object<executable>(q);
+    ar& boost::serialization::make_nvp(
+        "keyFields", boost::serialization::base_object<fieldNames>(q));
+    ar& boost::serialization::make_nvp(
+        "query", boost::serialization::base_object<query>(q));
+    ar& boost::serialization::make_nvp("params", *q.internalPtr());
+}
+
+template <class Archive>
+void serialize(Archive& ar, readHasMany& q, const unsigned int /*version*/)
+{
+
+    ar& boost::serialization::make_nvp(
+        "readStatement", boost::serialization::base_object<readStatement>(q));
+    ar& boost::serialization::make_nvp("params", *q.internalPtr());
+}
+
+template <class Archive>
+void serialize(Archive& ar, queryBase& q, const unsigned int version)
+{
+    split_free(ar, q, version);
+}
+
+template <class Archive>
+void save(Archive& ar, const queryBase& q, const unsigned int /*version*/)
+{
+    std::_tstring s = q.toString();
+
+    serialize_string(ar, "queryString", s);
+    int v = q.getReject();
+    ar& make_nvp("reject", v);
+    v = q.getLimit();
+    ar& make_nvp("limit", v);
+    v = q.getOptimize();
+    ar& make_nvp("optimize", v);
+    v = q.isBookmarkAlso();
+    ar& make_nvp("boolmarkAlso", v);
+    v = q.isAll();
+    ar& make_nvp("isAll", v);
+}
+
+template <class Archive>
+void load(Archive& ar, queryBase& q, const unsigned int /*version*/)
+{
+    std::_tstring s;
+    int v;
+
+    q.reset();
+    serialize_string(ar, "queryString", s);
+    q.queryString(s.c_str());
+
+    ar& make_nvp("reject", v);
+    q.reject(v);
+
+    ar& make_nvp("limit", v);
+    q.limit(v);
+
+    ar& make_nvp("optimize", v);
+    q.optimize((queryBase::eOptimize)v);
+
+    ar& make_nvp("boolmarkAlso", v);
+    q.bookmarkAlso(v != 0);
+
+    ar& make_nvp("isAll", v);
+    if (v)
+        q.all();
+}
+
+template <class Archive>
+void serialize(Archive& ar, fieldNames& q, const unsigned int /*version*/)
+{
+    int count = q.count();
+    ar& boost::serialization::make_nvp("count", count);
+    std::_tstring s;
+    for (int i = 0; i < count; i++)
+    {
+        if (Archive::is_loading::value)
+        {
+            serialize_string(ar, "value", s);
+            q.addValue(s.c_str());
+        }
+        else
+        {
+            s = q.getValue(i);
+            serialize_string(ar, "value", s);
+        }
+    }
+}
+
+template <class Archive>
+void serialize(Archive& ar, query& q, const unsigned int /*version*/)
+{
+    ar& make_nvp("readQuery", boost::serialization::base_object<queryBase>(q));
+}
+
+template <class Archive>
+void serialize(Archive& ar, recordsetQuery& q, const unsigned int /*version*/)
+{
+    queryBase* qq = q.internalQuery();
+    ar& make_nvp("recordsetQuery", *qq);
+}
+
+template <class Archive>
+void serialize(Archive& ar, groupFuncBase& q, const unsigned int ver)
+{
+    ar& boost::serialization::make_nvp(
+        "query", boost::serialization::base_object<recordsetQuery>(q));
+
+    fieldNames& fns = q.targetNames();
+    if (ver >= 1)
+        ar& make_nvp("targetNames", fns);
+
+    std::_tstring s;
+
+    if (Archive::is_loading::value)
+    {
+        // For compatibility
+        if (ver < 1)
+        {
+            serialize_string(ar, "targetName", s);
+            q.targetNames().addValue(s.c_str());
+        }
+        serialize_string(ar, "resultName", s);
+        q.setResultName(s.c_str());
+    }
+    else
+    {
+        if (q.resultName())
+            s = q.resultName();
+        else
+            s = _T("");
+        serialize_string(ar, "resultName", s);
+    }
+}
+
+template <class Archive>
+void serialize(Archive& ar, sum& q, const unsigned int /*version*/)
+{
+    ar& make_nvp("param", boost::serialization::base_object<groupFuncBase>(q));
+}
+
+template <class Archive>
+void serialize(Archive& ar, count& q, const unsigned int /*version*/)
+{
+    ar& make_nvp("param", boost::serialization::base_object<groupFuncBase>(q));
+}
+
+template <class Archive>
+void serialize(Archive& ar, avg& q, const unsigned int /*version*/)
+{
+    ar& make_nvp("param", boost::serialization::base_object<groupFuncBase>(q));
+}
+
+template <class Archive>
+void serialize(Archive& ar, min& q, const unsigned int /*version*/)
+{
+    ar& make_nvp("param", boost::serialization::base_object<groupFuncBase>(q));
+}
+
+template <class Archive>
+void serialize(Archive& ar, max& q, const unsigned int /*version*/)
+{
+    ar& make_nvp("param", boost::serialization::base_object<groupFuncBase>(q));
+}
+
+template <class Archive>
+void serialize(Archive& ar, groupQuery& q, const unsigned int /*version*/)
+{
+    fieldNames& v = const_cast<fieldNames&>(q.getKeyFields());
+    ar& make_nvp("keyFields", v);
+}
+
+struct aliasPair
+{
+    std::_tstring first;
+    std::_tstring second;
+    aliasPair() {}
+    aliasPair(const _TCHAR* f, const _TCHAR* s) : first(f), second(s) {}
+};
+
+typedef aliasPair alias_type;
+
+template <class Archive>
+void serialize(Archive& ar, alias_type& q, const unsigned int /*version*/)
+{
+    std::_tstring s = q.first;
+    std::_tstring s2 = q.second;
+    serialize_string(ar, "first", s);
+    serialize_string(ar, "second", s2);
+    if (Archive::is_loading::value)
+    {
+        q.first = s;
+        q.second = s2;
+    }
+}
+
+//---------------------------------------------------------------------------
+//   class executable
+//---------------------------------------------------------------------------
+void executable::release()
+{
+    delete this;
+};
+
+//---------------------------------------------------------------------------
+//   class groupByStatement
+//---------------------------------------------------------------------------
+class prepairedValues
+{
+    const std::vector<std::_tstring>* m_values;
+    mutable int m_index;
+
+public:
+    inline void setValues(const std::vector<std::_tstring>* values)
+    {
+        m_values = values;
+        m_index = 0;
+    }
+
+    const _TCHAR* replace(const _TCHAR* v) const
+    {
+        if (_tcscmp(v, _T("?")) == 0)
+        {
+            if (m_index >= (int)m_values->size())
+                THROW_BZS_ERROR_WITH_MSG(_T("Too few values for prepair."));
+            return (*m_values)[m_index++].c_str();
+        }
+        return v;
+    }
+};
+
+//---------------------------------------------------------------------------
+//   class groupByStatement
+//---------------------------------------------------------------------------
+groupByStatement* groupByStatement::create()
+{
+    return new groupByStatement();
+}
+
+groupByStatement::groupByStatement()
+    : fieldNames(), m_statements(new std::vector<groupFuncBase*>())
+{
+}
+
+groupByStatement::~groupByStatement()
+{
+    reset();
+    delete m_statements;
+}
+
+groupFuncBase& groupByStatement::addFunction(eFunc v,
+                                             const fieldNames& targetNames,
+                                             const _TCHAR* resultName)
+{
+    groupFuncBase* func;
+    switch (v)
+    {
+    case fsum:
+        func = new client::sum(targetNames, resultName);
+        break;
+    case fcount:
+        func = new client::count(resultName);
+        break;
+    case favg:
+        func = new client::avg(targetNames, resultName);
+        break;
+    case fmin:
+        func = new client::min(targetNames, resultName);
+        break;
+    case fmax:
+        func = new client::max(targetNames, resultName);
+        break;
+    };
+    m_statements->push_back(func);
+    return *func;
+}
+
+groupFuncBase& groupByStatement::function(int index)
+{
+    assert(index >= 0 && index < (int)m_statements->size());
+    return *((*m_statements)[index]);
+}
+
+groupByStatement& groupByStatement::reset()
+{
+    for (int i = 0; i < (int)m_statements->size(); ++i)
+        delete ((*m_statements)[i]);
+    m_statements->clear();
+    fieldNames::reset();
+    return *this;
+}
+
+int groupByStatement::size() const
+{
+    return (int)m_statements->size();
+}
+
+void groupByStatement::execute(recordset& rs)
+{
+    const _TCHAR* keys[8] = { NULL };
+    for (int i = 0; i < count(); ++i)
+        keys[i] = getValue(i);
+    groupQuery q;
+    q.keyField(keys[0], keys[1], keys[2], keys[3], keys[4], keys[5], keys[6],
+               keys[7]);
+    std::vector<boost::shared_ptr<groupFuncBase> > statements;
+    for (int i = 0; i < (int)m_statements->size(); ++i)
+    {
+        boost::shared_ptr<groupFuncBase> p((*m_statements)[i]->clone());
+        statements.push_back(p);
+        query* pq = p->internalQuery();
+        replaceQueryParams(NULL, *pq, m_parent);
+        q.addFunction(p.get());
+    }
+    rs.groupBy(q);
+}
+
+//---------------------------------------------------------------------------
+//   class matchByStatement
+//---------------------------------------------------------------------------
+matchByStatement* matchByStatement::create()
+{
+    return new matchByStatement();
+}
+
+void matchByStatement::execute(recordset& rs)
+{
+    client::query q;
+    client::query* ret = replaceQueryParams(internalQuery(), q, m_parent);
+    if (ret != internalQuery())
+    {
+        recordsetQuery rq;
+        *rq.internalQuery() = *ret;
+        rs.matchBy(rq);
+    }
+    else
+        rs.matchBy(*this);
+}
+
+//---------------------------------------------------------------------------
+//   class orderByStatement
+//---------------------------------------------------------------------------
+orderByStatement* orderByStatement::create()
+{
+    return new orderByStatement();
+}
+
+orderByStatement::orderByStatement() : m_sortFields(new sortFields())
+{
+}
+
+orderByStatement::~orderByStatement()
+{
+    delete m_sortFields;
+}
+
+void orderByStatement::execute(recordset& rs)
+{
+    rs.orderBy(*m_sortFields);
+}
+
+void orderByStatement::add(const _TCHAR* name, bool asc)
+{
+    m_sortFields->add(name, asc);
+}
+
+int orderByStatement::size() const
+{
+    return (int)m_sortFields->size();
+}
+
+const sortField& orderByStatement::get(int index) const
+{
+    return (*m_sortFields)[index];
+}
+
+orderByStatement& orderByStatement::reset()
+{
+    m_sortFields->clear();
+    return *this;
+}
+
+//---------------------------------------------------------------------------
+//   class reverseOrderStatement
+//---------------------------------------------------------------------------
+reverseOrderStatement* reverseOrderStatement::create()
+{
+    return new reverseOrderStatement();
+}
+
+void reverseOrderStatement::execute(recordset& rs)
+{
+    rs.reverse();
+};
+
+//---------------------------------------------------------------------------
+//        struct queryStatementsImple
+//---------------------------------------------------------------------------
+struct queryStatementsImple
+{
+    idatabaseManager* dbm;
+    database* db;
+    int id;
+    std::_tstring title;
+    std::_tstring description;
+    std::vector<executable*> statements;
+    prepairedValues pv;
+
+    inline queryStatementsImple() : dbm(NULL), db(NULL){};
+
+    ~queryStatementsImple() { reset(); }
+
+    void reset()
+    {
+        for (int i = 0; i < (int)statements.size(); ++i)
+            statements[i]->release();
+        statements.clear();
+        title = _T("");
+        description = _T("");
+        id = 0;
+    }
+
+    inline void execute(recordset& rs, executeListner* listner)
+    {
+        for (size_t i = 0; i < statements.size(); ++i)
+        {
+            statements[i]->execute(rs);
+            if (listner)
+                listner->onExecuted(statements[i], rs);
+        }
+    }
+
+private:
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version);
+};
+
+//---------------------------------------------------------------------------
+//   struct queryStatementImple
+//---------------------------------------------------------------------------
+struct queryStatementImple
+{
+    struct queryStatementsImple* parent;
+    std::_tstring database;
+    std::_tstring table;
+    int option;
+    fieldNames* keyFields;
+    client::query* query;
+    readStatement::eReadType readType;
+    short index;
+    // int dbIndex;
+
+    std::vector<alias_type> aliases;
+
+    queryStatementImple(){};
+
+    void alias(const _TCHAR* src, const _TCHAR* dst)
+    {
+        aliases.push_back(alias_type(src, dst));
+    }
+
+    inline void use(idatabaseManager* dbm, const connectParams* p)
+    {
+        /*dbIndex = dbm->findDbIndex(p);
+        if (dbIndex==-1)
+                return false;*/
+        dbm->use(p);
+        // return dbm->db()->isOpened();
+    }
+
+    inline void use(client::database* db, const connectParams* p)
+    {
+        if (db && db->isOpened())
+            return;
+        if (p)
+            connectOpen(db, *p, false);
+    }
+
+    template <class Database> inline void execute(recordset& rs, Database db)
+    {
+
+        const _TCHAR* keys[8] = { NULL };
+        for (int i = 0; i < keyFields->count(); ++i)
+            keys[i] = parent->pv.replace(keyFields->getValue(i));
+
+        client::query q;
+        client::query* tq = replaceQueryParams(query, q, parent);
+
+        if (database != _T(""))
+        {
+            connectParams p(database.c_str());
+            use(db, &p);
+        }
+        else
+            use(db, NULL);
+
+        /*if (!isOpened(db, p))      //Change current db in dbm
+                connect(db, p, false); //Change current db in dbm
+        */
+
+        activeTable at(db, table.c_str());
+        at.index(index).option(option);
+        for (int i = 0; i < (int)aliases.size(); ++i)
+            at.alias(aliases[i].first.c_str(), aliases[i].second.c_str());
+        if (readType == readStatement::opRead)
+        {
+            at.keyValue(keys[0], keys[1], keys[2], keys[3], keys[4], keys[5],
+                        keys[6], keys[7]);
+            at.read(rs, *tq);
+        }
+        else if (readType == readStatement::opJoin)
+            at.join(rs, *tq, keys[0], keys[1], keys[2], keys[3], keys[4],
+                    keys[5], keys[6], keys[7]);
+        else if (readType == readStatement::opOuterJoin)
+            at.outerJoin(rs, *tq, keys[0], keys[1], keys[2], keys[3], keys[4],
+                         keys[5], keys[6], keys[7]);
+    }
+
+private:
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version)
+    {
+        ar& make_nvp("readType", readType);
+        serialize_string(ar, "database", database);
+        serialize_string(ar, "table", table);
+        ar& make_nvp("index", index);
+        int count = (int)aliases.size();
+        ar& boost::serialization::make_nvp("alias_count", count);
+        alias_type a;
+        for (int i = 0; i < count; i++)
+        {
+            if (!Archive::is_loading::value)
+                a = aliases[i];
+            ar& make_nvp("alias", a);
+            if (Archive::is_loading::value)
+                aliases.push_back(a);
+        }
+    }
+};
+
+// template <class Archive>
+// void serialize(Archive& ar, readStatement& q, const unsigned int version);
+
+template <class Archive>
+void queryStatementsImple::serialize(Archive& ar, const unsigned int version)
+{
+    ar& make_nvp("id", id);
+    serialize_string(ar, "title", title);
+    serialize_string(ar, "description", description);
+    ar& make_nvp("items", statements);
+    if (Archive::is_loading::value)
+    {
+        for (int i = 0; i < (int)statements.size(); ++i)
+        {
+            readStatement* p = dynamic_cast<readStatement*>(statements[i]);
+            if (p)
+                p->m_impl->parent = this;
+            else
+            {
+                matchByStatement* pm =
+                    dynamic_cast<matchByStatement*>(statements[i]);
+                if (pm)
+                    pm->m_parent = this;
+                else
+                {
+                    groupByStatement* pg =
+                        dynamic_cast<groupByStatement*>(statements[i]);
+                    if (pg)
+                        pg->m_parent = this;
+                }
+            }
+        }
+    }
+}
+
+//---------------------------------------------------------------------------
+//        class readStatement
+//---------------------------------------------------------------------------
+readStatement* readStatement::create()
+{
+    return new readStatement();
+}
+
+readStatement::readStatement() : m_impl(new queryStatementImple)
+{
+    m_impl->keyFields = this;
+    m_impl->query = this;
+}
+
+readStatement::~readStatement()
+{
+    delete m_impl;
+}
+
+const _TCHAR* readStatement::getDatabaseUri() const
+{
+    return m_impl->database.c_str();
+}
+
+readStatement& readStatement::databaseUri(const _TCHAR* v)
+{
+    m_impl->database = v;
+    return *this;
+}
+
+const _TCHAR* readStatement::getTableName() const
+{
+    return m_impl->table.c_str();
+}
+
+readStatement& readStatement::tableName(const _TCHAR* v)
+{
+    m_impl->table = v;
+    return *this;
+}
+
+int readStatement::getIndex() const
+{
+    return m_impl->index;
+}
+
+readStatement& readStatement::index(int v)
+{
+    m_impl->index = v;
+    return *this;
+}
+
+int readStatement::getOption() const
+{
+    return m_impl->option;
+}
+
+readStatement& readStatement::option(int v)
+{
+    m_impl->option = v;
+    return *this;
+}
+
+readStatement::eReadType readStatement::getReadType() const
+{
+    return m_impl->readType;
+}
+
+readStatement& readStatement::readType(readStatement::eReadType v)
+{
+    m_impl->readType = v;
+    return *this;
+}
+
+queryStatementImple* readStatement::internalPtr() const
+{
+    return m_impl;
+}
+
+readStatement& readStatement::alias(const _TCHAR* src, const _TCHAR* dst)
+{
+    m_impl->alias(src, dst);
+    return *this;
+}
+
+readStatement& readStatement::reset()
+{
+    query::reset();
+    fieldNames::reset();
+    m_impl->aliases.clear();
+    return *this;
+}
+
+int readStatement::aliasCount() const
+{
+    return (int)m_impl->aliases.size();
+}
+
+const _TCHAR* readStatement::getAliasFirst(int index) const
+{
+    return m_impl->aliases[index].first.c_str();
+}
+
+const _TCHAR* readStatement::getAliasSecond(int index) const
+{
+    return m_impl->aliases[index].second.c_str();
+}
+
+void readStatement::execute(recordset& rs)
+{
+    if (m_impl->parent->dbm)
+        m_impl->execute(rs, m_impl->parent->dbm);
+    else if (m_impl->parent->db)
+        m_impl->execute(rs, m_impl->parent->db);
+}
+
+//---------------------------------------------------------------------------
+//        class queryExecuter
+//---------------------------------------------------------------------------
+queryStatements* queryStatements::create(idatabaseManager& dbm)
+{
+    return new queryStatements(dbm);
+}
+
+queryStatements* queryStatements::create(database* db)
+{
+    return new queryStatements(db);
+}
+
+void queryStatements::release()
+{
+    delete this;
+}
+
+queryStatements::queryStatements(idatabaseManager& dbm)
+    : m_impl(new queryStatementsImple)
+{
+    m_impl->dbm = &dbm;
+}
+
+queryStatements::queryStatements(database* db)
+    : m_impl(new queryStatementsImple)
+{
+    m_impl->db = db;
+}
+
+queryStatements::~queryStatements()
+{
+    delete m_impl;
+}
+
+int queryStatements::getId() const
+{
+    return m_impl->id;
+}
+
+queryStatements& queryStatements::id(int v)
+{
+    m_impl->id = v;
+    return *this;
+}
+
+const _TCHAR* queryStatements::getTitle() const
+{
+    return m_impl->title.c_str();
+}
+
+queryStatements& queryStatements::title(const _TCHAR* v)
+{
+    m_impl->title = v;
+    return *this;
+}
+
+const _TCHAR* queryStatements::getDescription() const
+{
+    return m_impl->description.c_str();
+}
+
+queryStatements& queryStatements::description(const _TCHAR* v)
+{
+    m_impl->description = v;
+    return *this;
+}
+
+readStatement* queryStatements::addRead(readStatement::eReadType type)
+{
+    readStatement* p = readStatement::create();
+    p->readType(type);
+    p->m_impl->parent = this->m_impl;
+    m_impl->statements.push_back(p);
+    return p;
+}
+
+readHasMany* queryStatements::addHasManyRead()
+{
+    readHasMany* p = readHasMany::create();
+    m_impl->statements.push_back(p);
+    return p;
+}
+
+groupByStatement* queryStatements::addGroupBy()
+{
+    groupByStatement* p = groupByStatement::create();
+    p->m_parent = this->m_impl;
+    m_impl->statements.push_back(p);
+    return p;
+}
+
+orderByStatement* queryStatements::addOrderBy()
+{
+    orderByStatement* p = orderByStatement::create();
+    m_impl->statements.push_back(p);
+    return p;
+}
+
+matchByStatement* queryStatements::addMatchBy()
+{
+    matchByStatement* p = matchByStatement::create();
+    p->m_parent = this->m_impl;
+    m_impl->statements.push_back(p);
+    return p;
+}
+
+reverseOrderStatement* queryStatements::addReverseOrder()
+{
+    reverseOrderStatement* p = reverseOrderStatement::create();
+    m_impl->statements.push_back(p);
+    return p;
+}
+
+executable* queryStatements::get(int index)
+{
+    return m_impl->statements[index];
+}
+
+void queryStatements::pop_back()
+{
+    m_impl->statements.pop_back();
+}
+
+int queryStatements::size() const
+{
+    return (int)m_impl->statements.size();
+}
+
+queryStatementsImple* queryStatements::internalPtr() const
+{
+    return m_impl;
+}
+
+void queryStatements::save(const _TCHAR* filename)
+{
+#ifdef _UNICODE
+    char p[MAX_PATH];
+    WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, filename, -1, p, MAX_PATH,
+                        NULL, NULL);
+#else
+    const char* p = filename;
+
+#endif
+    std::ofstream file(p);
+    xml_oarchive oa(file);
+    queryStatementsImple& queryStatements = *m_impl;
+    oa << BOOST_SERIALIZATION_NVP(queryStatements);
+}
+
+void queryStatements::load(const _TCHAR* filename)
+{
+
+#ifdef _UNICODE
+    char p[MAX_PATH];
+    WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, filename, -1, p, MAX_PATH,
+                        NULL, NULL);
+
+#else
+    const char* p = filename;
+
+#endif
+    m_impl->reset();
+    std::ifstream file(p);
+    xml_iarchive ia(file);
+    queryStatementsImple& queryStatements = *m_impl;
+    ia >> BOOST_SERIALIZATION_NVP(queryStatements);
+}
+
+void queryStatements::save(std::stringstream& sf)
+{
+    xml_oarchive oa(sf);
+    queryStatementsImple& queryStatements = *m_impl;
+    oa << BOOST_SERIALIZATION_NVP(queryStatements);
+}
+
+void queryStatements::load(std::stringstream& sf)
+{
+    m_impl->reset();
+    xml_iarchive ia(sf);
+    queryStatementsImple& queryStatements = *m_impl;
+    ia >> BOOST_SERIALIZATION_NVP(queryStatements);
+}
+
+void queryStatements::execute(recordset& rs,
+                              const std::vector<std::_tstring>* values,
+                              executeListner* listner)
+{
+    m_impl->pv.setValues(values);
+    m_impl->execute(rs, listner);
+}
+
+void queryStatements::clear()
+{
+    m_impl->reset();
+}
+
+int queryStatements::statementType(int index)
+{
+    if (dynamic_cast<readHasMany*>(m_impl->statements[index]))
+        return 2;
+    if (dynamic_cast<readStatement*>(m_impl->statements[index]))
+        return 1;
+    if (dynamic_cast<groupByStatement*>(m_impl->statements[index]))
+        return 3;
+    if (dynamic_cast<orderByStatement*>(m_impl->statements[index]))
+        return 4;
+    if (dynamic_cast<matchByStatement*>(m_impl->statements[index]))
+        return 5;
+    if (dynamic_cast<reverseOrderStatement*>(m_impl->statements[index]))
+        return 6;
+
+    return 0;
+}
+
+readStatement* queryStatements::getReadStatement(executable* e)
+{
+    return dynamic_cast<readStatement*>(e);
+}
+
+readHasMany* queryStatements::getReadHasMany(executable* e)
+{
+    return dynamic_cast<readHasMany*>(e);
+}
+
+groupByStatement* queryStatements::getGroupByStatement(executable* e)
+{
+    return dynamic_cast<groupByStatement*>(e);
+}
+
+orderByStatement* queryStatements::getOrderByStatement(executable* e)
+{
+    return dynamic_cast<orderByStatement*>(e);
+}
+
+matchByStatement* queryStatements::getMatchByStatement(executable* e)
+{
+    return dynamic_cast<matchByStatement*>(e);
+}
+
+reverseOrderStatement* queryStatements::getReverseOrderStatement(executable* e)
+{
+    return dynamic_cast<reverseOrderStatement*>(e);
+}
+
+const readStatement*
+queryStatements::getReadStatement(const executable* e) const
+{
+    return dynamic_cast<const readStatement*>(e);
+}
+
+const readHasMany* queryStatements::getReadHasMany(const executable* e) const
+{
+    return dynamic_cast<const readHasMany*>(e);
+}
+
+const groupByStatement*
+queryStatements::getGroupByStatement(const executable* e) const
+{
+    return dynamic_cast<const groupByStatement*>(e);
+}
+
+const orderByStatement*
+queryStatements::getOrderByStatement(const executable* e) const
+{
+    return dynamic_cast<const orderByStatement*>(e);
+}
+
+const matchByStatement*
+queryStatements::getMatchByStatement(const executable* e) const
+{
+    return dynamic_cast<const matchByStatement*>(e);
+}
+
+const reverseOrderStatement*
+queryStatements::getReverseOrderStatement(const executable* e) const
+{
+    return dynamic_cast<const reverseOrderStatement*>(e);
+}
+
+//---------------------------------------------------------------------------
+//        struct readHasManyImple
+//---------------------------------------------------------------------------
+
+struct readHasManyImple
+{
+    fieldNames columns;
+    recordsets rss;
+
+    void reset()
+    {
+        rss.clear();
+        columns.reset();
+    }
+
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int version)
+    {
+        ar& make_nvp("columns", columns);
+    }
+};
+
+//---------------------------------------------------------------------------
+//        class readHasMany
+//---------------------------------------------------------------------------
+
+readHasMany::readHasMany()
+    : readStatement(), m_readHasManyImpl(new readHasManyImple)
+{
+}
+
+readHasMany::~readHasMany()
+{
+    delete m_readHasManyImpl;
+}
+
+readHasManyImple* readHasMany::internalPtr() const
+{
+    return m_readHasManyImpl;
+}
+
+recordsets& readHasMany::recordsets()
+{
+    return m_readHasManyImpl->rss;
+}
+
+void readHasMany::addkeyValueColumn(const _TCHAR* name)
+{
+    m_readHasManyImpl->columns.addValue(name);
+}
+
+const _TCHAR* readHasMany::getkeyValueColumn(int index) const
+{
+    return m_readHasManyImpl->columns.getValue(index);
+}
+
+int readHasMany::keyValueColumns() const
+{
+    return m_readHasManyImpl->columns.count();
+}
+
+readHasMany& readHasMany::reset()
+{
+    readStatement::reset();
+    m_readHasManyImpl->reset();
+    return *this;
+}
+
+void readHasMany::execute(recordset& rs)
+{
+    m_readHasManyImpl->rss.clear();
+
+    std::vector<int> indexes;
+    const fielddefs* fds = rs.fieldDefs();
+    for (int i = 0; i < m_readHasManyImpl->columns.count(); ++i)
+        indexes.push_back(fds->indexByName(getkeyValueColumn(i)));
+
+    for (int i = 0; i < (int)rs.size(); ++i)
+    {
+        fieldNames::reset();
+        // setkey values
+        for (int j = 0; j < (int)indexes.size(); ++j)
+        {
+            const _TCHAR* p = rs[i][indexes[j]].c_str();
+            addValue(p);
+            if (j == 0)
+                addLogic(getkeyValueColumn(j), _T("="), p);
+            else
+                addLogic(_T("and"), getkeyValueColumn(j), _T("="), p);
+        }
+        recordset* tmp = new recordset();
+        boost::shared_ptr<recordset> r(tmp,
+                                       boost::bind(&recordset::release, tmp));
+        m_readHasManyImpl->rss.push_back(r);
+        readStatement::execute(*r);
+    }
+}
+
+client::query* replaceQueryParams(client::query* tq, client::query& tmpq,
+                                  queryStatementsImple* parent)
+{
+
+    int n = 0;
+    if (tq)
+        n = tq->whereTokens();
+    else
+        n = tmpq.whereTokens();
+    if (n)
+    {
+        if (tq)
+            tmpq = *tq;
+        for (int i = 0; i < n; ++i)
+        {
+            if (_tcscmp(tmpq.getWhereToken(i), _T("?")) == 0)
+                tmpq.setWhereToken(i,
+                                   parent->pv.replace(tmpq.getWhereToken(i)));
+        }
+        return &tmpq;
+    }
+    return tq;
+}
+
+readHasMany* readHasMany::create()
+{
+    return new readHasMany();
+}
+
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
+
+#ifdef BCB_32
+#pragma option pop
+#endif