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