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