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