transactd 1.2.0 → 2.0.0

data/source/bzs/db/protocol/tdap/client/field.h

@@ -0,0 +1,393 @@
+#ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_FIELD_H
+#define BZS_DB_PROTOCOL_TDAP_CLIENT_FIELD_H
+/*=================================================================
+   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 "nsTable.h"
+#include "fieldNameAlias.h"
+
+class CField; // atl interface
+
+namespace bzs
+{
+namespace rtl
+{
+class stringBuffer;
+}
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+class stringConverter;
+/** @cond INTERNAL */
+
+/* non copyable */
+class DLLLIB fieldShare
+{
+    friend class field;
+    friend class table;
+    friend class recordCache;
+
+private:
+    struct Imple* m_imple;
+    struct
+    {
+        unsigned char myDateTimeValueByBtrv : 1;
+        unsigned char trimPadChar : 1;
+        unsigned char usePadChar : 1;
+        unsigned char logicalToString : 1;
+    };
+    fieldShare(const fieldShare&); // no implememt
+    fieldShare& operator=(const fieldShare&); // no implememt
+
+protected:
+    fieldShare();
+
+    virtual ~fieldShare();
+    stringConverter* cv();
+    bzs::rtl::stringBuffer* strBufs();
+    void blobPushBack(char* p);
+    void blobClear();
+};
+
+/** @endcond */
+
+class DLLLIB fielddefs : public fieldShare
+{
+    struct infoImple* m_imple;
+    void aliasing(fielddef* p) const;
+    fielddefs();
+    ~fielddefs();
+    fielddefs(const fielddefs& r);
+    fielddefs& operator=(const fielddefs& r);
+    friend class table;
+    friend class recordsetImple;
+    friend class writableRecord;
+    friend class memoryRecord;
+    friend class recordsetQuery;
+    friend struct recordsetQueryImple;
+    friend class fieldsBase;
+
+    void addAllFileds(tabledef* def);
+    void copyFrom(const class table* tb);
+    bool canUnion(const fielddefs& r) const;
+    size_t totalFieldLen() const;
+    void resetUpdateIndicator();
+    void setAliases(const aliasMap_type* p);
+    void push_back(const fielddef* p, bool rePosition = false);
+    void remove(int index);
+    void reserve(size_t size);
+    void clear();
+
+public:
+    fielddefs* clone() const;
+    int indexByName(const std::_tstring& name) const;
+    const fielddef& operator[](int index) const;
+    const fielddef& operator[](const _TCHAR* name) const;
+    const fielddef& operator[](const std::_tstring& name) const;
+    bool checkIndex(int index) const;
+    size_t size() const;
+    void release();
+    static fielddefs* create();
+};
+
+/** @cond INTERNAL */
+
+typedef int (*compFieldFunc)(const class field& l, const class field& r,
+                             char logType);
+
+/** @endcond */
+
+class DLLLIB field
+{
+    friend class table;
+    friend class fieldsBase;
+    friend class CField; // atl interface
+    /** @cond INTERNAL */
+    friend int compBlob(const field& l, const field& r, char logType);
+    /** @endcond */
+    fielddef* m_fd;
+    unsigned char* m_ptr;
+    class fielddefs* m_fds;
+
+    compFieldFunc getCompFunc(char logType) const;
+    int blobLenBytes() const { return m_fd->blobLenBytes(); }
+
+private:
+    //  ---- bigin regacy interfaces ----  //
+    unsigned char getFVbyt() const;
+    short getFVsht() const;
+    int getFVint() const;
+    int getFVlng() const;
+    __int64 getFV64() const;
+    float getFVflt() const;
+    double getFVdbl() const;
+    void* getFVbin(uint_td& size) const;
+    const char* getFVAstr() const;
+#ifdef _WIN32
+    const wchar_t* getFVWstr() const;
+    void setFVW(const wchar_t* data);
+#endif
+    void setFV(float data);
+    void setFV(double data);
+    void setFV(unsigned char data);
+    void setFV(short data);
+    void setFV(int data);
+    void setFV(__int64 data);
+    void setFVA(const char* data);
+    void setFV(const void* data, uint_td size);
+#ifdef _UNICODE
+    inline const wchar_t* getFVstr() const { return getFVWstr(); };
+    inline void setFV(const wchar_t* data) { setFVW(data); };
+#else
+    inline const char* getFVstr() const { return getFVAstr(); };
+    inline void setFV(const char* data) { setFVA(data); };
+#endif
+    double getFVnumeric() const;
+    double getFVDecimal() const;
+    void setFVDecimal(double data);
+    void setFVNumeric(double data);
+    //  ---- end regacy interfaces ----  //
+
+    inline field(unsigned char* ptr, const fielddef& fd, fielddefs* fds)
+        : m_fd((fielddef*)&fd), m_ptr(ptr), m_fds(fds){};
+
+/** @cond INTERNAL */
+#if defined(SWIG) ||                                                           \
+    defined(SWIG_BUILDING) // SWIG Wrapper need public constructor
+public:
+#endif
+    inline field() : m_fd(NULL), m_ptr(NULL), m_fds(NULL){};
+    /** @endcond */
+
+public:
+    // To inline
+    inline field(const field& r) : m_fd(r.m_fd), m_ptr(r.m_ptr), m_fds(r.m_fds)
+    {
+    }
+
+    inline field& operator=(const field& r)
+    {
+        m_fd = r.m_fd;
+        m_ptr = r.m_ptr;
+        m_fds = r.m_fds;
+        return *this;
+    }
+
+    void* ptr() const;
+
+    unsigned char type() const { return m_fd->type; }
+
+    unsigned short len() const { return m_fd->len; }
+
+    inline const _TCHAR* c_str() const { return getFVstr(); }
+
+    inline const char* a_str() const { return getFVAstr(); }
+
+    inline int i() const { return getFVint(); }
+
+    inline int i8() const { return getFVbyt(); }
+
+    inline short i16() const { return getFVsht(); }
+
+    inline __int64 i64() const { return getFV64(); }
+
+    inline float f() const { return getFVflt(); }
+
+    inline double d() const { return getFVdbl(); }
+
+    inline field& operator=(const _TCHAR* p)
+    {
+        setFV(p);
+        m_fd->enableFlags.bitE = true;
+        return *this;
+    }
+
+    inline field& operator=(const std::_tstring& p)
+    {
+        setFV(p.c_str());
+        m_fd->enableFlags.bitE = true;
+        return *this;
+    }
+
+#ifdef _UNICODE
+    inline field& operator=(const char* p)
+    {
+        setFVA(p);
+        m_fd->enableFlags.bitE = true;
+        return *this;
+    }
+
+    inline field& operator=(const std::string& p)
+    {
+        setFVA(p.c_str());
+        m_fd->enableFlags.bitE = true;
+        return *this;
+    }
+
+#endif
+
+    inline field& operator=(int v)
+    {
+        setFV(v);
+        m_fd->enableFlags.bitE = true;
+        return *this;
+    }
+
+    inline field& operator=(__int64 v)
+    {
+        setFV(v);
+        m_fd->enableFlags.bitE = true;
+        return *this;
+    }
+
+    inline field& operator=(float v)
+    {
+        setFV(v);
+        m_fd->enableFlags.bitE = true;
+        return *this;
+    }
+
+    inline field& operator=(double v)
+    {
+        setFV(v);
+        m_fd->enableFlags.bitE = true;
+        return *this;
+    }
+
+    inline bool operator!=(const _TCHAR* p)
+    {
+        return (_tcscmp(p, c_str()) != 0);
+    };
+    inline bool operator==(const _TCHAR* p)
+    {
+        return (_tcscmp(p, c_str()) == 0);
+    };
+
+    inline bool operator!=(int v) { return (v != i()); };
+    inline bool operator==(int v) { return (v == i()); };
+
+    inline bool operator!=(short v) { return (v != i16()); };
+    inline bool operator==(short v) { return (v == i16()); };
+
+    inline bool operator!=(__int64 v) { return (v != i64()); };
+    inline bool operator==(__int64 v) { return (v == i64()); };
+
+    inline bool operator!=(float v) { return (v != f()); };
+    inline bool operator==(float v) { return (v == f()); };
+
+    inline bool operator!=(double v) { return (v != d()); };
+    inline bool operator==(double v) { return (v == d()); };
+
+    inline void setBin(const void* data, uint_td size)
+    {
+        setFV(data, size);
+        m_fd->enableFlags.bitE = true;
+    }
+    inline void* getBin(uint_td& size) { return getFVbin(size); };
+
+    int comp(const field& r, char logType = CMPLOGICAL_VAR_COMP_ALL) const;
+
+    /** @cond INTERNAL */
+    bool isCompPartAndMakeValue();
+    /** @endcond */
+};
+
+/** @cond INTERNAL */
+/* For template tget type num by type.*/
+
+inline int getFieldType(int)
+{
+    return ft_integer;
+}
+
+inline int getFieldType(__int64)
+{
+    return ft_integer;
+}
+
+inline int getFieldType(short)
+{
+    return ft_integer;
+}
+
+inline int getFieldType(char)
+{
+    return ft_integer;
+}
+
+inline int getFieldType(double)
+{
+    return ft_float;
+}
+
+inline int getFieldType(float)
+{
+    return ft_float;
+}
+
+inline __int64 fieldValue(const field& fd, __int64)
+{
+    return fd.i64();
+}
+
+inline int fieldValue(const field& fd, int)
+{
+    return fd.i();
+}
+
+inline short fieldValue(const field& fd, short)
+{
+    return (short)fd.i();
+}
+
+inline char fieldValue(const field& fd, char)
+{
+    return (char)fd.i();
+}
+
+inline double fieldValue(const field& fd, double)
+{
+    return fd.d();
+}
+
+inline float fieldValue(const field& fd, float)
+{
+    return fd.f();
+}
+
+inline const _TCHAR* fieldValue(const field& fd, const _TCHAR*)
+{
+    return fd.c_str();
+}
+
+DLLLIB const fielddef& dummyFd();
+
+/** @endcond */
+
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_FIELD_H

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

