transactd 2.3.0 → 2.4.0

data/source/global/tdclatl/Bookmark.h

@@ -0,0 +1,65 @@
+#pragma once
+/*=================================================================
+   Copyright (C) 2015 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/tdapcapi.h>
+
+using namespace ATL;
+
+class ATL_NO_VTABLE CBookmark
+    : public CComObjectRootEx<CComSingleThreadModel>,
+      public CComCoClass<CBookmark, &CLSID_Bookmark>,
+      public IDispatchImpl<IBookmark, &IID_IBookmark,
+                           &LIBID_transactd, /* wMajor = */ 1, /* wMinor = */ 0>
+{
+
+    bookmark_td m_bm;
+    short m_len;
+public:
+    CBookmark(){}
+
+    void set(bookmark_td& b, short len){ m_bm = b; m_len = len;}
+
+    bookmark_td& internalBookmark()
+    {
+        return m_bm;
+    }
+    short bookmarkLen()
+    {
+        return m_len;
+    }
+    //DECLARE_REGISTRY_RESOURCEID(IDR_CONNECTPARAM)
+
+    BEGIN_COM_MAP(CBookmark)
+    COM_INTERFACE_ENTRY(IBookmark)
+    COM_INTERFACE_ENTRY(IDispatch)
+    END_COM_MAP()
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    HRESULT FinalConstruct(){ return S_OK;}
+
+    void FinalRelease(){};
+
+public:
+    STDMETHOD(get_IsEmpty)(VARIANT_BOOL* retVal);
+};
+
+//OBJECT_ENTRY_AUTO(__uuidof(Bookmark), CBookmark)

data/source/global/tdclatl/Database.cpp

@@ -193,9 +193,9 @@ STDMETHODIMP CDatabase::Create(BSTR URI, int type)
     return S_OK;
 }
 
-STDMETHODIMP CDatabase::Close()
+STDMETHODIMP CDatabase::Close(VARIANT_BOOL withDropDefaultSchema)
 {
-    m_db->close();
+    m_db->close(withDropDefaultSchema == -1);
     return S_OK;
 }
 

data/source/global/tdclatl/Database.h

@@ -101,7 +101,7 @@ public:
     STDMETHOD(Drop)();
     STDMETHOD(DropTable)(BSTR TableName);
     STDMETHOD(Create)(BSTR URI, int type);
-    STDMETHOD(Close)();
+    STDMETHOD(Close)(VARIANT_BOOL withDropDefaultSchema = 0);
     STDMETHOD(Connect)(BSTR URI, VARIANT_BOOL newConnection,
                        VARIANT_BOOL* Value);
     STDMETHOD(Disconnect)(BSTR URI, VARIANT_BOOL* Param2);
@@ -152,8 +152,6 @@ public:
     STDMETHOD(get_MaxTables)(int* Value);
     STDMETHOD(get_TrxIsolationServer)(eSrvIsorationType* Value);
     STDMETHOD(get_TrxLockWaitTimeoutServer)(int* Value);
-
-
 };
 
 OBJECT_ENTRY_AUTO(__uuidof(Database), CDatabase)

data/source/global/tdclatl/DbDef.cpp

@@ -244,3 +244,9 @@ STDMETHODIMP CDbDef::TdapErr(OLE_HANDLE hWnd, BSTR* Value)
         m_dbDef->tdapErr((HWND)hWnd);
     return S_OK;
 }
+
+STDMETHODIMP CDbDef::ValidateTableDef(short TableIndex, short* Value)
+{
+    *Value = m_dbDef->validateTableDef(TableIndex);
+    return S_OK;
+}

data/source/global/tdclatl/DbDef.h

@@ -76,4 +76,5 @@ public:
     STDMETHOD(put_Version)(int Value);
     STDMETHOD(get_Stat)(eStatus* Value);
     STDMETHOD(TdapErr)(OLE_HANDLE hWnd, BSTR* Value);
