dlls/msi/tests/db.c

   1 /*
   2  * Copyright (C) 2005 Mike McCormack for CodeWeavers
   3  *
   4  * A test program for MSI database files.
   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 #include <stdio.h>
  21
  22 #include <windows.h>
  23 #include <msi.h>
  24 #include <msiquery.h>
  25
  26 #include "wine/test.h"
  27
  28 static const char *msifile = "winetest.msi";
  29 static const char *msifile2 = "winetst2.msi";
  30 static const char *mstfile = "winetst.mst";
  31
  32 #ifndef ERROR_INSTALL_TRANSFORM_FAILURE
  33 #define ERROR_INSTALL_TRANSFORM_FAILURE 1624
  34 #endif
  35
  36 static void test_msidatabase(void)
  37 {
  38     MSIHANDLE hdb = 0, hdb2 = 0;
  39     UINT res;
  40
  41     DeleteFile(msifile);
  42
  43     res = MsiOpenDatabase( msifile, msifile2, &hdb );
  44     ok( res == ERROR_OPEN_FAILED, "expected failure\n");
  45
  46     res = MsiOpenDatabase( msifile, (LPSTR) 0xff, &hdb );
  47     ok( res == ERROR_INVALID_PARAMETER, "expected failure\n");
  48
  49     res = MsiCloseHandle( hdb );
  50     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  51
  52     /* create an empty database */
  53     res = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb );
  54     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
  55
  56     res = MsiDatabaseCommit( hdb );
  57     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  58
  59     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
  60
  61     res = MsiCloseHandle( hdb );
  62     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  63     res = MsiOpenDatabase( msifile, msifile2, &hdb2 );
  64     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  65
  66     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile2 ), "database should exist\n");
  67
  68     res = MsiDatabaseCommit( hdb2 );
  69     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  70
  71     res = MsiCloseHandle( hdb2 );
  72     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  73
  74     res = MsiOpenDatabase( msifile, msifile2, &hdb2 );
  75     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  76
  77     res = MsiCloseHandle( hdb2 );
  78     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  79
  80     ok( INVALID_FILE_ATTRIBUTES == GetFileAttributes( msifile2 ), "uncommitted database should not exist\n");
  81
  82     res = MsiOpenDatabase( msifile, msifile2, &hdb2 );
  83     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  84
  85     res = MsiDatabaseCommit( hdb2 );
  86     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  87
  88     res = MsiCloseHandle( hdb2 );
  89     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  90
  91     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile2 ), "committed database should exist\n");
  92
  93     res = MsiOpenDatabase( msifile, MSIDBOPEN_READONLY, &hdb );
  94     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  95
  96     res = MsiCloseHandle( hdb );
  97     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  98
  99     res = MsiOpenDatabase( msifile, MSIDBOPEN_DIRECT, &hdb );
 100     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 101
 102     res = MsiCloseHandle( hdb );
 103     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 104
 105     res = MsiOpenDatabase( msifile, MSIDBOPEN_TRANSACT, &hdb );
 106     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 107
 108     res = MsiCloseHandle( hdb );
 109     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 110     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
 111
 112     todo_wine {
 113     /* MSIDBOPEN_CREATE deletes the database if MsiCommitDatabase isn't called */
 114     res = MsiOpenDatabase( msifile, MSIDBOPEN_CREATE, &hdb );
 115     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 116
 117     res = MsiCloseHandle( hdb );
 118     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 119
 120     res = MsiOpenDatabase( msifile, MSIDBOPEN_CREATE, &hdb );
 121     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 122
 123     res = MsiDatabaseCommit( hdb );
 124     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 125
 126     res = MsiCloseHandle( hdb );
 127     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 128     }
 129     res = DeleteFile( msifile2 );
 130     ok( res == TRUE, "Failed to delete database\n" );
 131
 132     res = DeleteFile( msifile );
 133     ok( res == TRUE, "Failed to delete database\n" );
 134 }
 135
 136 static UINT do_query(MSIHANDLE hdb, const char *query, MSIHANDLE *phrec)
 137 {
 138     MSIHANDLE hview = 0;
 139     UINT r, ret;
 140
 141     /* open a select query */
 142     r = MsiDatabaseOpenView(hdb, query, &hview);
 143     if (r != ERROR_SUCCESS)
 144         return r;
 145     r = MsiViewExecute(hview, 0);
 146     if (r != ERROR_SUCCESS)
 147         return r;
 148     ret = MsiViewFetch(hview, phrec);
 149     r = MsiViewClose(hview);
 150     if (r != ERROR_SUCCESS)
 151         return r;
 152     r = MsiCloseHandle(hview);
 153     if (r != ERROR_SUCCESS)
 154         return r;
 155     return ret;
 156 }
 157
 158 static UINT run_query( MSIHANDLE hdb, MSIHANDLE hrec, const char *query )
 159 {
 160     MSIHANDLE hview = 0;
 161     UINT r;
 162
 163     r = MsiDatabaseOpenView(hdb, query, &hview);
 164     if( r != ERROR_SUCCESS )
 165         return r;
 166
 167     r = MsiViewExecute(hview, hrec);
 168     if( r == ERROR_SUCCESS )
 169         r = MsiViewClose(hview);
 170     MsiCloseHandle(hview);
 171     return r;
 172 }
 173
 174 static UINT create_component_table( MSIHANDLE hdb )
 175 {
 176     return run_query( hdb, 0,
 177             "CREATE TABLE `Component` ( "
 178             "`Component` CHAR(72) NOT NULL, "
 179             "`ComponentId` CHAR(38), "
 180             "`Directory_` CHAR(72) NOT NULL, "
 181             "`Attributes` SHORT NOT NULL, "
 182             "`Condition` CHAR(255), "
 183             "`KeyPath` CHAR(72) "
 184             "PRIMARY KEY `Component`)" );
 185 }
 186
 187 static UINT create_feature_components_table( MSIHANDLE hdb )
 188 {
 189     return run_query( hdb, 0,
 190             "CREATE TABLE `FeatureComponents` ( "
 191             "`Feature_` CHAR(38) NOT NULL, "
 192             "`Component_` CHAR(72) NOT NULL "
 193             "PRIMARY KEY `Feature_`, `Component_` )" );
 194 }
 195
 196 static UINT create_std_dlls_table( MSIHANDLE hdb )
 197 {
 198     return run_query( hdb, 0,
 199             "CREATE TABLE `StdDlls` ( "
 200             "`File` CHAR(255) NOT NULL, "
 201             "`Binary_` CHAR(72) NOT NULL "
 202             "PRIMARY KEY `File` )" );
 203 }
 204
 205 static UINT create_binary_table( MSIHANDLE hdb )
 206 {
 207     return run_query( hdb, 0,
 208             "CREATE TABLE `Binary` ( "
 209             "`Name` CHAR(72) NOT NULL, "
 210             "`Data` CHAR(72) NOT NULL "
 211             "PRIMARY KEY `Name` )" );
 212 }
 213
 214 static UINT add_component_entry( MSIHANDLE hdb, const char *values )
 215 {
 216     char insert[] = "INSERT INTO `Component`  "
 217             "(`Component`, `ComponentId`, `Directory_`, `Attributes`, `Condition`, `KeyPath`) "
 218             "VALUES( %s )";
 219     char *query;
 220     UINT sz, r;
 221
 222     sz = strlen(values) + sizeof insert;
 223     query = HeapAlloc(GetProcessHeap(),0,sz);
 224     sprintf(query,insert,values);
 225     r = run_query( hdb, 0, query );
 226     HeapFree(GetProcessHeap(), 0, query);
 227     return r;
 228 }
 229
 230 static UINT add_feature_components_entry( MSIHANDLE hdb, const char *values )
 231 {
 232     char insert[] = "INSERT INTO `FeatureComponents` "
 233             "(`Feature_`, `Component_`) "
 234             "VALUES( %s )";
 235     char *query;
 236     UINT sz, r;
 237
 238     sz = strlen(values) + sizeof insert;
 239     query = HeapAlloc(GetProcessHeap(),0,sz);
 240     sprintf(query,insert,values);
 241     r = run_query( hdb, 0, query );
 242     HeapFree(GetProcessHeap(), 0, query);
 243     return r;
 244 }
 245
 246 static UINT add_std_dlls_entry( MSIHANDLE hdb, const char *values )
 247 {
 248     char insert[] = "INSERT INTO `StdDlls` "
 249             "(`File`, `Binary_`) "
 250             "VALUES( %s )";
 251     char *query;
 252     UINT sz, r;
 253
 254     sz = strlen(values) + sizeof insert;
 255     query = HeapAlloc(GetProcessHeap(),0,sz);
 256     sprintf(query,insert,values);
 257     r = run_query( hdb, 0, query );
 258     HeapFree(GetProcessHeap(), 0, query);
 259     return r;
 260 }
 261
 262 static UINT add_binary_entry( MSIHANDLE hdb, const char *values )
 263 {
 264     char insert[] = "INSERT INTO `Binary` "
 265             "(`Name`, `Data`) "
 266             "VALUES( %s )";
 267     char *query;
 268     UINT sz, r;
 269
 270     sz = strlen(values) + sizeof insert;
 271     query = HeapAlloc(GetProcessHeap(),0,sz);
 272     sprintf(query,insert,values);
 273     r = run_query( hdb, 0, query );
 274     HeapFree(GetProcessHeap(), 0, query);
 275     return r;
 276 }
 277
 278 static void test_msiinsert(void)
 279 {
 280     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 281     UINT r;
 282     const char *query;
 283     char buf[80];
 284     DWORD sz;
 285
 286     DeleteFile(msifile);
 287
 288     /* just MsiOpenDatabase should not create a file */
 289     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 290     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 291
 292     /* create a table */
 293     query = "CREATE TABLE `phone` ( "
 294             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 295             "PRIMARY KEY `id`)";
 296     r = MsiDatabaseOpenView(hdb, query, &hview);
 297     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 298     r = MsiViewExecute(hview, 0);
 299     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 300     r = MsiViewClose(hview);
 301     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 302     r = MsiCloseHandle(hview);
 303     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 304
 305     /* insert a value into it */
 306     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 307         "VALUES('1', 'Abe', '8675309')";
 308     r = MsiDatabaseOpenView(hdb, query, &hview);
 309     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 310     r = MsiViewExecute(hview, 0);
 311     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 312     r = MsiViewClose(hview);
 313     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 314     r = MsiCloseHandle(hview);
 315     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 316
 317     query = "SELECT * FROM `phone` WHERE `id` = 1";
 318     r = do_query(hdb, query, &hrec);
 319     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 320
 321     /* check the record contains what we put in it */
 322     r = MsiRecordGetFieldCount(hrec);
 323     ok(r == 3, "record count wrong\n");
 324
 325     todo_wine {
 326     r = MsiRecordIsNull(hrec, 0);
 327     ok(r == FALSE, "field 0 not null\n");
 328     }
 329
 330     r = MsiRecordGetInteger(hrec, 1);
 331     ok(r == 1, "field 1 contents wrong\n");
 332     sz = sizeof buf;
 333     r = MsiRecordGetString(hrec, 2, buf, &sz);
 334     ok(r == ERROR_SUCCESS, "field 2 content fetch failed\n");
 335     ok(!strcmp(buf,"Abe"), "field 2 content incorrect\n");
 336     sz = sizeof buf;
 337     r = MsiRecordGetString(hrec, 3, buf, &sz);
 338     ok(r == ERROR_SUCCESS, "field 3 content fetch failed\n");
 339     ok(!strcmp(buf,"8675309"), "field 3 content incorrect\n");
 340
 341     r = MsiCloseHandle(hrec);
 342     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 343
 344     /* open a select query */
 345     hrec = 100;
 346     query = "SELECT * FROM `phone` WHERE `id` >= 10";
 347     r = do_query(hdb, query, &hrec);
 348     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 349     ok(hrec == 0, "hrec should be null\n");
 350
 351     r = MsiCloseHandle(hrec);
 352     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 353
 354     query = "SELECT * FROM `phone` WHERE `id` < 0";
 355     r = do_query(hdb, query, &hrec);
 356     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 357
 358     query = "SELECT * FROM `phone` WHERE `id` <= 0";
 359     r = do_query(hdb, query, &hrec);
 360     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 361
 362     query = "SELECT * FROM `phone` WHERE `id` <> 1";
 363     r = do_query(hdb, query, &hrec);
 364     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 365
 366     query = "SELECT * FROM `phone` WHERE `id` > 10";
 367     r = do_query(hdb, query, &hrec);
 368     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 369
 370     /* now try a few bad INSERT xqueries */
 371     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 372         "VALUES(?, ?)";
 373     r = MsiDatabaseOpenView(hdb, query, &hview);
 374     ok(r == ERROR_BAD_QUERY_SYNTAX, "MsiDatabaseOpenView failed\n");
 375
 376     /* construct a record to insert */
 377     hrec = MsiCreateRecord(4);
 378     r = MsiRecordSetInteger(hrec, 1, 2);
 379     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 380     r = MsiRecordSetString(hrec, 2, "Adam");
 381     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 382     r = MsiRecordSetString(hrec, 3, "96905305");
 383     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 384
 385     /* insert another value, using a record and wildcards */
 386     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 387         "VALUES(?, ?, ?)";
 388     r = MsiDatabaseOpenView(hdb, query, &hview);
 389     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 390
 391     if (r == ERROR_SUCCESS)
 392     {
 393         r = MsiViewExecute(hview, hrec);
 394         ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 395         r = MsiViewClose(hview);
 396         ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 397         r = MsiCloseHandle(hview);
 398         ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 399     }
 400     r = MsiCloseHandle(hrec);
 401     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 402
 403     r = MsiViewFetch(0, NULL);
 404     ok(r == ERROR_INVALID_PARAMETER, "MsiViewFetch failed\n");
 405
 406     r = MsiDatabaseCommit(hdb);
 407     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
 408
 409     r = MsiCloseHandle(hdb);
 410     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 411
 412     r = DeleteFile(msifile);
 413     ok(r == TRUE, "file didn't exist after commit\n");
 414 }
 415
 416 typedef UINT (WINAPI *fnMsiDecomposeDescriptorA)(LPCSTR, LPCSTR, LPSTR, LPSTR, DWORD *);
 417 static fnMsiDecomposeDescriptorA pMsiDecomposeDescriptorA;
 418
 419 static void test_msidecomposedesc(void)
 420 {
 421     char prod[MAX_FEATURE_CHARS+1], comp[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1];
 422     const char *desc;
 423     UINT r;
 424     DWORD len;
 425     HMODULE hmod;
 426
 427     hmod = GetModuleHandle("msi.dll");
 428     if (!hmod)
 429         return;
 430     pMsiDecomposeDescriptorA = (fnMsiDecomposeDescriptorA)
 431         GetProcAddress(hmod, "MsiDecomposeDescriptorA");
 432     if (!pMsiDecomposeDescriptorA)
 433         return;
 434
 435     /* test a valid feature descriptor */
 436     desc = "']gAVn-}f(ZXfeAR6.jiFollowTheWhiteRabbit>3w2x^IGfe?CxI5heAvk.";
 437     len = 0;
 438     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 439     ok(r == ERROR_SUCCESS, "returned an error\n");
 440     ok(len == strlen(desc), "length was wrong\n");
 441     ok(strcmp(prod,"{90110409-6000-11D3-8CFE-0150048383C9}")==0, "product wrong\n");
 442     ok(strcmp(feature,"FollowTheWhiteRabbit")==0, "feature wrong\n");
 443     ok(strcmp(comp,"{A7CD68DB-EF74-49C8-FBB2-A7C463B2AC24}")==0,"component wrong\n");
 444
 445     /* test an invalid feature descriptor with too many characters */
 446     desc = "']gAVn-}f(ZXfeAR6.ji"
 447            "ThisWillFailIfTheresMoreThanAGuidsChars>"
 448            "3w2x^IGfe?CxI5heAvk.";
 449     len = 0;
 450     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 451     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 452
 453     /*
 454      * Test a valid feature descriptor with the
 455      * maximum number of characters and some trailing characters.
 456      */
 457     desc = "']gAVn-}f(ZXfeAR6.ji"
 458            "ThisWillWorkIfTheresLTEThanAGuidsChars>"
 459            "3w2x^IGfe?CxI5heAvk."
 460            "extra";
 461     len = 0;
 462     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 463     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 464     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 465
 466     len = 0;
 467     r = pMsiDecomposeDescriptorA(desc, prod, feature, NULL, &len);
 468     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 469     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 470
 471     len = 0;
 472     r = pMsiDecomposeDescriptorA(desc, prod, NULL, NULL, &len);
 473     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 474     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 475
 476     len = 0;
 477     r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, &len);
 478     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 479     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 480
 481     len = 0;
 482     r = pMsiDecomposeDescriptorA(NULL, NULL, NULL, NULL, &len);
 483     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 484     ok(len == 0, "length wrong\n");
 485 }
 486
 487 static UINT try_query_param( MSIHANDLE hdb, LPCSTR szQuery, MSIHANDLE hrec )
 488 {
 489     MSIHANDLE htab = 0;
 490     UINT res;
 491
 492     res = MsiDatabaseOpenView( hdb, szQuery, &htab );
 493     if(res == ERROR_SUCCESS )
 494     {
 495         UINT r;
 496
 497         r = MsiViewExecute( htab, hrec );
 498         if(r != ERROR_SUCCESS )
 499             res = r;
 500
 501         r = MsiViewClose( htab );
 502         if(r != ERROR_SUCCESS )
 503             res = r;
 504
 505         r = MsiCloseHandle( htab );
 506         if(r != ERROR_SUCCESS )
 507             res = r;
 508     }
 509     return res;
 510 }
 511
 512 static UINT try_query( MSIHANDLE hdb, LPCSTR szQuery )
 513 {
 514     return try_query_param( hdb, szQuery, 0 );
 515 }
 516
 517 static UINT try_insert_query( MSIHANDLE hdb, LPCSTR szQuery )
 518 {
 519     MSIHANDLE hrec = 0;
 520     UINT r;
 521
 522     hrec = MsiCreateRecord( 1 );
 523     MsiRecordSetString( hrec, 1, "Hello");
 524
 525     r = try_query_param( hdb, szQuery, hrec );
 526
 527     MsiCloseHandle( hrec );
 528     return r;
 529 }
 530
 531 static void test_msibadqueries(void)
 532 {
 533     MSIHANDLE hdb = 0;
 534     UINT r;
 535
 536     DeleteFile(msifile);
 537
 538     /* just MsiOpenDatabase should not create a file */
 539     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 540     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 541
 542     r = MsiDatabaseCommit( hdb );
 543     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
 544
 545     r = MsiCloseHandle( hdb );
 546     ok(r == ERROR_SUCCESS , "Failed to close database\n");
 547
 548     /* open it readonly */
 549     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb );
 550     ok(r == ERROR_SUCCESS , "Failed to open database r/o\n");
 551
 552     /* add a table to it */
 553     r = try_query( hdb, "select * from _Tables");
 554     ok(r == ERROR_SUCCESS , "query 1 failed\n");
 555
 556     r = MsiCloseHandle( hdb );
 557     ok(r == ERROR_SUCCESS , "Failed to close database r/o\n");
 558
 559     /* open it read/write */
 560     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb );
 561     ok(r == ERROR_SUCCESS , "Failed to open database r/w\n");
 562
 563     /* a bunch of test queries that fail with the native MSI */
 564
 565     r = try_query( hdb, "CREATE TABLE");
 566     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2a return code\n");
 567
 568     r = try_query( hdb, "CREATE TABLE `a`");
 569     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2b return code\n");
 570
 571     r = try_query( hdb, "CREATE TABLE `a` ()");
 572     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2c return code\n");
 573
 574     r = try_query( hdb, "CREATE TABLE `a` (`b`)");
 575     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2d return code\n");
 576
 577     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) )");
 578     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2e return code\n");
 579
 580     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL)");
 581     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2f return code\n");
 582
 583     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY)");
 584     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2g return code\n");
 585
 586     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 587     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2h return code\n");
 588
 589     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 590     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2i return code\n");
 591
 592     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY 'b')");
 593     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2j return code\n");
 594
 595     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 596     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2k return code\n");
 597
 598     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 599     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2l return code\n");
 600
 601     r = try_query( hdb, "CREATE TABLE `a` (`b` CHA(72) NOT NULL PRIMARY KEY `b`)");
 602     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2m return code\n");
 603
 604     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(-1) NOT NULL PRIMARY KEY `b`)");
 605     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2n return code\n");
 606
 607     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(720) NOT NULL PRIMARY KEY `b`)");
 608     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2o return code\n");
 609
 610     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL KEY `b`)");
 611     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 612
 613     r = try_query( hdb, "CREATE TABLE `a` (`` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 614     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 615
 616     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 617     ok(r == ERROR_SUCCESS , "valid query 2z failed\n");
 618
 619     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 620     ok(r == ERROR_BAD_QUERY_SYNTAX , "created same table again\n");
 621
 622     r = try_query( hdb, "CREATE TABLE `aa` (`b` CHAR(72) NOT NULL, `c` "
 623           "CHAR(72), `d` CHAR(255) NOT NULL LOCALIZABLE PRIMARY KEY `b`)");
 624     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 625
 626     r = MsiDatabaseCommit( hdb );
 627     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 628
 629     r = try_query( hdb, "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL "
 630                           "PRIMARY KEY `foo`)");
 631     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 632
 633     r = try_insert_query( hdb, "insert into a  ( `b` ) VALUES ( ? )");
 634     ok(r == ERROR_SUCCESS , "failed to insert record in db\n");
 635
 636     r = MsiDatabaseCommit( hdb );
 637     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 638
 639     r = try_query( hdb, "CREATE TABLE `boo` (`foo` CHAR(72) NOT NULL "
 640                           "PRIMARY KEY `ba`)");
 641     ok(r != ERROR_SUCCESS , "query 5 succeeded\n");
 642
 643     r = try_query( hdb,"CREATE TABLE `bee` (`foo` CHAR(72) NOT NULL )");
 644     ok(r != ERROR_SUCCESS , "query 6 succeeded\n");
 645
 646     r = try_query( hdb, "CREATE TABLE `temp` (`t` CHAR(72) NOT NULL "
 647                           "PRIMARY KEY `t`)");
 648     ok(r == ERROR_SUCCESS , "query 7 failed\n");
 649
 650     r = try_query( hdb, "CREATE TABLE `c` (`b` CHAR NOT NULL PRIMARY KEY `b`)");
 651     ok(r == ERROR_SUCCESS , "query 8 failed\n");
 652
 653     r = MsiCloseHandle( hdb );
 654     ok(r == ERROR_SUCCESS , "Failed to close database transact\n");
 655
 656     r = DeleteFile( msifile );
 657     ok(r == TRUE, "file didn't exist after commit\n");
 658 }
 659
 660 static void test_viewmodify(void)
 661 {
 662     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 663     UINT r;
 664     const char *query;
 665     char buffer[0x100];
 666     DWORD sz;
 667
 668     DeleteFile(msifile);
 669
 670     /* just MsiOpenDatabase should not create a file */
 671     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 672     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 673
 674     query = "CREATE TABLE `phone` ( "
 675             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 676             "PRIMARY KEY `id`)";
 677     r = run_query( hdb, 0, query );
 678     ok(r == ERROR_SUCCESS, "query failed\n");
 679
 680     /* check what the error function reports without doing anything */
 681     sz = 0;
 682     /* passing NULL as the 3rd param make function to crash on older platforms */
 683     r = MsiViewGetError( 0, NULL, &sz );
 684     ok(r == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 685
 686     /* open a view */
 687     query = "SELECT * FROM `phone`";
 688     r = MsiDatabaseOpenView(hdb, query, &hview);
 689     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 690
 691     /* see what happens with a good hview and bad args */
 692     r = MsiViewGetError( hview, NULL, NULL );
 693     ok(r == MSIDBERROR_INVALIDARG || r == MSIDBERROR_NOERROR,
 694        "MsiViewGetError returns %u (expected -3)\n", r);
 695     r = MsiViewGetError( hview, buffer, NULL );
 696     ok(r == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 697
 698     /* see what happens with a zero length buffer */
 699     sz = 0;
 700     buffer[0] = 'x';
 701     r = MsiViewGetError( hview, buffer, &sz );
 702     ok(r == MSIDBERROR_MOREDATA, "MsiViewGetError return\n");
 703     ok(buffer[0] == 'x', "buffer cleared\n");
 704     ok(sz == 0, "size not zero\n");
 705
 706     /* ok this one is strange */
 707     sz = 0;
 708     r = MsiViewGetError( hview, NULL, &sz );
 709     ok(r == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 710     ok(sz == 0, "size not zero\n");
 711
 712     /* see if it really has an error */
 713     sz = sizeof buffer;
 714     buffer[0] = 'x';
 715     r = MsiViewGetError( hview, buffer, &sz );
 716     ok(r == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 717     ok(buffer[0] == 0, "buffer not cleared\n");
 718     ok(sz == 0, "size not zero\n");
 719
 720     r = MsiViewExecute(hview, 0);
 721     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 722
 723     /* try some invalid records */
 724     r = MsiViewModify(hview, MSIMODIFY_INSERT, 0 );
 725     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 726     r = MsiViewModify(hview, -1, 0 );
 727     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 728
 729     /* try an small record */
 730     hrec = MsiCreateRecord(1);
 731     r = MsiViewModify(hview, -1, hrec );
 732     ok(r == ERROR_INVALID_DATA, "MsiViewModify failed\n");
 733
 734     r = MsiCloseHandle(hrec);
 735     ok(r == ERROR_SUCCESS, "failed to close record\n");
 736
 737     /* insert a valid record */
 738     hrec = MsiCreateRecord(3);
 739
 740     r = MsiRecordSetInteger(hrec, 2, 1);
 741     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 742     r = MsiRecordSetString(hrec, 2, "bob");
 743     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 744     r = MsiRecordSetString(hrec, 3, "7654321");
 745     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 746
 747     r = MsiViewExecute(hview, 0);
 748     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 749     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 750     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 751
 752     /* insert the same thing again */
 753     r = MsiViewExecute(hview, 0);
 754     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 755
 756     /* should fail ... */
 757     todo_wine {
 758     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 759     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 760     }
 761
 762     r = MsiCloseHandle(hrec);
 763     ok(r == ERROR_SUCCESS, "failed to close record\n");
 764
 765     r = MsiViewClose(hview);
 766     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 767     r = MsiCloseHandle(hview);
 768     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 769
 770     r = MsiCloseHandle( hdb );
 771     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
 772 }
 773
 774 static MSIHANDLE create_db(void)
 775 {
 776     MSIHANDLE hdb = 0;
 777     UINT res;
 778
 779     DeleteFile(msifile);
 780
 781     /* create an empty database */
 782     res = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb );
 783     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
 784     if( res != ERROR_SUCCESS )
 785         return hdb;
 786
 787     res = MsiDatabaseCommit( hdb );
 788     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 789
 790     return hdb;
 791 }
 792
 793 static void test_getcolinfo(void)
 794 {
 795     MSIHANDLE hdb, hview = 0, rec = 0;
 796     UINT r;
 797     DWORD sz;
 798     char buffer[0x20];
 799
 800     /* create an empty db */
 801     hdb = create_db();
 802     ok( hdb, "failed to create db\n");
 803
 804     /* tables should be present */
 805     r = MsiDatabaseOpenView(hdb, "select * from _Tables", &hview);
 806     ok( r == ERROR_SUCCESS, "failed to open query\n");
 807
 808     r = MsiViewExecute(hview, 0);
 809     ok( r == ERROR_SUCCESS, "failed to execute query\n");
 810
 811     /* check that NAMES works */
 812     rec = 0;
 813     r = MsiViewGetColumnInfo( hview, MSICOLINFO_NAMES, &rec );
 814     ok( r == ERROR_SUCCESS, "failed to get names\n");
 815     sz = sizeof buffer;
 816     r = MsiRecordGetString(rec, 1, buffer, &sz );
 817     ok( r == ERROR_SUCCESS, "failed to get string\n");
 818     ok( !strcmp(buffer,"Name"), "_Tables has wrong column name\n");
 819     r = MsiCloseHandle( rec );
 820     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
 821
 822     /* check that TYPES works */
 823     rec = 0;
 824     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, &rec );
 825     ok( r == ERROR_SUCCESS, "failed to get names\n");
 826     sz = sizeof buffer;
 827     r = MsiRecordGetString(rec, 1, buffer, &sz );
 828     ok( r == ERROR_SUCCESS, "failed to get string\n");
 829     ok( !strcmp(buffer,"s64"), "_Tables has wrong column type\n");
 830     r = MsiCloseHandle( rec );
 831     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
 832
 833     /* check that invalid values fail */
 834     rec = 0;
 835     r = MsiViewGetColumnInfo( hview, 100, &rec );
 836     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
 837     ok( rec == 0, "returned a record\n");
 838
 839     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, NULL );
 840     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
 841
 842     r = MsiViewGetColumnInfo( 0, MSICOLINFO_TYPES, &rec );
 843     ok( r == ERROR_INVALID_HANDLE, "wrong error code\n");
 844
 845     r = MsiViewClose(hview);
 846     ok( r == ERROR_SUCCESS, "failed to close view\n");
 847     r = MsiCloseHandle(hview);
 848     ok( r == ERROR_SUCCESS, "failed to close view handle\n");
 849     r = MsiCloseHandle(hdb);
 850     ok( r == ERROR_SUCCESS, "failed to close database\n");
 851 }
 852
 853 static MSIHANDLE get_column_info(MSIHANDLE hdb, const char *query, MSICOLINFO type)
 854 {
 855     MSIHANDLE hview = 0, rec = 0;
 856     UINT r;
 857
 858     r = MsiDatabaseOpenView(hdb, query, &hview);
 859     if( r != ERROR_SUCCESS )
 860         return r;
 861
 862     r = MsiViewExecute(hview, 0);
 863     if( r == ERROR_SUCCESS )
 864     {
 865         MsiViewGetColumnInfo( hview, type, &rec );
 866         MsiViewClose(hview);
 867     }
 868     MsiCloseHandle(hview);
 869     return rec;
 870 }
 871
 872 static UINT get_columns_table_type(MSIHANDLE hdb, const char *table, UINT field)
 873 {
 874     MSIHANDLE hview = 0, rec = 0;
 875     UINT r, type = 0;
 876     char query[0x100];
 877
 878     sprintf(query, "select * from `_Columns` where  `Table` = '%s'", table );
 879
 880     r = MsiDatabaseOpenView(hdb, query, &hview);
 881     if( r != ERROR_SUCCESS )
 882         return r;
 883
 884     r = MsiViewExecute(hview, 0);
 885     if( r == ERROR_SUCCESS )
 886     {
 887         while (1)
 888         {
 889             r = MsiViewFetch( hview, &rec );
 890             if( r != ERROR_SUCCESS)
 891                 break;
 892             r = MsiRecordGetInteger( rec, 2 );
 893             if (r == field)
 894                 type = MsiRecordGetInteger( rec, 4 );
 895             MsiCloseHandle( rec );
 896         }
 897
 898         MsiViewClose(hview);
 899     }
 900     MsiCloseHandle(hview);
 901     return type;
 902 }
 903
 904 static BOOL check_record( MSIHANDLE rec, UINT field, LPCSTR val )
 905 {
 906     CHAR buffer[0x20];
 907     UINT r;
 908     DWORD sz;
 909
 910     sz = sizeof buffer;
 911     r = MsiRecordGetString( rec, field, buffer, &sz );
 912     return (r == ERROR_SUCCESS ) && !strcmp(val, buffer);
 913 }
 914
 915 static void test_viewgetcolumninfo(void)
 916 {
 917     MSIHANDLE hdb = 0, rec;
 918     UINT r;
 919
 920     hdb = create_db();
 921     ok( hdb, "failed to create db\n");
 922
 923     r = run_query( hdb, 0,
 924             "CREATE TABLE `Properties` "
 925             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
 926     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 927
 928     /* check the column types */
 929     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_TYPES );
 930     ok( rec, "failed to get column info record\n" );
 931
 932     ok( check_record( rec, 1, "S255"), "wrong record type\n");
 933     ok( check_record( rec, 2, "S1"), "wrong record type\n");
 934
 935     MsiCloseHandle( rec );
 936
 937     /* check the type in _Columns */
 938     ok( 0x3dff == get_columns_table_type(hdb, "Properties", 1 ), "_columns table wrong\n");
 939     ok( 0x1d01 == get_columns_table_type(hdb, "Properties", 2 ), "_columns table wrong\n");
 940
 941     /* now try the names */
 942     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_NAMES );
 943     ok( rec, "failed to get column info record\n" );
 944
 945     ok( check_record( rec, 1, "Property"), "wrong record type\n");
 946     ok( check_record( rec, 2, "Value"), "wrong record type\n");
 947
 948     MsiCloseHandle( rec );
 949
 950     r = run_query( hdb, 0,
 951             "CREATE TABLE `Binary` "
 952             "( `Name` CHAR(255), `Data` OBJECT  PRIMARY KEY `Name`)" );
 953     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 954
 955     /* check the column types */
 956     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_TYPES );
 957     ok( rec, "failed to get column info record\n" );
 958
 959     ok( check_record( rec, 1, "S255"), "wrong record type\n");
 960     ok( check_record( rec, 2, "V0"), "wrong record type\n");
 961
 962     MsiCloseHandle( rec );
 963
 964     /* check the type in _Columns */
 965     ok( 0x3dff == get_columns_table_type(hdb, "Binary", 1 ), "_columns table wrong\n");
 966     ok( 0x1900 == get_columns_table_type(hdb, "Binary", 2 ), "_columns table wrong\n");
 967
 968     /* now try the names */
 969     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_NAMES );
 970     ok( rec, "failed to get column info record\n" );
 971
 972     ok( check_record( rec, 1, "Name"), "wrong record type\n");
 973     ok( check_record( rec, 2, "Data"), "wrong record type\n");
 974     MsiCloseHandle( rec );
 975
 976     r = run_query( hdb, 0,
 977             "CREATE TABLE `UIText` "
 978             "( `Key` CHAR(72) NOT NULL, `Text` CHAR(255) LOCALIZABLE PRIMARY KEY `Key`)" );
 979     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 980
 981     ok( 0x2d48 == get_columns_table_type(hdb, "UIText", 1 ), "_columns table wrong\n");
 982     ok( 0x1fff == get_columns_table_type(hdb, "UIText", 2 ), "_columns table wrong\n");
 983
 984     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_NAMES );
 985     ok( rec, "failed to get column info record\n" );
 986     ok( check_record( rec, 1, "Key"), "wrong record type\n");
 987     ok( check_record( rec, 2, "Text"), "wrong record type\n");
 988     MsiCloseHandle( rec );
 989
 990     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_TYPES );
 991     ok( rec, "failed to get column info record\n" );
 992     ok( check_record( rec, 1, "s72"), "wrong record type\n");
 993     ok( check_record( rec, 2, "L255"), "wrong record type\n");
 994     MsiCloseHandle( rec );
 995
 996     MsiCloseHandle( hdb );
 997 }
 998
 999 static void test_msiexport(void)
