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_set_row( struct tagMSIVIEW *view, UINT row, MSIRECORD *rec, UINT mask )
1281 {
1282     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1283     UINT i, val, r = ERROR_SUCCESS;
1284
1285     if ( !tv->table )
1286         return ERROR_INVALID_PARAMETER;
1287
1288     /* test if any of the mask bits are invalid */
1289     if ( mask >= (1<<tv->num_cols) )
1290         return ERROR_INVALID_PARAMETER;
1291
1292     for ( i = 0; i < tv->num_cols; i++ )
1293     {
1294         BOOL persistent;
1295
1296         /* only update the fields specified in the mask */
1297         if ( !(mask&(1<<i)) )
1298             continue;
1299
1300         /* if row >= tv->table->row_count then it is a non-persistent row */
1301         persistent = tv->table->persistent && (row < tv->table->row_count);
1302         /* FIXME: should we allow updating keys? */
1303
1304         val = 0;
1305         if ( !MSI_RecordIsNull( rec, i + 1 ) )
1306         {
1307             if ( MSITYPE_IS_BINARY(tv->columns[ i ].type) )
1308             {
1309                 val = 1; /* refers to the first key column */
1310             }
1311             else if ( tv->columns[i].type & MSITYPE_STRING )
1312             {
1313                 LPCWSTR sval = MSI_RecordGetString( rec, i + 1 );
1314                 val = msi_addstringW( tv->db->strings, 0, sval, -1, 1,
1315                                       persistent ? StringPersistent : StringNonPersistent );
1316             }
1317             else if ( 2 == bytes_per_column( &tv->columns[ i ] ) )
1318             {
1319                 val = 0x8000 + MSI_RecordGetInteger( rec, i + 1 );
1320                 if ( val & 0xffff0000 )
1321                 {
1322                     ERR("field %u value %d out of range\n", i+1, val - 0x8000 );
1323                     return ERROR_FUNCTION_FAILED;
1324                 }
1325             }
1326             else
1327             {
1328                 INT ival = MSI_RecordGetInteger( rec, i + 1 );
1329                 val = ival ^ 0x80000000;
1330             }
1331         }
1332
1333         r = TABLE_set_int( tv, row, i+1, val );
1334         if ( r != ERROR_SUCCESS )
1335             break;
1336     }
1337     return r;
1338 }
1339
1340 static UINT table_create_new_row( struct tagMSIVIEW *view, UINT *num, BOOL temporary )
1341 {
1342     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1343     BYTE **p, *row;
1344     UINT sz;
1345     BYTE ***data_ptr;
1346     UINT *row_count;
1347
1348     TRACE("%p %s\n", view, temporary ? "TRUE" : "FALSE");
1349
1350     if( !tv->table )
1351         return ERROR_INVALID_PARAMETER;
1352
1353     row = msi_alloc_zero( tv->row_size );
1354     if( !row )
1355         return ERROR_NOT_ENOUGH_MEMORY;
1356
1357     if( temporary )
1358     {
1359         row_count = &tv->table->nonpersistent_row_count;
1360         data_ptr = &tv->table->nonpersistent_data;
1361         *num = tv->table->row_count + tv->table->nonpersistent_row_count;
1362     }
1363     else
1364     {
1365         row_count = &tv->table->row_count;
1366         data_ptr = &tv->table->data;
1367         *num = tv->table->row_count;
1368     }
1369
1370     sz = (*row_count + 1) * sizeof (BYTE*);
1371     if( *data_ptr )
1372         p = msi_realloc( *data_ptr, sz );
1373     else
1374         p = msi_alloc( sz );
1375     if( !p )
1376     {
1377         msi_free( row );
1378         return ERROR_NOT_ENOUGH_MEMORY;
1379     }
1380
1381     *data_ptr = p;
1382     (*data_ptr)[*row_count] = row;
1383     (*row_count)++;
1384
1385     return ERROR_SUCCESS;
1386 }
1387
1388 static UINT TABLE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
1389 {
1390     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1391
1392     TRACE("%p %p\n", tv, record);
1393
1394     TRACE("There are %d columns\n", tv->num_cols );
1395
1396     return ERROR_SUCCESS;
1397 }
1398
1399 static UINT TABLE_close( struct tagMSIVIEW *view )
1400 {
1401     TRACE("%p\n", view );
1402
1403     return ERROR_SUCCESS;
1404 }
1405
1406 static UINT TABLE_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols)
1407 {
1408     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1409
1410     TRACE("%p %p %p\n", view, rows, cols );
1411
1412     if( cols )
1413         *cols = tv->num_cols;
1414     if( rows )
1415     {
1416         if( !tv->table )
1417             return ERROR_INVALID_PARAMETER;
1418         *rows = tv->table->row_count + tv->table->nonpersistent_row_count;
1419     }
1420
1421     return ERROR_SUCCESS;
1422 }
1423
1424 static UINT TABLE_get_column_info( struct tagMSIVIEW *view,
1425                 UINT n, LPWSTR *name, UINT *type )
1426 {
1427     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1428
1429     TRACE("%p %d %p %p\n", tv, n, name, type );
1430
1431     if( ( n == 0 ) || ( n > tv->num_cols ) )
1432         return ERROR_INVALID_PARAMETER;
1433
1434     if( name )
1435     {
1436         *name = strdupW( tv->columns[n-1].colname );
1437         if( !*name )
1438             return ERROR_FUNCTION_FAILED;
1439     }
1440     if( type )
1441         *type = tv->columns[n-1].type;
1442
1443     return ERROR_SUCCESS;
1444 }
1445
1446 static UINT msi_table_find_row( MSITABLEVIEW *tv, MSIRECORD *rec, UINT *row );
1447
1448 static UINT table_validate_new( MSITABLEVIEW *tv, MSIRECORD *rec )
1449 {
1450     UINT r, row, i;
1451
1452     /* check there's no null values where they're not allowed */
1453     for( i = 0; i < tv->num_cols; i++ )
1454     {
1455         if ( tv->columns[i].type & MSITYPE_NULLABLE )
1456             continue;
1457
1458         if ( MSITYPE_IS_BINARY(tv->columns[i].type) )
1459             TRACE("skipping binary column\n");
1460         else if ( tv->columns[i].type & MSITYPE_STRING )
1461         {
1462             LPCWSTR str;
1463
1464             str = MSI_RecordGetString( rec, i+1 );
1465             if (str == NULL || str[0] == 0)
1466                 return ERROR_INVALID_DATA;
1467         }
1468         else
1469         {
1470             UINT n;
1471
1472             n = MSI_RecordGetInteger( rec, i+1 );
1473             if (n == MSI_NULL_INTEGER)
1474                 return ERROR_INVALID_DATA;
1475         }
1476     }
1477
1478     /* check there's no duplicate keys */
1479     r = msi_table_find_row( tv, rec, &row );
1480     if (r == ERROR_SUCCESS)
1481         return ERROR_INVALID_DATA;
1482
1483     return ERROR_SUCCESS;
1484 }
1485
1486 static UINT TABLE_insert_row( struct tagMSIVIEW *view, MSIRECORD *rec, BOOL temporary )
1487 {
1488     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1489     UINT r, row = -1;
1490
1491     TRACE("%p %p %s\n", tv, rec, temporary ? "TRUE" : "FALSE" );
1492
1493     /* check that the key is unique - can we find a matching row? */
1494     r = table_validate_new( tv, rec );
1495     if( r != ERROR_SUCCESS )
1496         return ERROR_FUNCTION_FAILED;
1497
1498     r = table_create_new_row( view, &row, temporary );
1499     TRACE("insert_row returned %08x\n", r);
1500     if( r != ERROR_SUCCESS )
1501         return r;
1502
1503     return TABLE_set_row( view, row, rec, (1<<tv->num_cols) - 1 );
1504 }
1505
1506 static UINT TABLE_delete_row( struct tagMSIVIEW *view, UINT row )
1507 {
1508     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1509     UINT r, num_rows, num_cols;
1510     BYTE *src, *dest;
1511
1512     TRACE("%p %d\n", tv, row);
1513
1514     if ( !tv->table )
1515         return ERROR_INVALID_PARAMETER;
1516
1517     r = TABLE_get_dimensions( view, &num_rows, &num_cols );
1518     if ( r != ERROR_SUCCESS )
1519         return r;
1520
1521     if ( row >= num_rows )
1522         return ERROR_FUNCTION_FAILED;
1523
1524     tv->table->row_count--;
1525
1526     if ( row == num_rows - 1 )
1527         return ERROR_SUCCESS;
1528
1529     dest = tv->table->data[row];
1530     src = tv->table->data[row + 1];
1531     memmove(dest, src, (num_rows - row - 1) * tv->row_size);
1532     return ERROR_SUCCESS;
1533 }
1534
1535 static UINT TABLE_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode,
1536                 MSIRECORD *rec)
1537 {
1538     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1539     UINT r;
1540
1541     TRACE("%p %d %p\n", view, eModifyMode, rec );
1542
1543     switch (eModifyMode)
1544     {
1545     case MSIMODIFY_VALIDATE_NEW:
1546         r = table_validate_new( tv, rec );
1547         break;
1548
1549     case MSIMODIFY_INSERT_TEMPORARY:
1550         r = table_validate_new( tv, rec );
1551         if (r != ERROR_SUCCESS)
1552             break;
1553         r = TABLE_insert_row( view, rec, TRUE );
1554         break;
1555
1556     case MSIMODIFY_REFRESH:
1557     case MSIMODIFY_INSERT:
1558     case MSIMODIFY_UPDATE:
1559     case MSIMODIFY_ASSIGN:
1560     case MSIMODIFY_REPLACE:
1561     case MSIMODIFY_MERGE:
1562     case MSIMODIFY_DELETE:
1563     case MSIMODIFY_VALIDATE:
1564     case MSIMODIFY_VALIDATE_FIELD:
1565     case MSIMODIFY_VALIDATE_DELETE:
1566         FIXME("%p %d %p - mode not implemented\n", view, eModifyMode, rec );
1567         r = ERROR_CALL_NOT_IMPLEMENTED;
1568         break;
1569
1570     default:
1571         r = ERROR_INVALID_DATA;
1572     }
1573
1574     return r;
1575 }
1576
1577 static UINT TABLE_delete( struct tagMSIVIEW *view )
1578 {
1579     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1580
1581     TRACE("%p\n", view );
1582
1583     tv->table = NULL;
1584
1585     tv->columns = NULL;
1586
1587     msi_free( tv );
1588
1589     return ERROR_SUCCESS;
1590 }
1591
1592 static UINT TABLE_find_matching_rows( struct tagMSIVIEW *view, UINT col,
1593     UINT val, UINT *row, MSIITERHANDLE *handle )
1594 {
1595     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1596     const MSICOLUMNHASHENTRY *entry;
1597
1598     TRACE("%p, %d, %u, %p\n", view, col, val, *handle);
1599
1600     if( !tv->table )
1601         return ERROR_INVALID_PARAMETER;
1602
1603     if( (col==0) || (col > tv->num_cols) )
1604         return ERROR_INVALID_PARAMETER;
1605
1606     if( !tv->columns[col-1].hash_table )
1607     {
1608         UINT i;
1609         UINT num_rows = tv->table->row_count + tv->table->nonpersistent_row_count;
1610         MSICOLUMNHASHENTRY **hash_table;
1611         MSICOLUMNHASHENTRY *new_entry;
1612
1613         if( tv->columns[col-1].offset >= tv->row_size )
1614         {
1615             ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1616             ERR("%p %p\n", tv, tv->columns );
1617             return ERROR_FUNCTION_FAILED;
1618         }
1619
1620         /* allocate contiguous memory for the table and its entries so we
1621          * don't have to do an expensive cleanup */
1622         hash_table = msi_alloc(MSITABLE_HASH_TABLE_SIZE * sizeof(MSICOLUMNHASHENTRY*) +
1623             num_rows * sizeof(MSICOLUMNHASHENTRY));
1624         if (!hash_table)
1625             return ERROR_OUTOFMEMORY;
1626
1627         memset(hash_table, 0, MSITABLE_HASH_TABLE_SIZE * sizeof(MSICOLUMNHASHENTRY*));
1628         tv->columns[col-1].hash_table = hash_table;
1629
1630         new_entry = (MSICOLUMNHASHENTRY *)(hash_table + MSITABLE_HASH_TABLE_SIZE);
1631
1632         for (i = 0; i < num_rows; i++, new_entry++)
1633         {
1634             UINT row_value;
1635
1636             if (view->ops->fetch_int( view, i, col, &row_value ) != ERROR_SUCCESS)
1637                 continue;
1638
1639             new_entry->next = NULL;
1640             new_entry->value = row_value;
1641             new_entry->row = i;
1642             if (hash_table[row_value % MSITABLE_HASH_TABLE_SIZE])
1643             {
1644                 MSICOLUMNHASHENTRY *prev_entry = hash_table[row_value % MSITABLE_HASH_TABLE_SIZE];
1645                 while (prev_entry->next)
1646                     prev_entry = prev_entry->next;
1647                 prev_entry->next = new_entry;
1648             }
1649             else
1650                 hash_table[row_value % MSITABLE_HASH_TABLE_SIZE] = new_entry;
1651         }
1652     }
1653
1654     if( !*handle )
1655         entry = tv->columns[col-1].hash_table[val % MSITABLE_HASH_TABLE_SIZE];
1656     else
1657         entry = (*handle)->next;
1658
1659     while (entry && entry->value != val)
1660         entry = entry->next;
1661
1662     *handle = entry;
1663     if (!entry)
1664         return ERROR_NO_MORE_ITEMS;
1665
1666     *row = entry->row;
1667     return ERROR_SUCCESS;
1668 }
1669
1670 static UINT TABLE_add_ref(struct tagMSIVIEW *view)
1671 {
1672     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1673     int i;
1674
1675     TRACE("%p %d\n", view, tv->table->ref_count);
1676
1677     for (i = 0; i < tv->table->col_count; i++)
1678     {
1679         if (tv->table->colinfo[i].type & MSITYPE_TEMPORARY)
1680             InterlockedIncrement(&tv->table->colinfo[i].ref_count);
1681     }
1682
1683     return InterlockedIncrement(&tv->table->ref_count);
1684 }
1685
1686 static UINT TABLE_remove_column(struct tagMSIVIEW *view, LPCWSTR table, UINT number)
1687 {
1688     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1689     MSIRECORD *rec;
1690     MSIVIEW *columns = NULL;
1691     UINT row, r;
1692
1693     rec = MSI_CreateRecord(2);
1694     if (!rec)
1695         return ERROR_OUTOFMEMORY;
1696
1697     MSI_RecordSetStringW(rec, 1, table);
1698     MSI_RecordSetInteger(rec, 2, number);
1699
1700     r = TABLE_CreateView(tv->db, szColumns, &columns);
1701     if (r != ERROR_SUCCESS)
1702         return r;
1703
1704     r = msi_table_find_row((MSITABLEVIEW *)columns, rec, &row);
1705     if (r != ERROR_SUCCESS)
1706         goto done;
1707
1708     r = TABLE_delete_row(columns, row);
1709     if (r != ERROR_SUCCESS)
1710         goto done;
1711
1712     msi_update_table_columns(tv->db, table);
1713
1714 done:
1715     msiobj_release(&rec->hdr);
1716     if (columns) msiobj_release(&columns->hdr);
1717     return r;
1718 }
1719
1720 static UINT TABLE_release(struct tagMSIVIEW *view)
1721 {
1722     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1723     INT ref = tv->table->ref_count;
1724     int i;
1725     UINT r;
1726
1727     TRACE("%p %d\n", view, ref);
1728
1729     for (i = 0; i < tv->table->col_count; i++)
1730     {
1731         if (tv->table->colinfo[i].type & MSITYPE_TEMPORARY)
1732         {
1733             ref = InterlockedDecrement(&tv->table->colinfo[i].ref_count);
1734             if (ref == 0)
1735             {
1736                 r = TABLE_remove_column(view, tv->table->colinfo[i].tablename,
1737                                         tv->table->colinfo[i].number);
1738                 if (r != ERROR_SUCCESS)
1739                     break;
1740             }
1741         }
1742     }
1743
1744     ref = InterlockedDecrement(&tv->table->ref_count);
1745     if (ref == 0)
1746     {
1747         if (!tv->table->row_count)
1748         {
1749             list_remove(&tv->table->entry);
1750             free_table(tv->table);
1751             TABLE_delete(view);
1752         }
1753     }
1754
1755     return ref;
1756 }
1757
1758 static UINT TABLE_add_column(struct tagMSIVIEW *view, LPCWSTR table, UINT number,
1759                              LPCWSTR column, UINT type, BOOL hold)
1760 {
1761     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1762     MSITABLE *msitable;
1763     MSIRECORD *rec;
1764     UINT r, i;
1765
1766     rec = MSI_CreateRecord(4);
1767     if (!rec)
1768         return ERROR_OUTOFMEMORY;
1769
1770     MSI_RecordSetStringW(rec, 1, table);
1771     MSI_RecordSetInteger(rec, 2, number);
1772     MSI_RecordSetStringW(rec, 3, column);
1773     MSI_RecordSetInteger(rec, 4, type);
1774
1775     r = TABLE_insert_row(&tv->view, rec, FALSE);
1776     if (r != ERROR_SUCCESS)
1777         goto done;
1778
1779     msi_update_table_columns(tv->db, table);
1780
1781     if (!hold)
1782         goto done;
1783
1784     msitable = find_cached_table(tv->db, table);
1785     for (i = 0; i < msitable->col_count; i++)
1786     {
1787         if (!lstrcmpW(msitable->colinfo[i].colname, column))
1788         {
1789             InterlockedIncrement(&msitable->colinfo[i].ref_count);
1790             break;
1791         }
1792     }
1793
1794 done:
1795     msiobj_release(&rec->hdr);
1796     return r;
1797 }
1798
1799 static const MSIVIEWOPS table_ops =
1800 {
1801     TABLE_fetch_int,
1802     TABLE_fetch_stream,
1803     TABLE_set_row,
1804     TABLE_insert_row,
1805     TABLE_delete_row,
1806     TABLE_execute,
1807     TABLE_close,
1808     TABLE_get_dimensions,
1809     TABLE_get_column_info,
1810     TABLE_modify,
1811     TABLE_delete,
1812     TABLE_find_matching_rows,
1813     TABLE_add_ref,
1814     TABLE_release,
1815     TABLE_add_column,
1816     TABLE_remove_column,
1817 };
1818
1819 UINT TABLE_CreateView( MSIDATABASE *db, LPCWSTR name, MSIVIEW **view )
1820 {
1821     MSITABLEVIEW *tv ;
1822     UINT r, sz;
1823
1824     static const WCHAR Streams[] = {'_','S','t','r','e','a','m','s',0};
1825
1826     TRACE("%p %s %p\n", db, debugstr_w(name), view );
1827
1828     if ( !lstrcmpW( name, Streams ) )
1829         return STREAMS_CreateView( db, view );
1830
1831     sz = sizeof *tv + lstrlenW(name)*sizeof name[0] ;
1832     tv = msi_alloc_zero( sz );
1833     if( !tv )
1834         return ERROR_FUNCTION_FAILED;
1835
1836     r = get_table( db, name, &tv->table );
1837     if( r != ERROR_SUCCESS )
1838     {
1839         msi_free( tv );
1840         WARN("table not found\n");
1841         return r;
1842     }
1843
1844     TRACE("table %p found with %d columns\n", tv->table, tv->table->col_count);
1845
1846     /* fill the structure */
1847     tv->view.ops = &table_ops;
1848     tv->db = db;
1849     tv->columns = tv->table->colinfo;
1850     tv->num_cols = tv->table->col_count;
1851     tv->row_size = msi_table_get_row_size( tv->table->colinfo, tv->table->col_count );
1852
1853     TRACE("%s one row is %d bytes\n", debugstr_w(name), tv->row_size );
1854
1855     *view = (MSIVIEW*) tv;
1856     lstrcpyW( tv->name, name );
1857
1858     return ERROR_SUCCESS;
1859 }
1860
1861 UINT MSI_CommitTables( MSIDATABASE *db )
1862 {
1863     UINT r;
1864     MSITABLE *table = NULL;
1865
1866     TRACE("%p\n",db);
1867
1868     r = msi_save_string_table( db->strings, db->storage );
1869     if( r != ERROR_SUCCESS )
1870     {
1871         WARN("failed to save string table r=%08x\n",r);
1872         return r;
1873     }
1874
1875     LIST_FOR_EACH_ENTRY( table, &db->tables, MSITABLE, entry )
1876     {
1877         r = save_table( db, table );
1878         if( r != ERROR_SUCCESS )
1879         {
1880             WARN("failed to save table %s (r=%08x)\n",
1881                   debugstr_w(table->name), r);
1882             return r;
1883         }
1884     }
1885
1886     /* force everything to reload next time */
1887     free_cached_tables( db );
1888
1889     return ERROR_SUCCESS;
1890 }
1891
1892 MSICONDITION MSI_DatabaseIsTablePersistent( MSIDATABASE *db, LPCWSTR table )
1893 {
1894     MSITABLE *t;
1895     UINT r;
1896
1897     TRACE("%p %s\n", db, debugstr_w(table));
1898
1899     if (!table)
1900         return MSICONDITION_ERROR;
1901
1902     r = get_table( db, table, &t );
1903     if (r != ERROR_SUCCESS)
1904         return MSICONDITION_NONE;
1905
1906     if (t->persistent)
1907         return MSICONDITION_TRUE;
1908     else
1909         return MSICONDITION_FALSE;
1910 }
1911
1912 static UINT read_raw_int(const BYTE *data, UINT col, UINT bytes)
1913 {
1914     UINT ret = 0, i;
1915
1916     for (i = 0; i < bytes; i++)
1917         ret += (data[col + i] << i * 8);
1918
1919     return ret;
1920 }
1921
1922 static MSIRECORD *msi_get_transform_record( const MSITABLEVIEW *tv, const string_table *st,
1923                                             const BYTE *rawdata, UINT bytes_per_strref )
1924 {
1925     UINT i, val, ofs = 0;
1926     USHORT mask;
1927     MSICOLUMNINFO *columns = tv->columns;
1928     MSIRECORD *rec;
1929
1930     mask = rawdata[0] | (rawdata[1] << 8);
1931     rawdata += 2;
1932
1933     rec = MSI_CreateRecord( tv->num_cols );
1934     if( !rec )
1935         return rec;
1936
1937     TRACE("row ->\n");
1938     for( i=0; i<tv->num_cols; i++ )
1939     {
1940         if ( (mask&1) && (i>=(mask>>8)) )
1941             break;
1942         /* all keys must be present */
1943         if ( (~mask&1) && (~columns[i].type & MSITYPE_KEY) && ((1<<i) & ~mask) )
1944             continue;
1945
1946         if( (columns[i].type & MSITYPE_STRING) &&
1947             ! MSITYPE_IS_BINARY(tv->columns[i].type) )
1948         {
1949             LPCWSTR sval;
1950
1951             val = read_raw_int(rawdata, ofs, bytes_per_strref);
1952             sval = msi_string_lookup_id( st, val );
1953             MSI_RecordSetStringW( rec, i+1, sval );
1954             TRACE(" field %d [%s]\n", i+1, debugstr_w(sval));
1955             ofs += bytes_per_strref;
1956         }
1957         else
1958         {
1959             UINT n = bytes_per_column( &columns[i] );
1960             switch( n )
1961             {
1962             case 2:
1963                 val = read_raw_int(rawdata, ofs, n);
1964                 if (val)
1965                     MSI_RecordSetInteger( rec, i+1, val^0x8000 );
1966                 TRACE(" field %d [0x%04x]\n", i+1, val );
1967                 break;
1968             case 4:
1969                 val = read_raw_int(rawdata, ofs, n);
1970                 if (val)
1971                     MSI_RecordSetInteger( rec, i+1, val^0x80000000 );
1972                 TRACE(" field %d [0x%08x]\n", i+1, val );
1973                 break;
1974             default:
1975                 ERR("oops - unknown column width %d\n", n);
1976                 break;
1977             }
1978             ofs += n;
1979         }
1980     }
1981     return rec;
1982 }
1983
1984 static void dump_record( MSIRECORD *rec )
1985 {
1986     UINT i, n;
1987
1988     n = MSI_RecordGetFieldCount( rec );
1989     for( i=1; i<=n; i++ )
1990     {
1991         LPCWSTR sval = MSI_RecordGetString( rec, i );
1992
1993         if( MSI_RecordIsNull( rec, i ) )
1994             TRACE("row -> []\n");
1995         else if( (sval = MSI_RecordGetString( rec, i )) )
1996             TRACE("row -> [%s]\n", debugstr_w(sval));
1997         else
1998             TRACE("row -> [0x%08x]\n", MSI_RecordGetInteger( rec, i ) );
1999     }
2000 }
2001
2002 static void dump_table( const string_table *st, const USHORT *rawdata, UINT rawsize )
2003 {
2004     LPCWSTR sval;
2005     UINT i;
2006
2007     for( i=0; i<(rawsize/2); i++ )
2008     {
2009         sval = msi_string_lookup_id( st, rawdata[i] );
2010         MESSAGE(" %04x %s\n", rawdata[i], debugstr_w(sval) );
2011     }
2012 }
2013
2014 static UINT* msi_record_to_row( const MSITABLEVIEW *tv, MSIRECORD *rec )
2015 {
2016     LPCWSTR str;
2017     UINT i, r, *data;
2018
2019     data = msi_alloc( tv->num_cols *sizeof (UINT) );
2020     for( i=0; i<tv->num_cols; i++ )
2021     {
2022         data[i] = 0;
2023
2024         if ( ~tv->columns[i].type & MSITYPE_KEY )
2025             continue;
2026
2027         /* turn the transform column value into a row value */
2028         if ( ( tv->columns[i].type & MSITYPE_STRING ) &&
2029              ! MSITYPE_IS_BINARY(tv->columns[i].type) )
2030         {
2031             str = MSI_RecordGetString( rec, i+1 );
2032             r = msi_string2idW( tv->db->strings, str, &data[i] );
2033
2034             /* if there's no matching string in the string table,
2035                these keys can't match any record, so fail now. */
2036             if( ERROR_SUCCESS != r )
2037             {
2038                 msi_free( data );
2039                 return NULL;
2040             }
2041         }
2042         else
2043         {
2044             data[i] = MSI_RecordGetInteger( rec, i+1 );
2045             if ((tv->columns[i].type&0xff) == 2)
2046                 data[i] += 0x8000;
2047             else
2048                 data[i] += 0x80000000;
2049         }
2050     }
2051     return data;
2052 }
2053
2054 static UINT msi_row_matches( MSITABLEVIEW *tv, UINT row, const UINT *data )
2055 {
2056     UINT i, r, x, ret = ERROR_FUNCTION_FAILED;
2057
2058     for( i=0; i<tv->num_cols; i++ )
2059     {
2060         if ( ~tv->columns[i].type & MSITYPE_KEY )
2061             continue;
2062
2063         /* turn the transform column value into a row value */
2064         r = TABLE_fetch_int( &tv->view, row, i+1, &x );
2065         if ( r != ERROR_SUCCESS )
2066         {
2067             ERR("TABLE_fetch_int shouldn't fail here\n");
2068             break;
2069         }
2070
2071         /* if this key matches, move to the next column */
2072         if ( x != data[i] )
2073         {
2074             ret = ERROR_FUNCTION_FAILED;
2075             break;
2076         }
2077
2078         ret = ERROR_SUCCESS;
2079     }
2080
2081     return ret;
2082 }
2083
2084 static UINT msi_table_find_row( MSITABLEVIEW *tv, MSIRECORD *rec, UINT *row )
2085 {
2086     UINT i, r = ERROR_FUNCTION_FAILED, *data;
2087
2088     data = msi_record_to_row( tv, rec );
2089     if( !data )
2090         return r;
2091     for( i = 0; i < tv->table->row_count + tv->table->nonpersistent_row_count; i++ )
2092     {
2093         r = msi_row_matches( tv, i, data );
2094         if( r == ERROR_SUCCESS )
2095         {
2096             *row = i;
2097             break;
2098         }
2099     }
2100     msi_free( data );
2101     return r;
2102 }
2103
2104 typedef struct
2105 {
2106     struct list entry;
2107     LPWSTR name;
2108 } TRANSFORMDATA;
2109
2110 static UINT msi_table_load_transform( MSIDATABASE *db, IStorage *stg,
2111                                       string_table *st, TRANSFORMDATA *transform,
2112                                       UINT bytes_per_strref )
2113 {
2114     UINT rawsize = 0;
2115     BYTE *rawdata = NULL;
2116     MSITABLEVIEW *tv = NULL;
2117     UINT r, n, sz, i, mask;
2118     MSIRECORD *rec = NULL;
2119     UINT colcol = 0;
2120     WCHAR coltable[32];
2121     LPWSTR name;
2122
2123     if (!transform)
2124         return ERROR_SUCCESS;
2125
2126     name = transform->name;
2127
2128     coltable[0] = 0;
2129     TRACE("%p %p %p %s\n", db, stg, st, debugstr_w(name) );
2130
2131     /* read the transform data */
2132     read_stream_data( stg, name, TRUE, &rawdata, &rawsize );
2133     if ( !rawdata )
2134     {
2135         TRACE("table %s empty\n", debugstr_w(name) );
2136         return ERROR_INVALID_TABLE;
2137     }
2138
2139     /* create a table view */
2140     r = TABLE_CreateView( db, name, (MSIVIEW**) &tv );
2141     if( r != ERROR_SUCCESS )
2142         goto err;
2143
2144     r = tv->view.ops->execute( &tv->view, NULL );
2145     if( r != ERROR_SUCCESS )
2146         goto err;
2147
2148     TRACE("name = %s columns = %u row_size = %u raw size = %u\n",
2149           debugstr_w(name), tv->num_cols, tv->row_size, rawsize );
2150
2151     /* interpret the data */
2152     r = ERROR_SUCCESS;
2153     for( n=0; n < rawsize;  )
2154     {
2155         mask = rawdata[n] | (rawdata[n+1] << 8);
2156
2157         if (mask&1)
2158         {
2159             /*
2160              * if the low bit is set, columns are continuous and
2161              * the number of columns is specified in the high byte
2162              */
2163             sz = 2;
2164             for( i=0; i<tv->num_cols; i++ )
2165             {
2166                 if( (tv->columns[i].type & MSITYPE_STRING) &&
2167                     ! MSITYPE_IS_BINARY(tv->columns[i].type) )
2168                     sz += bytes_per_strref;
2169                 else
2170                     sz += bytes_per_column( &tv->columns[i] );
2171             }
2172         }
2173         else
2174         {
2175             /*
2176              * If the low bit is not set, mask is a bitmask.
2177              * Excepting for key fields, which are always present,
2178              *  each bit indicates that a field is present in the transform record.
2179              *
2180              * mask == 0 is a special case ... only the keys will be present
2181              * and it means that this row should be deleted.
2182              */
2183             sz = 2;
2184             for( i=0; i<tv->num_cols; i++ )
2185             {
2186                 if( (tv->columns[i].type & MSITYPE_KEY) || ((1<<i)&mask))
2187                 {
2188                     if( (tv->columns[i].type & MSITYPE_STRING) &&
2189                         ! MSITYPE_IS_BINARY(tv->columns[i].type) )
2190                         sz += bytes_per_strref;
2191                     else
2192                         sz += bytes_per_column( &tv->columns[i] );
2193                 }
2194             }
2195         }
2196
2197         /* check we didn't run of the end of the table */
2198         if ( (n+sz) > rawsize )
2199         {
2200             ERR("borked.\n");
2201             dump_table( st, (USHORT *)rawdata, rawsize );
2202             break;
2203         }
2204
2205         rec = msi_get_transform_record( tv, st, &rawdata[n], bytes_per_strref );
2206         if (rec)
2207         {
2208             if ( mask & 1 )
2209             {
2210                 WCHAR table[32];
2211                 DWORD sz = 32;
2212                 UINT number = MSI_NULL_INTEGER;
2213
2214                 TRACE("inserting record\n");
2215
2216                 if (!lstrcmpW(name, szColumns))
2217                 {
2218                     MSI_RecordGetStringW( rec, 1, table, &sz );
2219                     number = MSI_RecordGetInteger( rec, 2 );
2220
2221                     /*
2222                      * Native msi seems writes nul into the Number (2nd) column of
2223                      * the _Columns table, only when the columns are from a new table
2224                      */
2225                     if ( number == MSI_NULL_INTEGER )
2226                     {
2227                         /* reset the column number on a new table */
2228                         if ( lstrcmpW(coltable, table) )
2229                         {
2230                             colcol = 0;
2231                             lstrcpyW( coltable, table );
2232                         }
2233
2234                         /* fix nul column numbers */
2235                         MSI_RecordSetInteger( rec, 2, ++colcol );
2236                     }
2237                 }
2238
2239                 r = TABLE_insert_row( &tv->view, rec, FALSE );
2240                 if (r != ERROR_SUCCESS)
2241                     ERR("insert row failed\n");
2242
2243                 if ( number != MSI_NULL_INTEGER && !lstrcmpW(name, szColumns) )
2244                     msi_update_table_columns( db, table );
2245             }
2246             else
2247             {
2248                 UINT row = 0;
2249
2250                 r = msi_table_find_row( tv, rec, &row );
2251                 if (r != ERROR_SUCCESS)
2252                     ERR("no matching row to transform\n");
2253                 else if ( mask )
2254                 {
2255                     TRACE("modifying row [%d]:\n", row);
2256                     TABLE_set_row( &tv->view, row, rec, mask );
2257                 }
2258                 else
2259                 {
2260                     TRACE("deleting row [%d]:\n", row);
2261                     TABLE_delete_row( &tv->view, row );
2262                 }
2263             }
2264             if( TRACE_ON(msidb) ) dump_record( rec );
2265             msiobj_release( &rec->hdr );
2266         }
2267
2268         n += sz;
2269     }
2270
2271 err:
2272     /* no need to free the table, it's associated with the database */
2273     msi_free( rawdata );
2274     if( tv )
2275         tv->view.ops->delete( &tv->view );
2276
2277     return ERROR_SUCCESS;
2278 }
2279
2280 /*
2281  * msi_table_apply_transform
2282  *
2283  * Enumerate the table transforms in a transform storage and apply each one.
2284  */
2285 UINT msi_table_apply_transform( MSIDATABASE *db, IStorage *stg )
2286 {
2287     struct list transforms;
2288     IEnumSTATSTG *stgenum = NULL;
2289     TRANSFORMDATA *transform;
2290     TRANSFORMDATA *tables = NULL, *columns = NULL;
2291     HRESULT r;
2292     STATSTG stat;
2293     string_table *strings;
2294     UINT ret = ERROR_FUNCTION_FAILED;
2295     UINT bytes_per_strref;
2296
2297     TRACE("%p %p\n", db, stg );
2298
2299     strings = msi_load_string_table( stg, &bytes_per_strref );
2300     if( !strings )
2301         goto end;
2302
2303     r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
2304     if( FAILED( r ) )
2305         goto end;
2306
2307     list_init(&transforms);
2308
2309     while ( TRUE )
2310     {
2311         MSITABLEVIEW *tv = NULL;
2312         WCHAR name[0x40];
2313         ULONG count = 0;
2314
2315         r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
2316         if ( FAILED( r ) || !count )
2317             break;
2318
2319         decode_streamname( stat.pwcsName, name );
2320         if ( name[0] != 0x4840 )
2321             continue;
2322
2323         if ( !lstrcmpW( name+1, szStringPool ) ||
2324              !lstrcmpW( name+1, szStringData ) )
2325             continue;
2326
2327         transform = msi_alloc_zero( sizeof(TRANSFORMDATA) );
2328         if ( !transform )
2329             break;
2330
2331         list_add_tail( &transforms, &transform->entry );
2332
2333         transform->name = strdupW( name + 1 );
2334
2335         if ( !lstrcmpW( transform->name, szTables ) )
2336             tables = transform;
2337         else if (!lstrcmpW( transform->name, szColumns ) )
2338             columns = transform;
2339
2340         TRACE("transform contains stream %s\n", debugstr_w(name));
2341
2342         /* load the table */
2343         r = TABLE_CreateView( db, transform->name, (MSIVIEW**) &tv );
2344         if( r != ERROR_SUCCESS )
2345             continue;
2346
2347         r = tv->view.ops->execute( &tv->view, NULL );
2348         if( r != ERROR_SUCCESS )
2349         {
2350             tv->view.ops->delete( &tv->view );
2351             continue;
2352         }
2353
2354         tv->view.ops->delete( &tv->view );
2355     }
2356
2357     /*
2358      * Apply _Tables and _Columns transforms first so that
2359      * the table metadata is correct, and empty tables exist.
2360      */
2361     ret = msi_table_load_transform( db, stg, strings, tables, bytes_per_strref );
2362     if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
2363         goto end;
2364
2365     ret = msi_table_load_transform( db, stg, strings, columns, bytes_per_strref );
2366     if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
2367         goto end;
2368
2369     ret = ERROR_SUCCESS;
2370
2371     while ( !list_empty( &transforms ) )
2372     {
2373         transform = LIST_ENTRY( list_head( &transforms ), TRANSFORMDATA, entry );
2374
2375         if ( lstrcmpW( transform->name, szColumns ) &&
2376              lstrcmpW( transform->name, szTables ) &&
2377              ret == ERROR_SUCCESS )
2378         {
2379             ret = msi_table_load_transform( db, stg, strings, transform, bytes_per_strref );
2380         }
2381
2382         list_remove( &transform->entry );
2383         msi_free( transform->name );
2384         msi_free( transform );
2385     }
2386
2387     if ( ret == ERROR_SUCCESS )
2388         append_storage_to_db( db, stg );
2389
2390 end:
2391     if ( stgenum )
2392         IEnumSTATSTG_Release( stgenum );
2393     if ( strings )
2394         msi_destroy_stringtable( strings );
2395
2396     return ret;
2397 }
2398
2399 void append_storage_to_db( MSIDATABASE *db, IStorage *stg )
2400 {
2401     MSITRANSFORM *t;
2402
2403     t = msi_alloc( sizeof *t );
2404     t->stg = stg;
2405     IStorage_AddRef( stg );
2406     list_add_tail( &db->transforms, &t->entry );
2407 }
2408
2409 void msi_free_transforms( MSIDATABASE *db )
2410 {
2411     while( !list_empty( &db->transforms ) )
2412     {
2413         MSITRANSFORM *t = LIST_ENTRY( list_head( &db->transforms ),
2414                                       MSITRANSFORM, entry );
2415         list_remove( &t->entry );
2416         IStorage_Release( t->stg );
2417         msi_free( t );
2418     }
2419 }