+    STDMETHOD(ValidateTableDef)(short TableIndex, short* Value);
 };

data/source/global/tdclatl/QueryBase.cpp

@@ -19,6 +19,7 @@
 #include "stdafx.h"
 #include "QueryBase.h"
 #include "Table.h"
+#include "Bookmark.h"
 
 STDMETHODIMP CQueryBase::Reset(IQueryBase** retVal)
 {
@@ -101,6 +102,11 @@ STDMETHODIMP CQueryBase::Or(BSTR Name, BSTR Logic, VARIANT Value,
 }
 
 STDMETHODIMP CQueryBase::AddInValue(VARIANT Value, VARIANT_BOOL Reset)
+{
+    return AddSeekKeyValue(Value, Reset);
+}
+
+STDMETHODIMP CQueryBase::AddSeekKeyValue(VARIANT Value, VARIANT_BOOL Reset)
 {
     if (Value.vt != VT_BSTR)
         VariantChangeType(&Value, &Value, 0, VT_BSTR);
@@ -108,6 +114,24 @@ STDMETHODIMP CQueryBase::AddInValue(VARIANT Value, VARIANT_BOOL Reset)
     return S_OK;
 }
 
+STDMETHODIMP CQueryBase::AddSeekBookmark(VARIANT Value, VARIANT_BOOL Reset)
+{
+    if ((Value.vt == VT_DISPATCH) && Value.pdispVal)
+    {
+        CBookmark* bm = dynamic_cast<CBookmark*>(Value.pdispVal);
+        if (bm)
+        {
+            if(!bm->internalBookmark().empty)
+                m_qb.addSeekBookmark(bm->internalBookmark(), bm->bookmarkLen(), (Reset == -1));
+            else
+                return Error("Bookmark is empty", IID_IQueryBase);
+        }
+        else
+            return Error("Invalid param 1 not IBookmark", IID_IQueryBase);
+    }
+    return S_OK;
+}
+
 STDMETHODIMP CQueryBase::In(VARIANT Value, VARIANT Value1, VARIANT Value2,
                             VARIANT Value3, VARIANT Value4, VARIANT Value5,
                             VARIANT Value6, VARIANT Value7, VARIANT Value8,
@@ -323,3 +347,8 @@ STDMETHODIMP CQueryBase::IsStopAtLimit(VARIANT_BOOL* retVal)
     return S_OK;
 }
 
+STDMETHODIMP CQueryBase::IsSeekByBookmarks(VARIANT_BOOL* retVal)
+{
+    *retVal = m_qb.isSeekByBookmarks();
+    return S_OK;
+}

data/source/global/tdclatl/QueryBase.h

@@ -89,6 +89,10 @@ public:
     STDMETHOD(IsBookmarkAlso)(VARIANT_BOOL* retVal);
     STDMETHOD(StopAtLimit)(VARIANT_BOOL Value, IQueryBase** retVal);
     STDMETHOD(IsStopAtLimit)(VARIANT_BOOL* retVal);
+    STDMETHOD(IsSeekByBookmarks)(VARIANT_BOOL* retVal);
+    STDMETHOD(AddSeekKeyValue)(VARIANT Value, VARIANT_BOOL Reset);
+    STDMETHOD(AddSeekBookmark)(VARIANT Value, VARIANT_BOOL Reset);
+
 };
 
 OBJECT_ENTRY_AUTO(__uuidof(QueryBase), CQueryBase)

data/source/global/tdclatl/Record.cpp

@@ -20,6 +20,7 @@
 #include "Record.h"
 #include "Field.h"
 #include "FieldDefs.h"
+#include "Bookmark.h"
 
 void CRecord::FinalRelease()
 {
@@ -188,12 +189,23 @@ STDMETHODIMP CWritableRecord::Update()
     }
 }
 