@@ -16,9 +16,6 @@
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
  ================================================================= */
-#include <bzs/env/tstring.h>
-#pragma hdrstop
-
 #include "fieldDDF.h"
 #include "nsDatabase.h"
 #pragma package(smart_init)
@@ -34,7 +31,10 @@ namespace tdap
 namespace client
 {
 
-fieldDDF::fieldDDF(nsdatabase *pbe) : nstable(pbe) {m_keybuflen = 128;}
+fieldDDF::fieldDDF(nsdatabase* pbe) : nstable(pbe)
+{
+    m_keybuflen = 128;
+}
 
 void fieldDDF::doOpen(const _TCHAR* Dir, char_td mode, const _TCHAR* OwnerName)
 {
@@ -58,9 +58,11 @@ keylen_td fieldDDF::writeKeyData()
     keylen_td len = 2;
     switch (m_keynum)
     {
-    case 0: memcpy(&keybuf[0], &fieldid, len);
+    case 0:
+        memcpy(&keybuf[0], &fieldid, len);
         break;
-    case 1: memcpy(&keybuf[0], &fileid, len);
+    case 1:
+        memcpy(&keybuf[0], &fileid, len);
         break;
     case 2:
         len = 20;
@@ -89,7 +91,6 @@ void fieldDDF::writeRecordData()
     datbuf.dec = dec;
 
     datbuf.flag = flag;
-
 }
 
 void fieldDDF::onReadAfter()
@@ -104,12 +105,11 @@ void fieldDDF::onReadAfter()
     len = datbuf.len;
     dec = datbuf.dec;
     flag = datbuf.flag;
-
 }
 
 void fieldDDF::createTable(const _TCHAR* fullpath)
 {
-    fileSpec *fs;
+    fileSpec* fs;
     fs = (fileSpec*)malloc(512);
     memset(fs, 512, 0x00);
     fs->recLen = 32;
@@ -162,8 +162,8 @@ void fieldDDF::createTable(const _TCHAR* fullpath)
     m_stat = nsdb()->stat();
 }
 
-}// namespace client
-}// namespace tdap
-}// namespace protocol
-}// namespace db
-}// namespace bzs
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs

