transactd 1.0.1

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

@@ -0,0 +1,527 @@
+/* =================================================================
+ Copyright (C) 2000-2013 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/env/tstring.h>
+#pragma hdrstop
+
+#include "filter.h"
+#pragma option -w-ucp
+
+#pragma package(smart_init)
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+inline ushort_td varlenForFilter(const fielddef& fd)
+{
+    if (((fd.type >= ft_myvarchar) && (fd.type <= ft_mywvarbinary)) || fd.type == ft_lstring)
+        return fd.len < 256 ? 1 : 2;
+    else if ((fd.type == ft_myblob) || (fd.type == ft_mytext))
+        return fd.len - 8;
+    return 0;
+}
+
+/** Length of compare
+ * if part of string or zstring then return strlen.
+ */
+inline uint_td compDataLen(const fielddef& fd, const uchar_td* ptr, bool part)
+{
+    uint_td length = fd.keyDataLen(ptr);
+    if (part)
+    {
+        if ((fd.type == ft_string) || (fd.type == ft_zstring) || (fd.type == ft_note))
+            length = (uint_td)strlen((const char*)ptr);
+        else if ((fd.type == ft_wstring) || (fd.type == ft_wzstring))
+            length = (uint_td)wcslen((const wchar_t*)ptr);
+    }
+    return length;
+}
+
+/** copy data for select comp
+ */
+inline ushort_td copyForCompare(const fielddef& fd, uchar_td* to, const uchar_td* from, bool part)
+{
+    ushort_td varlen = varlenForFilter(fd);
+    int copylen = compDataLen(fd, from, part);
+    if (varlen)
+        memcpy(to, from, varlen);
+    memcpy(to + varlen, fd.keyData(from), copylen);
+    return copylen + varlen;
+}
+
+filter::filter(table* pBao)
+{
+    m_pFilter = NULL;
+    m_pEntendBuf = NULL;
+    m_pEntendBuflen = 0;
+
+    init(pBao);
+
+}
+
+void filter::init(table* pBao)
+{
+    m_tb = pBao;
+    strcpy(&m_PosType[0], "UC");
+    m_RejectCount = 65000;
+    m_iRecordCount = 1;
+    m_iFieldCount = 1;
+    memset(m_iFieldLen, 0, 255 * sizeof(ushort_td));
+    memset(m_iFieldOffset, 0, 255 * sizeof(ushort_td));
+    m_iFieldLen[0] = (ushort_td) m_tb->tableDef()->maxRecordLen;
+    m_iFieldOffset[0] = 0;
+}
+
+filter::~filter()
+{
+    if (m_pFilter != NULL)
+        delete[]m_pFilter; ;
+    if (m_pEntendBuf != NULL)
+        free(m_pEntendBuf);
+
+}
+
+ushort_td filter::GetFieldLen(int index) {return m_iFieldLen[index];
+
+}
+
+ushort_td filter::GetFieldOffset(int index) {return m_iFieldOffset[index];}
+
+_TCHAR* filter::filterStr() {return m_pFilter;}
+
+bool filter::GetPosType()
+{
+
+    if (strcmp(m_PosType, "UC") == 0)
+        return false;
+    else
+        return true;
+}
+
+void filter::SetPosType(bool getnext)
+{
+
+    if (getnext)
+        strcpy(&m_PosType[0], "EG");
+    else
+        strcpy(&m_PosType[0], "UC");
+    if (m_pEntendBuf)
+        memcpy((void*)((char*)m_pEntendBuf + 2), &m_PosType[0], 2);
+
+}
+
+void filter::WriteBuffer() {memcpy(m_tb->dataBak(), m_pEntendBuf, m_pEntendBuflen);}
+
+bool filter::setFilter(const _TCHAR* str, ushort_td RejectCount, ushort_td CashCount)
+{
+
+    _TCHAR* NewPointer;
+
+    BFilter* itm;
+    BFilter* Olditm = NULL;
+
+    bool joint = false;
+    bool cmpfield;
+    ushort_td Oldlen;
+    short OldfieldNum = -1;
+    BFilterHeader* FilterHead;
+    ushort_td LogicalCount = 0;
+    BFilterDisc* disc;
+
+    m_RejectCount = RejectCount;
+    m_iRecordCount = CashCount;
+
+    if (m_pFilter)
+        delete[]m_pFilter;
+    size_t size = _tcslen(str) + 2;
+    m_pFilter = new _TCHAR[size];
+    if (m_pFilter == NULL)
+        return false;
+    memset(m_pFilter, 0, size * sizeof(_TCHAR));
+    _tcscpy(m_pFilter, str);
+
+    int sDataBufSize = 8192;
+    if (m_pEntendBuf == NULL)
+        m_pEntendBuf = malloc(sDataBufSize);
+    else
+        memset(m_pEntendBuf, 0, sDataBufSize);
+
+    if (m_pEntendBuf == NULL)
+        return false;
+
+    itm = (BFilter*)((char*)m_pEntendBuf + 8);
+
+    NewPointer = m_pFilter;
+
+    m_FieldSelected = false;
+    if (m_pFilter[0] == '*')
+        LogicalCount = 0;
+    else
+    {
+
+        // -------------------------------------------------------------
+        // SELECT
+        if (_tcsstr(m_pFilter, _T("SELECT ")) == NewPointer)
+        {
+            if (!MakeFieldSelect(&NewPointer))
+                return false;
+        }
+
+        while (1)
+        {
+            cmpfield = false;
+
+            // -------------------------------------------------------------
+            // Get filed number
+            // -------------------------------------------------------------
+            short fieldNum = GetField(&NewPointer);
+            if (fieldNum == -1)
+                break;
+
+            LogicalCount++;
+            fielddef* fd = &m_tb->tableDef()->fieldDefs[fieldNum];
+            itm->Type = fd->type;
+            itm->Len = fd->len;
+            itm->Pos = fd->pos;
+
+            // -------------------------------------------------------------
+            // Get logical type
+            // -------------------------------------------------------------
+            itm->CompType = GetCompType(&NewPointer);
+            if (itm->CompType == 255)
+                return false;
+
+            // -------------------------------------------------------------
+            // Get compare value
+            // if [fieldName] then comapre as field value
+            // -------------------------------------------------------------
+            _TCHAR* start = NewPointer;
+            if (!GetCompStr(&NewPointer))
+                return false;
+            if (NewPointer == NULL)
+                return false;
+
+            int offset = 0;
+            if (start[0] == '[')
+            {
+                start++;
+                int num = m_tb->fieldNumByName(start);
+                if (num != -1)
+                {
+                    itm->Data = m_tb->tableDef()->fieldDefs[num].pos;
+                    itm->CompType |= CMPLOGICAL_FIELD;
+                    cmpfield = true;
+                }
+            }
+            else
+            {
+
+                bool isPart = false;
+                if (start[0] == '\'')
+                {// string
+                    start++; // erase front '
+                    int len = (ushort_td) _tcslen(start);
+                    start[--len] = 0x00; // erase after '
+                    isPart = (start[len - 1] == '*');
+                    if (isPart)
+                    start[--len] = 0x00;
+
+                }
+                m_tb->setFV(fieldNum, start);
+                itm->Len =
+                    copyForCompare(*fd, (uchar_td*)(&itm->Data),
+                    (const uchar_td*)m_tb->fieldPtr(fieldNum), isPart);
+                if (!isPart && (fd->varLenBytes() || fd->blobLenBytes()))
+                    itm->CompType |= CMPLOGICAL_VAR_COMP_ALL; //match complate
+                offset = itm->Len - 2;
+            }
+
+            // LogicalType
+            itm->LogicalType = GetLogical(&NewPointer);
+            // ------------------------------------------------------------
+            // chain befor field
+            // ------------------------------------------------------------
+            Oldlen = fd->len;
+
+            if ((joint == true) && (OldfieldNum + 1 == fieldNum) && (itm->CompType == 1) &&
+                (cmpfield == false) && (itm->Len == fd->len) && (itm->Type != 11) &&
+                (varlenForFilter(*fd) == 0))
+            {
+                Olditm->LogicalType = itm->LogicalType;
+                Oldlen = itm->Len;
+                memcpy((void*)((char*)(&Olditm->Data) + Olditm->Len), &itm->Data, itm->Len);
+                Olditm->Len += Oldlen;
+                Oldlen = Olditm->Len;
+                itm = Olditm;
+                itm->Type = 0; // comapre as string
+
+                offset = itm->Len - 2;
+                LogicalCount--;
+            }
+            if (itm->LogicalType != 0) // If zero then logical is end.
+            {
+                // ------------------------------------------------------------
+                // Can it connect?   not * and not zstring
+                // ------------------------------------------------------------
+                if ((itm->CompType == 1) && (itm->LogicalType == 1) && (cmpfield == false) &&
+                    (itm->Len == Oldlen) && (itm->Type != 11) && (varlenForFilter(*fd) == 0))
+                    joint = true;
+                else
+                    joint = false;
+                Olditm = itm;
+                OldfieldNum = fieldNum;
+            }
+            // ------------------------------------------------------------
+            // move pointer
+            itm = (BFilter*)((char*)itm +sizeof(BFilter) + offset);
+        }
+    }
+    _tcscpy(m_pFilter, str);
+    // header
+    FilterHead = (BFilterHeader*) m_pEntendBuf;
+    FilterHead->BufLen = (ushort_td)((char*)itm - (char*)m_pEntendBuf + 4 + (m_iFieldCount * 4));
+    memcpy(FilterHead->PosType, m_PosType, 2);
+    FilterHead->RejectCount = m_RejectCount;
+    FilterHead->LogicalCount = LogicalCount;
+
+    // descipter
+    disc = (BFilterDisc*)itm;
+    disc->iRecordCount = m_iRecordCount;
+    disc->iFieldCount = m_iFieldCount;
+    int RecordSize = 0;
+    for (int i = 0; i < m_iFieldCount; i++)
+    {
+        disc->iSelectFields[i].iFieldLen = m_iFieldLen[i];
+        disc->iSelectFields[i].iFieldOffset = m_iFieldOffset[i];
+        RecordSize += m_iFieldLen[i];
+    }
+    m_iRecordCountDirect = &disc->iRecordCount;
+    m_pEntendBuflen = FilterHead->BufLen;
+    if (disc->iRecordCount == 0)
+    {
+        disc->iRecordCount = (ushort_td)(57000 / (RecordSize + 6));
+    }
+    m_ExDataBufLen = (ushort_td)((disc->iRecordCount * (RecordSize + 6)) + 2);
+
+    if ((ushort_td)m_ExDataBufLen < m_pEntendBuflen)
+        m_ExDataBufLen = m_pEntendBuflen;
+
+    uint_td len;
+    if ((m_FieldSelected == false) && !m_tb->valiableFormatType())
+        len = m_ExDataBufLen;
+    else
+        len = (uint_td)(m_ExDataBufLen + m_tb->buflen());
+
+    if (m_tb->buflen() < len)
+    {
+        m_tb->setDataBak((void*) realloc(m_tb->dataBak(), len));
+        m_tb->setData(m_tb->dataBak());
+
+        if (m_tb->data() == NULL)
+            return false;
+
+    }
+    return true;
+}
+
+bool filter::MakeFieldSelect(_TCHAR** str)
+{
+    _TCHAR* p;
+    _TCHAR* ret;
+    _TCHAR* point[255];
+    ushort_td index = 0;
+    _TCHAR FiledName[20] = {0x00};
+
+    m_iFieldCount = 0;
+
+
+    *str += 7; // "select" length = 7
+    point[index] = *str;
+
+    ret = (_TCHAR*)_tcsmstr((_TUCHAR*)*str, (_TUCHAR*)_T(" "));
+    if (ret == NULL)
+        return false;
+    ret[0] = 0x00; // set null
+    *str = ret + 1;
+
+    index++;
+    p = (_TCHAR*)_tcsmstr((_TUCHAR*)point[index - 1], (_TUCHAR*)_T(",")) + 1;
+    point[index] = p;
+    p--;
+    while (p)
+    {
+        index++;
+        p = (_TCHAR*)_tcsmstr((_TUCHAR*)point[index - 1], (_TUCHAR*)_T(","));
+        if (p)
+            point[index] = p + 1;
+        else
+            break;
+
+    }
+    point[index] = ret + 1;
+    size_t n;
+    short FieldNum;
+    for (int i = 0; i < index; i++)
+    {
+        n = point[i + 1] - point[i] - 1;
+        _tcsncpy(FiledName, point[i], n);
+        FiledName[n] = 0x00;
+        FieldNum = m_tb->fieldNumByName(FiledName);
+        if (FieldNum < 0)
+            return false;
+        m_iFieldLen[i] = m_tb->tableDef()->fieldDefs[FieldNum].len;
+        m_iFieldOffset[i] = m_tb->tableDef()->fieldDefs[FieldNum].pos;
+    }
+    m_iFieldCount = index;
+    m_FieldSelected = true;
+
+    return true;
+}
+
+short filter::GetField(_TCHAR** str)
+{
+    _TCHAR* ret;
+    _TCHAR FiledName[20] = {0x00};
+    int offset = 0;
+    // Get string that until next space.
+    if (*str[0] == '[')
+    {
+        offset = 1;
+        ret = (_TCHAR*)_tcsmstr((_TUCHAR*)*str, (_TUCHAR*) _T("]"));
+    }
+    else
+        ret = (_TCHAR*)_tcsmstr((_TUCHAR*)*str, (_TUCHAR*)_T(" "));
+
+    if (ret)
+    {
+        _tcsncpy(FiledName, *str + offset, ret - *str - offset);
+        *str = ret + 1 + offset;
+        return m_tb->fieldNumByName(FiledName);
+    }
+    else
+        return -1;
+}
+
+bool filter::GetCompStr(_TCHAR** str)
+{
+    _TCHAR* ret;
+    int offset = 0;
+
+    // Get string that until next space.
+    if (*str[0] == _T('['))
+    {
+        offset = 1;
+        ret = _tcsstr(*str, _T("]"));
+        if (!ret)
+            return false;
+    }
+    else if (*str[0] == _T('\''))
+    { // find next '
+        ret = (_TCHAR*)_tcsmstr((_TUCHAR*)*str + 1, (_TUCHAR*)_T("\'"));
+
+        if (ret)
+            ret += 1;
+        else
+            return false;
+    }
+    else
+        ret = (_TCHAR*)_tcsmstr((_TUCHAR*)*str, (_TUCHAR*)_T(" "));
+
+    if (ret)
+    {
+        *ret = 0x00;
+        *str = ret + 1 + offset;
+
+    }
+    return true;
+}
+
+uchar_td filter::GetLogical(_TCHAR** str)
+{
+    _TCHAR* ret;
+    _TCHAR LogicalStr[10] = {0x00};
+
+    // Get string that until next space.
+    ret = (_TCHAR*)_tcsmstr((_TUCHAR*)*str, (_TUCHAR*)_T(" "));
+    if (ret)
+    {
+        _tcsncpy(LogicalStr, *str, ret - *str);
+        _tcsmupr((_TUCHAR*)LogicalStr);
+        *str = ret + 1;
+        if (_tcscmp(LogicalStr, _T("AND")) == 0)
+            return (uchar_td)1;
+        else if (_tcscmp(LogicalStr, _T("OR")) == 0)
+            return (uchar_td)2;
+        else
+            return 0;
+    }
+    else
+        return 0;
+}
+
+uchar_td filter::GetCompType(_TCHAR** str)
+{
+    _TCHAR* ret;
+    _TCHAR cmpstr[10] = {0x00};
+
+    // Get string that until next space.
+    ret = (_TCHAR*)_tcsmstr((_TUCHAR*)*str, (_TUCHAR*)_T(" "));
+    if (ret)
+    {
+        _tcsncpy(cmpstr, *str, ret - *str);
+        *str = ret + 1;
+        if (_tcscmp(cmpstr, _T("=")) == 0)
+            return (uchar_td)1;
+
+        if (_tcscmp(cmpstr, _T(">")) == 0)
+            return (uchar_td)2;
+
+        if (_tcscmp(cmpstr, _T("<")) == 0)
+            return (uchar_td)3;
+
+        if (_tcscmp(cmpstr, _T("<>")) == 0)
+            return (uchar_td)4;
+
+        if (_tcscmp(cmpstr, _T("=>")) == 0)
+            return (uchar_td)5;
+        if (_tcscmp(cmpstr, _T(">=")) == 0)
+            return (uchar_td)5;
+
+        if (_tcscmp(cmpstr, _T("=<")) == 0)
+            return (uchar_td)6;
+        if (_tcscmp(cmpstr, _T("<=")) == 0)
+            return (uchar_td)6;
+        return 255;
+    }
+    else
+        return 255;
+}
+
+}// namespace client
+}// namespace tdap
+}// namespace protocol
+}// namespace db
+}// namespace bzs

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

