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