data/source/bzs/db/protocol/tdap/client/fieldDDF.h

@@ -31,8 +31,8 @@ namespace tdap
 namespace client
 {
 
-#pragma option -a1
-pragma_pack1
+#pragma pack(push, 1)
+pragma_pack1;
 
 struct SFIELDDDF
 {
@@ -46,10 +46,8 @@ struct SFIELDDDF
     short flag;
 };
 
-#pragma option -a
-pragma_pop
-
-
+#pragma pack(pop)
+pragma_pop;
 
 class fieldDDF : public nstable
 {
@@ -77,15 +75,14 @@ public:
 
     char keybuf[128];
 
-    explicit fieldDDF(nsdatabase *pbe);
+    explicit fieldDDF(nsdatabase* pbe);
     void createTable(const _TCHAR* fullpath);
     using nstable::open;
-
 };
 
-}// namespace client
-}// namespace tdap
-}// namespace protocol
-}// namespace db
-}// namespace bzs
-#endif//BZS_DB_PROTOCOL_TDAP_CLIENT_FIELDDDF_H
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_FIELDDDF_H

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

@@ -0,0 +1,123 @@
+/*=================================================================
+   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 "fieldNameAlias.h"
+
+#ifdef BCB_32
+#pragma option push
+#pragma option -O1
+#include <boost/unordered_map.hpp>
+#pragma option pop
+#else
+#include <boost/unordered_map.hpp>
+#endif
+
+#pragma package(smart_init)
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+typedef boost::unordered_map<std::_tstring, std::_tstring> map_type;
+
+struct fdnImple
+{
+    map_type map;
+};
+
+fdNmaeAlias::fdNmaeAlias() : m_imple(new fdnImple)
+{
+}
+
+fdNmaeAlias::fdNmaeAlias(const fdNmaeAlias& r)
+    : m_imple(new fdnImple(*r.m_imple))
+{
+}
+
+fdNmaeAlias& fdNmaeAlias::operator=(const fdNmaeAlias& r)
+{
+    if (this != &r)
+        *this->m_imple = *r.m_imple;
+    return *this;
+}
+
+fdNmaeAlias::~fdNmaeAlias()
+{
+    delete m_imple;
+}
+
+void fdNmaeAlias::set(const _TCHAR* src, const _TCHAR* dst)
+{
+    m_imple->map[src] = dst;
+}
+
+const _TCHAR* fdNmaeAlias::get(const _TCHAR* src) const
+{
+    try
+    {
+        if (m_imple && m_imple->map.count(src))
+            return m_imple->map.at(src).c_str();
+        return _T("");
+    }
+    catch (...)
+    {
+        return _T("");
+    }
+    return _T("");
+}
+
+const _TCHAR* fdNmaeAlias::resolv(const _TCHAR* dst) const
+{
+    map_type::const_iterator it = m_imple->map.begin();
+    while (it != m_imple->map.end())
+    {
+        if ((*it).second == dst)
+            return (*it).first.c_str();
+        ++it;
+    }
+    return _T("");
+}
+
+void fdNmaeAlias::clear()
+{
+    m_imple->map.clear();
+}
+
+void fdNmaeAlias::reverseAliasNamesQuery(queryBase& q) const
+{
+    map_type::const_iterator it = m_imple->map.begin();
+    while (it != m_imple->map.end())
+    {
+        q.reverseAliasName((*it).second.c_str(), (*it).first.c_str());
+        ++it;
+    }
+}
+
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs

data/source/bzs/db/protocol/tdap/client/fieldNameAlias.h

@@ -0,0 +1,58 @@
+#ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_FIELDNAMEALIAS_H
+#define BZS_DB_PROTOCOL_TDAP_CLIENT_FIELDNAMEALIAS_H
+/*=================================================================
+   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 "table.h"
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+class DLLLIB fdNmaeAlias
+{
+    struct fdnImple* m_imple;
+
+public:
+    fdNmaeAlias();
+    fdNmaeAlias(const fdNmaeAlias& r);
+    fdNmaeAlias& operator=(const fdNmaeAlias& r);
+    ~fdNmaeAlias();
+    void set(const _TCHAR* src, const _TCHAR* dst);
+    const _TCHAR* get(const _TCHAR* src) const;
+    const _TCHAR* resolv(const _TCHAR* dst) const;
+    void clear();
+    void reverseAliasNamesQuery(queryBase& q) const;
+};
+
+typedef fdNmaeAlias aliasMap_type;
+
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
+
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_FIELDNAMEALIAS_H