transactd 2.4.5 → 3.0.0

data/source/global/tdclatl/Field.h

@@ -49,14 +49,28 @@ public:
     void FinalRelease() {}
 
 public:
-    STDMETHOD(get_Text)(BSTR* Value);
-    STDMETHOD(get_Vlng)(int* Value);
     STDMETHOD(put_Text)(BSTR Value);
+    STDMETHOD(get_Text)(BSTR* Value);
     STDMETHOD(put_Vlng)(int Value);
-    STDMETHOD(get_V64)(__int64* Value);
+    STDMETHOD(get_Vlng)(int* Value);
     STDMETHOD(put_V64)(__int64 Value);
-    STDMETHOD(get_Vbin)(BSTR* Value);
+    STDMETHOD(get_V64)(__int64* Value);
+    STDMETHOD(put_Vdbl)(double Value);
     STDMETHOD(get_Vdbl)(double* Value);
     STDMETHOD(put_Vbin)(BSTR Value);
-    STDMETHOD(put_Vdbl)(double Value);
+    STDMETHOD(get_Vbin)(BSTR* Value);
+
+    STDMETHOD(IsNull)(VARIANT_BOOL* Value);
+    STDMETHOD(SetNull)(VARIANT_BOOL Value);
+    STDMETHOD(SetValue)(VARIANT Value);
+    STDMETHOD(SetBin)(BSTR Value);
+    STDMETHOD(I)(int* Value);
+    STDMETHOD(I64)(__int64* Value);
+    STDMETHOD(D)(double* Value);
+    STDMETHOD(Bin)(BSTR* Value);
+    STDMETHOD(Str)(BSTR* Value);
+    STDMETHOD(get_Type)(short* Value);
+    STDMETHOD(get_Len)(short* Value);
+    STDMETHOD(GetBits)(IBitset** Value);
+
 };

data/source/global/tdclatl/FieldDef.cpp

@@ -19,6 +19,8 @@
 #include "stdafx.h"
 #include "FieldDef.h"
 #include "Flags.h"
+#include "Bitset.h"
+
 STDMETHODIMP CFieldDef::InterfaceSupportsErrorInfo(REFIID riid)
 {
 	static const IID* const arr[] = 
@@ -122,20 +124,6 @@ STDMETHODIMP CFieldDef::put_Min(double Value)
     return S_OK;
 }
 
