diff options
Diffstat (limited to 'connectivity/source/drivers/ado/Awrapado.cxx')
| -rw-r--r-- | connectivity/source/drivers/ado/Awrapado.cxx | 894 |
1 files changed, 894 insertions, 0 deletions
diff --git a/connectivity/source/drivers/ado/Awrapado.cxx b/connectivity/source/drivers/ado/Awrapado.cxx new file mode 100644 index 000000000000..bc91fa2c2530 --- /dev/null +++ b/connectivity/source/drivers/ado/Awrapado.cxx @@ -0,0 +1,894 @@ +/************************************************************************* + * + * $RCSfile: Awrapado.cxx,v $ + * + * $Revision: 1.1 $ + * + * last change: $Author: oj $ $Date: 2001-05-14 11:42:44 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the License); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an AS IS basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ +#ifndef _CONNECTIVITY_ADO_AWRAPADO_HXX_ +#include "ado/Awrapado.hxx" +#endif + +using namespace connectivity::ado; + +ADOProperties* WpADOConnection::get_Properties() const +{ + ADOProperties* pProps=NULL; + pInterface->get_Properties(&pProps); + return pProps; +} + +rtl::OUString WpADOConnection::GetConnectionString() const +{ + OLEString aBSTR; + pInterface->get_ConnectionString(&aBSTR); + return aBSTR; +} + +sal_Bool WpADOConnection::PutConnectionString(const ::rtl::OUString &aCon) const +{ + OLEString bstr(aCon); + sal_Bool bErg = SUCCEEDED(pInterface->put_ConnectionString(bstr)); + + return bErg; +} + +sal_Int32 WpADOConnection::GetCommandTimeout() const +{ + sal_Int32 nRet=0; + pInterface->get_CommandTimeout(&nRet); + return nRet; +} + +void WpADOConnection::PutCommandTimeout(sal_Int32 nRet) +{ + pInterface->put_CommandTimeout(nRet); +} + +sal_Int32 WpADOConnection::GetConnectionTimeout() const +{ + sal_Int32 nRet=0; + pInterface->get_ConnectionTimeout(&nRet); + return nRet; +} + +void WpADOConnection::PutConnectionTimeout(sal_Int32 nRet) +{ + pInterface->put_ConnectionTimeout(nRet); +} + +sal_Bool WpADOConnection::Close( ) +{ + return (SUCCEEDED(pInterface->Close())); +} + +sal_Bool WpADOConnection::Execute(const ::rtl::OUString& _CommandText,OLEVariant& RecordsAffected,long Options, WpADORecordset** ppiRset) +{ + OLEString sStr1(_CommandText); + sal_Bool bErg = SUCCEEDED(pInterface->Execute(sStr1,&RecordsAffected,Options,(_ADORecordset**)ppiRset)); + return bErg; +} + +sal_Bool WpADOConnection::BeginTrans() +{ + sal_Int32 nIso=0; + return SUCCEEDED(pInterface->BeginTrans(&nIso)); +} + +sal_Bool WpADOConnection::CommitTrans( ) +{ + return SUCCEEDED(pInterface->CommitTrans()); +} + +sal_Bool WpADOConnection::RollbackTrans( ) +{ + return SUCCEEDED(pInterface->RollbackTrans()); +} + +sal_Bool WpADOConnection::Open(const ::rtl::OUString& ConnectionString, const ::rtl::OUString& UserID,const ::rtl::OUString& Password,long Options) +{ + OLEString sStr1(ConnectionString); + OLEString sStr2(UserID); + OLEString sStr3(Password); + sal_Bool bErg = SUCCEEDED(pInterface->Open(sStr1,sStr2,sStr3,Options)); + return bErg; +} + +sal_Bool WpADOConnection::GetErrors(ADOErrors** pErrors) +{ + return SUCCEEDED(pInterface->get_Errors(pErrors)); +} + +::rtl::OUString WpADOConnection::GetDefaultDatabase() const +{ + OLEString aBSTR; pInterface->get_DefaultDatabase(&aBSTR); + return aBSTR; +} + +sal_Bool WpADOConnection::PutDefaultDatabase(const ::rtl::OUString& _bstr) +{ + OLEString bstr(_bstr); + sal_Bool bErg = SUCCEEDED(pInterface->put_DefaultDatabase(bstr)); + + return bErg; +} + +IsolationLevelEnum WpADOConnection::get_IsolationLevel() const +{ + IsolationLevelEnum eNum=adXactUnspecified; + pInterface->get_IsolationLevel(&eNum); + return eNum; +} + +sal_Bool WpADOConnection::put_IsolationLevel(const IsolationLevelEnum& eNum) +{ + return SUCCEEDED(pInterface->put_IsolationLevel(eNum)); +} + +sal_Int32 WpADOConnection::get_Attributes() const +{ + sal_Int32 nRet=0; + pInterface->get_Attributes(&nRet); + return nRet; +} + +sal_Bool WpADOConnection::put_Attributes(sal_Int32 nRet) +{ + return SUCCEEDED(pInterface->put_Attributes(nRet)); +} + +CursorLocationEnum WpADOConnection::get_CursorLocation() const +{ + CursorLocationEnum eNum=adUseNone; + pInterface->get_CursorLocation(&eNum); + return eNum; +} + +sal_Bool WpADOConnection::put_CursorLocation(const CursorLocationEnum &eNum) +{ + return SUCCEEDED(pInterface->put_CursorLocation(eNum)); +} + +ConnectModeEnum WpADOConnection::get_Mode() const +{ + ConnectModeEnum eNum=adModeUnknown; + pInterface->get_Mode(&eNum); + return eNum; +} + +sal_Bool WpADOConnection::put_Mode(const ConnectModeEnum &eNum) +{ + + return SUCCEEDED(pInterface->put_Mode(eNum)); +} + +::rtl::OUString WpADOConnection::get_Provider() const +{ + OLEString aBSTR; pInterface->get_Provider(&aBSTR); + return aBSTR; +} + +sal_Bool WpADOConnection::put_Provider(const ::rtl::OUString& _bstr) +{ + OLEString bstr(_bstr); + return SUCCEEDED(pInterface->put_Provider(bstr)); +} + +sal_Int32 WpADOConnection::get_State() const +{ + sal_Int32 nRet=0; + pInterface->get_State(&nRet); + return nRet; +} + +sal_Bool WpADOConnection::OpenSchema(SchemaEnum eNum,OLEVariant& Restrictions,OLEVariant& SchemaID,ADORecordset**pprset) +{ + return SUCCEEDED(pInterface->OpenSchema(eNum,Restrictions,SchemaID,pprset)); +} + +::rtl::OUString WpADOConnection::get_Version() const +{ + OLEString aBSTR; + pInterface->get_Version(&aBSTR); + return aBSTR; +} + +sal_Bool WpADOCommand::putref_ActiveConnection( WpADOConnection *pCon) +{ + return SUCCEEDED(pInterface->putref_ActiveConnection(pCon->pInterface)); +} + +void WpADOCommand::put_ActiveConnection(/* [in] */ const OLEVariant& vConn) +{ + pInterface->put_ActiveConnection(vConn); +} + +void WpADOCommand::Create() +{ + IClassFactory2* pIUnknown = NULL; + IUnknown *pOuter = NULL; + HRESULT hr; + hr = CoGetClassObject( ADOS::CLSID_ADOCOMMAND_21, + CLSCTX_INPROC_SERVER, + NULL, + IID_IClassFactory2, + (void**)&pIUnknown ); + + if( !FAILED( hr ) ) + { + pIUnknown->AddRef(); + ADOCommand* pCommand=NULL; + + hr = pIUnknown->CreateInstanceLic( pOuter, + NULL, + ADOS::IID_ADOCOMMAND_21, + ADOS::GetKeyStr(), + (void**) &pCommand); + + if( !FAILED( hr ) ) + { + pInterface = pCommand; + pInterface->AddRef(); + } + pIUnknown->Release(); + } +} + +sal_Int32 WpADOCommand::get_State() const +{ + sal_Int32 nRet=0; + pInterface->get_State(&nRet); + return nRet; +} + +::rtl::OUString WpADOCommand::get_CommandText() const +{ + OLEString aBSTR; pInterface->get_CommandText(&aBSTR); + return aBSTR; +} + +sal_Bool WpADOCommand::put_CommandText(const ::rtl::OUString &aCon) +{ + OLEString bstr(aCon); + sal_Bool bErg = SUCCEEDED(pInterface->put_CommandText(bstr)); + + return bErg; +} + +sal_Int32 WpADOCommand::get_CommandTimeout() const +{ + sal_Int32 nRet=0; + pInterface->get_CommandTimeout(&nRet); + return nRet; +} + +void WpADOCommand::put_CommandTimeout(sal_Int32 nRet) +{ + pInterface->put_CommandTimeout(nRet); +} + +sal_Bool WpADOCommand::get_Prepared() const +{ + VARIANT_BOOL bPrepared = VARIANT_FALSE; + pInterface->get_Prepared(&bPrepared); + return bPrepared == VARIANT_TRUE; +} + +sal_Bool WpADOCommand::put_Prepared(VARIANT_BOOL bPrepared) const +{ + return SUCCEEDED(pInterface->put_Prepared(bPrepared)); +} + +sal_Bool WpADOCommand::Execute(OLEVariant& RecordsAffected,OLEVariant& Parameters,long Options, ADORecordset** ppiRset) +{ + return SUCCEEDED(pInterface->Execute(&RecordsAffected,&Parameters,Options,ppiRset)); +} + +ADOParameter* WpADOCommand::CreateParameter(const ::rtl::OUString &_bstr,DataTypeEnum Type,ParameterDirectionEnum Direction,long nSize,const OLEVariant &Value) +{ + ADOParameter* pPara = NULL; + OLEString bstr(_bstr); + sal_Bool bErg = SUCCEEDED(pInterface->CreateParameter(bstr,Type,Direction,nSize,Value,&pPara)); + + return bErg ? pPara : NULL; +} + +ADOParameters* WpADOCommand::get_Parameters() const +{ + ADOParameters* pPara=NULL; + pInterface->get_Parameters(&pPara); + return pPara; +} + +sal_Bool WpADOCommand::put_CommandType( /* [in] */ CommandTypeEnum lCmdType) +{ + return SUCCEEDED(pInterface->put_CommandType(lCmdType)); +} + +CommandTypeEnum WpADOCommand::get_CommandType( ) const +{ + CommandTypeEnum eNum=adCmdUnspecified; + pInterface->get_CommandType(&eNum); + return eNum; +} + +// gibt den Namen des Feldes zur"ueck +::rtl::OUString WpADOCommand::GetName() const +{ + OLEString aBSTR; + pInterface->get_Name(&aBSTR); + return aBSTR; +} + +sal_Bool WpADOCommand::put_Name(const ::rtl::OUString& _Name) +{ + OLEString bstr(_Name); + sal_Bool bErg = SUCCEEDED(pInterface->put_Name(bstr)); + + return bErg; +} +sal_Bool WpADOCommand::Cancel() +{ + return SUCCEEDED(pInterface->Cancel()); +} + +::rtl::OUString WpADOError::GetDescription() const +{ + OLEString aBSTR; + pInterface->get_Description(&aBSTR); + return aBSTR; +} + + ::rtl::OUString WpADOError::GetSource() const +{ + OLEString aBSTR; + pInterface->get_Source(&aBSTR); + return aBSTR; +} + + sal_Int32 WpADOError::GetNumber() const +{ + sal_Int32 nErrNr=0; + pInterface->get_Number(&nErrNr); + return nErrNr; +} + + ::rtl::OUString WpADOError::GetSQLState() const +{ + OLEString aBSTR; + pInterface->get_SQLState(&aBSTR); + return aBSTR; +} + + sal_Int32 WpADOError::GetNativeError() const +{ + sal_Int32 nErrNr=0; + pInterface->get_NativeError(&nErrNr); + return nErrNr; +} + ADOProperties* WpADOField::get_Properties() +{ + ADOProperties* pProps = NULL; + pInterface->get_Properties(&pProps); + return pProps; +} + + sal_Int32 WpADOField::GetActualSize() const +{ + sal_Int32 nActualSize=0; + pInterface->get_ActualSize(&nActualSize); + return nActualSize; +} + + sal_Int32 WpADOField::GetAttributes() const +{ + sal_Int32 eADOSFieldAttributes=0; + pInterface->get_Attributes(&eADOSFieldAttributes); + return eADOSFieldAttributes; +} + + sal_Int32 WpADOField::GetStatus() const +{ + sal_Int32 eADOSFieldAttributes=0; + // pInterface->get_Status(&eADOSFieldAttributes); + return eADOSFieldAttributes; +} + + sal_Int32 WpADOField::GetDefinedSize() const +{ + sal_Int32 nDefinedSize=0; + pInterface->get_DefinedSize(&nDefinedSize); + return nDefinedSize; +} + +// gibt den Namen des Feldes zur"ueck + ::rtl::OUString WpADOField::GetName() const +{ + OLEString aBSTR; + pInterface->get_Name(&aBSTR); + return aBSTR; +} + + DataTypeEnum WpADOField::GetADOType() const +{ + DataTypeEnum eType=adEmpty; + pInterface->get_Type(&eType); + return eType; +} + + void WpADOField::get_Value(OLEVariant& aValVar) const +{ + aValVar.setEmpty(); + pInterface->get_Value(&aValVar); +} + + OLEVariant WpADOField::get_Value() const +{ + OLEVariant aValVar; + pInterface->get_Value(&aValVar); + return aValVar; +} + + sal_Bool WpADOField::PutValue(const OLEVariant& aVariant) +{ + return (SUCCEEDED(pInterface->put_Value(aVariant))); +} + + sal_Int32 WpADOField::GetPrecision() const +{ + sal_uInt8 eType=0; + pInterface->get_Precision(&eType); + return eType; +} + + sal_Int32 WpADOField::GetNumericScale() const +{ + sal_uInt8 eType=0; + pInterface->get_NumericScale(&eType); + return eType; +} + + sal_Bool WpADOField::AppendChunk(const OLEVariant& _Variant) +{ + return (SUCCEEDED(pInterface->AppendChunk(_Variant))); +} + + OLEVariant WpADOField::GetChunk(long Length) const +{ + OLEVariant aValVar; + pInterface->GetChunk(Length,&aValVar); + return aValVar; +} + + void WpADOField::GetChunk(long Length,OLEVariant &aValVar) const +{ + pInterface->GetChunk(Length,&aValVar); +} + + OLEVariant WpADOField::GetOriginalValue() const +{ + OLEVariant aValVar; + pInterface->get_OriginalValue(&aValVar); + return aValVar; +} + + void WpADOField::GetOriginalValue(OLEVariant &aValVar) const +{ + pInterface->get_OriginalValue(&aValVar); +} + + OLEVariant WpADOField::GetUnderlyingValue() const +{ + OLEVariant aValVar; + pInterface->get_UnderlyingValue(&aValVar); + return aValVar; +} + + void WpADOField::GetUnderlyingValue(OLEVariant &aValVar) const +{ + pInterface->get_UnderlyingValue(&aValVar); +} + + sal_Bool WpADOField::PutPrecision(sal_Int8 _prec) +{ + return (SUCCEEDED(pInterface->put_Precision(_prec))); +} + + sal_Bool WpADOField::PutNumericScale(sal_Int8 _prec) +{ + return (SUCCEEDED(pInterface->put_NumericScale(_prec))); +} + + void WpADOField::PutADOType(DataTypeEnum eType) +{ + pInterface->put_Type(eType); +} + + sal_Bool WpADOField::PutDefinedSize(sal_Int32 _nDefSize) +{ + return (SUCCEEDED(pInterface->put_DefinedSize(_nDefSize))); +} + + sal_Bool WpADOField::PutAttributes(sal_Int32 _nDefSize) +{ + return (SUCCEEDED(pInterface->put_Attributes(_nDefSize))); +} + + OLEVariant WpADOProperty::GetValue() const +{ + OLEVariant aValVar; + pInterface->get_Value(&aValVar); + return aValVar; +} + + void WpADOProperty::GetValue(OLEVariant &aValVar) const +{ + pInterface->get_Value(&aValVar); +} + + sal_Bool WpADOProperty::PutValue(const OLEVariant &aValVar) +{ + return (SUCCEEDED(pInterface->put_Value(aValVar))); +} + + ::rtl::OUString WpADOProperty::GetName() const +{ + OLEString aBSTR; + pInterface->get_Name(&aBSTR); + return aBSTR; +} + + DataTypeEnum WpADOProperty::GetADOType() const +{ + DataTypeEnum eType=adEmpty; + pInterface->get_Type(&eType); + return eType; +} + + sal_Int32 WpADOProperty::GetAttributes() const +{ + sal_Int32 eADOSFieldAttributes=0; + pInterface->get_Attributes(&eADOSFieldAttributes); + return eADOSFieldAttributes; +} + + sal_Bool WpADOProperty::PutAttributes(sal_Int32 _nDefSize) +{ + return (SUCCEEDED(pInterface->put_Attributes(_nDefSize))); +} + void WpADORecordset::Create() +{ + IClassFactory2* pIUnknown = NULL; + IUnknown *pOuter = NULL; + HRESULT hr; + hr = CoGetClassObject( ADOS::CLSID_ADORECORDSET_21, + CLSCTX_INPROC_SERVER, + NULL, + IID_IClassFactory2, + (void**)&pIUnknown ); + + if( !FAILED( hr ) ) + { + pIUnknown->AddRef(); + + ADORecordset *pRec = NULL; + hr = pIUnknown->CreateInstanceLic( pOuter, + NULL, + ADOS::IID_ADORECORDSET_21, + ADOS::GetKeyStr(), + (void**) &pRec); + + if( !FAILED( hr ) ) + { + pInterface = pRec; + pInterface->AddRef(); + } + pIUnknown->Release(); + } +} + + sal_Bool WpADORecordset::Open( + /* [optional][in] */ VARIANT Source, + /* [optional][in] */ VARIANT ActiveConnection, + /* [defaultvalue][in] */ CursorTypeEnum CursorType, + /* [defaultvalue][in] */ LockTypeEnum LockType, + /* [defaultvalue][in] */ sal_Int32 Options) +{ + return (SUCCEEDED(pInterface->Open(Source,ActiveConnection,CursorType,LockType,Options))); +} + + + LockTypeEnum WpADORecordset::GetLockType() +{ + LockTypeEnum eType=adLockUnspecified; + pInterface->get_LockType(&eType); + return eType; +} + + void WpADORecordset::Close() +{ + pInterface->Close(); +} + + sal_Bool WpADORecordset::Cancel() const +{ + return (SUCCEEDED(pInterface->Cancel())); +} + + sal_Int32 WpADORecordset::get_State( ) +{ + sal_Int32 nState = 0; + pInterface->get_State(&nState); + return nState; +} + + sal_Bool WpADORecordset::Supports( /* [in] */ CursorOptionEnum CursorOptions) +{ + VARIANT_BOOL bSupports=VARIANT_FALSE; + pInterface->Supports(CursorOptions,&bSupports); + return bSupports == VARIANT_TRUE; +} + +PositionEnum WpADORecordset::get_AbsolutePosition() +{ + PositionEnum aTemp=adPosUnknown; + pInterface->get_AbsolutePosition(&aTemp); + return aTemp; +} + + void WpADORecordset::GetDataSource(IUnknown** pIUnknown) const +{ + pInterface->get_DataSource(pIUnknown); +} + + void WpADORecordset::PutRefDataSource(IUnknown* pIUnknown) +{ + pInterface->putref_DataSource(pIUnknown); +} + + void WpADORecordset::GetBookmark(VARIANT& var) +{ + pInterface->get_Bookmark(&var); +} + + OLEVariant WpADORecordset::GetBookmark() +{ + OLEVariant var; + pInterface->get_Bookmark(&var); + return var; +} + +CompareEnum WpADORecordset::CompareBookmarks(const OLEVariant& left,const OLEVariant& right) +{ + CompareEnum eNum=adCompareNotComparable; + pInterface->CompareBookmarks(left,right,&eNum); + return eNum; +} + + sal_Bool WpADORecordset::SetBookmark(const OLEVariant &pSafeAr) +{ + return SUCCEEDED(pInterface->put_Bookmark(pSafeAr)); +} + + + ADOFields* WpADORecordset::GetFields() const +{ + ADOFields* pFields=NULL; + pInterface->get_Fields(&pFields); + return pFields; +} + + + sal_Bool WpADORecordset::Move(sal_Int32 nRows, VARIANT aBmk) {return SUCCEEDED(pInterface->Move(nRows, aBmk));} + sal_Bool WpADORecordset::MoveNext() {return SUCCEEDED(pInterface->MoveNext());} + sal_Bool WpADORecordset::MovePrevious() {return SUCCEEDED(pInterface->MovePrevious());} + sal_Bool WpADORecordset::MoveFirst() {return SUCCEEDED(pInterface->MoveFirst());} + sal_Bool WpADORecordset::MoveLast() {return SUCCEEDED(pInterface->MoveLast());} + + sal_Bool WpADORecordset::IsAtBOF() const +{ + VARIANT_BOOL bIsAtBOF=VARIANT_FALSE; + pInterface->get_BOF(&bIsAtBOF); + return bIsAtBOF == VARIANT_TRUE; +} + + sal_Bool WpADORecordset::IsAtEOF() const +{ + VARIANT_BOOL bIsAtEOF=VARIANT_FALSE; + pInterface->get_EOF(&bIsAtEOF); + return bIsAtEOF == VARIANT_TRUE; +} + + sal_Bool WpADORecordset::Delete(AffectEnum eNum) +{ + return SUCCEEDED(pInterface->Delete(eNum)); +} + + sal_Bool WpADORecordset::AddNew(const OLEVariant &FieldList,const OLEVariant &Values) +{ + return SUCCEEDED(pInterface->AddNew(FieldList,Values)); +} + + sal_Bool WpADORecordset::Update(const OLEVariant &FieldList,const OLEVariant &Values) +{ + return SUCCEEDED(pInterface->Update(FieldList,Values)); +} + + sal_Bool WpADORecordset::CancelUpdate() +{ + return SUCCEEDED(pInterface->CancelUpdate()); +} + + ADOProperties* WpADORecordset::get_Properties() const +{ + ADOProperties* pProps=NULL; + pInterface->get_Properties(&pProps); + return pProps; +} + + sal_Bool WpADORecordset::NextRecordset(OLEVariant& RecordsAffected,ADORecordset** ppiRset) +{ + return SUCCEEDED(pInterface->NextRecordset(&RecordsAffected,ppiRset)); +} + + sal_Bool WpADORecordset::get_RecordCount(sal_Int32 &_nRet) const +{ + return SUCCEEDED(pInterface->get_RecordCount(&_nRet)); +} + + sal_Bool WpADORecordset::get_MaxRecords(sal_Int32 &_nRet) const +{ + return SUCCEEDED(pInterface->get_MaxRecords(&_nRet)); +} + + sal_Bool WpADORecordset::put_MaxRecords(sal_Int32 _nRet) +{ + return SUCCEEDED(pInterface->put_MaxRecords(_nRet)); +} + + sal_Bool WpADORecordset::get_CursorType(CursorTypeEnum &_nRet) const +{ + return SUCCEEDED(pInterface->get_CursorType(&_nRet)); +} + + sal_Bool WpADORecordset::put_CursorType(CursorTypeEnum _nRet) +{ + return SUCCEEDED(pInterface->put_CursorType(_nRet)); +} + + sal_Bool WpADORecordset::get_LockType(LockTypeEnum &_nRet) const +{ + return SUCCEEDED(pInterface->get_LockType(&_nRet)); +} + + sal_Bool WpADORecordset::put_LockType(LockTypeEnum _nRet) +{ + return SUCCEEDED(pInterface->put_LockType(_nRet)); +} + + sal_Bool WpADORecordset::get_CacheSize(sal_Int32 &_nRet) const +{ + return SUCCEEDED(pInterface->get_CacheSize(&_nRet)); +} + + sal_Bool WpADORecordset::put_CacheSize(sal_Int32 _nRet) +{ + return SUCCEEDED(pInterface->put_CacheSize(_nRet)); +} + + sal_Bool WpADORecordset::UpdateBatch(AffectEnum AffectRecords) +{ + return SUCCEEDED(pInterface->UpdateBatch(AffectRecords)); +} + + ::rtl::OUString WpADOParameter::GetName() const +{ + OLEString aBSTR; + pInterface->get_Name(&aBSTR); + return aBSTR; +} + + DataTypeEnum WpADOParameter::GetADOType() const +{ + DataTypeEnum eType=adEmpty; + pInterface->get_Type(&eType); + return eType; +} + + sal_Int32 WpADOParameter::GetAttributes() const +{ + sal_Int32 eADOSFieldAttributes=0; + pInterface->get_Attributes(&eADOSFieldAttributes); + return eADOSFieldAttributes; +} + + sal_Int32 WpADOParameter::GetPrecision() const +{ + sal_uInt8 eType=0; + pInterface->get_Precision(&eType); + return eType; +} + + sal_Int32 WpADOParameter::GetNumericScale() const +{ + sal_uInt8 eType=0; + pInterface->get_NumericScale(&eType); + return eType; +} + + ParameterDirectionEnum WpADOParameter::get_Direction() const +{ + ParameterDirectionEnum alParmDirection=adParamUnknown; + pInterface->get_Direction(&alParmDirection); + return alParmDirection; +} + + void WpADOParameter::GetValue(OLEVariant& aValVar) const +{ + pInterface->get_Value(&aValVar); +} + + OLEVariant WpADOParameter::GetValue() const +{ + OLEVariant aValVar; + pInterface->get_Value(&aValVar); + return aValVar; +} + + sal_Bool WpADOParameter::PutValue(const OLEVariant& aVariant) +{ + return (SUCCEEDED(pInterface->put_Value(aVariant))); +} |