-STDMETHODIMP CWritableRecord::Read(VARIANT_BOOL KeysetAlrady,
+STDMETHODIMP CWritableRecord::Read(VARIANT param,
                                    VARIANT_BOOL* retVal)
 {
     try
     {
-        *retVal = m_rec->read(KeysetAlrady);
+        if ((param.vt == VT_DISPATCH) && param.pdispVal)
+        {
+            CBookmark* bm = dynamic_cast<CBookmark*>(param.pdispVal);
+            if (bm)
+                m_rec->read(bm->internalBookmark());
+            else
+                return Error("Invalid param 1 not IBookmark", IID_IWritableRecord);
+        }
+        else if (param.vt == VT_BOOL) 
+            *retVal = m_rec->read(param.boolVal);    
+        else
+            *retVal = m_rec->read();
         return S_OK;
     }
     catch (bzs::rtl::exception& e)

data/source/global/tdclatl/Record.h

@@ -90,7 +90,7 @@ public:
     STDMETHOD(Insert)();
     STDMETHOD(Del)(VARIANT_BOOL KeysetAlrady);
     STDMETHOD(Update)();
-    STDMETHOD(Read)(VARIANT_BOOL KeysetAlrady, VARIANT_BOOL* retVal);
+    STDMETHOD(Read)(VARIANT KeysetAlradyOrBookmark, VARIANT_BOOL* retVal);
     STDMETHOD(get_FieldDefs)(IFieldDefs** retVal);
     STDMETHOD(get_IsInvalidRecord)(VARIANT_BOOL* retVal);
 };

data/source/global/tdclatl/Table.cpp

@@ -24,6 +24,7 @@
 #include "QueryBase.h"
 #include "PreparedQuery.h"
 #include <bzs/db/protocol/tdap/client/fields.h>
+#include "Bookmark.h"
 
 using namespace bzs::db::protocol::tdap;
 
@@ -220,21 +221,42 @@ STDMETHODIMP CTableTd::SeekLessThan(VARIANT_BOOL orEqual, eLockType lockBias)
     return S_OK;
 }
 
-STDMETHODIMP CTableTd::get_BookMark(long* Value)
+STDMETHODIMP CTableTd::get_Bookmark(IBookmark** retVal)
 {
-    *Value = m_tb->bookmark();
+    CComObject<CBookmark>* bm;
+    CComObject<CBookmark>::CreateInstance(&bm);
+    if (!bm)
+        return Error("CreateInstance Bookmark", IID_ITable);
+    bm->set(m_tb->bookmark(), m_tb->bookmarkLen());
+    IBookmark* b;
+    bm->QueryInterface(IID_IBookmark, (void**)&b);
+    _ASSERTE(b);
+    *retVal = b;
     return S_OK;
 }
 
-STDMETHODIMP CTableTd::SeekByBookMark(long Value, eLockType lockBias)
+STDMETHODIMP CTableTd::SeekByBookmark(IBookmark* bm, eLockType lockBias)
 {
-    m_tb->seekByBookmark(Value, (ushort_td)lockBias);
-    return S_OK;
+    CBookmark* cb = dynamic_cast<CBookmark*>(bm);
+    if (cb)
+    {   
+        m_tb->seekByBookmark(cb->internalBookmark(), (ushort_td)lockBias);
+        return S_OK;
+    }
+    return Error("Invalid param bookmark", IID_ITable);
 }
 
-STDMETHODIMP CTableTd::get_Percentage(long* Value)
+STDMETHODIMP CTableTd::get_Percentage(VARIANT param, long* Value)
 {
-    *Value = m_tb->getPercentage();
+    if ((param.vt == VT_DISPATCH) && param.pdispVal)
+    {
+        CBookmark* bm = dynamic_cast<CBookmark*>(param.pdispVal);
+        if (bm)
+            *Value = m_tb->getPercentage(bm->internalBookmark());
+        else
+            return Error("Invalid param 1 not IBookmark", IID_ITable);
+    }else
+        *Value = m_tb->getPercentage();
     return S_OK;
 }
 
