git.oblomov.eu Git - wine/blob - dlls/msi/table.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 #include <assert.h>
  23
  24 #define COBJMACROS
  25 #define NONAMELESSUNION
  26 #define NONAMELESSSTRUCT
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winerror.h"
  31 #include "msi.h"
  32 #include "msiquery.h"
  33 #include "objbase.h"
  34 #include "objidl.h"
  35 #include "winnls.h"
  36 #include "msipriv.h"
  37 #include "query.h"
  38
  39 #include "wine/debug.h"
  40 #include "wine/unicode.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msidb);
  43
  44 #define MSITABLE_HASH_TABLE_SIZE 37
  45 #define LONG_STR_BYTES 3
  46
  47 typedef struct tagMSICOLUMNHASHENTRY
  48 {
  49     struct tagMSICOLUMNHASHENTRY *next;
  50     UINT value;
  51     UINT row;
  52 } MSICOLUMNHASHENTRY;
  53
  54 typedef struct tagMSICOLUMNINFO
  55 {
  56     LPCWSTR tablename;
  57     UINT   number;
  58     LPCWSTR colname;
  59     UINT   type;
  60     UINT   offset;
  61     INT    ref_count;
  62     MSICOLUMNHASHENTRY **hash_table;
  63 } MSICOLUMNINFO;
  64
  65 struct tagMSITABLE
  66 {
  67     BYTE **data;
  68     UINT row_count;
  69     BYTE **nonpersistent_data;
  70     UINT nonpersistent_row_count;
  71     struct list entry;
  72     MSICOLUMNINFO *colinfo;
  73     UINT col_count;
  74     BOOL persistent;
  75     INT ref_count;
  76     WCHAR name[1];
  77 };
  78
  79 typedef struct tagMSITRANSFORM {
  80     struct list entry;
  81     IStorage *stg;
  82 } MSITRANSFORM;
  83
  84 static const WCHAR szStringData[] = {
  85     '_','S','t','r','i','n','g','D','a','t','a',0 };
  86 static const WCHAR szStringPool[] = {
  87     '_','S','t','r','i','n','g','P','o','o','l',0 };
  88
  89 /* information for default tables */
  90 static const WCHAR szTables[]  = { '_','T','a','b','l','e','s',0 };
  91 static const WCHAR szTable[]  = { 'T','a','b','l','e',0 };
  92 static const WCHAR szName[]    = { 'N','a','m','e',0 };
  93 static const WCHAR szColumns[] = { '_','C','o','l','u','m','n','s',0 };
  94 static const WCHAR szNumber[]  = { 'N','u','m','b','e','r',0 };
  95 static const WCHAR szType[]    = { 'T','y','p','e',0 };
  96
  97 /* These tables are written into (the .hash_table part).
  98  * Do not mark them const.
  99  */
 100 static MSICOLUMNINFO _Columns_cols[4] = {
 101     { szColumns, 1, szTable,  MSITYPE_VALID | MSITYPE_STRING | MSITYPE_KEY | 64, 0 },
 102     { szColumns, 2, szNumber, MSITYPE_VALID | MSITYPE_KEY | 2,     2 },
 103     { szColumns, 3, szName,   MSITYPE_VALID | MSITYPE_STRING | 64, 4 },
 104     { szColumns, 4, szType,   MSITYPE_VALID | 2,                   6 },
 105 };
 106 static MSICOLUMNINFO _Tables_cols[1] = {
 107     { szTables,  1, szName,   MSITYPE_VALID | MSITYPE_STRING | 64, 0 },
 108 };
 109
 110 #define MAX_STREAM_NAME 0x1f
 111
 112 static UINT table_get_column_info( MSIDATABASE *db, LPCWSTR name,
 113        MSICOLUMNINFO **pcols, UINT *pcount );
 114 static void table_calc_column_offsets( MSICOLUMNINFO *colinfo, DWORD count );
 115 static UINT get_tablecolumns( MSIDATABASE *db,
 116        LPCWSTR szTableName, MSICOLUMNINFO *colinfo, UINT *sz);
 117 static void msi_free_colinfo( MSICOLUMNINFO *colinfo, UINT count );
 118
 119
 120 void msi_table_set_strref(UINT bytes_per_strref)
 121 {
 122     _Columns_cols[0].offset = 0;
 123     _Columns_cols[1].offset = bytes_per_strref;
 124     _Columns_cols[2].offset = _Columns_cols[1].offset + sizeof(USHORT);
 125     _Columns_cols[3].offset = _Columns_cols[2].offset + bytes_per_strref;
 126 }
 127
 128 static inline UINT bytes_per_column( const MSICOLUMNINFO *col )
 129 {
 130     if( MSITYPE_IS_BINARY(col->type) )
 131         return 2;
 132     if( col->type & MSITYPE_STRING )
 133         return _Columns_cols[1].offset;
 134     if( (col->type & 0xff) > 4 )
 135         ERR("Invalid column size!\n");
 136     return col->type & 0xff;
 137 }
 138
 139 static int utf2mime(int x)
 140 {
 141     if( (x>='0') && (x<='9') )
 142         return x-'0';
 143     if( (x>='A') && (x<='Z') )
 144         return x-'A'+10;
 145     if( (x>='a') && (x<='z') )
 146         return x-'a'+10+26;
 147     if( x=='.' )
 148         return 10+26+26;
 149     if( x=='_' )
 150         return 10+26+26+1;
 151     return -1;
 152 }
 153
 154 LPWSTR encode_streamname(BOOL bTable, LPCWSTR in)
 155 {
 156     DWORD count = MAX_STREAM_NAME;
 157     DWORD ch, next;
 158     LPWSTR out, p;
 159
 160     if( !bTable )
 161         count = lstrlenW( in )+2;
 162     out = msi_alloc( count*sizeof(WCHAR) );
 163     p = out;
 164
 165     if( bTable )
 166     {
 167          *p++ = 0x4840;
 168          count --;
 169     }
 170     while( count -- )
 171     {
 172         ch = *in++;
 173         if( !ch )
 174         {
 175             *p = ch;
 176             return out;
 177         }
 178         if( ( ch < 0x80 ) && ( utf2mime(ch) >= 0 ) )
 179         {
 180             ch = utf2mime(ch) + 0x4800;
 181             next = *in;
 182             if( next && (next<0x80) )
 183             {
 184                 next = utf2mime(next);
 185                 if( next >= 0  )
 186                 {
 187                      next += 0x3ffffc0;
 188                      ch += (next<<6);
 189                      in++;
 190                 }
 191             }
 192         }
 193         *p++ = ch;
 194     }
 195     ERR("Failed to encode stream name (%s)\n",debugstr_w(in));
 196     msi_free( out );
 197     return NULL;
 198 }
 199
 200 static int mime2utf(int x)
 201 {
 202     if( x<10 )
 203         return x + '0';
 204     if( x<(10+26))
 205         return x - 10 + 'A';
 206     if( x<(10+26+26))
 207         return x - 10 - 26 + 'a';
 208     if( x == (10+26+26) )
 209         return '.';
 210     return '_';
 211 }
 212
 213 BOOL decode_streamname(LPCWSTR in, LPWSTR out)
 214 {
 215     WCHAR ch;
 216     DWORD count = 0;
 217
 218     while ( (ch = *in++) )
 219     {
 220         if( (ch >= 0x3800 ) && (ch < 0x4840 ) )
 221         {
 222             if( ch >= 0x4800 )
 223                 ch = mime2utf(ch-0x4800);
 224             else
 225             {
 226                 ch -= 0x3800;
 227                 *out++ = mime2utf(ch&0x3f);
 228                 count++;
 229                 ch = mime2utf((ch>>6)&0x3f);
 230             }
 231         }
 232         *out++ = ch;
 233         count++;
 234     }
 235     *out = 0;
 236     return count;
 237 }
 238
 239 void enum_stream_names( IStorage *stg )
 240 {
 241     IEnumSTATSTG *stgenum = NULL;
 242     HRESULT r;
 243     STATSTG stat;
 244     ULONG n, count;
 245     WCHAR name[0x40];
 246
 247     r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
 248     if( FAILED( r ) )
 249         return;
 250
 251     n = 0;
 252     while( 1 )
 253     {
 254         count = 0;
 255         r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
 256         if( FAILED( r ) || !count )
 257             break;
 258         decode_streamname( stat.pwcsName, name );
 259         TRACE("stream %2d -> %s %s\n", n,
 260               debugstr_w(stat.pwcsName), debugstr_w(name) );
 261         n++;
 262     }
 263
 264     IEnumSTATSTG_Release( stgenum );
 265 }
 266
 267 UINT read_stream_data( IStorage *stg, LPCWSTR stname, BOOL table,
 268                        BYTE **pdata, UINT *psz )
 269 {
 270     HRESULT r;
 271     UINT ret = ERROR_FUNCTION_FAILED;
 272     VOID *data;
 273     ULONG sz, count;
 274     IStream *stm = NULL;
 275     STATSTG stat;
 276     LPWSTR encname;
 277
 278     encname = encode_streamname(table, stname);
 279
 280     TRACE("%s -> %s\n",debugstr_w(stname),debugstr_w(encname));
 281
 282     r = IStorage_OpenStream(stg, encname, NULL,
 283             STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
 284     msi_free( encname );
 285     if( FAILED( r ) )
 286     {
 287         WARN("open stream failed r = %08x - empty table?\n", r);
 288         return ret;
 289     }
 290
 291     r = IStream_Stat(stm, &stat, STATFLAG_NONAME );
 292     if( FAILED( r ) )
 293     {
 294         WARN("open stream failed r = %08x!\n", r);
 295         goto end;
 296     }
 297
 298     if( stat.cbSize.QuadPart >> 32 )
 299     {
 300         WARN("Too big!\n");
 301         goto end;
 302     }
 303
 304     sz = stat.cbSize.QuadPart;
 305     data = msi_alloc( sz );
 306     if( !data )
 307     {
 308         WARN("couldn't allocate memory r=%08x!\n", r);
 309         ret = ERROR_NOT_ENOUGH_MEMORY;
 310         goto end;
 311     }
 312
 313     r = IStream_Read(stm, data, sz, &count );
 314     if( FAILED( r ) || ( count != sz ) )
 315     {
 316         msi_free( data );
 317         WARN("read stream failed r = %08x!\n", r);
 318         goto end;
 319     }
 320
 321     *pdata = data;
 322     *psz = sz;
 323     ret = ERROR_SUCCESS;
 324
 325 end:
 326     IStream_Release( stm );
 327
 328     return ret;
 329 }
 330
 331 UINT db_get_raw_stream( MSIDATABASE *db, LPCWSTR stname, IStream **stm )
 332 {
 333     LPWSTR encname;
 334     HRESULT r;
 335
 336     encname = encode_streamname(FALSE, stname);
 337
 338     TRACE("%s -> %s\n",debugstr_w(stname),debugstr_w(encname));
 339
 340     r = IStorage_OpenStream(db->storage, encname, NULL,
 341             STGM_READ | STGM_SHARE_EXCLUSIVE, 0, stm);
 342     if( FAILED( r ) )
 343     {
 344         MSITRANSFORM *transform;
 345
 346         LIST_FOR_EACH_ENTRY( transform, &db->transforms, MSITRANSFORM, entry )
 347         {
 348             TRACE("looking for %s in transform storage\n", debugstr_w(stname) );
 349             r = IStorage_OpenStream( transform->stg, encname, NULL,
 350                     STGM_READ | STGM_SHARE_EXCLUSIVE, 0, stm );
 351             if (SUCCEEDED(r))
 352                 break;
 353         }
 354     }
 355
 356     msi_free( encname );
 357
 358     return SUCCEEDED(r) ? ERROR_SUCCESS : ERROR_FUNCTION_FAILED;
 359 }
 360
 361 UINT read_raw_stream_data( MSIDATABASE *db, LPCWSTR stname,
 362                               USHORT **pdata, UINT *psz )
 363 {
 364     HRESULT r;
 365     UINT ret = ERROR_FUNCTION_FAILED;
 366     VOID *data;
 367     ULONG sz, count;
 368     IStream *stm = NULL;
 369     STATSTG stat;
 370
 371     r = db_get_raw_stream( db, stname, &stm );
 372     if( r != ERROR_SUCCESS)
 373         return ret;
 374     r = IStream_Stat(stm, &stat, STATFLAG_NONAME );
 375     if( FAILED( r ) )
 376     {
 377         WARN("open stream failed r = %08x!\n", r);
 378         goto end;
 379     }
 380
 381     if( stat.cbSize.QuadPart >> 32 )
 382     {
 383         WARN("Too big!\n");
 384         goto end;
 385     }
 386
 387     sz = stat.cbSize.QuadPart;
 388     data = msi_alloc( sz );
 389     if( !data )
 390     {
 391         WARN("couldn't allocate memory r=%08x!\n", r);
 392         ret = ERROR_NOT_ENOUGH_MEMORY;
 393         goto end;
 394     }
 395
 396     r = IStream_Read(stm, data, sz, &count );
 397     if( FAILED( r ) || ( count != sz ) )
 398     {
 399         msi_free( data );
 400         WARN("read stream failed r = %08x!\n", r);
 401         goto end;
 402     }
 403
 404     *pdata = data;
 405     *psz = sz;
 406     ret = ERROR_SUCCESS;
 407
 408 end:
 409     IStream_Release( stm );
 410
 411     return ret;
 412 }
 413
 414 UINT write_stream_data( IStorage *stg, LPCWSTR stname,
 415                         LPCVOID data, UINT sz, BOOL bTable )
 416 {
 417     HRESULT r;
 418     UINT ret = ERROR_FUNCTION_FAILED;
 419     ULONG count;
 420     IStream *stm = NULL;
 421     ULARGE_INTEGER size;
 422     LARGE_INTEGER pos;
 423     LPWSTR encname;
 424
 425     encname = encode_streamname(bTable, stname );
 426     r = IStorage_OpenStream( stg, encname, NULL,
 427             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
 428     if( FAILED(r) )
 429     {
 430         r = IStorage_CreateStream( stg, encname,
 431                 STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
 432     }
 433     msi_free( encname );
 434     if( FAILED( r ) )
 435     {
 436         WARN("open stream failed r = %08x\n", r);
 437         return ret;
 438     }
 439
 440     size.QuadPart = sz;
 441     r = IStream_SetSize( stm, size );
 442     if( FAILED( r ) )
 443     {
 444         WARN("Failed to SetSize\n");
 445         goto end;
 446     }
 447
 448     pos.QuadPart = 0;
 449     r = IStream_Seek( stm, pos, STREAM_SEEK_SET, NULL );
 450     if( FAILED( r ) )
 451     {
 452         WARN("Failed to Seek\n");
 453         goto end;
 454     }
 455
 456     if (sz)
 457     {
 458         r = IStream_Write(stm, data, sz, &count );
 459         if( FAILED( r ) || ( count != sz ) )
 460         {
 461             WARN("Failed to Write\n");
 462             goto end;
 463         }
 464     }
 465
 466     ret = ERROR_SUCCESS;
 467
 468 end:
 469     IStream_Release( stm );
 470
 471     return ret;
 472 }
 473
 474 static void free_table( MSITABLE *table )
 475 {
 476     int i;
 477     for( i=0; i<table->row_count; i++ )
 478         msi_free( table->data[i] );
 479     msi_free( table->data );
 480     for( i=0; i<table->nonpersistent_row_count; i++ )
 481         msi_free( table->nonpersistent_data[i] );
 482     msi_free( table->nonpersistent_data );
 483     if( (table->colinfo != _Tables_cols) &&
 484         (table->colinfo != _Columns_cols) )
 485     {
 486         msi_free_colinfo( table->colinfo, table->col_count );
 487         msi_free( table->colinfo );
 488     }
 489     msi_free( table );
 490 }
 491
 492 static UINT msi_table_get_row_size( const MSICOLUMNINFO *cols, UINT count )
 493 {
 494     const MSICOLUMNINFO *last_col = &cols[count-1];
 495     if (!count)
 496         return 0;
 497     return last_col->offset + bytes_per_column( last_col );
 498 }
 499
 500 /* add this table to the list of cached tables in the database */
 501 static UINT read_table_from_storage( MSITABLE *t, IStorage *stg )
 502 {
 503     BYTE *rawdata = NULL;
 504     UINT rawsize = 0, i, j, row_size = 0;
 505
 506     TRACE("%s\n",debugstr_w(t->name));
 507
 508     row_size = msi_table_get_row_size( t->colinfo, t->col_count );
 509
 510     /* if we can't read the table, just assume that it's empty */
 511     read_stream_data( stg, t->name, TRUE, &rawdata, &rawsize );
 512     if( !rawdata )
 513         return ERROR_SUCCESS;
 514
 515     TRACE("Read %d bytes\n", rawsize );
 516
 517     if( rawsize % row_size )
 518     {
 519         WARN("Table size is invalid %d/%d\n", rawsize, row_size );
 520         goto err;
 521     }
 522
 523     t->row_count = rawsize / row_size;
 524     t->data = msi_alloc_zero( t->row_count * sizeof (USHORT*) );
 525     if( !t->data )
 526         goto err;
 527
 528     /* transpose all the data */
 529     TRACE("Transposing data from %d rows\n", t->row_count );
 530     for( i=0; i<t->row_count; i++ )
 531     {
 532         t->data[i] = msi_alloc( row_size );
 533         if( !t->data[i] )
 534             goto err;
 535
 536         for( j=0; j<t->col_count; j++ )
 537         {
 538             UINT ofs = t->colinfo[j].offset;
 539             UINT n = bytes_per_column( &t->colinfo[j] );
 540             UINT k;
 541
 542             if ( n != 2 && n != 3 && n != 4 )
 543             {
 544                 ERR("oops - unknown column width %d\n", n);
 545                 goto err;
 546             }
 547
 548             for ( k = 0; k < n; k++ )
 549                 t->data[i][ofs + k] = rawdata[ofs*t->row_count + i * n + k];
 550         }
 551     }
 552
 553     msi_free( rawdata );
 554     return ERROR_SUCCESS;
 555 err:
 556     msi_free( rawdata );
 557     return ERROR_FUNCTION_FAILED;
 558 }
 559
 560 void free_cached_tables( MSIDATABASE *db )
 561 {
 562     while( !list_empty( &db->tables ) )
 563     {
 564         MSITABLE *t = LIST_ENTRY( list_head( &db->tables ), MSITABLE, entry );
 565
 566         list_remove( &t->entry );
 567         free_table( t );
 568     }
 569 }
 570
 571 static MSITABLE *find_cached_table( MSIDATABASE *db, LPCWSTR name )
 572 {
 573     MSITABLE *t;
 574
 575     LIST_FOR_EACH_ENTRY( t, &db->tables, MSITABLE, entry )
 576         if( !lstrcmpW( name, t->name ) )
 577             return t;
 578
 579     return NULL;
 580 }
 581
 582 static UINT table_get_column_info( MSIDATABASE *db, LPCWSTR name, MSICOLUMNINFO **pcols, UINT *pcount )
 583 {
 584     UINT r, column_count = 0;
 585     MSICOLUMNINFO *columns;
 586
 587     /* get the number of columns in this table */
 588     column_count = 0;
 589     r = get_tablecolumns( db, name, NULL, &column_count );
 590     if( r != ERROR_SUCCESS )
 591         return r;
 592
 593     /* if there's no columns, there's no table */
 594     if( column_count == 0 )
 595         return ERROR_INVALID_PARAMETER;
 596
 597     TRACE("Table %s found\n", debugstr_w(name) );
 598
 599     columns = msi_alloc( column_count*sizeof (MSICOLUMNINFO) );
 600     if( !columns )
 601         return ERROR_FUNCTION_FAILED;
 602
 603     r = get_tablecolumns( db, name, columns, &column_count );
 604     if( r != ERROR_SUCCESS )
 605     {
 606         msi_free( columns );
 607         return ERROR_FUNCTION_FAILED;
 608     }
 609
 610     *pcols = columns;
 611     *pcount = column_count;
 612
 613     return r;
 614 }
 615
 616 UINT msi_create_table( MSIDATABASE *db, LPCWSTR name, column_info *col_info,
 617                        BOOL persistent, MSITABLE **table_ret)
 618 {
 619     UINT r, nField;
 620     MSIVIEW *tv = NULL;
 621     MSIRECORD *rec = NULL;
 622     column_info *col;
 623     MSITABLE *table;
 624     UINT i;
 625
 626     /* only add tables that don't exist already */
 627     if( TABLE_Exists(db, name ) )
 628     {
 629         WARN("table %s exists\n", debugstr_w(name));
 630         return ERROR_BAD_QUERY_SYNTAX;
 631     }
 632
 633     table = msi_alloc( sizeof (MSITABLE) + lstrlenW(name)*sizeof (WCHAR) );
 634     if( !table )
 635         return ERROR_FUNCTION_FAILED;
 636
 637     table->ref_count = 1;
 638     table->row_count = 0;
 639     table->data = NULL;
 640     table->nonpersistent_row_count = 0;
 641     table->nonpersistent_data = NULL;
 642     table->colinfo = NULL;
 643     table->col_count = 0;
 644     table->persistent = persistent;
 645     lstrcpyW( table->name, name );
 646
 647     for( col = col_info; col; col = col->next )
 648         table->col_count++;
 649
 650     table->colinfo = msi_alloc( table->col_count * sizeof(MSICOLUMNINFO) );
 651     if (!table->colinfo)
 652     {
 653         free_table( table );
 654         return ERROR_FUNCTION_FAILED;
 655     }
 656
 657     for( i = 0, col = col_info; col; i++, col = col->next )
 658     {
 659         table->colinfo[ i ].tablename = strdupW( col->table );
 660         table->colinfo[ i ].number = i + 1;
 661         table->colinfo[ i ].colname = strdupW( col->column );
 662         table->colinfo[ i ].type = col->type;
 663         table->colinfo[ i ].offset = 0;
 664         table->colinfo[ i ].ref_count = 0;
 665         table->colinfo[ i ].hash_table = NULL;
 666     }
 667     table_calc_column_offsets( table->colinfo, table->col_count);
 668
 669     r = TABLE_CreateView( db, szTables, &tv );
 670     TRACE("CreateView returned %x\n", r);
 671     if( r )
 672     {
 673         free_table( table );
 674         return r;
 675     }
 676
 677     r = tv->ops->execute( tv, 0 );
 678     TRACE("tv execute returned %x\n", r);
 679     if( r )
 680         goto err;
 681
 682     rec = MSI_CreateRecord( 1 );
 683     if( !rec )
 684         goto err;
 685
 686     r = MSI_RecordSetStringW( rec, 1, name );
 687     if( r )
 688         goto err;
 689
 690     r = tv->ops->insert_row( tv, rec, !persistent );
 691     TRACE("insert_row returned %x\n", r);
 692     if( r )
 693         goto err;
 694
 695     tv->ops->delete( tv );
 696     tv = NULL;
 697
 698     msiobj_release( &rec->hdr );
 699     rec = NULL;
 700
 701     if( persistent )
 702     {
 703         /* add each column to the _Columns table */
 704         r = TABLE_CreateView( db, szColumns, &tv );
 705         if( r )
 706             return r;
 707
 708         r = tv->ops->execute( tv, 0 );
 709         TRACE("tv execute returned %x\n", r);
 710         if( r )
 711             goto err;
 712
 713         rec = MSI_CreateRecord( 4 );
 714         if( !rec )
 715             goto err;
 716
 717         r = MSI_RecordSetStringW( rec, 1, name );
 718         if( r )
 719             goto err;
 720
 721         /*
 722          * need to set the table, column number, col name and type
 723          * for each column we enter in the table
 724          */
 725         nField = 1;
 726         for( col = col_info; col; col = col->next )
 727         {
 728             r = MSI_RecordSetInteger( rec, 2, nField );
 729             if( r )
 730                 goto err;
 731
 732             r = MSI_RecordSetStringW( rec, 3, col->column );
 733             if( r )
 734                 goto err;
 735
 736             r = MSI_RecordSetInteger( rec, 4, col->type );
 737             if( r )
 738                 goto err;
 739
 740             r = tv->ops->insert_row( tv, rec, FALSE );
 741             if( r )
 742                 goto err;
 743
 744             nField++;
 745         }
 746         if( !col )
 747             r = ERROR_SUCCESS;
 748     }
 749
 750 err:
 751     if (rec)
 752         msiobj_release( &rec->hdr );
 753     /* FIXME: remove values from the string table on error */
 754     if( tv )
 755         tv->ops->delete( tv );
 756
 757     if (r == ERROR_SUCCESS)
 758     {
 759         list_add_head( &db->tables, &table->entry );
 760         *table_ret = table;
 761     }
 762     else
 763         free_table( table );
 764
 765     return r;
 766 }
 767
 768 static UINT get_table( MSIDATABASE *db, LPCWSTR name, MSITABLE **table_ret )
 769 {
 770     MSITABLE *table;
 771     UINT r;
 772
 773     /* first, see if the table is cached */
 774     table = find_cached_table( db, name );
 775     if( table )
 776     {
 777         *table_ret = table;
 778         return ERROR_SUCCESS;
 779     }
 780
 781     /* nonexistent tables should be interpreted as empty tables */
 782     table = msi_alloc( sizeof (MSITABLE) + lstrlenW(name)*sizeof (WCHAR) );
 783     if( !table )
 784         return ERROR_FUNCTION_FAILED;
 785
 786     table->row_count = 0;
 787     table->data = NULL;
 788     table->nonpersistent_row_count = 0;
 789     table->nonpersistent_data = NULL;
 790     table->colinfo = NULL;
 791     table->col_count = 0;
 792     table->persistent = TRUE;
 793     lstrcpyW( table->name, name );
 794
 795     /* these two tables are special - we know the column types already */
 796     if( !lstrcmpW( name, szColumns ) )
 797     {
 798         table->colinfo = _Columns_cols;
 799         table->col_count = sizeof(_Columns_cols)/sizeof(_Columns_cols[0]);
 800     }
 801     else if( !lstrcmpW( name, szTables ) )
 802     {
 803         table->colinfo = _Tables_cols;
 804         table->col_count = sizeof(_Tables_cols)/sizeof(_Tables_cols[0]);
 805     }
 806     else
 807     {
 808         r = table_get_column_info( db, name, &table->colinfo, &table->col_count);
 809         if (r != ERROR_SUCCESS)
 810         {
 811             free_table ( table );
 812             return r;
 813         }
 814     }
 815
 816     r = read_table_from_storage( table, db->storage );
 817     if( r != ERROR_SUCCESS )
 818     {
 819         free_table( table );
 820         return r;
 821     }
 822
 823     list_add_head( &db->tables, &table->entry );
 824     *table_ret = table;
 825     return ERROR_SUCCESS;
 826 }
 827
 828 static UINT save_table( MSIDATABASE *db, const MSITABLE *t )
 829 {
 830     BYTE *rawdata = NULL, *p;
 831     UINT rawsize, r, i, j, row_size;
 832
 833     /* Nothing to do for non-persistent tables */
 834     if( !t->persistent )
 835         return ERROR_SUCCESS;
 836
 837     TRACE("Saving %s\n", debugstr_w( t->name ) );
 838
 839     row_size = msi_table_get_row_size( t->colinfo, t->col_count );
 840
 841     rawsize = t->row_count * row_size;
 842     rawdata = msi_alloc_zero( rawsize );
 843     if( !rawdata )
 844     {
 845         r = ERROR_NOT_ENOUGH_MEMORY;
 846         goto err;
 847     }
 848
 849     p = rawdata;
 850     for( i=0; i<t->col_count; i++ )
 851     {
 852         for( j=0; j<t->row_count; j++ )
 853         {
 854             UINT offset = t->colinfo[i].offset;
 855
 856             *p++ = t->data[j][offset];
 857             *p++ = t->data[j][offset + 1];
 858             if( 4 == bytes_per_column( &t->colinfo[i] ) )
 859             {
 860                 *p++ = t->data[j][offset + 2];
 861                 *p++ = t->data[j][offset + 3];
 862             }
 863         }
 864     }
 865
 866     TRACE("writing %d bytes\n", rawsize);
 867     r = write_stream_data( db->storage, t->name, rawdata, rawsize, TRUE );
 868
 869 err:
 870     msi_free( rawdata );
 871
 872     return r;
 873 }
 874
 875 static void table_calc_column_offsets( MSICOLUMNINFO *colinfo, DWORD count )
 876 {
 877     DWORD i;
 878
 879     for( i=0; colinfo && (i<count); i++ )
 880     {
 881          assert( (i+1) == colinfo[ i ].number );
 882          if (i)
 883              colinfo[i].offset = colinfo[ i - 1 ].offset
 884                                + bytes_per_column( &colinfo[ i - 1 ] );
 885          else
 886              colinfo[i].offset = 0;
 887          TRACE("column %d is [%s] with type %08x ofs %d\n",
 888                colinfo[i].number, debugstr_w(colinfo[i].colname),
 889                colinfo[i].type, colinfo[i].offset);
 890     }
 891 }
 892
 893 static UINT get_defaulttablecolumns( LPCWSTR name, MSICOLUMNINFO *colinfo, UINT *sz)
 894 {
 895     const MSICOLUMNINFO *p;
 896     DWORD i, n;
 897
 898     TRACE("%s\n", debugstr_w(name));
 899
 900     if (!lstrcmpW( name, szTables ))
 901     {
 902         p = _Tables_cols;
 903         n = 1;
 904     }
 905     else if (!lstrcmpW( name, szColumns ))
 906     {
 907         p = _Columns_cols;
 908         n = 4;
 909     }
 910     else
 911         return ERROR_FUNCTION_FAILED;
 912
 913     /* duplicate the string data so we can free it in msi_free_colinfo */
 914     for (i=0; i<n; i++)
 915     {
 916         if (colinfo && (i < *sz) )
 917         {
 918             memcpy( &colinfo[i], &p[i], sizeof(MSICOLUMNINFO) );
 919             colinfo[i].tablename = strdupW( p[i].tablename );
 920             colinfo[i].colname = strdupW( p[i].colname );
 921         }
 922         if( colinfo && (i >= *sz) )
 923             break;
 924     }
 925     table_calc_column_offsets( colinfo, n );
 926     *sz = n;
 927     return ERROR_SUCCESS;
 928 }
 929
 930 static void msi_free_colinfo( MSICOLUMNINFO *colinfo, UINT count )
 931 {
 932     UINT i;
 933
 934     for( i=0; i<count; i++ )
 935     {
 936         msi_free( (LPWSTR) colinfo[i].tablename );
 937         msi_free( (LPWSTR) colinfo[i].colname );
 938         msi_free( colinfo[i].hash_table );
 939     }
 940 }
 941
 942 static LPWSTR msi_makestring( const MSIDATABASE *db, UINT stringid)
 943 {
 944     return strdupW(msi_string_lookup_id( db->strings, stringid ));
 945 }
 946
 947 static UINT read_table_int(BYTE *const *data, UINT row, UINT col, UINT bytes)
 948 {
 949     UINT ret = 0, i;
 950
 951     for (i = 0; i < bytes; i++)
 952         ret += (data[row][col + i] << i * 8);
 953
 954     return ret;
 955 }
 956
 957 static UINT get_tablecolumns( MSIDATABASE *db,
 958        LPCWSTR szTableName, MSICOLUMNINFO *colinfo, UINT *sz)
 959 {
 960     UINT r, i, n=0, table_id, count, maxcount = *sz;
 961     MSITABLE *table = NULL;
 962
 963     TRACE("%s\n", debugstr_w(szTableName));
 964
 965     /* first check if there is a default table with that name */
 966     r = get_defaulttablecolumns( szTableName, colinfo, sz );
 967     if( ( r == ERROR_SUCCESS ) && *sz )
 968         return r;
 969
 970     r = get_table( db, szColumns, &table );
 971     if( r != ERROR_SUCCESS )
 972     {
 973         ERR("couldn't load _Columns table\n");
 974         return ERROR_FUNCTION_FAILED;
 975     }
 976
 977     /* convert table and column names to IDs from the string table */
 978     r = msi_string2idW( db->strings, szTableName, &table_id );
 979     if( r != ERROR_SUCCESS )
 980     {
 981         WARN("Couldn't find id for %s\n", debugstr_w(szTableName));
 982         return r;
 983     }
 984
 985     TRACE("Table id is %d, row count is %d\n", table_id, table->row_count);
 986
 987     /* Note: _Columns table doesn't have non-persistent data */
 988
 989     /* if maxcount is non-zero, assume it's exactly right for this table */
 990     memset( colinfo, 0, maxcount*sizeof(*colinfo) );
 991     count = table->row_count;
 992     for( i=0; i<count; i++ )
 993     {
 994         if( read_table_int(table->data, i, 0, db->bytes_per_strref) != table_id )
 995             continue;
 996         if( colinfo )
 997         {
 998             UINT id = read_table_int(table->data, i, _Columns_cols[2].offset, db->bytes_per_strref);
 999             UINT col = read_table_int(table->data, i, _Columns_cols[1].offset, sizeof(USHORT)) - (1<<15);
1000
1001             /* check the column number is in range */
1002             if (col<1 || col>maxcount)
1003             {
1004                 ERR("column %d out of range\n", col);
1005                 continue;
1006             }
1007
1008             /* check if this column was already set */
1009             if (colinfo[ col - 1 ].number)
1010             {
1011                 ERR("duplicate column %d\n", col);
1012                 continue;
1013             }
1014
1015             colinfo[ col - 1 ].tablename = msi_makestring( db, table_id );
1016             colinfo[ col - 1 ].number = col;
1017             colinfo[ col - 1 ].colname = msi_makestring( db, id );
1018             colinfo[ col - 1 ].type = read_table_int(table->data, i, _Columns_cols[3].offset, sizeof(USHORT)) - (1<<15);
1019             colinfo[ col - 1 ].offset = 0;
1020             colinfo[ col - 1 ].ref_count = 0;
1021             colinfo[ col - 1 ].hash_table = NULL;
1022         }
1023         n++;
1024     }
1025
1026     TRACE("%s has %d columns\n", debugstr_w(szTableName), n);
1027
1028     if (colinfo && n != maxcount)
1029     {
1030         ERR("missing column in table %s\n", debugstr_w(szTableName));
1031         msi_free_colinfo(colinfo, maxcount );
1032         return ERROR_FUNCTION_FAILED;
1033     }
1034
1035     table_calc_column_offsets( colinfo, n );
1036     *sz = n;
1037
1038     return ERROR_SUCCESS;
1039 }
1040
1041 static void msi_update_table_columns( MSIDATABASE *db, LPCWSTR name )
1042 {
1043     MSITABLE *table;
1044     UINT size, offset;
1045     int n;
1046
1047     table = find_cached_table( db, name );
1048     msi_free( table->colinfo );
1049     table_get_column_info( db, name, &table->colinfo, &table->col_count );
1050
1051     size = msi_table_get_row_size( table->colinfo, table->col_count );
1052     offset = table->colinfo[table->col_count - 1].offset;
1053
1054     for ( n = 0; n < table->row_count; n++ )
1055     {
1056         table->data[n] = msi_realloc( table->data[n], size );
1057         table->data[n][offset] = (BYTE)MSI_NULL_INTEGER;
1058     }
1059 }
1060
1061 /* try to find the table name in the _Tables table */
1062 BOOL TABLE_Exists( MSIDATABASE *db, LPCWSTR name )
1063 {
1064     UINT r, table_id = 0, i, count;
1065     MSITABLE *table = NULL;
1066
1067     if( !lstrcmpW( name, szTables ) )
1068         return TRUE;
1069     if( !lstrcmpW( name, szColumns ) )
1070         return TRUE;
1071
1072     r = msi_string2idW( db->strings, name, &table_id );
1073     if( r != ERROR_SUCCESS )
1074     {
1075         TRACE("Couldn't find id for %s\n", debugstr_w(name));
1076         return FALSE;
1077     }
1078
1079     r = get_table( db, szTables, &table );
1080     if( r != ERROR_SUCCESS )
1081     {
1082         ERR("table %s not available\n", debugstr_w(szTables));
1083         return FALSE;
1084     }
1085
1086     count = table->row_count;
1087     for( i=0; i<count; i++ )
1088         if( table->data[ i ][ 0 ] == table_id )
1089             break;
1090
1091     if (i!=count)
1092         return TRUE;
1093
1094     count = table->nonpersistent_row_count;
1095     for( i=0; i<count; i++ )
1096         if( table->nonpersistent_data[ i ][ 0 ] == table_id )
1097             break;
1098
1099     if (i!=count)
1100         return TRUE;
1101
1102     TRACE("Searched %d tables, but %d was not found\n", count, table_id );
1103
1104     return FALSE;
1105 }
1106
1107 /* below is the query interface to a table */
1108
1109 typedef struct tagMSITABLEVIEW
1110 {
1111     MSIVIEW        view;
1112     MSIDATABASE   *db;
1113     MSITABLE      *table;
1114     MSICOLUMNINFO *columns;
1115     UINT           num_cols;
1116     UINT           row_size;
1117     WCHAR          name[1];
1118 } MSITABLEVIEW;
1119
1120 static UINT TABLE_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
1121 {
1122     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1123     UINT offset, n;
1124     BYTE **data;
1125
1126     if( !tv->table )
1127         return ERROR_INVALID_PARAMETER;
1128
1129     if( (col==0) || (col>tv->num_cols) )
1130         return ERROR_INVALID_PARAMETER;
1131
1132     /* how many rows are there ? */
1133     if( row >= tv->table->row_count + tv->table->nonpersistent_row_count )
1134         return ERROR_NO_MORE_ITEMS;
1135
1136     if( tv->columns[col-1].offset >= tv->row_size )
1137     {
1138         ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1139         ERR("%p %p\n", tv, tv->columns );
1140         return ERROR_FUNCTION_FAILED;
1141     }
1142
1143     if (row >= tv->table->row_count)
1144     {
1145         row -= tv->table->row_count;
1146         data = tv->table->nonpersistent_data;
1147     }
1148     else
1149         data = tv->table->data;
1150
1151     n = bytes_per_column( &tv->columns[col-1] );
1152     if (n != 2 && n != 3 && n != 4)
1153     {
1154         ERR("oops! what is %d bytes per column?\n", n );
1155         return ERROR_FUNCTION_FAILED;
1156     }
1157
1158     offset = tv->columns[col-1].offset;
1159     *val = read_table_int(data, row, offset, n);
1160
1161     /* TRACE("Data [%d][%d] = %d\n", row, col, *val ); */
1162
1163     return ERROR_SUCCESS;
1164 }
1165
1166 /*
1167  * We need a special case for streams, as we need to reference column with
1168  * the name of the stream in the same table, and the table name
1169  * which may not be available at higher levels of the query
1170  */
1171 static UINT TABLE_fetch_stream( struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm )
1172 {
1173     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1174     UINT ival = 0, refcol = 0, r;
1175     LPCWSTR sval;
1176     LPWSTR full_name;
1177     DWORD len;
1178     static const WCHAR szDot[] = { '.', 0 };
1179     WCHAR number[0x20];
1180
1181     if( !view->ops->fetch_int )
1182         return ERROR_INVALID_PARAMETER;
1183
1184     /*
1185      * The column marked with the type stream data seems to have a single number
1186      * which references the column containing the name of the stream data
1187      *
1188      * Fetch the column to reference first.
1189      */
1190     r = view->ops->fetch_int( view, row, col, &ival );
1191     if( r != ERROR_SUCCESS )
1192         return r;
1193
1194     /* check the column value is in range */
1195     if (ival < 0 || ival > tv->num_cols || ival == col)
1196     {
1197         ERR("bad column ref (%u) for stream\n", ival);
1198         return ERROR_FUNCTION_FAILED;
1199     }
1200
1201     if ( tv->columns[ival - 1].type & MSITYPE_STRING )
1202     {
1203         /* now get the column with the name of the stream */
1204         r = view->ops->fetch_int( view, row, ival, &refcol );
1205         if ( r != ERROR_SUCCESS )
1206             return r;
1207
1208         /* lookup the string value from the string table */
1209         sval = msi_string_lookup_id( tv->db->strings, refcol );
1210         if ( !sval )
1211             return ERROR_INVALID_PARAMETER;
1212     }
1213     else
1214     {
1215         static const WCHAR fmt[] = { '%','d',0 };
1216         sprintfW( number, fmt, ival );
1217         sval = number;
1218     }
1219
1220     len = lstrlenW( tv->name ) + 2 + lstrlenW( sval );
1221     full_name = msi_alloc( len*sizeof(WCHAR) );
1222     lstrcpyW( full_name, tv->name );
1223     lstrcatW( full_name, szDot );
1224     lstrcatW( full_name, sval );
1225
1226     r = db_get_raw_stream( tv->db, full_name, stm );
1227     if( r )
1228         ERR("fetching stream %s, error = %d\n",debugstr_w(full_name), r);
1229     msi_free( full_name );
1230
1231     return r;
1232 }
1233
1234 static UINT TABLE_set_int( MSITABLEVIEW *tv, UINT row, UINT col, UINT val )
1235 {
1236     UINT offset, n, i;
1237     BYTE **data;
1238
1239     if( !tv->table )
1240         return ERROR_INVALID_PARAMETER;
1241
1242     if( (col==0) || (col>tv->num_cols) )
1243         return ERROR_INVALID_PARAMETER;
1244
1245     if( row >= tv->table->row_count + tv->table->nonpersistent_row_count )
1246         return ERROR_INVALID_PARAMETER;
1247
1248     if( tv->columns[col-1].offset >= tv->row_size )
1249     {
1250         ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1251         ERR("%p %p\n", tv, tv->columns );
1252         return ERROR_FUNCTION_FAILED;
1253     }
1254
1255     msi_free( tv->columns[col-1].hash_table );
1256     tv->columns[col-1].hash_table = NULL;
1257
1258     if (row >= tv->table->row_count)
1259     {
1260         row -= tv->table->row_count;
1261         data = tv->table->nonpersistent_data;
1262     }
1263     else
1264         data = tv->table->data;
1265
1266     n = bytes_per_column( &tv->columns[col-1] );
1267     if ( n != 2 && n != 3 && n != 4 )
1268     {
1269         ERR("oops! what is %d bytes per column?\n", n );
1270         return ERROR_FUNCTION_FAILED;
1271     }
1272
1273     offset = tv->columns[col-1].offset;
1274     for ( i = 0; i < n; i++ )
1275         data[row][offset + i] = (val >> i * 8) & 0xff;
1276
1277     return ERROR_SUCCESS;
1278 }
1279
1280 static UINT TABLE_get_row( struct tagMSIVIEW *view, UINT row, MSIRECORD **rec )
1281 {
1282     MSITABLEVIEW *tv = (MSITABLEVIEW *)view;
1283
1284     if (!tv->table)
1285         return ERROR_INVALID_PARAMETER;
1286
1287     return msi_view_get_row(tv->db, view, row, rec);
1288 }
1289
1290 static UINT TABLE_set_row( struct tagMSIVIEW *view, UINT row, MSIRECORD *rec, UINT mask )
1291 {
1292     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1293     UINT i, val, r = ERROR_SUCCESS;
1294
1295     if ( !tv->table )
1296         return ERROR_INVALID_PARAMETER;
1297
1298     /* test if any of the mask bits are invalid */
1299     if ( mask >= (1<<tv->num_cols) )
1300         return ERROR_INVALID_PARAMETER;
1301
1302     for ( i = 0; i < tv->num_cols; i++ )
1303     {
1304         BOOL persistent;
1305
1306         /* only update the fields specified in the mask */
1307         if ( !(mask&(1<<i)) )
1308             continue;
1309
1310         /* if row >= tv->table->row_count then it is a non-persistent row */
1311         persistent = tv->table->persistent && (row < tv->table->row_count);
1312         /* FIXME: should we allow updating keys? */
1313
1314         val = 0;
1315         if ( !MSI_RecordIsNull( rec, i + 1 ) )
1316         {
1317             if ( MSITYPE_IS_BINARY(tv->columns[ i ].type) )
1318             {
1319                 val = 1; /* refers to the first key column */
1320             }
1321             else if ( tv->columns[i].type & MSITYPE_STRING )
1322             {
1323                 LPCWSTR sval = MSI_RecordGetString( rec, i + 1 );
1324                 val = msi_addstringW( tv->db->strings, 0, sval, -1, 1,
1325                                       persistent ? StringPersistent : StringNonPersistent );
1326             }
1327             else if ( 2 == bytes_per_column( &tv->columns[ i ] ) )
1328             {
1329                 val = 0x8000 + MSI_RecordGetInteger( rec, i + 1 );
1330                 if ( val & 0xffff0000 )
1331                 {
1332                     ERR("field %u value %d out of range\n", i+1, val - 0x8000 );
1333                     return ERROR_FUNCTION_FAILED;
1334                 }
1335             }
1336             else
1337             {
1338                 INT ival = MSI_RecordGetInteger( rec, i + 1 );
1339                 val = ival ^ 0x80000000;
1340             }
1341         }
1342
1343         r = TABLE_set_int( tv, row, i+1, val );
1344         if ( r != ERROR_SUCCESS )
1345             break;
1346     }
1347     return r;
1348 }
1349
1350 static UINT table_create_new_row( struct tagMSIVIEW *view, UINT *num, BOOL temporary )
1351 {
1352     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1353     BYTE **p, *row;
1354     UINT sz;
1355     BYTE ***data_ptr;
1356     UINT *row_count;
1357
1358     TRACE("%p %s\n", view, temporary ? "TRUE" : "FALSE");
1359
1360     if( !tv->table )
1361         return ERROR_INVALID_PARAMETER;
1362
1363     row = msi_alloc_zero( tv->row_size );
1364     if( !row )
1365         return ERROR_NOT_ENOUGH_MEMORY;
1366
1367     if( temporary )
1368     {
1369         row_count = &tv->table->nonpersistent_row_count;
1370         data_ptr = &tv->table->nonpersistent_data;
1371         *num = tv->table->row_count + tv->table->nonpersistent_row_count;
1372     }
1373     else
1374     {
1375         row_count = &tv->table->row_count;
1376         data_ptr = &tv->table->data;
1377         *num = tv->table->row_count;
1378     }
1379
1380     sz = (*row_count + 1) * sizeof (BYTE*);
1381     if( *data_ptr )
1382         p = msi_realloc( *data_ptr, sz );
1383     else
1384         p = msi_alloc( sz );
1385     if( !p )
1386     {
1387         msi_free( row );
1388         return ERROR_NOT_ENOUGH_MEMORY;
1389     }
1390
1391     *data_ptr = p;
1392     (*data_ptr)[*row_count] = row;
1393     (*row_count)++;
1394
1395     return ERROR_SUCCESS;
1396 }
1397
1398 static UINT TABLE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
1399 {
1400     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1401
1402     TRACE("%p %p\n", tv, record);
1403
1404     TRACE("There are %d columns\n", tv->num_cols );
1405
1406     return ERROR_SUCCESS;
1407 }
1408
1409 static UINT TABLE_close( struct tagMSIVIEW *view )
1410 {
1411     TRACE("%p\n", view );
1412
1413     return ERROR_SUCCESS;
1414 }
1415
1416 static UINT TABLE_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols)
1417 {
1418     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1419
1420     TRACE("%p %p %p\n", view, rows, cols );
1421
1422     if( cols )
1423         *cols = tv->num_cols;
1424     if( rows )
1425     {
1426         if( !tv->table )
1427             return ERROR_INVALID_PARAMETER;
1428         *rows = tv->table->row_count + tv->table->nonpersistent_row_count;
1429     }
1430
1431     return ERROR_SUCCESS;
1432 }
1433
1434 static UINT TABLE_get_column_info( struct tagMSIVIEW *view,
1435                 UINT n, LPWSTR *name, UINT *type )
1436 {
1437     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1438
1439     TRACE("%p %d %p %p\n", tv, n, name, type );
1440
1441     if( ( n == 0 ) || ( n > tv->num_cols ) )
1442         return ERROR_INVALID_PARAMETER;
1443
1444     if( name )
1445     {
1446         *name = strdupW( tv->columns[n-1].colname );
1447         if( !*name )
1448             return ERROR_FUNCTION_FAILED;
1449     }
1450     if( type )
1451         *type = tv->columns[n-1].type;
1452
1453     return ERROR_SUCCESS;
1454 }
1455
1456 static UINT msi_table_find_row( MSITABLEVIEW *tv, MSIRECORD *rec, UINT *row );
1457
1458 static UINT table_validate_new( MSITABLEVIEW *tv, MSIRECORD *rec )
1459 {
1460     UINT r, row, i;
1461
1462     /* check there's no null values where they're not allowed */
1463     for( i = 0; i < tv->num_cols; i++ )
1464     {
1465         if ( tv->columns[i].type & MSITYPE_NULLABLE )
1466             continue;
1467
1468         if ( MSITYPE_IS_BINARY(tv->columns[i].type) )
1469             TRACE("skipping binary column\n");
1470         else if ( tv->columns[i].type & MSITYPE_STRING )
1471         {
1472             LPCWSTR str;
1473
1474             str = MSI_RecordGetString( rec, i+1 );
1475             if (str == NULL || str[0] == 0)
1476                 return ERROR_INVALID_DATA;
1477         }
1478         else
1479         {
1480             UINT n;
1481
1482             n = MSI_RecordGetInteger( rec, i+1 );
1483             if (n == MSI_NULL_INTEGER)
1484                 return ERROR_INVALID_DATA;
1485         }
1486     }
1487
1488     /* check there's no duplicate keys */
1489     r = msi_table_find_row( tv, rec, &row );
1490     if (r == ERROR_SUCCESS)
1491         return ERROR_INVALID_DATA;
1492
1493     return ERROR_SUCCESS;
1494 }
1495
1496 static UINT TABLE_insert_row( struct tagMSIVIEW *view, MSIRECORD *rec, BOOL temporary )
1497 {
1498     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1499     UINT r, row = -1;
1500
1501     TRACE("%p %p %s\n", tv, rec, temporary ? "TRUE" : "FALSE" );
1502
1503     /* check that the key is unique - can we find a matching row? */
1504     r = table_validate_new( tv, rec );
1505     if( r != ERROR_SUCCESS )
1506         return ERROR_FUNCTION_FAILED;
1507
1508     r = table_create_new_row( view, &row, temporary );
1509     TRACE("insert_row returned %08x\n", r);
1510     if( r != ERROR_SUCCESS )
1511         return r;
1512
1513     return TABLE_set_row( view, row, rec, (1<<tv->num_cols) - 1 );
1514 }
1515
1516 static UINT TABLE_delete_row( struct tagMSIVIEW *view, UINT row )
1517 {
1518     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1519     UINT r, num_rows, num_cols;
1520     BYTE *src, *dest;
1521
1522     TRACE("%p %d\n", tv, row);
1523
1524     if ( !tv->table )
1525         return ERROR_INVALID_PARAMETER;
1526
1527     r = TABLE_get_dimensions( view, &num_rows, &num_cols );
1528     if ( r != ERROR_SUCCESS )
1529         return r;
1530
1531     if ( row >= num_rows )
1532         return ERROR_FUNCTION_FAILED;
1533
1534     tv->table->row_count--;
1535
1536     if ( row == num_rows - 1 )
1537         return ERROR_SUCCESS;
1538
1539     dest = tv->table->data[row];
1540     src = tv->table->data[row + 1];
1541     memmove(dest, src, (num_rows - row - 1) * tv->row_size);
1542     return ERROR_SUCCESS;
1543 }
1544
1545 static UINT msi_table_update(struct tagMSIVIEW *view, MSIRECORD *rec, UINT row)
1546 {
1547     MSITABLEVIEW *tv = (MSITABLEVIEW *)view;
1548     UINT r, new_row;
1549
1550     /* FIXME: MsiViewFetch should set rec index 0 to some ID that
1551      * sets the fetched record apart from other records
1552      */
1553
1554     if (!tv->table)
1555         return ERROR_INVALID_PARAMETER;
1556
1557     r = msi_table_find_row(tv, rec, &new_row);
1558     if (r != ERROR_SUCCESS)
1559     {
1560         ERR("can't find row to modify\n");
1561         return ERROR_SUCCESS;
1562     }
1563
1564     /* the row cannot be changed */
1565     if (row != new_row + 1)
1566         return ERROR_FUNCTION_FAILED;
1567
1568     return TABLE_set_row(view, new_row, rec, (1 << tv->num_cols) - 1);
1569 }
1570
1571 static UINT TABLE_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode,
1572                           MSIRECORD *rec, UINT row)
1573 {
1574     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1575     UINT r;
1576
1577     TRACE("%p %d %p\n", view, eModifyMode, rec );
1578
1579     switch (eModifyMode)
1580     {
1581     case MSIMODIFY_VALIDATE_NEW:
1582         r = table_validate_new( tv, rec );
1583         break;
1584
1585     case MSIMODIFY_INSERT_TEMPORARY:
1586         r = table_validate_new( tv, rec );
1587         if (r != ERROR_SUCCESS)
1588             break;
1589         r = TABLE_insert_row( view, rec, TRUE );
1590         break;
1591
1592     case MSIMODIFY_UPDATE:
1593         r = msi_table_update( view, rec, row );
1594         break;
1595
1596     case MSIMODIFY_REFRESH:
1597     case MSIMODIFY_INSERT:
1598     case MSIMODIFY_ASSIGN:
1599     case MSIMODIFY_REPLACE:
1600     case MSIMODIFY_MERGE:
1601     case MSIMODIFY_DELETE:
1602     case MSIMODIFY_VALIDATE:
1603     case MSIMODIFY_VALIDATE_FIELD:
1604     case MSIMODIFY_VALIDATE_DELETE:
1605         FIXME("%p %d %p - mode not implemented\n", view, eModifyMode, rec );
1606         r = ERROR_CALL_NOT_IMPLEMENTED;
1607         break;
1608
1609     default:
1610         r = ERROR_INVALID_DATA;
1611     }
1612
1613     return r;
1614 }
1615
1616 static UINT TABLE_delete( struct tagMSIVIEW *view )
1617 {
1618     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1619
1620     TRACE("%p\n", view );
1621
1622     tv->table = NULL;
1623
1624     tv->columns = NULL;
1625
1626     msi_free( tv );
1627
1628     return ERROR_SUCCESS;
1629 }
1630
1631 static UINT TABLE_find_matching_rows( struct tagMSIVIEW *view, UINT col,
1632     UINT val, UINT *row, MSIITERHANDLE *handle )
1633 {
1634     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1635     const MSICOLUMNHASHENTRY *entry;
1636
1637     TRACE("%p, %d, %u, %p\n", view, col, val, *handle);
1638
1639     if( !tv->table )
1640         return ERROR_INVALID_PARAMETER;
1641
1642     if( (col==0) || (col > tv->num_cols) )
1643         return ERROR_INVALID_PARAMETER;
1644
1645     if( !tv->columns[col-1].hash_table )
1646     {
1647         UINT i;
1648         UINT num_rows = tv->table->row_count + tv->table->nonpersistent_row_count;
1649         MSICOLUMNHASHENTRY **hash_table;
1650         MSICOLUMNHASHENTRY *new_entry;
1651
1652         if( tv->columns[col-1].offset >= tv->row_size )
1653         {
1654             ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1655             ERR("%p %p\n", tv, tv->columns );
1656             return ERROR_FUNCTION_FAILED;
1657         }
1658
1659         /* allocate contiguous memory for the table and its entries so we
1660          * don't have to do an expensive cleanup */
1661         hash_table = msi_alloc(MSITABLE_HASH_TABLE_SIZE * sizeof(MSICOLUMNHASHENTRY*) +
1662             num_rows * sizeof(MSICOLUMNHASHENTRY));
1663         if (!hash_table)
1664             return ERROR_OUTOFMEMORY;
1665
1666         memset(hash_table, 0, MSITABLE_HASH_TABLE_SIZE * sizeof(MSICOLUMNHASHENTRY*));
1667         tv->columns[col-1].hash_table = hash_table;
1668
1669         new_entry = (MSICOLUMNHASHENTRY *)(hash_table + MSITABLE_HASH_TABLE_SIZE);
1670
1671         for (i = 0; i < num_rows; i++, new_entry++)
1672         {
1673             UINT row_value;
1674
1675             if (view->ops->fetch_int( view, i, col, &row_value ) != ERROR_SUCCESS)
1676                 continue;
1677
1678             new_entry->next = NULL;
1679             new_entry->value = row_value;
1680             new_entry->row = i;
1681             if (hash_table[row_value % MSITABLE_HASH_TABLE_SIZE])
1682             {
1683                 MSICOLUMNHASHENTRY *prev_entry = hash_table[row_value % MSITABLE_HASH_TABLE_SIZE];
1684                 while (prev_entry->next)
1685                     prev_entry = prev_entry->next;
1686                 prev_entry->next = new_entry;
1687             }
1688             else
1689                 hash_table[row_value % MSITABLE_HASH_TABLE_SIZE] = new_entry;
1690         }
1691     }
1692
1693     if( !*handle )
1694         entry = tv->columns[col-1].hash_table[val % MSITABLE_HASH_TABLE_SIZE];
1695     else
1696         entry = (*handle)->next;
1697
1698     while (entry && entry->value != val)
1699         entry = entry->next;
1700
1701     *handle = entry;
1702     if (!entry)
1703         return ERROR_NO_MORE_ITEMS;
1704
1705     *row = entry->row;
1706     return ERROR_SUCCESS;
1707 }
1708
1709 static UINT TABLE_add_ref(struct tagMSIVIEW *view)
1710 {
1711     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1712     int i;
1713
1714     TRACE("%p %d\n", view, tv->table->ref_count);
1715
1716     for (i = 0; i < tv->table->col_count; i++)
1717     {
1718         if (tv->table->colinfo[i].type & MSITYPE_TEMPORARY)
1719             InterlockedIncrement(&tv->table->colinfo[i].ref_count);
1720     }
1721
1722     return InterlockedIncrement(&tv->table->ref_count);
1723 }
1724
1725 static UINT TABLE_remove_column(struct tagMSIVIEW *view, LPCWSTR table, UINT number)
1726 {
1727     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1728     MSIRECORD *rec = NULL;
1729     MSIVIEW *columns = NULL;
1730     UINT row, r;
1731
1732     rec = MSI_CreateRecord(2);
1733     if (!rec)
1734         return ERROR_OUTOFMEMORY;
1735
1736     MSI_RecordSetStringW(rec, 1, table);
1737     MSI_RecordSetInteger(rec, 2, number);
1738
1739     r = TABLE_CreateView(tv->db, szColumns, &columns);
1740     if (r != ERROR_SUCCESS)
1741         return r;
1742
1743     r = msi_table_find_row((MSITABLEVIEW *)columns, rec, &row);
1744     if (r != ERROR_SUCCESS)
1745         goto done;
1746
1747     r = TABLE_delete_row(columns, row);
1748     if (r != ERROR_SUCCESS)
1749         goto done;
1750
1751     msi_update_table_columns(tv->db, table);
1752
1753 done:
1754     msiobj_release(&rec->hdr);
1755     if (columns) columns->ops->delete(columns);
1756     return r;
1757 }
1758
1759 static UINT TABLE_release(struct tagMSIVIEW *view)
1760 {
1761     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1762     INT ref = tv->table->ref_count;
1763     int i;
1764     UINT r;
1765
1766     TRACE("%p %d\n", view, ref);
1767
1768     for (i = 0; i < tv->table->col_count; i++)
1769     {
1770         if (tv->table->colinfo[i].type & MSITYPE_TEMPORARY)
1771         {
1772             ref = InterlockedDecrement(&tv->table->colinfo[i].ref_count);
1773             if (ref == 0)
1774             {
1775                 r = TABLE_remove_column(view, tv->table->colinfo[i].tablename,
1776                                         tv->table->colinfo[i].number);
1777                 if (r != ERROR_SUCCESS)
1778                     break;
1779             }
1780         }
1781     }
1782
1783     ref = InterlockedDecrement(&tv->table->ref_count);
1784     if (ref == 0)
1785     {
1786         if (!tv->table->row_count)
1787         {
1788             list_remove(&tv->table->entry);
1789             free_table(tv->table);
1790             TABLE_delete(view);
1791         }
1792     }
1793
1794     return ref;
1795 }
1796
1797 static UINT TABLE_add_column(struct tagMSIVIEW *view, LPCWSTR table, UINT number,
1798                              LPCWSTR column, UINT type, BOOL hold)
1799 {
1800     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1801     MSITABLE *msitable;
1802     MSIRECORD *rec;
1803     UINT r, i;
1804
1805     rec = MSI_CreateRecord(4);
1806     if (!rec)
1807         return ERROR_OUTOFMEMORY;
1808
1809     MSI_RecordSetStringW(rec, 1, table);
1810     MSI_RecordSetInteger(rec, 2, number);
1811     MSI_RecordSetStringW(rec, 3, column);
1812     MSI_RecordSetInteger(rec, 4, type);
1813
1814     r = TABLE_insert_row(&tv->view, rec, FALSE);
1815     if (r != ERROR_SUCCESS)
1816         goto done;
1817
1818     msi_update_table_columns(tv->db, table);
1819
1820     if (!hold)
1821         goto done;
1822
1823     msitable = find_cached_table(tv->db, table);
1824     for (i = 0; i < msitable->col_count; i++)
1825     {
1826         if (!lstrcmpW(msitable->colinfo[i].colname, column))
1827         {
1828             InterlockedIncrement(&msitable->colinfo[i].ref_count);
1829             break;
1830         }
1831     }
1832
1833 done:
1834     msiobj_release(&rec->hdr);
1835     return r;
1836 }
1837
1838 static const MSIVIEWOPS table_ops =
1839 {
1840     TABLE_fetch_int,
1841     TABLE_fetch_stream,
1842     TABLE_get_row,
1843     TABLE_set_row,
1844     TABLE_insert_row,
1845     TABLE_delete_row,
1846     TABLE_execute,
1847     TABLE_close,
1848     TABLE_get_dimensions,
1849     TABLE_get_column_info,
1850     TABLE_modify,
1851     TABLE_delete,
1852     TABLE_find_matching_rows,
1853     TABLE_add_ref,
1854     TABLE_release,
1855     TABLE_add_column,
1856     TABLE_remove_column,
1857 };
1858
1859 UINT TABLE_CreateView( MSIDATABASE *db, LPCWSTR name, MSIVIEW **view )
1860 {
1861     MSITABLEVIEW *tv ;
1862     UINT r, sz;
1863
1864     static const WCHAR Streams[] = {'_','S','t','r','e','a','m','s',0};
1865
1866     TRACE("%p %s %p\n", db, debugstr_w(name), view );
1867
1868     if ( !lstrcmpW( name, Streams ) )
1869         return STREAMS_CreateView( db, view );
1870
1871     sz = sizeof *tv + lstrlenW(name)*sizeof name[0] ;
1872     tv = msi_alloc_zero( sz );
1873     if( !tv )
1874         return ERROR_FUNCTION_FAILED;
1875
1876     r = get_table( db, name, &tv->table );
1877     if( r != ERROR_SUCCESS )
1878     {
1879         msi_free( tv );
1880         WARN("table not found\n");
1881         return r;
1882     }
1883
1884     TRACE("table %p found with %d columns\n", tv->table, tv->table->col_count);
1885
1886     /* fill the structure */
1887     tv->view.ops = &table_ops;
1888     tv->db = db;
1889     tv->columns = tv->table->colinfo;
1890     tv->num_cols = tv->table->col_count;
1891     tv->row_size = msi_table_get_row_size( tv->table->colinfo, tv->table->col_count );
1892
1893     TRACE("%s one row is %d bytes\n", debugstr_w(name), tv->row_size );
1894
1895     *view = (MSIVIEW*) tv;
1896     lstrcpyW( tv->name, name );
1897
1898     return ERROR_SUCCESS;
1899 }
1900
1901 UINT MSI_CommitTables( MSIDATABASE *db )
1902 {
1903     UINT r;
1904     MSITABLE *table = NULL;
1905
1906     TRACE("%p\n",db);
1907
1908     r = msi_save_string_table( db->strings, db->storage );
1909     if( r != ERROR_SUCCESS )
1910     {
1911         WARN("failed to save string table r=%08x\n",r);
1912         return r;
1913     }
1914
1915     LIST_FOR_EACH_ENTRY( table, &db->tables, MSITABLE, entry )
1916     {
1917         r = save_table( db, table );
1918         if( r != ERROR_SUCCESS )
1919         {
1920             WARN("failed to save table %s (r=%08x)\n",
1921                   debugstr_w(table->name), r);
1922             return r;
1923         }
1924     }
1925
1926     /* force everything to reload next time */
1927     free_cached_tables( db );
1928
1929     return ERROR_SUCCESS;
1930 }
1931
1932 MSICONDITION MSI_DatabaseIsTablePersistent( MSIDATABASE *db, LPCWSTR table )
1933 {
1934     MSITABLE *t;
1935     UINT r;
1936
1937     TRACE("%p %s\n", db, debugstr_w(table));
1938
1939     if (!table)
1940         return MSICONDITION_ERROR;
1941
1942     r = get_table( db, table, &t );
1943     if (r != ERROR_SUCCESS)
1944         return MSICONDITION_NONE;
1945
1946     if (t->persistent)
1947         return MSICONDITION_TRUE;
1948     else
1949         return MSICONDITION_FALSE;
1950 }
1951
1952 static UINT read_raw_int(const BYTE *data, UINT col, UINT bytes)
1953 {
1954     UINT ret = 0, i;
1955
1956     for (i = 0; i < bytes; i++)
1957         ret += (data[col + i] << i * 8);
1958
1959     return ret;
1960 }
1961
1962 static MSIRECORD *msi_get_transform_record( const MSITABLEVIEW *tv, const string_table *st,
1963                                             const BYTE *rawdata, UINT bytes_per_strref )
1964 {
1965     UINT i, val, ofs = 0;
1966     USHORT mask;
1967     MSICOLUMNINFO *columns = tv->columns;
1968     MSIRECORD *rec;
1969
1970     mask = rawdata[0] | (rawdata[1] << 8);
1971     rawdata += 2;
1972
1973     rec = MSI_CreateRecord( tv->num_cols );
1974     if( !rec )
1975         return rec;
1976
1977     TRACE("row ->\n");
1978     for( i=0; i<tv->num_cols; i++ )
1979     {
1980         if ( (mask&1) && (i>=(mask>>8)) )
1981             break;
1982         /* all keys must be present */
1983         if ( (~mask&1) && (~columns[i].type & MSITYPE_KEY) && ((1<<i) & ~mask) )
1984             continue;
1985
1986         if( (columns[i].type & MSITYPE_STRING) &&
1987             ! MSITYPE_IS_BINARY(tv->columns[i].type) )
1988         {
1989             LPCWSTR sval;
1990
1991             val = read_raw_int(rawdata, ofs, bytes_per_strref);
1992             sval = msi_string_lookup_id( st, val );
1993             MSI_RecordSetStringW( rec, i+1, sval );
1994             TRACE(" field %d [%s]\n", i+1, debugstr_w(sval));
1995             ofs += bytes_per_strref;
1996         }
1997         else
1998         {
1999             UINT n = bytes_per_column( &columns[i] );
2000             switch( n )
2001             {
2002             case 2:
2003                 val = read_raw_int(rawdata, ofs, n);
2004                 if (val)
2005                     MSI_RecordSetInteger( rec, i+1, val^0x8000 );
2006                 TRACE(" field %d [0x%04x]\n", i+1, val );
2007                 break;
2008             case 4:
2009                 val = read_raw_int(rawdata, ofs, n);
2010                 if (val)
2011                     MSI_RecordSetInteger( rec, i+1, val^0x80000000 );
2012                 TRACE(" field %d [0x%08x]\n", i+1, val );
2013                 break;
2014             default:
2015                 ERR("oops - unknown column width %d\n", n);
2016                 break;
2017             }
2018             ofs += n;
2019         }
2020     }
2021     return rec;
2022 }
2023
2024 static void dump_record( MSIRECORD *rec )
2025 {
2026     UINT i, n;
2027
2028     n = MSI_RecordGetFieldCount( rec );
2029     for( i=1; i<=n; i++ )
2030     {
2031         LPCWSTR sval = MSI_RecordGetString( rec, i );
2032
2033         if( MSI_RecordIsNull( rec, i ) )
2034             TRACE("row -> []\n");
2035         else if( (sval = MSI_RecordGetString( rec, i )) )
2036             TRACE("row -> [%s]\n", debugstr_w(sval));
2037         else
2038             TRACE("row -> [0x%08x]\n", MSI_RecordGetInteger( rec, i ) );
2039     }
2040 }
2041
2042 static void dump_table( const string_table *st, const USHORT *rawdata, UINT rawsize )
2043 {
2044     LPCWSTR sval;
2045     UINT i;
2046
2047     for( i=0; i<(rawsize/2); i++ )
2048     {
2049         sval = msi_string_lookup_id( st, rawdata[i] );
2050         MESSAGE(" %04x %s\n", rawdata[i], debugstr_w(sval) );
2051     }
2052 }
2053
2054 static UINT* msi_record_to_row( const MSITABLEVIEW *tv, MSIRECORD *rec )
2055 {
2056     LPCWSTR str;
2057     UINT i, r, *data;
2058
2059     data = msi_alloc( tv->num_cols *sizeof (UINT) );
2060     for( i=0; i<tv->num_cols; i++ )
2061     {
2062         data[i] = 0;
2063
2064         if ( ~tv->columns[i].type & MSITYPE_KEY )
2065             continue;
2066
2067         /* turn the transform column value into a row value */
2068         if ( ( tv->columns[i].type & MSITYPE_STRING ) &&
2069              ! MSITYPE_IS_BINARY(tv->columns[i].type) )
2070         {
2071             str = MSI_RecordGetString( rec, i+1 );
2072             r = msi_string2idW( tv->db->strings, str, &data[i] );
2073
2074             /* if there's no matching string in the string table,
2075                these keys can't match any record, so fail now. */
2076             if( ERROR_SUCCESS != r )
2077             {
2078                 msi_free( data );
2079                 return NULL;
2080             }
2081         }
2082         else
2083         {
2084             data[i] = MSI_RecordGetInteger( rec, i+1 );
2085             if ((tv->columns[i].type&0xff) == 2)
2086                 data[i] += 0x8000;
2087             else
2088                 data[i] += 0x80000000;
2089         }
2090     }
2091     return data;
2092 }
2093
2094 static UINT msi_row_matches( MSITABLEVIEW *tv, UINT row, const UINT *data )
2095 {
2096     UINT i, r, x, ret = ERROR_FUNCTION_FAILED;
2097
2098     for( i=0; i<tv->num_cols; i++ )
2099     {
2100         if ( ~tv->columns[i].type & MSITYPE_KEY )
2101             continue;
2102
2103         /* turn the transform column value into a row value */
2104         r = TABLE_fetch_int( &tv->view, row, i+1, &x );
2105         if ( r != ERROR_SUCCESS )
2106         {
2107             ERR("TABLE_fetch_int shouldn't fail here\n");
2108             break;
2109         }
2110
2111         /* if this key matches, move to the next column */
2112         if ( x != data[i] )
2113         {
2114             ret = ERROR_FUNCTION_FAILED;
2115             break;
2116         }
2117
2118         ret = ERROR_SUCCESS;
2119     }
2120
2121     return ret;
2122 }
2123
2124 static UINT msi_table_find_row( MSITABLEVIEW *tv, MSIRECORD *rec, UINT *row )
2125 {
2126     UINT i, r = ERROR_FUNCTION_FAILED, *data;
2127
2128     data = msi_record_to_row( tv, rec );
2129     if( !data )
2130         return r;
2131     for( i = 0; i < tv->table->row_count + tv->table->nonpersistent_row_count; i++ )
2132     {
2133         r = msi_row_matches( tv, i, data );
2134         if( r == ERROR_SUCCESS )
2135         {
2136             *row = i;
2137             break;
2138         }
2139     }
2140     msi_free( data );
2141     return r;
2142 }
2143
2144 typedef struct
2145 {
2146     struct list entry;
2147     LPWSTR name;
2148 } TRANSFORMDATA;
2149
2150 static UINT msi_table_load_transform( MSIDATABASE *db, IStorage *stg,
2151                                       string_table *st, TRANSFORMDATA *transform,
2152                                       UINT bytes_per_strref )
2153 {
2154     UINT rawsize = 0;
2155     BYTE *rawdata = NULL;
2156     MSITABLEVIEW *tv = NULL;
2157     UINT r, n, sz, i, mask;
2158     MSIRECORD *rec = NULL;
2159     UINT colcol = 0;
2160     WCHAR coltable[32];
2161     LPWSTR name;
2162
2163     if (!transform)
2164         return ERROR_SUCCESS;
2165
2166     name = transform->name;
2167
2168     coltable[0] = 0;
2169     TRACE("%p %p %p %s\n", db, stg, st, debugstr_w(name) );
2170
2171     /* read the transform data */
2172     read_stream_data( stg, name, TRUE, &rawdata, &rawsize );
2173     if ( !rawdata )
2174     {
2175         TRACE("table %s empty\n", debugstr_w(name) );
2176         return ERROR_INVALID_TABLE;
2177     }
2178
2179     /* create a table view */
2180     r = TABLE_CreateView( db, name, (MSIVIEW**) &tv );
2181     if( r != ERROR_SUCCESS )
2182         goto err;
2183
2184     r = tv->view.ops->execute( &tv->view, NULL );
2185     if( r != ERROR_SUCCESS )
2186         goto err;
2187
2188     TRACE("name = %s columns = %u row_size = %u raw size = %u\n",
2189           debugstr_w(name), tv->num_cols, tv->row_size, rawsize );
2190
2191     /* interpret the data */
2192     r = ERROR_SUCCESS;
2193     for( n=0; n < rawsize;  )
2194     {
2195         mask = rawdata[n] | (rawdata[n+1] << 8);
2196
2197         if (mask&1)
2198         {
2199             /*
2200              * if the low bit is set, columns are continuous and
2201              * the number of columns is specified in the high byte
2202              */
2203             sz = 2;
2204             for( i=0; i<tv->num_cols; i++ )
2205             {
2206                 if( (tv->columns[i].type & MSITYPE_STRING) &&
2207                     ! MSITYPE_IS_BINARY(tv->columns[i].type) )
2208                     sz += bytes_per_strref;
2209                 else
2210                     sz += bytes_per_column( &tv->columns[i] );
2211             }
2212         }
2213         else
2214         {
2215             /*
2216              * If the low bit is not set, mask is a bitmask.
2217              * Excepting for key fields, which are always present,
2218              *  each bit indicates that a field is present in the transform record.
2219              *
2220              * mask == 0 is a special case ... only the keys will be present
2221              * and it means that this row should be deleted.
2222              */
2223             sz = 2;
2224             for( i=0; i<tv->num_cols; i++ )
2225             {
2226                 if( (tv->columns[i].type & MSITYPE_KEY) || ((1<<i)&mask))
2227                 {
2228                     if( (tv->columns[i].type & MSITYPE_STRING) &&
2229                         ! MSITYPE_IS_BINARY(tv->columns[i].type) )
2230                         sz += bytes_per_strref;
2231                     else
2232                         sz += bytes_per_column( &tv->columns[i] );
2233                 }
2234             }
2235         }
2236
2237         /* check we didn't run of the end of the table */
2238         if ( (n+sz) > rawsize )
2239         {
2240             ERR("borked.\n");
2241             dump_table( st, (USHORT *)rawdata, rawsize );
2242             break;
2243         }
2244
2245         rec = msi_get_transform_record( tv, st, &rawdata[n], bytes_per_strref );
2246         if (rec)
2247         {
2248             if ( mask & 1 )
2249             {
2250                 WCHAR table[32];
2251                 DWORD sz = 32;
2252                 UINT number = MSI_NULL_INTEGER;
2253
2254                 TRACE("inserting record\n");
2255
2256                 if (!lstrcmpW(name, szColumns))
2257                 {
2258                     MSI_RecordGetStringW( rec, 1, table, &sz );
2259                     number = MSI_RecordGetInteger( rec, 2 );
2260
2261                     /*
2262                      * Native msi seems writes nul into the Number (2nd) column of
2263                      * the _Columns table, only when the columns are from a new table
2264                      */
2265                     if ( number == MSI_NULL_INTEGER )
2266                     {
2267                         /* reset the column number on a new table */
2268                         if ( lstrcmpW(coltable, table) )
2269                         {
2270                             colcol = 0;
2271                             lstrcpyW( coltable, table );
2272                         }
2273
2274                         /* fix nul column numbers */
2275                         MSI_RecordSetInteger( rec, 2, ++colcol );
2276                     }
2277                 }
2278
2279                 r = TABLE_insert_row( &tv->view, rec, FALSE );
2280                 if (r != ERROR_SUCCESS)
2281                     ERR("insert row failed\n");
2282
2283                 if ( number != MSI_NULL_INTEGER && !lstrcmpW(name, szColumns) )
2284                     msi_update_table_columns( db, table );
2285             }
2286             else
2287             {
2288                 UINT row = 0;
2289
2290                 r = msi_table_find_row( tv, rec, &row );
2291                 if (r != ERROR_SUCCESS)
2292                     ERR("no matching row to transform\n");
2293                 else if ( mask )
2294                 {
2295                     TRACE("modifying row [%d]:\n", row);
2296                     TABLE_set_row( &tv->view, row, rec, mask );
2297                 }
2298                 else
2299                 {
2300                     TRACE("deleting row [%d]:\n", row);
2301                     TABLE_delete_row( &tv->view, row );
2302                 }
2303             }
2304             if( TRACE_ON(msidb) ) dump_record( rec );
2305             msiobj_release( &rec->hdr );
2306         }
2307
2308         n += sz;
2309     }
2310
2311 err:
2312     /* no need to free the table, it's associated with the database */
2313     msi_free( rawdata );
2314     if( tv )
2315         tv->view.ops->delete( &tv->view );
2316
2317     return ERROR_SUCCESS;
2318 }
2319
2320 /*
2321  * msi_table_apply_transform
2322  *
2323  * Enumerate the table transforms in a transform storage and apply each one.
2324  */
2325 UINT msi_table_apply_transform( MSIDATABASE *db, IStorage *stg )
2326 {
2327     struct list transforms;
2328     IEnumSTATSTG *stgenum = NULL;
2329     TRANSFORMDATA *transform;
2330     TRANSFORMDATA *tables = NULL, *columns = NULL;
2331     HRESULT r;
2332     STATSTG stat;
2333     string_table *strings;
2334     UINT ret = ERROR_FUNCTION_FAILED;
2335     UINT bytes_per_strref;
2336
2337     TRACE("%p %p\n", db, stg );
2338
2339     strings = msi_load_string_table( stg, &bytes_per_strref );
2340     if( !strings )
2341         goto end;
2342
2343     r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
2344     if( FAILED( r ) )
2345         goto end;
2346
2347     list_init(&transforms);
2348
2349     while ( TRUE )
2350     {
2351         MSITABLEVIEW *tv = NULL;
2352         WCHAR name[0x40];
2353         ULONG count = 0;
2354
2355         r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
2356         if ( FAILED( r ) || !count )
2357             break;
2358
2359         decode_streamname( stat.pwcsName, name );
2360         if ( name[0] != 0x4840 )
2361             continue;
2362
2363         if ( !lstrcmpW( name+1, szStringPool ) ||
2364              !lstrcmpW( name+1, szStringData ) )
2365             continue;
2366
2367         transform = msi_alloc_zero( sizeof(TRANSFORMDATA) );
2368         if ( !transform )
2369             break;
2370
2371         list_add_tail( &transforms, &transform->entry );
2372
2373         transform->name = strdupW( name + 1 );
2374
2375         if ( !lstrcmpW( transform->name, szTables ) )
2376             tables = transform;
2377         else if (!lstrcmpW( transform->name, szColumns ) )
2378             columns = transform;
2379
2380         TRACE("transform contains stream %s\n", debugstr_w(name));
2381
2382         /* load the table */
2383         r = TABLE_CreateView( db, transform->name, (MSIVIEW**) &tv );
2384         if( r != ERROR_SUCCESS )
2385             continue;
2386
2387         r = tv->view.ops->execute( &tv->view, NULL );
2388         if( r != ERROR_SUCCESS )
2389         {
2390             tv->view.ops->delete( &tv->view );
2391             continue;
2392         }
2393
2394         tv->view.ops->delete( &tv->view );
2395     }
2396
2397     /*
2398      * Apply _Tables and _Columns transforms first so that
2399      * the table metadata is correct, and empty tables exist.
2400      */
2401     ret = msi_table_load_transform( db, stg, strings, tables, bytes_per_strref );
2402     if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
2403         goto end;
2404
2405     ret = msi_table_load_transform( db, stg, strings, columns, bytes_per_strref );
2406     if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
2407         goto end;
2408
2409     ret = ERROR_SUCCESS;
2410
2411     while ( !list_empty( &transforms ) )
2412     {
2413         transform = LIST_ENTRY( list_head( &transforms ), TRANSFORMDATA, entry );
2414
2415         if ( lstrcmpW( transform->name, szColumns ) &&
2416              lstrcmpW( transform->name, szTables ) &&
2417              ret == ERROR_SUCCESS )
2418         {
2419             ret = msi_table_load_transform( db, stg, strings, transform, bytes_per_strref );
2420         }
2421
2422         list_remove( &transform->entry );
2423         msi_free( transform->name );
2424         msi_free( transform );
2425     }
2426
2427     if ( ret == ERROR_SUCCESS )
2428         append_storage_to_db( db, stg );
2429
2430 end:
2431     if ( stgenum )
2432         IEnumSTATSTG_Release( stgenum );
2433     if ( strings )
2434         msi_destroy_stringtable( strings );
2435
2436     return ret;
2437 }
2438
2439 void append_storage_to_db( MSIDATABASE *db, IStorage *stg )
2440 {
2441     MSITRANSFORM *t;
2442
2443     t = msi_alloc( sizeof *t );
2444     t->stg = stg;
2445     IStorage_AddRef( stg );
2446     list_add_tail( &db->transforms, &t->entry );
2447 }
2448
2449 void msi_free_transforms( MSIDATABASE *db )
2450 {
2451     while( !list_empty( &db->transforms ) )
2452     {
2453         MSITRANSFORM *t = LIST_ENTRY( list_head( &db->transforms ),
2454                                       MSITRANSFORM, entry );
2455         list_remove( &t->entry );
2456         IStorage_Release( t->stg );
2457         msi_free( t );
2458     }
2459 }