connectivity/source/drivers/ado/Awrapado.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/macros.h>
  21 #include <ado/Awrapado.hxx>
  22 #include <ado/Awrapadox.hxx>
  23 #include <comphelper/types.hxx>
  24 #include <rtl/ustrbuf.hxx>
  25 #include <sal/log.hxx>
  26
  27 using namespace connectivity::ado;
  28
  29 void WpADOCatalog::Create()
  30 {
  31     _ADOCatalog* pCommand;
  32     HRESULT hr = CoCreateInstance(ADOS::CLSID_ADOCATALOG_25,
  33                           nullptr,
  34                           CLSCTX_INPROC_SERVER,
  35                           ADOS::IID_ADOCATALOG_25,
  36                           reinterpret_cast<void**>(&pCommand) );
  37
  38
  39     if( !FAILED( hr ) )
  40         setWithOutAddRef(pCommand);
  41 }
  42
  43
  44 WpADOProperties WpADOConnection::get_Properties() const
  45 {
  46     ADOProperties* pProps=nullptr;
  47     pInterface->get_Properties(&pProps);
  48     WpADOProperties aProps;
  49     aProps.setWithOutAddRef(pProps);
  50     return aProps;
  51 }
  52
  53 OUString WpADOConnection::GetConnectionString() const
  54 {
  55     assert(pInterface);
  56     OLEString aBSTR;
  57     pInterface->get_ConnectionString(aBSTR.getAddress());
  58     return aBSTR.asOUString();
  59 }
  60
  61 bool WpADOConnection::PutConnectionString(const OUString &aCon) const
  62 {
  63     assert(pInterface);
  64     OLEString bstr(aCon);
  65     bool bErg = SUCCEEDED(pInterface->put_ConnectionString(bstr.asBSTR()));
  66
  67     return bErg;
  68 }
  69
  70 sal_Int32 WpADOConnection::GetCommandTimeout() const
  71 {
  72     assert(pInterface);
  73     sal_Int32 nRet=0;
  74     pInterface->get_CommandTimeout(&nRet);
  75     return nRet;
  76 }
  77
  78 void WpADOConnection::PutCommandTimeout(sal_Int32 nRet)
  79 {
  80     assert(pInterface);
  81     pInterface->put_CommandTimeout(nRet);
  82 }
  83
  84 sal_Int32 WpADOConnection::GetConnectionTimeout() const
  85 {
  86     assert(pInterface);
  87     sal_Int32 nRet=0;
  88     pInterface->get_ConnectionTimeout(&nRet);
  89     return nRet;
  90 }
  91
  92 void WpADOConnection::PutConnectionTimeout(sal_Int32 nRet)
  93 {
  94     assert(pInterface);
  95     pInterface->put_ConnectionTimeout(nRet);
  96 }
  97
  98 bool WpADOConnection::Close()
  99 {
 100     assert(pInterface);
 101     return (SUCCEEDED(pInterface->Close()));
 102 }
 103
 104 bool WpADOConnection::Execute(const OUString& CommandText,OLEVariant& RecordsAffected,long Options, WpADORecordset** ppiRset)
 105 {
 106     assert(pInterface);
 107     OLEString sStr1(CommandText);
 108     bool bErg = SUCCEEDED(pInterface->Execute(sStr1.asBSTR(),&RecordsAffected,Options,reinterpret_cast<ADORecordset**>(ppiRset)));
 109     return bErg;
 110 }
 111
 112 bool WpADOConnection::BeginTrans()
 113 {
 114     assert(pInterface);
 115     sal_Int32 nIso=0;
 116     return SUCCEEDED(pInterface->BeginTrans(&nIso));
 117 }
 118
 119 bool WpADOConnection::CommitTrans( )
 120 {
 121     assert(pInterface);
 122     return SUCCEEDED(pInterface->CommitTrans());
 123 }
 124
 125 bool WpADOConnection::RollbackTrans( )
 126 {
 127     assert(pInterface);
 128     return SUCCEEDED(pInterface->RollbackTrans());
 129 }
 130
 131 bool WpADOConnection::Open(const OUString& ConnectionString, const OUString& UserID,const OUString& Password,long Options)
 132 {
 133     assert(pInterface);
 134     OLEString sStr1(ConnectionString);
 135     OLEString sStr2(UserID);
 136     OLEString sStr3(Password);
 137     bool bErg = SUCCEEDED(pInterface->Open(sStr1.asBSTR(),sStr2.asBSTR(),sStr3.asBSTR(),Options));
 138     return bErg;
 139 }
 140
 141 bool WpADOConnection::GetErrors(ADOErrors** pErrors)
 142 {
 143     assert(pInterface);
 144     return SUCCEEDED(pInterface->get_Errors(pErrors));
 145 }
 146
 147 OUString WpADOConnection::GetDefaultDatabase() const
 148 {
 149     assert(pInterface);
 150     OLEString aBSTR; pInterface->get_DefaultDatabase(aBSTR.getAddress());
 151     return aBSTR.asOUString();
 152 }
 153
 154 bool WpADOConnection::PutDefaultDatabase(const OUString& _bstr)
 155 {
 156     assert(pInterface);
 157     OLEString bstr(_bstr);
 158     bool bErg = SUCCEEDED(pInterface->put_DefaultDatabase(bstr.asBSTR()));
 159
 160     return bErg;
 161 }
 162
 163 IsolationLevelEnum WpADOConnection::get_IsolationLevel() const
 164 {
 165     assert(pInterface);
 166     IsolationLevelEnum eNum=adXactUnspecified;
 167     pInterface->get_IsolationLevel(&eNum);
 168     return eNum;
 169 }
 170
 171 bool WpADOConnection::put_IsolationLevel(const IsolationLevelEnum& eNum)
 172 {
 173     assert(pInterface);
 174     return SUCCEEDED(pInterface->put_IsolationLevel(eNum));
 175 }
 176
 177 sal_Int32 WpADOConnection::get_Attributes() const
 178 {
 179     assert(pInterface);
 180     sal_Int32 nRet=0;
 181     pInterface->get_Attributes(&nRet);
 182     return nRet;
 183 }
 184
 185 bool WpADOConnection::put_Attributes(sal_Int32 nRet)
 186 {
 187     assert(pInterface);
 188     return SUCCEEDED(pInterface->put_Attributes(nRet));
 189 }
 190
 191 CursorLocationEnum WpADOConnection::get_CursorLocation() const
 192 {
 193     assert(pInterface);
 194     CursorLocationEnum eNum=adUseNone;
 195     pInterface->get_CursorLocation(&eNum);
 196     return eNum;
 197 }
 198
 199 bool WpADOConnection::put_CursorLocation(const CursorLocationEnum &eNum)
 200 {
 201     assert(pInterface);
 202     return SUCCEEDED(pInterface->put_CursorLocation(eNum));
 203 }
 204
 205 ConnectModeEnum WpADOConnection::get_Mode() const
 206 {
 207     assert(pInterface);
 208     ConnectModeEnum eNum=adModeUnknown;
 209     pInterface->get_Mode(&eNum);
 210     return eNum;
 211 }
 212
 213 bool WpADOConnection::put_Mode(const ConnectModeEnum &eNum)
 214 {
 215     assert(pInterface);
 216     return SUCCEEDED(pInterface->put_Mode(eNum));
 217 }
 218
 219 OUString WpADOConnection::get_Provider() const
 220 {
 221     assert(pInterface);
 222     OLEString aBSTR; pInterface->get_Provider(aBSTR.getAddress());
 223     return aBSTR.asOUString();
 224 }
 225
 226 bool WpADOConnection::put_Provider(const OUString& _bstr)
 227 {
 228     assert(pInterface);
 229     OLEString bstr(_bstr);
 230     return SUCCEEDED(pInterface->put_Provider(bstr.asBSTR()));
 231 }
 232
 233 sal_Int32 WpADOConnection::get_State() const
 234 {
 235     assert(pInterface);
 236     sal_Int32 nRet=0;
 237     pInterface->get_State(&nRet);
 238     return nRet;
 239 }
 240
 241 bool WpADOConnection::OpenSchema(SchemaEnum eNum,OLEVariant const & Restrictions,OLEVariant const & SchemaID,ADORecordset**pprset)
 242 {
 243     assert(pInterface);
 244     return SUCCEEDED(pInterface->OpenSchema(eNum,Restrictions,SchemaID,pprset));
 245 }
 246
 247 OUString WpADOConnection::get_Version() const
 248 {
 249     assert(pInterface);
 250     OLEString aBSTR;
 251     pInterface->get_Version(aBSTR.getAddress());
 252     return aBSTR.asOUString();
 253 }
 254
 255 bool WpADOCommand::putref_ActiveConnection( WpADOConnection *pCon)
 256 {
 257     assert(pInterface);
 258     if(pCon)
 259         return SUCCEEDED(pInterface->putref_ActiveConnection(pCon->pInterface));
 260     else
 261         return SUCCEEDED(pInterface->putref_ActiveConnection(nullptr));
 262 }
 263
 264 void WpADOCommand::put_ActiveConnection(/* [in] */ const OLEVariant& vConn)
 265 {
 266     assert(pInterface);
 267     pInterface->put_ActiveConnection(vConn);
 268 }
 269
 270 void WpADOCommand::Create()
 271 {
 272     IClassFactory2* pInterface2 = nullptr;
 273     HRESULT hr = CoGetClassObject( ADOS::CLSID_ADOCOMMAND_21,
 274                           CLSCTX_INPROC_SERVER,
 275                           nullptr,
 276                           IID_IClassFactory2,
 277                           reinterpret_cast<void**>(&pInterface2) );
 278
 279     if( !FAILED( hr ) )
 280     {
 281         ADOCommand* pCommand=nullptr;
 282         IUnknown* pOuter=nullptr;
 283
 284         hr = pInterface2->CreateInstanceLic(  pOuter,
 285                                             nullptr,
 286                                             ADOS::IID_ADOCOMMAND_21,
 287                                             ADOS::GetKeyStr().asBSTR(),
 288                                             reinterpret_cast<void**>(&pCommand));
 289
 290         if( !FAILED( hr ) )
 291         {
 292             operator=(pCommand);
 293             pCommand->Release();
 294         }
 295
 296         pInterface2->Release();
 297     }
 298 }
 299
 300 sal_Int32 WpADOCommand::get_State() const
 301 {
 302     assert(pInterface);
 303     sal_Int32 nRet=0;
 304     pInterface->get_State(&nRet);
 305     return nRet;
 306 }
 307
 308 OUString WpADOCommand::get_CommandText() const
 309 {
 310     assert(pInterface);
 311     OLEString aBSTR;
 312     pInterface->get_CommandText(aBSTR.getAddress());
 313     return aBSTR.asOUString();
 314 }
 315
 316 bool WpADOCommand::put_CommandText(const OUString &aCon)
 317 {
 318     assert(pInterface);
 319     OLEString bstr(aCon);
 320     bool bErg = SUCCEEDED(pInterface->put_CommandText(bstr.asBSTR()));
 321
 322     return bErg;
 323 }
 324
 325 sal_Int32 WpADOCommand::get_CommandTimeout() const
 326 {
 327     assert(pInterface);
 328     sal_Int32 nRet=0;
 329     pInterface->get_CommandTimeout(&nRet);
 330     return nRet;
 331 }
 332
 333 void WpADOCommand::put_CommandTimeout(sal_Int32 nRet)
 334 {
 335     assert(pInterface);
 336     pInterface->put_CommandTimeout(nRet);
 337 }
 338
 339 bool WpADOCommand::get_Prepared() const
 340 {
 341     assert(pInterface);
 342     VARIANT_BOOL bPrepared = VARIANT_FALSE;
 343     pInterface->get_Prepared(&bPrepared);
 344     return bPrepared == VARIANT_TRUE;
 345 }
 346
 347 bool WpADOCommand::put_Prepared(VARIANT_BOOL bPrepared) const
 348 {
 349     assert(pInterface);
 350     return SUCCEEDED(pInterface->put_Prepared(bPrepared));
 351 }
 352
 353 bool WpADOCommand::Execute(OLEVariant& RecordsAffected,OLEVariant& Params,long Options, ADORecordset** ppiRset)
 354 {
 355     assert(pInterface);
 356     return SUCCEEDED(pInterface->Execute(&RecordsAffected,&Params,Options,ppiRset));
 357 }
 358
 359 ADOParameter* WpADOCommand::CreateParameter(const OUString &_bstr,DataTypeEnum Type,ParameterDirectionEnum Direction,long nSize,const OLEVariant &Value)
 360 {
 361     assert(pInterface);
 362     ADOParameter* pPara = nullptr;
 363     OLEString bstr(_bstr);
 364     bool bErg = SUCCEEDED(pInterface->CreateParameter(bstr.asBSTR(),Type,Direction,nSize,Value,&pPara));
 365
 366     return bErg ? pPara : nullptr;
 367 }
 368
 369 ADOParameters* WpADOCommand::get_Parameters() const
 370 {
 371     assert(pInterface);
 372     ADOParameters* pPara=nullptr;
 373     pInterface->get_Parameters(&pPara);
 374     return pPara;
 375 }
 376
 377 bool WpADOCommand::put_CommandType( /* [in] */ CommandTypeEnum lCmdType)
 378 {
 379     assert(pInterface);
 380     return SUCCEEDED(pInterface->put_CommandType(lCmdType));
 381 }
 382
 383 CommandTypeEnum WpADOCommand::get_CommandType() const
 384 {
 385     assert(pInterface);
 386     CommandTypeEnum eNum=adCmdUnspecified;
 387     pInterface->get_CommandType(&eNum);
 388     return eNum;
 389 }
 390
 391 // returns the name of the field
 392 OUString WpADOCommand::GetName() const
 393 {
 394     assert(pInterface);
 395     OLEString aBSTR;
 396     pInterface->get_Name(aBSTR.getAddress());
 397     return aBSTR.asOUString();
 398 }
 399
 400 bool WpADOCommand::put_Name(const OUString& Name)
 401 {
 402     assert(pInterface);
 403     OLEString bstr(Name);
 404     bool bErg = SUCCEEDED(pInterface->put_Name(bstr.asBSTR()));
 405
 406     return bErg;
 407 }
 408 bool WpADOCommand::Cancel()
 409 {
 410     assert(pInterface);
 411     return SUCCEEDED(pInterface->Cancel());
 412 }
 413
 414 OUString WpADOError::GetDescription() const
 415 {
 416     assert(pInterface);
 417     OLEString aBSTR;
 418     pInterface->get_Description(aBSTR.getAddress());
 419     return aBSTR.asOUString();
 420 }
 421
 422 OUString WpADOError::GetSource() const
 423 {
 424     assert(pInterface);
 425     OLEString aBSTR;
 426     pInterface->get_Source(aBSTR.getAddress());
 427     return aBSTR.asOUString();
 428 }
 429
 430 sal_Int32 WpADOError::GetNumber() const
 431 {
 432     assert(pInterface);
 433     sal_Int32 nErrNr=0;
 434     pInterface->get_Number(&nErrNr);
 435     return nErrNr;
 436 }
 437
 438 OUString WpADOError::GetSQLState() const
 439 {
 440     assert(pInterface);
 441     OLEString aBSTR;
 442     pInterface->get_SQLState(aBSTR.getAddress());
 443     return aBSTR.asOUString();
 444 }
 445
 446 sal_Int32 WpADOError::GetNativeError() const
 447 {
 448     assert(pInterface);
 449     sal_Int32 nErrNr=0;
 450     pInterface->get_NativeError(&nErrNr);
 451     return nErrNr;
 452 }
 453
 454 WpADOProperties WpADOField::get_Properties()
 455 {
 456     assert(pInterface);
 457     ADOProperties* pProps = nullptr;
 458     pInterface->get_Properties(&pProps);
 459     WpADOProperties aProps;
 460
 461     aProps.setWithOutAddRef(pProps);
 462     return aProps;
 463 }
 464
 465 sal_Int32 WpADOField::GetActualSize() const
 466 {
 467     assert(pInterface);
 468     ADO_LONGPTR nActualSize=0;
 469     pInterface->get_ActualSize(&nActualSize);
 470     return nActualSize;
 471 }
 472
 473 sal_Int32 WpADOField::GetAttributes() const
 474 {
 475     assert(pInterface);
 476     sal_Int32 eADOSFieldAttributes=0;
 477     pInterface->get_Attributes(&eADOSFieldAttributes);
 478     return eADOSFieldAttributes;
 479 }
 480
 481 sal_Int32 WpADOField::GetStatus() const
 482 {
 483     assert(pInterface);
 484     //  pInterface->get_Status(&eADOSFieldAttributes);
 485     return 0;
 486 }
 487
 488 sal_Int32 WpADOField::GetDefinedSize() const
 489 {
 490     assert(pInterface);
 491     ADO_LONGPTR nDefinedSize=0;
 492     pInterface->get_DefinedSize(&nDefinedSize);
 493     return nDefinedSize;
 494 }
 495
 496 // returns the name of the field
 497 OUString WpADOField::GetName() const
 498 {
 499     assert(pInterface);
 500     OLEString aBSTR;
 501     pInterface->get_Name(aBSTR.getAddress());
 502     return aBSTR.asOUString();
 503 }
 504
 505 DataTypeEnum WpADOField::GetADOType() const
 506 {
 507     assert(pInterface);
 508     DataTypeEnum eType=adEmpty;
 509     pInterface->get_Type(&eType);
 510     return eType;
 511 }
 512
 513 void WpADOField::get_Value(OLEVariant& aValVar) const
 514 {
 515     assert(pInterface);
 516     aValVar.setEmpty();
 517     pInterface->get_Value(&aValVar);
 518 }
 519
 520 OLEVariant WpADOField::get_Value() const
 521 {
 522     assert(pInterface);
 523     OLEVariant aValVar;
 524     pInterface->get_Value(&aValVar);
 525     return aValVar;
 526 }
 527
 528 bool WpADOField::PutValue(const OLEVariant& aVariant)
 529 {
 530     assert(pInterface);
 531     return (SUCCEEDED(pInterface->put_Value(aVariant)));
 532 }
 533
 534 sal_Int32 WpADOField::GetPrecision() const
 535 {
 536     assert(pInterface);
 537     sal_uInt8 eType=0;
 538     pInterface->get_Precision(&eType);
 539     return eType;
 540 }
 541
 542 sal_Int32 WpADOField::GetNumericScale() const
 543 {
 544     assert(pInterface);
 545     sal_uInt8 eType=0;
 546     pInterface->get_NumericScale(&eType);
 547     return eType;
 548 }
 549
 550 bool WpADOField::AppendChunk(const OLEVariant& Variant)
 551 {
 552     assert(pInterface);
 553     return (SUCCEEDED(pInterface->AppendChunk(Variant)));
 554 }
 555
 556 OLEVariant WpADOField::GetChunk(long Length) const
 557 {
 558     assert(pInterface);
 559     OLEVariant aValVar;
 560     pInterface->GetChunk(Length,&aValVar);
 561     return aValVar;
 562 }
 563
 564 void WpADOField::GetChunk(long Length,OLEVariant &aValVar) const
 565 {
 566     assert(pInterface);
 567     pInterface->GetChunk(Length,&aValVar);
 568 }
 569
 570 OLEVariant WpADOField::GetOriginalValue() const
 571 {
 572     assert(pInterface);
 573     OLEVariant aValVar;
 574     pInterface->get_OriginalValue(&aValVar);
 575     return aValVar;
 576 }
 577
 578 void WpADOField::GetOriginalValue(OLEVariant &aValVar) const
 579 {
 580     assert(pInterface);
 581     pInterface->get_OriginalValue(&aValVar);
 582 }
 583
 584 OLEVariant WpADOField::GetUnderlyingValue() const
 585 {
 586     assert(pInterface);
 587     OLEVariant aValVar;
 588     pInterface->get_UnderlyingValue(&aValVar);
 589     return aValVar;
 590 }
 591
 592 void WpADOField::GetUnderlyingValue(OLEVariant &aValVar) const
 593 {
 594     assert(pInterface);
 595     pInterface->get_UnderlyingValue(&aValVar);
 596 }
 597
 598 bool WpADOField::PutPrecision(sal_Int8 _prec)
 599 {
 600     assert(pInterface);
 601     return (SUCCEEDED(pInterface->put_Precision(_prec)));
 602 }
 603
 604 bool WpADOField::PutNumericScale(sal_Int8 _prec)
 605 {
 606     assert(pInterface);
 607     return (SUCCEEDED(pInterface->put_NumericScale(_prec)));
 608 }
 609
 610 void WpADOField::PutADOType(DataTypeEnum eType)
 611 {
 612     assert(pInterface);
 613     pInterface->put_Type(eType);
 614 }
 615
 616 bool WpADOField::PutDefinedSize(sal_Int32 _nDefSize)
 617 {
 618     assert(pInterface);
 619     return (SUCCEEDED(pInterface->put_DefinedSize(_nDefSize)));
 620 }
 621
 622 bool WpADOField::PutAttributes(sal_Int32 _nDefSize)
 623 {
 624     assert(pInterface);
 625     return (SUCCEEDED(pInterface->put_Attributes(_nDefSize)));
 626 }
 627
 628 OLEVariant WpADOProperty::GetValue() const
 629 {
 630     OLEVariant aValVar;
 631     if(pInterface)
 632         pInterface->get_Value(&aValVar);
 633     return aValVar;
 634 }
 635
 636 void WpADOProperty::GetValue(OLEVariant &aValVar) const
 637 {
 638     assert(pInterface);
 639     if(pInterface)
 640         pInterface->get_Value(&aValVar);
 641 }
 642
 643 bool WpADOProperty::PutValue(const OLEVariant &aValVar)
 644 {
 645     assert(pInterface);
 646     return (SUCCEEDED(pInterface->put_Value(aValVar)));
 647 }
 648
 649 OUString WpADOProperty::GetName() const
 650 {
 651     assert(pInterface);
 652     OLEString aBSTR;
 653     pInterface->get_Name(aBSTR.getAddress());
 654     return aBSTR.asOUString();
 655 }
 656
 657 DataTypeEnum WpADOProperty::GetADOType() const
 658 {
 659     assert(pInterface);
 660     DataTypeEnum eType=adEmpty;
 661     pInterface->get_Type(&eType);
 662     return eType;
 663 }
 664
 665 sal_Int32 WpADOProperty::GetAttributes() const
 666 {
 667     assert(pInterface);
 668     sal_Int32 eADOSFieldAttributes=0;
 669     pInterface->get_Attributes(&eADOSFieldAttributes);
 670     return eADOSFieldAttributes;
 671 }
 672
 673 bool WpADOProperty::PutAttributes(sal_Int32 _nDefSize)
 674 {
 675     assert(pInterface);
 676     return (SUCCEEDED(pInterface->put_Attributes(_nDefSize)));
 677 }
 678  void WpADORecordset::Create()
 679 {
 680     IClassFactory2* pInterface2 = nullptr;
 681     HRESULT hr = CoGetClassObject( ADOS::CLSID_ADORECORDSET_21,
 682                           CLSCTX_INPROC_SERVER,
 683                           nullptr,
 684                           IID_IClassFactory2,
 685                           reinterpret_cast<void**>(&pInterface2) );
 686
 687     if( !FAILED( hr ) )
 688     {
 689         ADORecordset *pRec = nullptr;
 690         IUnknown *pOuter = nullptr;
 691         hr = pInterface2->CreateInstanceLic(  pOuter,
 692                                             nullptr,
 693                                             ADOS::IID_ADORECORDSET_21,
 694                                             ADOS::GetKeyStr().asBSTR(),
 695                                             reinterpret_cast<void**>(&pRec));
 696
 697         if( !FAILED( hr ) )
 698         {
 699             operator=(pRec);
 700             pRec->Release();
 701         }
 702
 703         pInterface2->Release();
 704     }
 705 }
 706
 707 bool WpADORecordset::Open(
 708         /* [optional][in] */ VARIANT Source,
 709         /* [optional][in] */ VARIANT ActiveConnection,
 710         /* [defaultvalue][in] */ CursorTypeEnum CursorType,
 711         /* [defaultvalue][in] */ LockTypeEnum LockType,
 712         /* [defaultvalue][in] */ sal_Int32 Options)
 713 {
 714     assert(pInterface);
 715     return (SUCCEEDED(pInterface->Open(Source,ActiveConnection,CursorType,LockType,Options)));
 716 }
 717
 718
 719 LockTypeEnum WpADORecordset::GetLockType()
 720 {
 721     assert(pInterface);
 722     LockTypeEnum eType=adLockUnspecified;
 723     pInterface->get_LockType(&eType);
 724     return eType;
 725 }
 726
 727 void WpADORecordset::Close()
 728 {
 729     assert(pInterface);
 730     pInterface->Close();
 731 }
 732
 733 bool WpADORecordset::Cancel() const
 734 {
 735     assert(pInterface);
 736     return (SUCCEEDED(pInterface->Cancel()));
 737 }
 738
 739 sal_Int32 WpADORecordset::get_State()
 740 {
 741     assert(pInterface);
 742     sal_Int32 nState = 0;
 743     pInterface->get_State(&nState);
 744     return nState;
 745 }
 746
 747 bool WpADORecordset::Supports( /* [in] */ CursorOptionEnum CursorOptions)
 748 {
 749     assert(pInterface);
 750     VARIANT_BOOL bSupports=VARIANT_FALSE;
 751     pInterface->Supports(CursorOptions,&bSupports);
 752     return bSupports == VARIANT_TRUE;
 753 }
 754
 755 PositionEnum_Param WpADORecordset::get_AbsolutePosition()
 756 {
 757     assert(pInterface);
 758     PositionEnum_Param aTemp=adPosUnknown;
 759     pInterface->get_AbsolutePosition(&aTemp);
 760     return aTemp;
 761 }
 762
 763 void WpADORecordset::GetDataSource(IUnknown** _pInterface) const
 764 {
 765     assert(pInterface);
 766     pInterface->get_DataSource(_pInterface);
 767 }
 768
 769 void WpADORecordset::PutRefDataSource(IUnknown* _pInterface)
 770 {
 771     assert(pInterface);
 772     pInterface->putref_DataSource(_pInterface);
 773 }
 774
 775 void WpADORecordset::GetBookmark(VARIANT& var)
 776 {
 777     assert(pInterface);
 778     pInterface->get_Bookmark(&var);
 779 }
 780
 781 OLEVariant WpADORecordset::GetBookmark()
 782 {
 783     assert(pInterface);
 784     OLEVariant var;
 785     pInterface->get_Bookmark(&var);
 786     return var;
 787 }
 788
 789 CompareEnum WpADORecordset::CompareBookmarks(const OLEVariant& left,const OLEVariant& right)
 790 {
 791     assert(pInterface);
 792     CompareEnum eNum=adCompareNotComparable;
 793     pInterface->CompareBookmarks(left,right,&eNum);
 794     return eNum;
 795 }
 796
 797 bool WpADORecordset::SetBookmark(const OLEVariant &pSafeAr)
 798 {
 799     assert(pInterface);
 800     return SUCCEEDED(pInterface->put_Bookmark(pSafeAr));
 801 }
 802
 803
 804 WpADOFields WpADORecordset::GetFields() const
 805 {
 806     assert(pInterface);
 807     ADOFields* pFields=nullptr;
 808     pInterface->get_Fields(&pFields);
 809     WpADOFields aFields;
 810     aFields.setWithOutAddRef(pFields);
 811     return aFields;
 812 }
 813
 814
 815 bool WpADORecordset::Move(sal_Int32 nRows, VARIANT aBmk)   {return pInterface && SUCCEEDED(pInterface->Move(nRows, aBmk));}
 816 bool WpADORecordset::MoveNext() {return pInterface && SUCCEEDED(pInterface->MoveNext());}
 817 bool WpADORecordset::MovePrevious() {return pInterface && SUCCEEDED(pInterface->MovePrevious());}
 818 bool WpADORecordset::MoveFirst() {return pInterface && SUCCEEDED(pInterface->MoveFirst());}
 819 bool WpADORecordset::MoveLast()    {return pInterface && SUCCEEDED(pInterface->MoveLast());}
 820
 821 bool WpADORecordset::IsAtBOF() const
 822 {
 823     assert(pInterface);
 824     VARIANT_BOOL bIsAtBOF=VARIANT_FALSE;
 825     pInterface->get_BOF(&bIsAtBOF);
 826     return bIsAtBOF == VARIANT_TRUE;
 827 }
 828
 829 bool WpADORecordset::IsAtEOF() const
 830 {
 831     assert(pInterface);
 832     VARIANT_BOOL bIsAtEOF=VARIANT_FALSE;
 833     pInterface->get_EOF(&bIsAtEOF);
 834     return bIsAtEOF == VARIANT_TRUE;
 835 }
 836
 837 bool WpADORecordset::Delete(AffectEnum eNum)
 838 {
 839     assert(pInterface);
 840     return SUCCEEDED(pInterface->Delete(eNum));
 841 }
 842
 843 bool WpADORecordset::AddNew(const OLEVariant &FieldList,const OLEVariant &Values)
 844 {
 845     assert(pInterface);
 846     return SUCCEEDED(pInterface->AddNew(FieldList,Values));
 847 }
 848
 849 bool WpADORecordset::Update(const OLEVariant &FieldList,const OLEVariant &Values)
 850 {
 851     assert(pInterface);
 852     return SUCCEEDED(pInterface->Update(FieldList,Values));
 853 }
 854
 855 bool WpADORecordset::CancelUpdate()
 856 {
 857     assert(pInterface);
 858     return SUCCEEDED(pInterface->CancelUpdate());
 859 }
 860
 861 WpADOProperties WpADORecordset::get_Properties() const
 862 {
 863     assert(pInterface);
 864     ADOProperties* pProps=nullptr;
 865     pInterface->get_Properties(&pProps);
 866     WpADOProperties aProps;
 867     aProps.setWithOutAddRef(pProps);
 868     return aProps;
 869 }
 870
 871 bool WpADORecordset::NextRecordset(OLEVariant& RecordsAffected,ADORecordset** ppiRset)
 872 {
 873     assert(pInterface);
 874     return SUCCEEDED(pInterface->NextRecordset(&RecordsAffected,ppiRset));
 875 }
 876
 877 bool WpADORecordset::get_RecordCount(ADO_LONGPTR &_nRet) const
 878 {
 879     assert(pInterface);
 880     return SUCCEEDED(pInterface->get_RecordCount(&_nRet));
 881 }
 882
 883 bool WpADORecordset::get_MaxRecords(ADO_LONGPTR &_nRet) const
 884 {
 885     assert(pInterface);
 886     return SUCCEEDED(pInterface->get_MaxRecords(&_nRet));
 887 }
 888
 889 bool WpADORecordset::put_MaxRecords(ADO_LONGPTR _nRet)
 890 {
 891     assert(pInterface);
 892     return SUCCEEDED(pInterface->put_MaxRecords(_nRet));
 893 }
 894
 895 bool WpADORecordset::get_CursorType(CursorTypeEnum &_nRet) const
 896 {
 897     assert(pInterface);
 898     return SUCCEEDED(pInterface->get_CursorType(&_nRet));
 899 }
 900
 901 bool WpADORecordset::put_CursorType(CursorTypeEnum _nRet)
 902 {
 903     assert(pInterface);
 904     return SUCCEEDED(pInterface->put_CursorType(_nRet));
 905 }
 906
 907 bool WpADORecordset::get_LockType(LockTypeEnum &_nRet) const
 908 {
 909     assert(pInterface);
 910     return SUCCEEDED(pInterface->get_LockType(&_nRet));
 911 }
 912
 913 bool WpADORecordset::put_LockType(LockTypeEnum _nRet)
 914 {
 915     assert(pInterface);
 916     return SUCCEEDED(pInterface->put_LockType(_nRet));
 917 }
 918
 919 bool WpADORecordset::get_CacheSize(sal_Int32 &_nRet) const
 920 {
 921     assert(pInterface);
 922     return SUCCEEDED(pInterface->get_CacheSize(&_nRet));
 923 }
 924
 925 bool WpADORecordset::put_CacheSize(sal_Int32 _nRet)
 926 {
 927     assert(pInterface);
 928     return SUCCEEDED(pInterface->put_CacheSize(_nRet));
 929 }
 930
 931 bool WpADORecordset::UpdateBatch(AffectEnum AffectRecords)
 932 {
 933     assert(pInterface);
 934     return SUCCEEDED(pInterface->UpdateBatch(AffectRecords));
 935 }
 936
 937 OUString WpADOParameter::GetName() const
 938 {
 939     assert(pInterface);
 940     OLEString aBSTR;
 941     pInterface->get_Name(aBSTR.getAddress());
 942     return aBSTR.asOUString();
 943 }
 944
 945 DataTypeEnum WpADOParameter::GetADOType() const
 946 {
 947     assert(pInterface);
 948     DataTypeEnum eType=adEmpty;
 949     pInterface->get_Type(&eType);
 950     return eType;
 951 }
 952
 953 void WpADOParameter::put_Type(const DataTypeEnum& _eType)
 954 {
 955     assert(pInterface);
 956     pInterface->put_Type(_eType);
 957 }
 958
 959 sal_Int32 WpADOParameter::GetAttributes() const
 960 {
 961     assert(pInterface);
 962     sal_Int32 eADOSFieldAttributes=0;
 963     pInterface->get_Attributes(&eADOSFieldAttributes);
 964     return eADOSFieldAttributes;
 965 }
 966
 967 sal_Int32 WpADOParameter::GetPrecision() const
 968 {
 969     assert(pInterface);
 970     sal_uInt8 eType=0;
 971     pInterface->get_Precision(&eType);
 972     return eType;
 973 }
 974
 975 sal_Int32 WpADOParameter::GetNumericScale() const
 976 {
 977     assert(pInterface);
 978     sal_uInt8 eType=0;
 979     pInterface->get_NumericScale(&eType);
 980     return eType;
 981 }
 982
 983 ParameterDirectionEnum WpADOParameter::get_Direction() const
 984 {
 985     assert(pInterface);
 986     ParameterDirectionEnum alParmDirection=adParamUnknown;
 987     pInterface->get_Direction(&alParmDirection);
 988     return alParmDirection;
 989 }
 990
 991 void WpADOParameter::GetValue(OLEVariant& aValVar) const
 992 {
 993     assert(pInterface);
 994     pInterface->get_Value(&aValVar);
 995 }
 996
 997 OLEVariant WpADOParameter::GetValue() const
 998 {
 999     assert(pInterface);
1000     OLEVariant aValVar;
1001     pInterface->get_Value(&aValVar);
1002     return aValVar;
1003 }
1004
1005 bool WpADOParameter::PutValue(const OLEVariant& aVariant)
1006 {
1007     assert(pInterface);
1008     return (SUCCEEDED(pInterface->put_Value(aVariant)));
1009 }
1010 bool WpADOParameter::AppendChunk(const OLEVariant& aVariant)
1011 {
1012     assert(pInterface);
1013     return (SUCCEEDED(pInterface->AppendChunk(aVariant)));
1014 }
1015 bool WpADOParameter::put_Size(sal_Int32 _nSize)
1016 {
1017     assert(pInterface);
1018     return (SUCCEEDED(pInterface->put_Size(_nSize)));
1019 }
1020
1021 OUString WpADOColumn::get_Name() const
1022 {
1023     assert(pInterface);
1024     OLEString aBSTR;
1025     pInterface->get_Name(aBSTR.getAddress());
1026     return aBSTR.asOUString();
1027 }
1028
1029 OUString WpADOColumn::get_RelatedColumn() const
1030 {
1031     assert(pInterface);
1032     OLEString aBSTR;
1033     pInterface->get_RelatedColumn(aBSTR.getAddress());
1034     return aBSTR.asOUString();
1035 }
1036
1037 void WpADOColumn::put_Name(const OUString& _rName)
1038 {
1039     assert(pInterface);
1040     OLEString bstr(_rName);
1041     pInterface->put_Name(bstr.asBSTR());
1042 }
1043 void WpADOColumn::put_RelatedColumn(const OUString& _rName)
1044 {
1045     assert(pInterface);
1046     OLEString bstr(_rName);
1047     pInterface->put_RelatedColumn(bstr.asBSTR());
1048 }
1049
1050 DataTypeEnum WpADOColumn::get_Type() const
1051 {
1052     assert(pInterface);
1053     DataTypeEnum eNum = adVarChar;
1054     pInterface->get_Type(&eNum);
1055     return eNum;
1056 }
1057
1058 void WpADOColumn::put_Type(const DataTypeEnum& _eNum)
1059 {
1060     assert(pInterface);
1061     pInterface->put_Type(_eNum);
1062 }
1063
1064 sal_Int32 WpADOColumn::get_Precision() const
1065 {
1066     assert(pInterface);
1067     sal_Int32 nPrec=0;
1068     pInterface->get_Precision(&nPrec);
1069     return nPrec;
1070 }
1071
1072 void WpADOColumn::put_Precision(sal_Int32 _nPre)
1073 {
1074     assert(pInterface);
1075     pInterface->put_Precision(_nPre);
1076 }
1077
1078 sal_Int32 WpADOColumn::get_DefinedSize() const
1079 {
1080     assert(pInterface);
1081     sal_Int32 nPrec=0;
1082     pInterface->get_DefinedSize(&nPrec);
1083     return nPrec;
1084 }
1085 sal_uInt8 WpADOColumn::get_NumericScale() const
1086 {
1087     assert(pInterface);
1088     sal_uInt8 nPrec=0;
1089     pInterface->get_NumericScale(&nPrec);
1090     return nPrec;
1091 }
1092
1093 void WpADOColumn::put_NumericScale(sal_Int8 _nScale)
1094 {
1095     assert(pInterface);
1096     pInterface->put_NumericScale(_nScale);
1097 }
1098
1099 SortOrderEnum WpADOColumn::get_SortOrder() const
1100 {
1101     assert(pInterface);
1102     SortOrderEnum nPrec=adSortAscending;
1103     pInterface->get_SortOrder(&nPrec);
1104     return nPrec;
1105 }
1106
1107 void WpADOColumn::put_SortOrder(SortOrderEnum _nScale)
1108 {
1109     assert(pInterface);
1110     pInterface->put_SortOrder(_nScale);
1111 }
1112
1113 ColumnAttributesEnum WpADOColumn::get_Attributes() const
1114 {
1115     assert(pInterface);
1116     ColumnAttributesEnum eNum=adColNullable;
1117     pInterface->get_Attributes(&eNum);
1118     return eNum;
1119 }
1120
1121 bool WpADOColumn::put_Attributes(const ColumnAttributesEnum& _eNum)
1122 {
1123     assert(pInterface);
1124     return SUCCEEDED(pInterface->put_Attributes(_eNum));
1125 }
1126
1127 WpADOProperties WpADOColumn::get_Properties() const
1128 {
1129     assert(pInterface);
1130     ADOProperties* pProps = nullptr;
1131     pInterface->get_Properties(&pProps);
1132     WpADOProperties aProps;
1133
1134     aProps.setWithOutAddRef(pProps);
1135     return aProps;
1136 }
1137
1138 OUString WpADOKey::get_Name() const
1139 {
1140     assert(pInterface);
1141     OLEString aBSTR;
1142     pInterface->get_Name(aBSTR.getAddress());
1143     return aBSTR.asOUString();
1144 }
1145
1146 void WpADOKey::put_Name(const OUString& _rName)
1147 {
1148     assert(pInterface);
1149     OLEString bstr(_rName);
1150     pInterface->put_Name(bstr.asBSTR());
1151 }
1152
1153 KeyTypeEnum WpADOKey::get_Type() const
1154 {
1155     assert(pInterface);
1156     KeyTypeEnum eNum=adKeyPrimary;
1157     pInterface->get_Type(&eNum);
1158     return eNum;
1159 }
1160
1161 void WpADOKey::put_Type(const KeyTypeEnum& _eNum)
1162 {
1163     assert(pInterface);
1164     pInterface->put_Type(_eNum);
1165 }
1166
1167 OUString WpADOKey::get_RelatedTable() const
1168 {
1169     assert(pInterface);
1170     OLEString aBSTR;
1171     pInterface->get_RelatedTable(aBSTR.getAddress());
1172     return aBSTR.asOUString();
1173 }
1174
1175 void WpADOKey::put_RelatedTable(const OUString& _rName)
1176 {
1177     assert(pInterface);
1178     OLEString bstr(_rName);
1179     pInterface->put_RelatedTable(bstr.asBSTR());
1180 }
1181
1182 RuleEnum WpADOKey::get_DeleteRule() const
1183 {
1184     assert(pInterface);
1185     RuleEnum eNum = adRINone;
1186     pInterface->get_DeleteRule(&eNum);
1187     return eNum;
1188 }
1189
1190 void WpADOKey::put_DeleteRule(const RuleEnum& _eNum)
1191 {
1192     assert(pInterface);
1193     pInterface->put_DeleteRule(_eNum);
1194 }
1195
1196 RuleEnum WpADOKey::get_UpdateRule() const
1197 {
1198     assert(pInterface);
1199     RuleEnum eNum = adRINone;
1200     pInterface->get_UpdateRule(&eNum);
1201     return eNum;
1202 }
1203
1204 void WpADOKey::put_UpdateRule(const RuleEnum& _eNum)
1205 {
1206     assert(pInterface);
1207     pInterface->put_UpdateRule(_eNum);
1208 }
1209
1210 WpADOColumns WpADOKey::get_Columns() const
1211 {
1212     assert(pInterface);
1213     ADOColumns* pCols = nullptr;
1214     pInterface->get_Columns(&pCols);
1215     WpADOColumns aCols;
1216     aCols.setWithOutAddRef(pCols);
1217     return aCols;
1218 }
1219
1220 OUString WpADOIndex::get_Name() const
1221 {
1222     assert(pInterface);
1223     OLEString aBSTR;
1224     pInterface->get_Name(aBSTR.getAddress());
1225     return aBSTR.asOUString();
1226 }
1227
1228 void WpADOIndex::put_Name(const OUString& _rName)
1229 {
1230     assert(pInterface);
1231     OLEString bstr(_rName);
1232     pInterface->put_Name(bstr.asBSTR());
1233 }
1234
1235 bool WpADOIndex::get_Clustered() const
1236 {
1237     assert(pInterface);
1238     VARIANT_BOOL eNum = VARIANT_FALSE;
1239     pInterface->get_Clustered(&eNum);
1240     return eNum == VARIANT_TRUE;
1241 }
1242
1243 void WpADOIndex::put_Clustered(bool _b)
1244 {
1245     assert(pInterface);
1246     pInterface->put_Clustered(_b ? VARIANT_TRUE : VARIANT_FALSE);
1247 }
1248
1249 bool WpADOIndex::get_Unique() const
1250 {
1251     assert(pInterface);
1252     VARIANT_BOOL eNum = VARIANT_FALSE;
1253     pInterface->get_Unique(&eNum);
1254     return eNum == VARIANT_TRUE;
1255 }
1256
1257 void WpADOIndex::put_Unique(bool _b)
1258 {
1259     assert(pInterface);
1260     pInterface->put_Unique(_b ? VARIANT_TRUE : VARIANT_FALSE);
1261 }
1262
1263 bool WpADOIndex::get_PrimaryKey() const
1264 {
1265     assert(pInterface);
1266     VARIANT_BOOL eNum = VARIANT_FALSE;
1267     pInterface->get_PrimaryKey(&eNum);
1268     return eNum == VARIANT_TRUE;
1269 }
1270
1271 void WpADOIndex::put_PrimaryKey(bool _b)
1272 {
1273     assert(pInterface);
1274     pInterface->put_PrimaryKey(_b ? VARIANT_TRUE : VARIANT_FALSE);
1275 }
1276
1277 WpADOColumns WpADOIndex::get_Columns() const
1278 {
1279     assert(pInterface);
1280     ADOColumns* pCols = nullptr;
1281     pInterface->get_Columns(&pCols);
1282     WpADOColumns aCols;
1283     aCols.setWithOutAddRef(pCols);
1284     return aCols;
1285 }
1286
1287 void WpADOCatalog::putref_ActiveConnection(IDispatch* pCon)
1288 {
1289     assert(pInterface);
1290     pInterface->putref_ActiveConnection(pCon);
1291 }
1292
1293 WpADOTables WpADOCatalog::get_Tables()
1294 {
1295     assert(pInterface);
1296     ADOTables* pRet = nullptr;
1297     pInterface->get_Tables(&pRet);
1298     WpADOTables aRet;
1299     aRet.setWithOutAddRef(pRet);
1300     return aRet;
1301 }
1302
1303 WpADOViews WpADOCatalog::get_Views()
1304 {
1305     assert(pInterface);
1306     ADOViews* pRet = nullptr;
1307     pInterface->get_Views(&pRet);
1308     WpADOViews aRet;
1309     aRet.setWithOutAddRef(pRet);
1310     return aRet;
1311 }
1312
1313 WpADOGroups WpADOCatalog::get_Groups()
1314 {
1315     assert(pInterface);
1316     ADOGroups* pRet = nullptr;
1317     pInterface->get_Groups(&pRet);
1318     WpADOGroups aRet;
1319     aRet.setWithOutAddRef(pRet);
1320     return aRet;
1321 }
1322
1323 WpADOUsers WpADOCatalog::get_Users()
1324 {
1325     assert(pInterface);
1326     ADOUsers* pRet = nullptr;
1327     pInterface->get_Users(&pRet);
1328     WpADOUsers aRet;
1329     aRet.setWithOutAddRef(pRet);
1330     return aRet;
1331 }
1332
1333 ADOProcedures* WpADOCatalog::get_Procedures()
1334 {
1335     assert(pInterface);
1336     ADOProcedures* pRet = nullptr;
1337     pInterface->get_Procedures(&pRet);
1338     return pRet;
1339 }
1340
1341 OUString WpADOTable::get_Name() const
1342 {
1343     assert(pInterface);
1344     OLEString aBSTR;
1345     pInterface->get_Name(aBSTR.getAddress());
1346     return aBSTR.asOUString();
1347 }
1348
1349 void WpADOTable::put_Name(const OUString& _rName)
1350 {
1351     assert(pInterface);
1352     OLEString bstr(_rName);
1353     pInterface->put_Name(bstr.asBSTR());
1354 }
1355
1356 OUString WpADOTable::get_Type() const
1357 {
1358     assert(pInterface);
1359     OLEString aBSTR;
1360     pInterface->get_Type(aBSTR.getAddress());
1361     return aBSTR.asOUString();
1362 }
1363
1364 WpADOColumns WpADOTable::get_Columns() const
1365 {
1366     assert(pInterface);
1367     ADOColumns* pCols = nullptr;
1368     pInterface->get_Columns(&pCols);
1369     WpADOColumns aCols;
1370     aCols.setWithOutAddRef(pCols);
1371     return aCols;
1372 }
1373
1374 WpADOIndexes WpADOTable::get_Indexes() const
1375 {
1376     assert(pInterface);
1377     ADOIndexes* pCols = nullptr;
1378     pInterface->get_Indexes(&pCols);
1379     WpADOIndexes aRet;
1380     aRet.setWithOutAddRef(pCols);
1381     return aRet;
1382 }
1383
1384 WpADOKeys WpADOTable::get_Keys() const
1385 {
1386     assert(pInterface);
1387     ADOKeys* pCols = nullptr;
1388     pInterface->get_Keys(&pCols);
1389     WpADOKeys aRet;
1390     aRet.setWithOutAddRef(pCols);
1391     return aRet;
1392 }
1393
1394 WpADOCatalog WpADOTable::get_ParentCatalog() const
1395 {
1396     assert(pInterface);
1397     ADOCatalog* pCat = nullptr;
1398     pInterface->get_ParentCatalog(&pCat);
1399     WpADOCatalog aRet;
1400     aRet.setWithOutAddRef(pCat);
1401     return aRet;
1402 }
1403
1404 WpADOProperties WpADOTable::get_Properties() const
1405 {
1406     assert(pInterface);
1407     ADOProperties* pProps = nullptr;
1408     pInterface->get_Properties(&pProps);
1409     WpADOProperties aProps;
1410     aProps.setWithOutAddRef(pProps);
1411     return aProps;
1412 }
1413
1414 OUString WpADOView::get_Name() const
1415 {
1416     assert(pInterface);
1417     OLEString aBSTR;
1418     pInterface->get_Name(aBSTR.getAddress());
1419     return aBSTR.asOUString();
1420 }
1421
1422 void WpADOView::get_Command(OLEVariant& _rVar) const
1423 {
1424     assert(pInterface);
1425     pInterface->get_Command(&_rVar);
1426 }
1427
1428 void WpADOView::put_Command(OLEVariant const & _rVar)
1429 {
1430     assert(pInterface);
1431     pInterface->put_Command(_rVar);
1432 }
1433
1434 OUString WpADOGroup::get_Name() const
1435 {
1436     OLEString aBSTR;
1437     pInterface->get_Name(aBSTR.getAddress());
1438     return aBSTR.asOUString();
1439 }
1440
1441 void WpADOGroup::put_Name(const OUString& _rName)
1442 {
1443     OLEString bstr(_rName);
1444     pInterface->put_Name(bstr.asBSTR());
1445 }
1446
1447 RightsEnum WpADOGroup::GetPermissions(
1448     /* [in] */ const OLEVariant& Name,
1449     /* [in] */ ObjectTypeEnum ObjectType)
1450 {
1451     RightsEnum Rights=adRightNone;
1452     OLEVariant ObjectTypeId;
1453     ObjectTypeId.setNoArg();
1454     pInterface->GetPermissions(Name,ObjectType,ObjectTypeId,&Rights);
1455     return Rights;
1456 }
1457
1458 bool WpADOGroup::SetPermissions(
1459     /* [in] */ const OLEVariant& Name,
1460     /* [in] */ ObjectTypeEnum ObjectType,
1461     /* [in] */ ActionEnum Action,
1462     /* [in] */ RightsEnum Rights)
1463 {
1464     OLEVariant ObjectTypeId;
1465     ObjectTypeId.setNoArg();
1466     return SUCCEEDED(pInterface->SetPermissions(Name,ObjectType,Action,Rights,adInheritNone,ObjectTypeId));
1467 }
1468
1469 WpADOUsers WpADOGroup::get_Users( )
1470 {
1471     ADOUsers* pRet = nullptr;
1472     pInterface->get_Users( &pRet);
1473     WpADOUsers aRet;
1474     aRet.setWithOutAddRef(pRet);
1475     return aRet;
1476 }
1477
1478 OUString WpADOUser::get_Name() const
1479 {
1480     OLEString aBSTR;
1481     pInterface->get_Name(aBSTR.getAddress());
1482     return aBSTR.asOUString();
1483 }
1484
1485 void WpADOUser::put_Name(const OUString& _rName)
1486 {
1487     OLEString bstr(_rName);
1488     pInterface->put_Name(bstr.asBSTR());
1489 }
1490
1491 bool WpADOUser::ChangePassword(const OUString& _rPwd,const OUString& _rNewPwd)
1492 {
1493     OLEString sStr1(_rPwd);
1494     OLEString sStr2(_rNewPwd);
1495     bool bErg = SUCCEEDED(pInterface->ChangePassword(sStr1.asBSTR(),sStr2.asBSTR()));
1496     return bErg;
1497 }
1498
1499 WpADOGroups WpADOUser::get_Groups()
1500 {
1501     ADOGroups* pRet = nullptr;
1502     pInterface->get_Groups(&pRet);
1503     WpADOGroups aRet;
1504     aRet.setWithOutAddRef(pRet);
1505     return aRet;
1506 }
1507
1508 RightsEnum WpADOUser::GetPermissions(
1509     /* [in] */ const OLEVariant& Name,
1510     /* [in] */ ObjectTypeEnum ObjectType)
1511 {
1512     RightsEnum Rights=adRightNone;
1513     OLEVariant ObjectTypeId;
1514     ObjectTypeId.setNoArg();
1515     pInterface->GetPermissions(Name,ObjectType,ObjectTypeId,&Rights);
1516     return Rights;
1517 }
1518
1519 bool WpADOUser::SetPermissions(
1520     /* [in] */ const OLEVariant& Name,
1521     /* [in] */ ObjectTypeEnum ObjectType,
1522     /* [in] */ ActionEnum Action,
1523     /* [in] */ RightsEnum Rights)
1524 {
1525     OLEVariant ObjectTypeId;
1526     ObjectTypeId.setNoArg();
1527     return SUCCEEDED(pInterface->SetPermissions(Name,ObjectType,Action,Rights,adInheritNone,ObjectTypeId));
1528 }
1529
1530 WpBase::WpBase() : pIUnknown(nullptr)
1531 {
1532 }
1533 WpBase::WpBase(IDispatch* pInt)
1534     :pIUnknown(pInt)
1535 {
1536     if (pIUnknown)
1537     {
1538         pIUnknown->AddRef();
1539     }
1540 }
1541
1542 WpBase::WpBase(const WpBase& aWrapper)
1543     :pIUnknown(aWrapper.pIUnknown)
1544 {
1545     if (pIUnknown)
1546         pIUnknown->AddRef();
1547 }
1548
1549 //inline
1550 WpBase& WpBase::operator=(const WpBase& rhs)
1551 {
1552     operator=(rhs.pIUnknown);
1553     return *this;
1554 };
1555
1556 WpBase& WpBase::operator=(IDispatch* rhs)
1557 {
1558     if (pIUnknown != rhs)
1559     {
1560         if (pIUnknown)
1561             pIUnknown->Release();
1562         pIUnknown = rhs;
1563         if (pIUnknown)
1564             pIUnknown->AddRef();
1565     }
1566     return *this;
1567 }
1568
1569 WpBase::~WpBase()
1570 {
1571     if (pIUnknown)
1572     {
1573         pIUnknown->Release();
1574         pIUnknown = nullptr;
1575     }
1576 }
1577
1578 void WpBase::clear()
1579 {
1580     if (pIUnknown)
1581     {
1582         pIUnknown->Release();
1583         pIUnknown = nullptr;
1584     }
1585 }
1586
1587
1588 bool WpBase::IsValid() const
1589 {
1590     return pIUnknown != nullptr;
1591 }
1592 WpBase::operator IDispatch*()
1593 {
1594     return pIUnknown;
1595 }
1596
1597 ADORecordset* WpADOConnection::getExportedKeys( const css::uno::Any& catalog, const OUString& schema, const OUString& table )
1598 {
1599     // Create elements used in the array
1600     SAFEARRAYBOUND rgsabound[1];
1601     SAFEARRAY *psa = nullptr;
1602     OLEVariant varCriteria[6];
1603
1604     // Create SafeArray Bounds and initialize the array
1605     rgsabound[0].lLbound   = 0;
1606     rgsabound[0].cElements = SAL_N_ELEMENTS(varCriteria);
1607     psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
1608
1609     sal_Int32 nPos=0;
1610     if(catalog.hasValue())
1611         varCriteria[nPos].setString(::comphelper::getString(catalog));
1612
1613     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
1614     if(schema.getLength() && schema.toChar() != '%')
1615         varCriteria[nPos].setString(schema);
1616     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
1617
1618     varCriteria[nPos].setString(table);
1619     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
1620
1621     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
1622     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
1623     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
1624
1625     OLEVariant  vtEmpty;
1626     vtEmpty.setNoArg();
1627
1628     // Initialize and fill the SafeArray
1629     OLEVariant vsa;
1630     vsa.setArray(psa,VT_VARIANT);
1631
1632     ADORecordset *pRecordset = nullptr;
1633     OpenSchema(adSchemaForeignKeys,vsa,vtEmpty,&pRecordset);
1634     return pRecordset;
1635 }
1636
1637 ADORecordset* WpADOConnection::getImportedKeys( const css::uno::Any& catalog, const OUString& schema, const OUString& table )
1638 {
1639     // Create elements used in the array
1640     SAFEARRAYBOUND rgsabound[1];
1641     SAFEARRAY *psa = nullptr;
1642     OLEVariant varCriteria[6];
1643
1644     // Create SafeArray Bounds and initialize the array
1645     rgsabound[0].lLbound   = 0;
1646     rgsabound[0].cElements = SAL_N_ELEMENTS(varCriteria);
1647     psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
1648
1649     sal_Int32 nPos=0;
1650     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
1651     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
1652     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
1653
1654     if(catalog.hasValue())
1655         varCriteria[nPos].setString(::comphelper::getString(catalog));
1656
1657     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
1658     if(schema.getLength() && schema.toChar() != '%')
1659         varCriteria[nPos].setString(schema);
1660     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
1661
1662     varCriteria[nPos].setString(table);
1663     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
1664
1665     OLEVariant  vtEmpty;
1666     vtEmpty.setNoArg();
1667
1668     // Initialize and fill the SafeArray
1669     OLEVariant vsa;
1670     vsa.setArray(psa,VT_VARIANT);
1671
1672     ADORecordset *pRecordset = nullptr;
1673     OpenSchema(adSchemaForeignKeys,vsa,vtEmpty,&pRecordset);
1674
1675     return pRecordset;
1676
1677 }
1678
1679 ADORecordset* WpADOConnection::getPrimaryKeys( const css::uno::Any& catalog, const OUString& schema, const OUString& table )
1680 {
1681     // Create elements used in the array
1682     SAFEARRAYBOUND rgsabound[1];
1683     SAFEARRAY *psa = nullptr;
1684     OLEVariant varCriteria[3];
1685
1686     // Create SafeArray Bounds and initialize the array
1687     rgsabound[0].lLbound   = 0;
1688     rgsabound[0].cElements = SAL_N_ELEMENTS(varCriteria);
1689     psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
1690
1691     sal_Int32 nPos=0;
1692     if(catalog.hasValue())
1693         varCriteria[nPos].setString(::comphelper::getString(catalog));
1694
1695     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
1696     if(schema.getLength() && schema.toChar() != '%')
1697         varCriteria[nPos].setString(schema);
1698     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
1699
1700     varCriteria[nPos].setString(table);
1701     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
1702
1703
1704     OLEVariant  vtEmpty;
1705     vtEmpty.setNoArg();
1706
1707     // Initialize and fill the SafeArray
1708     OLEVariant vsa;
1709     vsa.setArray(psa,VT_VARIANT);
1710
1711     ADORecordset *pRecordset = nullptr;
1712     OpenSchema(adSchemaPrimaryKeys,vsa,vtEmpty,&pRecordset);
1713
1714     return pRecordset;
1715 }
1716
1717 ADORecordset* WpADOConnection::getIndexInfo(
1718     const css::uno::Any& catalog, const OUString& schema, const OUString& table,
1719     bool /*unique*/, bool /*approximate*/ )
1720 {
1721     // Create elements used in the array
1722     SAFEARRAYBOUND rgsabound[1];
1723     SAFEARRAY *psa = nullptr;
1724     OLEVariant varCriteria[5];
1725
1726     // Create SafeArray Bounds and initialize the array
1727     rgsabound[0].lLbound   = 0;
1728     rgsabound[0].cElements = SAL_N_ELEMENTS(varCriteria);
1729     psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
1730
1731     sal_Int32 nPos=0;
1732     if(catalog.hasValue())
1733         varCriteria[nPos].setString(::comphelper::getString(catalog));
1734
1735     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
1736     if(schema.getLength() && schema.toChar() != '%')
1737         varCriteria[nPos].setString(schema);
1738     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
1739
1740     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// INDEX_NAME
1741
1742     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TYPE
1743
1744     varCriteria[nPos].setString(table);
1745     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
1746
1747     OLEVariant  vtEmpty;
1748     vtEmpty.setNoArg();
1749
1750     // Initialize and fill the SafeArray
1751     OLEVariant vsa;
1752     vsa.setArray(psa,VT_VARIANT);
1753
1754     ADORecordset *pRecordset = nullptr;
1755     OpenSchema(adSchemaIndexes,vsa,vtEmpty,&pRecordset);
1756
1757     return pRecordset;
1758 }
1759
1760 ADORecordset* WpADOConnection::getTablePrivileges( const css::uno::Any& catalog,
1761                                                   const OUString& schemaPattern,
1762                                                   const OUString& tableNamePattern )
1763 {
1764     SAFEARRAYBOUND rgsabound[1];
1765     SAFEARRAY *psa = nullptr;
1766     OLEVariant varCriteria[5];
1767
1768     // Create SafeArray Bounds and initialize the array
1769     rgsabound[0].lLbound   = 0;
1770     rgsabound[0].cElements = SAL_N_ELEMENTS(varCriteria);
1771     psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
1772
1773     sal_Int32 nPos=0;
1774     if(catalog.hasValue())
1775         varCriteria[nPos].setString(::comphelper::getString(catalog));
1776
1777     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
1778     if(schemaPattern.getLength() && schemaPattern.toChar() != '%')
1779         varCriteria[nPos].setString(schemaPattern);
1780     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
1781
1782     if(tableNamePattern.toChar() != '%')
1783         varCriteria[nPos].setString(tableNamePattern);
1784     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
1785
1786     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// GRANTOR
1787     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// GRANTEE
1788
1789     OLEVariant  vtEmpty;
1790     vtEmpty.setNoArg();
1791
1792     // Initialize and fill the SafeArray
1793     OLEVariant vsa;
1794     vsa.setArray(psa,VT_VARIANT);
1795
1796     ADORecordset *pRecordset = nullptr;
1797     OpenSchema(adSchemaTablePrivileges,vsa,vtEmpty,&pRecordset);
1798
1799     return pRecordset;
1800 }
1801
1802 ADORecordset* WpADOConnection::getCrossReference( const css::uno::Any& primaryCatalog,
1803                                                   const OUString& primarySchema,
1804                                                   const OUString& primaryTable,
1805                                                   const css::uno::Any& foreignCatalog,
1806                                                   const OUString& foreignSchema,
1807                                                   const OUString& foreignTable)
1808 {
1809     // Create elements used in the array
1810     SAFEARRAYBOUND rgsabound[1];
1811     SAFEARRAY *psa = nullptr;
1812     OLEVariant varCriteria[6];
1813
1814     // Create SafeArray Bounds and initialize the array
1815     rgsabound[0].lLbound   = 0;
1816     rgsabound[0].cElements = SAL_N_ELEMENTS(varCriteria);
1817     psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
1818
1819     sal_Int32 nPos=0;
1820     if(primaryCatalog.hasValue())
1821         varCriteria[nPos].setString(::comphelper::getString(primaryCatalog));
1822
1823     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
1824     if(primarySchema.getLength() && primarySchema.toChar() != '%')
1825         varCriteria[nPos].setString(primarySchema);
1826     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
1827
1828     varCriteria[nPos].setString(primaryTable);
1829     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
1830
1831     if(foreignCatalog.hasValue())
1832         varCriteria[nPos].setString(::comphelper::getString(foreignCatalog));
1833
1834     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
1835     if(foreignSchema.getLength() && foreignSchema.toChar() != '%')
1836         varCriteria[nPos].setString(foreignSchema);
1837     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
1838
1839     varCriteria[nPos].setString(foreignTable);
1840     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
1841
1842     OLEVariant  vtEmpty;
1843     vtEmpty.setNoArg();
1844
1845     // Initialize and fill the SafeArray
1846     OLEVariant vsa;
1847     vsa.setArray(psa,VT_VARIANT);
1848
1849     ADORecordset *pRecordset = nullptr;
1850     OpenSchema(adSchemaForeignKeys,vsa,vtEmpty,&pRecordset);
1851
1852     return pRecordset;
1853 }
1854
1855 ADORecordset* WpADOConnection::getProcedures( const css::uno::Any& catalog,
1856                                                   const OUString& schemaPattern,
1857                                                   const OUString& procedureNamePattern )
1858 {
1859     SAFEARRAYBOUND rgsabound[1];
1860     SAFEARRAY *psa = nullptr;
1861     OLEVariant varCriteria[3];
1862
1863     // Create SafeArray Bounds and initialize the array
1864     rgsabound[0].lLbound   = 0;
1865     rgsabound[0].cElements = SAL_N_ELEMENTS(varCriteria);
1866     psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
1867
1868     sal_Int32 nPos=0;
1869     if(catalog.hasValue())
1870         varCriteria[nPos].setString(::comphelper::getString(catalog));
1871
1872     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
1873     if(schemaPattern.getLength() && schemaPattern.toChar() != '%')
1874         varCriteria[nPos].setString(schemaPattern);
1875     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
1876
1877     if(procedureNamePattern.toChar() != '%')
1878         varCriteria[nPos].setString(procedureNamePattern);
1879     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
1880
1881     OLEVariant  vtEmpty;
1882     vtEmpty.setNoArg();
1883
1884     // Initialize and fill the SafeArray
1885     OLEVariant vsa;
1886     vsa.setArray(psa,VT_VARIANT);
1887
1888     ADORecordset *pRecordset = nullptr;
1889     OpenSchema(adSchemaProcedures,vsa,vtEmpty,&pRecordset);
1890
1891     return pRecordset;
1892 }
1893
1894 ADORecordset* WpADOConnection::getProcedureColumns( const css::uno::Any& catalog,
1895                                                   const OUString& schemaPattern,
1896                                                   const OUString& procedureNamePattern,
1897                                                   const OUString& columnNamePattern )
1898 {
1899     // Create elements used in the array
1900     SAFEARRAYBOUND rgsabound[1];
1901     SAFEARRAY *psa = nullptr;
1902     OLEVariant varCriteria[4];
1903
1904     // Create SafeArray Bounds and initialize the array
1905     rgsabound[0].lLbound   = 0;
1906     rgsabound[0].cElements = SAL_N_ELEMENTS(varCriteria);
1907     psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
1908
1909     sal_Int32 nPos=0;
1910     if(catalog.hasValue())
1911         varCriteria[nPos].setString(::comphelper::getString(catalog));
1912
1913     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
1914     if(schemaPattern.getLength() && schemaPattern.toChar() != '%')
1915         varCriteria[nPos].setString(schemaPattern);
1916     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
1917
1918     if(procedureNamePattern.toChar() != '%')
1919         varCriteria[nPos].setString(procedureNamePattern);
1920     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
1921
1922     if(columnNamePattern.toChar() != '%')
1923         varCriteria[nPos].setString(columnNamePattern);
1924     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// COLUMN_NAME
1925
1926     OLEVariant  vtEmpty;
1927     vtEmpty.setNoArg();
1928
1929     // Initialize and fill the SafeArray
1930     OLEVariant vsa;
1931     vsa.setArray(psa,VT_VARIANT);
1932
1933     ADORecordset *pRecordset = nullptr;
1934     OpenSchema(adSchemaProcedureParameters,vsa,vtEmpty,&pRecordset);
1935
1936     return pRecordset;
1937 }
1938
1939 ADORecordset* WpADOConnection::getTables( const css::uno::Any& catalog,
1940                                                   const OUString& schemaPattern,
1941                                                   const OUString& tableNamePattern,
1942                                                   const css::uno::Sequence< OUString >& types )
1943 {
1944     // Create elements used in the array
1945     HRESULT hr = S_OK;
1946     OLEVariant varCriteria[4];
1947
1948     sal_Int32 nPos=0;
1949     OUString sCatalog;
1950     if ( catalog.hasValue() && (catalog >>= sCatalog) )
1951         varCriteria[nPos].setString(sCatalog);
1952
1953     ++nPos;
1954     if(schemaPattern.getLength() && schemaPattern.toChar() != '%')
1955         varCriteria[nPos].setString(schemaPattern);
1956
1957     ++nPos;
1958     if(tableNamePattern.toChar() != '%')
1959         varCriteria[nPos].setString(tableNamePattern);
1960
1961     ++nPos;
1962     OUStringBuffer aTypes;
1963     const OUString* pIter = types.getConstArray();
1964     const OUString* pEnd = pIter + types.getLength();
1965     for( ; pIter != pEnd ; ++pIter)
1966     {
1967         if ( aTypes.getLength() )
1968             aTypes.append(",");
1969         aTypes.append(*pIter);
1970     }
1971
1972     OUString sTypeNames = aTypes.makeStringAndClear();
1973     if ( sTypeNames.getLength() )
1974         varCriteria[nPos].setString(sTypeNames);
1975
1976     // Create SafeArray Bounds and initialize the array
1977     const sal_Int32 nCrit = SAL_N_ELEMENTS(varCriteria);
1978     SAFEARRAYBOUND rgsabound[1];
1979     rgsabound[0].lLbound   = 0;
1980     rgsabound[0].cElements = nCrit;
1981     SAFEARRAY *psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
1982
1983     // Set the values for each element of the array
1984     for( long i = 0 ; i < nCrit && SUCCEEDED( hr );i++)
1985     {
1986         hr  = SafeArrayPutElement(psa, &i,&varCriteria[i]);
1987     }
1988
1989     OLEVariant  vtEmpty;
1990     vtEmpty.setNoArg();
1991
1992     // Initialize and fill the SafeArray
1993     OLEVariant vsa;
1994     vsa.setArray(psa,VT_VARIANT);
1995
1996     ADORecordset *pRecordset = nullptr;
1997     OpenSchema(adSchemaTables,vsa,vtEmpty,&pRecordset);
1998
1999     return pRecordset;
2000 }
2001
2002 ADORecordset* WpADOConnection::getColumns( const css::uno::Any& catalog,
2003                                                   const OUString& schemaPattern,
2004                                                   const OUString& tableNamePattern,
2005                                                   const OUString& columnNamePattern )
2006 {
2007     // Create elements used in the array
2008     SAFEARRAYBOUND rgsabound[1];
2009     SAFEARRAY *psa = nullptr;
2010     OLEVariant varCriteria[4];
2011
2012     // Create SafeArray Bounds and initialize the array
2013     rgsabound[0].lLbound   = 0;
2014     rgsabound[0].cElements = SAL_N_ELEMENTS(varCriteria);
2015     psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
2016
2017     sal_Int32 nPos=0;
2018     if(catalog.hasValue())
2019         varCriteria[nPos].setString(::comphelper::getString(catalog));
2020
2021     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
2022     if(schemaPattern.getLength() && schemaPattern.toChar() != '%')
2023         varCriteria[nPos].setString(schemaPattern);
2024     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
2025
2026     if(tableNamePattern.toChar() != '%')
2027         varCriteria[nPos].setString(tableNamePattern);
2028     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
2029
2030     varCriteria[nPos].setString(columnNamePattern);
2031     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// COLUMN_NAME
2032
2033     OLEVariant  vtEmpty;
2034     vtEmpty.setNoArg();
2035
2036     // Initialize and fill the SafeArray
2037     OLEVariant vsa;
2038     vsa.setArray(psa,VT_VARIANT);
2039
2040     ADORecordset *pRecordset = nullptr;
2041     OpenSchema(adSchemaColumns,vsa,vtEmpty,&pRecordset);
2042
2043     return pRecordset;
2044 }
2045
2046 ADORecordset* WpADOConnection::getColumnPrivileges( const css::uno::Any& catalog,
2047                                                   const OUString& schema,
2048                                                   const OUString& table,
2049                                                   const OUString& columnNamePattern )
2050 {
2051     // Create elements used in the array
2052     SAFEARRAYBOUND rgsabound[1];
2053     SAFEARRAY *psa = nullptr;
2054     OLEVariant varCriteria[4];
2055
2056     // Create SafeArray Bounds and initialize the array
2057     rgsabound[0].lLbound   = 0;
2058     rgsabound[0].cElements = SAL_N_ELEMENTS(varCriteria);
2059     psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
2060
2061     sal_Int32 nPos=0;
2062     if(catalog.hasValue())
2063         varCriteria[nPos].setString(::comphelper::getString(catalog));
2064
2065     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_CATALOG
2066     if(schema.getLength() && schema.toChar() != '%')
2067         varCriteria[nPos].setString(schema);
2068     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_SCHEMA
2069
2070     varCriteria[nPos].setString(table);
2071     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// TABLE_NAME
2072
2073     varCriteria[nPos].setString(columnNamePattern);
2074     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;// COLUMN_NAME
2075
2076     OLEVariant  vtEmpty;
2077     vtEmpty.setNoArg();
2078
2079     // Initialize and fill the SafeArray
2080     OLEVariant vsa;
2081     vsa.setArray(psa,VT_VARIANT);
2082
2083     ADORecordset *pRecordset = nullptr;
2084     OpenSchema(adSchemaColumnPrivileges,vsa,vtEmpty,&pRecordset);
2085
2086     return pRecordset;
2087 }
2088
2089 ADORecordset* WpADOConnection::getTypeInfo(DataTypeEnum /*_eType*/)
2090 {
2091     // Create elements used in the array
2092     OLEVariant varCriteria[2];
2093     const int nCrit = SAL_N_ELEMENTS(varCriteria);
2094     // Create SafeArray Bounds and initialize the array
2095     SAFEARRAYBOUND rgsabound[1];
2096     rgsabound[0].lLbound   = 0;
2097     rgsabound[0].cElements = nCrit;
2098     SAFEARRAY *psa         = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
2099
2100     sal_Int32 nPos = 0;
2101     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;
2102     SafeArrayPutElement(psa,&nPos,&varCriteria[nPos]);nPos++;
2103
2104     // Initialize and fill the SafeArray
2105     OLEVariant vsa;
2106     vsa.setArray(psa,VT_VARIANT);
2107
2108     OLEVariant aEmpty;
2109     aEmpty.setNoArg();
2110
2111     ADORecordset *pRec=nullptr;
2112     OpenSchema(adSchemaProviderTypes,vsa,aEmpty,&pRec);
2113
2114     return pRec;
2115 }
2116
2117 void WpADOColumn::put_ParentCatalog(/* [in] */ _ADOCatalog __RPC_FAR *ppvObject)
2118 {
2119     assert(pInterface);
2120     bool bRet = SUCCEEDED(pInterface->put_ParentCatalog(ppvObject));
2121     SAL_WARN_IF(!bRet, "connectivity.ado", "Could not set ParentCatalog!");
2122 }
2123
2124 void WpADOTable::putref_ParentCatalog(/* [in] */ _ADOCatalog __RPC_FAR *ppvObject)
2125 {
2126     assert(pInterface);
2127     bool bRet = SUCCEEDED(pInterface->putref_ParentCatalog(ppvObject));
2128     SAL_WARN_IF(!bRet, "connectivity.ado", "Could not set ParentCatalog!");
2129 }
2130
2131 void WpBase::setIDispatch(IDispatch* _pIUnknown)
2132 {
2133     pIUnknown = _pIUnknown;
2134 }
2135
2136 void OTools::putValue(const WpADOProperties& _rProps,const OLEVariant &_aPosition,const OLEVariant &_aValVar)
2137 {
2138     SAL_WARN_IF(!_rProps.IsValid(), "connectivity.ado", "Properties are not valid!");
2139     WpADOProperty aProp(_rProps.GetItem(_aPosition));
2140     if ( aProp.IsValid() )
2141     {
2142         bool bRet = aProp.PutValue(_aValVar);
2143         SAL_WARN_IF(!bRet, "connectivity.ado", "Could not put value!");
2144     }
2145 }
2146
2147 OLEVariant OTools::getValue(const WpADOProperties& _rProps,const OLEVariant &_aPosition)
2148 {
2149     WpADOProperty aProp(_rProps.GetItem(_aPosition));
2150     return aProp.GetValue();
2151 }
2152
2153 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */