msi: Unpublish the product after running all the actions.
[wine] / dlls / msi / where.c
1 /*
2  * Implementation of the Microsoft Installer (msi.dll)
3  *
4  * Copyright 2002 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 #include "windef.h"
24 #include "winbase.h"
25 #include "winerror.h"
26 #include "wine/debug.h"
27 #include "msi.h"
28 #include "msiquery.h"
29 #include "objbase.h"
30 #include "objidl.h"
31 #include "msipriv.h"
32 #include "winnls.h"
33
34 #include "query.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(msidb);
37
38 #define MSI_HASH_TABLE_SIZE 37
39
40 typedef struct tagMSIHASHENTRY
41 {
42     struct tagMSIHASHENTRY *next;
43     UINT value;
44     UINT row;
45 } MSIHASHENTRY;
46
47 /* below is the query interface to a table */
48
49 typedef struct tagMSIWHEREVIEW
50 {
51     MSIVIEW        view;
52     MSIDATABASE   *db;
53     MSIVIEW       *table;
54     UINT           row_count;
55     MSIHASHENTRY **reorder;
56     struct expr   *cond;
57     UINT           rec_index;
58 } MSIWHEREVIEW;
59
60 static void free_hash_table(MSIHASHENTRY **table)
61 {
62     MSIHASHENTRY *new, *old;
63     int i;
64
65     if (!table)
66         return;
67
68     for (i = 0; i < MSI_HASH_TABLE_SIZE; i++)
69     {
70         new = table[i];
71
72         while (new)
73         {
74             old = new;
75             new = old->next;
76             msi_free(old);
77         }
78
79         table[i] = NULL;
80     }
81
82     msi_free(table);
83 }
84
85 static UINT find_entry_in_hash(MSIHASHENTRY **table, UINT row, UINT *val)
86 {
87     MSIHASHENTRY *entry;
88
89     if (!table)
90         return ERROR_SUCCESS;
91
92     if (!(entry = table[row % MSI_HASH_TABLE_SIZE]))
93     {
94         WARN("Row not found in hash table!\n");
95         return ERROR_FUNCTION_FAILED;
96     }
97
98     while (entry && entry->row != row)
99         entry = entry->next;
100
101     if (entry) *val = entry->value;
102     return ERROR_SUCCESS;
103 }
104
105 static UINT add_entry_to_hash(MSIHASHENTRY **table, UINT row, UINT val)
106 {
107     MSIHASHENTRY *new = msi_alloc(sizeof(MSIHASHENTRY));
108     MSIHASHENTRY *prev;
109
110     if (!new)
111         return ERROR_OUTOFMEMORY;
112
113     new->next = NULL;
114     new->value = val;
115     new->row = row;
116
117     prev = table[row % MSI_HASH_TABLE_SIZE];
118     if (prev)
119         new->next = prev;
120
121     table[row % MSI_HASH_TABLE_SIZE] = new;
122
123     return ERROR_SUCCESS;
124 }
125
126 static UINT WHERE_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
127 {
128     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
129     UINT r;
130
131     TRACE("%p %d %d %p\n", wv, row, col, val );
132
133     if( !wv->table )
134         return ERROR_FUNCTION_FAILED;
135
136     if( row > wv->row_count )
137         return ERROR_NO_MORE_ITEMS;
138
139     r = find_entry_in_hash(wv->reorder, row, &row);
140     if (r != ERROR_SUCCESS)
141         return r;
142
143     return wv->table->ops->fetch_int( wv->table, row, col, val );
144 }
145
146 static UINT WHERE_fetch_stream( struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm )
147 {
148     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
149     UINT r;
150
151     TRACE("%p %d %d %p\n", wv, row, col, stm );
152
153     if( !wv->table )
154         return ERROR_FUNCTION_FAILED;
155
156     if( row > wv->row_count )
157         return ERROR_NO_MORE_ITEMS;
158
159     r = find_entry_in_hash(wv->reorder, row, &row);
160     if (r != ERROR_SUCCESS)
161         return r;
162
163     return wv->table->ops->fetch_stream( wv->table, row, col, stm );
164 }
165
166 static UINT WHERE_get_row( struct tagMSIVIEW *view, UINT row, MSIRECORD **rec )
167 {
168     MSIWHEREVIEW *wv = (MSIWHEREVIEW *)view;
169     UINT r;
170
171     TRACE("%p %d %p\n", wv, row, rec );
172
173     if (!wv->table)
174         return ERROR_FUNCTION_FAILED;
175
176     if (row > wv->row_count)
177         return ERROR_NO_MORE_ITEMS;
178
179     r = find_entry_in_hash(wv->reorder, row, &row);
180     if (r != ERROR_SUCCESS)
181         return r;
182
183     return wv->table->ops->get_row(wv->table, row, rec);
184 }
185
186 static UINT WHERE_set_row( struct tagMSIVIEW *view, UINT row, MSIRECORD *rec, UINT mask )
187 {
188     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
189     UINT r;
190
191     TRACE("%p %d %p %08x\n", wv, row, rec, mask );
192
193     if( !wv->table )
194          return ERROR_FUNCTION_FAILED;
195
196     if( row > wv->row_count )
197         return ERROR_NO_MORE_ITEMS;
198
199     r = find_entry_in_hash(wv->reorder, row, &row);
200     if (r != ERROR_SUCCESS)
201         return r;
202
203     return wv->table->ops->set_row( wv->table, row, rec, mask );
204 }
205
206 static UINT WHERE_delete_row(struct tagMSIVIEW *view, UINT row)
207 {
208     MSIWHEREVIEW *wv = (MSIWHEREVIEW *)view;
209     UINT r;
210
211     TRACE("(%p %d)\n", view, row);
212
213     if ( !wv->table )
214         return ERROR_FUNCTION_FAILED;
215
216     if ( row > wv->row_count )
217         return ERROR_NO_MORE_ITEMS;
218
219     r = find_entry_in_hash( wv->reorder, row, &row );
220     if ( r != ERROR_SUCCESS )
221         return r;
222
223     return wv->table->ops->delete_row( wv->table, row );
224 }
225
226 static INT INT_evaluate_binary( INT lval, UINT op, INT rval )
227 {
228     switch( op )
229     {
230     case OP_EQ:
231         return ( lval == rval );
232     case OP_AND:
233         return ( lval && rval );
234     case OP_OR:
235         return ( lval || rval );
236     case OP_GT:
237         return ( lval > rval );
238     case OP_LT:
239         return ( lval < rval );
240     case OP_LE:
241         return ( lval <= rval );
242     case OP_GE:
243         return ( lval >= rval );
244     case OP_NE:
245         return ( lval != rval );
246     default:
247         ERR("Unknown operator %d\n", op );
248     }
249     return 0;
250 }
251
252 static INT INT_evaluate_unary( INT lval, UINT op )
253 {
254     switch( op )
255     {
256     case OP_ISNULL:
257         return ( !lval );
258     case OP_NOTNULL:
259         return ( lval );
260     default:
261         ERR("Unknown operator %d\n", op );
262     }
263     return 0;
264 }
265
266 static const WCHAR *STRING_evaluate( MSIWHEREVIEW *wv, UINT row,
267                                      const struct expr *expr,
268                                      const MSIRECORD *record )
269 {
270     UINT val = 0, r;
271
272     switch( expr->type )
273     {
274     case EXPR_COL_NUMBER_STRING:
275         r = wv->table->ops->fetch_int( wv->table, row, expr->u.col_number, &val );
276         if( r != ERROR_SUCCESS )
277             return NULL;
278         return msi_string_lookup_id( wv->db->strings, val );
279
280     case EXPR_SVAL:
281         return expr->u.sval;
282
283     case EXPR_WILDCARD:
284         return MSI_RecordGetString( record, ++wv->rec_index );
285
286     default:
287         ERR("Invalid expression type\n");
288         break;
289     }
290     return NULL;
291 }
292
293 static UINT STRCMP_Evaluate( MSIWHEREVIEW *wv, UINT row, const struct expr *cond,
294                              INT *val, const MSIRECORD *record )
295 {
296     int sr;
297     const WCHAR *l_str, *r_str;
298
299     l_str = STRING_evaluate( wv, row, cond->u.expr.left, record );
300     r_str = STRING_evaluate( wv, row, cond->u.expr.right, record );
301     if( l_str == r_str ||
302         ((!l_str || !*l_str) && (!r_str || !*r_str)) )
303         sr = 0;
304     else if( l_str && ! r_str )
305         sr = 1;
306     else if( r_str && ! l_str )
307         sr = -1;
308     else
309         sr = lstrcmpW( l_str, r_str );
310
311     *val = ( cond->u.expr.op == OP_EQ && ( sr == 0 ) ) ||
312            ( cond->u.expr.op == OP_NE && ( sr != 0 ) );
313
314     return ERROR_SUCCESS;
315 }
316
317 static UINT WHERE_evaluate( MSIWHEREVIEW *wv, UINT row,
318                             struct expr *cond, INT *val, MSIRECORD *record )
319 {
320     UINT r, tval;
321     INT lval, rval;
322
323     if( !cond )
324         return ERROR_SUCCESS;
325
326     switch( cond->type )
327     {
328     case EXPR_COL_NUMBER:
329         r = wv->table->ops->fetch_int( wv->table, row, cond->u.col_number, &tval );
330         *val = tval - 0x8000;
331         return ERROR_SUCCESS;
332
333     case EXPR_COL_NUMBER32:
334         r = wv->table->ops->fetch_int( wv->table, row, cond->u.col_number, &tval );
335         *val = tval - 0x80000000;
336         return r;
337
338     case EXPR_UVAL:
339         *val = cond->u.uval;
340         return ERROR_SUCCESS;
341
342     case EXPR_COMPLEX:
343         r = WHERE_evaluate( wv, row, cond->u.expr.left, &lval, record );
344         if( r != ERROR_SUCCESS )
345             return r;
346         r = WHERE_evaluate( wv, row, cond->u.expr.right, &rval, record );
347         if( r != ERROR_SUCCESS )
348             return r;
349         *val = INT_evaluate_binary( lval, cond->u.expr.op, rval );
350         return ERROR_SUCCESS;
351
352     case EXPR_UNARY:
353         r = wv->table->ops->fetch_int( wv->table, row, cond->u.expr.left->u.col_number, &tval );
354         if( r != ERROR_SUCCESS )
355             return r;
356         *val = INT_evaluate_unary( tval, cond->u.expr.op );
357         return ERROR_SUCCESS;
358
359     case EXPR_STRCMP:
360         return STRCMP_Evaluate( wv, row, cond, val, record );
361
362     case EXPR_WILDCARD:
363         *val = MSI_RecordGetInteger( record, ++wv->rec_index );
364         return ERROR_SUCCESS;
365
366     default:
367         ERR("Invalid expression type\n");
368         break;
369     }
370
371     return ERROR_SUCCESS;
372 }
373
374 static UINT WHERE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
375 {
376     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
377     UINT count = 0, r, i;
378     INT val;
379     MSIVIEW *table = wv->table;
380
381     TRACE("%p %p\n", wv, record);
382
383     if( !table )
384          return ERROR_FUNCTION_FAILED;
385
386     r = table->ops->execute( table, record );
387     if( r != ERROR_SUCCESS )
388         return r;
389
390     r = table->ops->get_dimensions( table, &count, NULL );
391     if( r != ERROR_SUCCESS )
392         return r;
393
394     free_hash_table(wv->reorder);
395     wv->reorder = msi_alloc_zero(MSI_HASH_TABLE_SIZE * sizeof(MSIHASHENTRY *));
396     if( !wv->reorder )
397         return ERROR_OUTOFMEMORY;
398
399     wv->row_count = 0;
400
401 if (0) /* disable optimization, there's no guarantee that strings are in the string table */
402 {
403     if (wv->cond->type == EXPR_STRCMP)
404     {
405         MSIITERHANDLE handle = NULL;
406         UINT row, value, col;
407         struct expr *col_cond = wv->cond->u.expr.left;
408         struct expr *val_cond = wv->cond->u.expr.right;
409
410         /* swap conditionals */
411         if (col_cond->type != EXPR_COL_NUMBER_STRING)
412         {
413             val_cond = wv->cond->u.expr.left;
414             col_cond = wv->cond->u.expr.right;
415         }
416
417         if ((col_cond->type == EXPR_COL_NUMBER_STRING) && (val_cond->type == EXPR_SVAL))
418         {
419             col = col_cond->u.col_number;
420             /* special case for "" - translate it into nil */
421             if (!val_cond->u.sval[0])
422                 value = 0;
423             else
424             {
425                 r = msi_string2idW(wv->db->strings, val_cond->u.sval, &value);
426                 if (r != ERROR_SUCCESS)
427                 {
428                     TRACE("no id for %s, assuming it doesn't exist in the table\n", debugstr_w(wv->cond->u.expr.right->u.sval));
429                     return ERROR_SUCCESS;
430                 }
431             }
432
433             do
434             {
435                 r = table->ops->find_matching_rows(table, col, value, &row, &handle);
436                 if (r == ERROR_SUCCESS)
437                     add_entry_to_hash(wv->reorder, wv->row_count++, row);
438             } while (r == ERROR_SUCCESS);
439
440             if (r == ERROR_NO_MORE_ITEMS)
441                 return ERROR_SUCCESS;
442             else
443                 return r;
444         }
445         /* else fallback to slow case */
446     }
447 }
448
449     for( i=0; i<count; i++ )
450     {
451         val = 0;
452         wv->rec_index = 0;
453         r = WHERE_evaluate( wv, i, wv->cond, &val, record );
454         if( r != ERROR_SUCCESS )
455             return r;
456         if( val )
457             add_entry_to_hash( wv->reorder, wv->row_count++, i );
458     }
459
460     return ERROR_SUCCESS;
461 }
462
463 static UINT WHERE_close( struct tagMSIVIEW *view )
464 {
465     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
466
467     TRACE("%p\n", wv );
468
469     if( !wv->table )
470         return ERROR_FUNCTION_FAILED;
471
472     return wv->table->ops->close( wv->table );
473 }
474
475 static UINT WHERE_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols )
476 {
477     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
478
479     TRACE("%p %p %p\n", wv, rows, cols );
480
481     if( !wv->table )
482          return ERROR_FUNCTION_FAILED;
483
484     if( rows )
485     {
486         if( !wv->reorder )
487             return ERROR_FUNCTION_FAILED;
488         *rows = wv->row_count;
489     }
490
491     return wv->table->ops->get_dimensions( wv->table, NULL, cols );
492 }
493
494 static UINT WHERE_get_column_info( struct tagMSIVIEW *view,
495                 UINT n, LPWSTR *name, UINT *type, BOOL *temporary,
496                 LPWSTR *table_name)
497 {
498     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
499
500     TRACE("%p %d %p %p %p %p\n", wv, n, name, type, temporary, table_name );
501
502     if( !wv->table )
503          return ERROR_FUNCTION_FAILED;
504
505     return wv->table->ops->get_column_info( wv->table, n, name,
506                                             type, temporary, table_name );
507 }
508
509 static UINT WHERE_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode,
510                           MSIRECORD *rec, UINT row )
511 {
512     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
513
514     TRACE("%p %d %p\n", wv, eModifyMode, rec);
515
516     find_entry_in_hash(wv->reorder, row - 1, &row);
517     row++;
518
519     return wv->table->ops->modify( wv->table, eModifyMode, rec, row );
520 }
521
522 static UINT WHERE_delete( struct tagMSIVIEW *view )
523 {
524     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
525
526     TRACE("%p\n", wv );
527
528     if( wv->table )
529         wv->table->ops->delete( wv->table );
530     wv->table = 0;
531
532     free_hash_table(wv->reorder);
533     wv->reorder = NULL;
534     wv->row_count = 0;
535
536     msiobj_release( &wv->db->hdr );
537     msi_free( wv );
538
539     return ERROR_SUCCESS;
540 }
541
542 static UINT WHERE_find_matching_rows( struct tagMSIVIEW *view, UINT col,
543     UINT val, UINT *row, MSIITERHANDLE *handle )
544 {
545     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
546     UINT r;
547
548     TRACE("%p, %d, %u, %p\n", view, col, val, *handle);
549
550     if( !wv->table )
551          return ERROR_FUNCTION_FAILED;
552
553     r = wv->table->ops->find_matching_rows( wv->table, col, val, row, handle );
554     if (r != ERROR_SUCCESS)
555         return r;
556
557     if( *row > wv->row_count )
558         return ERROR_NO_MORE_ITEMS;
559
560     return find_entry_in_hash(wv->reorder, *row, row);
561 }
562
563 static UINT WHERE_sort(struct tagMSIVIEW *view, column_info *columns)
564 {
565     MSIWHEREVIEW *wv = (MSIWHEREVIEW *)view;
566
567     TRACE("%p %p\n", view, columns);
568
569     return wv->table->ops->sort(wv->table, columns);
570 }
571
572 static const MSIVIEWOPS where_ops =
573 {
574     WHERE_fetch_int,
575     WHERE_fetch_stream,
576     WHERE_get_row,
577     WHERE_set_row,
578     NULL,
579     WHERE_delete_row,
580     WHERE_execute,
581     WHERE_close,
582     WHERE_get_dimensions,
583     WHERE_get_column_info,
584     WHERE_modify,
585     WHERE_delete,
586     WHERE_find_matching_rows,
587     NULL,
588     NULL,
589     NULL,
590     NULL,
591     WHERE_sort,
592     NULL,
593 };
594
595 static UINT WHERE_VerifyCondition( MSIDATABASE *db, MSIVIEW *table, struct expr *cond,
596                                    UINT *valid )
597 {
598     UINT r, val = 0;
599
600     switch( cond->type )
601     {
602     case EXPR_COLUMN:
603         r = VIEW_find_column( table, cond->u.column.column,
604                               cond->u.column.table, &val );
605         if( r == ERROR_SUCCESS )
606         {
607             UINT type = 0;
608             r = table->ops->get_column_info( table, val, NULL, &type,
609                                              NULL, NULL );
610             if( r == ERROR_SUCCESS )
611             {
612                 if (type&MSITYPE_STRING)
613                     cond->type = EXPR_COL_NUMBER_STRING;
614                 else if ((type&0xff) == 4)
615                     cond->type = EXPR_COL_NUMBER32;
616                 else
617                     cond->type = EXPR_COL_NUMBER;
618                 cond->u.col_number = val;
619                 *valid = 1;
620             }
621             else
622                 *valid = 0;
623         }
624         else
625         {
626             *valid = 0;
627             WARN("Couldn't find column %s.%s\n", debugstr_w( cond->u.column.table ), debugstr_w( cond->u.column.column ) );
628         }
629         break;
630     case EXPR_COMPLEX:
631         r = WHERE_VerifyCondition( db, table, cond->u.expr.left, valid );
632         if( r != ERROR_SUCCESS )
633             return r;
634         if( !*valid )
635             return ERROR_SUCCESS;
636         r = WHERE_VerifyCondition( db, table, cond->u.expr.right, valid );
637         if( r != ERROR_SUCCESS )
638             return r;
639
640         /* check the type of the comparison */
641         if( ( cond->u.expr.left->type == EXPR_SVAL ) ||
642             ( cond->u.expr.left->type == EXPR_COL_NUMBER_STRING ) ||
643             ( cond->u.expr.right->type == EXPR_SVAL ) ||
644             ( cond->u.expr.right->type == EXPR_COL_NUMBER_STRING ) )
645         {
646             switch( cond->u.expr.op )
647             {
648             case OP_EQ:
649             case OP_NE:
650                 break;
651             default:
652                 *valid = FALSE;
653                 return ERROR_INVALID_PARAMETER;
654             }
655
656             /* FIXME: check we're comparing a string to a column */
657
658             cond->type = EXPR_STRCMP;
659         }
660
661         break;
662     case EXPR_UNARY:
663         if ( cond->u.expr.left->type != EXPR_COLUMN )
664         {
665             *valid = FALSE;
666             return ERROR_INVALID_PARAMETER;
667         }
668         r = WHERE_VerifyCondition( db, table, cond->u.expr.left, valid );
669         if( r != ERROR_SUCCESS )
670             return r;
671         break;
672     case EXPR_IVAL:
673         *valid = 1;
674         cond->type = EXPR_UVAL;
675         cond->u.uval = cond->u.ival;
676         break;
677     case EXPR_WILDCARD:
678         *valid = 1;
679         break;
680     case EXPR_SVAL:
681         *valid = 1;
682         break;
683     default:
684         ERR("Invalid expression type\n");
685         *valid = 0;
686         break;
687     }
688
689     return ERROR_SUCCESS;
690 }
691
692 UINT WHERE_CreateView( MSIDATABASE *db, MSIVIEW **view, MSIVIEW *table,
693                        struct expr *cond )
694 {
695     MSIWHEREVIEW *wv = NULL;
696     UINT count = 0, r, valid = 0;
697
698     TRACE("%p\n", table );
699
700     r = table->ops->get_dimensions( table, NULL, &count );
701     if( r != ERROR_SUCCESS )
702     {
703         ERR("can't get table dimensions\n");
704         return r;
705     }
706
707     if( cond )
708     {
709         r = WHERE_VerifyCondition( db, table, cond, &valid );
710         if( r != ERROR_SUCCESS )
711             return r;
712         if( !valid )
713             return ERROR_FUNCTION_FAILED;
714     }
715
716     wv = msi_alloc_zero( sizeof *wv );
717     if( !wv )
718         return ERROR_FUNCTION_FAILED;
719     
720     /* fill the structure */
721     wv->view.ops = &where_ops;
722     msiobj_addref( &db->hdr );
723     wv->db = db;
724     wv->table = table;
725     wv->row_count = 0;
726     wv->reorder = NULL;
727     wv->cond = cond;
728     wv->rec_index = 0;
729     *view = (MSIVIEW*) wv;
730
731     return ERROR_SUCCESS;
732 }