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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 #include "msiserver.h"
  39
  40 #include "initguid.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  43
  44 static void MSI_CloseView( MSIOBJECTHDR *arg )
  45 {
  46     MSIQUERY *query = (MSIQUERY*) arg;
  47     struct list *ptr, *t;
  48
  49     if( query->view && query->view->ops->delete )
  50         query->view->ops->delete( query->view );
  51     msiobj_release( &query->db->hdr );
  52
  53     LIST_FOR_EACH_SAFE( ptr, t, &query->mem )
  54     {
  55         msi_free( ptr );
  56     }
  57 }
  58
  59 UINT VIEW_find_column( MSIVIEW *table, LPCWSTR name, LPCWSTR table_name, UINT *n )
  60 {
  61     LPCWSTR col_name, haystack_table_name;
  62     UINT i, count, r;
  63
  64     r = table->ops->get_dimensions( table, NULL, &count );
  65     if( r != ERROR_SUCCESS )
  66         return r;
  67
  68     for( i=1; i<=count; i++ )
  69     {
  70         INT x;
  71
  72         r = table->ops->get_column_info( table, i, &col_name, NULL,
  73                                          NULL, &haystack_table_name );
  74         if( r != ERROR_SUCCESS )
  75             return r;
  76         x = strcmpW( name, col_name );
  77         if( table_name )
  78             x |= strcmpW( table_name, haystack_table_name );
  79         if( !x )
  80         {
  81             *n = i;
  82             return ERROR_SUCCESS;
  83         }
  84     }
  85     return ERROR_INVALID_PARAMETER;
  86 }
  87
  88 UINT WINAPI MsiDatabaseOpenViewA(MSIHANDLE hdb,
  89               LPCSTR szQuery, MSIHANDLE *phView)
  90 {
  91     UINT r;
  92     LPWSTR szwQuery;
  93
  94     TRACE("%d %s %p\n", hdb, debugstr_a(szQuery), phView);
  95
  96     if( szQuery )
  97     {
  98         szwQuery = strdupAtoW( szQuery );
  99         if( !szwQuery )
 100             return ERROR_FUNCTION_FAILED;
 101     }
 102     else
 103         szwQuery = NULL;
 104
 105     r = MsiDatabaseOpenViewW( hdb, szwQuery, phView);
 106
 107     msi_free( szwQuery );
 108     return r;
 109 }
 110
 111 UINT MSI_DatabaseOpenViewW(MSIDATABASE *db,
 112               LPCWSTR szQuery, MSIQUERY **pView)
 113 {
 114     MSIQUERY *query;
 115     UINT r;
 116
 117     TRACE("%s %p\n", debugstr_w(szQuery), pView);
 118
 119     if( !szQuery)
 120         return ERROR_INVALID_PARAMETER;
 121
 122     /* pre allocate a handle to hold a pointer to the view */
 123     query = alloc_msiobject( MSIHANDLETYPE_VIEW, sizeof (MSIQUERY),
 124                               MSI_CloseView );
 125     if( !query )
 126         return ERROR_FUNCTION_FAILED;
 127
 128     msiobj_addref( &db->hdr );
 129     query->db = db;
 130     list_init( &query->mem );
 131
 132     r = MSI_ParseSQL( db, szQuery, &query->view, &query->mem );
 133     if( r == ERROR_SUCCESS )
 134     {
 135         msiobj_addref( &query->hdr );
 136         *pView = query;
 137     }
 138
 139     msiobj_release( &query->hdr );
 140     return r;
 141 }
 142
 143 UINT MSI_OpenQuery( MSIDATABASE *db, MSIQUERY **view, LPCWSTR fmt, ... )
 144 {
 145     UINT r;
 146     int size = 100, res;
 147     LPWSTR query;
 148
 149     /* construct the string */
 150     for (;;)
 151     {
 152         va_list va;
 153         query = msi_alloc( size*sizeof(WCHAR) );
 154         va_start(va, fmt);
 155         res = vsnprintfW(query, size, fmt, va);
 156         va_end(va);
 157         if (res == -1) size *= 2;
 158         else if (res >= size) size = res + 1;
 159         else break;
 160         msi_free( query );
 161     }
 162     /* perform the query */
 163     r = MSI_DatabaseOpenViewW(db, query, view);
 164     msi_free(query);
 165     return r;
 166 }
 167
 168 UINT MSI_IterateRecords( MSIQUERY *view, LPDWORD count,
 169                          record_func func, LPVOID param )
 170 {
 171     MSIRECORD *rec = NULL;
 172     UINT r, n = 0, max = 0;
 173
 174     r = MSI_ViewExecute( view, NULL );
 175     if( r != ERROR_SUCCESS )
 176         return r;
 177
 178     if( count )
 179         max = *count;
 180
 181     /* iterate a query */
 182     for( n = 0; (max == 0) || (n < max); n++ )
 183     {
 184         r = MSI_ViewFetch( view, &rec );
 185         if( r != ERROR_SUCCESS )
 186             break;
 187         if (func)
 188             r = func( rec, param );
 189         msiobj_release( &rec->hdr );
 190         if( r != ERROR_SUCCESS )
 191             break;
 192     }
 193
 194     MSI_ViewClose( view );
 195
 196     if( count )
 197         *count = n;
 198
 199     if( r == ERROR_NO_MORE_ITEMS )
 200         r = ERROR_SUCCESS;
 201
 202     return r;
 203 }
 204
 205 /* return a single record from a query */
 206 MSIRECORD *MSI_QueryGetRecord( MSIDATABASE *db, LPCWSTR fmt, ... )
 207 {
 208     MSIRECORD *rec = NULL;
 209     MSIQUERY *view = NULL;
 210     UINT r;
 211     int size = 100, res;
 212     LPWSTR query;
 213
 214     /* construct the string */
 215     for (;;)
 216     {
 217         va_list va;
 218         query = msi_alloc( size*sizeof(WCHAR) );
 219         va_start(va, fmt);
 220         res = vsnprintfW(query, size, fmt, va);
 221         va_end(va);
 222         if (res == -1) size *= 2;
 223         else if (res >= size) size = res + 1;
 224         else break;
 225         msi_free( query );
 226     }
 227     /* perform the query */
 228     r = MSI_DatabaseOpenViewW(db, query, &view);
 229     msi_free(query);
 230
 231     if( r == ERROR_SUCCESS )
 232     {
 233         MSI_ViewExecute( view, NULL );
 234         MSI_ViewFetch( view, &rec );
 235         MSI_ViewClose( view );
 236         msiobj_release( &view->hdr );
 237     }
 238     return rec;
 239 }
 240
 241 UINT WINAPI MsiDatabaseOpenViewW(MSIHANDLE hdb,
 242               LPCWSTR szQuery, MSIHANDLE *phView)
 243 {
 244     MSIDATABASE *db;
 245     MSIQUERY *query = NULL;
 246     UINT ret;
 247
 248     TRACE("%s %p\n", debugstr_w(szQuery), phView);
 249
 250     db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE );
 251     if( !db )
 252     {
 253         HRESULT hr;
 254         IWineMsiRemoteDatabase *remote_database;
 255
 256         remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hdb );
 257         if ( !remote_database )
 258             return ERROR_INVALID_HANDLE;
 259
 260         hr = IWineMsiRemoteDatabase_OpenView( remote_database, szQuery, phView );
 261         IWineMsiRemoteDatabase_Release( remote_database );
 262
 263         if (FAILED(hr))
 264         {
 265             if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
 266                 return HRESULT_CODE(hr);
 267
 268             return ERROR_FUNCTION_FAILED;
 269         }
 270
 271         return ERROR_SUCCESS;
 272     }
 273
 274     ret = MSI_DatabaseOpenViewW( db, szQuery, &query );
 275     if( ret == ERROR_SUCCESS )
 276     {
 277         *phView = alloc_msihandle( &query->hdr );
 278         if (! *phView)
 279            ret = ERROR_NOT_ENOUGH_MEMORY;
 280         msiobj_release( &query->hdr );
 281     }
 282     msiobj_release( &db->hdr );
 283
 284     return ret;
 285 }
 286
 287 UINT msi_view_get_row(MSIDATABASE *db, MSIVIEW *view, UINT row, MSIRECORD **rec)
 288 {
 289     UINT row_count = 0, col_count = 0, i, ival, ret, type;
 290
 291     TRACE("%p %p %d %p\n", db, view, row, rec);
 292
 293     ret = view->ops->get_dimensions(view, &row_count, &col_count);
 294     if (ret)
 295         return ret;
 296
 297     if (!col_count)
 298         return ERROR_INVALID_PARAMETER;
 299
 300     if (row >= row_count)
 301         return ERROR_NO_MORE_ITEMS;
 302
 303     *rec = MSI_CreateRecord(col_count);
 304     if (!*rec)
 305         return ERROR_FUNCTION_FAILED;
 306
 307     for (i = 1; i <= col_count; i++)
 308     {
 309         ret = view->ops->get_column_info(view, i, NULL, &type, NULL, NULL);
 310         if (ret)
 311         {
 312             ERR("Error getting column type for %d\n", i);
 313             continue;
 314         }
 315
 316         if (MSITYPE_IS_BINARY(type))
 317         {
 318             IStream *stm = NULL;
 319
 320             ret = view->ops->fetch_stream(view, row, i, &stm);
 321             if ((ret == ERROR_SUCCESS) && stm)
 322             {
 323                 MSI_RecordSetIStream(*rec, i, stm);
 324                 IStream_Release(stm);
 325             }
 326             else
 327                 WARN("failed to get stream\n");
 328
 329             continue;
 330         }
 331
 332         ret = view->ops->fetch_int(view, row, i, &ival);
 333         if (ret)
 334         {
 335             ERR("Error fetching data for %d\n", i);
 336             continue;
 337         }
 338
 339         if (! (type & MSITYPE_VALID))
 340             ERR("Invalid type!\n");
 341
 342         /* check if it's nul (0) - if so, don't set anything */
 343         if (!ival)
 344             continue;
 345
 346         if (type & MSITYPE_STRING)
 347         {
 348             LPCWSTR sval;
 349
 350             sval = msi_string_lookup_id(db->strings, ival);
 351             MSI_RecordSetStringW(*rec, i, sval);
 352         }
 353         else
 354         {
 355             if ((type & MSI_DATASIZEMASK) == 2)
 356                 MSI_RecordSetInteger(*rec, i, ival - (1<<15));
 357             else
 358                 MSI_RecordSetInteger(*rec, i, ival - (1<<31));
 359         }
 360     }
 361
 362     return ERROR_SUCCESS;
 363 }
 364
 365 UINT MSI_ViewFetch(MSIQUERY *query, MSIRECORD **prec)
 366 {
 367     MSIVIEW *view;
 368     UINT r;
 369
 370     TRACE("%p %p\n", query, prec );
 371
 372     view = query->view;
 373     if( !view )
 374         return ERROR_FUNCTION_FAILED;
 375
 376     r = msi_view_get_row(query->db, view, query->row, prec);
 377     if (r == ERROR_SUCCESS)
 378     {
 379         query->row ++;
 380         MSI_RecordSetIntPtr(*prec, 0, (INT_PTR)query);
 381     }
 382
 383     return r;
 384 }
 385
 386 UINT WINAPI MsiViewFetch(MSIHANDLE hView, MSIHANDLE *record)
 387 {
 388     MSIQUERY *query;
 389     MSIRECORD *rec = NULL;
 390     UINT ret;
 391
 392     TRACE("%d %p\n", hView, record);
 393
 394     if( !record )
 395         return ERROR_INVALID_PARAMETER;
 396     *record = 0;
 397
 398     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 399     if( !query )
 400         return ERROR_INVALID_HANDLE;
 401     ret = MSI_ViewFetch( query, &rec );
 402     if( ret == ERROR_SUCCESS )
 403     {
 404         *record = alloc_msihandle( &rec->hdr );
 405         if (! *record)
 406            ret = ERROR_NOT_ENOUGH_MEMORY;
 407         msiobj_release( &rec->hdr );
 408     }
 409     msiobj_release( &query->hdr );
 410     return ret;
 411 }
 412
 413 UINT MSI_ViewClose(MSIQUERY *query)
 414 {
 415     MSIVIEW *view;
 416
 417     TRACE("%p\n", query );
 418
 419     view = query->view;
 420     if( !view )
 421         return ERROR_FUNCTION_FAILED;
 422     if( !view->ops->close )
 423         return ERROR_FUNCTION_FAILED;
 424
 425     return view->ops->close( view );
 426 }
 427
 428 UINT WINAPI MsiViewClose(MSIHANDLE hView)
 429 {
 430     MSIQUERY *query;
 431     UINT ret;
 432
 433     TRACE("%d\n", hView );
 434
 435     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 436     if( !query )
 437         return ERROR_INVALID_HANDLE;
 438
 439     ret = MSI_ViewClose( query );
 440     msiobj_release( &query->hdr );
 441     return ret;
 442 }
 443
 444 UINT MSI_ViewExecute(MSIQUERY *query, MSIRECORD *rec )
 445 {
 446     MSIVIEW *view;
 447
 448     TRACE("%p %p\n", query, rec);
 449
 450     view = query->view;
 451     if( !view )
 452         return ERROR_FUNCTION_FAILED;
 453     if( !view->ops->execute )
 454         return ERROR_FUNCTION_FAILED;
 455     query->row = 0;
 456
 457     return view->ops->execute( view, rec );
 458 }
 459
 460 UINT WINAPI MsiViewExecute(MSIHANDLE hView, MSIHANDLE hRec)
 461 {
 462     MSIQUERY *query;
 463     MSIRECORD *rec = NULL;
 464     UINT ret;
 465
 466     TRACE("%d %d\n", hView, hRec);
 467
 468     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 469     if( !query )
 470         return ERROR_INVALID_HANDLE;
 471
 472     if( hRec )
 473     {
 474         rec = msihandle2msiinfo( hRec, MSIHANDLETYPE_RECORD );
 475         if( !rec )
 476         {
 477             ret = ERROR_INVALID_HANDLE;
 478             goto out;
 479         }
 480     }
 481
 482     msiobj_lock( &rec->hdr );
 483     ret = MSI_ViewExecute( query, rec );
 484     msiobj_unlock( &rec->hdr );
 485
 486 out:
 487     msiobj_release( &query->hdr );
 488     if( rec )
 489         msiobj_release( &rec->hdr );
 490
 491     return ret;
 492 }
 493
 494 static UINT msi_set_record_type_string( MSIRECORD *rec, UINT field,
 495                                         UINT type, BOOL temporary )
 496 {
 497     static const WCHAR fmt[] = { '%','d',0 };
 498     WCHAR szType[0x10];
 499
 500     if (MSITYPE_IS_BINARY(type))
 501         szType[0] = 'v';
 502     else if (type & MSITYPE_LOCALIZABLE)
 503         szType[0] = 'l';
 504     else if (type & MSITYPE_UNKNOWN)
 505         szType[0] = 'f';
 506     else if (type & MSITYPE_STRING)
 507     {
 508         if (temporary)
 509             szType[0] = 'g';
 510         else
 511           szType[0] = 's';
 512     }
 513     else
 514     {
 515         if (temporary)
 516             szType[0] = 'j';
 517         else
 518             szType[0] = 'i';
 519     }
 520
 521     if (type & MSITYPE_NULLABLE)
 522         szType[0] &= ~0x20;
 523
 524     sprintfW( &szType[1], fmt, (type&0xff) );
 525
 526     TRACE("type %04x -> %s\n", type, debugstr_w(szType) );
 527
 528     return MSI_RecordSetStringW( rec, field, szType );
 529 }
 530
 531 UINT MSI_ViewGetColumnInfo( MSIQUERY *query, MSICOLINFO info, MSIRECORD **prec )
 532 {
 533     UINT r = ERROR_FUNCTION_FAILED, i, count = 0, type;
 534     MSIRECORD *rec;
 535     MSIVIEW *view = query->view;
 536     LPCWSTR name;
 537     BOOL temporary;
 538
 539     if( !view )
 540         return ERROR_FUNCTION_FAILED;
 541
 542     if( !view->ops->get_dimensions )
 543         return ERROR_FUNCTION_FAILED;
 544
 545     r = view->ops->get_dimensions( view, NULL, &count );
 546     if( r != ERROR_SUCCESS )
 547         return r;
 548     if( !count )
 549         return ERROR_INVALID_PARAMETER;
 550
 551     rec = MSI_CreateRecord( count );
 552     if( !rec )
 553         return ERROR_FUNCTION_FAILED;
 554
 555     for( i=0; i<count; i++ )
 556     {
 557         name = NULL;
 558         r = view->ops->get_column_info( view, i+1, &name, &type, &temporary, NULL );
 559         if( r != ERROR_SUCCESS )
 560             continue;
 561         if (info == MSICOLINFO_NAMES)
 562             MSI_RecordSetStringW( rec, i+1, name );
 563         else
 564             msi_set_record_type_string( rec, i+1, type, temporary );
 565     }
 566     *prec = rec;
 567     return ERROR_SUCCESS;
 568 }
 569
 570 UINT WINAPI MsiViewGetColumnInfo(MSIHANDLE hView, MSICOLINFO info, MSIHANDLE *hRec)
 571 {
 572     MSIQUERY *query = NULL;
 573     MSIRECORD *rec = NULL;
 574     UINT r;
 575
 576     TRACE("%d %d %p\n", hView, info, hRec);
 577
 578     if( !hRec )
 579         return ERROR_INVALID_PARAMETER;
 580
 581     if( info != MSICOLINFO_NAMES && info != MSICOLINFO_TYPES )
 582         return ERROR_INVALID_PARAMETER;
 583
 584     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 585     if( !query )
 586         return ERROR_INVALID_HANDLE;
 587
 588     r = MSI_ViewGetColumnInfo( query, info, &rec );
 589     if ( r == ERROR_SUCCESS )
 590     {
 591         *hRec = alloc_msihandle( &rec->hdr );
 592         if ( !*hRec )
 593             r = ERROR_NOT_ENOUGH_MEMORY;
 594         msiobj_release( &rec->hdr );
 595     }
 596
 597     msiobj_release( &query->hdr );
 598
 599     return r;
 600 }
 601
 602 UINT MSI_ViewModify( MSIQUERY *query, MSIMODIFY mode, MSIRECORD *rec )
 603 {
 604     MSIVIEW *view = NULL;
 605     UINT r;
 606
 607     if ( !query || !rec )
 608         return ERROR_INVALID_HANDLE;
 609
 610     view = query->view;
 611     if ( !view  || !view->ops->modify)
 612         return ERROR_FUNCTION_FAILED;
 613
 614     if ( mode == MSIMODIFY_UPDATE && MSI_RecordGetIntPtr( rec, 0 ) != (INT_PTR)query )
 615         return ERROR_FUNCTION_FAILED;
 616
 617     r = view->ops->modify( view, mode, rec, query->row );
 618     if (mode == MSIMODIFY_DELETE && r == ERROR_SUCCESS)
 619         query->row--;
 620
 621     return r;
 622 }
 623
 624 UINT WINAPI MsiViewModify( MSIHANDLE hView, MSIMODIFY eModifyMode,
 625                 MSIHANDLE hRecord)
 626 {
 627     MSIQUERY *query = NULL;
 628     MSIRECORD *rec = NULL;
 629     UINT r = ERROR_FUNCTION_FAILED;
 630
 631     TRACE("%d %x %d\n", hView, eModifyMode, hRecord);
 632
 633     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 634     if( !query )
 635         return ERROR_INVALID_HANDLE;
 636
 637     rec = msihandle2msiinfo( hRecord, MSIHANDLETYPE_RECORD );
 638     r = MSI_ViewModify( query, eModifyMode, rec );
 639
 640     msiobj_release( &query->hdr );
 641     if( rec )
 642         msiobj_release( &rec->hdr );
 643
 644     return r;
 645 }
 646
 647 MSIDBERROR WINAPI MsiViewGetErrorW( MSIHANDLE handle, LPWSTR buffer, LPDWORD buflen )
 648 {
 649     MSIQUERY *query;
 650     const WCHAR *column;
 651     MSIDBERROR r;
 652     DWORD len;
 653
 654     TRACE("%u %p %p\n", handle, buffer, buflen);
 655
 656     if (!buflen)
 657         return MSIDBERROR_INVALIDARG;
 658
 659     query = msihandle2msiinfo( handle, MSIHANDLETYPE_VIEW );
 660     if( !query )
 661         return MSIDBERROR_INVALIDARG;
 662
 663     if ((r = query->view->error)) column = query->view->error_column;
 664     else column = szEmpty;
 665
 666     len = strlenW( column );
 667     if (buffer)
 668     {
 669         if (*buflen > len)
 670             strcpyW( buffer, column );
 671         else
 672             r = MSIDBERROR_MOREDATA;
 673     }
 674     *buflen = len;
 675     msiobj_release( &query->hdr );
 676     return r;
 677 }
 678
 679 MSIDBERROR WINAPI MsiViewGetErrorA( MSIHANDLE handle, LPSTR buffer, LPDWORD buflen )
 680 {
 681     MSIQUERY *query;
 682     const WCHAR *column;
 683     MSIDBERROR r;
 684     DWORD len;
 685
 686     TRACE("%u %p %p\n", handle, buffer, buflen);
 687
 688     if (!buflen)
 689         return MSIDBERROR_INVALIDARG;
 690
 691     query = msihandle2msiinfo( handle, MSIHANDLETYPE_VIEW );
 692     if (!query)
 693         return MSIDBERROR_INVALIDARG;
 694
 695     if ((r = query->view->error)) column = query->view->error_column;
 696     else column = szEmpty;
 697
 698     len = WideCharToMultiByte( CP_ACP, 0, column, -1, NULL, 0, NULL, NULL );
 699     if (buffer)
 700     {
 701         if (*buflen >= len)
 702             WideCharToMultiByte( CP_ACP, 0, column, -1, buffer, *buflen, NULL, NULL );
 703         else
 704             r = MSIDBERROR_MOREDATA;
 705     }
 706     *buflen = len - 1;
 707     msiobj_release( &query->hdr );
 708     return r;
 709 }
 710
 711 MSIHANDLE WINAPI MsiGetLastErrorRecord( void )
 712 {
 713     FIXME("\n");
 714     return 0;
 715 }
 716
 717 UINT MSI_DatabaseApplyTransformW( MSIDATABASE *db,
 718                  LPCWSTR szTransformFile, int iErrorCond )
 719 {
 720     HRESULT r;
 721     UINT ret = ERROR_FUNCTION_FAILED;
 722     IStorage *stg = NULL;
 723     STATSTG stat;
 724
 725     TRACE("%p %s %d\n", db, debugstr_w(szTransformFile), iErrorCond);
 726
 727     r = StgOpenStorage( szTransformFile, NULL,
 728            STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
 729     if ( FAILED(r) )
 730     {
 731         WARN("failed to open transform 0x%08x\n", r);
 732         return ret;
 733     }
 734
 735     r = IStorage_Stat( stg, &stat, STATFLAG_NONAME );
 736     if ( FAILED( r ) )
 737         goto end;
 738
 739     if ( !IsEqualGUID( &stat.clsid, &CLSID_MsiTransform ) )
 740         goto end;
 741
 742     if( TRACE_ON( msi ) )
 743         enum_stream_names( stg );
 744
 745     ret = msi_table_apply_transform( db, stg );
 746
 747 end:
 748     IStorage_Release( stg );
 749
 750     return ret;
 751 }
 752
 753 UINT WINAPI MsiDatabaseApplyTransformW( MSIHANDLE hdb,
 754                  LPCWSTR szTransformFile, int iErrorCond)
 755 {
 756     MSIDATABASE *db;
 757     UINT r;
 758
 759     db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE );
 760     if( !db )
 761     {
 762         IWineMsiRemoteDatabase *remote_database;
 763
 764         remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hdb );
 765         if ( !remote_database )
 766             return ERROR_INVALID_HANDLE;
 767
 768         IWineMsiRemoteDatabase_Release( remote_database );
 769         WARN("MsiDatabaseApplyTransform not allowed during a custom action!\n");
 770
 771         return ERROR_SUCCESS;
 772     }
 773
 774     r = MSI_DatabaseApplyTransformW( db, szTransformFile, iErrorCond );
 775     msiobj_release( &db->hdr );
 776     return r;
 777 }
 778
 779 UINT WINAPI MsiDatabaseApplyTransformA( MSIHANDLE hdb,
 780                  LPCSTR szTransformFile, int iErrorCond)
 781 {
 782     LPWSTR wstr;
 783     UINT ret;
 784
 785     TRACE("%d %s %d\n", hdb, debugstr_a(szTransformFile), iErrorCond);
 786
 787     wstr = strdupAtoW( szTransformFile );
 788     if( szTransformFile && !wstr )
 789         return ERROR_NOT_ENOUGH_MEMORY;
 790
 791     ret = MsiDatabaseApplyTransformW( hdb, wstr, iErrorCond);
 792
 793     msi_free( wstr );
 794
 795     return ret;
 796 }
 797
 798 UINT WINAPI MsiDatabaseGenerateTransformA( MSIHANDLE hdb, MSIHANDLE hdbref,
 799                  LPCSTR szTransformFile, int iReserved1, int iReserved2 )
 800 {
 801     FIXME("%d %d %s %d %d\n", hdb, hdbref,
 802            debugstr_a(szTransformFile), iReserved1, iReserved2);
 803     return ERROR_CALL_NOT_IMPLEMENTED;
 804 }
 805
 806 UINT WINAPI MsiDatabaseGenerateTransformW( MSIHANDLE hdb, MSIHANDLE hdbref,
 807                  LPCWSTR szTransformFile, int iReserved1, int iReserved2 )
 808 {
 809     FIXME("%d %d %s %d %d\n", hdb, hdbref,
 810            debugstr_w(szTransformFile), iReserved1, iReserved2);
 811     return ERROR_CALL_NOT_IMPLEMENTED;
 812 }
 813
 814 UINT WINAPI MsiDatabaseCommit( MSIHANDLE hdb )
 815 {
 816     MSIDATABASE *db;
 817     UINT r;
 818
 819     TRACE("%d\n", hdb);
 820
 821     db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE );
 822     if( !db )
 823     {
 824         IWineMsiRemoteDatabase *remote_database;
 825
 826         remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hdb );
 827         if ( !remote_database )
 828             return ERROR_INVALID_HANDLE;
 829
 830         IWineMsiRemoteDatabase_Release( remote_database );
 831         WARN("not allowed during a custom action!\n");
 832
 833         return ERROR_SUCCESS;
 834     }
 835
 836     if (db->mode == MSIDBOPEN_READONLY)
 837     {
 838         msiobj_release( &db->hdr );
 839         return ERROR_SUCCESS;
 840     }
 841
 842     /* FIXME: lock the database */
 843
 844     r = MSI_CommitTables( db );
 845     if (r != ERROR_SUCCESS) ERR("Failed to commit tables!\n");
 846
 847     /* FIXME: unlock the database */
 848
 849     msiobj_release( &db->hdr );
 850
 851     if (r == ERROR_SUCCESS)
 852     {
 853         msi_free( db->deletefile );
 854         db->deletefile = NULL;
 855     }
 856
 857     return r;
 858 }
 859
 860 struct msi_primary_key_record_info
 861 {
 862     DWORD n;
 863     MSIRECORD *rec;
 864 };
 865
 866 static UINT msi_primary_key_iterator( MSIRECORD *rec, LPVOID param )
 867 {
 868     struct msi_primary_key_record_info *info = param;
 869     LPCWSTR name, table;
 870     DWORD type;
 871
 872     type = MSI_RecordGetInteger( rec, 4 );
 873     if( type & MSITYPE_KEY )
 874     {
 875         info->n++;
 876         if( info->rec )
 877         {
 878             if ( info->n == 1 )
 879             {
 880                 table = MSI_RecordGetString( rec, 1 );
 881                 MSI_RecordSetStringW( info->rec, 0, table);
 882             }
 883
 884             name = MSI_RecordGetString( rec, 3 );
 885             MSI_RecordSetStringW( info->rec, info->n, name );
 886         }
 887     }
 888
 889     return ERROR_SUCCESS;
 890 }
 891
 892 UINT MSI_DatabaseGetPrimaryKeys( MSIDATABASE *db,
 893                 LPCWSTR table, MSIRECORD **prec )
 894 {
 895     static const WCHAR sql[] = {
 896         's','e','l','e','c','t',' ','*',' ',
 897         'f','r','o','m',' ','`','_','C','o','l','u','m','n','s','`',' ',
 898         'w','h','e','r','e',' ',
 899         '`','T','a','b','l','e','`',' ','=',' ','\'','%','s','\'',0 };
 900     struct msi_primary_key_record_info info;
 901     MSIQUERY *query = NULL;
 902     UINT r;
 903
 904     if (!TABLE_Exists( db, table ))
 905         return ERROR_INVALID_TABLE;
 906
 907     r = MSI_OpenQuery( db, &query, sql, table );
 908     if( r != ERROR_SUCCESS )
 909         return r;
 910
 911     /* count the number of primary key records */
 912     info.n = 0;
 913     info.rec = 0;
 914     r = MSI_IterateRecords( query, 0, msi_primary_key_iterator, &info );
 915     if( r == ERROR_SUCCESS )
 916     {
 917         TRACE("Found %d primary keys\n", info.n );
 918
 919         /* allocate a record and fill in the names of the tables */
 920         info.rec = MSI_CreateRecord( info.n );
 921         info.n = 0;
 922         r = MSI_IterateRecords( query, 0, msi_primary_key_iterator, &info );
 923         if( r == ERROR_SUCCESS )
 924             *prec = info.rec;
 925         else
 926             msiobj_release( &info.rec->hdr );
 927     }
 928     msiobj_release( &query->hdr );
 929
 930     return r;
 931 }
 932
 933 UINT WINAPI MsiDatabaseGetPrimaryKeysW( MSIHANDLE hdb,
 934                     LPCWSTR table, MSIHANDLE* phRec )
 935 {
 936     MSIRECORD *rec = NULL;
 937     MSIDATABASE *db;
 938     UINT r;
 939
 940     TRACE("%d %s %p\n", hdb, debugstr_w(table), phRec);
 941
 942     db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE );
 943     if( !db )
 944     {
 945         HRESULT hr;
 946         IWineMsiRemoteDatabase *remote_database;
 947
 948         remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hdb );
 949         if ( !remote_database )
 950             return ERROR_INVALID_HANDLE;
 951
 952         hr = IWineMsiRemoteDatabase_GetPrimaryKeys( remote_database, table, phRec );
 953         IWineMsiRemoteDatabase_Release( remote_database );
 954
 955         if (FAILED(hr))
 956         {
 957             if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
 958                 return HRESULT_CODE(hr);
 959
 960             return ERROR_FUNCTION_FAILED;
 961         }
 962
 963         return ERROR_SUCCESS;
 964     }
 965
 966     r = MSI_DatabaseGetPrimaryKeys( db, table, &rec );
 967     if( r == ERROR_SUCCESS )
 968     {
 969         *phRec = alloc_msihandle( &rec->hdr );
 970         if (! *phRec)
 971            r = ERROR_NOT_ENOUGH_MEMORY;
 972         msiobj_release( &rec->hdr );
 973     }
 974     msiobj_release( &db->hdr );
 975
 976     return r;
 977 }
 978
 979 UINT WINAPI MsiDatabaseGetPrimaryKeysA(MSIHANDLE hdb,
 980                     LPCSTR table, MSIHANDLE* phRec)
 981 {
 982     LPWSTR szwTable = NULL;
 983     UINT r;
 984
 985     TRACE("%d %s %p\n", hdb, debugstr_a(table), phRec);
 986
 987     if( table )
 988     {
 989         szwTable = strdupAtoW( table );
 990         if( !szwTable )
 991             return ERROR_OUTOFMEMORY;
 992     }
 993     r = MsiDatabaseGetPrimaryKeysW( hdb, szwTable, phRec );
 994     msi_free( szwTable );
 995
 996     return r;
 997 }
 998
 999 MSICONDITION WINAPI MsiDatabaseIsTablePersistentA(
1000               MSIHANDLE hDatabase, LPCSTR szTableName)
1001 {
1002     LPWSTR szwTableName = NULL;
1003     MSICONDITION r;
1004
1005     TRACE("%x %s\n", hDatabase, debugstr_a(szTableName));
1006
1007     if( szTableName )
1008     {
1009         szwTableName = strdupAtoW( szTableName );
1010         if( !szwTableName )
1011             return MSICONDITION_ERROR;
1012     }
1013     r = MsiDatabaseIsTablePersistentW( hDatabase, szwTableName );
1014     msi_free( szwTableName );
1015
1016     return r;
1017 }
1018
1019 MSICONDITION WINAPI MsiDatabaseIsTablePersistentW(
1020               MSIHANDLE hDatabase, LPCWSTR szTableName)
1021 {
1022     MSIDATABASE *db;
1023     MSICONDITION r;
1024
1025     TRACE("%x %s\n", hDatabase, debugstr_w(szTableName));
1026
1027     db = msihandle2msiinfo( hDatabase, MSIHANDLETYPE_DATABASE );
1028     if( !db )
1029     {
1030         HRESULT hr;
1031         MSICONDITION condition;
1032         IWineMsiRemoteDatabase *remote_database;
1033
1034         remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hDatabase );
1035         if ( !remote_database )
1036             return MSICONDITION_ERROR;
1037
1038         hr = IWineMsiRemoteDatabase_IsTablePersistent( remote_database,
1039                                                        szTableName, &condition );
1040         IWineMsiRemoteDatabase_Release( remote_database );
1041
1042         if (FAILED(hr))
1043             return MSICONDITION_ERROR;
1044
1045         return condition;
1046     }
1047
1048     r = MSI_DatabaseIsTablePersistent( db, szTableName );
1049
1050     msiobj_release( &db->hdr );
1051
1052     return r;
1053 }