@@ -247,6 +269,9 @@ STDMETHODIMP CTableTd::get_RecordLength(long* Value)
 STDMETHODIMP CTableTd::RecordCount(VARIANT_BOOL estimate,
                                    VARIANT_BOOL fromCurrent, long* Value)
 {
+    m_tb->setOnRecordCount(onRecordCount);
+    m_tb->setOptionalData(this);
+
     *Value = m_tb->recordCount((estimate == -1), (fromCurrent == -1));
     return S_OK;
 }
@@ -497,9 +522,9 @@ STDMETHODIMP CTableTd::TdapErr(OLE_HANDLE hWnd, BSTR* Value)
     return S_OK;
 }
 
-STDMETHODIMP CTableTd::Unlock_(unsigned int bm)
+STDMETHODIMP CTableTd::Unlock_()
 {
-    m_tb->unlock(bm);
+    m_tb->unlock();
     return S_OK;
 }
 
@@ -509,17 +534,24 @@ STDMETHODIMP CTableTd::get_BlobFieldUsed(VARIANT_BOOL* Value)
     return S_OK;
 }
 
-STDMETHODIMP CTableTd::get_BookmarkFindCurrent(unsigned int* Value)
+STDMETHODIMP CTableTd::get_BookmarkFindCurrent(IBookmark** retVal)
 {
-
-    *Value = m_tb->bookmarkFindCurrent();
+    CComObject<CBookmark>* bm;
+    CComObject<CBookmark>::CreateInstance(&bm);
+    if (!bm)
+        return Error("CreateInstance Bookmark", IID_ITable);
+    bm->set(m_tb->bookmarkFindCurrent(), m_tb->bookmarkLen());
+    IBookmark* b;
+    bm->QueryInterface(IID_IBookmark, (void**)&b);
+    _ASSERTE(b);
+    *retVal = b;
     return S_OK;
 }
 
-STDMETHODIMP CTableTd::get_BookMarksCount(int* Value)
+STDMETHODIMP CTableTd::get_BookmarksCount(int* Value)
 {
 
-    *Value = m_tb->bookMarksCount();
+    *Value = m_tb->bookmarksCount();
     return S_OK;
 }
 
@@ -549,9 +581,9 @@ STDMETHODIMP CTableTd::put_LogicalToString(VARIANT_BOOL Value)
     return S_OK;
 }
 
-STDMETHODIMP CTableTd::MoveBookmarksId(long Value)
+STDMETHODIMP CTableTd::MoveBookmarks(long Value)
 {
-    m_tb->moveBookmarksId(Value);
+    m_tb->moveBookmarks(Value);
     return S_OK;
 }
 
@@ -650,3 +682,35 @@ STDMETHODIMP CTableTd::get_LastFindDirection(short* Value)
     return S_FALSE;
 }
 
+STDMETHODIMP CTableTd::get_BookmarkLen(unsigned short* Value)
+{
+    *Value = m_tb->bookmarkLen();
+    return S_FALSE;
+}
+
+STDMETHODIMP CTableTd::get_Bookmarks(long index, IBookmark** retVal)
+{
+    CComObject<CBookmark>* bm;
+    CComObject<CBookmark>::CreateInstance(&bm);
+    if (!bm)
+        return Error("CreateInstance Bookmark", IID_ITable);
+    bm->set(m_tb->bookmarks((unsigned int)index), m_tb->bookmarkLen());
+    IBookmark* b;
+    bm->QueryInterface(IID_IBookmark, (void**)&b);
+    _ASSERTE(b);
+    *retVal = b;
+    return S_OK;
+}
+
+void __stdcall onRecordCount(bzs::db::protocol::tdap::client::table* tb,
+                          int count, bool& cancel)
+{
+    CTableTd* ctb = reinterpret_cast<CTableTd*>(tb->optionalData());
+    ITable* tbPtr = dynamic_cast<ITable*>(ctb);
+    _ASSERTE(tbPtr);
+    VARIANT_BOOL tmp = 0;
+    ctb->Fire_OnRecordCount(tbPtr, count, &tmp);
+    if (tmp)
+        cancel = true;
+}
+

