transactd 1.2.0 → 2.0.0

data/source/global/tdclatl/Record.cpp

@@ -0,0 +1,214 @@
+/*=================================================================
+   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 "Record.h"
+#include "Field.h"
+#include "FieldDefs.h"
+
+void CRecord::FinalRelease()
+{
+    if (m_fieldObj)
+        m_fieldObj->Release();
+}
+short CRecord::GetFieldNum(VARIANT* Index)
+{
+    short index = -1;
+    if (Index->vt == VT_BSTR)
+        index = m_rec->indexByName(Index->bstrVal);
+    else if ((Index->vt == VT_I2) || (Index->vt == VT_I4))
+        index = Index->iVal;
+    return index;
+}
+
+STDMETHODIMP CRecord::get_Size(short* retVal)
+{
+    *retVal = (short)m_rec->size();
+    return S_OK;
+}
+
+STDMETHODIMP CRecord::get_Field(VARIANT Index, IField** retVal)
+{
+    short index = GetFieldNum(&Index);
+    if (index < 0)
+        return Error("Invalid index", IID_ITable);
+
+    if (m_fieldObj == NULL)
+    {
+        CComObject<CField>::CreateInstance(&m_fieldObj);
+        m_fieldObj->AddRef();
+    }
+    if (m_fieldObj)
+    {
+        m_fieldObj->m_fd = (*m_rec)[index];
+        IField* fd;
+        m_fieldObj->QueryInterface(IID_IField, (void**)&fd);
+        _ASSERTE(fd);
+        *retVal = fd;
+    }
+    return S_OK;
+}
+
+STDMETHODIMP CRecord::get_IsInvalidRecord(VARIANT_BOOL* retVal)
+{
+    *retVal = m_rec->isInvalidRecord();
+    return S_OK;
+}
+
+void CWritableRecord::FinalRelease()
+{
+    if (m_fieldObj)
+        m_fieldObj->Release();
+    if (m_fieldDefsObj)
+        m_fieldDefsObj->Release();
+}
+
+short CWritableRecord::GetFieldNum(VARIANT* Index)
+{
+    short index = -1;
+    if (Index->vt == VT_BSTR)
+        index = m_rec->indexByName(Index->bstrVal);
+    else if ((Index->vt == VT_I2) || (Index->vt == VT_I4))
+        index = Index->iVal;
+    return index;
+}
+
+STDMETHODIMP CWritableRecord::Clear()
+{
+    m_rec->clear();
+    return S_OK;
+}
+
+STDMETHODIMP CWritableRecord::get_Size(short* retVal)
+{
+    *retVal = (short)m_rec->size();
+    return S_OK;
+}
+
+STDMETHODIMP CWritableRecord::get_Field(VARIANT Index, IField** retVal)
+{
+    short index = GetFieldNum(&Index);
+    if (index < 0)
+        return Error("Invalid index", IID_IWritableRecord);
+
+    if (m_fieldObj == NULL)
+    {
+        CComObject<CField>::CreateInstance(&m_fieldObj);
+        m_fieldObj->AddRef();
+    }
+    if (m_fieldObj)
+    {
+        m_fieldObj->m_fd = (*m_rec)[index];
+        IField* fd;
+        m_fieldObj->QueryInterface(IID_IField, (void**)&fd);
+        _ASSERTE(fd);
+        *retVal = fd;
+    }
+    return S_OK;
+}
+
+STDMETHODIMP CWritableRecord::Save()
+{
+    try
+    {
+        m_rec->save();
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IWritableRecord);
+    }
+}
+
+STDMETHODIMP CWritableRecord::Insert()
+{
+    try
+    {
+        m_rec->insert();
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IWritableRecord);
+    }
+}
+
+STDMETHODIMP CWritableRecord::Del(VARIANT_BOOL KeysetAlrady)
+{
+    try
+    {
+        m_rec->del(KeysetAlrady);
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IWritableRecord);
+    }
+}
+
+STDMETHODIMP CWritableRecord::Update()
+{
+    try
+    {
+        m_rec->update();
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IWritableRecord);
+    }
+}
+
+STDMETHODIMP CWritableRecord::Read(VARIANT_BOOL KeysetAlrady,
+                                   VARIANT_BOOL* retVal)
+{
+    try
+    {
+        *retVal = m_rec->read(KeysetAlrady);
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IWritableRecord);
+    }
+}
+
+STDMETHODIMP CWritableRecord::get_FieldDefs(IFieldDefs** retVal)
+{
+    if (m_fieldDefsObj == NULL)
+    {
+        CComObject<CFieldDefs>::CreateInstance(&m_fieldDefsObj);
+        m_fieldDefsObj->AddRef();
+    }
+    if (m_fieldDefsObj)
+    {
+        m_fieldDefsObj->m_fds = m_rec->fieldDefs();
+
+        IFieldDefs* fds;
+        m_fieldDefsObj->QueryInterface(IID_IFieldDefs, (void**)&fds);
+        _ASSERTE(fds);
+        *retVal = fds;
+    }
+    return S_OK;
+}
+
+STDMETHODIMP CWritableRecord::get_IsInvalidRecord(VARIANT_BOOL* retVal)
+{
+    *retVal = m_rec->isInvalidRecord();
+    return S_OK;
+}

data/source/global/tdclatl/Record.h

@@ -0,0 +1,96 @@
+#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/memRecord.h>
+
+using namespace ATL;
+class CField;
+class CFieldDefs;
+class ATL_NO_VTABLE CRecord
+    : public CComObjectRootEx<CComSingleThreadModel>,
+      public CComCoClass<CRecord, &CLSID_Record>,
+      public IDispatchImpl<IRecord, &IID_IRecord, &LIBID_transactd,
+                           /* wMajor = */ 1, /* wMinor = */ 0>
+{
+
+    CComObject<CField>* m_fieldObj;
+    short GetFieldNum(VARIANT* Index);
+
+public:
+    bzs::db::protocol::tdap::client::fieldsBase* m_rec;
+    CRecord() : m_fieldObj(NULL) {}
+
+    BEGIN_COM_MAP(CRecord)
+    COM_INTERFACE_ENTRY(IRecord)
+    COM_INTERFACE_ENTRY(IDispatch)
+    END_COM_MAP()
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    HRESULT FinalConstruct() { return S_OK; }
+
+    void FinalRelease();
+
+public:
+    STDMETHOD(get_Size)(short* retVal);
+    STDMETHOD(get_Field)(VARIANT Index, IField** retVal);
+    STDMETHOD(get_IsInvalidRecord)(VARIANT_BOOL* retVal);
+};
+
+class ATL_NO_VTABLE CWritableRecord
+    : public CComObjectRootEx<CComSingleThreadModel>,
+      public CComCoClass<CWritableRecord, &CLSID_Record>,
+      public IDispatchImpl<IWritableRecord, &IID_IWritableRecord,
+                           &LIBID_transactd, /* wMajor = */ 1, /* wMinor = */ 0>
+{
+
+    CComObject<CField>* m_fieldObj;
+    short GetFieldNum(VARIANT* Index);
+    CComObject<CFieldDefs>* m_fieldDefsObj;
+
+public:
+    bzs::db::protocol::tdap::client::writableRecord* m_rec;
+    CWritableRecord() : m_fieldObj(NULL), m_fieldDefsObj(NULL) {}
+
+    BEGIN_COM_MAP(CWritableRecord)
+    COM_INTERFACE_ENTRY(IWritableRecord)
+    COM_INTERFACE_ENTRY(IDispatch)
+    END_COM_MAP()
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    HRESULT FinalConstruct() { return S_OK; }
+
+    void FinalRelease();
+
+public:
+    STDMETHOD(Clear)();
+    STDMETHOD(get_Size)(short* retVal);
+    STDMETHOD(get_Field)(VARIANT Index, IField** retVal);
+    STDMETHOD(Save)();
+    STDMETHOD(Insert)();
+    STDMETHOD(Del)(VARIANT_BOOL KeysetAlrady);
+    STDMETHOD(Update)();
+    STDMETHOD(Read)(VARIANT_BOOL KeysetAlrady, VARIANT_BOOL* retVal);
+    STDMETHOD(get_FieldDefs)(IFieldDefs** retVal);
+    STDMETHOD(get_IsInvalidRecord)(VARIANT_BOOL* retVal);
+};

