transactd 2.4.5 → 3.0.0

data/source/global/tdclatl/Table.cpp

@@ -25,6 +25,7 @@
 #include "PreparedQuery.h"
 #include <bzs/db/protocol/tdap/client/fields.h>
 #include "Bookmark.h"
+#include "Bitset.h"
 
 using namespace bzs::db::protocol::tdap;
 
@@ -48,8 +49,10 @@ short CTableTd::GetFieldNum(VARIANT* Index)
     short index = -1;
     if (Index->vt == VT_BSTR)
         index = m_tb->fieldNumByName(Index->bstrVal);
-    else if ((Index->vt == VT_I2) || (Index->vt == VT_I4))
+    else if (Index->vt == VT_I2)
         index = Index->iVal;
+    else if (Index->vt == VT_I4)
+        index = (short)Index->lVal;
     return index;
 }
 
@@ -90,6 +93,100 @@ STDMETHODIMP CTableTd::put_Vlng(VARIANT Index, int Value)
     return S_OK;
 }
 
+STDMETHODIMP CTableTd::SetFVNull(VARIANT Index, VARIANT_BOOL Value)
+{
+    short index = GetFieldNum(&Index);
+    if (index < 0)
+        return Error("Invalid index", IID_ITable);
+    m_tb->setFVNull(index, Value != 0);
+    return S_OK;
+}
+
+STDMETHODIMP CTableTd::GetFVNull(VARIANT Index, VARIANT_BOOL* Value)
+{
+    short index = GetFieldNum(&Index);
+    if (index < 0)
+        return Error("Invalid index", IID_ITable);
+    *Value = m_tb->getFVNull(index);
+    return S_OK;
+}
+
+
+STDMETHODIMP CTableTd::GetFVint(VARIANT Index, int* Value)
+{
+    short index = GetFieldNum(&Index);
+    if (index < 0)
+        return Error("Invalid index", IID_ITable);
+    *Value = m_tb->getFVint(index);
+    return S_OK;
+}
+
+STDMETHODIMP CTableTd::GetFV64(VARIANT Index, __int64* Value)
+{
+    short index = GetFieldNum(&Index);
+    if (index < 0)
+        return Error("Invalid index", IID_ITable);
+    *Value = m_tb->getFV64(index);
+    return S_OK;
+}
+
+STDMETHODIMP CTableTd::GetFVdbl(VARIANT Index, double* Value)
+{
+    short index = GetFieldNum(&Index);
+    if (index < 0)
+        return Error("Invalid index", IID_ITable);
+    *Value = m_tb->getFVdbl(index);
+    return S_OK;
+}
+
+STDMETHODIMP CTableTd::GetFVstr(VARIANT Index, BSTR* Value)
+{
+    short index = GetFieldNum(&Index);
+    if (index < 0)
+        return Error("Invalid index", IID_ITable);
+
+    *Value = ::SysAllocString(m_tb->getFVstr(index));
+    return S_OK;
+}
+
+STDMETHODIMP CTableTd::SetFV(VARIANT Index, VARIANT Value)
+{
+    short index = GetFieldNum(&Index);
+    if (index < 0)
+        return Error("Invalid index", IID_ITable);
+
+    if (Value.vt == VT_BSTR)
+        m_tb->setFV(index, Value.bstrVal);
+    else if (Value.vt == VT_R4)
+        m_tb->setFV(index, Value.fltVal);
+    else if (Value.vt == VT_R8)
+        m_tb->setFV(index, Value.dblVal);
+    else if (Value.vt == VT_I2)
+        m_tb->setFV(index, Value.iVal);
+    else if (Value.vt == VT_I4 || Value.vt == VT_INT)
+        m_tb->setFV(index, Value.lVal);
+    else if (Value.vt == VT_I8)
+        m_tb->setFV(index, Value.llVal);
+    else if (Value.vt == VT_NULL)
+        m_tb->setFV(index, (wchar_t*)NULL);
+    else if ((Value.vt == VT_DISPATCH) && Value.pdispVal)
+    {
+        CBitset* b = dynamic_cast<CBitset*>(Value.pdispVal);
+        if (b)
+            m_tb->setFV(index, b->m_bitset.internalValue());    
+    }
+    else
+    {
+        VariantChangeType( &Value, &Value, 0, VT_BSTR );
+        if (Value.bstrVal[0])
+            m_tb->setFV(index, Value.bstrVal);
+        else
+            m_tb->setFV(index, L"");
+    }
+    return S_OK;
+}
+
+
 STDMETHODIMP CTableTd::get_V64(VARIANT Index, __int64* Value)
 {
     short index = GetFieldNum(&Index);
@@ -182,9 +279,11 @@ STDMETHODIMP CTableTd::Delete(VARIANT_BOOL inkey)
     return S_OK;
 }
 