data/source/global/tdclatl/Table.h

@@ -22,13 +22,20 @@
 #include "tdclatl_i.h"
 #include "Field.h"
 #include <bzs/db/protocol/tdap/client/trdboostapi.h>
+#include "_IDatabaseEvents_CP.H"
+
 using namespace ATL;
+void __stdcall onRecordCount(bzs::db::protocol::tdap::client::table* tb,
+                          int count, bool& cancel);
 
 class ATL_NO_VTABLE CTableTd
     : public CComObjectRootEx<CComSingleThreadModel>,
       public CComCoClass<CTableTd, &CLSID_Table>,
       public IDispatchImpl<ITable, &IID_ITable, &LIBID_transactd,
-                           /* wMajor = */ 1, /* wMinor = */ 0>
+                           /* wMajor = */ 1, /* wMinor = */ 0>,
+      public IConnectionPointContainerImpl<CTableTd>,
+      public CProxy_ITableEvents<CTableTd>
+
 {
 
     int m_filterRejectCount;
@@ -48,8 +55,14 @@ public:
     BEGIN_COM_MAP(CTableTd)
     COM_INTERFACE_ENTRY(ITable)
     COM_INTERFACE_ENTRY(IDispatch)
+    COM_INTERFACE_ENTRY(IConnectionPointContainer)
     END_COM_MAP()
 
+    BEGIN_CONNECTION_POINT_MAP(CTableTd)
+    CONNECTION_POINT_ENTRY(__uuidof(_ITableEvents))
+    END_CONNECTION_POINT_MAP()
+
+
     DECLARE_PROTECT_FINAL_CONSTRUCT()
 
     HRESULT FinalConstruct() { return S_OK; }
@@ -77,9 +90,9 @@ public:
     STDMETHOD(Seek)(eLockType lockBias);
     STDMETHOD(SeekGreater)(VARIANT_BOOL orEqual, eLockType lockBias);
     STDMETHOD(SeekLessThan)(VARIANT_BOOL orEqual, eLockType lockBias);
-    STDMETHOD(get_BookMark)(long* Value);
-    STDMETHOD(SeekByBookMark)(long Value, eLockType lockBias);
-    STDMETHOD(get_Percentage)(long* Value);
+    STDMETHOD(get_Bookmark)(IBookmark** Value);
+    STDMETHOD(SeekByBookmark)(IBookmark* bm, eLockType lockBias);
+    STDMETHOD(get_Percentage)(VARIANT param, long* Value);
     STDMETHOD(get_RecordLength)(long* Value);
     STDMETHOD(RecordCount)(VARIANT_BOOL estimate, VARIANT_BOOL fromCurrent,
                            long* Value);
@@ -126,15 +139,15 @@ public:
     STDMETHOD(SetAccessRights)(unsigned char curd);
     STDMETHOD(SetOwnerName)(BSTR* name, short enctype);
     STDMETHOD(TdapErr)(OLE_HANDLE hWnd, BSTR* Value);
-    STDMETHOD(Unlock_)(unsigned int bm);
+    STDMETHOD(Unlock_)();
     STDMETHOD(get_BlobFieldUsed)(VARIANT_BOOL* Value);
-    STDMETHOD(get_BookmarkFindCurrent)(unsigned int* Value);
-    STDMETHOD(get_BookMarksCount)(int* Value);
+    STDMETHOD(get_BookmarkFindCurrent)(IBookmark** Value);
+    STDMETHOD(get_BookmarksCount)(int* Value);
     STDMETHOD(Find)(eFindType FindType);
     STDMETHOD(get_RecordHash)(unsigned int* Value);
     STDMETHOD(get_LogicalToString)(VARIANT_BOOL* Value);
     STDMETHOD(put_LogicalToString)(VARIANT_BOOL Value);
-    STDMETHOD(MoveBookmarksId)(long Value);
+    STDMETHOD(MoveBookmarks)(long Value);
     STDMETHOD(get_MyDateTimeValueByBtrv)(VARIANT_BOOL* Value);
     STDMETHOD(get_ValiableFormatType)(VARIANT_BOOL* Value);
     STDMETHOD(SmartUpdate)(void);
@@ -145,5 +158,7 @@ public:
     STDMETHOD(FieldNumByName)(BSTR Name, short* Value);
     STDMETHOD(get_StatReasonOfFind)(short* Value);
     STDMETHOD(get_LastFindDirection)(short* Value);
+    STDMETHOD(get_BookmarkLen)(unsigned short* Value);
+    STDMETHOD(get_Bookmarks)(long index, IBookmark** Value);
 
 };

