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