-STDMETHODIMP CTableTd::ClearBuffer()
+STDMETHODIMP CTableTd::ClearBuffer(eNullReset resetType)
 {
-    m_tb->clearBuffer();
+  
+    m_tb->clearBuffer((resetType == defaultNull) ? 
+            client::table::defaultNull : client::table::clearNull);
     return S_OK;
 }
 
@@ -728,6 +827,31 @@ STDMETHODIMP CTableTd::get_Bookmarks(long index, IBookmark** retVal)
     return S_OK;
 }
 
+STDMETHODIMP CTableTd::SetTimestampMode(eTimeStampMode mode)
+{
+    m_tb->setTimestampMode((int)mode);
+    return S_OK;
+}
+
+STDMETHODIMP CTableTd::GetFVbits(VARIANT Index, IBitset** Value)
+{
+    short index = GetFieldNum(&Index);
+    if (index < 0)
+        return Error("Invalid index", IID_ITable);
+    
+    CComObject<CBitset>* b;
+    CComObject<CBitset>::CreateInstance(&b);
+    if (!b)
+        return Error("CreateInstance Bitset", IID_ITable);
+    b->m_bitset = bzs::db::protocol::tdap::bitset(m_tb->getFV64(index));
+    CBitset* bi;
+    b->QueryInterface(IID_IBitset, (void**)&bi);
+    _ASSERTE(bi);
+    *Value = bi;
+    return S_OK;
+}
+   
+
 void __stdcall onRecordCount(bzs::db::protocol::tdap::client::table* tb,
                           int count, bool& cancel)
 {

data/source/global/tdclatl/Table.h

@@ -85,7 +85,7 @@ public:
     STDMETHOD(get_TableDef)(ITableDef** Value);
     STDMETHOD(Insert)(eUpdateType ncc);
     STDMETHOD(Delete)(VARIANT_BOOL inkey);
-    STDMETHOD(ClearBuffer)();
+    STDMETHOD(ClearBuffer)(eNullReset resetType);
     STDMETHOD(Close)();
     STDMETHOD(SeekFirst)(eLockType lockBias);
     STDMETHOD(SeekLast)(eLockType lockBias);
@@ -165,5 +165,14 @@ public:
     STDMETHOD(get_LastFindDirection)(short* Value);
     STDMETHOD(get_BookmarkLen)(unsigned short* Value);
     STDMETHOD(get_Bookmarks)(long index, IBookmark** Value);
+    STDMETHOD(GetFVNull)(VARIANT Index, VARIANT_BOOL* Value);
+    STDMETHOD(SetFVNull)(VARIANT Index, VARIANT_BOOL Value);
+    STDMETHOD(GetFVint)(VARIANT Index, int* Value);
+    STDMETHOD(GetFV64)(VARIANT Index, __int64* Value);
+    STDMETHOD(GetFVdbl)(VARIANT Index, double* Value);
+    STDMETHOD(GetFVstr)(VARIANT Index, BSTR* Value);
+    STDMETHOD(SetFV)(VARIANT Index, VARIANT Value);
+    STDMETHOD(SetTimestampMode)(eTimeStampMode mode);
+    STDMETHOD(GetFVbits)(VARIANT Index, IBitset** Value);
 
 };

data/source/global/tdclatl/TableDef.cpp

@@ -276,15 +276,9 @@ STDMETHODIMP CTableDef::put_FixedRecordLen(unsigned short Value)
     return S_OK;
 }
 
