transactd 1.2.0 → 2.0.0

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

@@ -20,13 +20,14 @@
  ================================================================= */
 #include "nsTable.h"
 #include <vector>
+#include <stdio.h>
 namespace bzs
 {
 
 namespace db
 {
-    struct blobHeader;
-    struct blob;
+struct blobHeader;
+struct blob;
 namespace protocol
 {
 namespace tdap
@@ -34,116 +35,152 @@ namespace tdap
 namespace client
 {
 
-class fields;
+/** @cond INTERNAL */
 class database;
 class queryBase;
+class fields;
 #define null_str _T("")
 
-#pragma warning(disable:4251)
+#pragma warning(disable : 4251)
+
+static const int mra_nojoin = 0;
+static const int mra_first = 0;
+static const int mra_nextrows = 1;
+static const int mra_innerjoin = 2;
+static const int mra_outerjoin = 4;
+static const int mra_current_block = -1;
+
+class multiRecordAlocator
+{
+
+public:
+    virtual ~multiRecordAlocator() {}
+    virtual void init(size_t recordCount, size_t recordLen, int addType,
+                      const class table* tb) = 0;
+    virtual unsigned char* ptr(size_t row, int stat) = 0;
+    virtual void setJoinType(int v) = 0;
+    virtual void setInvalidRecord(size_t row, bool v) = 0;
+    virtual void setJoinRowMap(
+        const std::vector<std::vector<int> >* v /*, size_t size*/) = 0;
+    virtual const std::vector<std::vector<int> >* joinRowMap() const = 0;
+    virtual void duplicateRow(int row, int count) = 0;
+    virtual void removeLastMemBlock(int row) = 0;
+};
 
+/** @endcond */
 
-class AGRPACK table : public nstable
+class DLLLIB table : public nstable
 {
     friend class recordCache;
     friend class database;
     friend class filter;
+    friend class fields;
 
     struct tbimpl* m_impl;
+    class fielddefs* m_fddefs;
     tabledef* m_tableDef;
 
-    uchar_td charset() const ;
+    uchar_td charset() const;
     bool checkFindDirection(ushort_td op);
-    bool checkIndex(short index);
+    bool checkIndex(short index) const;
     void getKeySpec(keySpec* ks, bool SpecifyKeyNum = false);
     const bzs::db::blobHeader* getBlobHeader();
-    void setBlobFieldPointer(char*ptr, const ::bzs::db::blobHeader* p);
+    void setBlobFieldPointer(char* ptr, const ::bzs::db::blobHeader* p);
     void addSendBlob(const bzs::db::blob* blob);
     void addBlobEndRow();
     void resetSendBlob();
     void btrvGetExtend(ushort_td op);
     void getRecords(ushort_td op);
-    uint_td doGetWriteImageLen();   // orverride
+    uint_td doGetWriteImageLen(); // orverride
     void doUpdate(bool ncc = false); // orverride
     ushort_td doCommitBulkInsert(bool autoCommit = false); // orverride
     void doAbortBulkInsert(); // orverride
     void doCreateIndex(bool SpecifyKeyNum = false); // orverride
-    uint_td doRecordCount(bool estimate, bool fromCurrent, eFindType direction); // orverride
+    uint_td doRecordCount(bool estimate, bool fromCurrent); // orverride
     short_td doBtrvErr(HWND hWnd, _TCHAR* retbuf = NULL); // orverride
-
-    double getFVnumeric(short index);
-    double getFVDecimal(short index);
-    void setFVDecimal(short index, double data);
-    void setFVNumeric(short index, double data);
-    void doFind( ushort_td op, bool notIncCurrent);
+    void doFind(ushort_td op, bool notIncCurrent);
     bool setSeekValueField(int row);
+    void btrvSeekMulti();
+    bool doSeekMultiAfter(int row);
 
 protected:
-    explicit table(nsdatabase *pbe); // Inheritance is impossible
+    explicit table(nsdatabase* pbe); // Inheritance is impossible
     virtual ~table();
-    void* dataBak() const ;
+    void* dataBak() const;
     void setDataBak(void* v);
     void setBookMarks(int StartId, void* Data, ushort_td Count);
-    uint_td unPack(char*ptr, size_t size);
-    uint_td pack(char*ptr, size_t size);
+    uint_td unPack(char* ptr, size_t size);
+    uint_td pack(char* ptr, size_t size);
     keylen_td writeKeyData(); // orverride
-    
-	void writeRecordData(){};
+    keylen_td writeKeyDataTo(uchar_td* to, int keySize);
+
+    void writeRecordData(){};
 
-    void onReadAfter();  // orverride
-    bool onUpdateCheck(eUpdateType type);     // orverride
+    void onReadAfter(); // orverride
+    bool onUpdateCheck(eUpdateType type); // orverride
 
-	int onUpdateBefore(){return 0;}; // orverride
+    int onUpdateBefore() { return 0; }; // orverride
 
-	void onUpdateAfter(int beforeResult); // orverride
+    void onUpdateAfter(int beforeResult); // orverride
     bool onDeleteCheck(bool inkey); // orverride
 
-	int onInsertBefore() {return 0;}; // orverride
+    int onInsertBefore() { return 0; }; // orverride
 
-	void onInsertAfter(int beforeResult); // orverride
-    bool isUniqeKey(char_td keynum);//orverride
-	void init(tabledef* def, short filenum, bool regularDir);
+    void onInsertAfter(int beforeResult); // orverride
+    bool isUniqeKey(char_td keynum); // orverride
+    void init(tabledef* def, short filenum, bool regularDir);
     void* attachBuffer(void* newPtr, bool unpack = false, size_t size = 0);
     void dettachBuffer();
 
-	virtual void doInit(tabledef* def, short filenum, bool regularDir);
+    virtual void doInit(tabledef* def, short filenum, bool regularDir);
 
     virtual void onRecordCounting(size_t count, bool& complate){};
 
-    virtual void setNoUpdateTimeStamp(bool v) {};
-
+    virtual void setNoUpdateTimeStamp(bool v){};
 
 public:
     using nstable::eFindType;
 
-    inline const tabledef* tableDef() const {return m_tableDef;};
+    inline const tabledef* tableDef() const { return m_tableDef; };
+    inline const tabledef** tableDefPtr() const
+    {
+        return const_cast<const tabledef**>(&m_tableDef);
+    };
 
-    inline bool valiableFormatType() const {return m_tableDef->optionFlags.bitA;}
+    inline bool valiableFormatType() const
+    {
+        return m_tableDef->optionFlags.bitA;
+    }
 
-    inline bool blobFieldUsed() const {return m_tableDef->optionFlags.bitB;}
+    inline bool blobFieldUsed() const { return m_tableDef->optionFlags.bitB; }
 
-    bool logicalToString() const ;
+    bool logicalToString() const;
     void setLogicalToString(bool v);
-    bool trimPadChar() const ;
+    bool trimPadChar() const;
     void setTrimPadChar(bool v);
-    bool usePadChar() const ;
+    bool usePadChar() const;
     void setUsePadChar(bool v);
-	void* optionalData() const;
-	void setOptionalData(void* v);
-    bool myDateTimeValueByBtrv() const ;
-    int bookMarksCount() const ;
+    void* optionalData() const;
+    void setOptionalData(void* v);
+    bool myDateTimeValueByBtrv() const;
+    int bookMarksCount() const;
     void moveBookmarksId(long Id);
     void clearBuffer();
     unsigned int getRecordHash();
     void smartUpdate();
-    void find(eFindType type=findForword);
+
+    void setMra(multiRecordAlocator* p);
+    multiRecordAlocator* mra() const;
+
+    void find(eFindType type = findForword);
     void findFirst();
     void findLast();
     void findNext(bool notIncCurrent = true);
     void findPrev(bool notIncCurrent = true);
     bookmark_td bookmarkFindCurrent() const;
     void setQuery(const queryBase* query);
-    void setFilter(const _TCHAR* str, ushort_td rejectCount, ushort_td cacheCount);
-    const _TCHAR* filterStr();
+    void setFilter(const _TCHAR* str, ushort_td rejectCount,
+                   ushort_td cacheCount, bool autoEscape = true);
     short fieldNumByName(const _TCHAR* name);
     unsigned char getFVbyt(short index);
     short getFVsht(short index);
@@ -166,7 +203,6 @@ public:
     void setFV(short index, double data);
     void setFV(short index, float data);
     void setFV(short index, unsigned char data);
-    void setFV(short index, bool data);
     void setFV(short index, short data);
     void setFVA(short index, const char* data);
     void setFV(short index, int data);
@@ -179,29 +215,36 @@ public:
     const wchar_t* getFVWstr(short index);
     void setFVW(short index, const wchar_t* data);
     void setFVW(const _TCHAR* fieldName, const wchar_t* data);
-
 #endif
 
 #ifdef _UNICODE
-
-    inline const wchar_t* getFVstr(short index) {return getFVWstr(index);};
-
-    inline const wchar_t* getFVstr(const wchar_t* fieldName) {return getFVWstr(fieldName);};
-
-    inline void setFV(short index, const wchar_t* data) {setFVW(index, data);};
-
-    inline void setFV(const wchar_t* fieldName, const wchar_t* data) {setFVW(fieldName, data);};
-
+    inline const wchar_t* getFVstr(short index) { return getFVWstr(index); };
+    inline const wchar_t* getFVstr(const wchar_t* fieldName)
+    {
+        return getFVWstr(fieldName);
+    };
 #else
+    inline const char* getFVstr(short index) { return getFVAstr(index); };
+    inline const char* getFVstr(const char* fieldName)
+    {
+        return getFVAstr(fieldName);
+    };
+#endif
 
-    inline const char* getFVstr(short index) {return getFVAstr(index);};
-
-    inline const char* getFVstr(const char* fieldName) {return getFVAstr(fieldName);};
-
-    inline void setFV(short index, const char* data) {setFVA(index, data);};
-
-    inline void setFV(const char* fieldName, const char* data) {setFVA(fieldName, data);};
-
+    inline void setFV(short index, const char* data) { setFVA(index, data); };
+    inline void setFV(const _TCHAR* fieldName, const char* data)
+    {
+        setFVA(fieldName, data);
+    };
+#ifdef _WIN32
+    inline void setFV(short index, const wchar_t* data)
+    {
+        setFVW(index, data);
+    };
+    inline void setFV(const _TCHAR* fieldName, const wchar_t* data)
+    {
+        setFVW(fieldName, data);
+    };
 #endif
 
     void setFV(const _TCHAR* fieldName, double data);
@@ -211,53 +254,336 @@ public:
     void setFV(const _TCHAR* fieldName, const void* data, uint_td size);
     void setFV(short index, __int64 data);
     void setFV(const _TCHAR* fieldName, __int64 data);
-    void* fieldPtr(short index);
+    void* fieldPtr(short index) const;
     void keyValueDescription(_TCHAR* buf, int bufsize);
-
+    short getCurProcFieldCount() const;
+    short getCurProcFieldIndex(short index) const;
+    client::fields& fields();
 };
 
+#define KEYVALUE_PTR 0
+#define KEYVALUE_STR 1
+#define KEYVALUE_NEED_COPY 2
+#define KEYVALUE_STR_NEED_COPY 3
+
+/** @cond INTERNAL */
+
+struct DLLLIB keyValuePtr
+{
+
+    const void* ptr;
+    ushort_td len;
+    short type;
+    keyValuePtr(const void* p, ushort_td l, short typeStr);
+    ~keyValuePtr();
+};
+/** @endcond */
 
-class AGRPACK queryBase
+class DLLLIB queryBase
 {
-	friend class filter;
+    friend class filter;
     struct impl* m_impl;
 
+protected:
     const std::vector<std::_tstring>& getSelects() const;
     const std::vector<std::_tstring>& getWheres() const;
     const std::vector<std::_tstring>& getSeekKeyValues() const;
+    const std::vector<keyValuePtr>& getSeekValuesPtr() const;
+
 public:
+    enum eOptimize
+    {
+        none = 0,
+        joinHasOneOrHasMany = 1,
+        combineCondition = 2
+    };
+
     queryBase();
+    queryBase(const queryBase& r);
+    queryBase& operator=(const queryBase& r);
+
     virtual ~queryBase();
     void reset();
     void clearSeekKeyValues();
     void clearSelectFields();
     void addField(const _TCHAR* name);
-    void addLogic(const _TCHAR* name, const _TCHAR* logic,  const _TCHAR* value);
-    void addLogic(const _TCHAR* combine, const _TCHAR* name, const _TCHAR* logic,  const _TCHAR* value);
-    void addSeekKeyValue(const _TCHAR* value, bool reset=false);
-    queryBase& queryString(const _TCHAR* str);
+    void addLogic(const _TCHAR* name, const _TCHAR* logic, const _TCHAR* value);
+    void addLogic(const _TCHAR* combine, const _TCHAR* name,
+                  const _TCHAR* logic, const _TCHAR* value);
+    void addSeekKeyValue(const _TCHAR* value, bool reset = false);
+    void addSeekKeyValuePtr(const void* value, ushort_td len, short typeStr,
+                            bool reset = false);
+    void reserveSeekKeyValueSize(size_t v);
+    void reserveSeekKeyValuePtrSize(size_t v);
+    queryBase& queryString(const _TCHAR* str, bool autoEscape = false);
     queryBase& reject(int v);
-	queryBase& limit(int v);
+    queryBase& limit(int v);
     queryBase& direction(table::eFindType v);
     queryBase& all();
-    queryBase& optimize(bool v);
+    queryBase& optimize(eOptimize v);
+    queryBase& bookmarkAlso(bool v);
+    queryBase& joinKeySize(int v);
+
     const _TCHAR* toString() const;
     table::eFindType getDirection() const;
-    int getReject()const;
-    int getLimit()const;
-    bool isAll()const;
-    bool isOptimize()const;
-    void release();
+    int getReject() const;
+    int getLimit() const;
+    bool isAll() const;
+    int getJoinKeySize() const;
+    eOptimize getOptimize() const;
+    bool isBookmarkAlso() const;
+    short selectCount() const;
+    const _TCHAR* getSelect(short index) const;
+    short whereTokens() const;
+    const _TCHAR* getWhereToken(short index) const;
+    void setWhereToken(short index, const _TCHAR* v);
+    void reverseAliasName(const _TCHAR* alias, const _TCHAR* src);
+
+    void release(); // don't virtual
     static queryBase* create();
 };
 
+/** @cond INTERNAL */
+
+inline std::_tstring lexical_cast(__int64 v)
+{
+    _TCHAR tmp[256];
+    _i64tot_s(v, tmp, 256, 10);
+    return std::_tstring(tmp);
+}
+
+inline std::_tstring lexical_cast(int v)
+{
+    _TCHAR tmp[256];
+    _ltot_s(v, tmp, 256, 10);
+    return std::_tstring(tmp);
+}
+
+inline std::_tstring lexical_cast(short v)
+{
+    _TCHAR tmp[256];
+    _ltot_s((int)v, tmp, 256, 10);
+    return std::_tstring(tmp);
+}
+
+inline std::_tstring lexical_cast(char v)
+{
+    _TCHAR tmp[256];
+    _ltot_s((int)v, tmp, 256, 10);
+    return std::_tstring(tmp);
+}
+
+inline std::_tstring lexical_cast(double v)
+{
+    _TCHAR tmp[256];
+    _stprintf_s(tmp, 256, _T("%.*f"), 15, v);
+    return std::_tstring(tmp);
+}
+
+inline std::_tstring lexical_cast(float v)
+{
+    _TCHAR tmp[256];
+    _stprintf_s(tmp, 256, _T("%.*f"), 15, v);
+    return std::_tstring(tmp);
+}
+
+inline std::_tstring lexical_cast(const _TCHAR* v)
+{
+    return std::_tstring(v);
+}
+
+class qlogic
+{
+    std::_tstring m_name;
+    std::_tstring m_value;
+    std::_tstring m_type;
+    combineType m_next;
+
+public:
+    template <class T>
+    qlogic(const _TCHAR* name, const _TCHAR* type, T value, combineType next)
+        : m_name(name), m_type(type), m_next(next)
+    {
+        m_value = lexical_cast(value);
+    }
+};
+/** @endcond */
+
+class DLLLIB query : public queryBase
+{
+public:
+    query() : queryBase() {}
+    query(const query& r) : queryBase(r) {}
+
+    virtual ~query() {}
+
+    query& reset()
+    {
+        queryBase::reset();
+        return *this;
+    }
+
+    query& select(const _TCHAR* name, const _TCHAR* name1 = NULL,
+                  const _TCHAR* name2 = NULL, const _TCHAR* name3 = NULL,
+                  const _TCHAR* name4 = NULL, const _TCHAR* name5 = NULL,
+                  const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
+                  const _TCHAR* name8 = NULL, const _TCHAR* name9 = NULL,
+                  const _TCHAR* name10 = NULL)
+    {
+        if (_tcscmp(name, _T("*")) == 0)
+        {
+            clearSelectFields();
+            return *this;
+        }
+        addField(name);
+        if (name1)
+            addField(name1);
+        if (name2)
+            addField(name2);
+        if (name3)
+            addField(name3);
+        if (name4)
+            addField(name4);
+        if (name5)
+            addField(name5);
+        if (name6)
+            addField(name6);
+        if (name7)
+            addField(name7);
+        if (name8)
+            addField(name8);
+        if (name9)
+            addField(name9);
+        if (name10)
+            addField(name10);
+        return *this;
+    }
+
+    template <class T>
+    query& where(const _TCHAR* name, const _TCHAR* qlogic, T value)
+    {
+        addLogic(name, qlogic, lexical_cast(value).c_str());
+        return *this;
+    }
+
+    template <class T>
+    query& and_(const _TCHAR* name, const _TCHAR* qlogic, T value)
+    {
+        if (whereTokens() == 0)
+            THROW_BZS_ERROR_WITH_CODEMSG(STATUS_FILTERSTRING_ERROR,
+                                         _T("Invalid function call."));
+
+        addLogic(_T("and"), name, qlogic, lexical_cast(value).c_str());
+        return *this;
+    }
+
+    template <class T>
+    query& or_(const _TCHAR* name, const _TCHAR* qlogic, T value)
+    {
+        if (whereTokens() == 0)
+            THROW_BZS_ERROR_WITH_CODEMSG(STATUS_FILTERSTRING_ERROR,
+                                         _T("Invalid function call."));
+
+        addLogic(_T("or"), name, qlogic, lexical_cast(value).c_str());
+        return *this;
+    }
+
+    template <class T0, class T1, class T2, class T3, class T4, class T5,
+              class T6, class T7>
+    query& in(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,
+              const T4 kv4, const T5 kv5, const T6 kv6, const T7 kv7)
+    {
+        addSeekKeyValue(lexical_cast(kv0).c_str());
+        addSeekKeyValue(lexical_cast(kv1).c_str());
+        addSeekKeyValue(lexical_cast(kv2).c_str());
+        addSeekKeyValue(lexical_cast(kv3).c_str());
+        addSeekKeyValue(lexical_cast(kv4).c_str());
+        addSeekKeyValue(lexical_cast(kv5).c_str());
+        addSeekKeyValue(lexical_cast(kv6).c_str());
+        addSeekKeyValue(lexical_cast(kv7).c_str());
+        return *this;
+    }
+    template <class T0, class T1, class T2, class T3, class T4, class T5,
+              class T6>
+    query& in(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,
+              const T4 kv4, const T5 kv5, const T6 kv6)
+    {
+        addSeekKeyValue(lexical_cast(kv0).c_str());
+        addSeekKeyValue(lexical_cast(kv1).c_str());
+        addSeekKeyValue(lexical_cast(kv2).c_str());
+        addSeekKeyValue(lexical_cast(kv3).c_str());
+        addSeekKeyValue(lexical_cast(kv4).c_str());
+        addSeekKeyValue(lexical_cast(kv5).c_str());
+        addSeekKeyValue(lexical_cast(kv6).c_str());
+        return *this;
+    }
+
+    template <class T0, class T1, class T2, class T3, class T4, class T5>
+    query& in(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,
+              const T4 kv4, const T5 kv5)
+    {
+        addSeekKeyValue(lexical_cast(kv0).c_str());
+        addSeekKeyValue(lexical_cast(kv1).c_str());
+        addSeekKeyValue(lexical_cast(kv2).c_str());
+        addSeekKeyValue(lexical_cast(kv3).c_str());
+        addSeekKeyValue(lexical_cast(kv4).c_str());
+        addSeekKeyValue(lexical_cast(kv5).c_str());
+        return *this;
+    }
+
+    template <class T0, class T1, class T2, class T3, class T4>
+    query& in(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,
+              const T4 kv4)
+    {
+        addSeekKeyValue(lexical_cast(kv0).c_str());
+        addSeekKeyValue(lexical_cast(kv1).c_str());
+        addSeekKeyValue(lexical_cast(kv2).c_str());
+        addSeekKeyValue(lexical_cast(kv3).c_str());
+        addSeekKeyValue(lexical_cast(kv4).c_str());
+        return *this;
+    }
+
+    template <class T0, class T1, class T2, class T3>
+    query& in(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3)
+    {
+        addSeekKeyValue(lexical_cast(kv0).c_str());
+        addSeekKeyValue(lexical_cast(kv1).c_str());
+        addSeekKeyValue(lexical_cast(kv2).c_str());
+        addSeekKeyValue(lexical_cast(kv3).c_str());
+        return *this;
+    }
+
+    template <class T0, class T1, class T2>
+    query& in(const T0 kv0, const T1 kv1, const T2 kv2)
+    {
+        addSeekKeyValue(lexical_cast(kv0).c_str());
+        addSeekKeyValue(lexical_cast(kv1).c_str());
+        addSeekKeyValue(lexical_cast(kv2).c_str());
+        return *this;
+    }
+
+    template <class T0, class T1> query& in(const T0 kv0, const T1 kv1)
+    {
+        addSeekKeyValue(lexical_cast(kv0).c_str());
+        addSeekKeyValue(lexical_cast(kv1).c_str());
+        return *this;
+    }
+
+    template <class T0> query& in(const T0 kv0)
+    {
+        addSeekKeyValue(lexical_cast(kv0).c_str());
+        return *this;
+    }
+
+    static query* create(); // implemet int activeTable.cpp
+};
 
-#pragma warning(default:4251)
+#pragma warning(default : 4251)
 
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
 
-}// namespace client
-}// namespace tdap
-}// namespace protocol
-}// namespace db
-}// namespace bzs
-#endif//BZS_DB_PROTOCOL_TDAP_CLIENT_TABLE_H
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_TABLE_H