1000 {
1001     MSIHANDLE hdb = 0, hview = 0;
1002     UINT r;
1003     const char *query;
1004     char path[MAX_PATH];
1005     const char file[] = "phone.txt";
1006     HANDLE handle;
1007     char buffer[0x100];
1008     DWORD length;
1009     const char expected[] =
1010         "id\tname\tnumber\r\n"
1011         "I2\tS32\tS32\r\n"
1012         "phone\tid\r\n"
1013         "1\tAbe\t8675309\r\n";
1014
1015     DeleteFile(msifile);
1016
1017     /* just MsiOpenDatabase should not create a file */
1018     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
1019     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1020
1021     /* create a table */
1022     query = "CREATE TABLE `phone` ( "
1023             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
1024             "PRIMARY KEY `id`)";
1025     r = MsiDatabaseOpenView(hdb, query, &hview);
1026     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1027     r = MsiViewExecute(hview, 0);
1028     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1029     r = MsiViewClose(hview);
1030     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1031     r = MsiCloseHandle(hview);
1032     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1033
1034     /* insert a value into it */
1035     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
1036         "VALUES('1', 'Abe', '8675309')";
1037     r = MsiDatabaseOpenView(hdb, query, &hview);
1038     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1039     r = MsiViewExecute(hview, 0);
1040     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1041     r = MsiViewClose(hview);
1042     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1043     r = MsiCloseHandle(hview);
1044     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1045
1046     GetCurrentDirectory(MAX_PATH, path);
1047
1048     r = MsiDatabaseExport(hdb, "phone", path, file);
1049     ok(r == ERROR_SUCCESS, "MsiDatabaseExport failed\n");
1050
1051     MsiCloseHandle(hdb);
1052
1053     lstrcat(path, "\\");
1054     lstrcat(path, file);
1055
1056     /* check the data that was written */
1057     length = 0;
1058     memset(buffer, 0, sizeof buffer);
1059     handle = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
1060     if (handle != INVALID_HANDLE_VALUE)
1061     {
1062         ReadFile(handle, buffer, sizeof buffer, &length, NULL);
1063         CloseHandle(handle);
1064         DeleteFile(path);
1065     }
1066     else
1067         ok(0, "failed to open file %s\n", path);
1068
1069     ok( length == strlen(expected), "length of data wrong\n");
1070     ok( !lstrcmp(buffer, expected), "data doesn't match\n");
1071     DeleteFile(msifile);
1072 }
1073
1074 static void test_longstrings(void)
1075 {
1076     const char insert_query[] =
1077         "INSERT INTO `strings` ( `id`, `val` ) VALUES('1', 'Z')";
1078     char *str;
1079     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
1080     DWORD len;
1081     UINT r;
1082     const DWORD STRING_LENGTH = 0x10005;
1083
1084     DeleteFile(msifile);
1085     /* just MsiOpenDatabase should not create a file */
1086     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
1087     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1088
1089     /* create a table */
1090     r = try_query( hdb,
1091         "CREATE TABLE `strings` ( `id` INT, `val` CHAR(0) PRIMARY KEY `id`)");
1092     ok(r == ERROR_SUCCESS, "query failed\n");
1093
1094     /* try a insert a very long string */
1095     str = HeapAlloc(GetProcessHeap(), 0, STRING_LENGTH+sizeof insert_query);
1096     len = strchr(insert_query, 'Z') - insert_query;
1097     strcpy(str, insert_query);
1098     memset(str+len, 'Z', STRING_LENGTH);
1099     strcpy(str+len+STRING_LENGTH, insert_query+len+1);
1100     r = try_query( hdb, str );
1101     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1102
1103     HeapFree(GetProcessHeap(), 0, str);
1104
1105     MsiDatabaseCommit(hdb);
1106     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
1107     MsiCloseHandle(hdb);
1108
1109     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb);
1110     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1111
1112     r = MsiDatabaseOpenView(hdb, "select * from `strings` where `id` = 1", &hview);
1113     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1114
1115     r = MsiViewExecute(hview, 0);
1116     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1117
1118     r = MsiViewFetch(hview, &hrec);
1119     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1120
1121     MsiCloseHandle(hview);
1122
1123     r = MsiRecordGetString(hrec, 2, NULL, &len);
1124     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1125     ok(len == STRING_LENGTH, "string length wrong\n");
1126
1127     MsiCloseHandle(hrec);
1128     MsiCloseHandle(hdb);
1129     DeleteFile(msifile);
1130 }
1131
1132 static void create_file(const CHAR *name)
1133 {
1134     HANDLE file;
1135     DWORD written;
1136
1137     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
1138     ok(file != INVALID_HANDLE_VALUE, "Failure to open file %s\n", name);
1139     WriteFile(file, name, strlen(name), &written, NULL);
1140     WriteFile(file, "\n", strlen("\n"), &written, NULL);
1141     CloseHandle(file);
1142 }
1143
1144 static void test_streamtable(void)
1145 {
1146     MSIHANDLE hdb = 0, rec, view;
1147     char file[MAX_PATH];
1148     char buf[MAX_PATH];
1149     DWORD size;
1150     UINT r;
1151
1152     hdb = create_db();
1153     ok( hdb, "failed to create db\n");
1154
1155     r = run_query( hdb, 0,
1156             "CREATE TABLE `Properties` "
1157             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
1158     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1159
1160     /* check the column types */
1161     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_TYPES );
1162     ok( rec, "failed to get column info record\n" );
1163
1164     todo_wine {
1165     ok( check_record( rec, 1, "s62"), "wrong record type\n");
1166     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1167     }
1168
1169     MsiCloseHandle( rec );
1170
1171     /* now try the names */
1172     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_NAMES );
1173     ok( rec, "failed to get column info record\n" );
1174
1175     todo_wine {
1176     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1177     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1178     }
1179
1180     MsiCloseHandle( rec );
1181
1182     /* insert a file into the _Streams table */
1183     create_file( "test.txt" );
1184
1185     rec = MsiCreateRecord( 2 );
1186     MsiRecordSetString( rec, 1, "data" );
1187
1188     r = MsiRecordSetStream( rec, 2, "test.txt" );
1189     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1190
1191     DeleteFile("test.txt");
1192
1193     r = MsiDatabaseOpenView( hdb,
1194             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1195     todo_wine
1196     {
1197         ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1198     }
1199
1200     r = MsiViewExecute( view, rec );
1201     todo_wine
1202     {
1203         ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1204     }
1205
1206     MsiCloseHandle( rec );
1207     MsiCloseHandle( view );
1208
1209     r = MsiDatabaseOpenView( hdb,
1210             "SELECT `Name`, `Data` FROM `_Streams`", &view );
1211     todo_wine
1212     {
1213         ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1214     }
1215
1216     r = MsiViewExecute( view, 0 );
1217     todo_wine
1218     {
1219         ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1220     }
1221
1222     r = MsiViewFetch( view, &rec );
1223     todo_wine
1224     {
1225         ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1226     }
1227
1228     size = MAX_PATH;
1229     r = MsiRecordGetString( rec, 1, file, &size );
1230     todo_wine
1231     {
1232         ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1233         ok( !lstrcmp(file, "data"), "Expected 'data', got %s\n", file);
1234     }
1235
1236     size = MAX_PATH;
1237     memset(buf, 0, MAX_PATH);
1238     r = MsiRecordReadStream( rec, 2, buf, &size );
1239     todo_wine
1240     {
1241         ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1242         ok( !lstrcmp(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf);
1243     }
1244
1245     MsiCloseHandle( rec );
1246
1247     r = MsiViewFetch( view, &rec );
1248     todo_wine
1249     {
1250         ok( r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
1251     }
1252
1253     MsiCloseHandle( view );
1254     MsiCloseHandle( hdb );
1255     DeleteFile(msifile);
1256 }
1257
1258 static void test_where(void)
1259 {
1260     MSIHANDLE hdb = 0, rec;
1261     LPCSTR query;
1262     UINT r;
1263
1264     hdb = create_db();
1265     ok( hdb, "failed to create db\n");
1266
1267     r = run_query( hdb, 0,
1268             "CREATE TABLE `Media` ("
1269             "`DiskId` SHORT NOT NULL, "
1270             "`LastSequence` LONG, "
1271             "`DiskPrompt` CHAR(64) LOCALIZABLE, "
1272             "`Cabinet` CHAR(255), "
1273             "`VolumeLabel` CHAR(32), "
1274             "`Source` CHAR(72) "
1275             "PRIMARY KEY `DiskId`)" );
1276     ok( r == S_OK, "cannot create Media table: %d\n", r );
1277
1278     r = run_query( hdb, 0, "INSERT INTO `Media` "
1279             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1280             "VALUES ( 1, 0, '', 'zero.cab', '', '' )" );
1281     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1282
1283     r = run_query( hdb, 0, "INSERT INTO `Media` "
1284             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1285             "VALUES ( 2, 1, '', 'one.cab', '', '' )" );
1286     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1287
1288     r = run_query( hdb, 0, "INSERT INTO `Media` "
1289             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1290             "VALUES ( 3, 2, '', 'two.cab', '', '' )" );
1291     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1292
1293     query = "SELECT * FROM `Media`";
1294     r = do_query(hdb, query, &rec);
1295     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1296     ok( check_record( rec, 4, "zero.cab"), "wrong cabinet\n");
1297     MsiCloseHandle( rec );
1298
1299     query = "SELECT * FROM `Media` WHERE `LastSequence` >= 1";
1300     r = do_query(hdb, query, &rec);
1301     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1302     ok( check_record( rec, 4, "one.cab"), "wrong cabinet\n");
1303
1304     r = MsiRecordGetInteger(rec, 1);
1305     ok( 2 == r, "field wrong\n");
1306     r = MsiRecordGetInteger(rec, 2);
1307     ok( 1 == r, "field wrong\n");
1308
1309     MsiCloseHandle( rec );
1310
1311     MsiCloseHandle( hdb );
1312     DeleteFile(msifile);
1313 }
1314
1315 static CHAR CURR_DIR[MAX_PATH];
1316
1317 static const CHAR test_data[] = "FirstPrimaryColumn\tSecondPrimaryColumn\tShortInt\tShortIntNullable\tLongInt\tLongIntNullable\tString\tLocalizableString\tLocalizableStringNullable\n"
1318                                 "s255\ti2\ti2\tI2\ti4\tI4\tS255\tS0\ts0\n"
1319                                 "TestTable\tFirstPrimaryColumn\n"
1320                                 "stringage\t5\t2\t\t2147483640\t-2147483640\tanother string\tlocalizable\tduh\n";
1321
1322 static void write_file(const CHAR *filename, const char *data, int data_size)
1323 {
1324     DWORD size;
1325
1326     HANDLE hf = CreateFile(filename, GENERIC_WRITE, 0, NULL,
1327                            CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1328
1329     WriteFile(hf, data, data_size, &size, NULL);
1330     CloseHandle(hf);
1331 }
1332
1333 static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
1334 {
1335     UINT r;
1336
1337     write_file("temp_file", table_data, (lstrlen(table_data) - 1) * sizeof(char));
1338     r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
1339     DeleteFileA("temp_file");
1340
1341     return r;
1342 }
1343
1344 static void test_msiimport(void)
1345 {
1346     MSIHANDLE hdb, view, rec;
1347     LPCSTR query;
1348     UINT r, count;
1349     signed int i;
1350
1351     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
1352
1353     r = MsiOpenDatabaseA(msifile, MSIDBOPEN_CREATE, &hdb);
1354     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1355
1356     r = add_table_to_db(hdb, test_data);
1357     todo_wine
1358     {
1359         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1360     }
1361
1362     query = "SELECT * FROM `TestTable`";
1363     r = MsiDatabaseOpenView(hdb, query, &view);
1364     todo_wine
1365     {
1366         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1367     }
1368
1369     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
1370     count = MsiRecordGetFieldCount(rec);
1371     todo_wine
1372     {
1373         ok(count == 9, "Expected 9, got %d\n", count);
1374         ok(check_record(rec, 1, "FirstPrimaryColumn"), "Expected FirstPrimaryColumn\n");
1375         ok(check_record(rec, 2, "SecondPrimaryColumn"), "Expected SecondPrimaryColumn\n");
1376         ok(check_record(rec, 3, "ShortInt"), "Expected ShortInt\n");
1377         ok(check_record(rec, 4, "ShortIntNullable"), "Expected ShortIntNullalble\n");
1378         ok(check_record(rec, 5, "LongInt"), "Expected LongInt\n");
1379         ok(check_record(rec, 6, "LongIntNullable"), "Expected LongIntNullalble\n");
1380         ok(check_record(rec, 7, "String"), "Expected String\n");
1381         ok(check_record(rec, 8, "LocalizableString"), "Expected LocalizableString\n");
1382         ok(check_record(rec, 9, "LocalizableStringNullable"), "Expected LocalizableStringNullable\n");
1383     }
1384
1385     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
1386     count = MsiRecordGetFieldCount(rec);
1387     todo_wine
1388     {
1389         ok(count == 9, "Expected 9, got %d\n", count);
1390         ok(check_record(rec, 1, "s255"), "Expected s255\n");
1391         ok(check_record(rec, 2, "i2"), "Expected i2\n");
1392         ok(check_record(rec, 3, "i2"), "Expected i2\n");
1393         ok(check_record(rec, 4, "I2"), "Expected I2\n");
1394         ok(check_record(rec, 5, "i4"), "Expected i4\n");
1395         ok(check_record(rec, 6, "I4"), "Expected I4\n");
1396         ok(check_record(rec, 7, "S255"), "Expected S255\n");
1397         ok(check_record(rec, 8, "S0"), "Expected S0\n");
1398         ok(check_record(rec, 9, "s0"), "Expected s0\n");
1399     }
1400
1401     query = "SELECT * FROM `TestTable`";
1402     r = do_query(hdb, query, &rec);
1403     todo_wine
1404     {
1405         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1406     }
1407
1408     todo_wine
1409     {
1410         ok(check_record(rec, 1, "stringage"), "Expected 'stringage'\n");
1411         ok(check_record(rec, 7, "another string"), "Expected 'another string'\n");
1412         ok(check_record(rec, 8, "localizable"), "Expected 'localizable'\n");
1413         ok(check_record(rec, 9, "duh"), "Expected 'duh'\n");
1414     }
1415
1416     i = MsiRecordGetInteger(rec, 2);
1417     todo_wine
1418     {
1419         ok(i == 5, "Expected 5, got %d\n", i);
1420     }
1421
1422     i = MsiRecordGetInteger(rec, 3);
1423     todo_wine
1424     {
1425         ok(i == 2, "Expected 2, got %d\n", i);
1426     }
1427
1428     i = MsiRecordGetInteger(rec, 4);
1429     ok(i == 0x80000000, "Expected 0x80000000, got %d\n", i);
1430
1431     i = MsiRecordGetInteger(rec, 5);
1432     todo_wine
1433     {
1434         ok(i == 2147483640, "Expected 2147483640, got %d\n", i);
1435     }
1436
1437     i = MsiRecordGetInteger(rec, 6);
1438     todo_wine
1439     {
1440         ok(i == -2147483640, "Expected -2147483640, got %d\n", i);
1441     }
1442
1443     MsiCloseHandle(rec);
1444     MsiCloseHandle(view);
1445     MsiCloseHandle(hdb);
1446     DeleteFileA(msifile);
1447 }
1448
1449 static void test_markers(void)
1450 {
1451     MSIHANDLE hdb, rec;
1452     LPCSTR query;
1453     UINT r;
1454
1455     hdb = create_db();
1456     ok( hdb, "failed to create db\n");
1457
1458     rec = MsiCreateRecord(3);
1459     MsiRecordSetString(rec, 1, "Table");
1460     MsiRecordSetString(rec, 2, "Apples");
1461     MsiRecordSetString(rec, 3, "Oranges");
1462
1463     /* try a legit create */
1464     query = "CREATE TABLE `Table` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1465     r = run_query(hdb, 0, query);
1466     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1467     MsiCloseHandle(rec);
1468
1469     /* try table name as marker */
1470     rec = MsiCreateRecord(1);
1471     MsiRecordSetString(rec, 1, "Fable");
1472     query = "CREATE TABLE `?` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1473     r = run_query(hdb, rec, query);
1474     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1475
1476     /* verify that we just created a table called '?', not 'Fable' */
1477     r = try_query(hdb, "SELECT * from `Fable`");
1478     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1479
1480     r = try_query(hdb, "SELECT * from `?`");
1481     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1482
1483     /* try table name as marker without backticks */
1484     MsiRecordSetString(rec, 1, "Mable");
1485     query = "CREATE TABLE ? ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1486     r = run_query(hdb, rec, query);
1487     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1488
1489     /* try one column name as marker */
1490     MsiRecordSetString(rec, 1, "One");
1491     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1492     r = run_query(hdb, rec, query);
1493     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1494
1495     /* try column names as markers */
1496     MsiCloseHandle(rec);
1497     rec = MsiCreateRecord(2);
1498     MsiRecordSetString(rec, 1, "One");
1499     MsiRecordSetString(rec, 2, "Two");
1500     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `One`)";
1501     r = run_query(hdb, rec, query);
1502     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1503
1504     /* try names with backticks */
1505     MsiCloseHandle(rec);
1506     rec = MsiCreateRecord(3);
1507     MsiRecordSetString(rec, 1, "One");
1508     MsiRecordSetString(rec, 2, "Two");
1509     MsiRecordSetString(rec, 3, "One");
1510     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
1511     r = run_query(hdb, rec, query);
1512     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1513
1514     /* try names with backticks, minus definitions */
1515     query = "CREATE TABLE `Mable` ( `?`, `?` PRIMARY KEY `?`)";
1516     r = run_query(hdb, rec, query);
1517     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1518
1519     /* try names without backticks */
1520     query = "CREATE TABLE `Mable` ( ? SHORT NOT NULL, ? CHAR(255) PRIMARY KEY ?)";
1521     r = run_query(hdb, rec, query);
1522     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1523
1524     /* try one long marker */
1525     MsiCloseHandle(rec);
1526     rec = MsiCreateRecord(1);
1527     MsiRecordSetString(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
1528     query = "CREATE TABLE `Mable` ( ? )";
1529     r = run_query(hdb, rec, query);
1530     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1531
1532     /* try all names as markers */
1533     MsiCloseHandle(rec);
1534     rec = MsiCreateRecord(4);
1535     MsiRecordSetString(rec, 1, "Mable");
1536     MsiRecordSetString(rec, 2, "One");
1537     MsiRecordSetString(rec, 3, "Two");
1538     MsiRecordSetString(rec, 4, "One");
1539     query = "CREATE TABLE `?` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
1540     r = run_query(hdb, rec, query);
1541     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1542
1543     /* try a legit insert */
1544     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( 5, 'hello' )";
1545     r = run_query(hdb, 0, query);
1546     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1547
1548     r = try_query(hdb, "SELECT * from `Table`");
1549     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1550
1551     /* try values as markers */
1552     MsiCloseHandle(rec);
1553     rec = MsiCreateRecord(2);
1554     MsiRecordSetInteger(rec, 1, 4);
1555     MsiRecordSetString(rec, 2, "hi");
1556     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
1557     r = run_query(hdb, rec, query);
1558     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1559
1560     /* try column names and values as markers */
1561     MsiCloseHandle(rec);
1562     rec = MsiCreateRecord(4);
1563     MsiRecordSetString(rec, 1, "One");
1564     MsiRecordSetString(rec, 2, "Two");
1565     MsiRecordSetInteger(rec, 3, 5);
1566     MsiRecordSetString(rec, 4, "hi");
1567     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( ?, '?' )";
1568     r = run_query(hdb, rec, query);
1569     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1570
1571     /* try column names as markers */
1572     MsiCloseHandle(rec);
1573     rec = MsiCreateRecord(2);
1574     MsiRecordSetString(rec, 1, "One");
1575     MsiRecordSetString(rec, 2, "Two");
1576     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( 3, 'yellow' )";
1577     r = run_query(hdb, rec, query);
1578     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1579
1580     /* try table name as a marker */
1581     MsiCloseHandle(rec);
1582     rec = MsiCreateRecord(1);
1583     MsiRecordSetString(rec, 1, "Table");
1584     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( 2, 'green' )";
1585     r = run_query(hdb, rec, query);
1586     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1587
1588     /* try table name and values as markers */
1589     MsiCloseHandle(rec);
1590     rec = MsiCreateRecord(3);
1591     MsiRecordSetString(rec, 1, "Table");
1592     MsiRecordSetInteger(rec, 2, 10);
1593     MsiRecordSetString(rec, 3, "haha");
1594     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
1595     r = run_query(hdb, rec, query);
1596     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
1597
1598     /* try all markers */
1599     MsiCloseHandle(rec);
1600     rec = MsiCreateRecord(5);
1601     MsiRecordSetString(rec, 1, "Table");
1602     MsiRecordSetString(rec, 1, "One");
1603     MsiRecordSetString(rec, 1, "Two");
1604     MsiRecordSetInteger(rec, 2, 10);
1605     MsiRecordSetString(rec, 3, "haha");
1606     query = "INSERT INTO `?` ( `?`, `?` ) VALUES ( ?, '?' )";
1607     r = run_query(hdb, rec, query);
1608     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1609
1610     /* insert an integer as a string */
1611     MsiCloseHandle(rec);
1612     rec = MsiCreateRecord(2);
1613     MsiRecordSetString(rec, 1, "11");
1614     MsiRecordSetString(rec, 2, "hi");
1615     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
1616     r = run_query(hdb, rec, query);
1617     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1618
1619     /* leave off the '' for the string */
1620     MsiCloseHandle(rec);
1621     rec = MsiCreateRecord(2);
1622     MsiRecordSetInteger(rec, 1, 12);
1623     MsiRecordSetString(rec, 2, "hi");
1624     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, ? )";
1625     r = run_query(hdb, rec, query);
1626     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1627     MsiCloseHandle(rec);
1628
1629     MsiCloseHandle(hdb);
1630     DeleteFileA(msifile);
1631 }
1632
1633 #define MY_NVIEWS 4000    /* Largest installer I've seen uses < 2k */
1634 static void test_handle_limit(void)
1635 {
1636     int i;
1637     MSIHANDLE hdb;
1638     MSIHANDLE hviews[MY_NVIEWS];
1639     UINT r;
1640
1641     /* create an empty db */
1642     hdb = create_db();
1643     ok( hdb, "failed to create db\n");
1644
1645     memset(hviews, 0, sizeof(hviews));
1646
1647     for (i=0; i<MY_NVIEWS; i++) {
1648         static char szQueryBuf[256] = "SELECT * from `_Tables`";
1649         hviews[i] = 0xdeadbeeb;
1650         r = MsiDatabaseOpenView(hdb, szQueryBuf, &hviews[i]);
1651         if( r != ERROR_SUCCESS || hviews[i] == 0xdeadbeeb ||
1652             hviews[i] == 0 || (i && (hviews[i] == hviews[i-1])))
1653             break;
1654     }
1655
1656     ok( i == MY_NVIEWS, "problem opening views\n");
1657
1658     for (i=0; i<MY_NVIEWS; i++) {
1659         if (hviews[i] != 0 && hviews[i] != 0xdeadbeeb) {
1660             r = MsiCloseHandle(hviews[i]);
1661             if (r != ERROR_SUCCESS)
1662                 break;
1663         }
1664     }
1665
1666     ok( i == MY_NVIEWS, "problem closing views\n");
1667
1668     r = MsiCloseHandle(hdb);
1669     ok( r == ERROR_SUCCESS, "failed to close database\n");
1670 }
1671
1672 static void test_generate_transform(void)
1673 {
1674     MSIHANDLE hdb1, hdb2;
1675     LPCSTR query;
1676     UINT r;
1677
1678     DeleteFile(msifile);
1679     DeleteFile(msifile2);
1680     DeleteFile(mstfile);
1681
1682     /* create an empty database */
1683     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb1 );
1684     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
1685
1686     r = MsiDatabaseCommit( hdb1 );
1687     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1688
1689     /* create another empty database */
1690     r = MsiOpenDatabase(msifile2, MSIDBOPEN_CREATE, &hdb2 );
1691     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
1692
1693     r = MsiDatabaseCommit( hdb2 );
1694     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1695
1696     /* the transform between two empty database should be empty */
1697     r = MsiDatabaseGenerateTransform(hdb1, hdb2, NULL, 0, 0);
1698     todo_wine {
1699     ok( r == ERROR_NO_DATA, "return code %d, should be ERROR_NO_DATA\n", r );
1700     }
1701
1702     query = "CREATE TABLE `AAR` ( `BAR` SHORT NOT NULL, `CAR` CHAR(255) PRIMARY KEY `CAR`)";
1703     r = run_query(hdb1, 0, query);
1704     ok(r == ERROR_SUCCESS, "failed to add table\n");
1705
1706     todo_wine {
1707     r = MsiDatabaseGenerateTransform(hdb1, hdb2, NULL, 0, 0);
1708     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
1709
1710     r = MsiDatabaseGenerateTransform(hdb1, hdb2, mstfile, 0, 0);
1711     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
1712
1713     MsiCloseHandle( hdb1 );
1714
1715     r = MsiDatabaseApplyTransform( hdb2, mstfile, 0 );
1716     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
1717
1718     /* apply the same transform again? */
1719     r = MsiDatabaseApplyTransform( hdb2, mstfile, 0 );
1720     ok( r == ERROR_INSTALL_TRANSFORM_FAILURE,
1721        "return code %d, should be ERROR_INSTALL_TRANSFORM_FAILURE\n", r );
1722     }
1723
1724     MsiCloseHandle( hdb2 );
1725
1726     DeleteFile(msifile);
1727     DeleteFile(msifile2);
1728     DeleteFile(mstfile);
1729 }
1730
1731 struct join_res
1732 {
1733     const CHAR one[MAX_PATH];
1734     const CHAR two[MAX_PATH];
1735 };
1736
1737 static const struct join_res join_res_first[] =
1738 {
1739     { "alveolar", "procerus" },
1740     { "septum", "procerus" },
1741     { "septum", "nasalis" },
1742     { "ramus", "nasalis" },
1743     { "malar", "mentalis" },
1744 };
1745
1746 static const struct join_res join_res_second[] =
1747 {
1748     { "nasal", "septum" },
1749     { "mandible", "ramus" },
1750 };
1751
1752 static const struct join_res join_res_third[] =
1753 {
1754     { "msvcp.dll", "abcdefgh" },
1755     { "msvcr.dll", "ijklmnop" },
1756 };
1757
1758 static const struct join_res join_res_fourth[] =
1759 {
1760     { "msvcp.dll.01234", "single.dll.31415" },
1761 };
1762
1763 static const struct join_res join_res_fifth[] =
1764 {
1765     { "malar", "procerus" },
1766 };
1767
1768 static const struct join_res join_res_sixth[] =
1769 {
1770     { "malar", "procerus" },
1771     { "malar", "procerus" },
1772     { "malar", "nasalis" },
1773     { "malar", "nasalis" },
1774     { "malar", "nasalis" },
1775     { "malar", "mentalis" },
1776 };
1777
1778 static const struct join_res join_res_seventh[] =
1779 {
1780     { "malar", "nasalis" },
1781     { "malar", "nasalis" },
1782     { "malar", "nasalis" },
1783 };
1784
1785 static void test_join(void)
1786 {
1787     MSIHANDLE hdb, hview, hrec;
1788     LPCSTR query;
1789     CHAR buf[MAX_PATH];
1790     UINT r, count;
1791     DWORD size, i;
1792
1793     hdb = create_db();
1794     ok( hdb, "failed to create db\n");
1795
1796     r = create_component_table( hdb );
1797     ok( r == ERROR_SUCCESS, "cannot create Component table: %d\n", r );
1798
1799     r = add_component_entry( hdb, "'zygomatic', 'malar', 'INSTALLDIR', 0, '', ''" );
1800     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
1801
1802     r = add_component_entry( hdb, "'maxilla', 'alveolar', 'INSTALLDIR', 0, '', ''" );
1803     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
1804
1805     r = add_component_entry( hdb, "'nasal', 'septum', 'INSTALLDIR', 0, '', ''" );
1806     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
1807
1808     r = add_component_entry( hdb, "'mandible', 'ramus', 'INSTALLDIR', 0, '', ''" );
1809     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
1810
1811     r = create_feature_components_table( hdb );
1812     ok( r == ERROR_SUCCESS, "cannot create FeatureComponents table: %d\n", r );
1813
1814     r = add_feature_components_entry( hdb, "'procerus', 'maxilla'" );
1815     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
1816
1817     r = add_feature_components_entry( hdb, "'procerus', 'nasal'" );
1818     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
1819
1820     r = add_feature_components_entry( hdb, "'nasalis', 'nasal'" );
1821     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
1822
1823     r = add_feature_components_entry( hdb, "'nasalis', 'mandible'" );
1824     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
1825
1826     r = add_feature_components_entry( hdb, "'nasalis', 'notacomponent'" );
1827     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
1828
1829     r = add_feature_components_entry( hdb, "'mentalis', 'zygomatic'" );
1830     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
1831
1832     r = create_std_dlls_table( hdb );
1833     ok( r == ERROR_SUCCESS, "cannot create StdDlls table: %d\n", r );
1834
1835     r = add_std_dlls_entry( hdb, "'msvcp.dll', 'msvcp.dll.01234'" );
1836     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
1837
1838     r = add_std_dlls_entry( hdb, "'msvcr.dll', 'msvcr.dll.56789'" );
1839     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
1840
1841     r = create_binary_table( hdb );
1842     ok( r == ERROR_SUCCESS, "cannot create Binary table: %d\n", r );
1843
1844     r = add_binary_entry( hdb, "'msvcp.dll.01234', 'abcdefgh'" );
1845     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
1846
1847     r = add_binary_entry( hdb, "'msvcr.dll.56789', 'ijklmnop'" );
1848     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
1849
1850     r = add_binary_entry( hdb, "'single.dll.31415', 'msvcp.dll'" );
1851     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
1852
1853     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
1854             "FROM `Component`, `FeatureComponents` "
1855             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
1856             "ORDER BY `Feature_`";
1857     r = MsiDatabaseOpenView(hdb, query, &hview);
1858     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1859
1860     r = MsiViewExecute(hview, 0);
1861     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1862
1863     i = 0;
1864     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
1865     {
1866         count = MsiRecordGetFieldCount( hrec );
1867         ok( count == 2, "Expected 2 record fields, got %d\n", count );
1868
1869         size = MAX_PATH;
1870         r = MsiRecordGetString( hrec, 1, buf, &size );
1871         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1872         if (i == 2 || i == 3) todo_wine
1873         {
1874             ok( !lstrcmp( buf, join_res_first[i].one ),
1875                 "Expected '%s', got %s\n", join_res_first[i].one, buf );
1876         }
1877
1878         size = MAX_PATH;
1879         r = MsiRecordGetString( hrec, 2, buf, &size );
1880         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1881         if (i == 3) todo_wine
1882         {
1883             ok( !lstrcmp( buf, join_res_first[i].two ),
1884                 "Expected '%s', got %s\n", join_res_first[i].two, buf );
1885         }
1886
1887         i++;
1888         MsiCloseHandle(hrec);
1889     }
1890
1891     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
1892
1893     MsiViewClose(hview);
1894     MsiCloseHandle(hview);
1895
1896     query = "SELECT DISTINCT Component, ComponentId FROM FeatureComponents, Component "
1897             "WHERE FeatureComponents.Component_=Component.Component "
1898             "AND (Feature_='nasalis') ORDER BY Feature_";
1899     r = MsiDatabaseOpenView(hdb, query, &hview);
1900     todo_wine
1901     {
1902         ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1903     }
1904
1905     r = MsiViewExecute(hview, 0);
1906     todo_wine
1907     {
1908         ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1909     }
1910
1911     i = 0;
1912     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
1913     {
1914         count = MsiRecordGetFieldCount( hrec );
1915         ok( count == 2, "Expected 2 record fields, got %d\n", count );
1916
1917         size = MAX_PATH;
1918         r = MsiRecordGetString( hrec, 1, buf, &size );
1919         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1920         ok( !lstrcmp( buf, join_res_second[i].one ),
1921             "Expected '%s', got %s\n", join_res_second[i].one, buf );
1922
1923         size = MAX_PATH;
1924         r = MsiRecordGetString( hrec, 2, buf, &size );
1925         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1926         ok( !lstrcmp( buf, join_res_second[i].two ),
1927             "Expected '%s', got %s\n", join_res_second[i].two, buf );
1928
1929         i++;
1930         MsiCloseHandle(hrec);
1931     }
1932
1933     todo_wine
1934     {
1935         ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
1936     }
1937
1938     MsiViewClose(hview);
1939     MsiCloseHandle(hview);
1940
1941     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
1942             "FROM `StdDlls`, `Binary` "
1943             "WHERE `StdDlls`.`Binary_` = `Binary`.`Name` "
1944             "ORDER BY `File`";
1945     r = MsiDatabaseOpenView(hdb, query, &hview);
1946     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1947
1948     r = MsiViewExecute(hview, 0);
1949     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1950
1951     i = 0;
1952     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
1953     {
1954         count = MsiRecordGetFieldCount( hrec );
1955         ok( count == 2, "Expected 2 record fields, got %d\n", count );
1956
1957         size = MAX_PATH;
1958         r = MsiRecordGetString( hrec, 1, buf, &size );
1959         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1960         ok( !lstrcmp( buf, join_res_third[i].one ),
1961             "Expected '%s', got %s\n", join_res_third[i].one, buf );
1962
1963         size = MAX_PATH;
1964         r = MsiRecordGetString( hrec, 2, buf, &size );
1965         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1966         ok( !lstrcmp( buf, join_res_third[i].two ),
1967             "Expected '%s', got %s\n", join_res_third[i].two, buf );
1968
1969         i++;
1970         MsiCloseHandle(hrec);
1971     }
1972
1973     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
1974
1975     MsiViewClose(hview);
1976     MsiCloseHandle(hview);
1977
1978     query = "SELECT `StdDlls`.`Binary_`, `Binary`.`Name` "
1979             "FROM `StdDlls`, `Binary` "
1980             "WHERE `StdDlls`.`File` = `Binary`.`Data` "
1981             "ORDER BY `Name`";
1982     r = MsiDatabaseOpenView(hdb, query, &hview);
1983     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1984
1985     r = MsiViewExecute(hview, 0);
1986     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1987
1988     i = 0;
1989     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
1990     {
1991         count = MsiRecordGetFieldCount( hrec );
1992         ok( count == 2, "Expected 2 record fields, got %d\n", count );
1993
1994         size = MAX_PATH;
1995         r = MsiRecordGetString( hrec, 1, buf, &size );
1996         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1997         ok( !lstrcmp( buf, join_res_fourth[i].one ),
1998             "Expected '%s', got %s\n", join_res_fourth[i].one, buf );
1999
2000         size = MAX_PATH;
2001         r = MsiRecordGetString( hrec, 2, buf, &size );
2002         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2003         ok( !lstrcmp( buf, join_res_fourth[i].two ),
2004             "Expected '%s', got %s\n", join_res_fourth[i].two, buf );
2005
2006         i++;
2007         MsiCloseHandle(hrec);
2008     }
2009
2010     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2011
2012     MsiViewClose(hview);
2013     MsiCloseHandle(hview);
2014
2015     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2016             "FROM `Component`, `FeatureComponents` "
2017             "WHERE `Component`.`Component` = 'zygomatic' "
2018             "AND `FeatureComponents`.`Component_` = 'maxilla' "
2019             "ORDER BY `Feature_`";
2020     r = MsiDatabaseOpenView(hdb, query, &hview);
2021     todo_wine
2022     {
2023         ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2024     }
2025
2026     r = MsiViewExecute(hview, 0);
2027     todo_wine
2028     {
2029         ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2030     }
2031
2032     i = 0;
2033     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2034     {
2035         count = MsiRecordGetFieldCount( hrec );
2036         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2037
2038         size = MAX_PATH;
2039         r = MsiRecordGetString( hrec, 1, buf, &size );
2040         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2041         ok( !lstrcmp( buf, join_res_fifth[i].one ),
2042             "Expected '%s', got %s\n", join_res_fifth[i].one, buf );
2043
2044         size = MAX_PATH;
2045         r = MsiRecordGetString( hrec, 2, buf, &size );
2046         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2047         ok( !lstrcmp( buf, join_res_fifth[i].two ),
2048             "Expected '%s', got %s\n", join_res_fifth[i].two, buf );
2049
2050         i++;
2051         MsiCloseHandle(hrec);
2052     }
2053
2054     todo_wine
2055     {
2056         ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2057     }
2058
2059     MsiViewClose(hview);
2060     MsiCloseHandle(hview);
2061
2062     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2063             "FROM `Component`, `FeatureComponents` "
2064             "WHERE `Component` = 'zygomatic' "
2065             "ORDER BY `Feature_`";
2066     r = MsiDatabaseOpenView(hdb, query, &hview);
2067     todo_wine
2068     {
2069         ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2070     }
2071
2072     r = MsiViewExecute(hview, 0);
2073     todo_wine
2074     {
2075         ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2076     }
2077
2078     i = 0;
2079     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2080     {
2081         count = MsiRecordGetFieldCount( hrec );
2082         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2083
2084         size = MAX_PATH;
2085         r = MsiRecordGetString( hrec, 1, buf, &size );
2086         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2087         ok( !lstrcmp( buf, join_res_sixth[i].one ),
2088             "Expected '%s', got %s\n", join_res_sixth[i].one, buf );
2089
2090         size = MAX_PATH;
2091         r = MsiRecordGetString( hrec, 2, buf, &size );
2092         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2093         ok( !lstrcmp( buf, join_res_sixth[i].two ),
2094             "Expected '%s', got %s\n", join_res_sixth[i].two, buf );
2095
2096         i++;
2097         MsiCloseHandle(hrec);
2098     }
2099
2100     todo_wine
2101     {
2102         ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2103     }
2104
2105     MsiViewClose(hview);
2106     MsiCloseHandle(hview);
2107
2108     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2109             "FROM `Component`, `FeatureComponents` "
2110             "WHERE `Component` = 'zygomatic' "
2111             "AND `Feature_` = 'nasalis' "
2112             "ORDER BY `Feature_`";
2113     r = MsiDatabaseOpenView(hdb, query, &hview);
2114     todo_wine
2115     {
2116         ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2117     }
2118
2119     r = MsiViewExecute(hview, 0);
2120     todo_wine
2121     {
2122         ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2123     }
2124
2125     i = 0;
2126     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2127     {
2128         count = MsiRecordGetFieldCount( hrec );
2129         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2130
2131         size = MAX_PATH;
2132         r = MsiRecordGetString( hrec, 1, buf, &size );
2133         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2134         ok( !lstrcmp( buf, join_res_seventh[i].one ),
2135             "Expected '%s', got %s\n", join_res_seventh[i].one, buf );
2136
2137         size = MAX_PATH;
2138         r = MsiRecordGetString( hrec, 2, buf, &size );
2139         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2140         ok( !lstrcmp( buf, join_res_seventh[i].two ),
2141             "Expected '%s', got %s\n", join_res_seventh[i].two, buf );
2142
2143         i++;
2144         MsiCloseHandle(hrec);
2145     }
2146
2147     todo_wine
2148     {
2149         ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2150     }
2151
2152     MsiViewClose(hview);
2153     MsiCloseHandle(hview);
2154     MsiCloseHandle(hdb);
2155     DeleteFile(msifile);
2156 }
2157
2158 static void test_temporary_table(void)
2159 {
2160     MSICONDITION cond;
2161     MSIHANDLE hdb = 0, view = 0, rec;
2162     const char *query;
2163     UINT r;
2164     char buf[0x10];
2165     DWORD sz;
2166
2167     cond = MsiDatabaseIsTablePersistent(0, NULL);
2168     todo_wine ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
2169
2170     hdb = create_db();
2171     ok( hdb, "failed to create db\n");
2172
2173     todo_wine {
2174     cond = MsiDatabaseIsTablePersistent(hdb, NULL);
2175     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
2176
2177     cond = MsiDatabaseIsTablePersistent(hdb, "_Tables");
2178     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2179
2180     cond = MsiDatabaseIsTablePersistent(hdb, "_Columns");
2181     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2182
2183     cond = MsiDatabaseIsTablePersistent(hdb, "_Streams");
2184     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2185     }
2186
2187     query = "CREATE TABLE `P` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`)";
2188     r = run_query(hdb, 0, query);
2189     ok(r == ERROR_SUCCESS, "failed to add table\n");
2190
2191     cond = MsiDatabaseIsTablePersistent(hdb, "P");
2192     todo_wine ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
2193
2194     query = "CREATE TABLE `P2` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`) HOLD";
2195     r = run_query(hdb, 0, query);
2196     ok(r == ERROR_SUCCESS, "failed to add table\n");
2197
2198     todo_wine {
2199     cond = MsiDatabaseIsTablePersistent(hdb, "P");
2200     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
2201     }
2202
2203     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
2204     r = run_query(hdb, 0, query);
2205     ok(r == ERROR_SUCCESS, "failed to add table\n");
2206
2207     cond = MsiDatabaseIsTablePersistent(hdb, "T");
2208     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
2209
2210     query = "CREATE TABLE `T2` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
2211     r = run_query(hdb, 0, query);
2212     ok(r == ERROR_SUCCESS, "failed to add table\n");
2213
2214     todo_wine {
2215     cond = MsiDatabaseIsTablePersistent(hdb, "T2");
2216     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2217     }
2218
2219     query = "CREATE TABLE `T3` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) PRIMARY KEY `C`)";
2220     r = run_query(hdb, 0, query);
2221     ok(r == ERROR_SUCCESS, "failed to add table\n");
2222
2223     todo_wine {
2224     cond = MsiDatabaseIsTablePersistent(hdb, "T3");
2225     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
2226
2227     query = "CREATE TABLE `T4` ( `B` SHORT NOT NULL, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
2228     r = run_query(hdb, 0, query);
2229     ok(r == ERROR_FUNCTION_FAILED, "failed to add table\n");
2230
2231     cond = MsiDatabaseIsTablePersistent(hdb, "T4");
2232     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2233     }
2234
2235     query = "CREATE TABLE `T5` ( `B` SHORT NOT NULL TEMP, `C` CHAR(255) TEMP PRIMARY KEY `C`) HOLD";
2236     r = run_query(hdb, 0, query);
2237     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to add table\n");
2238
2239     query = "select * from `T`";
2240     r = MsiDatabaseOpenView(hdb, query, &view);
2241     ok(r == ERROR_SUCCESS, "failed to query table\n");
2242     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2243     ok(r == ERROR_SUCCESS, "failed to get column info\n");
2244
2245     sz = sizeof buf;
2246     r = MsiRecordGetString(rec, 1, buf, &sz);
2247     ok(r == ERROR_SUCCESS, "failed to get string\n");
2248     todo_wine ok( 0 == strcmp("G255", buf), "wrong column type\n");
2249
2250     sz = sizeof buf;
2251     r = MsiRecordGetString(rec, 2, buf, &sz);
2252     ok(r == ERROR_SUCCESS, "failed to get string\n");
2253     todo_wine ok( 0 == strcmp("j2", buf), "wrong column type\n");
2254
2255     MsiCloseHandle( rec );
2256     MsiCloseHandle( view );
2257
2258     /* query the table data */
2259     rec = 0;
2260     r = do_query(hdb, "select * from `_Tables` where `Name` = 'T'", &rec);
2261     ok( r == ERROR_SUCCESS, "temporary table exists in _Tables\n");
2262     MsiCloseHandle( rec );
2263
2264     todo_wine {
2265     /* query the column data */
2266     rec = 0;
2267     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'B'", &rec);
2268     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
2269
2270     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'C'", &rec);
2271     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
2272     }
2273
2274     MsiCloseHandle( hdb );
2275
2276     DeleteFile(msifile);
2277 }
2278
2279 START_TEST(db)
2280 {
2281     test_msidatabase();
2282     test_msiinsert();
2283     test_msidecomposedesc();
2284     test_msibadqueries();
2285     test_viewmodify();
2286     test_viewgetcolumninfo();
2287     test_getcolinfo();
2288     test_msiexport();
2289     test_longstrings();
2290     test_streamtable();
2291     test_where();
2292     test_msiimport();
2293     test_markers();
2294     test_handle_limit();
2295     test_generate_transform();
2296     test_join();
2297     test_temporary_table();
2298 }