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/exception.h"
  30 #include "msi.h"
  31 #include "msiquery.h"
  32 #include "objbase.h"
  33 #include "objidl.h"
  34 #include "winnls.h"
  35
  36 #include "msipriv.h"
  37 #include "query.h"
  38 #include "winemsi.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 = wcscmp( name, col_name );
  77         if( table_name )
  78             x |= wcscmp( 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     /* 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->db = db;
 127     list_init( &query->mem );
 128
 129     r = MSI_ParseSQL( db, szQuery, &query->view, &query->mem );
 130     if( r == ERROR_SUCCESS )
 131     {
 132         msiobj_addref( &query->hdr );
 133         *pView = query;
 134     }
 135
 136     msiobj_release( &query->hdr );
 137     return r;
 138 }
 139
 140 UINT WINAPIV MSI_OpenQuery( MSIDATABASE *db, MSIQUERY **view, LPCWSTR fmt, ... )
 141 {
 142     UINT r;
 143     int size = 100, res;
 144     LPWSTR query;
 145
 146     /* construct the string */
 147     for (;;)
 148     {
 149         va_list va;
 150         query = msi_alloc( size*sizeof(WCHAR) );
 151         va_start(va, fmt);
 152         res = vswprintf(query, size, fmt, va);
 153         va_end(va);
 154         if (res == -1) size *= 2;
 155         else if (res >= size) size = res + 1;
 156         else break;
 157         msi_free( query );
 158     }
 159     /* perform the query */
 160     r = MSI_DatabaseOpenViewW(db, query, view);
 161     msi_free(query);
 162     return r;
 163 }
 164
 165 UINT MSI_IterateRecords( MSIQUERY *view, LPDWORD count,
 166                          record_func func, LPVOID param )
 167 {
 168     MSIRECORD *rec = NULL;
 169     UINT r, n = 0, max = 0;
 170
 171     r = MSI_ViewExecute( view, NULL );
 172     if( r != ERROR_SUCCESS )
 173         return r;
 174
 175     if( count )
 176         max = *count;
 177
 178     /* iterate a query */
 179     for( n = 0; (max == 0) || (n < max); n++ )
 180     {
 181         r = MSI_ViewFetch( view, &rec );
 182         if( r != ERROR_SUCCESS )
 183             break;
 184         if (func)
 185             r = func( rec, param );
 186         msiobj_release( &rec->hdr );
 187         if( r != ERROR_SUCCESS )
 188             break;
 189     }
 190
 191     MSI_ViewClose( view );
 192
 193     if( count )
 194         *count = n;
 195
 196     if( r == ERROR_NO_MORE_ITEMS )
 197         r = ERROR_SUCCESS;
 198
 199     return r;
 200 }
 201
 202 /* return a single record from a query */
 203 MSIRECORD * WINAPIV MSI_QueryGetRecord( MSIDATABASE *db, LPCWSTR fmt, ... )
 204 {
 205     MSIRECORD *rec = NULL;
 206     MSIQUERY *view = NULL;
 207     UINT r;
 208     int size = 100, res;
 209     LPWSTR query;
 210
 211     /* construct the string */
 212     for (;;)
 213     {
 214         va_list va;
 215         query = msi_alloc( size*sizeof(WCHAR) );
 216         va_start(va, fmt);
 217         res = vswprintf(query, size, fmt, va);
 218         va_end(va);
 219         if (res == -1) size *= 2;
 220         else if (res >= size) size = res + 1;
 221         else break;
 222         msi_free( query );
 223     }
 224     /* perform the query */
 225     r = MSI_DatabaseOpenViewW(db, query, &view);
 226     msi_free(query);
 227
 228     if( r == ERROR_SUCCESS )
 229     {
 230         MSI_ViewExecute( view, NULL );
 231         MSI_ViewFetch( view, &rec );
 232         MSI_ViewClose( view );
 233         msiobj_release( &view->hdr );
 234     }
 235     return rec;
 236 }
 237
 238 UINT WINAPI MsiDatabaseOpenViewW(MSIHANDLE hdb,
 239               LPCWSTR szQuery, MSIHANDLE *phView)
 240 {
 241     MSIDATABASE *db;
 242     MSIQUERY *query = NULL;
 243     UINT ret;
 244
 245     TRACE("%s %p\n", debugstr_w(szQuery), phView);
 246
 247     if (!phView)
 248         return ERROR_INVALID_PARAMETER;
 249
 250     if (!szQuery)
 251         return ERROR_BAD_QUERY_SYNTAX;
 252
 253     db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE );
 254     if( !db )
 255     {
 256         MSIHANDLE remote, remote_view;
 257
 258         if (!(remote = msi_get_remote(hdb)))
 259             return ERROR_INVALID_HANDLE;
 260
 261         __TRY
 262         {
 263             ret = remote_DatabaseOpenView(remote, szQuery, &remote_view);
 264         }
 265         __EXCEPT(rpc_filter)
 266         {
 267             ret = GetExceptionCode();
 268         }
 269         __ENDTRY
 270
 271         if (!ret)
 272             *phView = alloc_msi_remote_handle(remote_view);
 273         return ret;
 274     }
 275
 276     ret = MSI_DatabaseOpenViewW( db, szQuery, &query );
 277     if( ret == ERROR_SUCCESS )
 278     {
 279         *phView = alloc_msihandle( &query->hdr );
 280         if (! *phView)
 281            ret = ERROR_NOT_ENOUGH_MEMORY;
 282         msiobj_release( &query->hdr );
 283     }
 284     msiobj_release( &db->hdr );
 285
 286     return ret;
 287 }
 288
 289 UINT msi_view_refresh_row(MSIDATABASE *db, MSIVIEW *view, UINT row, MSIRECORD *rec)
 290 {
 291     UINT row_count = 0, col_count = 0, i, ival, ret, type;
 292
 293     TRACE("%p %p %d %p\n", db, view, row, rec);
 294
 295     ret = view->ops->get_dimensions(view, &row_count, &col_count);
 296     if (ret)
 297         return ret;
 298
 299     if (!col_count)
 300         return ERROR_INVALID_PARAMETER;
 301
 302     for (i = 1; i <= col_count; i++)
 303     {
 304         ret = view->ops->get_column_info(view, i, NULL, &type, NULL, NULL);
 305         if (ret)
 306         {
 307             ERR("Error getting column type for %d\n", i);
 308             continue;
 309         }
 310
 311         if (MSITYPE_IS_BINARY(type))
 312         {
 313             IStream *stm = NULL;
 314
 315             ret = view->ops->fetch_stream(view, row, i, &stm);
 316             if ((ret == ERROR_SUCCESS) && stm)
 317             {
 318                 MSI_RecordSetIStream(rec, i, stm);
 319                 IStream_Release(stm);
 320             }
 321             else
 322                 WARN("failed to get stream\n");
 323
 324             continue;
 325         }
 326
 327         ret = view->ops->fetch_int(view, row, i, &ival);
 328         if (ret)
 329         {
 330             ERR("Error fetching data for %d\n", i);
 331             continue;
 332         }
 333
 334         if (! (type & MSITYPE_VALID))
 335             ERR("Invalid type!\n");
 336
 337         if (type & MSITYPE_STRING)
 338         {
 339             int len;
 340             const WCHAR *sval = msi_string_lookup(db->strings, ival, &len);
 341             msi_record_set_string(rec, i, sval, len);
 342         }
 343         else
 344         {
 345             if ((type & MSI_DATASIZEMASK) == 2)
 346                 MSI_RecordSetInteger(rec, i, ival ? ival - (1<<15) : MSI_NULL_INTEGER);
 347             else
 348                 MSI_RecordSetInteger(rec, i, ival - (1u<<31));
 349         }
 350     }
 351
 352     return ERROR_SUCCESS;
 353 }
 354
 355 UINT msi_view_get_row(MSIDATABASE *db, MSIVIEW *view, UINT row, MSIRECORD **rec)
 356 {
 357     UINT row_count = 0, col_count = 0, r;
 358     MSIRECORD *object;
 359
 360     TRACE("view %p, row %u, rec %p.\n", view, row, rec);
 361
 362     if ((r = view->ops->get_dimensions(view, &row_count, &col_count)))
 363         return r;
 364
 365     if (row >= row_count)
 366         return ERROR_NO_MORE_ITEMS;
 367
 368     if (!(object = MSI_CreateRecord( col_count )))
 369         return ERROR_OUTOFMEMORY;
 370
 371     if ((r = msi_view_refresh_row(db, view, row, object)))
 372         msiobj_release( &object->hdr );
 373     else
 374         *rec = object;
 375
 376     return r;
 377 }
 378
 379 UINT MSI_ViewFetch(MSIQUERY *query, MSIRECORD **prec)
 380 {
 381     MSIVIEW *view;
 382     UINT r;
 383
 384     TRACE("%p %p\n", query, prec );
 385
 386     view = query->view;
 387     if( !view )
 388         return ERROR_FUNCTION_FAILED;
 389
 390     r = msi_view_get_row(query->db, view, query->row, prec);
 391     if (r == ERROR_SUCCESS)
 392     {
 393         query->row ++;
 394         (*prec)->cookie = (UINT64)(ULONG_PTR)query;
 395         MSI_RecordSetInteger(*prec, 0, 1);
 396     }
 397     else if (r == ERROR_NO_MORE_ITEMS)
 398     {
 399         /* end of view; reset cursor to first row */
 400         query->row = 0;
 401     }
 402
 403     return r;
 404 }
 405
 406 UINT WINAPI MsiViewFetch(MSIHANDLE hView, MSIHANDLE *record)
 407 {
 408     MSIQUERY *query;
 409     MSIRECORD *rec = NULL;
 410     UINT ret;
 411
 412     TRACE("%d %p\n", hView, record);
 413
 414     if( !record )
 415         return ERROR_INVALID_PARAMETER;
 416     *record = 0;
 417
 418     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 419     if (!query)
 420     {
 421         struct wire_record *wire_rec = NULL;
 422         MSIHANDLE remote;
 423
 424         if (!(remote = msi_get_remote(hView)))
 425             return ERROR_INVALID_HANDLE;
 426
 427         __TRY
 428         {
 429             ret = remote_ViewFetch(remote, &wire_rec);
 430         }
 431         __EXCEPT(rpc_filter)
 432         {
 433             ret = GetExceptionCode();
 434         }
 435         __ENDTRY
 436
 437         if (!ret)
 438         {
 439             ret = unmarshal_record(wire_rec, record);
 440             free_remote_record(wire_rec);
 441         }
 442         return ret;
 443     }
 444     ret = MSI_ViewFetch( query, &rec );
 445     if( ret == ERROR_SUCCESS )
 446     {
 447         *record = alloc_msihandle( &rec->hdr );
 448         if (! *record)
 449            ret = ERROR_NOT_ENOUGH_MEMORY;
 450         msiobj_release( &rec->hdr );
 451     }
 452     msiobj_release( &query->hdr );
 453     return ret;
 454 }
 455
 456 UINT MSI_ViewClose(MSIQUERY *query)
 457 {
 458     MSIVIEW *view;
 459
 460     TRACE("%p\n", query );
 461
 462     view = query->view;
 463     if( !view )
 464         return ERROR_FUNCTION_FAILED;
 465     if( !view->ops->close )
 466         return ERROR_FUNCTION_FAILED;
 467
 468     return view->ops->close( view );
 469 }
 470
 471 UINT WINAPI MsiViewClose(MSIHANDLE hView)
 472 {
 473     MSIQUERY *query;
 474     UINT ret;
 475
 476     TRACE("%d\n", hView );
 477
 478     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 479     if (!query)
 480     {
 481         MSIHANDLE remote;
 482
 483         if (!(remote = msi_get_remote(hView)))
 484             return ERROR_INVALID_HANDLE;
 485
 486         __TRY
 487         {
 488             ret = remote_ViewClose(remote);
 489         }
 490         __EXCEPT(rpc_filter)
 491         {
 492             ret = GetExceptionCode();
 493         }
 494         __ENDTRY
 495
 496         return ret;
 497     }
 498
 499     ret = MSI_ViewClose( query );
 500     msiobj_release( &query->hdr );
 501     return ret;
 502 }
 503
 504 UINT MSI_ViewExecute(MSIQUERY *query, MSIRECORD *rec )
 505 {
 506     MSIVIEW *view;
 507
 508     TRACE("%p %p\n", query, rec);
 509
 510     view = query->view;
 511     if( !view )
 512         return ERROR_FUNCTION_FAILED;
 513     if( !view->ops->execute )
 514         return ERROR_FUNCTION_FAILED;
 515     query->row = 0;
 516
 517     return view->ops->execute( view, rec );
 518 }
 519
 520 UINT WINAPI MsiViewExecute(MSIHANDLE hView, MSIHANDLE hRec)
 521 {
 522     MSIQUERY *query;
 523     MSIRECORD *rec = NULL;
 524     UINT ret;
 525
 526     TRACE("%d %d\n", hView, hRec);
 527
 528     if( hRec )
 529     {
 530         rec = msihandle2msiinfo( hRec, MSIHANDLETYPE_RECORD );
 531         if( !rec )
 532             return ERROR_INVALID_HANDLE;
 533     }
 534
 535     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 536     if( !query )
 537     {
 538         MSIHANDLE remote;
 539
 540         if (!(remote = msi_get_remote(hView)))
 541             return ERROR_INVALID_HANDLE;
 542
 543         __TRY
 544         {
 545             ret = remote_ViewExecute(remote, rec ? (struct wire_record *)&rec->count : NULL);
 546         }
 547         __EXCEPT(rpc_filter)
 548         {
 549             ret = GetExceptionCode();
 550         }
 551         __ENDTRY
 552
 553         if (rec)
 554             msiobj_release(&rec->hdr);
 555         return ret;
 556     }
 557
 558     msiobj_lock( &rec->hdr );
 559     ret = MSI_ViewExecute( query, rec );
 560     msiobj_unlock( &rec->hdr );
 561
 562     msiobj_release( &query->hdr );
 563     if( rec )
 564         msiobj_release( &rec->hdr );
 565
 566     return ret;
 567 }
 568
 569 static UINT msi_set_record_type_string( MSIRECORD *rec, UINT field,
 570                                         UINT type, BOOL temporary )
 571 {
 572     WCHAR szType[0x10];
 573
 574     if (MSITYPE_IS_BINARY(type))
 575         szType[0] = 'v';
 576     else if (type & MSITYPE_LOCALIZABLE)
 577         szType[0] = 'l';
 578     else if (type & MSITYPE_UNKNOWN)
 579         szType[0] = 'f';
 580     else if (type & MSITYPE_STRING)
 581     {
 582         if (temporary)
 583             szType[0] = 'g';
 584         else
 585           szType[0] = 's';
 586     }
 587     else
 588     {
 589         if (temporary)
 590             szType[0] = 'j';
 591         else
 592             szType[0] = 'i';
 593     }
 594
 595     if (type & MSITYPE_NULLABLE)
 596         szType[0] &= ~0x20;
 597
 598     swprintf( &szType[1], ARRAY_SIZE(szType) - 1, L"%d", (type&0xff) );
 599
 600     TRACE("type %04x -> %s\n", type, debugstr_w(szType) );
 601
 602     return MSI_RecordSetStringW( rec, field, szType );
 603 }
 604
 605 UINT MSI_ViewGetColumnInfo( MSIQUERY *query, MSICOLINFO info, MSIRECORD **prec )
 606 {
 607     UINT r = ERROR_FUNCTION_FAILED, i, count = 0, type;
 608     MSIRECORD *rec;
 609     MSIVIEW *view = query->view;
 610     LPCWSTR name;
 611     BOOL temporary;
 612
 613     if( !view )
 614         return ERROR_FUNCTION_FAILED;
 615
 616     if( !view->ops->get_dimensions )
 617         return ERROR_FUNCTION_FAILED;
 618
 619     r = view->ops->get_dimensions( view, NULL, &count );
 620     if( r != ERROR_SUCCESS )
 621         return r;
 622     if( !count )
 623         return ERROR_INVALID_PARAMETER;
 624
 625     rec = MSI_CreateRecord( count );
 626     if( !rec )
 627         return ERROR_FUNCTION_FAILED;
 628
 629     for( i=0; i<count; i++ )
 630     {
 631         name = NULL;
 632         r = view->ops->get_column_info( view, i+1, &name, &type, &temporary, NULL );
 633         if( r != ERROR_SUCCESS )
 634             continue;
 635         if (info == MSICOLINFO_NAMES)
 636             MSI_RecordSetStringW( rec, i+1, name );
 637         else
 638             msi_set_record_type_string( rec, i+1, type, temporary );
 639     }
 640     *prec = rec;
 641     return ERROR_SUCCESS;
 642 }
 643
 644 UINT WINAPI MsiViewGetColumnInfo(MSIHANDLE hView, MSICOLINFO info, MSIHANDLE *hRec)
 645 {
 646     MSIQUERY *query = NULL;
 647     MSIRECORD *rec = NULL;
 648     UINT r;
 649
 650     TRACE("%d %d %p\n", hView, info, hRec);
 651
 652     if( !hRec )
 653         return ERROR_INVALID_PARAMETER;
 654
 655     if( info != MSICOLINFO_NAMES && info != MSICOLINFO_TYPES )
 656         return ERROR_INVALID_PARAMETER;
 657
 658     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 659     if (!query)
 660     {
 661         struct wire_record *wire_rec = NULL;
 662         MSIHANDLE remote;
 663
 664         if (!(remote = msi_get_remote(hView)))
 665             return ERROR_INVALID_HANDLE;
 666
 667         __TRY
 668         {
 669             r = remote_ViewGetColumnInfo(remote, info, &wire_rec);
 670         }
 671         __EXCEPT(rpc_filter)
 672         {
 673             r = GetExceptionCode();
 674         }
 675         __ENDTRY
 676
 677         if (!r)
 678         {
 679             r = unmarshal_record(wire_rec, hRec);
 680             free_remote_record(wire_rec);
 681         }
 682
 683         return r;
 684     }
 685
 686     r = MSI_ViewGetColumnInfo( query, info, &rec );
 687     if ( r == ERROR_SUCCESS )
 688     {
 689         *hRec = alloc_msihandle( &rec->hdr );
 690         if ( !*hRec )
 691             r = ERROR_NOT_ENOUGH_MEMORY;
 692         msiobj_release( &rec->hdr );
 693     }
 694
 695     msiobj_release( &query->hdr );
 696
 697     return r;
 698 }
 699
 700 UINT MSI_ViewModify( MSIQUERY *query, MSIMODIFY mode, MSIRECORD *rec )
 701 {
 702     MSIVIEW *view = NULL;
 703     UINT r;
 704
 705     if ( !query || !rec )
 706         return ERROR_INVALID_HANDLE;
 707
 708     view = query->view;
 709     if ( !view  || !view->ops->modify)
 710         return ERROR_FUNCTION_FAILED;
 711
 712     if ( mode == MSIMODIFY_UPDATE && rec->cookie != (UINT64)(ULONG_PTR)query )
 713         return ERROR_FUNCTION_FAILED;
 714
 715     r = view->ops->modify( view, mode, rec, query->row - 1 );
 716     if (mode == MSIMODIFY_DELETE && r == ERROR_SUCCESS)
 717         query->row--;
 718
 719     return r;
 720 }
 721
 722 UINT WINAPI MsiViewModify( MSIHANDLE hView, MSIMODIFY eModifyMode,
 723                 MSIHANDLE hRecord)
 724 {
 725     MSIQUERY *query = NULL;
 726     MSIRECORD *rec = NULL;
 727     UINT r = ERROR_FUNCTION_FAILED;
 728
 729     TRACE("%d %x %d\n", hView, eModifyMode, hRecord);
 730
 731     rec = msihandle2msiinfo( hRecord, MSIHANDLETYPE_RECORD );
 732
 733     if (!rec)
 734         return ERROR_INVALID_HANDLE;
 735
 736     query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW );
 737     if (!query)
 738     {
 739         struct wire_record *wire_refreshed = NULL;
 740         MSIHANDLE remote;
 741
 742         if (!(remote = msi_get_remote(hView)))
 743             return ERROR_INVALID_HANDLE;
 744
 745         __TRY
 746         {
 747             r = remote_ViewModify(remote, eModifyMode,
 748                 (struct wire_record *)&rec->count, &wire_refreshed);
 749         }
 750         __EXCEPT(rpc_filter)
 751         {
 752             r = GetExceptionCode();
 753         }
 754         __ENDTRY
 755
 756         if (!r && (eModifyMode == MSIMODIFY_REFRESH || eModifyMode == MSIMODIFY_SEEK))
 757         {
 758             r = copy_remote_record(wire_refreshed, hRecord);
 759             free_remote_record(wire_refreshed);
 760         }
 761
 762         msiobj_release(&rec->hdr);
 763         return r;
 764     }
 765
 766     r = MSI_ViewModify( query, eModifyMode, rec );
 767
 768     msiobj_release( &query->hdr );
 769     msiobj_release(&rec->hdr);
 770     return r;
 771 }
 772
 773 MSIDBERROR WINAPI MsiViewGetErrorW( MSIHANDLE handle, LPWSTR buffer, LPDWORD buflen )
 774 {
 775     MSIQUERY *query;
 776     const WCHAR *column;
 777     MSIDBERROR r;
 778
 779     TRACE("%u %p %p\n", handle, buffer, buflen);
 780
 781     if (!buflen)
 782         return MSIDBERROR_INVALIDARG;
 783
 784     if (!(query = msihandle2msiinfo(handle, MSIHANDLETYPE_VIEW)))
 785     {
 786         WCHAR *remote_column = NULL;
 787         MSIHANDLE remote;
 788
 789         if (!(remote = msi_get_remote(handle)))
 790             return MSIDBERROR_INVALIDARG;
 791
 792         if (!*buflen)
 793             return MSIDBERROR_FUNCTIONERROR;
 794
 795         __TRY
 796         {
 797             r = remote_ViewGetError(remote, &remote_column);
 798         }
 799         __EXCEPT(rpc_filter)
 800         {
 801             r = GetExceptionCode();
 802         }
 803         __ENDTRY;
 804
 805         if (msi_strncpyW(remote_column ? remote_column : L"", -1, buffer, buflen) == ERROR_MORE_DATA)
 806             r = MSIDBERROR_MOREDATA;
 807
 808         if (remote_column)
 809             midl_user_free(remote_column);
 810
 811         return r;
 812     }
 813
 814     if ((r = query->view->error)) column = query->view->error_column;
 815     else column = L"";
 816
 817     if (msi_strncpyW(column, -1, buffer, buflen) == ERROR_MORE_DATA)
 818         r = MSIDBERROR_MOREDATA;
 819
 820     msiobj_release( &query->hdr );
 821     return r;
 822 }
 823
 824 MSIDBERROR WINAPI MsiViewGetErrorA( MSIHANDLE handle, LPSTR buffer, LPDWORD buflen )
 825 {
 826     MSIQUERY *query;
 827     const WCHAR *column;
 828     MSIDBERROR r;
 829
 830     TRACE("%u %p %p\n", handle, buffer, buflen);
 831
 832     if (!buflen)
 833         return MSIDBERROR_INVALIDARG;
 834
 835     if (!(query = msihandle2msiinfo(handle, MSIHANDLETYPE_VIEW)))
 836     {
 837         WCHAR *remote_column = NULL;
 838         MSIHANDLE remote;
 839
 840         if (!(remote = msi_get_remote(handle)))
 841             return MSIDBERROR_INVALIDARG;
 842
 843         if (!*buflen)
 844             return MSIDBERROR_FUNCTIONERROR;
 845
 846         __TRY
 847         {
 848             r = remote_ViewGetError(remote, &remote_column);
 849         }
 850         __EXCEPT(rpc_filter)
 851         {
 852             r = GetExceptionCode();
 853         }
 854         __ENDTRY;
 855
 856         if (msi_strncpyWtoA(remote_column ? remote_column : L"", -1, buffer, buflen, FALSE) == ERROR_MORE_DATA)
 857             r = MSIDBERROR_MOREDATA;
 858
 859         if (remote_column)
 860             midl_user_free(remote_column);
 861
 862         return r;
 863     }
 864
 865     if ((r = query->view->error)) column = query->view->error_column;
 866     else column = L"";
 867
 868     if (msi_strncpyWtoA(column, -1, buffer, buflen, FALSE) == ERROR_MORE_DATA)
 869         r = MSIDBERROR_MOREDATA;
 870
 871     msiobj_release( &query->hdr );
 872     return r;
 873 }
 874
 875 MSIHANDLE WINAPI MsiGetLastErrorRecord( void )
 876 {
 877     FIXME("\n");
 878     return 0;
 879 }
 880
 881 UINT MSI_DatabaseApplyTransformW( MSIDATABASE *db, const WCHAR *transform, int error_cond )
 882 {
 883     HRESULT hr;
 884     UINT ret = ERROR_FUNCTION_FAILED;
 885     IStorage *stg;
 886     STATSTG stat;
 887
 888     TRACE( "%p %s %08x\n", db, debugstr_w(transform), error_cond );
 889
 890     if (*transform == ':')
 891     {
 892         hr = IStorage_OpenStorage( db->storage, transform + 1, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg );
 893         if (FAILED( hr ))
 894         {
 895             WARN( "failed to open substorage transform 0x%08x\n", hr );
 896             return ERROR_FUNCTION_FAILED;
 897         }
 898     }
 899     else
 900     {
 901         hr = StgOpenStorage( transform, NULL, STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE, NULL, 0, &stg );
 902         if (FAILED( hr ))
 903         {
 904             WARN( "failed to open file transform 0x%08x\n", hr );
 905             return ERROR_FUNCTION_FAILED;
 906         }
 907     }
 908
 909     hr = IStorage_Stat( stg, &stat, STATFLAG_NONAME );
 910     if (FAILED( hr )) goto end;
 911     if (!IsEqualGUID( &stat.clsid, &CLSID_MsiTransform )) goto end;
 912     if (TRACE_ON( msi )) enum_stream_names( stg );
 913
 914     ret = msi_table_apply_transform( db, stg, error_cond );
 915
 916 end:
 917     IStorage_Release( stg );
 918     return ret;
 919 }
 920
 921 UINT WINAPI MsiDatabaseApplyTransformW( MSIHANDLE hdb, const WCHAR *transform, int error_cond )
 922 {
 923     MSIDATABASE *db;
 924     UINT r;
 925
 926     if (error_cond & ~MSITRANSFORM_ERROR_VIEWTRANSFORM) FIXME( "ignoring error conditions\n" );
 927
 928     if (!(db = msihandle2msiinfo(hdb, MSIHANDLETYPE_DATABASE)))
 929         return ERROR_INVALID_HANDLE;
 930
 931     r = MSI_DatabaseApplyTransformW( db, transform, error_cond );
 932     msiobj_release( &db->hdr );
 933     return r;
 934 }
 935
 936 UINT WINAPI MsiDatabaseApplyTransformA( MSIHANDLE hdb, const char *transform, int error_cond )
 937 {
 938     WCHAR *wstr;
 939     UINT ret;
 940
 941     TRACE( "%d %s %08x\n", hdb, debugstr_a(transform), error_cond );
 942
 943     wstr = strdupAtoW( transform );
 944     if (transform && !wstr)
 945         return ERROR_NOT_ENOUGH_MEMORY;
 946
 947     ret = MsiDatabaseApplyTransformW( hdb, wstr, error_cond );
 948     msi_free( wstr );
 949     return ret;
 950 }
 951
 952 UINT WINAPI MsiDatabaseGenerateTransformA( MSIHANDLE hdb, MSIHANDLE hdbref,
 953                  LPCSTR szTransformFile, int iReserved1, int iReserved2 )
 954 {
 955     FIXME("%d %d %s %d %d\n", hdb, hdbref,
 956            debugstr_a(szTransformFile), iReserved1, iReserved2);
 957     return ERROR_CALL_NOT_IMPLEMENTED;
 958 }
 959
 960 UINT WINAPI MsiDatabaseGenerateTransformW( MSIHANDLE hdb, MSIHANDLE hdbref,
 961                  LPCWSTR szTransformFile, int iReserved1, int iReserved2 )
 962 {
 963     FIXME("%d %d %s %d %d\n", hdb, hdbref,
 964            debugstr_w(szTransformFile), iReserved1, iReserved2);
 965     return ERROR_CALL_NOT_IMPLEMENTED;
 966 }
 967
 968 UINT WINAPI MsiDatabaseCommit( MSIHANDLE hdb )
 969 {
 970     MSIDATABASE *db;
 971     UINT r;
 972
 973     TRACE("%d\n", hdb);
 974
 975     db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE );
 976     if( !db )
 977     {
 978         MSIHANDLE remote;
 979
 980         if (!(remote = msi_get_remote(hdb)))
 981             return ERROR_INVALID_HANDLE;
 982
 983         WARN("not allowed during a custom action!\n");
 984
 985         return ERROR_SUCCESS;
 986     }
 987
 988     if (db->mode == MSI_OPEN_READONLY)
 989     {
 990         msiobj_release( &db->hdr );
 991         return ERROR_SUCCESS;
 992     }
 993
 994     /* FIXME: lock the database */
 995
 996     r = msi_commit_streams( db );
 997     if (r != ERROR_SUCCESS) ERR("Failed to commit streams!\n");
 998     else
 999     {
1000         r = MSI_CommitTables( db );
1001         if (r != ERROR_SUCCESS) ERR("Failed to commit tables!\n");
1002     }
1003
1004     /* FIXME: unlock the database */
1005
1006     msiobj_release( &db->hdr );
1007
1008     if (r == ERROR_SUCCESS)
1009     {
1010         msi_free( db->deletefile );
1011         db->deletefile = NULL;
1012     }
1013
1014     return r;
1015 }
1016
1017 struct msi_primary_key_record_info
1018 {
1019     DWORD n;
1020     MSIRECORD *rec;
1021 };
1022
1023 static UINT msi_primary_key_iterator( MSIRECORD *rec, LPVOID param )
1024 {
1025     struct msi_primary_key_record_info *info = param;
1026     LPCWSTR name, table;
1027     DWORD type;
1028
1029     type = MSI_RecordGetInteger( rec, 4 );
1030     if( type & MSITYPE_KEY )
1031     {
1032         info->n++;
1033         if( info->rec )
1034         {
1035             if ( info->n == 1 )
1036             {
1037                 table = MSI_RecordGetString( rec, 1 );
1038                 MSI_RecordSetStringW( info->rec, 0, table);
1039             }
1040
1041             name = MSI_RecordGetString( rec, 3 );
1042             MSI_RecordSetStringW( info->rec, info->n, name );
1043         }
1044     }
1045
1046     return ERROR_SUCCESS;
1047 }
1048
1049 UINT MSI_DatabaseGetPrimaryKeys( MSIDATABASE *db,
1050                 LPCWSTR table, MSIRECORD **prec )
1051 {
1052     struct msi_primary_key_record_info info;
1053     MSIQUERY *query = NULL;
1054     UINT r;
1055
1056     if (!TABLE_Exists( db, table ))
1057         return ERROR_INVALID_TABLE;
1058
1059     r = MSI_OpenQuery( db, &query, L"SELECT * FROM `_Columns` WHERE `Table` = '%s'", table );
1060     if( r != ERROR_SUCCESS )
1061         return r;
1062
1063     /* count the number of primary key records */
1064     info.n = 0;
1065     info.rec = 0;
1066     r = MSI_IterateRecords( query, 0, msi_primary_key_iterator, &info );
1067     if( r == ERROR_SUCCESS )
1068     {
1069         TRACE("Found %d primary keys\n", info.n );
1070
1071         /* allocate a record and fill in the names of the tables */
1072         info.rec = MSI_CreateRecord( info.n );
1073         info.n = 0;
1074         r = MSI_IterateRecords( query, 0, msi_primary_key_iterator, &info );
1075         if( r == ERROR_SUCCESS )
1076             *prec = info.rec;
1077         else
1078             msiobj_release( &info.rec->hdr );
1079     }
1080     msiobj_release( &query->hdr );
1081
1082     return r;
1083 }
1084
1085 UINT WINAPI MsiDatabaseGetPrimaryKeysW( MSIHANDLE hdb,
1086                     LPCWSTR table, MSIHANDLE* phRec )
1087 {
1088     MSIRECORD *rec = NULL;
1089     MSIDATABASE *db;
1090     UINT r;
1091
1092     TRACE("%d %s %p\n", hdb, debugstr_w(table), phRec);
1093
1094     db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE );
1095     if( !db )
1096     {
1097         struct wire_record *wire_rec = NULL;
1098         MSIHANDLE remote;
1099
1100         if (!(remote = msi_get_remote(hdb)))
1101             return ERROR_INVALID_HANDLE;
1102
1103         __TRY
1104         {
1105             r = remote_DatabaseGetPrimaryKeys(remote, table, &wire_rec);
1106         }
1107         __EXCEPT(rpc_filter)
1108         {
1109             r = GetExceptionCode();
1110         }
1111         __ENDTRY
1112
1113         if (!r)
1114         {
1115             r = unmarshal_record(wire_rec, phRec);
1116             free_remote_record(wire_rec);
1117         }
1118
1119         return r;
1120     }
1121
1122     r = MSI_DatabaseGetPrimaryKeys( db, table, &rec );
1123     if( r == ERROR_SUCCESS )
1124     {
1125         *phRec = alloc_msihandle( &rec->hdr );
1126         if (! *phRec)
1127            r = ERROR_NOT_ENOUGH_MEMORY;
1128         msiobj_release( &rec->hdr );
1129     }
1130     msiobj_release( &db->hdr );
1131
1132     return r;
1133 }
1134
1135 UINT WINAPI MsiDatabaseGetPrimaryKeysA(MSIHANDLE hdb,
1136                     LPCSTR table, MSIHANDLE* phRec)
1137 {
1138     LPWSTR szwTable = NULL;
1139     UINT r;
1140
1141     TRACE("%d %s %p\n", hdb, debugstr_a(table), phRec);
1142
1143     if( table )
1144     {
1145         szwTable = strdupAtoW( table );
1146         if( !szwTable )
1147             return ERROR_OUTOFMEMORY;
1148     }
1149     r = MsiDatabaseGetPrimaryKeysW( hdb, szwTable, phRec );
1150     msi_free( szwTable );
1151
1152     return r;
1153 }
1154
1155 MSICONDITION WINAPI MsiDatabaseIsTablePersistentA(
1156               MSIHANDLE hDatabase, LPCSTR szTableName)
1157 {
1158     LPWSTR szwTableName = NULL;
1159     MSICONDITION r;
1160
1161     TRACE("%x %s\n", hDatabase, debugstr_a(szTableName));
1162
1163     if( szTableName )
1164     {
1165         szwTableName = strdupAtoW( szTableName );
1166         if( !szwTableName )
1167             return MSICONDITION_ERROR;
1168     }
1169     r = MsiDatabaseIsTablePersistentW( hDatabase, szwTableName );
1170     msi_free( szwTableName );
1171
1172     return r;
1173 }
1174
1175 MSICONDITION WINAPI MsiDatabaseIsTablePersistentW(
1176               MSIHANDLE hDatabase, LPCWSTR szTableName)
1177 {
1178     MSIDATABASE *db;
1179     MSICONDITION r;
1180
1181     TRACE("%x %s\n", hDatabase, debugstr_w(szTableName));
1182
1183     db = msihandle2msiinfo( hDatabase, MSIHANDLETYPE_DATABASE );
1184     if( !db )
1185     {
1186         MSIHANDLE remote;
1187
1188         if (!(remote = msi_get_remote(hDatabase)))
1189             return MSICONDITION_ERROR;
1190
1191         __TRY
1192         {
1193             r = remote_DatabaseIsTablePersistent(remote, szTableName);
1194         }
1195         __EXCEPT(rpc_filter)
1196         {
1197             r = MSICONDITION_ERROR;
1198         }
1199         __ENDTRY
1200
1201         return r;
1202     }
1203
1204     r = MSI_DatabaseIsTablePersistent( db, szTableName );
1205
1206     msiobj_release( &db->hdr );
1207
1208     return r;
1209 }
1210
1211 UINT __cdecl s_remote_ViewClose(MSIHANDLE view)
1212 {
1213     return MsiViewClose(view);
1214 }
1215
1216 UINT __cdecl s_remote_ViewExecute(MSIHANDLE view, struct wire_record *remote_rec)
1217 {
1218     MSIHANDLE rec = 0;
1219     UINT r;
1220
1221     if ((r = unmarshal_record(remote_rec, &rec)))
1222         return r;
1223
1224     r = MsiViewExecute(view, rec);
1225
1226     MsiCloseHandle(rec);
1227     return r;
1228 }
1229
1230 UINT __cdecl s_remote_ViewFetch(MSIHANDLE view, struct wire_record **rec)
1231 {
1232     MSIHANDLE handle;
1233     UINT r = MsiViewFetch(view, &handle);
1234     *rec = NULL;
1235     if (!r)
1236         *rec = marshal_record(handle);
1237     MsiCloseHandle(handle);
1238     return r;
1239 }
1240
1241 UINT __cdecl s_remote_ViewGetColumnInfo(MSIHANDLE view, MSICOLINFO info, struct wire_record **rec)
1242 {
1243     MSIHANDLE handle;
1244     UINT r = MsiViewGetColumnInfo(view, info, &handle);
1245     *rec = NULL;
1246     if (!r)
1247         *rec = marshal_record(handle);
1248     MsiCloseHandle(handle);
1249     return r;
1250 }
1251
1252 MSIDBERROR __cdecl s_remote_ViewGetError(MSIHANDLE view, LPWSTR *column)
1253 {
1254     WCHAR empty[1];
1255     DWORD size = 1;
1256     UINT r;
1257
1258     r = MsiViewGetErrorW(view, empty, &size);
1259     if (r == MSIDBERROR_MOREDATA)
1260     {
1261         if (!(*column = midl_user_allocate(++size * sizeof(WCHAR))))
1262             return MSIDBERROR_FUNCTIONERROR;
1263         r = MsiViewGetErrorW(view, *column, &size);
1264     }
1265     return r;
1266 }
1267
1268 UINT __cdecl s_remote_ViewModify(MSIHANDLE view, MSIMODIFY mode,
1269     struct wire_record *remote_rec, struct wire_record **remote_refreshed)
1270 {
1271     MSIHANDLE handle = 0;
1272     UINT r;
1273
1274     if ((r = unmarshal_record(remote_rec, &handle)))
1275         return r;
1276
1277     r = MsiViewModify(view, mode, handle);
1278     *remote_refreshed = NULL;
1279     if (!r && (mode == MSIMODIFY_REFRESH || mode == MSIMODIFY_SEEK))
1280         *remote_refreshed = marshal_record(handle);
1281
1282     MsiCloseHandle(handle);
1283     return r;
1284 }