-STDMETHODIMP CTableDef::get_MaxRecordLen(unsigned short* Value)
+STDMETHODIMP CTableDef::get_RecordLen(unsigned short* Value)
 {
-    *Value = (*m_tabledefPtr)->maxRecordLen;
-    return S_OK;
-}
-
-STDMETHODIMP CTableDef::put_MaxRecordLen(unsigned short Value)
-{
-    (*m_tabledefPtr)->maxRecordLen = Value;
+    *Value = (*m_tabledefPtr)->recordlen();
     return S_OK;
 }
 
@@ -305,3 +299,42 @@ STDMETHODIMP CTableDef::get_Version(unsigned short* Value)
     *Value = (*m_tabledefPtr)->version;
     return S_OK;
 }
+
+STDMETHODIMP CTableDef::get_FieldNumByName(BSTR Name, short* Value)
+{
+    *Value = (*m_tabledefPtr)->fieldNumByName(Name);
+    return S_OK;
+}
+
+STDMETHODIMP CTableDef::get_Nullfields(short* Value)
+{
+    *Value = (*m_tabledefPtr)->nullfields();
+    return S_OK;
+}
+
+STDMETHODIMP CTableDef::get_InUse(short* Value)
+{
+    *Value = (*m_tabledefPtr)->inUse();
+    return S_OK;
+}
+
+STDMETHODIMP CTableDef::get_MysqlNullMode(VARIANT_BOOL* Value)
+{
+    *Value = (*m_tabledefPtr)->isMysqlNullMode();
+    return S_OK;
+}
+
+STDMETHODIMP CTableDef::get_Size(int* Value)
+{
+    *Value = (*m_tabledefPtr)->size();
+    return S_OK;
+}
+
+STDMETHODIMP CTableDef::SetValidationTarget(VARIANT_BOOL isMariadb, short srvMinorVersion)
+{
+    (*m_tabledefPtr)->setValidationTarget(isMariadb, (uchar_td)srvMinorVersion);
+    return S_OK;
+}
+
+
+

data/source/global/tdclatl/TableDef.h

@@ -80,9 +80,14 @@ public:
     STDMETHOD(put_PrimaryKeyNum)(unsigned char Value);
     STDMETHOD(get_FixedRecordLen)(unsigned short* Value);
     STDMETHOD(put_FixedRecordLen)(unsigned short Value);
-    STDMETHOD(get_MaxRecordLen)(unsigned short* Value);
-    STDMETHOD(put_MaxRecordLen)(unsigned short Value);
+    STDMETHOD(get_RecordLen)(unsigned short* Value);
     STDMETHOD(get_SchemaCodePage)(unsigned int* Value);
     STDMETHOD(put_SchemaCodePage)(unsigned int Value);
     STDMETHOD(get_Version)(unsigned short* Value);
+    STDMETHOD(get_FieldNumByName)(BSTR Name, short* Value);
+    STDMETHOD(get_Nullfields)(short* Value);
+    STDMETHOD(get_InUse)(short* Value);
+    STDMETHOD(get_MysqlNullMode)(VARIANT_BOOL* Value);
+    STDMETHOD(get_Size)(int* Value);
+    STDMETHOD(SetValidationTarget)(VARIANT_BOOL isMariadb, short srvMinorVersion);
 };

data/source/global/tdclatl/activeTable.cpp

@@ -26,6 +26,7 @@
 #include "PooledDbManager.h"
 #include "PreparedQuery.h"
 #include "Table.h"
+#include "Bitset.h"
 
 using namespace bzs::db::protocol::tdap::client;
 using namespace bzs::db::protocol::tdap;
@@ -105,85 +106,53 @@ STDMETHODIMP CActiveTable::Index(short Value, IActiveTable** retVal)
     }
 }
 
