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