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