@@ -0,0 +1,154 @@
+#ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_FILTER_H
+#define BZS_DB_PROTOCOL_TDAP_CLIENT_FILTER_H
+/* =================================================================
+ Copyright (C) 2000-2013 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
+{
+
+
+#pragma option -a-
+pragma_pack1
+
+struct BFilter
+{
+    uchar_td Type;
+    ushort_td Len;
+    ushort_td Pos;
+    uchar_td CompType;
+    uchar_td LogicalType;
+    ushort_td Data;
+};
+
+struct BFilterHeader
+{
+    ushort_td BufLen;
+    char PosType[2]; // "EG" or "UC"
+    ushort_td RejectCount;
+    ushort_td LogicalCount;
+};
+
+struct BSelectField
+{
+    ushort_td iFieldLen;
+    ushort_td iFieldOffset;
+};
+
+struct BFilterDisc
+{
+    ushort_td iRecordCount;
+    ushort_td iFieldCount;
+    BSelectField iSelectFields[255];
+};
+
+#pragma option -a
+pragma_pop
+
+class filter
+{
+
+    table* m_tb;
+
+    //buffer
+    _TCHAR* m_pFilter;
+    void* m_pEntendBuf;
+    ushort_td m_pEntendBuflen;
+    uint_td m_ExDataBufLen;
+
+    //hedaer
+    ushort_td m_RejectCount;
+    char m_PosType[3]; // "EG" or "UC"
+
+    //tail
+    ushort_td m_iRecordCount;
+    ushort_td m_iFieldCount;
+
+    ushort_td* m_iRecordCountDirect;
+    //result
+    ushort_td m_iFieldLen[255];
+    ushort_td m_iFieldOffset[255];
+
+    bool GetCompStr(_TCHAR** str);
+    uchar_td GetLogical(_TCHAR** str);
+    uchar_td GetCompType(_TCHAR** str);
+    short GetField(_TCHAR** str);
+    ushort_td GetFieldLen(int index);
+    ushort_td GetFieldOffset(int index);
+    bool MakeFieldSelect(_TCHAR** str);
+
+    bool m_FieldSelected;
+
+public:
+    filter(table* pBao);
+    ~filter();
+
+    bool posTypeNext() {return GetPosType();}
+
+    void setPosTypeNext(bool v) {SetPosType(v);}
+
+    uint_td exDataBufLen() const {return m_ExDataBufLen;}
+
+    ushort_td recordCount() const {return m_iRecordCount;}
+
+    void setRecordCount(ushort_td v) {m_iRecordCount = v;}
+
+    ushort_td fieldCount() const {return m_iFieldCount;}
+
+    void setFieldCount(ushort_td v) {m_iFieldCount = v;}
+
+    void* entendBuf() const {return m_pEntendBuf;}
+
+    void setEntendBuf(void* v) {m_pEntendBuf = v;};
+
+    ushort_td* recordCountDirect() const {return m_iRecordCountDirect;}
+
+    void setRecordCountDirect(ushort_td* v) {m_iRecordCountDirect = v;}
+
+    ushort_td rejectCount() const {return m_RejectCount;}
+
+    ushort_td fieldLen(int index) {return GetFieldLen(index);}
+
+    ushort_td fieldOffset(int index) {return GetFieldOffset(index);}
+
+    bool fieldSelected() const {return m_FieldSelected;}
+
+    void init(table* pBao);
+    bool GetPosType();
+    void SetPosType(bool);
+    void WriteBuffer();
+    bool setFilter(const _TCHAR* str, ushort_td RejectCount, ushort_td CashCount);
+    _TCHAR* filterStr();
+
+};
+
+}// namespace client
+}// namespace tdap
+}// namespace protocol
+}// namespace db
+}// namespace bzs
+#endif//BZS_DB_PROTOCOL_TDAP_CLIENT_FILTER_H