data/source/global/tdclatl/Recordset.cpp

@@ -0,0 +1,278 @@
+/*=================================================================
+   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 "Recordset.h"
+#include "Record.h"
+#include "Field.h"
+#include "GroupQuery.h"
+#include "FieldDefs.h"
+#include "RecordsetQuery.h"
+
+using namespace bzs::db::protocol::tdap::client;
+
+CARecordset::CARecordset()
+    : m_rs(new recordset()), m_recObj(NULL), m_fieldDefsObj(NULL)
+{
+}
+
+CARecordset::~CARecordset()
+{
+
+    if (m_recObj)
+        m_recObj->Release();
+    if (m_fieldDefsObj)
+        m_fieldDefsObj->Release();
+}
+
+void CARecordset::setResult(IRecordset** retVal)
+{
+    this->QueryInterface(IID_IRecordset, (void**)retVal);
+}
+
+STDMETHODIMP CARecordset::Record(unsigned long Index, IRecord** retVal)
+{
+    if (Index >= 0 && Index < m_rs->size())
+    {
+        if (m_recObj == NULL)
+        {
+            CComObject<CRecord>::CreateInstance(&m_recObj);
+            m_recObj->AddRef();
+        }
+        if (m_recObj)
+        {
+            m_recObj->m_rec = &((*m_rs)[Index]);
+            IRecord* rec;
+            m_recObj->QueryInterface(IID_IRecord, (void**)&rec);
+            _ASSERTE(rec);
+            *retVal = rec;
+        }
+        return S_OK;
+    }
+    return Error("Invalid index", IID_IRecordset);
+}
+
+STDMETHODIMP CARecordset::First(IRecord** retVal)
+{
+    return Record(0, retVal);
+}
+
+STDMETHODIMP CARecordset::Last(IRecord** retVal)
+{
+    return Record((short)m_rs->size() - 1, retVal);
+}
+
+STDMETHODIMP CARecordset::Top(unsigned long Num, IRecordset** retVal)
+{
+    if (Num > 0 && Num < m_rs->size())
+    {
+        CComObject<CARecordset>* rsObj;
+        CComObject<CARecordset>::CreateInstance(&rsObj);
+        if (rsObj)
+        {
+            m_rs->top(*rsObj->m_rs, Num);
+            IRecordset* rs;
+            rsObj->QueryInterface(IID_IRecordset, (void**)&rs);
+            _ASSERTE(rs);
+            *retVal = rs;
+        }
+        return S_OK;
+    }
+    return Error("Invalid top number", IID_IRecordset);
+}
+
+STDMETHODIMP CARecordset::Clone(IRecordset** retVal)
+{
+    CComObject<CARecordset>* rsObj;
+    CComObject<CARecordset>::CreateInstance(&rsObj);
+    if (rsObj)
+    {
+        rsObj->m_rs.reset(m_rs->clone());
+        IRecordset* rs;
+        rsObj->QueryInterface(IID_IRecordset, (void**)&rs);
+        _ASSERTE(rs);
+        *retVal = rs;
+    }
+    return S_OK;
+}
+
+STDMETHODIMP CARecordset::Erase(unsigned long Index)
+{
+    if (Index >= 0 && Index < m_rs->size())
+    {
+        m_rs->erase(Index);
+        return S_OK;
+    }
+    return Error("Invalid index", IID_IRecordset);
+}
+
+STDMETHODIMP CARecordset::get_Count(unsigned long* retVal)
+{
+    *retVal = (long)m_rs->count();
+    return S_OK;
+}
+
+STDMETHODIMP CARecordset::get_Size(unsigned long* retVal)
+{
+    *retVal = (long)m_rs->count();
+    return S_OK;
+}
+
+STDMETHODIMP CARecordset::RemoveField(short Index)
+{
+    if (Index >= 0 && Index < (int)m_rs->fieldDefs()->size())
+    {
+        try
+        {
+            m_rs->removeField(Index);
+            return S_OK;
+        }
+        catch (bzs::rtl::exception& e)
+        {
+            return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
+        }
+    }
+    return Error("Invalid field index", IID_IRecordset);
+}
+
+STDMETHODIMP CARecordset::AppendField(BSTR name, eFieldType type, short len)
+{
+    try
+    {
+        m_rs->appendField(name, (uchar_td)type, len);
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
+    }
+}
+
+STDMETHODIMP CARecordset::MatchBy(IRecordsetQuery* irq, IRecordset** retVal)
+{
+    try
+    {
+        if (irq)
+        {
+            CRecordsetQuery* rq = dynamic_cast<CRecordsetQuery*>(irq);
+            m_rs->matchBy(rq->m_qb);
+        }
+        setResult(retVal);
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
+    }
+}
+
+STDMETHODIMP CARecordset::GroupBy(IGroupQuery* igq, IRecordset** retVal)
+{
+    try
+    {
+        if (igq)
+        {
+            CGroupQuery* gq = dynamic_cast<CGroupQuery*>(igq);
+            m_rs->groupBy(gq->m_gq);
+        }
+        setResult(retVal);
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
+    }
+}
+
+STDMETHODIMP CARecordset::OrderBy(BSTR Name0, BSTR Name1, BSTR Name2,
+                                  BSTR Name3, BSTR Name4, BSTR Name5,
+                                  BSTR Name6, BSTR Name7, BSTR Name8,
+                                  IRecordset** retVal)
+{
+    try
+    {
+        if (!Name1 || !Name1[0])
+            m_rs->orderBy(Name0);
+        else if (!Name2 || !Name2[0])
+            m_rs->orderBy(Name0, Name1);
+        else if (!Name3 || !Name3[0])
+            m_rs->orderBy(Name0, Name1, Name2);
+        else if (!Name4 || !Name4[0])
+            m_rs->orderBy(Name0, Name1, Name2, Name3);
+        else if (!Name5 || !Name5[0])
+            m_rs->orderBy(Name0, Name1, Name2, Name3, Name4);
+        else if (!Name6 || !Name6[0])
+            m_rs->orderBy(Name0, Name1, Name2, Name3, Name4, Name5);
+        else if (!Name7 || !Name7[0])
+            m_rs->orderBy(Name0, Name1, Name2, Name3, Name4, Name5, Name6);
+        else
+            m_rs->orderBy(Name0, Name1, Name2, Name3, Name4, Name5, Name6,
+                          Name7);
+        setResult(retVal);
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
+    }
+}
+
+STDMETHODIMP CARecordset::OrderByEx(ISortFields* sortFields,
+                                    IRecordset** retVal)
+{
+    try
+    {
+        if (sortFields)
+        {
+            CSortFields* gq = dynamic_cast<CSortFields*>(sortFields);
+            m_rs->orderBy(gq->m_sortFields);
+        }
+        setResult(retVal);
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
+    }
+}
+
+STDMETHODIMP CARecordset::Reverse(IRecordset** retVal)
+{
+    m_rs->reverse();
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CARecordset::get_FieldDefs(IFieldDefs** retVal)
+{
+    if (m_fieldDefsObj == NULL)
+    {
+        CComObject<CFieldDefs>::CreateInstance(&m_fieldDefsObj);
+        m_fieldDefsObj->AddRef();
+    }
+    if (m_fieldDefsObj)
+    {
+        m_fieldDefsObj->m_fds = m_rs->fieldDefs();
+
+        IFieldDefs* fds;
+        m_fieldDefsObj->QueryInterface(IID_IFieldDefs, (void**)&fds);
+        _ASSERTE(fds);
+        *retVal = fds;
+    }
+    return S_OK;
+}

data/source/global/tdclatl/Recordset.h

@@ -0,0 +1,83 @@
+#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/recordset.h>
+using namespace ATL;
+
+class CRecord;
+class CFieldDefs;
+
+class ATL_NO_VTABLE CARecordset
+    : public CComObjectRootEx<CComSingleThreadModel>,
+      public CComCoClass<CARecordset, &CLSID_Recordset>,
+      public IDispatchImpl<IRecordset, &IID_IRecordset, &LIBID_transactd,
+                           /* wMajor = */ 1, /* wMinor = */ 0>
+{
+    void setResult(IRecordset** retVal);
+    CComObject<CRecord>* m_recObj;
+    CComObject<CFieldDefs>* m_fieldDefsObj;
+    typedef boost::shared_ptr<bzs::db::protocol::tdap::client::recordset>
+        internal_ptr;
+
+public:
+    internal_ptr m_rs;
+
+    CARecordset();
+    ~CARecordset();
+    void setRecordset(bzs::db::protocol::tdap::client::recordset* rs)
+    {
+        m_rs.reset(rs);
+    }
+
+    BEGIN_COM_MAP(CARecordset)
+    COM_INTERFACE_ENTRY(IRecordset)
+    COM_INTERFACE_ENTRY(IDispatch)
+    END_COM_MAP()
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    HRESULT FinalConstruct() { return S_OK; }
+
+    void FinalRelease(){};
+
+public:
+    STDMETHOD(Record)(unsigned long Index, IRecord** retVal);
+    STDMETHOD(First)(IRecord** retVal);
+    STDMETHOD(Last)(IRecord** retVal);
+    STDMETHOD(Top)(unsigned long Num, IRecordset** retVal);
+    STDMETHOD(Erase)(unsigned long Index);
+    STDMETHOD(get_Count)(unsigned long* retVal);
+    STDMETHOD(get_Size)(unsigned long* retVal);
+    STDMETHOD(RemoveField)(short Index);
+    STDMETHOD(AppendField)(BSTR name, eFieldType type, short len);
+    STDMETHOD(GroupBy)(IGroupQuery* gq, IRecordset** retVal);
+    STDMETHOD(MatchBy)(IRecordsetQuery* rq, IRecordset** retVal);
+
+    STDMETHOD(OrderBy)(BSTR name0, BSTR name1, BSTR name2, BSTR name3,
+                       BSTR name4, BSTR name5, BSTR name6, BSTR name7,
+                       BSTR name8, IRecordset** retVal);
+
+    STDMETHOD(OrderByEx)(ISortFields* sortFields, IRecordset** retVal);
+    STDMETHOD(Reverse)(IRecordset** retVal);
+    STDMETHOD(get_FieldDefs)(IFieldDefs** retVal);
+    STDMETHOD(Clone)(IRecordset** retVal);
+};