dlls/msi/msiquery.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2002-2005 Mike McCormack for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winerror.h"
  28 #include "wine/debug.h"
  29 #include "wine/unicode.h"
  30 #include "msi.h"
  31 #include "msiquery.h"
  32 #include "objbase.h"
  33 #include "objidl.h"
  34 #include "msipriv.h"
  35 #include "winnls.h"
  36
  37 #include "query.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  40
  41 void MSI_CloseView( MSIOBJECTHDR *arg )
  42 {
  43     MSIQUERY *query = (MSIQUERY*) arg;
  44     struct list *ptr, *t;
  45
  46     if( query->view && query->view->ops->delete )
  47         query->view->ops->delete( query->view );
  48     msiobj_release( &query->db->hdr );
  49
  50     LIST_FOR_EACH_SAFE( ptr, t, &query->mem )
  51     {
  52         HeapFree( GetProcessHeap(), 0, ptr );
  53     }
  54 }
  55
  56 UINT VIEW_find_column( MSIVIEW *table, LPCWSTR name, UINT *n )
  57 {
  58     LPWSTR col_name;
  59     UINT i, count, r;
  60
  61     r = table->ops->get_dimensions( table, NULL, &count );
  62     if( r != ERROR_SUCCESS )
  63         return r;
  64
  65     for( i=1; i<=count; i++ )
  66     {
  67         INT x;
  68
  69         col_name = NULL;
  70         r = table->ops->get_column_info( table, i, &col_name, NULL );
  71         if( r != ERROR_SUCCESS )
  72             return r;
  73         x = lstrcmpW( name, col_name );
  74         HeapFree( GetProcessHeap(), 0, col_name );
  75         if( !x )
  76         {
  77             *n = i;
  78             return ERROR_SUCCESS;
  79         }
  80     }
  81
  82     return ERROR_INVALID_PARAMETER;
  83 }
  84
  85 UINT WINAPI MsiDatabaseOpenViewA(MSIHANDLE hdb,
  86               LPCSTR szQuery, MSIHANDLE *phView)
  87 {
  88     UINT r;
  89     LPWSTR szwQuery;
  90
  91     TRACE("%ld %s %p\n", hdb, debugstr_a(szQuery), phView);
  92
  93     if( szQuery )
  94     {
  95         szwQuery = strdupAtoW( szQuery );
  96         if( !szwQuery )
  97             return ERROR_FUNCTION_FAILED;
  98     }
  99     else
 100         szwQuery = NULL;
 101
 102     r = MsiDatabaseOpenViewW( hdb, szwQuery, phView);
 103
 104     HeapFree( GetProcessHeap(), 0, szwQuery );
 105     return r;
 106 }
 107
 108 UINT MSI_DatabaseOpenViewW(MSIDATABASE *db,
 109               LPCWSTR szQuery, MSIQUERY **pView)
 110 {
 111     MSIQUERY *query;
 112     UINT r;
 113
 114     TRACE("%s %p\n", debugstr_w(szQuery), pView);
 115
 116     if( !szQuery)
 117         return ERROR_INVALID_PARAMETER;
 118
 119     /* pre allocate a handle to hold a pointer to the view */
 120     query = alloc_msiobject( MSIHANDLETYPE_VIEW, sizeof (MSIQUERY),
 121                               MSI_CloseView );
 122     if( !query )
 123         return ERROR_FUNCTION_FAILED;
 124
 125     msiobj_addref( &db->hdr );
 126     query->row = 0;
 127     query->db = db;
 128     query->view = NULL;
 129     list_init( &query->mem );
 130
 131     r = MSI_ParseSQL( db, szQuery, &query->view, &query->mem );
 132     if( r == ERROR_SUCCESS )
 133     {
 134         msiobj_addref( &query->hdr );
 135         *pView = query;
 136     }
 137
 138     msiobj_release( &query->hdr );
 139     return r;
 140 }
 141
 142 UINT MSI_OpenQuery( MSIDATABASE *db, MSIQUERY **view, LPCWSTR fmt, ... )
 143 {
 144     LPWSTR szQuery;
 145     LPCWSTR p;
 146     UINT sz, rc;
 147     va_list va;
 148
 149     /* figure out how much space we need to allocate */
 150     va_start(va, fmt);
 151     sz = lstrlenW(fmt) + 1;
 152     p = fmt;
 153     while (*p)
 154     {
 155         p = strchrW(p, '%');
 156         if (!p)
 157             break;
 158         p++;
 159         switch (*p)
 160         {
 161         case 's':  /* a string */
 162             sz += lstrlenW(va_arg(va,LPCWSTR));
 163             break;
 164         case 'd':
 165         case 'i':  /* an integer -2147483648 seems to be longest */
 166             sz += 3*sizeof(int);
 167             (void)va_arg(va,int);
 168             break;
 169         case '%':  /* a single % - leave it alone */
 170             break;
 171         default:
 172             FIXME("Unhandled character type %c\n",*p);
 173         }
 174         p++;
 175     }
 176     va_end(va);
 177
 178     /* construct the string */
 179     szQuery = HeapAlloc(GetProcessHeap(), 0, sz*sizeof(WCHAR));
 180     va_start(va, fmt);
 181     vsnprintfW(szQuery, sz, fmt, va);
 182     va_end(va);
 183
 184     /* perform the query */
 185     rc = MSI_DatabaseOpenViewW(db, szQuery, view);
 186     HeapFree(GetProcessHeap(), 0, szQuery);
 187     return rc;
 188 }
 189
 190 UINT MSI_IterateRecords( MSIQUERY *view, DWORD *count,
 191                          record_func func, LPVOID param )
 192 {
 193     MSIRECORD *rec = NULL;
 194     UINT r, n = 0, max = 0;
 195
 196     r = MSI_ViewExecute( view, NULL );
 197     if( r != ERROR_SUCCESS )
 198         return r;
 199
 200     if( count )
 201         max = *count;
 202
 203     /* iterate a query */
 204     for( n = 0; (max == 0) || (n < max); n++ )
 205     {
 206         r = MSI_ViewFetch( view, &rec );
 207         if( r != ERROR_SUCCESS )
 208             break;
 209         r = func( rec, param );
 210         msiobj_release( &rec->hdr );
 211         if( r != ERROR_SUCCESS )
 212             break;
 213     }
 214
 215     MSI_ViewClose( view );
 216
 217     if( count )
 218         *count = n;
 219
 220     if( r == ERROR_NO_MORE_ITEMS )
 221         r = ERROR_SUCCESS;
 222
 223     return r;
 224 }
 225
 226 UINT WINAPI MsiDatabaseOpenViewW(MSIHANDLE hdb,
 227               LPCWSTR szQuery, MSIHANDLE *phView)
 228 {
 229     MSIDATABASE *db;
 230     MSIQUERY *query = NULL;
 231     UINT ret;
 232
 233     TRACE("%s %p\n", debugstr_w(szQuery), phView);
 234
 235     db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE );
 236     if( !db )
 237         return ERROR_INVALID_HANDLE;
 238
 239     ret = MSI_DatabaseOpenViewW( db, szQuery, &query );
 240     if( ret == ERROR_SUCCESS )
 241     {
 242         *phView = alloc_msihandle( &query->hdr );
 243         msiobj_release( &query->hdr );
 244     }
 245     msiobj_release( &db->hdr );
 246
 247     return ret;
 248 }
 249
 250 UINT MSI_ViewFetch(MSIQUERY *query, MSIRECORD **prec)
 251 {
 252     MSIVIEW *view;
 253     MSIRECORD *rec;
 254     UINT row_count = 0, col_count = 0, i, ival, ret, type;
 255
 256     TRACE("%p %p\n", query, prec );
 257
 258     view = query->view;
 259     if( !view )
 260         return ERROR_FUNCTION_FAILED;
 261
 262     ret = view->ops->get_dimensions( view, &row_count, &col_count );
 263     if( ret )
 264         return ret;
 265     if( !col_count )
 266         return ERROR_INVALID_PARAMETER;
 267
 268     if( query->row >= row_count )
 269         return ERROR_NO_MORE_ITEMS;
 270
 271     rec = MSI_CreateRecord( col_count );
 272     if( !rec )
 273         return ERROR_FUNCTION_FAILED;
 274
 275     for( i=1; i<=col_count; i++ )
 276     {
 277         ret = view->ops->get_column_info( view, i, NULL, &type );
 278         if( ret )
 279         {
 280             ERR("Error getting column type for %d\n", i );
 281             continue;
 282         }
 283         if (( type != MSITYPE_BINARY) && (type != (MSITYPE_BINARY |
 284                                                    MSITYPE_NULLABLE)))
 285         {
 286             ret = view->ops->fetch_int( view, query->row, i, &ival );
 287             if( ret )
 288             {
 289                 ERR("Error fetching data for %d\n", i );
 290                 continue;
 291             }
 292             if( ! (type & MSITYPE_VALID ) )
 293                 ERR("Invalid type!\n");
 294
 295             /* check if it's nul (0) - if so, don't set anything */
 296             if( !ival )
 297                 continue;
 298
 299             if( type & MSITYPE_STRING )
 300             {
 301                 LPWSTR sval;
 302
 303                 sval = MSI_makestring( query->db, ival );
 304                 MSI_RecordSetStringW( rec, i, sval );
 305                 HeapFree( GetProcessHeap(), 0, sval );
 306             }
 307             else
 308             {
 309                 if( (type & MSI_DATASIZEMASK) == 2 )
 310                     MSI_RecordSetInteger( rec, i, ival - (1<<15) );
 311                 else
 312                     MSI_RecordSetInteger( rec, i, ival - (1<<31) );
 313             }
 314         }
 315         else
 316         {
 317             IStream *stm = NULL;
 318
 319             ret = view->ops->fetch_stream( view, query->row, i, &stm );
 320             if( ( ret == ERROR_SUCCESS ) && stm )
 321             {
 322                 MSI_RecordSetIStream( rec, i, stm );
 323                 IStream_Release( stm );
 324             }
 325             else
 326                 ERR("failed to get stream\n");
 327         }
 328     }
 329     query->row ++;
 330
 331     *prec = rec;
 332
 333     return ERROR_SUCCESS;
 334 }
 335
 336 UINT WINAPI MsiViewFetch(MSIHANDLE hView, MSIHANDLE *record)
 337 {
 338     MSIQUERY *query;
 339     MSIRECORD *rec = NULL;
 340     UINT ret;
 341
 342     TRACE("%ld %p\n", hView, record);
 343
 344     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 345     if( !query )
 346         return ERROR_INVALID_HANDLE;
 347     ret = MSI_ViewFetch( query, &rec );
 348     if( ret == ERROR_SUCCESS )
 349     {
 350         *record = alloc_msihandle( &rec->hdr );
 351         msiobj_release( &rec->hdr );
 352     }
 353     msiobj_release( &query->hdr );
 354     return ret;
 355 }
 356
 357 UINT MSI_ViewClose(MSIQUERY *query)
 358 {
 359     MSIVIEW *view;
 360
 361     TRACE("%p\n", query );
 362
 363     view = query->view;
 364     if( !view )
 365         return ERROR_FUNCTION_FAILED;
 366     if( !view->ops->close )
 367         return ERROR_FUNCTION_FAILED;
 368
 369     return view->ops->close( view );
 370 }
 371
 372 UINT WINAPI MsiViewClose(MSIHANDLE hView)
 373 {
 374     MSIQUERY *query;
 375     UINT ret;
 376
 377     TRACE("%ld\n", hView );
 378
 379     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 380     if( !query )
 381         return ERROR_INVALID_HANDLE;
 382
 383     ret = MSI_ViewClose( query );
 384     msiobj_release( &query->hdr );
 385     return ret;
 386 }
 387
 388 UINT MSI_ViewExecute(MSIQUERY *query, MSIRECORD *rec )
 389 {
 390     MSIVIEW *view;
 391
 392     TRACE("%p %p\n", query, rec);
 393
 394     view = query->view;
 395     if( !view )
 396         return ERROR_FUNCTION_FAILED;
 397     if( !view->ops->execute )
 398         return ERROR_FUNCTION_FAILED;
 399     query->row = 0;
 400
 401     return view->ops->execute( view, rec );
 402 }
 403
 404 UINT WINAPI MsiViewExecute(MSIHANDLE hView, MSIHANDLE hRec)
 405 {
 406     MSIQUERY *query;
 407     MSIRECORD *rec = NULL;
 408     UINT ret;
 409
 410     TRACE("%ld %ld\n", hView, hRec);
 411
 412     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 413     if( !query )
 414         return ERROR_INVALID_HANDLE;
 415
 416     if( hRec )
 417     {
 418         rec = msihandle2msiinfo( hRec, MSIHANDLETYPE_RECORD );
 419         if( !rec )
 420         {
 421             ret = ERROR_INVALID_HANDLE;
 422             goto out;
 423         }
 424     }
 425
 426     msiobj_lock( &rec->hdr );
 427     ret = MSI_ViewExecute( query, rec );
 428     msiobj_unlock( &rec->hdr );
 429
 430 out:
 431     msiobj_release( &query->hdr );
 432     if( rec )
 433         msiobj_release( &rec->hdr );
 434
 435     return ret;
 436 }
 437
 438 UINT WINAPI MsiViewGetColumnInfo(MSIHANDLE hView, MSICOLINFO info, MSIHANDLE *hRec)
 439 {
 440     MSIVIEW *view = NULL;
 441     MSIQUERY *query = NULL;
 442     MSIRECORD *rec = NULL;
 443     UINT r = ERROR_FUNCTION_FAILED, i, count = 0, type;
 444     LPWSTR name;
 445
 446     TRACE("%ld %d %p\n", hView, info, hRec);
 447
 448     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 449     if( !query )
 450         return ERROR_INVALID_HANDLE;
 451
 452     view = query->view;
 453     if( !view )
 454         goto out;
 455
 456     if( !view->ops->get_dimensions )
 457         goto out;
 458
 459     r = view->ops->get_dimensions( view, NULL, &count );
 460     if( r )
 461         goto out;
 462     if( !count )
 463     {
 464         r = ERROR_INVALID_PARAMETER;
 465         goto out;
 466     }
 467
 468     rec = MSI_CreateRecord( count );
 469     if( !rec )
 470     {
 471         r = ERROR_FUNCTION_FAILED;
 472         goto out;
 473     }
 474
 475     for( i=0; i<count; i++ )
 476     {
 477         name = NULL;
 478         r = view->ops->get_column_info( view, i+1, &name, &type );
 479         if( r != ERROR_SUCCESS )
 480             continue;
 481         MSI_RecordSetStringW( rec, i+1, name );
 482         HeapFree( GetProcessHeap(), 0, name );
 483     }
 484
 485     *hRec = alloc_msihandle( &rec->hdr );
 486
 487 out:
 488     msiobj_release( &query->hdr );
 489     if( rec )
 490         msiobj_release( &rec->hdr );
 491
 492     return r;
 493 }
 494
 495 UINT WINAPI MsiViewModify( MSIHANDLE hView, MSIMODIFY eModifyMode,
 496                 MSIHANDLE hRecord)
 497 {
 498     MSIVIEW *view = NULL;
 499     MSIQUERY *query = NULL;
 500     MSIRECORD *rec = NULL;
 501     UINT r = ERROR_FUNCTION_FAILED;
 502
 503     TRACE("%ld %x %ld\n", hView, eModifyMode, hRecord);
 504
 505     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 506     if( !query )
 507         return ERROR_INVALID_HANDLE;
 508
 509     view = query->view;
 510     if( !view )
 511         goto out;
 512
 513     if( !view->ops->modify )
 514         goto out;
 515
 516     rec = msihandle2msiinfo( hRecord, MSIHANDLETYPE_RECORD );
 517     if( !rec )
 518     {
 519         r = ERROR_INVALID_HANDLE;
 520         goto out;
 521     }
 522
 523     r = view->ops->modify( view, eModifyMode, rec );
 524
 525 out:
 526     msiobj_release( &query->hdr );
 527     if( rec )
 528         msiobj_release( &rec->hdr );
 529
 530     return r;
 531 }
 532
 533 UINT WINAPI MsiDatabaseApplyTransformA( MSIHANDLE hdb,
 534                  LPCSTR szTransformFile, int iErrorCond)
 535 {
 536     FIXME("%ld %s %d\n", hdb, debugstr_a(szTransformFile), iErrorCond);
 537     return ERROR_CALL_NOT_IMPLEMENTED;
 538 }
 539
 540 UINT WINAPI MsiDatabaseApplyTransformW( MSIHANDLE hdb,
 541                  LPCWSTR szTransformFile, int iErrorCond)
 542 {
 543     FIXME("%ld %s %d\n", hdb, debugstr_w(szTransformFile), iErrorCond);
 544     return ERROR_CALL_NOT_IMPLEMENTED;
 545 }
 546
 547 UINT WINAPI MsiDatabaseGenerateTransformA( MSIHANDLE hdb, MSIHANDLE hdbref,
 548                  LPCSTR szTransformFile, int iReserved1, int iReserved2 )
 549 {
 550     FIXME("%ld %ld %s %d %d\n", hdb, hdbref,
 551            debugstr_a(szTransformFile), iReserved1, iReserved2);
 552     return ERROR_CALL_NOT_IMPLEMENTED;
 553 }
 554
 555 UINT WINAPI MsiDatabaseGenerateTransformW( MSIHANDLE hdb, MSIHANDLE hdbref,
 556                  LPCWSTR szTransformFile, int iReserved1, int iReserved2 )
 557 {
 558     FIXME("%ld %ld %s %d %d\n", hdb, hdbref,
 559            debugstr_w(szTransformFile), iReserved1, iReserved2);
 560     return ERROR_CALL_NOT_IMPLEMENTED;
 561 }
 562
 563 UINT WINAPI MsiDatabaseCommit( MSIHANDLE hdb )
 564 {
 565     MSIDATABASE *db;
 566     UINT r;
 567
 568     TRACE("%ld\n", hdb);
 569
 570     db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE );
 571     if( !db )
 572         return ERROR_INVALID_HANDLE;
 573
 574     /* FIXME: lock the database */
 575
 576     r = MSI_CommitTables( db );
 577
 578     /* FIXME: unlock the database */
 579
 580     msiobj_release( &db->hdr );
 581
 582     return r;
 583 }
 584
 585 struct msi_primary_key_record_info
 586 {
 587     DWORD n;
 588     MSIRECORD *rec;
 589 };
 590
 591 static UINT msi_primary_key_iterator( MSIRECORD *rec, LPVOID param )
 592 {
 593     struct msi_primary_key_record_info *info = param;
 594     LPCWSTR name;
 595     DWORD type;
 596
 597     type = MSI_RecordGetInteger( rec, 4 );
 598     if( type & MSITYPE_KEY )
 599     {
 600         info->n++;
 601         if( info->rec )
 602         {
 603             name = MSI_RecordGetString( rec, 3 );
 604             MSI_RecordSetStringW( info->rec, info->n, name );
 605         }
 606     }
 607
 608     return ERROR_SUCCESS;
 609 }
 610
 611 UINT MSI_DatabaseGetPrimaryKeys( MSIDATABASE *db,
 612                 LPCWSTR table, MSIRECORD **prec )
 613 {
 614     static const WCHAR sql[] = {
 615         's','e','l','e','c','t',' ','*',' ',
 616         'f','r','o','m',' ','`','_','C','o','l','u','m','n','s','`',' ',
 617         'w','h','e','r','e',' ',
 618         '`','T','a','b','l','e','`',' ','=',' ','\'','%','s','\'',0 };
 619     struct msi_primary_key_record_info info;
 620     MSIQUERY *query = NULL;
 621     MSIVIEW *view;
 622     UINT r;
 623
 624     r = MSI_OpenQuery( db, &query, sql, table );
 625     if( r != ERROR_SUCCESS )
 626         return r;
 627
 628     view = query->view;
 629
 630     /* count the number of primary key records */
 631     info.n = 0;
 632     info.rec = 0;
 633     r = MSI_IterateRecords( query, 0, msi_primary_key_iterator, &info );
 634     if( r == ERROR_SUCCESS )
 635     {
 636         TRACE("Found %ld primary keys\n", info.n );
 637
 638         /* allocate a record and fill in the names of the tables */
 639         info.rec = MSI_CreateRecord( info.n );
 640         info.n = 0;
 641         r = MSI_IterateRecords( query, 0, msi_primary_key_iterator, &info );
 642         if( r == ERROR_SUCCESS )
 643             *prec = info.rec;
 644         else
 645             msiobj_release( &info.rec->hdr );
 646     }
 647     msiobj_release( &query->hdr );
 648
 649     return r;
 650 }
 651
 652 UINT WINAPI MsiDatabaseGetPrimaryKeysW( MSIHANDLE hdb,
 653                     LPCWSTR table, MSIHANDLE* phRec )
 654 {
 655     MSIRECORD *rec = NULL;
 656     MSIDATABASE *db;
 657     UINT r;
 658
 659     TRACE("%ld %s %p\n", hdb, debugstr_w(table), phRec);
 660
 661     db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE );
 662     if( !db )
 663         return ERROR_INVALID_HANDLE;
 664
 665     r = MSI_DatabaseGetPrimaryKeys( db, table, &rec );
 666     if( r == ERROR_SUCCESS )
 667     {
 668         *phRec = alloc_msihandle( &rec->hdr );
 669         msiobj_release( &rec->hdr );
 670     }
 671     msiobj_release( &db->hdr );
 672
 673     return r;
 674 }
 675
 676 UINT WINAPI MsiDatabaseGetPrimaryKeysA(MSIHANDLE hdb,
 677                     LPCSTR table, MSIHANDLE* phRec)
 678 {
 679     LPWSTR szwTable = NULL;
 680     UINT r;
 681
 682     TRACE("%ld %s %p\n", hdb, debugstr_a(table), phRec);
 683
 684     if( table )
 685     {
 686         szwTable = strdupAtoW( table );
 687         if( !szwTable )
 688             return ERROR_OUTOFMEMORY;
 689     }
 690     r = MsiDatabaseGetPrimaryKeysW( hdb, szwTable, phRec );
 691     HeapFree( GetProcessHeap(), 0, szwTable );
 692
 693     return r;
 694 }
 695
 696 UINT WINAPI MsiDatabaseIsTablePersistentA(
 697               MSIHANDLE hDatabase, LPSTR szTableName)
 698 {
 699     FIXME("%lx %s\n", hDatabase, debugstr_a(szTableName));
 700     return ERROR_CALL_NOT_IMPLEMENTED;
 701 }
 702
 703 UINT WINAPI MsiDatabaseIsTablePersistentW(
 704               MSIHANDLE hDatabase, LPWSTR szTableName)
 705 {
 706     FIXME("%lx %s\n", hDatabase, debugstr_w(szTableName));
 707     return ERROR_CALL_NOT_IMPLEMENTED;
 708 }