+wchar_t* convWCHAR(VARIANT& Value)
+{
+    wchar_t* v = NULL;
+    
+    if ((Value.vt == VT_DISPATCH) && Value.pdispVal)
+    {
+        CBitset* b = dynamic_cast<CBitset*>(Value.pdispVal);
+        if (b)
+        {
+            VariantInit(&Value);
+            Value.vt = VT_UI8;
+            Value.ullVal = b->m_bitset.internalValue(); 
+        }
+    }
+    if (Value.vt == VT_NULL)
+        v = NULL;
+    else if (Value.vt != VT_BSTR)
+    {
+        VariantChangeType(&Value, &Value, 0, VT_BSTR);
+        v = Value.bstrVal;
+    } 
+    else
+        v = Value.bstrVal;
+
+    return v;
+
+}
+
 STDMETHODIMP CActiveTable::KeyValue(VARIANT Value0, VARIANT Value1,
                                     VARIANT Value2, VARIANT Value3,
                                     VARIANT Value4, VARIANT Value5,
                                     VARIANT Value6, VARIANT Value7,
                                     IActiveTable** retVal)
 {
-
     try
     {
-        if (Value0.vt != VT_BSTR)
-            VariantChangeType(&Value0, &Value0, 0, VT_BSTR);
-
-        if (Value1.vt != VT_BSTR)
-            VariantChangeType(&Value1, &Value1, 0, VT_BSTR);
-        if (!Value1.bstrVal || !Value1.bstrVal[0])
-        {
-            m_at->keyValue(Value0.bstrVal);
-            setResult(retVal);
-            return S_OK;
-        }
-
-        if (Value2.vt != VT_BSTR)
-            VariantChangeType(&Value2, &Value2, 0, VT_BSTR);
-        if (!Value2.bstrVal || !Value2.bstrVal[0])
-        {
-            m_at->keyValue(Value0.bstrVal, Value1.bstrVal);
-            setResult(retVal);
-            return S_OK;
-        }
-        if (Value3.vt != VT_BSTR)
-            VariantChangeType(&Value3, &Value3, 0, VT_BSTR);
-        if (!Value3.bstrVal || !Value3.bstrVal[0])
-        {
-            m_at->keyValue(Value0.bstrVal, Value1.bstrVal, Value2.bstrVal);
-            setResult(retVal);
-            return S_OK;
-        }
-        if (Value4.vt != VT_BSTR)
-            VariantChangeType(&Value4, &Value4, 0, VT_BSTR);
-        if (!Value4.bstrVal || !Value4.bstrVal[0])
-        {
-            m_at->keyValue(Value0.bstrVal, Value1.bstrVal, Value2.bstrVal,
-                           Value3.bstrVal);
-            setResult(retVal);
-            return S_OK;
-        }
-
-        if (Value5.vt != VT_BSTR)
-            VariantChangeType(&Value5, &Value5, 0, VT_BSTR);
-        if (!Value5.bstrVal || !Value5.bstrVal[0])
-        {
-            m_at->keyValue(Value0.bstrVal, Value1.bstrVal, Value2.bstrVal,
-                           Value3.bstrVal, Value4.bstrVal);
-            setResult(retVal);
-            return S_OK;
-        }
-        if (Value6.vt != VT_BSTR)
-            VariantChangeType(&Value6, &Value6, 0, VT_BSTR);
-        if (!Value6.bstrVal || !Value6.bstrVal[0])
-        {
-            m_at->keyValue(Value0.bstrVal, Value1.bstrVal, Value2.bstrVal,
-                           Value3.bstrVal, Value4.bstrVal, Value5.bstrVal);
-            setResult(retVal);
-            return S_OK;
-        }
-
-        if (Value7.vt != VT_BSTR)
-            VariantChangeType(&Value7, &Value7, 0, VT_BSTR);
-        if (!Value7.bstrVal || !Value7.bstrVal[0])
-        {
-            m_at->keyValue(Value0.bstrVal, Value1.bstrVal, Value2.bstrVal,
-                           Value3.bstrVal, Value4.bstrVal, Value5.bstrVal,
-                           Value6.bstrVal);
-            setResult(retVal);
-            return S_OK;
-        }
-        m_at->keyValue(Value0.bstrVal, Value1.bstrVal, Value2.bstrVal,
-                       Value3.bstrVal, Value4.bstrVal, Value5.bstrVal,
-                       Value6.bstrVal, Value7.bstrVal);
+        wchar_t* v[8] = {NULL};
+        v[0] = convWCHAR(Value0);
+        v[1] = convWCHAR(Value1);
+        v[2] = convWCHAR(Value2);
+        v[3] = convWCHAR(Value3);
+        v[4] = convWCHAR(Value4);
+        v[5] = convWCHAR(Value5);
+        v[6] = convWCHAR(Value6);
+        v[7] = convWCHAR(Value7);
+
+        m_at->keyValue(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
         setResult(retVal);
         return S_OK;
     }