data/source/global/tdclatl/_IDatabaseEvents_CP.h

@@ -118,3 +118,42 @@ public:
         return hr;
     }
 };
+
+
+template <class T>
+class CProxy_ITableEvents
+    : public ATL::IConnectionPointImpl<T, &__uuidof(_ITableEvents)>
+{
+public:
+    HRESULT Fire_OnRecordCount(ITable* tb, int count, VARIANT_BOOL* cancel)
+    {
+        HRESULT hr = S_OK;
+        T* pThis = static_cast<T*>(this);
+        int cConnections = m_vec.GetSize();
+
+        for (int iConnection = 0; iConnection < cConnections; iConnection++)
+        {
+            pThis->Lock();
+            CComPtr<IUnknown> punkConnection = m_vec.GetAt(iConnection);
+            pThis->Unlock();
+
+            IDispatch* pConnection = static_cast<IDispatch*>(punkConnection.p);
+
+            if (pConnection)
+            {
+                CComVariant avarParams[3];
+                avarParams[2] = tb;
+                avarParams[1] = count;
+                avarParams[0].byref = cancel;
+                avarParams[0].vt = VT_BOOL | VT_BYREF;
+                CComVariant varResult;
+
+                DISPPARAMS params = { avarParams, NULL, 3, 0 };
+                hr = pConnection->Invoke(1, IID_NULL, LOCALE_USER_DEFAULT,
+                                         DISPATCH_METHOD, &params, &varResult,
+                                         NULL, NULL);
+            }
+        }
+        return hr;
+    }
+};

data/source/global/tdclatl/activeTable.cpp

@@ -43,7 +43,7 @@ void CActiveTable::FinalRelease()
         m_at->release();
 }
 
-STDMETHODIMP CActiveTable::SetDatabase(VARIANT Value, BSTR tableName)
+STDMETHODIMP CActiveTable::SetDatabase(VARIANT Value, BSTR tableName, short mode)
 {
     try
     {
@@ -64,7 +64,7 @@ STDMETHODIMP CActiveTable::SetDatabase(VARIANT Value, BSTR tableName)
         CDatabase* p = dynamic_cast<CDatabase*>(Value.pdispVal);
         if (p)
         {
-            m_at = activeTable::create(p->database(), tableName);
+            m_at = activeTable::create(p->database(), tableName, mode);
             m_at->table()->setOptionalData((void*)p->database());
             return S_OK;
         }

data/source/global/tdclatl/activeTable.h

@@ -54,7 +54,7 @@ public:
     void FinalRelease();
 
 public:
-    STDMETHOD(SetDatabase)(VARIANT Value, BSTR tableName);
+    STDMETHOD(SetDatabase)(VARIANT Value, BSTR tableName, short mode);
 
     STDMETHOD(Index)(short Value, IActiveTable** retVal);
     STDMETHOD(KeyValue)(VARIANT Value0, VARIANT Value1, VARIANT Value2,