-STDMETHODIMP CFieldDef::get_DefValue(double* Value)
-{
-    *Value = const_fielddef()->defValue;
-    return S_OK;
-}
-
-STDMETHODIMP CFieldDef::put_DefValue(double Value)
-{
-    if (!isWritabale())
-        return write_error();
-    fielddef()->defValue = Value;
-    return S_OK;
-}
-
 STDMETHODIMP CFieldDef::get_LookTable(unsigned char* Value)
 {
     *Value = const_fielddef()->lookTable;
@@ -299,12 +287,145 @@ STDMETHODIMP CFieldDef::SetPadCharSettings(VARIANT_BOOL set, VARIANT_BOOL trim)
 
 STDMETHODIMP CFieldDef::get_UsePadChar(VARIANT_BOOL* Value)
 {
-	*Value = fielddef()->usePadChar();
+	*Value = fielddef()->isUsePadChar();
     return S_OK;
 }
 
 STDMETHODIMP CFieldDef::get_TrimPadChar(VARIANT_BOOL* Value)
 {
-	*Value = fielddef()->trimPadChar();
+	*Value = fielddef()->isTrimPadChar();
     return S_OK;
 }
+
+STDMETHODIMP CFieldDef::put_DefaultValue(VARIANT Value)
+{
+    if (Value.vt == VT_BSTR)
+        fielddef()->setDefaultValue(Value.bstrVal);
+    else if (Value.vt == VT_R4)
+        fielddef()->setDefaultValue(Value.fltVal);
+    else if (Value.vt == VT_R8)
+        fielddef()->setDefaultValue(Value.dblVal);
+    else if (Value.vt == VT_I2)
+        fielddef()->setDefaultValue((__int64)Value.iVal);
+    else if (Value.vt == VT_I4 || Value.vt == VT_INT)
+        fielddef()->setDefaultValue((__int64)Value.lVal);
+    else if (Value.vt == VT_I8)
+        fielddef()->setDefaultValue((__int64)Value.llVal);
+    else if ((Value.vt == VT_DISPATCH) && Value.pdispVal)
+    {
+        CBitset* b = dynamic_cast<CBitset*>(Value.pdispVal);
+        if (b)
+            fielddef()->setDefaultValue(b->m_bitset.internalValue());
+        else
+            return Error("FieldDef DefaultValue param", IID_IFieldDef);
+    }
+    else
+    {
+        VariantChangeType( &Value, &Value, 0, VT_BSTR );
+        if (Value.bstrVal[0])
+            fielddef()->setDefaultValue(Value.bstrVal);
+    }
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_DefaultValue(VARIANT* Value)
+{
+    CComBSTR ret;
+    ret = const_fielddef()->defaultValue_str();
+
+    VariantClear(Value);
+    Value->vt = VT_BSTR;
+    Value->bstrVal = ret.Copy();
+
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_PadCharType(VARIANT_BOOL* Value)
+{
+	*Value = const_fielddef()->isPadCharType();
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_DateTimeType(VARIANT_BOOL* Value)
+{
+	*Value = const_fielddef()->isDateTimeType();
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_ValidCharNum(VARIANT_BOOL* Value)
+{
+	*Value = const_fielddef()->isValidCharNum();
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_Nullable(VARIANT_BOOL* Value)
+{
+	*Value = const_fielddef()->isNullable();
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::SetNullable(VARIANT_BOOL Value, VARIANT_BOOL DefaultNull)
+{
+	fielddef()->setNullable(Value != 0, DefaultNull != 0);
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::put_TimeStampOnUpdate(VARIANT_BOOL Value)
+{
+	fielddef()->setTimeStampOnUpdate(Value != 0);
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_TimeStampOnUpdate(VARIANT_BOOL* Value)
+{
+	*Value = const_fielddef()->isTimeStampOnUpdate();
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_DefaultNull(VARIANT_BOOL* Value)
+{
+	*Value = const_fielddef()->isDefaultNull();
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::put_Digits(short Value)
+{
+	fielddef()->digits = Value;
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_Digits(short* Value)
+{
+	*Value = fielddef()->digits;
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_IsIntegerType(VARIANT_BOOL* Value)
+{
+	*Value = fielddef()->isIntegerType();
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_IsNumericType(VARIANT_BOOL* Value)
+{
+	*Value = fielddef()->isNumericType();
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_IsDateTimeType(VARIANT_BOOL* Value)
+{
+	*Value = fielddef()->isDateTimeType();
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::SetDecimalDigits(int Digits, int Decimals)
+{
+	fielddef()->setDecimalDigits(Digits, Decimals);
+    return S_OK;
+}
+
+
+
+
+
+

data/source/global/tdclatl/FieldDef.h

@@ -77,14 +77,12 @@ public:
     STDMETHOD(get_Decimals)(unsigned char* Value);
     STDMETHOD(get_Max)(double* Value);
     STDMETHOD(get_Min)(double* Value);
-    STDMETHOD(get_DefValue)(double* Value);
     STDMETHOD(get_LookTable)(unsigned char* Value);
     STDMETHOD(get_LookField)(unsigned char* Value);
     STDMETHOD(get_LookViewField)(short Index, unsigned char* Value);
     STDMETHOD(get_EnableFlags)(IFlags** Value);
 
     STDMETHOD(put_Decimals)(unsigned char Value);
-    STDMETHOD(put_DefValue)(double Value);
     STDMETHOD(put_EnableFlags)(IFlags* Value);
     STDMETHOD(put_Len)(short Value);
     STDMETHOD(put_LookField)(unsigned char Value);
@@ -110,5 +108,23 @@ public:
 	STDMETHOD(SetPadCharSettings)(VARIANT_BOOL set, VARIANT_BOOL trim);
 	STDMETHOD(get_UsePadChar)(VARIANT_BOOL* Value);
 	STDMETHOD(get_TrimPadChar)(VARIANT_BOOL* Value);
+    
+    STDMETHOD(put_DefaultValue)(VARIANT Value);
+    STDMETHOD(get_DefaultValue)(VARIANT* Value);
+
+    STDMETHOD(get_PadCharType)(VARIANT_BOOL* Value);
+    STDMETHOD(get_DateTimeType)(VARIANT_BOOL* Value);
+    STDMETHOD(get_ValidCharNum)(VARIANT_BOOL* Value);
+    STDMETHOD(get_Nullable)(VARIANT_BOOL* Value);
+    STDMETHOD(SetNullable)(VARIANT_BOOL Value, VARIANT_BOOL DefaultNull);
+    STDMETHOD(put_TimeStampOnUpdate)(VARIANT_BOOL Value);
+    STDMETHOD(get_TimeStampOnUpdate)(VARIANT_BOOL* Value);
+    STDMETHOD(get_DefaultNull)(VARIANT_BOOL* Value);
+    STDMETHOD(put_Digits)(short Value);
+    STDMETHOD(get_Digits)(short* Value);
+    STDMETHOD(get_IsIntegerType)(VARIANT_BOOL* Value);
+    STDMETHOD(get_IsNumericType)(VARIANT_BOOL* Value);
+    STDMETHOD(get_IsDateTimeType)(VARIANT_BOOL* Value);
+    STDMETHOD(SetDecimalDigits)(int Digits, int Decimals);
 
 };

data/source/global/tdclatl/FieldDefs.cpp

@@ -19,6 +19,9 @@
 #include "stdafx.h"
 #include "FieldDefs.h"
 #include "FieldDef.h"
+#include "TableDef.h"
+#include "Table.h"
+
 STDMETHODIMP CFieldDefs::InterfaceSupportsErrorInfo(REFIID riid)
 {
 	static const IID* const arr[] = 
@@ -45,8 +48,10 @@ short CFieldDefs::GetFieldNum(VARIANT* Index)
     short index = -1;
     if (Index->vt == VT_BSTR)
         index = m_fds->indexByName(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;
 }
 
@@ -81,3 +86,51 @@ STDMETHODIMP CFieldDefs::get_Size(short* retVal)
     *retVal = (short)m_fds->size();
     return S_OK;
 }
+
+/*
+STDMETHODIMP CFieldDefs::AddAllFileds(ITableDef* Def)
+{
+    try
+    {
+        if (Def)
+        {
+            CTableDef* def = dynamic_cast<CTableDef*>(Def);
+            if (def)
+            {
+                const_cast<bzs::db::protocol::tdap::client::fielddefs*>(m_fds)
+                    ->addAllFileds(*(def->m_tabledefPtr));
+                return S_OK;
+            }
+        }
+        return Error("Invalid param Def", IID_IFieldDefs);
+        
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IFieldDefs);
+    }
+}
+
+STDMETHODIMP CFieldDefs::AddSelectedFields(ITable* Table)
+{
+    try
+    {
+        if (Table)
+        {
+            CTableTd* tb = dynamic_cast<CTableTd*>(Table);
+            if (tb)
+            {
+                const_cast<bzs::db::protocol::tdap::client::fielddefs*>(m_fds)
+                    ->addSelectedFields(tb->m_tb.get());
+                return S_OK;
+            }
+        }
+        return Error("Invalid param Def", IID_IFieldDefs);
+        
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IFieldDefs);
+    }
+
+}*/

data/source/global/tdclatl/FieldDefs.h

@@ -57,4 +57,7 @@ public:
     STDMETHOD(IndexByName)(BSTR Name, short* retVal);
     STDMETHOD(get_FieldDef)(VARIANT Name, IFieldDef** retVal);
     STDMETHOD(get_Size)(short* retVal);
+    //STDMETHOD(AddAllFileds)(ITableDef* Def);
+    //STDMETHOD(AddSelectedFields)(ITable* Table);
+
 };

data/source/global/tdclatl/GroupQuery.cpp

@@ -92,25 +92,25 @@ STDMETHODIMP CGroupQuery::AddFunction(eGroupFunc func, VARIANT targetNames,
     if (targetNames.vt == VT_DISPATCH)
         fn = dynamic_cast<CFieldNames*>(targetNames.pdispVal);
         
-    if ((func != fcount) && !fn)
+    if ((func != f_count) && !fn)
         return Error("Invalid targetNames", IID_IGroupQuery);
     if (fn)
         fns = fn->m_fnsPtr;
     boost::shared_ptr<groupFuncBase> f;
     
-    if (func == fsum)
+    if (func == f_sum)
         f.reset(sum::create(*fns, resultName), boost::bind(&sum::release, _1));
-    else if (func == fmin)
+    else if (func == f_min)
         f.reset(min::create(*fns, resultName), boost::bind(&min::release, _1));
-    else if (func == fmax)
+    else if (func == f_max)
         f.reset(max::create(*fns, resultName), boost::bind(&max::release, _1));
-    else if (func == favg)
+    else if (func == f_avg)
         f.reset(avg::create(*fns, resultName), boost::bind(&avg::release, _1));
-    else if (func == ffirst)
+    else if (func == f_first)
         f.reset(first::create(*fns, resultName), boost::bind(&first::release, _1));
-    else if (func == flast)
+    else if (func == f_last)
         f.reset(last::create(*fns, resultName), boost::bind(&last::release, _1));
-    else if (func == fcount)
+    else if (func == f_count)
     {
         if (resultName[0])
             f.reset(count::create(resultName), boost::bind(&count::release, _1));

data/source/global/tdclatl/QueryBase.cpp

@@ -367,3 +367,68 @@ STDMETHODIMP CQueryBase::IsSeekByBookmarks(VARIANT_BOOL* retVal)
     *retVal = m_qb.isSeekByBookmarks();
     return S_OK;
 }
+
+
+STDMETHODIMP CQueryBase::WhereIsNull(BSTR Name, IQueryBase** retVal)
+{
+    m_qb.addLogic(Name, _T("<==>"), _T(""));
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CQueryBase::AndIsNull(BSTR Name,IQueryBase** retVal)
+{
+    m_qb.addLogic(_T("and"), Name, _T("<==>"), _T(""));
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CQueryBase::OrIsNull(BSTR Name, IQueryBase** retVal)
+{
+    m_qb.addLogic(_T("or"), Name, _T("<==>"), _T(""));
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CQueryBase::WhereIsNotNull(BSTR Name, IQueryBase** retVal)
+{
+    m_qb.addLogic(Name, _T("<!=>"), _T(""));
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CQueryBase::AndIsNotNull(BSTR Name,IQueryBase** retVal)
+{
+    m_qb.addLogic(_T("and"), Name, _T("<!=>"), _T(""));
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CQueryBase::OrIsNotNull(BSTR Name, IQueryBase** retVal)
+{
+    m_qb.addLogic(_T("or"), Name, _T("<!=>"), _T(""));
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CQueryBase::SegmentsForInValue(int Value, IQueryBase** retVal)
+{
+    m_qb.joinKeySize(Value);
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CQueryBase::JoinKeySize(int Value, IQueryBase** retVal)
+{
+    m_qb.joinKeySize(Value);
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CQueryBase::GetJoinKeySize(int* retVal)
+{
+    *retVal = m_qb.getJoinKeySize();
+    return S_OK;
+}
+
+

data/source/global/tdclatl/QueryBase.h

@@ -96,6 +96,16 @@ public:
     STDMETHOD(IsSeekByBookmarks)(VARIANT_BOOL* retVal);
     STDMETHOD(AddSeekKeyValue)(VARIANT Value, VARIANT_BOOL Reset);
     STDMETHOD(AddSeekBookmark)(VARIANT Value, VARIANT_BOOL Reset);
+    STDMETHOD(WhereIsNull)(BSTR Name, IQueryBase** retVal);
+    STDMETHOD(AndIsNull)(BSTR Name,IQueryBase** retVal);
+    STDMETHOD(OrIsNull)(BSTR Name, IQueryBase** retVal);
+    STDMETHOD(WhereIsNotNull)(BSTR Name, IQueryBase** retVal);
+    STDMETHOD(AndIsNotNull)(BSTR Name,IQueryBase** retVal);
+    STDMETHOD(OrIsNotNull)(BSTR Name, IQueryBase** retVal);
+    STDMETHOD(SegmentsForInValue)(int Value, IQueryBase** retVal);
+    STDMETHOD(JoinKeySize)(int Value, IQueryBase** retVal);
+    STDMETHOD(GetJoinKeySize)(int* retVal);
+
 
 };
 

data/source/global/tdclatl/Record.cpp

@@ -24,6 +24,8 @@
 
 void CRecord::FinalRelease()
 {
+    if (m_fieldDefsObj != NULL)
+        m_fieldDefsObj->Release();
     if (m_fieldObj != NULL)
         m_fieldObj->Release();
 }
@@ -32,8 +34,10 @@ 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))
+    else if (Index->vt == VT_I2)
         index = Index->iVal;
+    else if (Index->vt == VT_I4)
+        index = (short)Index->lVal;
     return index;
 }
 
@@ -86,6 +90,31 @@ STDMETHODIMP CRecord::get_Field(VARIANT Index, IField** retVal)
     }
 }
 
+STDMETHODIMP CRecord::get_FieldDefs(IFieldDefs** retVal)
+{
+    if (m_fieldDefsObj == NULL)
+    {
+        CComObject<CFieldDefs>::CreateInstance(&m_fieldDefsObj);
+        if (!m_fieldDefsObj)
+            return Error("CreateInstance FieldDefs", IID_IWritableRecord);
+        m_fieldDefsObj->AddRef();
+    }
+    try
+    {
+        m_fieldDefsObj->m_fds = m_rec->fieldDefs();
+        IFieldDefs* fds;
+        m_fieldDefsObj->QueryInterface(IID_IFieldDefs, (void**)&fds);
+        _ASSERTE(fds);
+        *retVal = fds;
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IWritableRecord);
+    }
+}
+
+
 STDMETHODIMP CRecord::get_IsInvalidRecord(VARIANT_BOOL* retVal)
 {
     *retVal = m_rec->isInvalidRecord();
@@ -122,8 +151,10 @@ 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))
+    else if (Index->vt == VT_I2)
         index = Index->iVal;
+    else if (Index->vt == VT_I4)
+        index = (short)Index->lVal;
     return index;
 }
 

data/source/global/tdclatl/Record.h

@@ -34,11 +34,12 @@ class ATL_NO_VTABLE CRecord
 {
 
     CComObject<CField>* m_fieldObj;
+    CComObject<CFieldDefs>* m_fieldDefsObj;
     short GetFieldNum(VARIANT* Index);
 
 public:
     bzs::db::protocol::tdap::client::fieldsBase* m_rec;
-    CRecord() : m_fieldObj(NULL) {}
+    CRecord() : m_fieldObj(NULL), m_fieldDefsObj(NULL) {}
 
     BEGIN_COM_MAP(CRecord)
     COM_INTERFACE_ENTRY(IRecord)
@@ -57,6 +58,7 @@ public:
 public:
     STDMETHOD(get_Size)(short* retVal);
     STDMETHOD(get_Field)(VARIANT Index, IField** retVal);
+    STDMETHOD(get_FieldDefs)(IFieldDefs** retVal);
     STDMETHOD(get_IsInvalidRecord)(VARIANT_BOOL* retVal);
 };
 

data/source/global/tdclatl/RecordsetQuery.cpp

@@ -75,6 +75,48 @@ STDMETHODIMP CRecordsetQuery::Or(BSTR Name, BSTR Logic, VARIANT Value,
     return S_OK;
 }
 
+STDMETHODIMP CRecordsetQuery::WhenIsNull(BSTR Name, IRecordsetQuery** retVal)
+{
+    m_qb.whenIsNull(Name);
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CRecordsetQuery::AndIsNull(BSTR Name, IRecordsetQuery** retVal)
+{
+    m_qb.andIsNull(Name);
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CRecordsetQuery::OrIsNull(BSTR Name, IRecordsetQuery** retVal)
+{
+    m_qb.orIsNull(Name);
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CRecordsetQuery::WhenIsNotNull(BSTR Name, IRecordsetQuery** retVal)
+{
+    m_qb.whenIsNotNull(Name);
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CRecordsetQuery::AndIsNotNull(BSTR Name, IRecordsetQuery** retVal)
+{
+    m_qb.andIsNotNull(Name);
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CRecordsetQuery::OrIsNotNull(BSTR Name, IRecordsetQuery** retVal)
+{
+    m_qb.orIsNotNull(Name);
+    setResult(retVal);
+    return S_OK;
+}
+
 STDMETHODIMP CSortField::get_Name(BSTR* Value)
 {
     return S_OK;

data/source/global/tdclatl/RecordsetQuery.h

@@ -64,6 +64,14 @@ public:
                    IRecordsetQuery** retVal);
     STDMETHOD(Or)(BSTR Name, BSTR Logic, VARIANT Value,
                   IRecordsetQuery** retVal);
+
+    STDMETHOD(WhenIsNull)(BSTR Name, IRecordsetQuery** retVal);
+    STDMETHOD(AndIsNull)(BSTR Name,IRecordsetQuery** retVal);
+    STDMETHOD(OrIsNull)(BSTR Name, IRecordsetQuery** retVal);
+    STDMETHOD(WhenIsNotNull)(BSTR Name, IRecordsetQuery** retVal);
+    STDMETHOD(AndIsNotNull)(BSTR Name,IRecordsetQuery** retVal);
+    STDMETHOD(OrIsNotNull)(BSTR Name, IRecordsetQuery** retVal);
+
 };
 
 class ATL_NO_VTABLE CSortField