git.oblomov.eu Git - wine/blob - 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "wine/unicode.h"
  28 #include "msi.h"
  29 #include "msiquery.h"
  30 #include "objbase.h"
  31 #include "objidl.h"
  32 #include "msipriv.h"
  33 #include "winnls.h"
  34
  35 #include "query.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  38
  39
  40 /* below is the query interface to a table */
  41
  42 typedef struct tagMSIWHEREVIEW
  43 {
  44     MSIVIEW        view;
  45     MSIDATABASE   *db;
  46     MSIVIEW       *table;
  47     UINT           row_count;
  48     UINT          *reorder;
  49     struct expr   *cond;
  50 } MSIWHEREVIEW;
  51
  52 static UINT WHERE_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
  53 {
  54     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
  55
  56     TRACE("%p %d %d %p\n", wv, row, col, val );
  57
  58     if( !wv->table )
  59         return ERROR_FUNCTION_FAILED;
  60
  61     if( row > wv->row_count )
  62         return ERROR_NO_MORE_ITEMS;
  63
  64     row = wv->reorder[ row ];
  65
  66     return wv->table->ops->fetch_int( wv->table, row, col, val );
  67 }
  68
  69 static UINT WHERE_fetch_stream( struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm )
  70 {
  71     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
  72
  73     TRACE("%p %d %d %p\n", wv, row, col, stm );
  74
  75     if( !wv->table )
  76         return ERROR_FUNCTION_FAILED;
  77
  78     if( row > wv->row_count )
  79         return ERROR_NO_MORE_ITEMS;
  80
  81     row = wv->reorder[ row ];
  82
  83     return wv->table->ops->fetch_stream( wv->table, row, col, stm );
  84 }
  85
  86 static UINT WHERE_set_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT val )
  87 {
  88     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
  89
  90     TRACE("%p %d %d %04x\n", wv, row, col, val );
  91
  92     if( !wv->table )
  93          return ERROR_FUNCTION_FAILED;
  94
  95     if( row > wv->row_count )
  96         return ERROR_NO_MORE_ITEMS;
  97
  98     row = wv->reorder[ row ];
  99
 100     return wv->table->ops->set_int( wv->table, row, col, val );
 101 }
 102
 103 static UINT INT_evaluate( UINT lval, UINT op, UINT rval )
 104 {
 105     switch( op )
 106     {
 107     case OP_EQ:
 108         return ( lval == rval );
 109     case OP_AND:
 110         return ( lval && rval );
 111     case OP_OR:
 112         return ( lval || rval );
 113     case OP_GT:
 114         return ( lval > rval );
 115     case OP_LT:
 116         return ( lval < rval );
 117     case OP_LE:
 118         return ( lval <= rval );
 119     case OP_GE:
 120         return ( lval >= rval );
 121     case OP_NE:
 122         return ( lval != rval );
 123     case OP_ISNULL:
 124         return ( !lval );
 125     case OP_NOTNULL:
 126         return ( lval );
 127     default:
 128         ERR("Unknown operator %d\n", op );
 129     }
 130     return 0;
 131 }
 132
 133 static const WCHAR *STRING_evaluate( string_table *st,
 134               MSIVIEW *table, UINT row, struct expr *expr, MSIRECORD *record )
 135 {
 136     UINT val = 0, r;
 137
 138     switch( expr->type )
 139     {
 140     case EXPR_COL_NUMBER_STRING:
 141         r = table->ops->fetch_int( table, row, expr->u.col_number, &val );
 142         if( r != ERROR_SUCCESS )
 143             return NULL;
 144         return msi_string_lookup_id( st, val );
 145
 146     case EXPR_SVAL:
 147         return expr->u.sval;
 148
 149     case EXPR_WILDCARD:
 150         return MSI_RecordGetString( record, 1 );
 151
 152     default:
 153         ERR("Invalid expression type\n");
 154         break;
 155     }
 156     return NULL;
 157 }
 158
 159 static UINT STRCMP_Evaluate( string_table *st, MSIVIEW *table, UINT row,
 160                              struct expr *cond, UINT *val, MSIRECORD *record )
 161 {
 162     int sr;
 163     const WCHAR *l_str, *r_str;
 164
 165     l_str = STRING_evaluate( st, table, row, cond->u.expr.left, record );
 166     r_str = STRING_evaluate( st, table, row, cond->u.expr.right, record );
 167     if( l_str == r_str )
 168         sr = 0;
 169     else if( l_str && ! r_str )
 170         sr = 1;
 171     else if( r_str && ! l_str )
 172         sr = -1;
 173     else
 174         sr = strcmpW( l_str, r_str );
 175
 176     *val = ( cond->u.expr.op == OP_EQ && ( sr == 0 ) ) ||
 177            ( cond->u.expr.op == OP_LT && ( sr < 0 ) ) ||
 178            ( cond->u.expr.op == OP_GT && ( sr > 0 ) );
 179
 180     return ERROR_SUCCESS;
 181 }
 182
 183 static UINT WHERE_evaluate( MSIDATABASE *db, MSIVIEW *table, UINT row,
 184                              struct expr *cond, UINT *val, MSIRECORD *record )
 185 {
 186     UINT r, lval, rval;
 187
 188     if( !cond )
 189         return ERROR_SUCCESS;
 190
 191     switch( cond->type )
 192     {
 193     case EXPR_COL_NUMBER_STRING:
 194     case EXPR_COL_NUMBER:
 195         return table->ops->fetch_int( table, row, cond->u.col_number, val );
 196
 197     case EXPR_UVAL:
 198         *val = cond->u.uval;
 199         return ERROR_SUCCESS;
 200
 201     case EXPR_COMPLEX:
 202         r = WHERE_evaluate( db, table, row, cond->u.expr.left, &lval, record );
 203         if( r != ERROR_SUCCESS )
 204             return r;
 205         r = WHERE_evaluate( db, table, row, cond->u.expr.right, &rval, record );
 206         if( r != ERROR_SUCCESS )
 207             return r;
 208         *val = INT_evaluate( lval, cond->u.expr.op, rval );
 209         return ERROR_SUCCESS;
 210
 211     case EXPR_STRCMP:
 212         return STRCMP_Evaluate( db->strings, table, row, cond, val, record );
 213
 214     case EXPR_WILDCARD:
 215         *val = MSI_RecordGetInteger( record, 1 );
 216         return ERROR_SUCCESS;
 217
 218     default:
 219         ERR("Invalid expression type\n");
 220         break;
 221     }
 222
 223     return ERROR_SUCCESS;
 224
 225 }
 226
 227 static UINT WHERE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
 228 {
 229     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
 230     UINT count = 0, r, val, i;
 231     MSIVIEW *table = wv->table;
 232
 233     TRACE("%p %p\n", wv, record);
 234
 235     if( !table )
 236          return ERROR_FUNCTION_FAILED;
 237
 238     r = table->ops->execute( table, record );
 239     if( r != ERROR_SUCCESS )
 240         return r;
 241
 242     r = table->ops->get_dimensions( table, &count, NULL );
 243     if( r != ERROR_SUCCESS )
 244         return r;
 245
 246     wv->reorder = HeapAlloc( GetProcessHeap(), 0, count*sizeof(UINT) );
 247     if( !wv->reorder )
 248         return ERROR_FUNCTION_FAILED;
 249
 250     wv->row_count = 0;
 251     for( i=0; i<count; i++ )
 252     {
 253         val = 0;
 254         r = WHERE_evaluate( wv->db, table, i, wv->cond, &val, record );
 255         if( r != ERROR_SUCCESS )
 256             return r;
 257         if( val )
 258             wv->reorder[ wv->row_count ++ ] = i;
 259     }
 260
 261     return ERROR_SUCCESS;
 262 }
 263
 264 static UINT WHERE_close( struct tagMSIVIEW *view )
 265 {
 266     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
 267
 268     TRACE("%p\n", wv );
 269
 270     if( !wv->table )
 271          return ERROR_FUNCTION_FAILED;
 272
 273     HeapFree( GetProcessHeap(), 0, wv->reorder );
 274     wv->reorder = NULL;
 275
 276     return wv->table->ops->close( wv->table );
 277 }
 278
 279 static UINT WHERE_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols )
 280 {
 281     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
 282
 283     TRACE("%p %p %p\n", wv, rows, cols );
 284
 285     if( !wv->table )
 286          return ERROR_FUNCTION_FAILED;
 287
 288     if( rows )
 289     {
 290         if( !wv->reorder )
 291             return ERROR_FUNCTION_FAILED;
 292         *rows = wv->row_count;
 293     }
 294
 295     return wv->table->ops->get_dimensions( wv->table, NULL, cols );
 296 }
 297
 298 static UINT WHERE_get_column_info( struct tagMSIVIEW *view,
 299                 UINT n, LPWSTR *name, UINT *type )
 300 {
 301     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
 302
 303     TRACE("%p %d %p %p\n", wv, n, name, type );
 304
 305     if( !wv->table )
 306          return ERROR_FUNCTION_FAILED;
 307
 308     return wv->table->ops->get_column_info( wv->table, n, name, type );
 309 }
 310
 311 static UINT WHERE_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode,
 312                 MSIRECORD *rec )
 313 {
 314     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
 315
 316     TRACE("%p %d %p\n", wv, eModifyMode, rec );
 317
 318     if( !wv->table )
 319          return ERROR_FUNCTION_FAILED;
 320
 321     return wv->table->ops->modify( wv->table, eModifyMode, rec );
 322 }
 323
 324 static UINT WHERE_delete( struct tagMSIVIEW *view )
 325 {
 326     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
 327
 328     TRACE("%p\n", wv );
 329
 330     if( wv->table )
 331         wv->table->ops->delete( wv->table );
 332
 333     HeapFree( GetProcessHeap(), 0, wv->reorder );
 334     wv->reorder = NULL;
 335     wv->row_count = 0;
 336
 337     if( wv->cond )
 338         delete_expr( wv->cond );
 339
 340     msiobj_release( &wv->db->hdr );
 341     HeapFree( GetProcessHeap(), 0, wv );
 342
 343     return ERROR_SUCCESS;
 344 }
 345
 346
 347 MSIVIEWOPS where_ops =
 348 {
 349     WHERE_fetch_int,
 350     WHERE_fetch_stream,
 351     WHERE_set_int,
 352     NULL,
 353     WHERE_execute,
 354     WHERE_close,
 355     WHERE_get_dimensions,
 356     WHERE_get_column_info,
 357     WHERE_modify,
 358     WHERE_delete
 359 };
 360
 361 static UINT WHERE_VerifyCondition( MSIDATABASE *db, MSIVIEW *table, struct expr *cond,
 362                                    UINT *valid )
 363 {
 364     UINT r, val = 0;
 365
 366     switch( cond->type )
 367     {
 368     case EXPR_COLUMN:
 369         r = VIEW_find_column( table, cond->u.column, &val );
 370         if( r == ERROR_SUCCESS )
 371         {
 372             UINT type = 0;
 373             r = table->ops->get_column_info( table, val, NULL, &type );
 374             if( r == ERROR_SUCCESS )
 375             {
 376                 if (type&MSITYPE_STRING)
 377                     cond->type = EXPR_COL_NUMBER_STRING;
 378                 else
 379                     cond->type = EXPR_COL_NUMBER;
 380                 cond->u.col_number = val;
 381                 *valid = 1;
 382             }
 383             else
 384                 *valid = 0;
 385         }
 386         else
 387         {
 388             *valid = 0;
 389             ERR("Couldn't find column %s\n", debugstr_w( cond->u.column ) );
 390         }
 391         break;
 392     case EXPR_COMPLEX:
 393         r = WHERE_VerifyCondition( db, table, cond->u.expr.left, valid );
 394         if( r != ERROR_SUCCESS )
 395             return r;
 396         if( !*valid )
 397             return ERROR_SUCCESS;
 398         r = WHERE_VerifyCondition( db, table, cond->u.expr.right, valid );
 399         if( r != ERROR_SUCCESS )
 400             return r;
 401
 402         /* check the type of the comparison */
 403         if( ( cond->u.expr.left->type == EXPR_SVAL ) ||
 404             ( cond->u.expr.left->type == EXPR_COL_NUMBER_STRING ) ||
 405             ( cond->u.expr.right->type == EXPR_SVAL ) ||
 406             ( cond->u.expr.right->type == EXPR_COL_NUMBER_STRING ) )
 407         {
 408             switch( cond->u.expr.op )
 409             {
 410             case OP_EQ:
 411             case OP_GT:
 412             case OP_LT:
 413                 break;
 414             default:
 415                 *valid = FALSE;
 416                 return ERROR_INVALID_PARAMETER;
 417             }
 418
 419             /* FIXME: check we're comparing a string to a column */
 420
 421             cond->type = EXPR_STRCMP;
 422         }
 423
 424         break;
 425     case EXPR_IVAL:
 426         *valid = 1;
 427         cond->type = EXPR_UVAL;
 428         cond->u.uval = cond->u.ival + (1<<15);
 429         break;
 430     case EXPR_WILDCARD:
 431         *valid = 1;
 432         break;
 433     case EXPR_SVAL:
 434         *valid = 1;
 435         break;
 436     default:
 437         ERR("Invalid expression type\n");
 438         *valid = 0;
 439         break;
 440     }
 441
 442     return ERROR_SUCCESS;
 443 }
 444
 445 UINT WHERE_CreateView( MSIDATABASE *db, MSIVIEW **view, MSIVIEW *table,
 446                        struct expr *cond )
 447 {
 448     MSIWHEREVIEW *wv = NULL;
 449     UINT count = 0, r, valid = 0;
 450
 451     TRACE("%p\n", wv );
 452
 453     r = table->ops->get_dimensions( table, NULL, &count );
 454     if( r != ERROR_SUCCESS )
 455     {
 456         ERR("can't get table dimensions\n");
 457         return r;
 458     }
 459
 460     if( cond )
 461     {
 462         r = WHERE_VerifyCondition( db, table, cond, &valid );
 463         if( r != ERROR_SUCCESS )
 464             return r;
 465         if( !valid )
 466             return ERROR_FUNCTION_FAILED;
 467     }
 468
 469     wv = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof *wv );
 470     if( !wv )
 471         return ERROR_FUNCTION_FAILED;
 472
 473     /* fill the structure */
 474     wv->view.ops = &where_ops;
 475     msiobj_addref( &db->hdr );
 476     wv->db = db;
 477     wv->table = table;
 478     wv->row_count = 0;
 479     wv->reorder = NULL;
 480     wv->cond = cond;
 481     *view = (MSIVIEW*) wv;
 482
 483     return ERROR_SUCCESS;
 484 }