git.oblomov.eu Git - wine/blob - 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
  21 #define COBJMACROS
  22
  23 #include <stdio.h>
  24
  25 #include <windows.h>
  26 #include <msi.h>
  27 #include <msidefs.h>
  28 #include <msiquery.h>
  29
  30 #include <objidl.h>
  31
  32 #include "wine/test.h"
  33
  34 static const char *msifile = "winetest-db.msi";
  35 static const char *msifile2 = "winetst2-db.msi";
  36 static const char *mstfile = "winetst-db.mst";
  37 static const WCHAR msifileW[] = {'w','i','n','e','t','e','s','t','-','d','b','.','m','s','i',0};
  38
  39 static void test_msidatabase(void)
  40 {
  41     MSIHANDLE hdb = 0, hdb2 = 0;
  42     UINT res;
  43
  44     DeleteFile(msifile);
  45
  46     res = MsiOpenDatabase( msifile, msifile2, &hdb );
  47     ok( res == ERROR_OPEN_FAILED, "expected failure\n");
  48
  49     res = MsiOpenDatabase( msifile, (LPSTR) 0xff, &hdb );
  50     ok( res == ERROR_INVALID_PARAMETER, "expected failure\n");
  51
  52     res = MsiCloseHandle( hdb );
  53     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  54
  55     /* create an empty database */
  56     res = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb );
  57     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
  58
  59     res = MsiDatabaseCommit( hdb );
  60     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  61
  62     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
  63
  64     res = MsiCloseHandle( hdb );
  65     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  66     res = MsiOpenDatabase( msifile, msifile2, &hdb2 );
  67     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  68
  69     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile2 ), "database should exist\n");
  70
  71     res = MsiDatabaseCommit( hdb2 );
  72     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  73
  74     res = MsiCloseHandle( hdb2 );
  75     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  76
  77     res = MsiOpenDatabase( msifile, msifile2, &hdb2 );
  78     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  79
  80     res = MsiCloseHandle( hdb2 );
  81     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  82
  83     ok( INVALID_FILE_ATTRIBUTES == GetFileAttributes( msifile2 ), "uncommitted database should not exist\n");
  84
  85     res = MsiOpenDatabase( msifile, msifile2, &hdb2 );
  86     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  87
  88     res = MsiDatabaseCommit( hdb2 );
  89     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  90
  91     res = MsiCloseHandle( hdb2 );
  92     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  93
  94     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile2 ), "committed database should exist\n");
  95
  96     res = MsiOpenDatabase( msifile, MSIDBOPEN_READONLY, &hdb );
  97     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  98
  99     res = MsiCloseHandle( hdb );
 100     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 101
 102     res = MsiOpenDatabase( msifile, MSIDBOPEN_DIRECT, &hdb );
 103     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 104
 105     res = MsiCloseHandle( hdb );
 106     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 107
 108     res = MsiOpenDatabase( msifile, MSIDBOPEN_TRANSACT, &hdb );
 109     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 110
 111     res = MsiCloseHandle( hdb );
 112     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 113     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
 114
 115     /* MSIDBOPEN_CREATE deletes the database if MsiCommitDatabase isn't called */
 116     res = MsiOpenDatabase( msifile, MSIDBOPEN_CREATE, &hdb );
 117     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 118
 119     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
 120
 121     res = MsiCloseHandle( hdb );
 122     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 123
 124     ok( INVALID_FILE_ATTRIBUTES == GetFileAttributes( msifile ), "database should exist\n");
 125
 126     res = MsiOpenDatabase( msifile, MSIDBOPEN_CREATE, &hdb );
 127     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 128
 129     res = MsiDatabaseCommit( hdb );
 130     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 131
 132     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
 133
 134     res = MsiCloseHandle( hdb );
 135     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 136
 137     res = DeleteFile( msifile2 );
 138     ok( res == TRUE, "Failed to delete database\n" );
 139
 140     res = DeleteFile( msifile );
 141     ok( res == TRUE, "Failed to delete database\n" );
 142 }
 143
 144 static UINT do_query(MSIHANDLE hdb, const char *query, MSIHANDLE *phrec)
 145 {
 146     MSIHANDLE hview = 0;
 147     UINT r, ret;
 148
 149     if (phrec)
 150         *phrec = 0;
 151
 152     /* open a select query */
 153     r = MsiDatabaseOpenView(hdb, query, &hview);
 154     if (r != ERROR_SUCCESS)
 155         return r;
 156     r = MsiViewExecute(hview, 0);
 157     if (r != ERROR_SUCCESS)
 158         return r;
 159     ret = MsiViewFetch(hview, phrec);
 160     r = MsiViewClose(hview);
 161     if (r != ERROR_SUCCESS)
 162         return r;
 163     r = MsiCloseHandle(hview);
 164     if (r != ERROR_SUCCESS)
 165         return r;
 166     return ret;
 167 }
 168
 169 static UINT run_query( MSIHANDLE hdb, MSIHANDLE hrec, const char *query )
 170 {
 171     MSIHANDLE hview = 0;
 172     UINT r;
 173
 174     r = MsiDatabaseOpenView(hdb, query, &hview);
 175     if( r != ERROR_SUCCESS )
 176         return r;
 177
 178     r = MsiViewExecute(hview, hrec);
 179     if( r == ERROR_SUCCESS )
 180         r = MsiViewClose(hview);
 181     MsiCloseHandle(hview);
 182     return r;
 183 }
 184
 185 static UINT create_component_table( MSIHANDLE hdb )
 186 {
 187     return run_query( hdb, 0,
 188             "CREATE TABLE `Component` ( "
 189             "`Component` CHAR(72) NOT NULL, "
 190             "`ComponentId` CHAR(38), "
 191             "`Directory_` CHAR(72) NOT NULL, "
 192             "`Attributes` SHORT NOT NULL, "
 193             "`Condition` CHAR(255), "
 194             "`KeyPath` CHAR(72) "
 195             "PRIMARY KEY `Component`)" );
 196 }
 197
 198 static UINT create_custom_action_table( MSIHANDLE hdb )
 199 {
 200     return run_query( hdb, 0,
 201             "CREATE TABLE `CustomAction` ( "
 202             "`Action` CHAR(72) NOT NULL, "
 203             "`Type` SHORT NOT NULL, "
 204             "`Source` CHAR(72), "
 205             "`Target` CHAR(255) "
 206             "PRIMARY KEY `Action`)" );
 207 }
 208
 209 static UINT create_directory_table( MSIHANDLE hdb )
 210 {
 211     return run_query( hdb, 0,
 212             "CREATE TABLE `Directory` ( "
 213             "`Directory` CHAR(255) NOT NULL, "
 214             "`Directory_Parent` CHAR(255), "
 215             "`DefaultDir` CHAR(255) NOT NULL "
 216             "PRIMARY KEY `Directory`)" );
 217 }
 218
 219 static UINT create_feature_components_table( MSIHANDLE hdb )
 220 {
 221     return run_query( hdb, 0,
 222             "CREATE TABLE `FeatureComponents` ( "
 223             "`Feature_` CHAR(38) NOT NULL, "
 224             "`Component_` CHAR(72) NOT NULL "
 225             "PRIMARY KEY `Feature_`, `Component_` )" );
 226 }
 227
 228 static UINT create_std_dlls_table( MSIHANDLE hdb )
 229 {
 230     return run_query( hdb, 0,
 231             "CREATE TABLE `StdDlls` ( "
 232             "`File` CHAR(255) NOT NULL, "
 233             "`Binary_` CHAR(72) NOT NULL "
 234             "PRIMARY KEY `File` )" );
 235 }
 236
 237 static UINT create_binary_table( MSIHANDLE hdb )
 238 {
 239     return run_query( hdb, 0,
 240             "CREATE TABLE `Binary` ( "
 241             "`Name` CHAR(72) NOT NULL, "
 242             "`Data` CHAR(72) NOT NULL "
 243             "PRIMARY KEY `Name` )" );
 244 }
 245
 246 #define make_add_entry(type, qtext) \
 247     static UINT add##_##type##_##entry( MSIHANDLE hdb, const char *values ) \
 248     { \
 249         char insert[] = qtext; \
 250         char *query; \
 251         UINT sz, r; \
 252         sz = strlen(values) + sizeof insert; \
 253         query = HeapAlloc(GetProcessHeap(),0,sz); \
 254         sprintf(query,insert,values); \
 255         r = run_query( hdb, 0, query ); \
 256         HeapFree(GetProcessHeap(), 0, query); \
 257         return r; \
 258     }
 259
 260 make_add_entry(component,
 261                "INSERT INTO `Component`  "
 262                "(`Component`, `ComponentId`, `Directory_`, "
 263                "`Attributes`, `Condition`, `KeyPath`) VALUES( %s )")
 264
 265 make_add_entry(custom_action,
 266                "INSERT INTO `CustomAction`  "
 267                "(`Action`, `Type`, `Source`, `Target`) VALUES( %s )")
 268
 269 make_add_entry(feature_components,
 270                "INSERT INTO `FeatureComponents` "
 271                "(`Feature_`, `Component_`) VALUES( %s )")
 272
 273 make_add_entry(std_dlls,
 274                "INSERT INTO `StdDlls` (`File`, `Binary_`) VALUES( %s )")
 275
 276 make_add_entry(binary,
 277                "INSERT INTO `Binary` (`Name`, `Data`) VALUES( %s )")
 278
 279 static void test_msiinsert(void)
 280 {
 281     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 282     UINT r;
 283     const char *query;
 284     char buf[80];
 285     DWORD sz;
 286
 287     DeleteFile(msifile);
 288
 289     /* just MsiOpenDatabase should not create a file */
 290     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 291     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 292
 293     /* create a table */
 294     query = "CREATE TABLE `phone` ( "
 295             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 296             "PRIMARY KEY `id`)";
 297     r = MsiDatabaseOpenView(hdb, query, &hview);
 298     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 299     r = MsiViewExecute(hview, 0);
 300     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 301     r = MsiViewClose(hview);
 302     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 303     r = MsiCloseHandle(hview);
 304     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 305
 306     /* insert a value into it */
 307     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 308         "VALUES('1', 'Abe', '8675309')";
 309     r = MsiDatabaseOpenView(hdb, query, &hview);
 310     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 311     r = MsiViewExecute(hview, 0);
 312     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 313     r = MsiViewClose(hview);
 314     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 315     r = MsiCloseHandle(hview);
 316     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 317
 318     query = "SELECT * FROM `phone` WHERE `id` = 1";
 319     r = do_query(hdb, query, &hrec);
 320     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 321
 322     /* check the record contains what we put in it */
 323     r = MsiRecordGetFieldCount(hrec);
 324     ok(r == 3, "record count wrong\n");
 325
 326     r = MsiRecordIsNull(hrec, 0);
 327     ok(r == FALSE, "field 0 not null\n");
 328
 329     r = MsiRecordGetInteger(hrec, 1);
 330     ok(r == 1, "field 1 contents wrong\n");
 331     sz = sizeof buf;
 332     r = MsiRecordGetString(hrec, 2, buf, &sz);
 333     ok(r == ERROR_SUCCESS, "field 2 content fetch failed\n");
 334     ok(!strcmp(buf,"Abe"), "field 2 content incorrect\n");
 335     sz = sizeof buf;
 336     r = MsiRecordGetString(hrec, 3, buf, &sz);
 337     ok(r == ERROR_SUCCESS, "field 3 content fetch failed\n");
 338     ok(!strcmp(buf,"8675309"), "field 3 content incorrect\n");
 339
 340     r = MsiCloseHandle(hrec);
 341     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 342
 343     /* open a select query */
 344     hrec = 100;
 345     query = "SELECT * FROM `phone` WHERE `id` >= 10";
 346     r = do_query(hdb, query, &hrec);
 347     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 348     ok(hrec == 0, "hrec should be null\n");
 349
 350     r = MsiCloseHandle(hrec);
 351     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 352
 353     query = "SELECT * FROM `phone` WHERE `id` < 0";
 354     r = do_query(hdb, query, &hrec);
 355     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 356
 357     query = "SELECT * FROM `phone` WHERE `id` <= 0";
 358     r = do_query(hdb, query, &hrec);
 359     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 360
 361     query = "SELECT * FROM `phone` WHERE `id` <> 1";
 362     r = do_query(hdb, query, &hrec);
 363     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 364
 365     query = "SELECT * FROM `phone` WHERE `id` > 10";
 366     r = do_query(hdb, query, &hrec);
 367     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 368
 369     /* now try a few bad INSERT xqueries */
 370     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 371         "VALUES(?, ?)";
 372     r = MsiDatabaseOpenView(hdb, query, &hview);
 373     ok(r == ERROR_BAD_QUERY_SYNTAX, "MsiDatabaseOpenView failed\n");
 374
 375     /* construct a record to insert */
 376     hrec = MsiCreateRecord(4);
 377     r = MsiRecordSetInteger(hrec, 1, 2);
 378     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 379     r = MsiRecordSetString(hrec, 2, "Adam");
 380     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 381     r = MsiRecordSetString(hrec, 3, "96905305");
 382     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 383
 384     /* insert another value, using a record and wildcards */
 385     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 386         "VALUES(?, ?, ?)";
 387     r = MsiDatabaseOpenView(hdb, query, &hview);
 388     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 389
 390     if (r == ERROR_SUCCESS)
 391     {
 392         r = MsiViewExecute(hview, hrec);
 393         ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 394         r = MsiViewClose(hview);
 395         ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 396         r = MsiCloseHandle(hview);
 397         ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 398     }
 399     r = MsiCloseHandle(hrec);
 400     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 401
 402     r = MsiViewFetch(0, NULL);
 403     ok(r == ERROR_INVALID_PARAMETER, "MsiViewFetch failed\n");
 404
 405     r = MsiDatabaseCommit(hdb);
 406     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
 407
 408     r = MsiCloseHandle(hdb);
 409     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 410
 411     r = DeleteFile(msifile);
 412     ok(r == TRUE, "file didn't exist after commit\n");
 413 }
 414
 415 typedef UINT (WINAPI *fnMsiDecomposeDescriptorA)(LPCSTR, LPCSTR, LPSTR, LPSTR, DWORD *);
 416 static fnMsiDecomposeDescriptorA pMsiDecomposeDescriptorA;
 417
 418 static void test_msidecomposedesc(void)
 419 {
 420     char prod[MAX_FEATURE_CHARS+1], comp[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1];
 421     const char *desc;
 422     UINT r;
 423     DWORD len;
 424     HMODULE hmod;
 425
 426     hmod = GetModuleHandle("msi.dll");
 427     pMsiDecomposeDescriptorA = (fnMsiDecomposeDescriptorA)
 428         GetProcAddress(hmod, "MsiDecomposeDescriptorA");
 429     if (!pMsiDecomposeDescriptorA)
 430         return;
 431
 432     /* test a valid feature descriptor */
 433     desc = "']gAVn-}f(ZXfeAR6.jiFollowTheWhiteRabbit>3w2x^IGfe?CxI5heAvk.";
 434     len = 0;
 435     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 436     ok(r == ERROR_SUCCESS, "returned an error\n");
 437     ok(len == strlen(desc), "length was wrong\n");
 438     ok(strcmp(prod,"{90110409-6000-11D3-8CFE-0150048383C9}")==0, "product wrong\n");
 439     ok(strcmp(feature,"FollowTheWhiteRabbit")==0, "feature wrong\n");
 440     ok(strcmp(comp,"{A7CD68DB-EF74-49C8-FBB2-A7C463B2AC24}")==0,"component wrong\n");
 441
 442     /* test an invalid feature descriptor with too many characters */
 443     desc = "']gAVn-}f(ZXfeAR6.ji"
 444            "ThisWillFailIfTheresMoreThanAGuidsChars>"
 445            "3w2x^IGfe?CxI5heAvk.";
 446     len = 0;
 447     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 448     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 449
 450     /*
 451      * Test a valid feature descriptor with the
 452      * maximum number of characters and some trailing characters.
 453      */
 454     desc = "']gAVn-}f(ZXfeAR6.ji"
 455            "ThisWillWorkIfTheresLTEThanAGuidsChars>"
 456            "3w2x^IGfe?CxI5heAvk."
 457            "extra";
 458     len = 0;
 459     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 460     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 461     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 462
 463     len = 0;
 464     r = pMsiDecomposeDescriptorA(desc, prod, feature, NULL, &len);
 465     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 466     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 467
 468     len = 0;
 469     r = pMsiDecomposeDescriptorA(desc, prod, NULL, NULL, &len);
 470     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 471     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 472
 473     len = 0;
 474     r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, &len);
 475     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 476     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 477
 478     len = 0;
 479     r = pMsiDecomposeDescriptorA(NULL, NULL, NULL, NULL, &len);
 480     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 481     ok(len == 0, "length wrong\n");
 482
 483     r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, NULL);
 484     ok(r == ERROR_SUCCESS, "returned wrong error\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 = try_query( hdb, "select * from c");
 654     ok(r == ERROR_SUCCESS , "query failed\n");
 655
 656     r = try_query( hdb, "select * from c where b = 'x");
 657     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 658
 659     r = try_query( hdb, "select * from c where b = 'x'");
 660     ok(r == ERROR_SUCCESS, "query failed\n");
 661
 662     r = try_query( hdb, "select * from 'c'");
 663     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 664
 665     r = try_query( hdb, "select * from ''");
 666     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 667
 668     r = try_query( hdb, "select * from c where b = x");
 669     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 670
 671     r = try_query( hdb, "select * from c where b = \"x\"");
 672     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 673
 674     r = try_query( hdb, "select * from c where b = 'x'");
 675     ok(r == ERROR_SUCCESS, "query failed\n");
 676
 677     r = try_query( hdb, "select * from c where b = '\"x'");
 678     ok(r == ERROR_SUCCESS, "query failed\n");
 679
 680     if (0)  /* FIXME: this query causes trouble with other tests */
 681     {
 682         r = try_query( hdb, "select * from c where b = '\\\'x'");
 683         ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 684     }
 685
 686     r = try_query( hdb, "select * from 'c'");
 687     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 688
 689     r = try_query( hdb, "CREATE TABLE `\5a` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 690     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 691
 692     r = try_query( hdb, "SELECT * FROM \5a" );
 693     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 694
 695     r = try_query( hdb, "CREATE TABLE `a\5` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 696     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 697
 698     r = try_query( hdb, "SELECT * FROM a\5" );
 699     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 700
 701     r = try_query( hdb, "CREATE TABLE `-a` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 702     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 703
 704     r = try_query( hdb, "SELECT * FROM -a" );
 705     todo_wine ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 706
 707     r = try_query( hdb, "CREATE TABLE `a-` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 708     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 709
 710     r = try_query( hdb, "SELECT * FROM a-" );
 711     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 712
 713     r = MsiCloseHandle( hdb );
 714     ok(r == ERROR_SUCCESS , "Failed to close database transact\n");
 715
 716     r = DeleteFile( msifile );
 717     ok(r == TRUE, "file didn't exist after commit\n");
 718 }
 719
 720 static void test_viewmodify(void)
 721 {
 722     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 723     UINT r;
 724     MSIDBERROR err;
 725     const char *query;
 726     char buffer[0x100];
 727     DWORD sz;
 728
 729     DeleteFile(msifile);
 730
 731     /* just MsiOpenDatabase should not create a file */
 732     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 733     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 734
 735     query = "CREATE TABLE `phone` ( "
 736             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 737             "PRIMARY KEY `id`)";
 738     r = run_query( hdb, 0, query );
 739     ok(r == ERROR_SUCCESS, "query failed\n");
 740
 741     /* check what the error function reports without doing anything */
 742     sz = 0;
 743     /* passing NULL as the 3rd param make function to crash on older platforms */
 744     err = MsiViewGetError( 0, NULL, &sz );
 745     ok(err == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 746
 747     /* open a view */
 748     query = "SELECT * FROM `phone`";
 749     r = MsiDatabaseOpenView(hdb, query, &hview);
 750     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 751
 752     /* see what happens with a good hview and bad args */
 753     err = MsiViewGetError( hview, NULL, NULL );
 754     ok(err == MSIDBERROR_INVALIDARG || err == MSIDBERROR_NOERROR,
 755        "MsiViewGetError returns %u (expected -3)\n", err);
 756     err = MsiViewGetError( hview, buffer, NULL );
 757     ok(err == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 758
 759     /* see what happens with a zero length buffer */
 760     sz = 0;
 761     buffer[0] = 'x';
 762     err = MsiViewGetError( hview, buffer, &sz );
 763     ok(err == MSIDBERROR_MOREDATA, "MsiViewGetError return\n");
 764     ok(buffer[0] == 'x', "buffer cleared\n");
 765     ok(sz == 0, "size not zero\n");
 766
 767     /* ok this one is strange */
 768     sz = 0;
 769     err = MsiViewGetError( hview, NULL, &sz );
 770     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 771     ok(sz == 0, "size not zero\n");
 772
 773     /* see if it really has an error */
 774     sz = sizeof buffer;
 775     buffer[0] = 'x';
 776     err = MsiViewGetError( hview, buffer, &sz );
 777     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 778     ok(buffer[0] == 0, "buffer not cleared\n");
 779     ok(sz == 0, "size not zero\n");
 780
 781     r = MsiViewExecute(hview, 0);
 782     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 783
 784     /* try some invalid records */
 785     r = MsiViewModify(hview, MSIMODIFY_INSERT, 0 );
 786     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 787     r = MsiViewModify(hview, -1, 0 );
 788     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 789
 790     /* try an small record */
 791     hrec = MsiCreateRecord(1);
 792     r = MsiViewModify(hview, -1, hrec );
 793     ok(r == ERROR_INVALID_DATA, "MsiViewModify failed\n");
 794
 795     r = MsiCloseHandle(hrec);
 796     ok(r == ERROR_SUCCESS, "failed to close record\n");
 797
 798     /* insert a valid record */
 799     hrec = MsiCreateRecord(3);
 800
 801     r = MsiRecordSetInteger(hrec, 1, 1);
 802     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 803     r = MsiRecordSetString(hrec, 2, "bob");
 804     ok(r == ERROR_SUCCESS, "failed to set string\n");
 805     r = MsiRecordSetString(hrec, 3, "7654321");
 806     ok(r == ERROR_SUCCESS, "failed to set string\n");
 807
 808     r = MsiViewExecute(hview, 0);
 809     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 810     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 811     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 812
 813     /* insert the same thing again */
 814     r = MsiViewExecute(hview, 0);
 815     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 816
 817     /* should fail ... */
 818     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 819     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 820
 821     r = MsiCloseHandle(hrec);
 822     ok(r == ERROR_SUCCESS, "failed to close record\n");
 823
 824     r = MsiViewClose(hview);
 825     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 826     r = MsiCloseHandle(hview);
 827     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 828
 829     query = "SELECT * FROM `phone`";
 830     r = MsiDatabaseOpenView(hdb, query, &hview);
 831     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 832
 833     r = MsiViewExecute(hview, 0);
 834     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 835
 836     r = MsiViewFetch(hview, &hrec);
 837     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 838
 839     r = MsiRecordGetInteger(hrec, 1);
 840     ok(r == 1, "Expected 1, got %d\n", r);
 841
 842     sz = sizeof(buffer);
 843     r = MsiRecordGetString(hrec, 2, buffer, &sz);
 844     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 845     ok(!lstrcmp(buffer, "bob"), "Expected bob, got %s\n", buffer);
 846
 847     sz = sizeof(buffer);
 848     r = MsiRecordGetString(hrec, 3, buffer, &sz);
 849     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 850     ok(!lstrcmp(buffer, "7654321"), "Expected 7654321, got %s\n", buffer);
 851
 852     /* update the view, non-primary key */
 853     r = MsiRecordSetString(hrec, 3, "3141592");
 854     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 855
 856     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 857     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 858
 859     /* do it again */
 860     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 861     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
 862
 863     /* update the view, primary key */
 864     r = MsiRecordSetInteger(hrec, 1, 5);
 865     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 866
 867     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 868     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 869
 870     r = MsiCloseHandle(hrec);
 871     ok(r == ERROR_SUCCESS, "failed to close record\n");
 872
 873     r = MsiViewClose(hview);
 874     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 875     r = MsiCloseHandle(hview);
 876     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 877
 878     query = "SELECT * FROM `phone`";
 879     r = MsiDatabaseOpenView(hdb, query, &hview);
 880     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 881
 882     r = MsiViewExecute(hview, 0);
 883     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 884
 885     r = MsiViewFetch(hview, &hrec);
 886     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 887
 888     r = MsiRecordGetInteger(hrec, 1);
 889     ok(r == 1, "Expected 1, got %d\n", r);
 890
 891     sz = sizeof(buffer);
 892     r = MsiRecordGetString(hrec, 2, buffer, &sz);
 893     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 894     ok(!lstrcmp(buffer, "bob"), "Expected bob, got %s\n", buffer);
 895
 896     sz = sizeof(buffer);
 897     r = MsiRecordGetString(hrec, 3, buffer, &sz);
 898     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 899     ok(!lstrcmp(buffer, "3141592"), "Expected 3141592, got %s\n", buffer);
 900
 901     r = MsiCloseHandle(hrec);
 902     ok(r == ERROR_SUCCESS, "failed to close record\n");
 903
 904     /* use a record that doesn't come from a view fetch */
 905     hrec = MsiCreateRecord(3);
 906     ok(hrec != 0, "MsiCreateRecord failed\n");
 907
 908     r = MsiRecordSetInteger(hrec, 1, 3);
 909     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 910     r = MsiRecordSetString(hrec, 2, "jane");
 911     ok(r == ERROR_SUCCESS, "failed to set string\n");
 912     r = MsiRecordSetString(hrec, 3, "112358");
 913     ok(r == ERROR_SUCCESS, "failed to set string\n");
 914
 915     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 916     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
 917
 918     r = MsiCloseHandle(hrec);
 919     ok(r == ERROR_SUCCESS, "failed to close record\n");
 920
 921     /* use a record that doesn't come from a view fetch, primary key matches */
 922     hrec = MsiCreateRecord(3);
 923     ok(hrec != 0, "MsiCreateRecord failed\n");
 924
 925     r = MsiRecordSetInteger(hrec, 1, 1);
 926     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 927     r = MsiRecordSetString(hrec, 2, "jane");
 928     ok(r == ERROR_SUCCESS, "failed to set string\n");
 929     r = MsiRecordSetString(hrec, 3, "112358");
 930     ok(r == ERROR_SUCCESS, "failed to set string\n");
 931
 932     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 933     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 934
 935     r = MsiCloseHandle(hrec);
 936     ok(r == ERROR_SUCCESS, "failed to close record\n");
 937
 938     hrec = MsiCreateRecord(3);
 939
 940     r = MsiRecordSetInteger(hrec, 1, 2);
 941     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 942     r = MsiRecordSetString(hrec, 2, "nick");
 943     ok(r == ERROR_SUCCESS, "failed to set string\n");
 944     r = MsiRecordSetString(hrec, 3, "141421");
 945     ok(r == ERROR_SUCCESS, "failed to set string\n");
 946
 947     r = MsiViewExecute(hview, 0);
 948     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 949     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 950     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 951
 952     r = MsiCloseHandle(hrec);
 953     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 954     r = MsiViewClose(hview);
 955     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 956     r = MsiCloseHandle(hview);
 957     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 958
 959     query = "SELECT * FROM `phone` WHERE `id` = 1";
 960     r = MsiDatabaseOpenView(hdb, query, &hview);
 961     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 962     r = MsiViewExecute(hview, 0);
 963     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 964     r = MsiViewFetch(hview, &hrec);
 965     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 966
 967     /* change the id to match the second row */
 968     r = MsiRecordSetInteger(hrec, 1, 2);
 969     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 970     r = MsiRecordSetString(hrec, 2, "jerry");
 971     ok(r == ERROR_SUCCESS, "failed to set string\n");
 972
 973     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 974     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 975
 976     r = MsiCloseHandle(hrec);
 977     ok(r == ERROR_SUCCESS, "failed to close record\n");
 978     r = MsiViewClose(hview);
 979     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 980     r = MsiCloseHandle(hview);
 981     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 982
 983     /* broader search */
 984     query = "SELECT * FROM `phone` ORDER BY `id`";
 985     r = MsiDatabaseOpenView(hdb, query, &hview);
 986     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 987     r = MsiViewExecute(hview, 0);
 988     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 989     r = MsiViewFetch(hview, &hrec);
 990     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 991
 992     /* change the id to match the second row */
 993     r = MsiRecordSetInteger(hrec, 1, 2);
 994     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 995     r = MsiRecordSetString(hrec, 2, "jerry");
 996     ok(r == ERROR_SUCCESS, "failed to set string\n");
 997
 998     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 999     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
1000
1001     r = MsiCloseHandle(hrec);
1002     ok(r == ERROR_SUCCESS, "failed to close record\n");
1003     r = MsiViewClose(hview);
1004     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1005     r = MsiCloseHandle(hview);
1006     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1007
1008     r = MsiCloseHandle( hdb );
1009     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
1010 }
1011
1012 static MSIHANDLE create_db(void)
1013 {
1014     MSIHANDLE hdb = 0;
1015     UINT res;
1016
1017     DeleteFile(msifile);
1018
1019     /* create an empty database */
1020     res = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb );
1021     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
1022     if( res != ERROR_SUCCESS )
1023         return hdb;
1024
1025     res = MsiDatabaseCommit( hdb );
1026     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
1027
1028     return hdb;
1029 }
1030
1031 static void test_getcolinfo(void)
1032 {
1033     MSIHANDLE hdb, hview = 0, rec = 0;
1034     UINT r;
1035     DWORD sz;
1036     char buffer[0x20];
1037
1038     /* create an empty db */
1039     hdb = create_db();
1040     ok( hdb, "failed to create db\n");
1041
1042     /* tables should be present */
1043     r = MsiDatabaseOpenView(hdb, "select * from _Tables", &hview);
1044     ok( r == ERROR_SUCCESS, "failed to open query\n");
1045
1046     r = MsiViewExecute(hview, 0);
1047     ok( r == ERROR_SUCCESS, "failed to execute query\n");
1048
1049     /* check that NAMES works */
1050     rec = 0;
1051     r = MsiViewGetColumnInfo( hview, MSICOLINFO_NAMES, &rec );
1052     ok( r == ERROR_SUCCESS, "failed to get names\n");
1053     sz = sizeof buffer;
1054     r = MsiRecordGetString(rec, 1, buffer, &sz );
1055     ok( r == ERROR_SUCCESS, "failed to get string\n");
1056     ok( !strcmp(buffer,"Name"), "_Tables has wrong column name\n");
1057     r = MsiCloseHandle( rec );
1058     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
1059
1060     /* check that TYPES works */
1061     rec = 0;
1062     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, &rec );
1063     ok( r == ERROR_SUCCESS, "failed to get names\n");
1064     sz = sizeof buffer;
1065     r = MsiRecordGetString(rec, 1, buffer, &sz );
1066     ok( r == ERROR_SUCCESS, "failed to get string\n");
1067     ok( !strcmp(buffer,"s64"), "_Tables has wrong column type\n");
1068     r = MsiCloseHandle( rec );
1069     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
1070
1071     /* check that invalid values fail */
1072     rec = 0;
1073     r = MsiViewGetColumnInfo( hview, 100, &rec );
1074     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
1075     ok( rec == 0, "returned a record\n");
1076
1077     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, NULL );
1078     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
1079
1080     r = MsiViewGetColumnInfo( 0, MSICOLINFO_TYPES, &rec );
1081     ok( r == ERROR_INVALID_HANDLE, "wrong error code\n");
1082
1083     r = MsiViewClose(hview);
1084     ok( r == ERROR_SUCCESS, "failed to close view\n");
1085     r = MsiCloseHandle(hview);
1086     ok( r == ERROR_SUCCESS, "failed to close view handle\n");
1087     r = MsiCloseHandle(hdb);
1088     ok( r == ERROR_SUCCESS, "failed to close database\n");
1089 }
1090
1091 static MSIHANDLE get_column_info(MSIHANDLE hdb, const char *query, MSICOLINFO type)
1092 {
1093     MSIHANDLE hview = 0, rec = 0;
1094     UINT r;
1095
1096     r = MsiDatabaseOpenView(hdb, query, &hview);
1097     if( r != ERROR_SUCCESS )
1098         return r;
1099
1100     r = MsiViewExecute(hview, 0);
1101     if( r == ERROR_SUCCESS )
1102     {
1103         MsiViewGetColumnInfo( hview, type, &rec );
1104     }
1105     MsiViewClose(hview);
1106     MsiCloseHandle(hview);
1107     return rec;
1108 }
1109
1110 static UINT get_columns_table_type(MSIHANDLE hdb, const char *table, UINT field)
1111 {
1112     MSIHANDLE hview = 0, rec = 0;
1113     UINT r, type = 0;
1114     char query[0x100];
1115
1116     sprintf(query, "select * from `_Columns` where  `Table` = '%s'", table );
1117
1118     r = MsiDatabaseOpenView(hdb, query, &hview);
1119     if( r != ERROR_SUCCESS )
1120         return r;
1121
1122     r = MsiViewExecute(hview, 0);
1123     if( r == ERROR_SUCCESS )
1124     {
1125         while (1)
1126         {
1127             r = MsiViewFetch( hview, &rec );
1128             if( r != ERROR_SUCCESS)
1129                 break;
1130             r = MsiRecordGetInteger( rec, 2 );
1131             if (r == field)
1132                 type = MsiRecordGetInteger( rec, 4 );
1133             MsiCloseHandle( rec );
1134         }
1135     }
1136     MsiViewClose(hview);
1137     MsiCloseHandle(hview);
1138     return type;
1139 }
1140
1141 static BOOL check_record( MSIHANDLE rec, UINT field, LPCSTR val )
1142 {
1143     CHAR buffer[0x20];
1144     UINT r;
1145     DWORD sz;
1146
1147     sz = sizeof buffer;
1148     r = MsiRecordGetString( rec, field, buffer, &sz );
1149     return (r == ERROR_SUCCESS ) && !strcmp(val, buffer);
1150 }
1151
1152 static void test_viewgetcolumninfo(void)
1153 {
1154     MSIHANDLE hdb = 0, rec;
1155     UINT r;
1156
1157     hdb = create_db();
1158     ok( hdb, "failed to create db\n");
1159
1160     r = run_query( hdb, 0,
1161             "CREATE TABLE `Properties` "
1162             "( `Property` CHAR(255), "
1163             "  `Value` CHAR(1), "
1164             "  `Intvalue` INT, "
1165             "  `Integervalue` INTEGER, "
1166             "  `Shortvalue` SHORT, "
1167             "  `Longvalue` LONG, "
1168             "  `Longcharvalue` LONGCHAR "
1169             "  PRIMARY KEY `Property`)" );
1170     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1171
1172     /* check the column types */
1173     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_TYPES );
1174     ok( rec, "failed to get column info record\n" );
1175
1176     ok( check_record( rec, 1, "S255"), "wrong record type\n");
1177     ok( check_record( rec, 2, "S1"), "wrong record type\n");
1178     ok( check_record( rec, 3, "I2"), "wrong record type\n");
1179     ok( check_record( rec, 4, "I2"), "wrong record type\n");
1180     ok( check_record( rec, 5, "I2"), "wrong record type\n");
1181     ok( check_record( rec, 6, "I4"), "wrong record type\n");
1182     ok( check_record( rec, 7, "S0"), "wrong record type\n");
1183
1184     MsiCloseHandle( rec );
1185
1186     /* check the type in _Columns */
1187     ok( 0x3dff == get_columns_table_type(hdb, "Properties", 1 ), "_columns table wrong\n");
1188     ok( 0x1d01 == get_columns_table_type(hdb, "Properties", 2 ), "_columns table wrong\n");
1189     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 3 ), "_columns table wrong\n");
1190     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 4 ), "_columns table wrong\n");
1191     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 5 ), "_columns table wrong\n");
1192     ok( 0x1104 == get_columns_table_type(hdb, "Properties", 6 ), "_columns table wrong\n");
1193     ok( 0x1d00 == get_columns_table_type(hdb, "Properties", 7 ), "_columns table wrong\n");
1194
1195     /* now try the names */
1196     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_NAMES );
1197     ok( rec, "failed to get column info record\n" );
1198
1199     ok( check_record( rec, 1, "Property"), "wrong record type\n");
1200     ok( check_record( rec, 2, "Value"), "wrong record type\n");
1201     ok( check_record( rec, 3, "Intvalue"), "wrong record type\n");
1202     ok( check_record( rec, 4, "Integervalue"), "wrong record type\n");
1203     ok( check_record( rec, 5, "Shortvalue"), "wrong record type\n");
1204     ok( check_record( rec, 6, "Longvalue"), "wrong record type\n");
1205     ok( check_record( rec, 7, "Longcharvalue"), "wrong record type\n");
1206
1207     MsiCloseHandle( rec );
1208
1209     r = run_query( hdb, 0,
1210             "CREATE TABLE `Binary` "
1211             "( `Name` CHAR(255), `Data` OBJECT  PRIMARY KEY `Name`)" );
1212     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1213
1214     /* check the column types */
1215     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_TYPES );
1216     ok( rec, "failed to get column info record\n" );
1217
1218     ok( check_record( rec, 1, "S255"), "wrong record type\n");
1219     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1220
1221     MsiCloseHandle( rec );
1222
1223     /* check the type in _Columns */
1224     ok( 0x3dff == get_columns_table_type(hdb, "Binary", 1 ), "_columns table wrong\n");
1225     ok( 0x1900 == get_columns_table_type(hdb, "Binary", 2 ), "_columns table wrong\n");
1226
1227     /* now try the names */
1228     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_NAMES );
1229     ok( rec, "failed to get column info record\n" );
1230
1231     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1232     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1233     MsiCloseHandle( rec );
1234
1235     r = run_query( hdb, 0,
1236             "CREATE TABLE `UIText` "
1237             "( `Key` CHAR(72) NOT NULL, `Text` CHAR(255) LOCALIZABLE PRIMARY KEY `Key`)" );
1238     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1239
1240     ok( 0x2d48 == get_columns_table_type(hdb, "UIText", 1 ), "_columns table wrong\n");
1241     ok( 0x1fff == get_columns_table_type(hdb, "UIText", 2 ), "_columns table wrong\n");
1242
1243     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_NAMES );
1244     ok( rec, "failed to get column info record\n" );
1245     ok( check_record( rec, 1, "Key"), "wrong record type\n");
1246     ok( check_record( rec, 2, "Text"), "wrong record type\n");
1247     MsiCloseHandle( rec );
1248
1249     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_TYPES );
1250     ok( rec, "failed to get column info record\n" );
1251     ok( check_record( rec, 1, "s72"), "wrong record type\n");
1252     ok( check_record( rec, 2, "L255"), "wrong record type\n");
1253     MsiCloseHandle( rec );
1254
1255     MsiCloseHandle( hdb );
1256 }
1257
1258 static void test_msiexport(void)
1259 {
1260     MSIHANDLE hdb = 0, hview = 0;
1261     UINT r;
1262     const char *query;
1263     char path[MAX_PATH];
1264     const char file[] = "phone.txt";
1265     HANDLE handle;
1266     char buffer[0x100];
1267     DWORD length;
1268     const char expected[] =
1269         "id\tname\tnumber\r\n"
1270         "I2\tS32\tS32\r\n"
1271         "phone\tid\r\n"
1272         "1\tAbe\t8675309\r\n";
1273
1274     DeleteFile(msifile);
1275
1276     /* just MsiOpenDatabase should not create a file */
1277     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
1278     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1279
1280     /* create a table */
1281     query = "CREATE TABLE `phone` ( "
1282             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
1283             "PRIMARY KEY `id`)";
1284     r = MsiDatabaseOpenView(hdb, query, &hview);
1285     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1286     r = MsiViewExecute(hview, 0);
1287     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1288     r = MsiViewClose(hview);
1289     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1290     r = MsiCloseHandle(hview);
1291     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1292
1293     /* insert a value into it */
1294     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
1295         "VALUES('1', 'Abe', '8675309')";
1296     r = MsiDatabaseOpenView(hdb, query, &hview);
1297     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1298     r = MsiViewExecute(hview, 0);
1299     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1300     r = MsiViewClose(hview);
1301     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1302     r = MsiCloseHandle(hview);
1303     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1304
1305     GetCurrentDirectory(MAX_PATH, path);
1306
1307     r = MsiDatabaseExport(hdb, "phone", path, file);
1308     ok(r == ERROR_SUCCESS, "MsiDatabaseExport failed\n");
1309
1310     MsiCloseHandle(hdb);
1311
1312     lstrcat(path, "\\");
1313     lstrcat(path, file);
1314
1315     /* check the data that was written */
1316     length = 0;
1317     memset(buffer, 0, sizeof buffer);
1318     handle = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
1319     if (handle != INVALID_HANDLE_VALUE)
1320     {
1321         ReadFile(handle, buffer, sizeof buffer, &length, NULL);
1322         CloseHandle(handle);
1323         DeleteFile(path);
1324     }
1325     else
1326         ok(0, "failed to open file %s\n", path);
1327
1328     ok( length == strlen(expected), "length of data wrong\n");
1329     ok( !lstrcmp(buffer, expected), "data doesn't match\n");
1330     DeleteFile(msifile);
1331 }
1332
1333 static void test_longstrings(void)
1334 {
1335     const char insert_query[] =
1336         "INSERT INTO `strings` ( `id`, `val` ) VALUES('1', 'Z')";
1337     char *str;
1338     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
1339     DWORD len;
1340     UINT r;
1341     const DWORD STRING_LENGTH = 0x10005;
1342
1343     DeleteFile(msifile);
1344     /* just MsiOpenDatabase should not create a file */
1345     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
1346     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1347
1348     /* create a table */
1349     r = try_query( hdb,
1350         "CREATE TABLE `strings` ( `id` INT, `val` CHAR(0) PRIMARY KEY `id`)");
1351     ok(r == ERROR_SUCCESS, "query failed\n");
1352
1353     /* try a insert a very long string */
1354     str = HeapAlloc(GetProcessHeap(), 0, STRING_LENGTH+sizeof insert_query);
1355     len = strchr(insert_query, 'Z') - insert_query;
1356     strcpy(str, insert_query);
1357     memset(str+len, 'Z', STRING_LENGTH);
1358     strcpy(str+len+STRING_LENGTH, insert_query+len+1);
1359     r = try_query( hdb, str );
1360     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1361
1362     HeapFree(GetProcessHeap(), 0, str);
1363
1364     MsiDatabaseCommit(hdb);
1365     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
1366     MsiCloseHandle(hdb);
1367
1368     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb);
1369     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1370
1371     r = MsiDatabaseOpenView(hdb, "select * from `strings` where `id` = 1", &hview);
1372     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1373
1374     r = MsiViewExecute(hview, 0);
1375     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1376
1377     r = MsiViewFetch(hview, &hrec);
1378     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1379
1380     MsiViewClose(hview);
1381     MsiCloseHandle(hview);
1382
1383     r = MsiRecordGetString(hrec, 2, NULL, &len);
1384     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1385     ok(len == STRING_LENGTH, "string length wrong\n");
1386
1387     MsiCloseHandle(hrec);
1388     MsiCloseHandle(hdb);
1389     DeleteFile(msifile);
1390 }
1391
1392 static void create_file_data(LPCSTR name, LPCSTR data, DWORD size)
1393 {
1394     HANDLE file;
1395     DWORD written;
1396
1397     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
1398     if (file == INVALID_HANDLE_VALUE)
1399         return;
1400
1401     WriteFile(file, data, strlen(data), &written, NULL);
1402     WriteFile(file, "\n", strlen("\n"), &written, NULL);
1403
1404     if (size)
1405     {
1406         SetFilePointer(file, size, NULL, FILE_BEGIN);
1407         SetEndOfFile(file);
1408     }
1409
1410     CloseHandle(file);
1411 }
1412
1413 #define create_file(name) create_file_data(name, name, 0)
1414
1415 static void test_streamtable(void)
1416 {
1417     MSIHANDLE hdb = 0, rec, view, hsi;
1418     char file[MAX_PATH];
1419     char buf[MAX_PATH];
1420     DWORD size;
1421     UINT r;
1422
1423     hdb = create_db();
1424     ok( hdb, "failed to create db\n");
1425
1426     r = run_query( hdb, 0,
1427             "CREATE TABLE `Properties` "
1428             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
1429     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1430
1431     r = run_query( hdb, 0,
1432             "INSERT INTO `Properties` "
1433             "( `Value`, `Property` ) VALUES ( 'Prop', 'value' )" );
1434     ok( r == ERROR_SUCCESS, "Failed to add to table\n" );
1435
1436     r = MsiDatabaseCommit( hdb );
1437     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1438
1439     MsiCloseHandle( hdb );
1440
1441     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb );
1442     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1443
1444     /* check the column types */
1445     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_TYPES );
1446     ok( rec, "failed to get column info record\n" );
1447
1448     ok( check_record( rec, 1, "s62"), "wrong record type\n");
1449     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1450
1451     MsiCloseHandle( rec );
1452
1453     /* now try the names */
1454     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_NAMES );
1455     ok( rec, "failed to get column info record\n" );
1456
1457     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1458     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1459
1460     MsiCloseHandle( rec );
1461
1462     r = MsiDatabaseOpenView( hdb,
1463             "SELECT * FROM `_Streams` WHERE `Name` = '\5SummaryInformation'", &view );
1464     ok( r == ERROR_SUCCESS, "Failed to open database view: %u\n", r );
1465
1466     r = MsiViewExecute( view, 0 );
1467     ok( r == ERROR_SUCCESS, "Failed to execute view: %u\n", r );
1468
1469     r = MsiViewFetch( view, &rec );
1470     ok( r == ERROR_NO_MORE_ITEMS, "Unexpected result: %u\n", r );
1471
1472     MsiCloseHandle( rec );
1473     MsiViewClose( view );
1474     MsiCloseHandle( view );
1475
1476     /* create a summary information stream */
1477     r = MsiGetSummaryInformationA( hdb, NULL, 1, &hsi );
1478     ok( r == ERROR_SUCCESS, "Failed to get summary information handle: %u\n", r );
1479
1480     r = MsiSummaryInfoSetPropertyA( hsi, PID_SECURITY, VT_I4, 2, NULL, NULL );
1481     ok( r == ERROR_SUCCESS, "Failed to set property: %u\n", r );
1482
1483     r = MsiSummaryInfoPersist( hsi );
1484     ok( r == ERROR_SUCCESS, "Failed to save summary information: %u\n", r );
1485
1486     MsiCloseHandle( hsi );
1487
1488     r = MsiDatabaseOpenView( hdb,
1489             "SELECT * FROM `_Streams` WHERE `Name` = '\5SummaryInformation'", &view );
1490     ok( r == ERROR_SUCCESS, "Failed to open database view: %u\n", r );
1491
1492     r = MsiViewExecute( view, 0 );
1493     ok( r == ERROR_SUCCESS, "Failed to execute view: %u\n", r );
1494
1495     r = MsiViewFetch( view, &rec );
1496     ok( r == ERROR_SUCCESS, "Unexpected result: %u\n", r );
1497
1498     MsiCloseHandle( rec );
1499     MsiViewClose( view );
1500     MsiCloseHandle( view );
1501
1502     /* insert a file into the _Streams table */
1503     create_file( "test.txt" );
1504
1505     rec = MsiCreateRecord( 2 );
1506     MsiRecordSetString( rec, 1, "data" );
1507
1508     r = MsiRecordSetStream( rec, 2, "test.txt" );
1509     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1510
1511     DeleteFile("test.txt");
1512
1513     r = MsiDatabaseOpenView( hdb,
1514             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1515     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1516
1517     r = MsiViewExecute( view, rec );
1518     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1519
1520     MsiCloseHandle( rec );
1521     MsiViewClose( view );
1522     MsiCloseHandle( view );
1523
1524     /* insert another one */
1525     create_file( "test1.txt" );
1526
1527     rec = MsiCreateRecord( 2 );
1528     MsiRecordSetString( rec, 1, "data1" );
1529
1530     r = MsiRecordSetStream( rec, 2, "test1.txt" );
1531     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1532
1533     DeleteFile("test1.txt");
1534
1535     r = MsiDatabaseOpenView( hdb,
1536             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1537     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1538
1539     r = MsiViewExecute( view, rec );
1540     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1541
1542     MsiCloseHandle( rec );
1543     MsiViewClose( view );
1544     MsiCloseHandle( view );
1545
1546     r = MsiDatabaseOpenView( hdb,
1547             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data'", &view );
1548     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1549
1550     r = MsiViewExecute( view, 0 );
1551     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1552
1553     r = MsiViewFetch( view, &rec );
1554     ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1555
1556     size = MAX_PATH;
1557     r = MsiRecordGetString( rec, 1, file, &size );
1558     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1559     ok( !lstrcmp(file, "data"), "Expected 'data', got %s\n", file);
1560
1561     size = MAX_PATH;
1562     memset(buf, 0, MAX_PATH);
1563     r = MsiRecordReadStream( rec, 2, buf, &size );
1564     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1565     ok( !lstrcmp(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf);
1566
1567     MsiCloseHandle( rec );
1568     MsiViewClose( view );
1569     MsiCloseHandle( view );
1570
1571     r = MsiDatabaseOpenView( hdb,
1572             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data1'", &view );
1573     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1574
1575     r = MsiViewExecute( view, 0 );
1576     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1577
1578     r = MsiViewFetch( view, &rec );
1579     ok( r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1580
1581     size = MAX_PATH;
1582     r = MsiRecordGetString( rec, 1, file, &size );
1583     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1584     ok( !lstrcmp(file, "data1"), "Expected 'data1', got %s\n", file);
1585
1586     size = MAX_PATH;
1587     memset(buf, 0, MAX_PATH);
1588     r = MsiRecordReadStream( rec, 2, buf, &size );
1589     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1590     ok( !lstrcmp(buf, "test1.txt\n"), "Expected 'test1.txt\\n', got %s\n", buf);
1591
1592     MsiCloseHandle( rec );
1593     MsiViewClose( view );
1594     MsiCloseHandle( view );
1595
1596     /* perform an update */
1597     create_file( "test2.txt" );
1598     rec = MsiCreateRecord( 1 );
1599
1600     r = MsiRecordSetStream( rec, 1, "test2.txt" );
1601     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1602
1603     DeleteFile("test2.txt");
1604
1605     r = MsiDatabaseOpenView( hdb,
1606             "UPDATE `_Streams` SET `Data` = ? WHERE `Name` = 'data1'", &view );
1607     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1608
1609     r = MsiViewExecute( view, rec );
1610     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1611
1612     MsiCloseHandle( rec );
1613     MsiViewClose( view );
1614     MsiCloseHandle( view );
1615
1616     r = MsiDatabaseOpenView( hdb,
1617             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data1'", &view );
1618     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1619
1620     r = MsiViewExecute( view, 0 );
1621     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1622
1623     r = MsiViewFetch( view, &rec );
1624     ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1625
1626     size = MAX_PATH;
1627     r = MsiRecordGetString( rec, 1, file, &size );
1628     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1629     ok( !lstrcmp(file, "data1"), "Expected 'data1', got %s\n", file);
1630
1631     size = MAX_PATH;
1632     memset(buf, 0, MAX_PATH);
1633     r = MsiRecordReadStream( rec, 2, buf, &size );
1634     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1635     todo_wine ok( !lstrcmp(buf, "test2.txt\n"), "Expected 'test2.txt\\n', got %s\n", buf);
1636
1637     MsiCloseHandle( rec );
1638     MsiViewClose( view );
1639     MsiCloseHandle( view );
1640     MsiCloseHandle( hdb );
1641     DeleteFile(msifile);
1642 }
1643
1644 static void test_binary(void)
1645 {
1646     MSIHANDLE hdb = 0, rec;
1647     char file[MAX_PATH];
1648     char buf[MAX_PATH];
1649     DWORD size;
1650     LPCSTR query;
1651     UINT r;
1652
1653     /* insert a file into the Binary table */
1654     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb );
1655     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1656
1657     query = "CREATE TABLE `Binary` ( `Name` CHAR(72) NOT NULL, `ID` INT NOT NULL, `Data` OBJECT  PRIMARY KEY `Name`, `ID`)";
1658     r = run_query( hdb, 0, query );
1659     ok( r == ERROR_SUCCESS, "Cannot create Binary table: %d\n", r );
1660
1661     create_file( "test.txt" );
1662     rec = MsiCreateRecord( 1 );
1663     r = MsiRecordSetStream( rec, 1, "test.txt" );
1664     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1665     DeleteFile( "test.txt" );
1666
1667     query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'filename1', 1, ? )";
1668     r = run_query( hdb, rec, query );
1669     ok( r == ERROR_SUCCESS, "Insert into Binary table failed: %d\n", r );
1670
1671     r = MsiCloseHandle( rec );
1672     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1673
1674     r = MsiDatabaseCommit( hdb );
1675     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1676
1677     r = MsiCloseHandle( hdb );
1678     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1679
1680     /* read file from the Stream table */
1681     r = MsiOpenDatabase( msifile, MSIDBOPEN_READONLY, &hdb );
1682     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1683
1684     query = "SELECT * FROM `_Streams`";
1685     r = do_query( hdb, query, &rec );
1686     ok( r == ERROR_SUCCESS, "SELECT query failed: %d\n", r );
1687
1688     size = MAX_PATH;
1689     r = MsiRecordGetString( rec, 1, file, &size );
1690     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
1691     ok( !lstrcmp(file, "Binary.filename1.1"), "Expected 'Binary.filename1.1', got %s\n", file );
1692
1693     size = MAX_PATH;
1694     memset( buf, 0, MAX_PATH );
1695     r = MsiRecordReadStream( rec, 2, buf, &size );
1696     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r );
1697     ok( !lstrcmp(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf );
1698
1699     r = MsiCloseHandle( rec );
1700     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1701
1702     /* read file from the Binary table */
1703     query = "SELECT * FROM `Binary`";
1704     r = do_query( hdb, query, &rec );
1705     ok( r == ERROR_SUCCESS, "SELECT query failed: %d\n", r );
1706
1707     size = MAX_PATH;
1708     r = MsiRecordGetString( rec, 1, file, &size );
1709     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
1710     ok( !lstrcmp(file, "filename1"), "Expected 'filename1', got %s\n", file );
1711
1712     size = MAX_PATH;
1713     memset( buf, 0, MAX_PATH );
1714     r = MsiRecordReadStream( rec, 3, buf, &size );
1715     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r );
1716     ok( !lstrcmp(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf );
1717
1718     r = MsiCloseHandle( rec );
1719     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1720
1721     r = MsiCloseHandle( hdb );
1722     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1723
1724     DeleteFile( msifile );
1725 }
1726
1727 static void test_where_not_in_selected(void)
1728 {
1729     MSIHANDLE hdb = 0, rec, view;
1730     LPCSTR query;
1731     UINT r;
1732
1733     hdb = create_db();
1734     ok( hdb, "failed to create db\n");
1735
1736     r = run_query(hdb, 0,
1737             "CREATE TABLE `IESTable` ("
1738             "`Action` CHAR(64), "
1739             "`Condition` CHAR(64), "
1740             "`Sequence` LONG PRIMARY KEY `Sequence`)");
1741     ok( r == S_OK, "Cannot create IESTable table: %d\n", r);
1742
1743     r = run_query(hdb, 0,
1744             "CREATE TABLE `CATable` ("
1745             "`Action` CHAR(64), "
1746             "`Type` LONG PRIMARY KEY `Type`)");
1747     ok( r == S_OK, "Cannot create CATable table: %d\n", r);
1748
1749     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1750             "( `Action`, `Condition`, `Sequence`) "
1751             "VALUES ( 'clean', 'cond4', 4)");
1752     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1753
1754     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1755             "( `Action`, `Condition`, `Sequence`) "
1756             "VALUES ( 'depends', 'cond1', 1)");
1757     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1758
1759     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1760             "( `Action`, `Condition`, `Sequence`) "
1761             "VALUES ( 'build', 'cond2', 2)");
1762     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1763
1764     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1765             "( `Action`, `Condition`, `Sequence`) "
1766             "VALUES ( 'build2', 'cond6', 6)");
1767     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1768
1769     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1770             "( `Action`, `Condition`, `Sequence`) "
1771             "VALUES ( 'build', 'cond3', 3)");
1772     ok(r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1773
1774     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1775             "( `Action`, `Type` ) "
1776             "VALUES ( 'build', 32)");
1777     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1778
1779     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1780             "( `Action`, `Type` ) "
1781             "VALUES ( 'depends', 64)");
1782     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1783
1784     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1785             "( `Action`, `Type` ) "
1786             "VALUES ( 'clean', 63)");
1787     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1788
1789     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1790             "( `Action`, `Type` ) "
1791             "VALUES ( 'build2', 34)");
1792     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1793     query = "Select IESTable.Condition from CATable, IESTable where "
1794             "CATable.Action = IESTable.Action and CATable.Type = 32";
1795     r = MsiDatabaseOpenView(hdb, query, &view);
1796     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1797
1798     r = MsiViewExecute(view, 0);
1799     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1800
1801     r = MsiViewFetch(view, &rec);
1802     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1803
1804     ok( check_record( rec, 1, "cond2"), "wrong condition\n");
1805
1806     MsiCloseHandle( rec );
1807     r = MsiViewFetch(view, &rec);
1808     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1809
1810     ok( check_record( rec, 1, "cond3"), "wrong condition\n");
1811
1812     MsiCloseHandle( rec );
1813     MsiViewClose(view);
1814     MsiCloseHandle(view);
1815
1816     MsiCloseHandle( hdb );
1817     DeleteFile(msifile);
1818
1819 }
1820
1821
1822 static void test_where(void)
1823 {
1824     MSIHANDLE hdb = 0, rec, view;
1825     LPCSTR query;
1826     UINT r;
1827     DWORD size;
1828     CHAR buf[MAX_PATH];
1829     UINT count;
1830
1831     hdb = create_db();
1832     ok( hdb, "failed to create db\n");
1833
1834     r = run_query( hdb, 0,
1835             "CREATE TABLE `Media` ("
1836             "`DiskId` SHORT NOT NULL, "
1837             "`LastSequence` LONG, "
1838             "`DiskPrompt` CHAR(64) LOCALIZABLE, "
1839             "`Cabinet` CHAR(255), "
1840             "`VolumeLabel` CHAR(32), "
1841             "`Source` CHAR(72) "
1842             "PRIMARY KEY `DiskId`)" );
1843     ok( r == S_OK, "cannot create Media table: %d\n", r );
1844
1845     r = run_query( hdb, 0, "INSERT INTO `Media` "
1846             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1847             "VALUES ( 1, 0, '', 'zero.cab', '', '' )" );
1848     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1849
1850     r = run_query( hdb, 0, "INSERT INTO `Media` "
1851             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1852             "VALUES ( 2, 1, '', 'one.cab', '', '' )" );
1853     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1854
1855     r = run_query( hdb, 0, "INSERT INTO `Media` "
1856             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1857             "VALUES ( 3, 2, '', 'two.cab', '', '' )" );
1858     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1859
1860     query = "SELECT * FROM `Media`";
1861     r = do_query(hdb, query, &rec);
1862     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1863     ok( check_record( rec, 4, "zero.cab"), "wrong cabinet\n");
1864     MsiCloseHandle( rec );
1865
1866     query = "SELECT * FROM `Media` WHERE `LastSequence` >= 1";
1867     r = do_query(hdb, query, &rec);
1868     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1869     ok( check_record( rec, 4, "one.cab"), "wrong cabinet\n");
1870
1871     r = MsiRecordGetInteger(rec, 1);
1872     ok( 2 == r, "field wrong\n");
1873     r = MsiRecordGetInteger(rec, 2);
1874     ok( 1 == r, "field wrong\n");
1875     MsiCloseHandle( rec );
1876
1877     query = "SELECT `DiskId` FROM `Media` WHERE `LastSequence` >= 1 AND DiskId >= 0";
1878     r = MsiDatabaseOpenView(hdb, query, &view);
1879     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1880
1881     r = MsiViewExecute(view, 0);
1882     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1883
1884     r = MsiViewFetch(view, &rec);
1885     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1886
1887     count = MsiRecordGetFieldCount( rec );
1888     ok( count == 1, "Expected 1 record fields, got %d\n", count );
1889
1890     size = MAX_PATH;
1891     r = MsiRecordGetString( rec, 1, buf, &size );
1892     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1893     ok( !lstrcmp( buf, "2" ),
1894         "For (row %d, column 1) expected '%d', got %s\n", 0, 2, buf );
1895     MsiCloseHandle( rec );
1896
1897     r = MsiViewFetch(view, &rec);
1898     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1899
1900     size = MAX_PATH;
1901     r = MsiRecordGetString( rec, 1, buf, &size );
1902     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1903     ok( !lstrcmp( buf, "3" ),
1904         "For (row %d, column 1) expected '%d', got %s\n", 1, 3, buf );
1905     MsiCloseHandle( rec );
1906
1907     r = MsiViewFetch(view, &rec);
1908     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
1909
1910     MsiViewClose(view);
1911     MsiCloseHandle(view);
1912
1913     MsiCloseHandle( rec );
1914
1915     rec = 0;
1916     query = "SELECT * FROM `Media` WHERE `DiskPrompt` IS NULL";
1917     r = do_query(hdb, query, &rec);
1918     ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
1919     MsiCloseHandle( rec );
1920
1921     rec = 0;
1922     query = "SELECT * FROM `Media` WHERE `DiskPrompt` < 'Cabinet'";
1923     r = do_query(hdb, query, &rec);
1924     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %d\n", r );
1925     MsiCloseHandle( rec );
1926
1927     rec = 0;
1928     query = "SELECT * FROM `Media` WHERE `DiskPrompt` > 'Cabinet'";
1929     r = do_query(hdb, query, &rec);
1930     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %d\n", r );
1931     MsiCloseHandle( rec );
1932
1933     rec = 0;
1934     query = "SELECT * FROM `Media` WHERE `DiskPrompt` <> 'Cabinet'";
1935     r = do_query(hdb, query, &rec);
1936     ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
1937     MsiCloseHandle( rec );
1938
1939     rec = 0;
1940     query = "SELECT * FROM `Media` WHERE `DiskPrompt` = 'Cabinet'";
1941     r = do_query(hdb, query, &rec);
1942     ok( r == ERROR_NO_MORE_ITEMS, "query failed: %d\n", r );
1943     MsiCloseHandle( rec );
1944
1945     rec = MsiCreateRecord(1);
1946     MsiRecordSetString(rec, 1, "");
1947
1948     query = "SELECT * FROM `Media` WHERE `DiskPrompt` = ?";
1949     r = MsiDatabaseOpenView(hdb, query, &view);
1950     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1951     r = MsiViewExecute(view, rec);
1952     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1953
1954     MsiCloseHandle(rec);
1955
1956     r = MsiViewFetch(view, &rec);
1957     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1958
1959     MsiCloseHandle(rec);
1960     MsiViewClose(view);
1961     MsiCloseHandle(view);
1962
1963     MsiCloseHandle( hdb );
1964     DeleteFile(msifile);
1965 }
1966
1967 static CHAR CURR_DIR[MAX_PATH];
1968
1969 static const CHAR test_data[] = "FirstPrimaryColumn\tSecondPrimaryColumn\tShortInt\tShortIntNullable\tLongInt\tLongIntNullable\tString\tLocalizableString\tLocalizableStringNullable\n"
1970                                 "s255\ti2\ti2\tI2\ti4\tI4\tS255\tS0\ts0\n"
1971                                 "TestTable\tFirstPrimaryColumn\n"
1972                                 "stringage\t5\t2\t\t2147483640\t-2147483640\tanother string\tlocalizable\tduh\n";
1973
1974 static const CHAR two_primary[] = "PrimaryOne\tPrimaryTwo\n"
1975                                   "s255\ts255\n"
1976                                   "TwoPrimary\tPrimaryOne\tPrimaryTwo\n"
1977                                   "papaya\tleaf\n"
1978                                   "papaya\tflower\n";
1979
1980 static const CHAR endlines1[] = "A\tB\tC\tD\tE\tF\r\n"
1981                                 "s72\ts72\ts72\ts72\ts72\ts72\n"
1982                                 "Table\tA\r\n"
1983                                 "a\tb\tc\td\te\tf\n"
1984                                 "g\th\ti\t\rj\tk\tl\r\n";
1985
1986 static const CHAR endlines2[] = "A\tB\tC\tD\tE\tF\r"
1987                                 "s72\ts72\ts72\ts72\ts72\ts72\n"
1988                                 "Table2\tA\r\n"
1989                                 "a\tb\tc\td\te\tf\n"
1990                                 "g\th\ti\tj\tk\tl\r\n";
1991
1992 static const CHAR suminfo[] = "PropertyId\tValue\n"
1993                               "i2\tl255\n"
1994                               "_SummaryInformation\tPropertyId\n"
1995                               "1\t1252\n"
1996                               "2\tInstaller Database\n"
1997                               "3\tInstaller description\n"
1998                               "4\tWineHQ\n"
1999                               "5\tInstaller\n"
2000                               "6\tInstaller comments\n"
2001                               "7\tIntel;1033\n"
2002                               "9\t{12345678-1234-1234-1234-123456789012}\n"
2003                               "12\t2009/04/12 15:46:11\n"
2004                               "13\t2009/04/12 15:46:11\n"
2005                               "14\t200\n"
2006                               "15\t2\n"
2007                               "18\tVim\n"
2008                               "19\t2\n";
2009
2010 static void write_file(const CHAR *filename, const char *data, int data_size)
2011 {
2012     DWORD size;
2013
2014     HANDLE hf = CreateFile(filename, GENERIC_WRITE, 0, NULL,
2015                            CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2016
2017     WriteFile(hf, data, data_size, &size, NULL);
2018     CloseHandle(hf);
2019 }
2020
2021 static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
2022 {
2023     UINT r;
2024
2025     write_file("temp_file", table_data, (lstrlen(table_data) - 1) * sizeof(char));
2026     r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
2027     DeleteFileA("temp_file");
2028
2029     return r;
2030 }
2031
2032 static void test_suminfo_import(void)
2033 {
2034     MSIHANDLE hdb, hsi, view = 0;
2035     LPCSTR query;
2036     UINT r, count, size, type;
2037     char str_value[50];
2038     INT int_value;
2039     FILETIME ft_value;
2040
2041     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
2042
2043     r = MsiOpenDatabaseA(msifile, MSIDBOPEN_CREATE, &hdb);
2044     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2045
2046     r = add_table_to_db(hdb, suminfo);
2047     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2048
2049     /* _SummaryInformation is not imported as a regular table... */
2050
2051     query = "SELECT * FROM `_SummaryInformation`";
2052     r = MsiDatabaseOpenViewA(hdb, query, &view);
2053     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %u\n", r);
2054     MsiCloseHandle(view);
2055
2056     /* ...its data is added to the special summary information stream */
2057
2058     r = MsiGetSummaryInformationA(hdb, NULL, 0, &hsi);
2059     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2060
2061     r = MsiSummaryInfoGetPropertyCount(hsi, &count);
2062     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2063     ok(count == 14, "Expected 14, got %u\n", count);
2064
2065     r = MsiSummaryInfoGetPropertyA(hsi, PID_CODEPAGE, &type, &int_value, NULL, NULL, NULL);
2066     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2067     ok(type ==  VT_I2, "Expected VT_I2, got %u\n", type);
2068     ok(int_value == 1252, "Expected 1252, got %d\n", int_value);
2069
2070     size = sizeof(str_value);
2071     r = MsiSummaryInfoGetPropertyA(hsi, PID_TITLE, &type, NULL, NULL, str_value, &size);
2072     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2073     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2074     ok(size == 18, "Expected 18, got %u\n", size);
2075     ok(!strcmp(str_value, "Installer Database"),
2076        "Expected \"Installer Database\", got %s\n", str_value);
2077
2078     size = sizeof(str_value);
2079     r = MsiSummaryInfoGetPropertyA(hsi, PID_SUBJECT, &type, NULL, NULL, str_value, &size);
2080     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2081     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2082     ok(!strcmp(str_value, "Installer description"),
2083        "Expected \"Installer description\", got %s\n", str_value);
2084
2085     size = sizeof(str_value);
2086     r = MsiSummaryInfoGetPropertyA(hsi, PID_AUTHOR, &type, NULL, NULL, str_value, &size);
2087     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2088     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2089     ok(!strcmp(str_value, "WineHQ"),
2090        "Expected \"WineHQ\", got %s\n", str_value);
2091
2092     size = sizeof(str_value);
2093     r = MsiSummaryInfoGetPropertyA(hsi, PID_KEYWORDS, &type, NULL, NULL, str_value, &size);
2094     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2095     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2096     ok(!strcmp(str_value, "Installer"),
2097        "Expected \"Installer\", got %s\n", str_value);
2098
2099     size = sizeof(str_value);
2100     r = MsiSummaryInfoGetPropertyA(hsi, PID_COMMENTS, &type, NULL, NULL, str_value, &size);
2101     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2102     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2103     ok(!strcmp(str_value, "Installer comments"),
2104        "Expected \"Installer comments\", got %s\n", str_value);
2105
2106     size = sizeof(str_value);
2107     r = MsiSummaryInfoGetPropertyA(hsi, PID_TEMPLATE, &type, NULL, NULL, str_value, &size);
2108     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2109     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2110     ok(!strcmp(str_value, "Intel;1033"),
2111        "Expected \"Intel;1033\", got %s\n", str_value);
2112
2113     size = sizeof(str_value);
2114     r = MsiSummaryInfoGetPropertyA(hsi, PID_REVNUMBER, &type, NULL, NULL, str_value, &size);
2115     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2116     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2117     ok(!strcmp(str_value, "{12345678-1234-1234-1234-123456789012}"),
2118        "Expected \"{12345678-1234-1234-1234-123456789012}\", got %s\n", str_value);
2119
2120     r = MsiSummaryInfoGetPropertyA(hsi, PID_CREATE_DTM, &type, NULL, &ft_value, NULL, NULL);
2121     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2122     ok(type == VT_FILETIME, "Expected VT_FILETIME, got %u\n", type);
2123
2124     r = MsiSummaryInfoGetPropertyA(hsi, PID_LASTSAVE_DTM, &type, NULL, &ft_value, NULL, NULL);
2125     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2126     ok(type == VT_FILETIME, "Expected VT_FILETIME, got %u\n", type);
2127
2128     r = MsiSummaryInfoGetPropertyA(hsi, PID_PAGECOUNT, &type, &int_value, NULL, NULL, NULL);
2129     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2130     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2131     ok(int_value == 200, "Expected 200, got %d\n", int_value);
2132
2133     r = MsiSummaryInfoGetPropertyA(hsi, PID_WORDCOUNT, &type, &int_value, NULL, NULL, NULL);
2134     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2135     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2136     ok(int_value == 2, "Expected 2, got %d\n", int_value);
2137
2138     r = MsiSummaryInfoGetPropertyA(hsi, PID_SECURITY, &type, &int_value, NULL, NULL, NULL);
2139     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2140     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2141     ok(int_value == 2, "Expected 2, got %d\n", int_value);
2142
2143     size = sizeof(str_value);
2144     r = MsiSummaryInfoGetPropertyA(hsi, PID_APPNAME, &type, NULL, NULL, str_value, &size);
2145     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2146     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2147     ok(!strcmp(str_value, "Vim"), "Expected \"Vim\", got %s\n", str_value);
2148
2149     MsiCloseHandle(hsi);
2150     MsiCloseHandle(hdb);
2151     DeleteFileA(msifile);
2152 }
2153
2154 static void test_msiimport(void)
2155 {
2156     MSIHANDLE hdb, view, rec;
2157     LPCSTR query;
2158     UINT r, count;
2159     signed int i;
2160
2161     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
2162
2163     r = MsiOpenDatabaseA(msifile, MSIDBOPEN_CREATE, &hdb);
2164     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2165
2166     r = add_table_to_db(hdb, test_data);
2167     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2168
2169     r = add_table_to_db(hdb, two_primary);
2170     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2171
2172     r = add_table_to_db(hdb, endlines1);
2173     if (r == ERROR_FUNCTION_FAILED)
2174     {
2175         /* win9x doesn't handle this case */
2176         skip("endlines not handled correctly.\n");
2177         MsiCloseHandle(hdb);
2178         DeleteFileA(msifile);
2179         return;
2180     }
2181
2182     r = add_table_to_db(hdb, endlines2);
2183     ok(r == ERROR_FUNCTION_FAILED,
2184        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
2185
2186     query = "SELECT * FROM `TestTable`";
2187     r = MsiDatabaseOpenView(hdb, query, &view);
2188     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2189
2190     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2191     count = MsiRecordGetFieldCount(rec);
2192     ok(count == 9, "Expected 9, got %d\n", count);
2193     ok(check_record(rec, 1, "FirstPrimaryColumn"), "Expected FirstPrimaryColumn\n");
2194     ok(check_record(rec, 2, "SecondPrimaryColumn"), "Expected SecondPrimaryColumn\n");
2195     ok(check_record(rec, 3, "ShortInt"), "Expected ShortInt\n");
2196     ok(check_record(rec, 4, "ShortIntNullable"), "Expected ShortIntNullalble\n");
2197     ok(check_record(rec, 5, "LongInt"), "Expected LongInt\n");
2198     ok(check_record(rec, 6, "LongIntNullable"), "Expected LongIntNullalble\n");
2199     ok(check_record(rec, 7, "String"), "Expected String\n");
2200     ok(check_record(rec, 8, "LocalizableString"), "Expected LocalizableString\n");
2201     ok(check_record(rec, 9, "LocalizableStringNullable"), "Expected LocalizableStringNullable\n");
2202     MsiCloseHandle(rec);
2203
2204     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2205     count = MsiRecordGetFieldCount(rec);
2206     ok(count == 9, "Expected 9, got %d\n", count);
2207     ok(check_record(rec, 1, "s255"), "Expected s255\n");
2208     ok(check_record(rec, 2, "i2"), "Expected i2\n");
2209     ok(check_record(rec, 3, "i2"), "Expected i2\n");
2210     ok(check_record(rec, 4, "I2"), "Expected I2\n");
2211     ok(check_record(rec, 5, "i4"), "Expected i4\n");
2212     ok(check_record(rec, 6, "I4"), "Expected I4\n");
2213     ok(check_record(rec, 7, "S255"), "Expected S255\n");
2214     ok(check_record(rec, 8, "S0"), "Expected S0\n");
2215     ok(check_record(rec, 9, "s0"), "Expected s0\n");
2216     MsiCloseHandle(rec);
2217
2218     query = "SELECT * FROM `TestTable`";
2219     r = do_query(hdb, query, &rec);
2220     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2221     ok(check_record(rec, 1, "stringage"), "Expected 'stringage'\n");
2222     ok(check_record(rec, 7, "another string"), "Expected 'another string'\n");
2223     ok(check_record(rec, 8, "localizable"), "Expected 'localizable'\n");
2224     ok(check_record(rec, 9, "duh"), "Expected 'duh'\n");
2225
2226     i = MsiRecordGetInteger(rec, 2);
2227     ok(i == 5, "Expected 5, got %d\n", i);
2228
2229     i = MsiRecordGetInteger(rec, 3);
2230     ok(i == 2, "Expected 2, got %d\n", i);
2231
2232     i = MsiRecordGetInteger(rec, 4);
2233     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
2234
2235     i = MsiRecordGetInteger(rec, 5);
2236     ok(i == 2147483640, "Expected 2147483640, got %d\n", i);
2237
2238     i = MsiRecordGetInteger(rec, 6);
2239     ok(i == -2147483640, "Expected -2147483640, got %d\n", i);
2240
2241     MsiCloseHandle(rec);
2242     MsiViewClose(view);
2243     MsiCloseHandle(view);
2244
2245     query = "SELECT * FROM `TwoPrimary`";
2246     r = MsiDatabaseOpenView(hdb, query, &view);
2247     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2248
2249     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2250     count = MsiRecordGetFieldCount(rec);
2251     ok(count == 2, "Expected 2, got %d\n", count);
2252     ok(check_record(rec, 1, "PrimaryOne"), "Expected PrimaryOne\n");
2253     ok(check_record(rec, 2, "PrimaryTwo"), "Expected PrimaryTwo\n");
2254
2255     MsiCloseHandle(rec);
2256
2257     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2258     count = MsiRecordGetFieldCount(rec);
2259     ok(count == 2, "Expected 2, got %d\n", count);
2260     ok(check_record(rec, 1, "s255"), "Expected s255\n");
2261     ok(check_record(rec, 2, "s255"), "Expected s255\n");
2262     MsiCloseHandle(rec);
2263
2264     r = MsiViewExecute(view, 0);
2265     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2266
2267     r = MsiViewFetch(view, &rec);
2268     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2269
2270     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
2271     ok(check_record(rec, 2, "leaf"), "Expected 'leaf'\n");
2272
2273     MsiCloseHandle(rec);
2274
2275     r = MsiViewFetch(view, &rec);
2276     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2277
2278     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
2279     ok(check_record(rec, 2, "flower"), "Expected 'flower'\n");
2280
2281     MsiCloseHandle(rec);
2282
2283     r = MsiViewFetch(view, &rec);
2284     ok(r == ERROR_NO_MORE_ITEMS,
2285        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
2286
2287     r = MsiViewClose(view);
2288     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2289
2290     MsiCloseHandle(view);
2291
2292     query = "SELECT * FROM `Table`";
2293     r = MsiDatabaseOpenView(hdb, query, &view);
2294     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2295
2296     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2297     count = MsiRecordGetFieldCount(rec);
2298     ok(count == 6, "Expected 6, got %d\n", count);
2299     ok(check_record(rec, 1, "A"), "Expected A\n");
2300     ok(check_record(rec, 2, "B"), "Expected B\n");
2301     ok(check_record(rec, 3, "C"), "Expected C\n");
2302     ok(check_record(rec, 4, "D"), "Expected D\n");
2303     ok(check_record(rec, 5, "E"), "Expected E\n");
2304     ok(check_record(rec, 6, "F"), "Expected F\n");
2305     MsiCloseHandle(rec);
2306
2307     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2308     count = MsiRecordGetFieldCount(rec);
2309     ok(count == 6, "Expected 6, got %d\n", count);
2310     ok(check_record(rec, 1, "s72"), "Expected s72\n");
2311     ok(check_record(rec, 2, "s72"), "Expected s72\n");
2312     ok(check_record(rec, 3, "s72"), "Expected s72\n");
2313     ok(check_record(rec, 4, "s72"), "Expected s72\n");
2314     ok(check_record(rec, 5, "s72"), "Expected s72\n");
2315     ok(check_record(rec, 6, "s72"), "Expected s72\n");
2316     MsiCloseHandle(rec);
2317
2318     MsiViewClose(view);
2319     MsiCloseHandle(view);
2320
2321     query = "SELECT * FROM `Table`";
2322     r = MsiDatabaseOpenView(hdb, query, &view);
2323     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2324
2325     r = MsiViewExecute(view, 0);
2326     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2327
2328     r = MsiViewFetch(view, &rec);
2329     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2330     ok(check_record(rec, 1, "a"), "Expected 'a'\n");
2331     ok(check_record(rec, 2, "b"), "Expected 'b'\n");
2332     ok(check_record(rec, 3, "c"), "Expected 'c'\n");
2333     ok(check_record(rec, 4, "d"), "Expected 'd'\n");
2334     ok(check_record(rec, 5, "e"), "Expected 'e'\n");
2335     ok(check_record(rec, 6, "f"), "Expected 'f'\n");
2336
2337     MsiCloseHandle(rec);
2338
2339     r = MsiViewFetch(view, &rec);
2340     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2341     ok(check_record(rec, 1, "g"), "Expected 'g'\n");
2342     ok(check_record(rec, 2, "h"), "Expected 'h'\n");
2343     ok(check_record(rec, 3, "i"), "Expected 'i'\n");
2344     ok(check_record(rec, 4, "j"), "Expected 'j'\n");
2345     ok(check_record(rec, 5, "k"), "Expected 'k'\n");
2346     ok(check_record(rec, 6, "l"), "Expected 'l'\n");
2347
2348     MsiCloseHandle(rec);
2349
2350     r = MsiViewFetch(view, &rec);
2351     ok(r == ERROR_NO_MORE_ITEMS,
2352        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
2353
2354     MsiViewClose(view);
2355     MsiCloseHandle(view);
2356     MsiCloseHandle(hdb);
2357     DeleteFileA(msifile);
2358 }
2359
2360 static const CHAR bin_import_dat[] = "Name\tData\r\n"
2361                                      "s72\tV0\r\n"
2362                                      "Binary\tName\r\n"
2363                                      "filename1\tfilename1.ibd\r\n";
2364
2365 static void test_binary_import(void)
2366 {
2367     MSIHANDLE hdb = 0, rec;
2368     char file[MAX_PATH];
2369     char buf[MAX_PATH];
2370     char path[MAX_PATH];
2371     DWORD size;
2372     LPCSTR query;
2373     UINT r;
2374
2375     /* create files to import */
2376     write_file("bin_import.idt", bin_import_dat,
2377           (sizeof(bin_import_dat) - 1) * sizeof(char));
2378     CreateDirectory("bin_import", NULL);
2379     create_file_data("bin_import/filename1.ibd", "just some words", 15);
2380
2381     /* import files into database */
2382     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
2383     ok( r == ERROR_SUCCESS , "Failed to open database\n");
2384
2385     GetCurrentDirectory(MAX_PATH, path);
2386     r = MsiDatabaseImport(hdb, path, "bin_import.idt");
2387     ok(r == ERROR_SUCCESS , "Failed to import Binary table\n");
2388
2389     /* read file from the Binary table */
2390     query = "SELECT * FROM `Binary`";
2391     r = do_query(hdb, query, &rec);
2392     ok(r == ERROR_SUCCESS, "SELECT query failed: %d\n", r);
2393
2394     size = MAX_PATH;
2395     r = MsiRecordGetString(rec, 1, file, &size);
2396     ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
2397     ok(!lstrcmp(file, "filename1"), "Expected 'filename1', got %s\n", file);
2398
2399     size = MAX_PATH;
2400     memset(buf, 0, MAX_PATH);
2401     r = MsiRecordReadStream(rec, 2, buf, &size);
2402     ok(r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
2403     ok(!lstrcmp(buf, "just some words"),
2404         "Expected 'just some words', got %s\n", buf);
2405
2406     r = MsiCloseHandle(rec);
2407     ok(r == ERROR_SUCCESS , "Failed to close record handle\n");
2408
2409     r = MsiCloseHandle(hdb);
2410     ok(r == ERROR_SUCCESS , "Failed to close database\n");
2411
2412     DeleteFile("bin_import/filename1.ibd");
2413     RemoveDirectory("bin_import");
2414     DeleteFile("bin_import.idt");
2415 }
2416
2417 static void test_markers(void)
2418 {
2419     MSIHANDLE hdb, rec;
2420     LPCSTR query;
2421     UINT r;
2422
2423     hdb = create_db();
2424     ok( hdb, "failed to create db\n");
2425
2426     rec = MsiCreateRecord(3);
2427     MsiRecordSetString(rec, 1, "Table");
2428     MsiRecordSetString(rec, 2, "Apples");
2429     MsiRecordSetString(rec, 3, "Oranges");
2430
2431     /* try a legit create */
2432     query = "CREATE TABLE `Table` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2433     r = run_query(hdb, 0, query);
2434     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2435     MsiCloseHandle(rec);
2436
2437     /* try table name as marker */
2438     rec = MsiCreateRecord(1);
2439     MsiRecordSetString(rec, 1, "Fable");
2440     query = "CREATE TABLE `?` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2441     r = run_query(hdb, rec, query);
2442     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2443
2444     /* verify that we just created a table called '?', not 'Fable' */
2445     r = try_query(hdb, "SELECT * from `Fable`");
2446     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2447
2448     r = try_query(hdb, "SELECT * from `?`");
2449     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2450
2451     /* try table name as marker without backticks */
2452     MsiRecordSetString(rec, 1, "Mable");
2453     query = "CREATE TABLE ? ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2454     r = run_query(hdb, rec, query);
2455     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2456
2457     /* try one column name as marker */
2458     MsiRecordSetString(rec, 1, "One");
2459     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2460     r = run_query(hdb, rec, query);
2461     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2462     MsiCloseHandle(rec);
2463
2464     /* try column names as markers */
2465     rec = MsiCreateRecord(2);
2466     MsiRecordSetString(rec, 1, "One");
2467     MsiRecordSetString(rec, 2, "Two");
2468     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `One`)";
2469     r = run_query(hdb, rec, query);
2470     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2471     MsiCloseHandle(rec);
2472
2473     /* try names with backticks */
2474     rec = MsiCreateRecord(3);
2475     MsiRecordSetString(rec, 1, "One");
2476     MsiRecordSetString(rec, 2, "Two");
2477     MsiRecordSetString(rec, 3, "One");
2478     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
2479     r = run_query(hdb, rec, query);
2480     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2481
2482     /* try names with backticks, minus definitions */
2483     query = "CREATE TABLE `Mable` ( `?`, `?` PRIMARY KEY `?`)";
2484     r = run_query(hdb, rec, query);
2485     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2486
2487     /* try names without backticks */
2488     query = "CREATE TABLE `Mable` ( ? SHORT NOT NULL, ? CHAR(255) PRIMARY KEY ?)";
2489     r = run_query(hdb, rec, query);
2490     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2491     MsiCloseHandle(rec);
2492
2493     /* try one long marker */
2494     rec = MsiCreateRecord(1);
2495     MsiRecordSetString(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
2496     query = "CREATE TABLE `Mable` ( ? )";
2497     r = run_query(hdb, rec, query);
2498     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2499     MsiCloseHandle(rec);
2500
2501     /* try all names as markers */
2502     rec = MsiCreateRecord(4);
2503     MsiRecordSetString(rec, 1, "Mable");
2504     MsiRecordSetString(rec, 2, "One");
2505     MsiRecordSetString(rec, 3, "Two");
2506     MsiRecordSetString(rec, 4, "One");
2507     query = "CREATE TABLE `?` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
2508     r = run_query(hdb, rec, query);
2509     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2510     MsiCloseHandle(rec);
2511
2512     /* try a legit insert */
2513     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( 5, 'hello' )";
2514     r = run_query(hdb, 0, query);
2515     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2516
2517     r = try_query(hdb, "SELECT * from `Table`");
2518     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2519
2520     /* try values as markers */
2521     rec = MsiCreateRecord(2);
2522     MsiRecordSetInteger(rec, 1, 4);
2523     MsiRecordSetString(rec, 2, "hi");
2524     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
2525     r = run_query(hdb, rec, query);
2526     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2527     MsiCloseHandle(rec);
2528
2529     /* try column names and values as markers */
2530     rec = MsiCreateRecord(4);
2531     MsiRecordSetString(rec, 1, "One");
2532     MsiRecordSetString(rec, 2, "Two");
2533     MsiRecordSetInteger(rec, 3, 5);
2534     MsiRecordSetString(rec, 4, "hi");
2535     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( ?, '?' )";
2536     r = run_query(hdb, rec, query);
2537     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2538     MsiCloseHandle(rec);
2539
2540     /* try column names as markers */
2541     rec = MsiCreateRecord(2);
2542     MsiRecordSetString(rec, 1, "One");
2543     MsiRecordSetString(rec, 2, "Two");
2544     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( 3, 'yellow' )";
2545     r = run_query(hdb, rec, query);
2546     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2547     MsiCloseHandle(rec);
2548
2549     /* try table name as a marker */
2550     rec = MsiCreateRecord(1);
2551     MsiRecordSetString(rec, 1, "Table");
2552     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( 2, 'green' )";
2553     r = run_query(hdb, rec, query);
2554     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2555     MsiCloseHandle(rec);
2556
2557     /* try table name and values as markers */
2558     rec = MsiCreateRecord(3);
2559     MsiRecordSetString(rec, 1, "Table");
2560     MsiRecordSetInteger(rec, 2, 10);
2561     MsiRecordSetString(rec, 3, "haha");
2562     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
2563     r = run_query(hdb, rec, query);
2564     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
2565     MsiCloseHandle(rec);
2566
2567     /* try all markers */
2568     rec = MsiCreateRecord(5);
2569     MsiRecordSetString(rec, 1, "Table");
2570     MsiRecordSetString(rec, 1, "One");
2571     MsiRecordSetString(rec, 1, "Two");
2572     MsiRecordSetInteger(rec, 2, 10);
2573     MsiRecordSetString(rec, 3, "haha");
2574     query = "INSERT INTO `?` ( `?`, `?` ) VALUES ( ?, '?' )";
2575     r = run_query(hdb, rec, query);
2576     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2577     MsiCloseHandle(rec);
2578
2579     /* insert an integer as a string */
2580     rec = MsiCreateRecord(2);
2581     MsiRecordSetString(rec, 1, "11");
2582     MsiRecordSetString(rec, 2, "hi");
2583     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
2584     r = run_query(hdb, rec, query);
2585     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2586     MsiCloseHandle(rec);
2587
2588     /* leave off the '' for the string */
2589     rec = MsiCreateRecord(2);
2590     MsiRecordSetInteger(rec, 1, 12);
2591     MsiRecordSetString(rec, 2, "hi");
2592     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, ? )";
2593     r = run_query(hdb, rec, query);
2594     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2595     MsiCloseHandle(rec);
2596
2597     MsiCloseHandle(hdb);
2598     DeleteFileA(msifile);
2599 }
2600
2601 #define MY_NVIEWS 4000    /* Largest installer I've seen uses < 2k */
2602 static void test_handle_limit(void)
2603 {
2604     int i;
2605     MSIHANDLE hdb;
2606     MSIHANDLE hviews[MY_NVIEWS];
2607     UINT r;
2608
2609     /* create an empty db */
2610     hdb = create_db();
2611     ok( hdb, "failed to create db\n");
2612
2613     memset(hviews, 0, sizeof(hviews));
2614
2615     for (i=0; i<MY_NVIEWS; i++) {
2616         static char szQueryBuf[256] = "SELECT * from `_Tables`";
2617         hviews[i] = 0xdeadbeeb;
2618         r = MsiDatabaseOpenView(hdb, szQueryBuf, &hviews[i]);
2619         if( r != ERROR_SUCCESS || hviews[i] == 0xdeadbeeb ||
2620             hviews[i] == 0 || (i && (hviews[i] == hviews[i-1])))
2621             break;
2622     }
2623
2624     ok( i == MY_NVIEWS, "problem opening views\n");
2625
2626     for (i=0; i<MY_NVIEWS; i++) {
2627         if (hviews[i] != 0 && hviews[i] != 0xdeadbeeb) {
2628             MsiViewClose(hviews[i]);
2629             r = MsiCloseHandle(hviews[i]);
2630             if (r != ERROR_SUCCESS)
2631                 break;
2632         }
2633     }
2634
2635     ok( i == MY_NVIEWS, "problem closing views\n");
2636
2637     r = MsiCloseHandle(hdb);
2638     ok( r == ERROR_SUCCESS, "failed to close database\n");
2639 }
2640
2641 static void generate_transform(void)
2642 {
2643     MSIHANDLE hdb1, hdb2, hrec;
2644     LPCSTR query;
2645     UINT r;
2646
2647     /* start with two identical databases */
2648     CopyFile(msifile2, msifile, FALSE);
2649
2650     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb1 );
2651     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2652
2653     r = MsiDatabaseCommit( hdb1 );
2654     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
2655
2656     r = MsiOpenDatabase(msifile2, MSIDBOPEN_READONLY, &hdb2 );
2657     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2658
2659     /* the transform between two identical database should be empty */
2660     r = MsiDatabaseGenerateTransform(hdb1, hdb2, NULL, 0, 0);
2661     todo_wine {
2662     ok( r == ERROR_NO_DATA, "return code %d, should be ERROR_NO_DATA\n", r );
2663     }
2664
2665     query = "CREATE TABLE `AAR` ( `BAR` SHORT NOT NULL, `CAR` CHAR(255) PRIMARY KEY `CAR`)";
2666     r = run_query(hdb1, 0, query);
2667     ok(r == ERROR_SUCCESS, "failed to add table\n");
2668
2669     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 1, 'vw' )";
2670     r = run_query(hdb1, 0, query);
2671     ok(r == ERROR_SUCCESS, "failed to add row 1\n");
2672
2673     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 2, 'bmw' )";
2674     r = run_query(hdb1, 0, query);
2675     ok(r == ERROR_SUCCESS, "failed to add row 2\n");
2676
2677     query = "UPDATE `MOO` SET `OOO` = 'c' WHERE `NOO` = 1";
2678     r = run_query(hdb1, 0, query);
2679     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2680
2681     query = "DELETE FROM `MOO` WHERE `NOO` = 3";
2682     r = run_query(hdb1, 0, query);
2683     ok(r == ERROR_SUCCESS, "failed to delete row\n");
2684
2685     hrec = MsiCreateRecord(2);
2686     r = MsiRecordSetInteger(hrec, 1, 1);
2687     ok(r == ERROR_SUCCESS, "failed to set integer\n");
2688
2689     write_file("testdata.bin", "naengmyon", 9);
2690     r = MsiRecordSetStream(hrec, 2, "testdata.bin");
2691     ok(r == ERROR_SUCCESS, "failed to set stream\n");
2692
2693     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
2694     r = run_query(hdb1, hrec, query);
2695     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
2696
2697     MsiCloseHandle(hrec);
2698
2699     query = "ALTER TABLE `MOO` ADD `COW` INTEGER";
2700     r = run_query(hdb1, 0, query);
2701     ok(r == ERROR_SUCCESS, "failed to add column\n");
2702
2703     query = "ALTER TABLE `MOO` ADD `PIG` INTEGER";
2704     r = run_query(hdb1, 0, query);
2705     ok(r == ERROR_SUCCESS, "failed to add column\n");
2706
2707     query = "UPDATE `MOO` SET `PIG` = 5 WHERE `NOO` = 1";
2708     r = run_query(hdb1, 0, query);
2709     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2710
2711     query = "CREATE TABLE `Property` ( `Property` CHAR(72) NOT NULL, "
2712             "`Value` CHAR(0) PRIMARY KEY `Property`)";
2713     r = run_query(hdb1, 0, query);
2714     ok(r == ERROR_SUCCESS, "failed to add property table\n");
2715
2716     query = "INSERT INTO `Property` ( `Property`, `Value` ) VALUES ( 'prop', 'val' )";
2717     r = run_query(hdb1, 0, query);
2718     ok(r == ERROR_SUCCESS, "failed to add property\n");
2719
2720     /* database needs to be committed */
2721     MsiDatabaseCommit(hdb1);
2722
2723     r = MsiDatabaseGenerateTransform(hdb1, hdb2, mstfile, 0, 0);
2724     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
2725
2726     MsiCloseHandle( hdb1 );
2727     MsiCloseHandle( hdb2 );
2728
2729     DeleteFile("testdata.bin");
2730 }
2731
2732 /* data for generating a transform */
2733
2734 /* tables transform names - encoded as they would be in an msi database file */
2735 static const WCHAR name1[] = { 0x4840, 0x3a8a, 0x481b, 0 }; /* AAR */
2736 static const WCHAR name2[] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }; /* _Columns */
2737 static const WCHAR name3[] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }; /* _Tables */
2738 static const WCHAR name4[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }; /* _StringData */
2739 static const WCHAR name5[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }; /* _StringPool */
2740 static const WCHAR name6[] = { 0x4840, 0x3e16, 0x4818, 0}; /* MOO */
2741 static const WCHAR name7[] = { 0x4840, 0x3c8b, 0x3a97, 0x409b, 0 }; /* BINARY */
2742 static const WCHAR name8[] = { 0x3c8b, 0x3a97, 0x409b, 0x387e, 0 }; /* BINARY.1 */
2743 static const WCHAR name9[] = { 0x4840, 0x4559, 0x44f2, 0x4568, 0x4737, 0 }; /* Property */
2744
2745 /* data in each table */
2746 static const WCHAR data1[] = { /* AAR */
2747     0x0201, 0x0008, 0x8001,  /* 0x0201 = add row (1), two shorts */
2748     0x0201, 0x0009, 0x8002,
2749 };
2750 static const WCHAR data2[] = { /* _Columns */
2751     0x0401, 0x0001, 0x8003, 0x0002, 0x9502,
2752     0x0401, 0x0001, 0x8004, 0x0003, 0x9502,
2753     0x0401, 0x0005, 0x0000, 0x0006, 0xbdff,  /* 0x0401 = add row (1), 4 shorts */
2754     0x0401, 0x0005, 0x0000, 0x0007, 0x8502,
2755     0x0401, 0x000a, 0x0000, 0x000a, 0xad48,
2756     0x0401, 0x000a, 0x0000, 0x000b, 0x9d00,
2757 };
2758 static const WCHAR data3[] = { /* _Tables */
2759     0x0101, 0x0005, /* 0x0101 = add row (1), 1 short */
2760     0x0101, 0x000a,
2761 };
2762 static const char data4[] = /* _StringData */
2763     "MOOCOWPIGcAARCARBARvwbmwPropertyValuepropval";  /* all the strings squashed together */
2764 static const WCHAR data5[] = { /* _StringPool */
2765 /*  len, refs */
2766     0,   0,    /* string 0 ''    */
2767     3,   2,    /* string 1 'MOO' */
2768     3,   1,    /* string 2 'COW' */
2769     3,   1,    /* string 3 'PIG' */
2770     1,   1,    /* string 4 'c'   */
2771     3,   3,    /* string 5 'AAR' */
2772     3,   1,    /* string 6 'CAR' */
2773     3,   1,    /* string 7 'BAR' */
2774     2,   1,    /* string 8 'vw'  */
2775     3,   1,    /* string 9 'bmw' */
2776     8,   4,    /* string 10 'Property' */
2777     5,   1,    /* string 11 'Value' */
2778     4,   1,    /* string 12 'prop' */
2779     3,   1,    /* string 13 'val' */
2780 };
2781 /* update row, 0x0002 is a bitmask of present column data, keys are excluded */
2782 static const WCHAR data6[] = { /* MOO */
2783     0x000a, 0x8001, 0x0004, 0x8005, /* update row */
2784     0x0000, 0x8003,         /* delete row */
2785 };
2786
2787 static const WCHAR data7[] = { /* BINARY */
2788     0x0201, 0x8001, 0x0001,
2789 };
2790
2791 static const char data8[] =  /* stream data for the BINARY table */
2792     "naengmyon";
2793
2794 static const WCHAR data9[] = { /* Property */
2795     0x0201, 0x000c, 0x000d,
2796 };
2797
2798 static const struct {
2799     LPCWSTR name;
2800     const void *data;
2801     DWORD size;
2802 } table_transform_data[] =
2803 {
2804     { name1, data1, sizeof data1 },
2805     { name2, data2, sizeof data2 },
2806     { name3, data3, sizeof data3 },
2807     { name4, data4, sizeof data4 - 1 },
2808     { name5, data5, sizeof data5 },
2809     { name6, data6, sizeof data6 },
2810     { name7, data7, sizeof data7 },
2811     { name8, data8, sizeof data8 - 1 },
2812     { name9, data9, sizeof data9 },
2813 };
2814
2815 #define NUM_TRANSFORM_TABLES (sizeof table_transform_data/sizeof table_transform_data[0])
2816
2817 static void generate_transform_manual(void)
2818 {
2819     IStorage *stg = NULL;
2820     IStream *stm;
2821     WCHAR name[0x20];
2822     HRESULT r;
2823     DWORD i, count;
2824     const DWORD mode = STGM_CREATE|STGM_READWRITE|STGM_DIRECT|STGM_SHARE_EXCLUSIVE;
2825
2826     const CLSID CLSID_MsiTransform = { 0xc1082,0,0,{0xc0,0,0,0,0,0,0,0x46}};
2827
2828     MultiByteToWideChar(CP_ACP, 0, mstfile, -1, name, 0x20);
2829
2830     r = StgCreateDocfile(name, mode, 0, &stg);
2831     ok(r == S_OK, "failed to create storage\n");
2832     if (!stg)
2833         return;
2834
2835     r = IStorage_SetClass( stg, &CLSID_MsiTransform );
2836     ok(r == S_OK, "failed to set storage type\n");
2837
2838     for (i=0; i<NUM_TRANSFORM_TABLES; i++)
2839     {
2840         r = IStorage_CreateStream( stg, table_transform_data[i].name,
2841                             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
2842         if (FAILED(r))
2843         {
2844             ok(0, "failed to create stream %08x\n", r);
2845             continue;
2846         }
2847
2848         r = IStream_Write( stm, table_transform_data[i].data,
2849                           table_transform_data[i].size, &count );
2850         if (FAILED(r) || count != table_transform_data[i].size)
2851             ok(0, "failed to write stream\n");
2852         IStream_Release(stm);
2853     }
2854
2855     IStorage_Release(stg);
2856 }
2857
2858 static UINT set_summary_info(MSIHANDLE hdb)
2859 {
2860     UINT res;
2861     MSIHANDLE suminfo;
2862
2863     /* build summary info */
2864     res = MsiGetSummaryInformation(hdb, NULL, 7, &suminfo);
2865     ok( res == ERROR_SUCCESS , "Failed to open summaryinfo\n" );
2866
2867     res = MsiSummaryInfoSetProperty(suminfo,2, VT_LPSTR, 0,NULL,
2868                         "Installation Database");
2869     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2870
2871     res = MsiSummaryInfoSetProperty(suminfo,3, VT_LPSTR, 0,NULL,
2872                         "Installation Database");
2873     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2874
2875     res = MsiSummaryInfoSetProperty(suminfo,4, VT_LPSTR, 0,NULL,
2876                         "Wine Hackers");
2877     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2878
2879     res = MsiSummaryInfoSetProperty(suminfo,7, VT_LPSTR, 0,NULL,
2880                     ";1033");
2881     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2882
2883     res = MsiSummaryInfoSetProperty(suminfo,9, VT_LPSTR, 0,NULL,
2884                     "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}");
2885     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2886
2887     res = MsiSummaryInfoSetProperty(suminfo, 14, VT_I4, 100, NULL, NULL);
2888     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2889
2890     res = MsiSummaryInfoSetProperty(suminfo, 15, VT_I4, 0, NULL, NULL);
2891     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2892
2893     res = MsiSummaryInfoPersist(suminfo);
2894     ok( res == ERROR_SUCCESS , "Failed to make summary info persist\n" );
2895
2896     res = MsiCloseHandle( suminfo);
2897     ok( res == ERROR_SUCCESS , "Failed to close suminfo\n" );
2898
2899     return res;
2900 }
2901
2902 static MSIHANDLE create_package_db(LPCSTR filename)
2903 {
2904     MSIHANDLE hdb = 0;
2905     UINT res;
2906
2907     DeleteFile(msifile);
2908
2909     /* create an empty database */
2910     res = MsiOpenDatabase(filename, MSIDBOPEN_CREATE, &hdb );
2911     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
2912     if( res != ERROR_SUCCESS )
2913         return hdb;
2914
2915     res = MsiDatabaseCommit( hdb );
2916     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
2917
2918     res = set_summary_info(hdb);
2919
2920     res = create_directory_table(hdb);
2921     ok( res == ERROR_SUCCESS , "Failed to create directory table\n" );
2922
2923     return hdb;
2924 }
2925
2926 static UINT package_from_db(MSIHANDLE hdb, MSIHANDLE *handle)
2927 {
2928     UINT res;
2929     CHAR szPackage[12];
2930     MSIHANDLE hPackage;
2931
2932     sprintf(szPackage, "#%u", hdb);
2933     res = MsiOpenPackage(szPackage, &hPackage);
2934     if (res != ERROR_SUCCESS)
2935         return res;
2936
2937     res = MsiCloseHandle(hdb);
2938     if (res != ERROR_SUCCESS)
2939     {
2940         MsiCloseHandle(hPackage);
2941         return res;
2942     }
2943
2944     *handle = hPackage;
2945     return ERROR_SUCCESS;
2946 }
2947
2948 static void test_try_transform(void)
2949 {
2950     MSIHANDLE hdb, hview, hrec, hpkg = 0;
2951     LPCSTR query;
2952     UINT r;
2953     DWORD sz;
2954     char buffer[MAX_PATH];
2955
2956     DeleteFile(msifile);
2957     DeleteFile(mstfile);
2958
2959     /* create the database */
2960     hdb = create_package_db(msifile);
2961     ok(hdb, "Failed to create package db\n");
2962
2963     query = "CREATE TABLE `MOO` ( `NOO` SHORT NOT NULL, `OOO` CHAR(255) PRIMARY KEY `NOO`)";
2964     r = run_query(hdb, 0, query);
2965     ok(r == ERROR_SUCCESS, "failed to add table\n");
2966
2967     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 1, 'a' )";
2968     r = run_query(hdb, 0, query);
2969     ok(r == ERROR_SUCCESS, "failed to add row\n");
2970
2971     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 2, 'b' )";
2972     r = run_query(hdb, 0, query);
2973     ok(r == ERROR_SUCCESS, "failed to add row\n");
2974
2975     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 3, 'c' )";
2976     r = run_query(hdb, 0, query);
2977     ok(r == ERROR_SUCCESS, "failed to add row\n");
2978
2979     query = "CREATE TABLE `BINARY` ( `ID` SHORT NOT NULL, `BLOB` OBJECT PRIMARY KEY `ID`)";
2980     r = run_query(hdb, 0, query);
2981     ok(r == ERROR_SUCCESS, "failed to add table\n");
2982
2983     hrec = MsiCreateRecord(2);
2984     r = MsiRecordSetInteger(hrec, 1, 2);
2985     ok(r == ERROR_SUCCESS, "failed to set integer\n");
2986
2987     write_file("testdata.bin", "lamyon", 6);
2988     r = MsiRecordSetStream(hrec, 2, "testdata.bin");
2989     ok(r == ERROR_SUCCESS, "failed to set stream\n");
2990
2991     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
2992     r = run_query(hdb, hrec, query);
2993     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
2994
2995     MsiCloseHandle(hrec);
2996
2997     r = MsiDatabaseCommit( hdb );
2998     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
2999
3000     MsiCloseHandle( hdb );
3001     DeleteFileA("testdata.bin");
3002
3003     /*
3004      * Both these generate an equivalent transform,
3005      *  but the first doesn't work in Wine yet
3006      *  because MsiDatabaseGenerateTransform is unimplemented.
3007      */
3008     if (0)
3009         generate_transform();
3010     else
3011         generate_transform_manual();
3012
3013     r = MsiOpenDatabase(msifile, MSIDBOPEN_DIRECT, &hdb );
3014     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
3015
3016     r = MsiDatabaseApplyTransform( hdb, mstfile, 0 );
3017     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
3018
3019     MsiDatabaseCommit( hdb );
3020
3021     /* check new values */
3022     hrec = 0;
3023     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 1 AND `CAR` = 'vw'";
3024     r = do_query(hdb, query, &hrec);
3025     ok(r == ERROR_SUCCESS, "select query failed\n");
3026     MsiCloseHandle(hrec);
3027
3028     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 2 AND `CAR` = 'bmw'";
3029     hrec = 0;
3030     r = do_query(hdb, query, &hrec);
3031     ok(r == ERROR_SUCCESS, "select query failed\n");
3032     MsiCloseHandle(hrec);
3033
3034     /* check updated values */
3035     hrec = 0;
3036     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 1 AND `OOO` = 'c'";
3037     r = do_query(hdb, query, &hrec);
3038     ok(r == ERROR_SUCCESS, "select query failed\n");
3039     MsiCloseHandle(hrec);
3040
3041     /* check unchanged value */
3042     hrec = 0;
3043     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 2 AND `OOO` = 'b'";
3044     r = do_query(hdb, query, &hrec);
3045     ok(r == ERROR_SUCCESS, "select query failed\n");
3046     MsiCloseHandle(hrec);
3047
3048     /* check deleted value */
3049     hrec = 0;
3050     query = "select * from `MOO` where `NOO` = 3";
3051     r = do_query(hdb, query, &hrec);
3052     ok(r == ERROR_NO_MORE_ITEMS, "select query failed\n");
3053     if (hrec) MsiCloseHandle(hrec);
3054
3055     /* check added stream */
3056     hrec = 0;
3057     query = "select `BLOB` from `BINARY` where `ID` = 1";
3058     r = do_query(hdb, query, &hrec);
3059     ok(r == ERROR_SUCCESS, "select query failed\n");
3060
3061     /* check the contents of the stream */
3062     sz = sizeof buffer;
3063     r = MsiRecordReadStream( hrec, 1, buffer, &sz );
3064     ok(r == ERROR_SUCCESS, "read stream failed\n");
3065     ok(!memcmp(buffer, "naengmyon", 9), "stream data was wrong\n");
3066     ok(sz == 9, "stream data was wrong size\n");
3067     if (hrec) MsiCloseHandle(hrec);
3068
3069     /* check the validity of the table with a deleted row */
3070     hrec = 0;
3071     query = "select * from `MOO`";
3072     r = MsiDatabaseOpenView(hdb, query, &hview);
3073     ok(r == ERROR_SUCCESS, "open view failed\n");
3074
3075     r = MsiViewExecute(hview, 0);
3076     ok(r == ERROR_SUCCESS, "view execute failed\n");
3077
3078     r = MsiViewFetch(hview, &hrec);
3079     ok(r == ERROR_SUCCESS, "view fetch failed\n");
3080
3081     r = MsiRecordGetInteger(hrec, 1);
3082     ok(r == 1, "Expected 1, got %d\n", r);
3083
3084     sz = sizeof buffer;
3085     r = MsiRecordGetString(hrec, 2, buffer, &sz);
3086     ok(r == ERROR_SUCCESS, "record get string failed\n");
3087     ok(!lstrcmpA(buffer, "c"), "Expected c, got %s\n", buffer);
3088
3089     r = MsiRecordGetInteger(hrec, 3);
3090     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3091
3092     r = MsiRecordGetInteger(hrec, 4);
3093     ok(r == 5, "Expected 5, got %d\n", r);
3094
3095     MsiCloseHandle(hrec);
3096
3097     r = MsiViewFetch(hview, &hrec);
3098     ok(r == ERROR_SUCCESS, "view fetch failed\n");
3099
3100     r = MsiRecordGetInteger(hrec, 1);
3101     ok(r == 2, "Expected 2, got %d\n", r);
3102
3103     sz = sizeof buffer;
3104     r = MsiRecordGetString(hrec, 2, buffer, &sz);
3105     ok(r == ERROR_SUCCESS, "record get string failed\n");
3106     ok(!lstrcmpA(buffer, "b"), "Expected b, got %s\n", buffer);
3107
3108     r = MsiRecordGetInteger(hrec, 3);
3109     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3110
3111     r = MsiRecordGetInteger(hrec, 4);
3112     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3113
3114     MsiCloseHandle(hrec);
3115
3116     r = MsiViewFetch(hview, &hrec);
3117     ok(r == ERROR_NO_MORE_ITEMS, "view fetch succeeded\n");
3118
3119     MsiCloseHandle(hrec);
3120     MsiViewClose(hview);
3121     MsiCloseHandle(hview);
3122
3123     /* check that the property was added */
3124     r = package_from_db(hdb, &hpkg);
3125     if (r == ERROR_INSTALL_PACKAGE_REJECTED)
3126     {
3127         skip("Not enough rights to perform tests\n");
3128         goto error;
3129     }
3130     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
3131
3132     sz = MAX_PATH;
3133     r = MsiGetProperty(hpkg, "prop", buffer, &sz);
3134     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3135     ok(!lstrcmp(buffer, "val"), "Expected val, got %s\n", buffer);
3136
3137     MsiCloseHandle(hpkg);
3138
3139 error:
3140     MsiCloseHandle(hdb);
3141     DeleteFile(msifile);
3142     DeleteFile(mstfile);
3143 }
3144
3145 struct join_res
3146 {
3147     const CHAR one[MAX_PATH];
3148     const CHAR two[MAX_PATH];
3149 };
3150
3151 struct join_res_4col
3152 {
3153     const CHAR one[MAX_PATH];
3154     const CHAR two[MAX_PATH];
3155     const CHAR three[MAX_PATH];
3156     const CHAR four[MAX_PATH];
3157 };
3158
3159 struct join_res_uint
3160 {
3161     UINT one;
3162     UINT two;
3163     UINT three;
3164     UINT four;
3165     UINT five;
3166     UINT six;
3167 };
3168
3169 static const struct join_res join_res_first[] =
3170 {
3171     { "alveolar", "procerus" },
3172     { "septum", "procerus" },
3173     { "septum", "nasalis" },
3174     { "ramus", "nasalis" },
3175     { "malar", "mentalis" },
3176 };
3177
3178 static const struct join_res join_res_second[] =
3179 {
3180     { "nasal", "septum" },
3181     { "mandible", "ramus" },
3182 };
3183
3184 static const struct join_res join_res_third[] =
3185 {
3186     { "msvcp.dll", "abcdefgh" },
3187     { "msvcr.dll", "ijklmnop" },
3188 };
3189
3190 static const struct join_res join_res_fourth[] =
3191 {
3192     { "msvcp.dll.01234", "single.dll.31415" },
3193 };
3194
3195 static const struct join_res join_res_fifth[] =
3196 {
3197     { "malar", "procerus" },
3198 };
3199
3200 static const struct join_res join_res_sixth[] =
3201 {
3202     { "malar", "procerus" },
3203     { "malar", "procerus" },
3204     { "malar", "nasalis" },
3205     { "malar", "nasalis" },
3206     { "malar", "nasalis" },
3207     { "malar", "mentalis" },
3208 };
3209
3210 static const struct join_res join_res_seventh[] =
3211 {
3212     { "malar", "nasalis" },
3213     { "malar", "nasalis" },
3214     { "malar", "nasalis" },
3215 };
3216
3217 static const struct join_res_4col join_res_eighth[] =
3218 {
3219     { "msvcp.dll", "msvcp.dll.01234", "msvcp.dll.01234", "abcdefgh" },
3220     { "msvcr.dll", "msvcr.dll.56789", "msvcp.dll.01234", "abcdefgh" },
3221     { "msvcp.dll", "msvcp.dll.01234", "msvcr.dll.56789", "ijklmnop" },
3222     { "msvcr.dll", "msvcr.dll.56789", "msvcr.dll.56789", "ijklmnop" },
3223     { "msvcp.dll", "msvcp.dll.01234", "single.dll.31415", "msvcp.dll" },
3224     { "msvcr.dll", "msvcr.dll.56789", "single.dll.31415", "msvcp.dll" },
3225 };
3226
3227 static const struct join_res_uint join_res_ninth[] =
3228 {
3229     { 1, 2, 3, 4, 7, 8 },
3230     { 1, 2, 5, 6, 7, 8 },
3231     { 1, 2, 3, 4, 9, 10 },
3232     { 1, 2, 5, 6, 9, 10 },
3233     { 1, 2, 3, 4, 11, 12 },
3234     { 1, 2, 5, 6, 11, 12 },
3235 };
3236
3237 static void test_join(void)
3238 {
3239     MSIHANDLE hdb, hview, hrec;
3240     LPCSTR query;
3241     CHAR buf[MAX_PATH];
3242     UINT r, count;
3243     DWORD size, i;
3244     BOOL data_correct;
3245
3246     hdb = create_db();
3247     ok( hdb, "failed to create db\n");
3248
3249     r = create_component_table( hdb );
3250     ok( r == ERROR_SUCCESS, "cannot create Component table: %d\n", r );
3251
3252     r = add_component_entry( hdb, "'zygomatic', 'malar', 'INSTALLDIR', 0, '', ''" );
3253     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3254
3255     r = add_component_entry( hdb, "'maxilla', 'alveolar', 'INSTALLDIR', 0, '', ''" );
3256     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3257
3258     r = add_component_entry( hdb, "'nasal', 'septum', 'INSTALLDIR', 0, '', ''" );
3259     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3260
3261     r = add_component_entry( hdb, "'mandible', 'ramus', 'INSTALLDIR', 0, '', ''" );
3262     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3263
3264     r = create_feature_components_table( hdb );
3265     ok( r == ERROR_SUCCESS, "cannot create FeatureComponents table: %d\n", r );
3266
3267     r = add_feature_components_entry( hdb, "'procerus', 'maxilla'" );
3268     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3269
3270     r = add_feature_components_entry( hdb, "'procerus', 'nasal'" );
3271     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3272
3273     r = add_feature_components_entry( hdb, "'nasalis', 'nasal'" );
3274     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3275
3276     r = add_feature_components_entry( hdb, "'nasalis', 'mandible'" );
3277     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3278
3279     r = add_feature_components_entry( hdb, "'nasalis', 'notacomponent'" );
3280     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3281
3282     r = add_feature_components_entry( hdb, "'mentalis', 'zygomatic'" );
3283     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3284
3285     r = create_std_dlls_table( hdb );
3286     ok( r == ERROR_SUCCESS, "cannot create StdDlls table: %d\n", r );
3287
3288     r = add_std_dlls_entry( hdb, "'msvcp.dll', 'msvcp.dll.01234'" );
3289     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
3290
3291     r = add_std_dlls_entry( hdb, "'msvcr.dll', 'msvcr.dll.56789'" );
3292     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
3293
3294     r = create_binary_table( hdb );
3295     ok( r == ERROR_SUCCESS, "cannot create Binary table: %d\n", r );
3296
3297     r = add_binary_entry( hdb, "'msvcp.dll.01234', 'abcdefgh'" );
3298     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3299
3300     r = add_binary_entry( hdb, "'msvcr.dll.56789', 'ijklmnop'" );
3301     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3302
3303     r = add_binary_entry( hdb, "'single.dll.31415', 'msvcp.dll'" );
3304     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3305
3306     query = "CREATE TABLE `One` (`A` SHORT, `B` SHORT PRIMARY KEY `A`)";
3307     r = run_query( hdb, 0, query);
3308     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3309
3310     query = "CREATE TABLE `Two` (`C` SHORT, `D` SHORT PRIMARY KEY `C`)";
3311     r = run_query( hdb, 0, query);
3312     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3313
3314     query = "CREATE TABLE `Three` (`E` SHORT, `F` SHORT PRIMARY KEY `E`)";
3315     r = run_query( hdb, 0, query);
3316     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3317
3318     query = "INSERT INTO `One` (`A`, `B`) VALUES (1, 2)";
3319     r = run_query( hdb, 0, query);
3320     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3321
3322     query = "INSERT INTO `Two` (`C`, `D`) VALUES (3, 4)";
3323     r = run_query( hdb, 0, query);
3324     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3325
3326     query = "INSERT INTO `Two` (`C`, `D`) VALUES (5, 6)";
3327     r = run_query( hdb, 0, query);
3328     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3329
3330     query = "INSERT INTO `Three` (`E`, `F`) VALUES (7, 8)";
3331     r = run_query( hdb, 0, query);
3332     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3333
3334     query = "INSERT INTO `Three` (`E`, `F`) VALUES (9, 10)";
3335     r = run_query( hdb, 0, query);
3336     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3337
3338     query = "INSERT INTO `Three` (`E`, `F`) VALUES (11, 12)";
3339     r = run_query( hdb, 0, query);
3340     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3341
3342     query = "CREATE TABLE `Four` (`G` SHORT, `H` SHORT PRIMARY KEY `G`)";
3343     r = run_query( hdb, 0, query);
3344     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3345
3346     query = "CREATE TABLE `Five` (`I` SHORT, `J` SHORT PRIMARY KEY `I`)";
3347     r = run_query( hdb, 0, query);
3348     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3349
3350     query = "INSERT INTO `Five` (`I`, `J`) VALUES (13, 14)";
3351     r = run_query( hdb, 0, query);
3352     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3353
3354     query = "INSERT INTO `Five` (`I`, `J`) VALUES (15, 16)";
3355     r = run_query( hdb, 0, query);
3356     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3357
3358     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3359             "FROM `Component`, `FeatureComponents` "
3360             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
3361             "ORDER BY `Feature_`";
3362     r = MsiDatabaseOpenView(hdb, query, &hview);
3363     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3364
3365     r = MsiViewExecute(hview, 0);
3366     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3367
3368     i = 0;
3369     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3370     {
3371         count = MsiRecordGetFieldCount( hrec );
3372         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3373
3374         size = MAX_PATH;
3375         r = MsiRecordGetString( hrec, 1, buf, &size );
3376         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3377         ok( !lstrcmp( buf, join_res_first[i].one ),
3378             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_first[i].one, buf );
3379
3380         size = MAX_PATH;
3381         r = MsiRecordGetString( hrec, 2, buf, &size );
3382         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3383         ok( !lstrcmp( buf, join_res_first[i].two ),
3384             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_first[i].two, buf );
3385
3386         i++;
3387         MsiCloseHandle(hrec);
3388     }
3389
3390     ok( i == 5, "Expected 5 rows, got %d\n", i );
3391     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3392
3393     MsiViewClose(hview);
3394     MsiCloseHandle(hview);
3395
3396     /* try a join without a WHERE condition */
3397     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3398             "FROM `Component`, `FeatureComponents` ";
3399     r = MsiDatabaseOpenView(hdb, query, &hview);
3400     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3401
3402     r = MsiViewExecute(hview, 0);
3403     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3404
3405     i = 0;
3406     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3407     {
3408         i++;
3409         MsiCloseHandle(hrec);
3410     }
3411     ok( i == 24, "Expected 24 rows, got %d\n", i );
3412
3413     MsiViewClose(hview);
3414     MsiCloseHandle(hview);
3415
3416     query = "SELECT DISTINCT Component, ComponentId FROM FeatureComponents, Component "
3417             "WHERE FeatureComponents.Component_=Component.Component "
3418             "AND (Feature_='nasalis') ORDER BY Feature_";
3419     r = MsiDatabaseOpenView(hdb, query, &hview);
3420     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3421
3422     r = MsiViewExecute(hview, 0);
3423     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3424
3425     i = 0;
3426     data_correct = TRUE;
3427     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3428     {
3429         count = MsiRecordGetFieldCount( hrec );
3430         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3431
3432         size = MAX_PATH;
3433         r = MsiRecordGetString( hrec, 1, buf, &size );
3434         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3435         if( lstrcmp( buf, join_res_second[i].one ))
3436             data_correct = FALSE;
3437
3438         size = MAX_PATH;
3439         r = MsiRecordGetString( hrec, 2, buf, &size );
3440         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3441         if( lstrcmp( buf, join_res_second[i].two ))
3442             data_correct = FALSE;
3443
3444         i++;
3445         MsiCloseHandle(hrec);
3446     }
3447
3448     ok( data_correct, "data returned in the wrong order\n");
3449
3450     ok( i == 2, "Expected 2 rows, got %d\n", i );
3451     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3452
3453     MsiViewClose(hview);
3454     MsiCloseHandle(hview);
3455
3456     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
3457             "FROM `StdDlls`, `Binary` "
3458             "WHERE `StdDlls`.`Binary_` = `Binary`.`Name` "
3459             "ORDER BY `File`";
3460     r = MsiDatabaseOpenView(hdb, query, &hview);
3461     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3462
3463     r = MsiViewExecute(hview, 0);
3464     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3465
3466     i = 0;
3467     data_correct = TRUE;
3468     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3469     {
3470         count = MsiRecordGetFieldCount( hrec );
3471         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3472
3473         size = MAX_PATH;
3474         r = MsiRecordGetString( hrec, 1, buf, &size );
3475         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3476         if( lstrcmp( buf, join_res_third[i].one ) )
3477             data_correct = FALSE;
3478
3479         size = MAX_PATH;
3480         r = MsiRecordGetString( hrec, 2, buf, &size );
3481         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3482         if( lstrcmp( buf, join_res_third[i].two ) )
3483             data_correct = FALSE;
3484
3485         i++;
3486         MsiCloseHandle(hrec);
3487     }
3488     ok( data_correct, "data returned in the wrong order\n");
3489
3490     ok( i == 2, "Expected 2 rows, got %d\n", i );
3491
3492     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3493
3494     MsiViewClose(hview);
3495     MsiCloseHandle(hview);
3496
3497     query = "SELECT `StdDlls`.`Binary_`, `Binary`.`Name` "
3498             "FROM `StdDlls`, `Binary` "
3499             "WHERE `StdDlls`.`File` = `Binary`.`Data` "
3500             "ORDER BY `Name`";
3501     r = MsiDatabaseOpenView(hdb, query, &hview);
3502     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3503
3504     r = MsiViewExecute(hview, 0);
3505     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3506
3507     i = 0;
3508     data_correct = TRUE;
3509     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3510     {
3511         count = MsiRecordGetFieldCount( hrec );
3512         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3513
3514         size = MAX_PATH;
3515         r = MsiRecordGetString( hrec, 1, buf, &size );
3516         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3517         if( lstrcmp( buf, join_res_fourth[i].one ))
3518             data_correct = FALSE;
3519
3520         size = MAX_PATH;
3521         r = MsiRecordGetString( hrec, 2, buf, &size );
3522         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3523         if( lstrcmp( buf, join_res_fourth[i].two ))
3524             data_correct = FALSE;
3525
3526         i++;
3527         MsiCloseHandle(hrec);
3528     }
3529     ok( data_correct, "data returned in the wrong order\n");
3530
3531     ok( i == 1, "Expected 1 rows, got %d\n", i );
3532     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3533
3534     MsiViewClose(hview);
3535     MsiCloseHandle(hview);
3536
3537     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3538             "FROM `Component`, `FeatureComponents` "
3539             "WHERE `Component`.`Component` = 'zygomatic' "
3540             "AND `FeatureComponents`.`Component_` = 'maxilla' "
3541             "ORDER BY `Feature_`";
3542     r = MsiDatabaseOpenView(hdb, query, &hview);
3543     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3544
3545     r = MsiViewExecute(hview, 0);
3546     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3547
3548     i = 0;
3549     data_correct = TRUE;
3550     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3551     {
3552         count = MsiRecordGetFieldCount( hrec );
3553         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3554
3555         size = MAX_PATH;
3556         r = MsiRecordGetString( hrec, 1, buf, &size );
3557         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3558         if( lstrcmp( buf, join_res_fifth[i].one ))
3559             data_correct = FALSE;
3560
3561         size = MAX_PATH;
3562         r = MsiRecordGetString( hrec, 2, buf, &size );
3563         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3564         if( lstrcmp( buf, join_res_fifth[i].two ))
3565             data_correct = FALSE;
3566
3567         i++;
3568         MsiCloseHandle(hrec);
3569     }
3570     ok( data_correct, "data returned in the wrong order\n");
3571
3572     ok( i == 1, "Expected 1 rows, got %d\n", i );
3573     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3574
3575     MsiViewClose(hview);
3576     MsiCloseHandle(hview);
3577
3578     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3579             "FROM `Component`, `FeatureComponents` "
3580             "WHERE `Component` = 'zygomatic' "
3581             "ORDER BY `Feature_`";
3582     r = MsiDatabaseOpenView(hdb, query, &hview);
3583     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3584
3585     r = MsiViewExecute(hview, 0);
3586     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3587
3588     i = 0;
3589     data_correct = TRUE;
3590     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3591     {
3592         count = MsiRecordGetFieldCount( hrec );
3593         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3594
3595         size = MAX_PATH;
3596         r = MsiRecordGetString( hrec, 1, buf, &size );
3597         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3598         if( lstrcmp( buf, join_res_sixth[i].one ))
3599             data_correct = FALSE;
3600
3601         size = MAX_PATH;
3602         r = MsiRecordGetString( hrec, 2, buf, &size );
3603         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3604         if( lstrcmp( buf, join_res_sixth[i].two ))
3605             data_correct = FALSE;
3606
3607         i++;
3608         MsiCloseHandle(hrec);
3609     }
3610     ok( data_correct, "data returned in the wrong order\n");
3611
3612     ok( i == 6, "Expected 6 rows, got %d\n", i );
3613     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3614
3615     MsiViewClose(hview);
3616     MsiCloseHandle(hview);
3617
3618     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3619             "FROM `Component`, `FeatureComponents` "
3620             "WHERE `Component` = 'zygomatic' "
3621             "AND `Feature_` = 'nasalis' "
3622             "ORDER BY `Feature_`";
3623     r = MsiDatabaseOpenView(hdb, query, &hview);
3624     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3625
3626     r = MsiViewExecute(hview, 0);
3627     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3628
3629     i = 0;
3630     data_correct = TRUE;
3631     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3632     {
3633         count = MsiRecordGetFieldCount( hrec );
3634         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3635
3636         size = MAX_PATH;
3637         r = MsiRecordGetString( hrec, 1, buf, &size );
3638         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3639         if( lstrcmp( buf, join_res_seventh[i].one ))
3640             data_correct = FALSE;
3641
3642         size = MAX_PATH;
3643         r = MsiRecordGetString( hrec, 2, buf, &size );
3644         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3645         if( lstrcmp( buf, join_res_seventh[i].two ))
3646             data_correct = FALSE;
3647
3648         i++;
3649         MsiCloseHandle(hrec);
3650     }
3651
3652     ok( data_correct, "data returned in the wrong order\n");
3653     ok( i == 3, "Expected 3 rows, got %d\n", i );
3654     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3655
3656     MsiViewClose(hview);
3657     MsiCloseHandle(hview);
3658
3659     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
3660             "FROM `StdDlls`, `Binary` ";
3661     r = MsiDatabaseOpenView(hdb, query, &hview);
3662     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3663
3664     r = MsiViewExecute(hview, 0);
3665     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3666
3667     i = 0;
3668     data_correct = TRUE;
3669     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3670     {
3671         count = MsiRecordGetFieldCount( hrec );
3672         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3673
3674         size = MAX_PATH;
3675         r = MsiRecordGetString( hrec, 1, buf, &size );
3676         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3677         if( lstrcmp( buf, join_res_eighth[i].one ))
3678             data_correct = FALSE;
3679
3680         size = MAX_PATH;
3681         r = MsiRecordGetString( hrec, 2, buf, &size );
3682         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3683         if( lstrcmp( buf, join_res_eighth[i].four ))
3684             data_correct = FALSE;
3685
3686         i++;
3687         MsiCloseHandle(hrec);
3688     }
3689
3690     ok( data_correct, "data returned in the wrong order\n");
3691     ok( i == 6, "Expected 6 rows, got %d\n", i );
3692     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3693
3694     MsiViewClose(hview);
3695     MsiCloseHandle(hview);
3696
3697     query = "SELECT * FROM `StdDlls`, `Binary` ";
3698     r = MsiDatabaseOpenView(hdb, query, &hview);
3699     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3700
3701     r = MsiViewExecute(hview, 0);
3702     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3703
3704     i = 0;
3705     data_correct = TRUE;
3706     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3707     {
3708         count = MsiRecordGetFieldCount( hrec );
3709         ok( count == 4, "Expected 4 record fields, got %d\n", count );
3710
3711         size = MAX_PATH;
3712         r = MsiRecordGetString( hrec, 1, buf, &size );
3713         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3714         if( lstrcmp( buf, join_res_eighth[i].one ))
3715             data_correct = FALSE;
3716
3717         size = MAX_PATH;
3718         r = MsiRecordGetString( hrec, 2, buf, &size );
3719         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3720         if( lstrcmp( buf, join_res_eighth[i].two ))
3721             data_correct = FALSE;
3722
3723         size = MAX_PATH;
3724         r = MsiRecordGetString( hrec, 3, buf, &size );
3725         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3726         if( lstrcmp( buf, join_res_eighth[i].three ))
3727             data_correct = FALSE;
3728
3729         size = MAX_PATH;
3730         r = MsiRecordGetString( hrec, 4, buf, &size );
3731         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3732         if( lstrcmp( buf, join_res_eighth[i].four ))
3733             data_correct = FALSE;
3734
3735         i++;
3736         MsiCloseHandle(hrec);
3737     }
3738     ok( data_correct, "data returned in the wrong order\n");
3739
3740     ok( i == 6, "Expected 6 rows, got %d\n", i );
3741     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3742
3743     MsiViewClose(hview);
3744     MsiCloseHandle(hview);
3745
3746     query = "SELECT * FROM `One`, `Two`, `Three` ";
3747     r = MsiDatabaseOpenView(hdb, query, &hview);
3748     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3749
3750     r = MsiViewExecute(hview, 0);
3751     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3752
3753     i = 0;
3754     data_correct = TRUE;
3755     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3756     {
3757         count = MsiRecordGetFieldCount( hrec );
3758         ok( count == 6, "Expected 6 record fields, got %d\n", count );
3759
3760         r = MsiRecordGetInteger( hrec, 1 );
3761         if( r != join_res_ninth[i].one )
3762             data_correct = FALSE;
3763
3764         r = MsiRecordGetInteger( hrec, 2 );
3765         if( r != join_res_ninth[i].two )
3766             data_correct = FALSE;
3767
3768         r = MsiRecordGetInteger( hrec, 3 );
3769         if( r != join_res_ninth[i].three )
3770             data_correct = FALSE;
3771
3772         r = MsiRecordGetInteger( hrec, 4 );
3773         if( r != join_res_ninth[i].four )
3774             data_correct = FALSE;
3775
3776         r = MsiRecordGetInteger( hrec, 5 );
3777         if( r != join_res_ninth[i].five )
3778             data_correct = FALSE;
3779
3780         r = MsiRecordGetInteger( hrec, 6);
3781         if( r != join_res_ninth[i].six )
3782             data_correct = FALSE;
3783
3784         i++;
3785         MsiCloseHandle(hrec);
3786     }
3787     ok( data_correct, "data returned in the wrong order\n");
3788
3789     ok( i == 6, "Expected 6 rows, got %d\n", i );
3790     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3791
3792     MsiViewClose(hview);
3793     MsiCloseHandle(hview);
3794
3795     query = "SELECT * FROM `Four`, `Five`";
3796     r = MsiDatabaseOpenView(hdb, query, &hview);
3797     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3798
3799     r = MsiViewExecute(hview, 0);
3800     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3801
3802     r = MsiViewFetch(hview, &hrec);
3803     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3804
3805     MsiViewClose(hview);
3806     MsiCloseHandle(hview);
3807
3808     query = "SELECT * FROM `Nonexistent`, `One`";
3809     r = MsiDatabaseOpenView(hdb, query, &hview);
3810     ok( r == ERROR_BAD_QUERY_SYNTAX,
3811         "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r );
3812
3813     /* try updating a row in a join table */
3814     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3815             "FROM `Component`, `FeatureComponents` "
3816             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
3817             "ORDER BY `Feature_`";
3818     r = MsiDatabaseOpenView(hdb, query, &hview);
3819     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3820
3821     r = MsiViewExecute(hview, 0);
3822     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3823
3824     r = MsiViewFetch(hview, &hrec);
3825     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
3826
3827     r = MsiRecordSetString( hrec, 1, "epicranius" );
3828     ok( r == ERROR_SUCCESS, "failed to set string: %d\n", r );
3829
3830     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
3831     ok( r == ERROR_SUCCESS, "failed to update row: %d\n", r );
3832
3833     /* try another valid operation for joins */
3834     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
3835     todo_wine ok( r == ERROR_SUCCESS, "failed to refresh row: %d\n", r );
3836
3837     /* try an invalid operation for joins */
3838     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
3839     ok( r == ERROR_FUNCTION_FAILED, "unexpected result: %d\n", r );
3840
3841     r = MsiRecordSetString( hrec, 2, "epicranius" );
3842     ok( r == ERROR_SUCCESS, "failed to set string: %d\n", r );
3843
3844     /* primary key cannot be updated */
3845     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
3846     todo_wine ok( r == ERROR_FUNCTION_FAILED, "failed to update row: %d\n", r );
3847
3848     MsiCloseHandle(hrec);
3849     MsiViewClose(hview);
3850     MsiCloseHandle(hview);
3851
3852     r = MsiDatabaseOpenView(hdb, query, &hview);
3853     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
3854
3855     r = MsiViewExecute(hview, 0);
3856     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
3857
3858     r = MsiViewFetch(hview, &hrec);
3859     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
3860
3861     size = MAX_PATH;
3862     r = MsiRecordGetString( hrec, 1, buf, &size );
3863     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3864     ok( !lstrcmp( buf, "epicranius" ), "expected 'epicranius', got %s\n", buf );
3865
3866     MsiCloseHandle(hrec);
3867     MsiViewClose(hview);
3868     MsiCloseHandle(hview);
3869
3870     MsiCloseHandle(hdb);
3871     DeleteFile(msifile);
3872 }
3873
3874 static void test_temporary_table(void)
3875 {
3876     MSICONDITION cond;
3877     MSIHANDLE hdb = 0, view = 0, rec;
3878     const char *query;
3879     UINT r;
3880     char buf[0x10];
3881     DWORD sz;
3882
3883     cond = MsiDatabaseIsTablePersistent(0, NULL);
3884     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
3885
3886     hdb = create_db();
3887     ok( hdb, "failed to create db\n");
3888
3889     cond = MsiDatabaseIsTablePersistent(hdb, NULL);
3890     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
3891
3892     cond = MsiDatabaseIsTablePersistent(hdb, "_Tables");
3893     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3894
3895     cond = MsiDatabaseIsTablePersistent(hdb, "_Columns");
3896     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3897
3898     cond = MsiDatabaseIsTablePersistent(hdb, "_Storages");
3899     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3900
3901     cond = MsiDatabaseIsTablePersistent(hdb, "_Streams");
3902     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3903
3904     query = "CREATE TABLE `P` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`)";
3905     r = run_query(hdb, 0, query);
3906     ok(r == ERROR_SUCCESS, "failed to add table\n");
3907
3908     cond = MsiDatabaseIsTablePersistent(hdb, "P");
3909     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
3910
3911     query = "CREATE TABLE `P2` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`) HOLD";
3912     r = run_query(hdb, 0, query);
3913     ok(r == ERROR_SUCCESS, "failed to add table\n");
3914
3915     cond = MsiDatabaseIsTablePersistent(hdb, "P2");
3916     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
3917
3918     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
3919     r = run_query(hdb, 0, query);
3920     ok(r == ERROR_SUCCESS, "failed to add table\n");
3921
3922     cond = MsiDatabaseIsTablePersistent(hdb, "T");
3923     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
3924
3925     query = "CREATE TABLE `T2` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
3926     r = run_query(hdb, 0, query);
3927     ok(r == ERROR_SUCCESS, "failed to add table\n");
3928
3929     query = "SELECT * FROM `T2`";
3930     r = MsiDatabaseOpenView(hdb, query, &view);
3931     ok(r == ERROR_BAD_QUERY_SYNTAX,
3932        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3933
3934     cond = MsiDatabaseIsTablePersistent(hdb, "T2");
3935     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3936
3937     query = "CREATE TABLE `T3` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) PRIMARY KEY `C`)";
3938     r = run_query(hdb, 0, query);
3939     ok(r == ERROR_SUCCESS, "failed to add table\n");
3940
3941     cond = MsiDatabaseIsTablePersistent(hdb, "T3");
3942     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
3943
3944     query = "CREATE TABLE `T4` ( `B` SHORT NOT NULL, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
3945     r = run_query(hdb, 0, query);
3946     ok(r == ERROR_FUNCTION_FAILED, "failed to add table\n");
3947
3948     cond = MsiDatabaseIsTablePersistent(hdb, "T4");
3949     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3950
3951     query = "CREATE TABLE `T5` ( `B` SHORT NOT NULL TEMP, `C` CHAR(255) TEMP PRIMARY KEY `C`) HOLD";
3952     r = run_query(hdb, 0, query);
3953     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to add table\n");
3954
3955     query = "select * from `T`";
3956     r = MsiDatabaseOpenView(hdb, query, &view);
3957     ok(r == ERROR_SUCCESS, "failed to query table\n");
3958     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
3959     ok(r == ERROR_SUCCESS, "failed to get column info\n");
3960
3961     sz = sizeof buf;
3962     r = MsiRecordGetString(rec, 1, buf, &sz);
3963     ok(r == ERROR_SUCCESS, "failed to get string\n");
3964     ok( 0 == strcmp("G255", buf), "wrong column type\n");
3965
3966     sz = sizeof buf;
3967     r = MsiRecordGetString(rec, 2, buf, &sz);
3968     ok(r == ERROR_SUCCESS, "failed to get string\n");
3969     ok( 0 == strcmp("j2", buf), "wrong column type\n");
3970
3971     MsiCloseHandle( rec );
3972     MsiViewClose( view );
3973     MsiCloseHandle( view );
3974
3975     /* query the table data */
3976     rec = 0;
3977     r = do_query(hdb, "select * from `_Tables` where `Name` = 'T'", &rec);
3978     ok( r == ERROR_SUCCESS, "temporary table exists in _Tables\n");
3979     MsiCloseHandle( rec );
3980
3981     /* query the column data */
3982     rec = 0;
3983     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'B'", &rec);
3984     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
3985     if (rec) MsiCloseHandle( rec );
3986
3987     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'C'", &rec);
3988     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
3989     if (rec) MsiCloseHandle( rec );
3990
3991     MsiCloseHandle( hdb );
3992
3993     DeleteFile(msifile);
3994 }
3995
3996 static void test_alter(void)
3997 {
3998     MSICONDITION cond;
3999     MSIHANDLE hdb = 0;
4000     const char *query;
4001     UINT r;
4002
4003     hdb = create_db();
4004     ok( hdb, "failed to create db\n");
4005
4006     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
4007     r = run_query(hdb, 0, query);
4008     ok(r == ERROR_SUCCESS, "failed to add table\n");
4009
4010     cond = MsiDatabaseIsTablePersistent(hdb, "T");
4011     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
4012
4013     query = "ALTER TABLE `T` HOLD";
4014     r = run_query(hdb, 0, query);
4015     ok(r == ERROR_SUCCESS, "failed to hold table %d\n", r);
4016
4017     query = "ALTER TABLE `T` FREE";
4018     r = run_query(hdb, 0, query);
4019     ok(r == ERROR_SUCCESS, "failed to free table\n");
4020
4021     query = "ALTER TABLE `T` FREE";
4022     r = run_query(hdb, 0, query);
4023     ok(r == ERROR_SUCCESS, "failed to free table\n");
4024
4025     query = "ALTER TABLE `T` FREE";
4026     r = run_query(hdb, 0, query);
4027     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to free table\n");
4028
4029     query = "ALTER TABLE `T` HOLD";
4030     r = run_query(hdb, 0, query);
4031     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to hold table %d\n", r);
4032
4033     /* table T is removed */
4034     query = "SELECT * FROM `T`";
4035     r = run_query(hdb, 0, query);
4036     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4037
4038     /* create the table again */
4039     query = "CREATE TABLE `U` ( `A` INTEGER, `B` INTEGER PRIMARY KEY `B`)";
4040     r = run_query(hdb, 0, query);
4041     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4042
4043     /* up the ref count */
4044     query = "ALTER TABLE `U` HOLD";
4045     r = run_query(hdb, 0, query);
4046     ok(r == ERROR_SUCCESS, "failed to free table\n");
4047
4048     /* add column, no data type */
4049     query = "ALTER TABLE `U` ADD `C`";
4050     r = run_query(hdb, 0, query);
4051     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4052
4053     query = "ALTER TABLE `U` ADD `C` INTEGER";
4054     r = run_query(hdb, 0, query);
4055     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4056
4057     /* add column C again */
4058     query = "ALTER TABLE `U` ADD `C` INTEGER";
4059     r = run_query(hdb, 0, query);
4060     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4061
4062     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY";
4063     r = run_query(hdb, 0, query);
4064     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4065
4066     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 1, 2, 3, 4 )";
4067     r = run_query(hdb, 0, query);
4068     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4069
4070     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY HOLD";
4071     r = run_query(hdb, 0, query);
4072     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4073
4074     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 5, 6, 7, 8 )";
4075     r = run_query(hdb, 0, query);
4076     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4077
4078     query = "SELECT * FROM `U` WHERE `D` = 8";
4079     r = run_query(hdb, 0, query);
4080     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4081
4082     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY FREE";
4083     r = run_query(hdb, 0, query);
4084     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4085
4086     query = "ALTER COLUMN `D` FREE";
4087     r = run_query(hdb, 0, query);
4088     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4089
4090     /* drop the ref count */
4091     query = "ALTER TABLE `U` FREE";
4092     r = run_query(hdb, 0, query);
4093     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4094
4095     /* table is not empty */
4096     query = "SELECT * FROM `U`";
4097     r = run_query(hdb, 0, query);
4098     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4099
4100     /* column D is removed */
4101     query = "SELECT * FROM `U` WHERE `D` = 8";
4102     r = run_query(hdb, 0, query);
4103     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4104
4105     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 9, 10, 11, 12 )";
4106     r = run_query(hdb, 0, query);
4107     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4108
4109     /* add the column again */
4110     query = "ALTER TABLE `U` ADD `E` INTEGER TEMPORARY HOLD";
4111     r = run_query(hdb, 0, query);
4112     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4113
4114     /* up the ref count */
4115     query = "ALTER TABLE `U` HOLD";
4116     r = run_query(hdb, 0, query);
4117     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4118
4119     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 13, 14, 15, 16 )";
4120     r = run_query(hdb, 0, query);
4121     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4122
4123     query = "SELECT * FROM `U` WHERE `E` = 16";
4124     r = run_query(hdb, 0, query);
4125     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4126
4127     /* drop the ref count */
4128     query = "ALTER TABLE `U` FREE";
4129     r = run_query(hdb, 0, query);
4130     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4131
4132     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 17, 18, 19, 20 )";
4133     r = run_query(hdb, 0, query);
4134     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4135
4136     query = "SELECT * FROM `U` WHERE `E` = 20";
4137     r = run_query(hdb, 0, query);
4138     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4139
4140     /* drop the ref count */
4141     query = "ALTER TABLE `U` FREE";
4142     r = run_query(hdb, 0, query);
4143     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4144
4145     /* table still exists */
4146     query = "SELECT * FROM `U`";
4147     r = run_query(hdb, 0, query);
4148     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4149
4150     /* col E is removed */
4151     query = "SELECT * FROM `U` WHERE `E` = 20";
4152     r = run_query(hdb, 0, query);
4153     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4154
4155     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 20, 21, 22, 23 )";
4156     r = run_query(hdb, 0, query);
4157     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4158
4159     /* drop the ref count once more */
4160     query = "ALTER TABLE `U` FREE";
4161     r = run_query(hdb, 0, query);
4162     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4163
4164     /* table still exists */
4165     query = "SELECT * FROM `U`";
4166     r = run_query(hdb, 0, query);
4167     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4168
4169     MsiCloseHandle( hdb );
4170     DeleteFile(msifile);
4171 }
4172
4173 static void test_integers(void)
4174 {
4175     MSIHANDLE hdb = 0, view = 0, rec = 0;
4176     DWORD count, i;
4177     const char *query;
4178     UINT r;
4179
4180     /* just MsiOpenDatabase should not create a file */
4181     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4182     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4183
4184     /* create a table */
4185     query = "CREATE TABLE `integers` ( "
4186             "`one` SHORT, `two` INT, `three` INTEGER, `four` LONG, "
4187             "`five` SHORT NOT NULL, `six` INT NOT NULL, "
4188             "`seven` INTEGER NOT NULL, `eight` LONG NOT NULL "
4189             "PRIMARY KEY `one`)";
4190     r = MsiDatabaseOpenView(hdb, query, &view);
4191     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4192     r = MsiViewExecute(view, 0);
4193     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4194     r = MsiViewClose(view);
4195     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4196     r = MsiCloseHandle(view);
4197     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4198
4199     query = "SELECT * FROM `integers`";
4200     r = MsiDatabaseOpenView(hdb, query, &view);
4201     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4202
4203     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
4204     count = MsiRecordGetFieldCount(rec);
4205     ok(count == 8, "Expected 8, got %d\n", count);
4206     ok(check_record(rec, 1, "one"), "Expected one\n");
4207     ok(check_record(rec, 2, "two"), "Expected two\n");
4208     ok(check_record(rec, 3, "three"), "Expected three\n");
4209     ok(check_record(rec, 4, "four"), "Expected four\n");
4210     ok(check_record(rec, 5, "five"), "Expected five\n");
4211     ok(check_record(rec, 6, "six"), "Expected six\n");
4212     ok(check_record(rec, 7, "seven"), "Expected seven\n");
4213     ok(check_record(rec, 8, "eight"), "Expected eight\n");
4214     MsiCloseHandle(rec);
4215
4216     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
4217     count = MsiRecordGetFieldCount(rec);
4218     ok(count == 8, "Expected 8, got %d\n", count);
4219     ok(check_record(rec, 1, "I2"), "Expected I2\n");
4220     ok(check_record(rec, 2, "I2"), "Expected I2\n");
4221     ok(check_record(rec, 3, "I2"), "Expected I2\n");
4222     ok(check_record(rec, 4, "I4"), "Expected I4\n");
4223     ok(check_record(rec, 5, "i2"), "Expected i2\n");
4224     ok(check_record(rec, 6, "i2"), "Expected i2\n");
4225     ok(check_record(rec, 7, "i2"), "Expected i2\n");
4226     ok(check_record(rec, 8, "i4"), "Expected i4\n");
4227     MsiCloseHandle(rec);
4228
4229     MsiViewClose(view);
4230     MsiCloseHandle(view);
4231
4232     /* insert values into it, NULL where NOT NULL is specified */
4233     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
4234         "VALUES('', '', '', '', '', '', '', '')";
4235     r = MsiDatabaseOpenView(hdb, query, &view);
4236     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4237     r = MsiViewExecute(view, 0);
4238     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
4239
4240     MsiViewClose(view);
4241     MsiCloseHandle(view);
4242
4243     query = "SELECT * FROM `integers`";
4244     r = do_query(hdb, query, &rec);
4245     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4246
4247     r = MsiRecordGetFieldCount(rec);
4248     ok(r == -1, "record count wrong: %d\n", r);
4249
4250     MsiCloseHandle(rec);
4251
4252     /* insert legitimate values into it */
4253     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
4254         "VALUES('', '2', '', '4', '5', '6', '7', '8')";
4255     r = MsiDatabaseOpenView(hdb, query, &view);
4256     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4257     r = MsiViewExecute(view, 0);
4258     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4259
4260     query = "SELECT * FROM `integers`";
4261     r = do_query(hdb, query, &rec);
4262     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4263
4264     r = MsiRecordGetFieldCount(rec);
4265     ok(r == 8, "record count wrong: %d\n", r);
4266
4267     i = MsiRecordGetInteger(rec, 1);
4268     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
4269     i = MsiRecordGetInteger(rec, 3);
4270     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
4271     i = MsiRecordGetInteger(rec, 2);
4272     ok(i == 2, "Expected 2, got %d\n", i);
4273     i = MsiRecordGetInteger(rec, 4);
4274     ok(i == 4, "Expected 4, got %d\n", i);
4275     i = MsiRecordGetInteger(rec, 5);
4276     ok(i == 5, "Expected 5, got %d\n", i);
4277     i = MsiRecordGetInteger(rec, 6);
4278     ok(i == 6, "Expected 6, got %d\n", i);
4279     i = MsiRecordGetInteger(rec, 7);
4280     ok(i == 7, "Expected 7, got %d\n", i);
4281     i = MsiRecordGetInteger(rec, 8);
4282     ok(i == 8, "Expected 8, got %d\n", i);
4283
4284     MsiCloseHandle(rec);
4285     MsiViewClose(view);
4286     MsiCloseHandle(view);
4287
4288     r = MsiDatabaseCommit(hdb);
4289     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
4290
4291     r = MsiCloseHandle(hdb);
4292     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4293
4294     r = DeleteFile(msifile);
4295     ok(r == TRUE, "file didn't exist after commit\n");
4296 }
4297
4298 static void test_update(void)
4299 {
4300     MSIHANDLE hdb = 0, view = 0, rec = 0;
4301     CHAR result[MAX_PATH];
4302     const char *query;
4303     DWORD size;
4304     UINT r;
4305
4306     /* just MsiOpenDatabase should not create a file */
4307     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4308     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4309
4310     /* create the Control table */
4311     query = "CREATE TABLE `Control` ( "
4312         "`Dialog_` CHAR(72) NOT NULL, `Control` CHAR(50) NOT NULL, `Type` SHORT NOT NULL, "
4313         "`X` SHORT NOT NULL, `Y` SHORT NOT NULL, `Width` SHORT NOT NULL, `Height` SHORT NOT NULL,"
4314         "`Attributes` LONG, `Property` CHAR(50), `Text` CHAR(0) LOCALIZABLE, "
4315         "`Control_Next` CHAR(50), `Help` CHAR(50) LOCALIZABLE PRIMARY KEY `Dialog_`, `Control`)";
4316     r = MsiDatabaseOpenView(hdb, query, &view);
4317     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4318     r = MsiViewExecute(view, 0);
4319     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4320     r = MsiViewClose(view);
4321     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4322     r = MsiCloseHandle(view);
4323     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4324
4325     /* add a control */
4326     query = "INSERT INTO `Control` ( "
4327         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4328         "`Property`, `Text`, `Control_Next`, `Help` )"
4329         "VALUES('ErrorDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
4330     r = MsiDatabaseOpenView(hdb, query, &view);
4331     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4332     r = MsiViewExecute(view, 0);
4333     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4334     r = MsiViewClose(view);
4335     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4336     r = MsiCloseHandle(view);
4337     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4338
4339     /* add a second control */
4340     query = "INSERT INTO `Control` ( "
4341         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4342         "`Property`, `Text`, `Control_Next`, `Help` )"
4343         "VALUES('ErrorDialog', 'Button', '1', '5', '5', '5', '5', '', '', '', '')";
4344     r = MsiDatabaseOpenView(hdb, query, &view);
4345     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4346     r = MsiViewExecute(view, 0);
4347     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4348     r = MsiViewClose(view);
4349     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4350     r = MsiCloseHandle(view);
4351     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4352
4353     /* add a third control */
4354     query = "INSERT INTO `Control` ( "
4355         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4356         "`Property`, `Text`, `Control_Next`, `Help` )"
4357         "VALUES('AnotherDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
4358     r = MsiDatabaseOpenView(hdb, query, &view);
4359     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4360     r = MsiViewExecute(view, 0);
4361     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4362     r = MsiViewClose(view);
4363     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4364     r = MsiCloseHandle(view);
4365     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4366
4367     /* bad table */
4368     query = "UPDATE `NotATable` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4369     r = MsiDatabaseOpenView(hdb, query, &view);
4370     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4371
4372     /* bad set column */
4373     query = "UPDATE `Control` SET `NotAColumn` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4374     r = MsiDatabaseOpenView(hdb, query, &view);
4375     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4376
4377     /* bad where condition */
4378     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `NotAColumn` = 'ErrorDialog'";
4379     r = MsiDatabaseOpenView(hdb, query, &view);
4380     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4381
4382     /* just the dialog_ specified */
4383     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4384     r = MsiDatabaseOpenView(hdb, query, &view);
4385     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4386     r = MsiViewExecute(view, 0);
4387     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4388     r = MsiViewClose(view);
4389     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4390     r = MsiCloseHandle(view);
4391     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4392
4393     /* check the modified text */
4394     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
4395     r = MsiDatabaseOpenView(hdb, query, &view);
4396     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4397     r = MsiViewExecute(view, 0);
4398     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4399
4400     r = MsiViewFetch(view, &rec);
4401     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4402
4403     size = MAX_PATH;
4404     r = MsiRecordGetString(rec, 1, result, &size);
4405     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4406     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
4407
4408     MsiCloseHandle(rec);
4409
4410     r = MsiViewFetch(view, &rec);
4411     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4412
4413     size = MAX_PATH;
4414     r = MsiRecordGetString(rec, 1, result, &size);
4415     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4416     ok(!lstrlen(result), "Expected an empty string, got %s\n", result);
4417
4418     MsiCloseHandle(rec);
4419
4420     r = MsiViewFetch(view, &rec);
4421     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4422
4423     r = MsiViewClose(view);
4424     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4425     r = MsiCloseHandle(view);
4426     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4427
4428     /* dialog_ and control specified */
4429     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog' AND `Control` = 'ErrorText'";
4430     r = MsiDatabaseOpenView(hdb, query, &view);
4431     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4432     r = MsiViewExecute(view, 0);
4433     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4434     r = MsiViewClose(view);
4435     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4436     r = MsiCloseHandle(view);
4437     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4438
4439     /* check the modified text */
4440     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
4441     r = MsiDatabaseOpenView(hdb, query, &view);
4442     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4443     r = MsiViewExecute(view, 0);
4444     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4445
4446     r = MsiViewFetch(view, &rec);
4447     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4448
4449     size = MAX_PATH;
4450     r = MsiRecordGetString(rec, 1, result, &size);
4451     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4452     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
4453
4454     MsiCloseHandle(rec);
4455
4456     r = MsiViewFetch(view, &rec);
4457     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4458
4459     size = MAX_PATH;
4460     r = MsiRecordGetString(rec, 1, result, &size);
4461     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4462     ok(!lstrlen(result), "Expected an empty string, got %s\n", result);
4463
4464     MsiCloseHandle(rec);
4465
4466     r = MsiViewFetch(view, &rec);
4467     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4468
4469     r = MsiViewClose(view);
4470     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4471     r = MsiCloseHandle(view);
4472     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4473
4474     /* no where condition */
4475     query = "UPDATE `Control` SET `Text` = 'this is text'";
4476     r = MsiDatabaseOpenView(hdb, query, &view);
4477     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4478     r = MsiViewExecute(view, 0);
4479     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4480     r = MsiViewClose(view);
4481     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4482     r = MsiCloseHandle(view);
4483     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4484
4485     /* check the modified text */
4486     query = "SELECT `Text` FROM `Control`";
4487     r = MsiDatabaseOpenView(hdb, query, &view);
4488     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4489     r = MsiViewExecute(view, 0);
4490     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4491
4492     r = MsiViewFetch(view, &rec);
4493     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4494
4495     size = MAX_PATH;
4496     r = MsiRecordGetString(rec, 1, result, &size);
4497     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4498     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
4499
4500     MsiCloseHandle(rec);
4501
4502     r = MsiViewFetch(view, &rec);
4503     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4504
4505     size = MAX_PATH;
4506     r = MsiRecordGetString(rec, 1, result, &size);
4507     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4508     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
4509
4510     MsiCloseHandle(rec);
4511
4512     r = MsiViewFetch(view, &rec);
4513     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4514
4515     size = MAX_PATH;
4516     r = MsiRecordGetString(rec, 1, result, &size);
4517     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4518     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
4519
4520     MsiCloseHandle(rec);
4521
4522     r = MsiViewFetch(view, &rec);
4523     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4524
4525     r = MsiViewClose(view);
4526     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4527     r = MsiCloseHandle(view);
4528     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4529
4530     query = "CREATE TABLE `Apple` ( `Banana` CHAR(72) NOT NULL, "
4531         "`Orange` CHAR(72),  `Pear` INT PRIMARY KEY `Banana`)";
4532     r = run_query(hdb, 0, query);
4533     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4534
4535     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4536         "VALUES('one', 'two', 3)";
4537     r = run_query(hdb, 0, query);
4538     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4539
4540     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4541         "VALUES('three', 'four', 5)";
4542     r = run_query(hdb, 0, query);
4543     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4544
4545     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4546         "VALUES('six', 'two', 7)";
4547     r = run_query(hdb, 0, query);
4548     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4549
4550     rec = MsiCreateRecord(2);
4551     MsiRecordSetInteger(rec, 1, 8);
4552     MsiRecordSetString(rec, 2, "two");
4553
4554     query = "UPDATE `Apple` SET `Pear` = ? WHERE `Orange` = ?";
4555     r = run_query(hdb, rec, query);
4556     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4557
4558     MsiCloseHandle(rec);
4559
4560     query = "SELECT `Pear` FROM `Apple` ORDER BY `Orange`";
4561     r = MsiDatabaseOpenView(hdb, query, &view);
4562     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4563     r = MsiViewExecute(view, 0);
4564     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4565
4566     r = MsiViewFetch(view, &rec);
4567     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4568
4569     r = MsiRecordGetInteger(rec, 1);
4570     ok(r == 8, "Expected 8, got %d\n", r);
4571
4572     MsiCloseHandle(rec);
4573
4574     r = MsiViewFetch(view, &rec);
4575     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4576
4577     r = MsiRecordGetInteger(rec, 1);
4578     ok(r == 8, "Expected 8, got %d\n", r);
4579
4580     MsiCloseHandle(rec);
4581
4582     r = MsiViewFetch(view, &rec);
4583     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4584
4585     r = MsiRecordGetInteger(rec, 1);
4586     ok(r == 5, "Expected 5, got %d\n", r);
4587
4588     MsiCloseHandle(rec);
4589
4590     r = MsiViewFetch(view, &rec);
4591     ok(r == ERROR_NO_MORE_ITEMS, "Expectd ERROR_NO_MORE_ITEMS, got %d\n", r);
4592
4593     MsiViewClose(view);
4594     MsiCloseHandle(view);
4595
4596     r = MsiDatabaseCommit(hdb);
4597     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
4598     r = MsiCloseHandle(hdb);
4599     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4600
4601     DeleteFile(msifile);
4602 }
4603
4604 static void test_special_tables(void)
4605 {
4606     const char *query;
4607     MSIHANDLE hdb = 0;
4608     UINT r;
4609
4610     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4611     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4612
4613     query = "CREATE TABLE `_Properties` ( "
4614         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4615     r = run_query(hdb, 0, query);
4616     ok(r == ERROR_SUCCESS, "failed to create table\n");
4617
4618     query = "CREATE TABLE `_Storages` ( "
4619         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4620     r = run_query(hdb, 0, query);
4621     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
4622
4623     query = "CREATE TABLE `_Streams` ( "
4624         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4625     r = run_query(hdb, 0, query);
4626     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
4627
4628     query = "CREATE TABLE `_Tables` ( "
4629         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4630     r = run_query(hdb, 0, query);
4631     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Tables table\n");
4632
4633     query = "CREATE TABLE `_Columns` ( "
4634         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4635     r = run_query(hdb, 0, query);
4636     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Columns table\n");
4637
4638     r = MsiCloseHandle(hdb);
4639     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4640 }
4641
4642 static void test_tables_order(void)
4643 {
4644     const char *query;
4645     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4646     UINT r;
4647     char buffer[100];
4648     DWORD sz;
4649
4650     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4651     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4652
4653     query = "CREATE TABLE `foo` ( "
4654         "`baz` INT NOT NULL PRIMARY KEY `baz`)";
4655     r = run_query(hdb, 0, query);
4656     ok(r == ERROR_SUCCESS, "failed to create table\n");
4657
4658     query = "CREATE TABLE `bar` ( "
4659         "`foo` INT NOT NULL PRIMARY KEY `foo`)";
4660     r = run_query(hdb, 0, query);
4661     ok(r == ERROR_SUCCESS, "failed to create table\n");
4662
4663     query = "CREATE TABLE `baz` ( "
4664         "`bar` INT NOT NULL, "
4665         "`baz` INT NOT NULL, "
4666         "`foo` INT NOT NULL PRIMARY KEY `bar`)";
4667     r = run_query(hdb, 0, query);
4668     ok(r == ERROR_SUCCESS, "failed to create table\n");
4669
4670     /* The names of the tables in the _Tables table must
4671        be in the same order as these names are created in
4672        the strings table. */
4673     query = "SELECT * FROM `_Tables`";
4674     r = MsiDatabaseOpenView(hdb, query, &hview);
4675     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4676     r = MsiViewExecute(hview, 0);
4677     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4678
4679     r = MsiViewFetch(hview, &hrec);
4680     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4681     sz = sizeof(buffer);
4682     r = MsiRecordGetString(hrec, 1, buffer, &sz);
4683     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4684     ok(!lstrcmp(buffer, "foo"), "Expected foo, got %s\n", buffer);
4685     r = MsiCloseHandle(hrec);
4686     ok(r == ERROR_SUCCESS, "failed to close record\n");
4687
4688     r = MsiViewFetch(hview, &hrec);
4689     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4690     sz = sizeof(buffer);
4691     r = MsiRecordGetString(hrec, 1, buffer, &sz);
4692     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4693     ok(!lstrcmp(buffer, "baz"), "Expected baz, got %s\n", buffer);
4694     r = MsiCloseHandle(hrec);
4695     ok(r == ERROR_SUCCESS, "failed to close record\n");
4696
4697     r = MsiViewFetch(hview, &hrec);
4698     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4699     sz = sizeof(buffer);
4700     r = MsiRecordGetString(hrec, 1, buffer, &sz);
4701     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4702     ok(!lstrcmp(buffer, "bar"), "Expected bar, got %s\n", buffer);
4703     r = MsiCloseHandle(hrec);
4704     ok(r == ERROR_SUCCESS, "failed to close record\n");
4705
4706     r = MsiViewClose(hview);
4707     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4708     r = MsiCloseHandle(hview);
4709     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4710
4711     /* The names of the tables in the _Columns table must
4712        be in the same order as these names are created in
4713        the strings table. */
4714     query = "SELECT * FROM `_Columns`";
4715     r = MsiDatabaseOpenView(hdb, query, &hview);
4716     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4717     r = MsiViewExecute(hview, 0);
4718     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4719
4720     r = MsiViewFetch(hview, &hrec);
4721     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4722     sz = sizeof(buffer);
4723     r = MsiRecordGetString(hrec, 1, buffer, &sz);
4724     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4725     ok(!lstrcmp(buffer, "foo"), "Expected foo, got %s\n", buffer);
4726     sz = sizeof(buffer);
4727     r = MsiRecordGetString(hrec, 3, buffer, &sz);
4728     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4729     ok(!lstrcmp(buffer, "baz"), "Expected baz, got %s\n", buffer);
4730     r = MsiCloseHandle(hrec);
4731     ok(r == ERROR_SUCCESS, "failed to close record\n");
4732
4733     r = MsiViewFetch(hview, &hrec);
4734     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4735     sz = sizeof(buffer);
4736     r = MsiRecordGetString(hrec, 1, buffer, &sz);
4737     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4738     ok(!lstrcmp(buffer, "baz"), "Expected baz, got %s\n", buffer);
4739     sz = sizeof(buffer);
4740     r = MsiRecordGetString(hrec, 3, buffer, &sz);
4741     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4742     ok(!lstrcmp(buffer, "bar"), "Expected bar, got %s\n", buffer);
4743     r = MsiCloseHandle(hrec);
4744     ok(r == ERROR_SUCCESS, "failed to close record\n");
4745
4746     r = MsiViewFetch(hview, &hrec);
4747     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4748     sz = sizeof(buffer);
4749     r = MsiRecordGetString(hrec, 1, buffer, &sz);
4750     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4751     ok(!lstrcmp(buffer, "baz"), "Expected baz, got %s\n", buffer);
4752     sz = sizeof(buffer);
4753     r = MsiRecordGetString(hrec, 3, buffer, &sz);
4754     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4755     ok(!lstrcmp(buffer, "baz"), "Expected baz, got %s\n", buffer);
4756     r = MsiCloseHandle(hrec);
4757     ok(r == ERROR_SUCCESS, "failed to close record\n");
4758
4759     r = MsiViewFetch(hview, &hrec);
4760     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4761     sz = sizeof(buffer);
4762     r = MsiRecordGetString(hrec, 1, buffer, &sz);
4763     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4764     ok(!lstrcmp(buffer, "baz"), "Expected baz, got %s\n", buffer);
4765     sz = sizeof(buffer);
4766     r = MsiRecordGetString(hrec, 3, buffer, &sz);
4767     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4768     ok(!lstrcmp(buffer, "foo"), "Expected foo, got %s\n", buffer);
4769     r = MsiCloseHandle(hrec);
4770     ok(r == ERROR_SUCCESS, "failed to close record\n");
4771
4772     r = MsiViewFetch(hview, &hrec);
4773     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4774     sz = sizeof(buffer);
4775     r = MsiRecordGetString(hrec, 1, buffer, &sz);
4776     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4777     ok(!lstrcmp(buffer, "bar"), "Expected bar, got %s\n", buffer);
4778     sz = sizeof(buffer);
4779     r = MsiRecordGetString(hrec, 3, buffer, &sz);
4780     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4781     ok(!lstrcmp(buffer, "foo"), "Expected foo, got %s\n", buffer);
4782     r = MsiCloseHandle(hrec);
4783     ok(r == ERROR_SUCCESS, "failed to close record\n");
4784
4785     r = MsiViewClose(hview);
4786     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4787     r = MsiCloseHandle(hview);
4788     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4789
4790     r = MsiCloseHandle(hdb);
4791     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4792
4793     DeleteFile(msifile);
4794 }
4795
4796 static void test_rows_order(void)
4797 {
4798     const char *query;
4799     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4800     UINT r;
4801     char buffer[100];
4802     DWORD sz;
4803
4804     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4805     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4806
4807     query = "CREATE TABLE `foo` ( "
4808         "`bar` LONGCHAR NOT NULL PRIMARY KEY `bar`)";
4809     r = run_query(hdb, 0, query);
4810     ok(r == ERROR_SUCCESS, "failed to create table\n");
4811
4812     r = run_query(hdb, 0, "INSERT INTO `foo` "
4813             "( `bar` ) VALUES ( 'A' )");
4814     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4815
4816     r = run_query(hdb, 0, "INSERT INTO `foo` "
4817             "( `bar` ) VALUES ( 'B' )");
4818     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4819
4820     r = run_query(hdb, 0, "INSERT INTO `foo` "
4821             "( `bar` ) VALUES ( 'C' )");
4822     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4823
4824     r = run_query(hdb, 0, "INSERT INTO `foo` "
4825             "( `bar` ) VALUES ( 'D' )");
4826     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4827
4828     r = run_query(hdb, 0, "INSERT INTO `foo` "
4829             "( `bar` ) VALUES ( 'E' )");
4830     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4831
4832     r = run_query(hdb, 0, "INSERT INTO `foo` "
4833             "( `bar` ) VALUES ( 'F' )");
4834     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4835
4836     query = "CREATE TABLE `bar` ( "
4837         "`foo` LONGCHAR NOT NULL, "
4838         "`baz` LONGCHAR NOT NULL "
4839         "PRIMARY KEY `foo` )";
4840     r = run_query(hdb, 0, query);
4841     ok(r == ERROR_SUCCESS, "failed to create table\n");
4842
4843     r = run_query(hdb, 0, "INSERT INTO `bar` "
4844             "( `foo`, `baz` ) VALUES ( 'C', 'E' )");
4845     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4846
4847     r = run_query(hdb, 0, "INSERT INTO `bar` "
4848             "( `foo`, `baz` ) VALUES ( 'F', 'A' )");
4849     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4850
4851     r = run_query(hdb, 0, "INSERT INTO `bar` "
4852             "( `foo`, `baz` ) VALUES ( 'A', 'B' )");
4853     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4854
4855     r = run_query(hdb, 0, "INSERT INTO `bar` "
4856             "( `foo`, `baz` ) VALUES ( 'D', 'E' )");
4857     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4858
4859     /* The rows of the table must be ordered by the column values of
4860        each row. For strings, the column value is the string id
4861        in the string table.  */
4862
4863     query = "SELECT * FROM `bar`";
4864     r = MsiDatabaseOpenView(hdb, query, &hview);
4865     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4866     r = MsiViewExecute(hview, 0);
4867     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4868
4869     r = MsiViewFetch(hview, &hrec);
4870     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4871     sz = sizeof(buffer);
4872     r = MsiRecordGetString(hrec, 1, buffer, &sz);
4873     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4874     ok(!lstrcmp(buffer, "A"), "Expected A, got %s\n", buffer);
4875     sz = sizeof(buffer);
4876     r = MsiRecordGetString(hrec, 2, buffer, &sz);
4877     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4878     ok(!lstrcmp(buffer, "B"), "Expected B, got %s\n", buffer);
4879     r = MsiCloseHandle(hrec);
4880     ok(r == ERROR_SUCCESS, "failed to close record\n");
4881
4882     r = MsiViewFetch(hview, &hrec);
4883     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4884     sz = sizeof(buffer);
4885     r = MsiRecordGetString(hrec, 1, buffer, &sz);
4886     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4887     ok(!lstrcmp(buffer, "C"), "Expected E, got %s\n", buffer);
4888     sz = sizeof(buffer);
4889     r = MsiRecordGetString(hrec, 2, buffer, &sz);
4890     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4891     ok(!lstrcmp(buffer, "E"), "Expected E, got %s\n", buffer);
4892     r = MsiCloseHandle(hrec);
4893     ok(r == ERROR_SUCCESS, "failed to close record\n");
4894
4895     r = MsiViewFetch(hview, &hrec);
4896     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4897     sz = sizeof(buffer);
4898     r = MsiRecordGetString(hrec, 1, buffer, &sz);
4899     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4900     ok(!lstrcmp(buffer, "D"), "Expected D, got %s\n", buffer);
4901     sz = sizeof(buffer);
4902     r = MsiRecordGetString(hrec, 2, buffer, &sz);
4903     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4904     ok(!lstrcmp(buffer, "E"), "Expected E, got %s\n", buffer);
4905     r = MsiCloseHandle(hrec);
4906     ok(r == ERROR_SUCCESS, "failed to close record\n");
4907
4908     r = MsiViewFetch(hview, &hrec);
4909     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4910     sz = sizeof(buffer);
4911     r = MsiRecordGetString(hrec, 1, buffer, &sz);
4912     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4913     ok(!lstrcmp(buffer, "F"), "Expected F, got %s\n", buffer);
4914     sz = sizeof(buffer);
4915     r = MsiRecordGetString(hrec, 2, buffer, &sz);
4916     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4917     ok(!lstrcmp(buffer, "A"), "Expected A, got %s\n", buffer);
4918     r = MsiCloseHandle(hrec);
4919     ok(r == ERROR_SUCCESS, "failed to close record\n");
4920
4921     r = MsiViewClose(hview);
4922     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4923     r = MsiCloseHandle(hview);
4924     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4925
4926     r = MsiCloseHandle(hdb);
4927     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4928
4929     DeleteFile(msifile);
4930 }
4931
4932 static void test_select_markers(void)
4933 {
4934     MSIHANDLE hdb = 0, rec, view, res;
4935     LPCSTR query;
4936     UINT r;
4937     DWORD size;
4938     CHAR buf[MAX_PATH];
4939
4940     hdb = create_db();
4941     ok( hdb, "failed to create db\n");
4942
4943     r = run_query(hdb, 0,
4944             "CREATE TABLE `Table` (`One` CHAR(72), `Two` CHAR(72), `Three` SHORT PRIMARY KEY `One`, `Two`, `Three`)");
4945     ok(r == S_OK, "cannot create table: %d\n", r);
4946
4947     r = run_query(hdb, 0, "INSERT INTO `Table` "
4948             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'one', 1 )");
4949     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
4950
4951     r = run_query(hdb, 0, "INSERT INTO `Table` "
4952             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 1 )");
4953     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
4954
4955     r = run_query(hdb, 0, "INSERT INTO `Table` "
4956             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 2 )");
4957     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
4958
4959     r = run_query(hdb, 0, "INSERT INTO `Table` "
4960             "( `One`, `Two`, `Three` ) VALUES ( 'banana', 'three', 3 )");
4961     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
4962
4963     rec = MsiCreateRecord(2);
4964     MsiRecordSetString(rec, 1, "apple");
4965     MsiRecordSetString(rec, 2, "two");
4966
4967     query = "SELECT * FROM `Table` WHERE `One`=? AND `Two`=? ORDER BY `Three`";
4968     r = MsiDatabaseOpenView(hdb, query, &view);
4969     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4970
4971     r = MsiViewExecute(view, rec);
4972     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4973
4974     r = MsiViewFetch(view, &res);
4975     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4976
4977     size = MAX_PATH;
4978     r = MsiRecordGetString(res, 1, buf, &size);
4979     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4980     ok(!lstrcmp(buf, "apple"), "Expected apple, got %s\n", buf);
4981
4982     size = MAX_PATH;
4983     r = MsiRecordGetString(res, 2, buf, &size);
4984     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4985     ok(!lstrcmp(buf, "two"), "Expected two, got %s\n", buf);
4986
4987     r = MsiRecordGetInteger(res, 3);
4988     ok(r == 1, "Expected 1, got %d\n", r);
4989
4990     MsiCloseHandle(res);
4991
4992     r = MsiViewFetch(view, &res);
4993     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4994
4995     size = MAX_PATH;
4996     r = MsiRecordGetString(res, 1, buf, &size);
4997     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4998     ok(!lstrcmp(buf, "apple"), "Expected apple, got %s\n", buf);
4999
5000     size = MAX_PATH;
5001     r = MsiRecordGetString(res, 2, buf, &size);
5002     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5003     ok(!lstrcmp(buf, "two"), "Expected two, got %s\n", buf);
5004
5005     r = MsiRecordGetInteger(res, 3);
5006     ok(r == 2, "Expected 2, got %d\n", r);
5007
5008     MsiCloseHandle(res);
5009
5010     r = MsiViewFetch(view, &res);
5011     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5012
5013     MsiCloseHandle(rec);
5014     MsiViewClose(view);
5015     MsiCloseHandle(view);
5016
5017     rec = MsiCreateRecord(2);
5018     MsiRecordSetString(rec, 1, "one");
5019     MsiRecordSetInteger(rec, 2, 1);
5020
5021     query = "SELECT * FROM `Table` WHERE `Two`<>? AND `Three`>? ORDER BY `Three`";
5022     r = MsiDatabaseOpenView(hdb, query, &view);
5023     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5024     r = MsiViewExecute(view, rec);
5025     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5026
5027     r = MsiViewFetch(view, &res);
5028     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5029
5030     size = MAX_PATH;
5031     r = MsiRecordGetString(res, 1, buf, &size);
5032     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5033     ok(!lstrcmp(buf, "apple"), "Expected apple, got %s\n", buf);
5034
5035     size = MAX_PATH;
5036     r = MsiRecordGetString(res, 2, buf, &size);
5037     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5038     ok(!lstrcmp(buf, "two"), "Expected two, got %s\n", buf);
5039
5040     r = MsiRecordGetInteger(res, 3);
5041     ok(r == 2, "Expected 2, got %d\n", r);
5042
5043     MsiCloseHandle(res);
5044
5045     r = MsiViewFetch(view, &res);
5046     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5047
5048     size = MAX_PATH;
5049     r = MsiRecordGetString(res, 1, buf, &size);
5050     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5051     ok(!lstrcmp(buf, "banana"), "Expected banana, got %s\n", buf);
5052
5053     size = MAX_PATH;
5054     r = MsiRecordGetString(res, 2, buf, &size);
5055     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5056     ok(!lstrcmp(buf, "three"), "Expected three, got %s\n", buf);
5057
5058     r = MsiRecordGetInteger(res, 3);
5059     ok(r == 3, "Expected 3, got %d\n", r);
5060
5061     MsiCloseHandle(res);
5062
5063     r = MsiViewFetch(view, &res);
5064     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5065
5066     MsiCloseHandle(rec);
5067     MsiViewClose(view);
5068     MsiCloseHandle(view);
5069     MsiCloseHandle(hdb);
5070     DeleteFile(msifile);
5071 }
5072
5073 static void test_viewmodify_update(void)
5074 {
5075     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5076     const char *query;
5077     UINT r;
5078
5079     DeleteFile(msifile);
5080
5081     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5082     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5083
5084     query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
5085     r = run_query( hdb, 0, query );
5086     ok(r == ERROR_SUCCESS, "query failed\n");
5087
5088     query = "INSERT INTO `table` (`A`, `B`) VALUES (1, 2)";
5089     r = run_query( hdb, 0, query );
5090     ok(r == ERROR_SUCCESS, "query failed\n");
5091
5092     query = "INSERT INTO `table` (`A`, `B`) VALUES (3, 4)";
5093     r = run_query( hdb, 0, query );
5094     ok(r == ERROR_SUCCESS, "query failed\n");
5095
5096     query = "INSERT INTO `table` (`A`, `B`) VALUES (5, 6)";
5097     r = run_query( hdb, 0, query );
5098     ok(r == ERROR_SUCCESS, "query failed\n");
5099
5100     query = "SELECT `B` FROM `table`";
5101     r = MsiDatabaseOpenView(hdb, query, &hview);
5102     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5103     r = MsiViewExecute(hview, 0);
5104     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5105     r = MsiViewFetch(hview, &hrec);
5106     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5107
5108     r = MsiRecordSetInteger(hrec, 1, 0);
5109     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5110
5111     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
5112     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5113
5114     r = MsiCloseHandle(hrec);
5115     ok(r == ERROR_SUCCESS, "failed to close record\n");
5116
5117     r = MsiViewClose(hview);
5118     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5119     r = MsiCloseHandle(hview);
5120     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5121
5122     query = "SELECT * FROM `table`";
5123     r = MsiDatabaseOpenView(hdb, query, &hview);
5124     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5125     r = MsiViewExecute(hview, 0);
5126     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5127     r = MsiViewFetch(hview, &hrec);
5128     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5129
5130     r = MsiRecordGetInteger(hrec, 1);
5131     ok(r == 1, "Expected 1, got %d\n", r);
5132     r = MsiRecordGetInteger(hrec, 2);
5133     ok(r == 0, "Expected 0, got %d\n", r);
5134
5135     r = MsiCloseHandle(hrec);
5136     ok(r == ERROR_SUCCESS, "failed to close record\n");
5137
5138     r = MsiViewFetch(hview, &hrec);
5139     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5140
5141     r = MsiRecordGetInteger(hrec, 1);
5142     ok(r == 3, "Expected 3, got %d\n", r);
5143     r = MsiRecordGetInteger(hrec, 2);
5144     ok(r == 4, "Expected 4, got %d\n", r);
5145
5146     r = MsiCloseHandle(hrec);
5147     ok(r == ERROR_SUCCESS, "failed to close record\n");
5148
5149     r = MsiViewFetch(hview, &hrec);
5150     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5151
5152     r = MsiRecordGetInteger(hrec, 1);
5153     ok(r == 5, "Expected 5, got %d\n", r);
5154     r = MsiRecordGetInteger(hrec, 2);
5155     ok(r == 6, "Expected 6, got %d\n", r);
5156
5157     r = MsiCloseHandle(hrec);
5158     ok(r == ERROR_SUCCESS, "failed to close record\n");
5159
5160     r = MsiViewFetch(hview, &hrec);
5161     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5162
5163     r = MsiViewClose(hview);
5164     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5165     r = MsiCloseHandle(hview);
5166     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5167
5168     /* loop through all elements */
5169     query = "SELECT `B` FROM `table`";
5170     r = MsiDatabaseOpenView(hdb, query, &hview);
5171     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5172     r = MsiViewExecute(hview, 0);
5173     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5174
5175     while (TRUE)
5176     {
5177         r = MsiViewFetch(hview, &hrec);
5178         if (r != ERROR_SUCCESS)
5179             break;
5180
5181         r = MsiRecordSetInteger(hrec, 1, 0);
5182         ok(r == ERROR_SUCCESS, "failed to set integer\n");
5183
5184         r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
5185         ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5186
5187         r = MsiCloseHandle(hrec);
5188         ok(r == ERROR_SUCCESS, "failed to close record\n");
5189     }
5190
5191     r = MsiViewClose(hview);
5192     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5193     r = MsiCloseHandle(hview);
5194     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5195
5196     query = "SELECT * FROM `table`";
5197     r = MsiDatabaseOpenView(hdb, query, &hview);
5198     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5199     r = MsiViewExecute(hview, 0);
5200     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5201     r = MsiViewFetch(hview, &hrec);
5202     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5203
5204     r = MsiRecordGetInteger(hrec, 1);
5205     ok(r == 1, "Expected 1, got %d\n", r);
5206     r = MsiRecordGetInteger(hrec, 2);
5207     ok(r == 0, "Expected 0, got %d\n", r);
5208
5209     r = MsiCloseHandle(hrec);
5210     ok(r == ERROR_SUCCESS, "failed to close record\n");
5211
5212     r = MsiViewFetch(hview, &hrec);
5213     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5214
5215     r = MsiRecordGetInteger(hrec, 1);
5216     ok(r == 3, "Expected 3, got %d\n", r);
5217     r = MsiRecordGetInteger(hrec, 2);
5218     ok(r == 0, "Expected 0, got %d\n", r);
5219
5220     r = MsiCloseHandle(hrec);
5221     ok(r == ERROR_SUCCESS, "failed to close record\n");
5222
5223     r = MsiViewFetch(hview, &hrec);
5224     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5225
5226     r = MsiRecordGetInteger(hrec, 1);
5227     ok(r == 5, "Expected 5, got %d\n", r);
5228     r = MsiRecordGetInteger(hrec, 2);
5229     ok(r == 0, "Expected 0, got %d\n", r);
5230
5231     r = MsiCloseHandle(hrec);
5232     ok(r == ERROR_SUCCESS, "failed to close record\n");
5233
5234     r = MsiViewFetch(hview, &hrec);
5235     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5236
5237     r = MsiViewClose(hview);
5238     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5239     r = MsiCloseHandle(hview);
5240     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5241
5242     r = MsiCloseHandle( hdb );
5243     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
5244 }
5245
5246 static void test_viewmodify_assign(void)
5247 {
5248     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5249     const char *query;
5250     UINT r;
5251
5252     /* setup database */
5253     DeleteFile(msifile);
5254
5255     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5256     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5257
5258     query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
5259     r = run_query( hdb, 0, query );
5260     ok(r == ERROR_SUCCESS, "query failed\n");
5261
5262     /* assign to view, new primary key */
5263     query = "SELECT * FROM `table`";
5264     r = MsiDatabaseOpenView(hdb, query, &hview);
5265     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5266     r = MsiViewExecute(hview, 0);
5267     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5268
5269     hrec = MsiCreateRecord(2);
5270     ok(hrec != 0, "MsiCreateRecord failed\n");
5271
5272     r = MsiRecordSetInteger(hrec, 1, 1);
5273     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5274     r = MsiRecordSetInteger(hrec, 2, 2);
5275     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5276
5277     r = MsiViewModify(hview, MSIMODIFY_ASSIGN, hrec);
5278     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5279
5280     r = MsiCloseHandle(hrec);
5281     ok(r == ERROR_SUCCESS, "failed to close record\n");
5282
5283     r = MsiViewClose(hview);
5284     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5285     r = MsiCloseHandle(hview);
5286     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5287
5288     query = "SELECT * FROM `table`";
5289     r = MsiDatabaseOpenView(hdb, query, &hview);
5290     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5291     r = MsiViewExecute(hview, 0);
5292     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5293     r = MsiViewFetch(hview, &hrec);
5294     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5295
5296     r = MsiRecordGetInteger(hrec, 1);
5297     ok(r == 1, "Expected 1, got %d\n", r);
5298     r = MsiRecordGetInteger(hrec, 2);
5299     ok(r == 2, "Expected 2, got %d\n", r);
5300
5301     r = MsiCloseHandle(hrec);
5302     ok(r == ERROR_SUCCESS, "failed to close record\n");
5303
5304     r = MsiViewFetch(hview, &hrec);
5305     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5306
5307     r = MsiViewClose(hview);
5308     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5309     r = MsiCloseHandle(hview);
5310     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5311
5312     /* assign to view, primary key matches */
5313     query = "SELECT * FROM `table`";
5314     r = MsiDatabaseOpenView(hdb, query, &hview);
5315     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5316     r = MsiViewExecute(hview, 0);
5317     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5318
5319     hrec = MsiCreateRecord(2);
5320     ok(hrec != 0, "MsiCreateRecord failed\n");
5321
5322     r = MsiRecordSetInteger(hrec, 1, 1);
5323     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5324     r = MsiRecordSetInteger(hrec, 2, 4);
5325     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5326
5327     r = MsiViewModify(hview, MSIMODIFY_ASSIGN, hrec);
5328     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5329
5330     r = MsiCloseHandle(hrec);
5331     ok(r == ERROR_SUCCESS, "failed to close record\n");
5332
5333     r = MsiViewClose(hview);
5334     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5335     r = MsiCloseHandle(hview);
5336     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5337
5338     query = "SELECT * FROM `table`";
5339     r = MsiDatabaseOpenView(hdb, query, &hview);
5340     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5341     r = MsiViewExecute(hview, 0);
5342     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5343     r = MsiViewFetch(hview, &hrec);
5344     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5345
5346     r = MsiRecordGetInteger(hrec, 1);
5347     ok(r == 1, "Expected 1, got %d\n", r);
5348     r = MsiRecordGetInteger(hrec, 2);
5349     ok(r == 4, "Expected 4, got %d\n", r);
5350
5351     r = MsiCloseHandle(hrec);
5352     ok(r == ERROR_SUCCESS, "failed to close record\n");
5353
5354     r = MsiViewFetch(hview, &hrec);
5355     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5356
5357     r = MsiViewClose(hview);
5358     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5359     r = MsiCloseHandle(hview);
5360     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5361
5362     /* close database */
5363     r = MsiCloseHandle( hdb );
5364     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
5365 }
5366
5367 static const WCHAR data10[] = { /* MOO */
5368     0x8001, 0x000b,
5369 };
5370 static const WCHAR data11[] = { /* AAR */
5371     0x8002, 0x8005,
5372     0x000c, 0x000f,
5373 };
5374 static const char data12[] = /* _StringData */
5375     "MOOABAARCDonetwofourfive";
5376 static const WCHAR data13[] = { /* _StringPool */
5377 /*  len, refs */
5378     0,   0,    /* string 0 ''     */
5379     0,   0,    /* string 1 ''     */
5380     0,   0,    /* string 2 ''     */
5381     0,   0,    /* string 3 ''     */
5382     0,   0,    /* string 4 ''     */
5383     3,   3,    /* string 5 'MOO'  */
5384     1,   1,    /* string 6 'A'    */
5385     1,   1,    /* string 7 'B'    */
5386     3,   3,    /* string 8 'AAR'  */
5387     1,   1,    /* string 9 'C'    */
5388     1,   1,    /* string a 'D'    */
5389     3,   1,    /* string b 'one'  */
5390     3,   1,    /* string c 'two'  */
5391     0,   0,    /* string d ''     */
5392     4,   1,    /* string e 'four' */
5393     4,   1,    /* string f 'five' */
5394 };
5395
5396 static void test_stringtable(void)
5397 {
5398     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5399     IStorage *stg = NULL;
5400     IStream *stm;
5401     WCHAR name[0x20];
5402     HRESULT hr;
5403     const char *query;
5404     char buffer[MAX_PATH];
5405     WCHAR data[MAX_PATH];
5406     DWORD sz, read;
5407     UINT r;
5408
5409     static const DWORD mode = STGM_DIRECT | STGM_READ | STGM_SHARE_DENY_WRITE;
5410     static const WCHAR stringdata[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0}; /* _StringData */
5411     static const WCHAR stringpool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0}; /* _StringPool */
5412     static const WCHAR moo[] = {0x4840, 0x3e16, 0x4818, 0}; /* MOO */
5413     static const WCHAR aar[] = {0x4840, 0x3a8a, 0x481b, 0}; /* AAR */
5414
5415     DeleteFile(msifile);
5416
5417     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5418     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5419
5420     query = "CREATE TABLE `MOO` (`A` INT, `B` CHAR(72) PRIMARY KEY `A`)";
5421     r = run_query(hdb, 0, query);
5422     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5423
5424     query = "CREATE TABLE `AAR` (`C` INT, `D` CHAR(72) PRIMARY KEY `C`)";
5425     r = run_query(hdb, 0, query);
5426     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5427
5428     /* insert persistent row */
5429     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (1, 'one')";
5430     r = run_query(hdb, 0, query);
5431     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5432
5433     /* insert persistent row */
5434     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (2, 'two')";
5435     r = run_query(hdb, 0, query);
5436     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5437
5438     /* open a view */
5439     query = "SELECT * FROM `MOO`";
5440     r = MsiDatabaseOpenView(hdb, query, &hview);
5441     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5442     r = MsiViewExecute(hview, 0);
5443     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5444
5445     hrec = MsiCreateRecord(2);
5446
5447     r = MsiRecordSetInteger(hrec, 1, 3);
5448     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5449     r = MsiRecordSetString(hrec, 2, "three");
5450     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5451
5452     /* insert a nonpersistent row */
5453     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
5454     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5455
5456     r = MsiCloseHandle(hrec);
5457     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5458     r = MsiViewClose(hview);
5459     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5460     r = MsiCloseHandle(hview);
5461     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5462
5463     /* insert persistent row */
5464     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (4, 'four')";
5465     r = run_query(hdb, 0, query);
5466     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5467
5468     /* insert persistent row */
5469     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (5, 'five')";
5470     r = run_query(hdb, 0, query);
5471     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5472
5473     r = MsiDatabaseCommit(hdb);
5474     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5475
5476     r = MsiCloseHandle(hdb);
5477     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5478
5479     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb);
5480     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5481
5482     query = "SELECT * FROM `MOO`";
5483     r = MsiDatabaseOpenView(hdb, query, &hview);
5484     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5485
5486     r = MsiViewExecute(hview, 0);
5487     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5488
5489     r = MsiViewFetch(hview, &hrec);
5490     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5491
5492     r = MsiRecordGetFieldCount(hrec);
5493     ok(r == 2, "Expected 2, got %d\n", r);
5494
5495     r = MsiRecordGetInteger(hrec, 1);
5496     ok(r == 1, "Expected 1, got %d\n", r);
5497
5498     sz = sizeof(buffer);
5499     r = MsiRecordGetString(hrec, 2, buffer, &sz);
5500     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5501     ok(!lstrcmp(buffer, "one"), "Expected one, got %s\n", buffer);
5502
5503     r = MsiCloseHandle(hrec);
5504     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5505
5506     r = MsiViewFetch(hview, &hrec);
5507     todo_wine
5508     {
5509         ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5510     }
5511
5512     r = MsiViewClose(hview);
5513     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5514     r = MsiCloseHandle(hview);
5515     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5516     r = MsiCloseHandle(hrec);
5517     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5518
5519     query = "SELECT * FROM `AAR`";
5520     r = MsiDatabaseOpenView(hdb, query, &hview);
5521     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5522
5523     r = MsiViewExecute(hview, 0);
5524     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5525
5526     r = MsiViewFetch(hview, &hrec);
5527     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5528
5529     r = MsiRecordGetFieldCount(hrec);
5530     ok(r == 2, "Expected 2, got %d\n", r);
5531
5532     r = MsiRecordGetInteger(hrec, 1);
5533     ok(r == 2, "Expected 2, got %d\n", r);
5534
5535     sz = sizeof(buffer);
5536     r = MsiRecordGetString(hrec, 2, buffer, &sz);
5537     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5538     ok(!lstrcmp(buffer, "two"), "Expected two, got %s\n", buffer);
5539
5540     r = MsiCloseHandle(hrec);
5541     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5542
5543     r = MsiViewFetch(hview, &hrec);
5544     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5545
5546     r = MsiRecordGetFieldCount(hrec);
5547     ok(r == 2, "Expected 2, got %d\n", r);
5548
5549     r = MsiRecordGetInteger(hrec, 1);
5550     ok(r == 5, "Expected 5, got %d\n", r);
5551
5552     sz = sizeof(buffer);
5553     r = MsiRecordGetString(hrec, 2, buffer, &sz);
5554     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5555     ok(!lstrcmp(buffer, "five"), "Expected five, got %s\n", buffer);
5556
5557     r = MsiCloseHandle(hrec);
5558     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5559
5560     r = MsiViewFetch(hview, &hrec);
5561     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5562
5563     r = MsiViewClose(hview);
5564     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5565     r = MsiCloseHandle(hview);
5566     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5567     r = MsiCloseHandle(hrec);
5568     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5569     r = MsiCloseHandle(hdb);
5570     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5571
5572     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, 0x20);
5573     hr = StgOpenStorage(name, NULL, mode, NULL, 0, &stg);
5574     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5575     ok(stg != NULL, "Expected non-NULL storage\n");
5576
5577     hr = IStorage_OpenStream(stg, moo, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
5578     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5579     ok(stm != NULL, "Expected non-NULL stream\n");
5580
5581     hr = IStream_Read(stm, data, MAX_PATH, &read);
5582     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5583     todo_wine
5584     {
5585         ok(read == 4, "Expected 4, got %d\n", read);
5586         ok(!memcmp(data, data10, read), "Unexpected data\n");
5587     }
5588
5589     hr = IStream_Release(stm);
5590     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5591
5592     hr = IStorage_OpenStream(stg, aar, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
5593     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5594     ok(stm != NULL, "Expected non-NULL stream\n");
5595
5596     hr = IStream_Read(stm, data, MAX_PATH, &read);
5597     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5598     ok(read == 8, "Expected 8, got %d\n", read);
5599     todo_wine
5600     {
5601         ok(!memcmp(data, data11, read), "Unexpected data\n");
5602     }
5603
5604     hr = IStream_Release(stm);
5605     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5606
5607     hr = IStorage_OpenStream(stg, stringdata, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
5608     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5609     ok(stm != NULL, "Expected non-NULL stream\n");
5610
5611     hr = IStream_Read(stm, buffer, MAX_PATH, &read);
5612     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5613     ok(read == 24, "Expected 24, got %d\n", read);
5614     ok(!memcmp(buffer, data12, read), "Unexpected data\n");
5615
5616     hr = IStream_Release(stm);
5617     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5618
5619     hr = IStorage_OpenStream(stg, stringpool, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
5620     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5621     ok(stm != NULL, "Expected non-NULL stream\n");
5622
5623     hr = IStream_Read(stm, data, MAX_PATH, &read);
5624     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5625     todo_wine
5626     {
5627         ok(read == 64, "Expected 64, got %d\n", read);
5628         ok(!memcmp(data, data13, read), "Unexpected data\n");
5629     }
5630
5631     hr = IStream_Release(stm);
5632     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5633
5634     hr = IStorage_Release(stg);
5635     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5636
5637     DeleteFileA(msifile);
5638 }
5639
5640 static void test_viewmodify_delete(void)
5641 {
5642     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5643     UINT r;
5644     const char *query;
5645     char buffer[0x100];
5646     DWORD sz;
5647
5648     DeleteFile(msifile);
5649
5650     /* just MsiOpenDatabase should not create a file */
5651     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5652     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5653
5654     query = "CREATE TABLE `phone` ( "
5655             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
5656             "PRIMARY KEY `id`)";
5657     r = run_query(hdb, 0, query);
5658     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5659
5660     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
5661         "VALUES('1', 'Alan', '5030581')";
5662     r = run_query(hdb, 0, query);
5663     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5664
5665     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
5666         "VALUES('2', 'Barry', '928440')";
5667     r = run_query(hdb, 0, query);
5668     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5669
5670     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
5671         "VALUES('3', 'Cindy', '2937550')";
5672     r = run_query(hdb, 0, query);
5673     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5674
5675     query = "SELECT * FROM `phone` WHERE `id` <= 2";
5676     r = MsiDatabaseOpenView(hdb, query, &hview);
5677     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5678     r = MsiViewExecute(hview, 0);
5679     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5680     r = MsiViewFetch(hview, &hrec);
5681     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5682
5683     /* delete 1 */
5684     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
5685     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5686
5687     r = MsiCloseHandle(hrec);
5688     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5689     r = MsiViewFetch(hview, &hrec);
5690     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5691
5692     /* delete 2 */
5693     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
5694     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5695
5696     r = MsiCloseHandle(hrec);
5697     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5698     r = MsiViewClose(hview);
5699     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5700     r = MsiCloseHandle(hview);
5701     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5702
5703     query = "SELECT * FROM `phone`";
5704     r = MsiDatabaseOpenView(hdb, query, &hview);
5705     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5706     r = MsiViewExecute(hview, 0);
5707     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5708     r = MsiViewFetch(hview, &hrec);
5709     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5710
5711     r = MsiRecordGetInteger(hrec, 1);
5712     ok(r == 3, "Expected 3, got %d\n", r);
5713
5714     sz = sizeof(buffer);
5715     r = MsiRecordGetString(hrec, 2, buffer, &sz);
5716     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5717     ok(!lstrcmp(buffer, "Cindy"), "Expected Cindy, got %s\n", buffer);
5718
5719     sz = sizeof(buffer);
5720     r = MsiRecordGetString(hrec, 3, buffer, &sz);
5721     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5722     ok(!lstrcmp(buffer, "2937550"), "Expected 2937550, got %s\n", buffer);
5723
5724     r = MsiCloseHandle(hrec);
5725     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5726
5727     r = MsiViewFetch(hview, &hrec);
5728     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5729
5730     r = MsiViewClose(hview);
5731     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5732     r = MsiCloseHandle(hview);
5733     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5734     r = MsiCloseHandle(hdb);
5735     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5736 }
5737
5738 static const WCHAR _Tables[] = {0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0};
5739 static const WCHAR _StringData[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0};
5740 static const WCHAR _StringPool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0};
5741
5742 static const WCHAR data14[] = { /* _StringPool */
5743 /*  len, refs */
5744     0,   0,    /* string 0 ''    */
5745 };
5746
5747 static const struct {
5748     LPCWSTR name;
5749     const void *data;
5750     DWORD size;
5751 } database_table_data[] =
5752 {
5753     {_Tables, NULL, 0},
5754     {_StringData, NULL, 0},
5755     {_StringPool, data14, sizeof data14},
5756 };
5757
5758 static void enum_stream_names(IStorage *stg)
5759 {
5760     IEnumSTATSTG *stgenum = NULL;
5761     IStream *stm;
5762     HRESULT hr;
5763     STATSTG stat;
5764     ULONG n, count;
5765     BYTE data[MAX_PATH];
5766     BYTE check[MAX_PATH];
5767     DWORD sz;
5768
5769     memset(check, 'a', MAX_PATH);
5770
5771     hr = IStorage_EnumElements(stg, 0, NULL, 0, &stgenum);
5772     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
5773
5774     n = 0;
5775     while(TRUE)
5776     {
5777         count = 0;
5778         hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &count);
5779         if(FAILED(hr) || !count)
5780             break;
5781
5782         ok(!lstrcmpW(stat.pwcsName, database_table_data[n].name),
5783            "Expected table %d name to match\n", n);
5784
5785         stm = NULL;
5786         hr = IStorage_OpenStream(stg, stat.pwcsName, NULL,
5787                                  STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
5788         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
5789         ok(stm != NULL, "Expected non-NULL stream\n");
5790
5791         CoTaskMemFree(stat.pwcsName);
5792
5793         sz = MAX_PATH;
5794         memset(data, 'a', MAX_PATH);
5795         hr = IStream_Read(stm, data, sz, &count);
5796         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
5797
5798         ok(count == database_table_data[n].size,
5799            "Expected %d, got %d\n", database_table_data[n].size, count);
5800
5801         if (!database_table_data[n].size)
5802             ok(!memcmp(data, check, MAX_PATH), "data should not be changed\n");
5803         else
5804             ok(!memcmp(data, database_table_data[n].data, database_table_data[n].size),
5805                "Expected table %d data to match\n", n);
5806
5807         IStream_Release(stm);
5808         n++;
5809     }
5810
5811     ok(n == 3, "Expected 3, got %d\n", n);
5812
5813     IEnumSTATSTG_Release(stgenum);
5814 }
5815
5816 static void test_defaultdatabase(void)
5817 {
5818     UINT r;
5819     HRESULT hr;
5820     MSIHANDLE hdb;
5821     IStorage *stg = NULL;
5822
5823     DeleteFile(msifile);
5824
5825     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5826     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5827
5828     r = MsiDatabaseCommit(hdb);
5829     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5830
5831     MsiCloseHandle(hdb);
5832
5833     hr = StgOpenStorage(msifileW, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
5834     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
5835     ok(stg != NULL, "Expected non-NULL stg\n");
5836
5837     enum_stream_names(stg);
5838
5839     IStorage_Release(stg);
5840     DeleteFileA(msifile);
5841 }
5842
5843 static void test_order(void)
5844 {
5845     MSIHANDLE hdb, hview, hrec;
5846     CHAR buffer[MAX_PATH];
5847     LPCSTR query;
5848     UINT r, sz;
5849     int val;
5850
5851     hdb = create_db();
5852     ok(hdb, "failed to create db\n");
5853
5854     query = "CREATE TABLE `Empty` ( `A` SHORT NOT NULL PRIMARY KEY `A`)";
5855     r = run_query(hdb, 0, query);
5856     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5857
5858     query = "CREATE TABLE `Mesa` ( `A` SHORT NOT NULL, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
5859     r = run_query(hdb, 0, query);
5860     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5861
5862     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 1, 2, 9 )";
5863     r = run_query(hdb, 0, query);
5864     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5865
5866     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 3, 4, 7 )";
5867     r = run_query(hdb, 0, query);
5868     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5869
5870     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 5, 6, 8 )";
5871     r = run_query(hdb, 0, query);
5872     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5873
5874     query = "CREATE TABLE `Sideboard` ( `D` SHORT NOT NULL, `E` SHORT, `F` SHORT PRIMARY KEY `D`)";
5875     r = run_query(hdb, 0, query);
5876     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5877
5878     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 10, 11, 18 )";
5879     r = run_query(hdb, 0, query);
5880     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5881
5882     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 12, 13, 16 )";
5883     r = run_query(hdb, 0, query);
5884     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5885
5886     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 14, 15, 17 )";
5887     r = run_query(hdb, 0, query);
5888     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5889
5890     query = "SELECT `A`, `B` FROM `Mesa` ORDER BY `C`";
5891     r = MsiDatabaseOpenView(hdb, query, &hview);
5892     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5893     r = MsiViewExecute(hview, 0);
5894     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5895
5896     r = MsiViewFetch(hview, &hrec);
5897     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5898
5899     val = MsiRecordGetInteger(hrec, 1);
5900     ok(val == 3, "Expected 3, got %d\n", val);
5901
5902     val = MsiRecordGetInteger(hrec, 2);
5903     ok(val == 4, "Expected 3, got %d\n", val);
5904
5905     MsiCloseHandle(hrec);
5906
5907     r = MsiViewFetch(hview, &hrec);
5908     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5909
5910     val = MsiRecordGetInteger(hrec, 1);
5911     ok(val == 5, "Expected 5, got %d\n", val);
5912
5913     val = MsiRecordGetInteger(hrec, 2);
5914     ok(val == 6, "Expected 6, got %d\n", val);
5915
5916     MsiCloseHandle(hrec);
5917
5918     r = MsiViewFetch(hview, &hrec);
5919     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5920
5921     val = MsiRecordGetInteger(hrec, 1);
5922     ok(val == 1, "Expected 1, got %d\n", val);
5923
5924     val = MsiRecordGetInteger(hrec, 2);
5925     ok(val == 2, "Expected 2, got %d\n", val);
5926
5927     MsiCloseHandle(hrec);
5928
5929     r = MsiViewFetch(hview, &hrec);
5930     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5931
5932     MsiViewClose(hview);
5933     MsiCloseHandle(hview);
5934
5935     query = "SELECT `A`, `D` FROM `Mesa`, `Sideboard` ORDER BY `F`";
5936     r = MsiDatabaseOpenView(hdb, query, &hview);
5937     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5938     r = MsiViewExecute(hview, 0);
5939     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5940
5941     r = MsiViewFetch(hview, &hrec);
5942     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5943
5944     val = MsiRecordGetInteger(hrec, 1);
5945     ok(val == 1, "Expected 1, got %d\n", val);
5946
5947     val = MsiRecordGetInteger(hrec, 2);
5948     ok(val == 12, "Expected 12, got %d\n", val);
5949
5950     MsiCloseHandle(hrec);
5951
5952     r = MsiViewFetch(hview, &hrec);
5953     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5954
5955     val = MsiRecordGetInteger(hrec, 1);
5956     ok(val == 3, "Expected 3, got %d\n", val);
5957
5958     val = MsiRecordGetInteger(hrec, 2);
5959     ok(val == 12, "Expected 12, got %d\n", val);
5960
5961     MsiCloseHandle(hrec);
5962
5963     r = MsiViewFetch(hview, &hrec);
5964     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5965
5966     val = MsiRecordGetInteger(hrec, 1);
5967     ok(val == 5, "Expected 5, got %d\n", val);
5968
5969     val = MsiRecordGetInteger(hrec, 2);
5970     ok(val == 12, "Expected 12, got %d\n", val);
5971
5972     MsiCloseHandle(hrec);
5973
5974     r = MsiViewFetch(hview, &hrec);
5975     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5976
5977     val = MsiRecordGetInteger(hrec, 1);
5978     ok(val == 1, "Expected 1, got %d\n", val);
5979
5980     val = MsiRecordGetInteger(hrec, 2);
5981     ok(val == 14, "Expected 14, got %d\n", val);
5982
5983     MsiCloseHandle(hrec);
5984
5985     r = MsiViewFetch(hview, &hrec);
5986     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5987
5988     val = MsiRecordGetInteger(hrec, 1);
5989     ok(val == 3, "Expected 3, got %d\n", val);
5990
5991     val = MsiRecordGetInteger(hrec, 2);
5992     ok(val == 14, "Expected 14, got %d\n", val);
5993
5994     MsiCloseHandle(hrec);
5995
5996     r = MsiViewFetch(hview, &hrec);
5997     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5998
5999     val = MsiRecordGetInteger(hrec, 1);
6000     ok(val == 5, "Expected 5, got %d\n", val);
6001
6002     val = MsiRecordGetInteger(hrec, 2);
6003     ok(val == 14, "Expected 14, got %d\n", val);
6004
6005     MsiCloseHandle(hrec);
6006
6007     r = MsiViewFetch(hview, &hrec);
6008     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6009
6010     val = MsiRecordGetInteger(hrec, 1);
6011     ok(val == 1, "Expected 1, got %d\n", val);
6012
6013     val = MsiRecordGetInteger(hrec, 2);
6014     ok(val == 10, "Expected 10, got %d\n", val);
6015
6016     MsiCloseHandle(hrec);
6017
6018     r = MsiViewFetch(hview, &hrec);
6019     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6020
6021     val = MsiRecordGetInteger(hrec, 1);
6022     ok(val == 3, "Expected 3, got %d\n", val);
6023
6024     val = MsiRecordGetInteger(hrec, 2);
6025     ok(val == 10, "Expected 10, got %d\n", val);
6026
6027     MsiCloseHandle(hrec);
6028
6029     r = MsiViewFetch(hview, &hrec);
6030     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6031
6032     val = MsiRecordGetInteger(hrec, 1);
6033     ok(val == 5, "Expected 5, got %d\n", val);
6034
6035     val = MsiRecordGetInteger(hrec, 2);
6036     ok(val == 10, "Expected 10, got %d\n", val);
6037
6038     MsiCloseHandle(hrec);
6039
6040     r = MsiViewFetch(hview, &hrec);
6041     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6042
6043     MsiViewClose(hview);
6044     MsiCloseHandle(hview);
6045
6046     query = "SELECT * FROM `Empty` ORDER BY `A`";
6047     r = MsiDatabaseOpenView(hdb, query, &hview);
6048     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6049     r = MsiViewExecute(hview, 0);
6050     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6051
6052     r = MsiViewFetch(hview, &hrec);
6053     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6054
6055     MsiViewClose(hview);
6056     MsiCloseHandle(hview);
6057
6058     query = "CREATE TABLE `Buffet` ( `One` CHAR(72), `Two` SHORT PRIMARY KEY `One`)";
6059     r = run_query(hdb, 0, query);
6060     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6061
6062     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'uno',  2)";
6063     r = run_query(hdb, 0, query);
6064     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6065
6066     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'dos',  3)";
6067     r = run_query(hdb, 0, query);
6068     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6069
6070     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'tres',  1)";
6071     r = run_query(hdb, 0, query);
6072     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6073
6074     query = "SELECT * FROM `Buffet` WHERE `One` = 'dos' ORDER BY `Two`";
6075     r = MsiDatabaseOpenView(hdb, query, &hview);
6076     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6077     r = MsiViewExecute(hview, 0);
6078     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6079
6080     r = MsiViewFetch(hview, &hrec);
6081     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6082
6083     sz = sizeof(buffer);
6084     r = MsiRecordGetString(hrec, 1, buffer, &sz);
6085     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6086     ok(!lstrcmp(buffer, "dos"), "Expected \"dos\", got \"%s\"\n", buffer);
6087
6088     r = MsiRecordGetInteger(hrec, 2);
6089     ok(r == 3, "Expected 3, got %d\n", r);
6090
6091     MsiCloseHandle(hrec);
6092
6093     r = MsiViewFetch(hview, &hrec);
6094     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6095
6096     MsiViewClose(hview);
6097     MsiCloseHandle(hview);
6098     MsiCloseHandle(hdb);
6099 }
6100
6101 static void test_viewmodify_delete_temporary(void)
6102 {
6103     MSIHANDLE hdb, hview, hrec;
6104     const char *query;
6105     UINT r;
6106
6107     DeleteFile(msifile);
6108
6109     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
6110     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6111
6112     query = "CREATE TABLE `Table` ( `A` SHORT PRIMARY KEY `A` )";
6113     r = run_query(hdb, 0, query);
6114     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6115
6116     query = "SELECT * FROM `Table`";
6117     r = MsiDatabaseOpenView(hdb, query, &hview);
6118     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6119     r = MsiViewExecute(hview, 0);
6120     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6121
6122     hrec = MsiCreateRecord(1);
6123     MsiRecordSetInteger(hrec, 1, 1);
6124
6125     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
6126     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6127
6128     MsiCloseHandle(hrec);
6129
6130     hrec = MsiCreateRecord(1);
6131     MsiRecordSetInteger(hrec, 1, 2);
6132
6133     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
6134     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6135
6136     MsiCloseHandle(hrec);
6137
6138     hrec = MsiCreateRecord(1);
6139     MsiRecordSetInteger(hrec, 1, 3);
6140
6141     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
6142     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6143
6144     MsiCloseHandle(hrec);
6145
6146     hrec = MsiCreateRecord(1);
6147     MsiRecordSetInteger(hrec, 1, 4);
6148
6149     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
6150     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6151
6152     MsiCloseHandle(hrec);
6153     MsiViewClose(hview);
6154     MsiCloseHandle(hview);
6155
6156     query = "SELECT * FROM `Table` WHERE  `A` = 2";
6157     r = MsiDatabaseOpenView(hdb, query, &hview);
6158     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6159     r = MsiViewExecute(hview, 0);
6160     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6161     r = MsiViewFetch(hview, &hrec);
6162     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6163
6164     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6165     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6166
6167     MsiCloseHandle(hrec);
6168     MsiViewClose(hview);
6169     MsiCloseHandle(hview);
6170
6171     query = "SELECT * FROM `Table` WHERE  `A` = 3";
6172     r = MsiDatabaseOpenView(hdb, query, &hview);
6173     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6174     r = MsiViewExecute(hview, 0);
6175     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6176     r = MsiViewFetch(hview, &hrec);
6177     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6178
6179     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6180     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6181
6182     MsiCloseHandle(hrec);
6183     MsiViewClose(hview);
6184     MsiCloseHandle(hview);
6185
6186     query = "SELECT * FROM `Table` ORDER BY `A`";
6187     r = MsiDatabaseOpenView(hdb, query, &hview);
6188     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6189     r = MsiViewExecute(hview, 0);
6190     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6191
6192     r = MsiViewFetch(hview, &hrec);
6193     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6194
6195     r = MsiRecordGetInteger(hrec, 1);
6196     ok(r == 1, "Expected 1, got %d\n", r);
6197
6198     MsiCloseHandle(hrec);
6199
6200     r = MsiViewFetch(hview, &hrec);
6201     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6202
6203     r = MsiRecordGetInteger(hrec, 1);
6204     ok(r == 4, "Expected 4, got %d\n", r);
6205
6206     MsiCloseHandle(hrec);
6207
6208     r = MsiViewFetch(hview, &hrec);
6209     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6210
6211     MsiViewClose(hview);
6212     MsiCloseHandle(hview);
6213     MsiCloseHandle(hdb);
6214     DeleteFileA(msifile);
6215 }
6216
6217 static void test_deleterow(void)
6218 {
6219     MSIHANDLE hdb, hview, hrec;
6220     const char *query;
6221     char buf[MAX_PATH];
6222     UINT r;
6223     DWORD size;
6224
6225     DeleteFile(msifile);
6226
6227     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
6228     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6229
6230     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6231     r = run_query(hdb, 0, query);
6232     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6233
6234     query = "INSERT INTO `Table` (`A`) VALUES ('one')";
6235     r = run_query(hdb, 0, query);
6236     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6237
6238     query = "INSERT INTO `Table` (`A`) VALUES ('two')";
6239     r = run_query(hdb, 0, query);
6240     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6241
6242     query = "DELETE FROM `Table` WHERE `A` = 'one'";
6243     r = run_query(hdb, 0, query);
6244     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6245
6246     r = MsiDatabaseCommit(hdb);
6247     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6248
6249     MsiCloseHandle(hdb);
6250
6251     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb);
6252     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6253
6254     query = "SELECT * FROM `Table`";
6255     r = MsiDatabaseOpenView(hdb, query, &hview);
6256     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6257     r = MsiViewExecute(hview, 0);
6258     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6259
6260     r = MsiViewFetch(hview, &hrec);
6261     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6262
6263     size = MAX_PATH;
6264     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6265     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6266     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
6267
6268     MsiCloseHandle(hrec);
6269
6270     r = MsiViewFetch(hview, &hrec);
6271     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6272
6273     MsiViewClose(hview);
6274     MsiCloseHandle(hview);
6275     MsiCloseHandle(hdb);
6276     DeleteFileA(msifile);
6277 }
6278
6279 static const CHAR import_dat[] = "A\n"
6280                                  "s72\n"
6281                                  "Table\tA\n"
6282                                  "This is a new 'string' ok\n";
6283
6284 static void test_quotes(void)
6285 {
6286     MSIHANDLE hdb, hview, hrec;
6287     const char *query;
6288     char buf[MAX_PATH];
6289     UINT r;
6290     DWORD size;
6291
6292     DeleteFile(msifile);
6293
6294     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
6295     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6296
6297     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6298     r = run_query(hdb, 0, query);
6299     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6300
6301     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a 'string' ok' )";
6302     r = run_query(hdb, 0, query);
6303     ok(r == ERROR_BAD_QUERY_SYNTAX,
6304        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6305
6306     query = "INSERT INTO `Table` ( `A` ) VALUES ( \"This is a 'string' ok\" )";
6307     r = run_query(hdb, 0, query);
6308     ok(r == ERROR_BAD_QUERY_SYNTAX,
6309        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6310
6311     query = "INSERT INTO `Table` ( `A` ) VALUES ( \"test\" )";
6312     r = run_query(hdb, 0, query);
6313     ok(r == ERROR_BAD_QUERY_SYNTAX,
6314        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6315
6316     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a ''string'' ok' )";
6317     r = run_query(hdb, 0, query);
6318     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6319
6320     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a '''string''' ok' )";
6321     r = run_query(hdb, 0, query);
6322     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6323
6324     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \'string\' ok' )";
6325     r = run_query(hdb, 0, query);
6326     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6327
6328     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \"string\" ok' )";
6329     r = run_query(hdb, 0, query);
6330     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6331
6332     query = "SELECT * FROM `Table`";
6333     r = MsiDatabaseOpenView(hdb, query, &hview);
6334     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6335
6336     r = MsiViewExecute(hview, 0);
6337     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6338
6339     r = MsiViewFetch(hview, &hrec);
6340     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6341
6342     size = MAX_PATH;
6343     r = MsiRecordGetString(hrec, 1, buf, &size);
6344     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6345     ok(!lstrcmp(buf, "This is a \"string\" ok"),
6346        "Expected \"This is a \"string\" ok\", got %s\n", buf);
6347
6348     MsiCloseHandle(hrec);
6349
6350     r = MsiViewFetch(hview, &hrec);
6351     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6352
6353     MsiViewClose(hview);
6354     MsiCloseHandle(hview);
6355
6356     write_file("import.idt", import_dat, (sizeof(import_dat) - 1) * sizeof(char));
6357
6358     r = MsiDatabaseImportA(hdb, CURR_DIR, "import.idt");
6359     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6360
6361     DeleteFileA("import.idt");
6362
6363     query = "SELECT * FROM `Table`";
6364     r = MsiDatabaseOpenView(hdb, query, &hview);
6365     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6366
6367     r = MsiViewExecute(hview, 0);
6368     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6369
6370     r = MsiViewFetch(hview, &hrec);
6371     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6372
6373     size = MAX_PATH;
6374     r = MsiRecordGetString(hrec, 1, buf, &size);
6375     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6376     ok(!lstrcmp(buf, "This is a new 'string' ok"),
6377        "Expected \"This is a new 'string' ok\", got %s\n", buf);
6378
6379     MsiCloseHandle(hrec);
6380
6381     r = MsiViewFetch(hview, &hrec);
6382     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6383
6384     MsiViewClose(hview);
6385     MsiCloseHandle(hview);
6386     MsiCloseHandle(hdb);
6387     DeleteFileA(msifile);
6388 }
6389
6390 static void test_carriagereturn(void)
6391 {
6392     MSIHANDLE hdb, hview, hrec;
6393     const char *query;
6394     char buf[MAX_PATH];
6395     UINT r;
6396     DWORD size;
6397
6398     DeleteFile(msifile);
6399
6400     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
6401     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6402
6403     query = "CREATE TABLE `Table`\r ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6404     r = run_query(hdb, 0, query);
6405     ok(r == ERROR_BAD_QUERY_SYNTAX,
6406        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6407
6408     query = "CREATE TABLE `Table` \r( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6409     r = run_query(hdb, 0, query);
6410     ok(r == ERROR_BAD_QUERY_SYNTAX,
6411        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6412
6413     query = "CREATE\r TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6414     r = run_query(hdb, 0, query);
6415     ok(r == ERROR_BAD_QUERY_SYNTAX,
6416        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6417
6418     query = "CREATE TABLE\r `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6419     r = run_query(hdb, 0, query);
6420     ok(r == ERROR_BAD_QUERY_SYNTAX,
6421        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6422
6423     query = "CREATE TABLE `Table` (\r `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6424     r = run_query(hdb, 0, query);
6425     ok(r == ERROR_BAD_QUERY_SYNTAX,
6426        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6427
6428     query = "CREATE TABLE `Table` ( `A`\r CHAR(72) NOT NULL PRIMARY KEY `A` )";
6429     r = run_query(hdb, 0, query);
6430     ok(r == ERROR_BAD_QUERY_SYNTAX,
6431        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6432
6433     query = "CREATE TABLE `Table` ( `A` CHAR(72)\r NOT NULL PRIMARY KEY `A` )";
6434     r = run_query(hdb, 0, query);
6435     ok(r == ERROR_BAD_QUERY_SYNTAX,
6436        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6437
6438     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT\r NULL PRIMARY KEY `A` )";
6439     r = run_query(hdb, 0, query);
6440     ok(r == ERROR_BAD_QUERY_SYNTAX,
6441        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6442
6443     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT \rNULL PRIMARY KEY `A` )";
6444     r = run_query(hdb, 0, query);
6445     ok(r == ERROR_BAD_QUERY_SYNTAX,
6446        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6447
6448     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL\r PRIMARY KEY `A` )";
6449     r = run_query(hdb, 0, query);
6450     ok(r == ERROR_BAD_QUERY_SYNTAX,
6451        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6452
6453     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL \rPRIMARY KEY `A` )";
6454     r = run_query(hdb, 0, query);
6455     ok(r == ERROR_BAD_QUERY_SYNTAX,
6456        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6457
6458     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY\r KEY `A` )";
6459     r = run_query(hdb, 0, query);
6460     ok(r == ERROR_BAD_QUERY_SYNTAX,
6461        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6462
6463     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY \rKEY `A` )";
6464     r = run_query(hdb, 0, query);
6465     ok(r == ERROR_BAD_QUERY_SYNTAX,
6466        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6467
6468     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY\r `A` )";
6469     r = run_query(hdb, 0, query);
6470     ok(r == ERROR_BAD_QUERY_SYNTAX,
6471        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6472
6473     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A`\r )";
6474     r = run_query(hdb, 0, query);
6475     ok(r == ERROR_BAD_QUERY_SYNTAX,
6476        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6477
6478     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )\r";
6479     r = run_query(hdb, 0, query);
6480     ok(r == ERROR_BAD_QUERY_SYNTAX,
6481        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6482
6483     query = "CREATE TABLE `\rOne` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6484     r = run_query(hdb, 0, query);
6485     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6486
6487     query = "CREATE TABLE `Tw\ro` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6488     r = run_query(hdb, 0, query);
6489     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6490
6491     query = "CREATE TABLE `Three\r` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6492     r = run_query(hdb, 0, query);
6493     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6494
6495     query = "CREATE TABLE `Four` ( `A\r` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6496     r = run_query(hdb, 0, query);
6497     ok(r == ERROR_BAD_QUERY_SYNTAX,
6498        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6499
6500     query = "CREATE TABLE `Four` ( `\rA` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6501     r = run_query(hdb, 0, query);
6502     ok(r == ERROR_BAD_QUERY_SYNTAX,
6503        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6504
6505     query = "CREATE TABLE `Four` ( `A` CHAR(72\r) NOT NULL PRIMARY KEY `A` )";
6506     r = run_query(hdb, 0, query);
6507     ok(r == ERROR_BAD_QUERY_SYNTAX,
6508        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6509
6510     query = "CREATE TABLE `Four` ( `A` CHAR(\r72) NOT NULL PRIMARY KEY `A` )";
6511     r = run_query(hdb, 0, query);
6512     ok(r == ERROR_BAD_QUERY_SYNTAX,
6513        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6514
6515     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `\rA` )";
6516     r = run_query(hdb, 0, query);
6517     ok(r == ERROR_BAD_QUERY_SYNTAX,
6518        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6519
6520     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
6521     r = run_query(hdb, 0, query);
6522     ok(r == ERROR_BAD_QUERY_SYNTAX,
6523        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6524
6525     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
6526     r = run_query(hdb, 0, query);
6527     ok(r == ERROR_BAD_QUERY_SYNTAX,
6528        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6529
6530     query = "SELECT * FROM `_Tables`";
6531     r = MsiDatabaseOpenView(hdb, query, &hview);
6532     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6533     r = MsiViewExecute(hview, 0);
6534     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6535
6536     r = MsiViewFetch(hview, &hrec);
6537     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6538
6539     size = MAX_PATH;
6540     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6541     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6542     ok(!lstrcmpA(buf, "\rOne"), "Expected \"\\rOne\", got \"%s\"\n", buf);
6543
6544     MsiCloseHandle(hrec);
6545
6546     r = MsiViewFetch(hview, &hrec);
6547     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6548
6549     size = MAX_PATH;
6550     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6551     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6552     ok(!lstrcmpA(buf, "Tw\ro"), "Expected \"Tw\\ro\", got \"%s\"\n", buf);
6553
6554     MsiCloseHandle(hrec);
6555
6556     r = MsiViewFetch(hview, &hrec);
6557     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6558
6559     size = MAX_PATH;
6560     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6561     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6562     ok(!lstrcmpA(buf, "Three\r"), "Expected \"Three\r\", got \"%s\"\n", buf);
6563
6564     MsiCloseHandle(hrec);
6565
6566     r = MsiViewFetch(hview, &hrec);
6567     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6568
6569     MsiViewClose(hview);
6570     MsiCloseHandle(hview);
6571
6572     MsiCloseHandle(hdb);
6573     DeleteFileA(msifile);
6574 }
6575
6576 static void test_noquotes(void)
6577 {
6578     MSIHANDLE hdb, hview, hrec;
6579     const char *query;
6580     char buf[MAX_PATH];
6581     UINT r;
6582     DWORD size;
6583
6584     DeleteFile(msifile);
6585
6586     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
6587     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6588
6589     query = "CREATE TABLE Table ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6590     r = run_query(hdb, 0, query);
6591     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6592
6593     query = "CREATE TABLE `Table` ( A CHAR(72) NOT NULL PRIMARY KEY `A` )";
6594     r = run_query(hdb, 0, query);
6595     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6596
6597     query = "CREATE TABLE `Table2` ( `A` CHAR(72) NOT NULL PRIMARY KEY A )";
6598     r = run_query(hdb, 0, query);
6599     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6600
6601     query = "CREATE TABLE `Table3` ( A CHAR(72) NOT NULL PRIMARY KEY A )";
6602     r = run_query(hdb, 0, query);
6603     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6604
6605     query = "SELECT * FROM `_Tables`";
6606     r = MsiDatabaseOpenView(hdb, query, &hview);
6607     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6608     r = MsiViewExecute(hview, 0);
6609     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6610
6611     r = MsiViewFetch(hview, &hrec);
6612     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6613
6614     size = MAX_PATH;
6615     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6616     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6617     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
6618
6619     MsiCloseHandle(hrec);
6620
6621     r = MsiViewFetch(hview, &hrec);
6622     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6623
6624     size = MAX_PATH;
6625     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6626     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6627     ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
6628
6629     MsiCloseHandle(hrec);
6630
6631     r = MsiViewFetch(hview, &hrec);
6632     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6633
6634     size = MAX_PATH;
6635     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6636     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6637     ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
6638
6639     MsiCloseHandle(hrec);
6640
6641     r = MsiViewFetch(hview, &hrec);
6642     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6643
6644     MsiViewClose(hview);
6645     MsiCloseHandle(hview);
6646
6647     query = "SELECT * FROM `_Columns`";
6648     r = MsiDatabaseOpenView(hdb, query, &hview);
6649     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6650     r = MsiViewExecute(hview, 0);
6651     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6652
6653     r = MsiViewFetch(hview, &hrec);
6654     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6655
6656     size = MAX_PATH;
6657     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6658     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6659     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
6660
6661     r = MsiRecordGetInteger(hrec, 2);
6662     ok(r == 1, "Expected 1, got %d\n", r);
6663
6664     size = MAX_PATH;
6665     r = MsiRecordGetStringA(hrec, 3, buf, &size);
6666     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6667     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
6668
6669     MsiCloseHandle(hrec);
6670
6671     r = MsiViewFetch(hview, &hrec);
6672     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6673
6674     size = MAX_PATH;
6675     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6676     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6677     ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
6678
6679     r = MsiRecordGetInteger(hrec, 2);
6680     ok(r == 1, "Expected 1, got %d\n", r);
6681
6682     size = MAX_PATH;
6683     r = MsiRecordGetStringA(hrec, 3, buf, &size);
6684     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6685     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
6686
6687     MsiCloseHandle(hrec);
6688
6689     r = MsiViewFetch(hview, &hrec);
6690     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6691
6692     size = MAX_PATH;
6693     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6694     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6695     ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
6696
6697     r = MsiRecordGetInteger(hrec, 2);
6698     ok(r == 1, "Expected 1, got %d\n", r);
6699
6700     size = MAX_PATH;
6701     r = MsiRecordGetStringA(hrec, 3, buf, &size);
6702     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6703     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
6704
6705     MsiCloseHandle(hrec);
6706
6707     r = MsiViewFetch(hview, &hrec);
6708     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6709
6710     MsiViewClose(hview);
6711     MsiCloseHandle(hview);
6712
6713     query = "INSERT INTO Table ( `A` ) VALUES ( 'hi' )";
6714     r = run_query(hdb, 0, query);
6715     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6716
6717     query = "INSERT INTO `Table` ( A ) VALUES ( 'hi' )";
6718     r = run_query(hdb, 0, query);
6719     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6720
6721     query = "INSERT INTO `Table` ( `A` ) VALUES ( hi )";
6722     r = run_query(hdb, 0, query);
6723     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6724
6725     query = "SELECT * FROM Table WHERE `A` = 'hi'";
6726     r = run_query(hdb, 0, query);
6727     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6728
6729     query = "SELECT * FROM `Table` WHERE `A` = hi";
6730     r = run_query(hdb, 0, query);
6731     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6732
6733     query = "SELECT * FROM Table";
6734     r = run_query(hdb, 0, query);
6735     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6736
6737     query = "SELECT * FROM Table2";
6738     r = MsiDatabaseOpenView(hdb, query, &hview);
6739     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6740     r = MsiViewExecute(hview, 0);
6741     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6742
6743     r = MsiViewFetch(hview, &hrec);
6744     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6745
6746     MsiViewClose(hview);
6747     MsiCloseHandle(hview);
6748
6749     query = "SELECT * FROM `Table` WHERE A = 'hi'";
6750     r = MsiDatabaseOpenView(hdb, query, &hview);
6751     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6752     r = MsiViewExecute(hview, 0);
6753     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6754
6755     r = MsiViewFetch(hview, &hrec);
6756     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6757
6758     size = MAX_PATH;
6759     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6760     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6761     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
6762
6763     MsiCloseHandle(hrec);
6764
6765     r = MsiViewFetch(hview, &hrec);
6766     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6767
6768     MsiViewClose(hview);
6769     MsiCloseHandle(hview);
6770     MsiCloseHandle(hdb);
6771     DeleteFileA(msifile);
6772 }
6773
6774 static void read_file_data(LPCSTR filename, LPSTR buffer)
6775 {
6776     HANDLE file;
6777     DWORD read;
6778
6779     file = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
6780     ZeroMemory(buffer, MAX_PATH);
6781     ReadFile(file, buffer, MAX_PATH, &read, NULL);
6782     CloseHandle(file);
6783 }
6784
6785 static void test_forcecodepage(void)
6786 {
6787     MSIHANDLE hdb;
6788     const char *query;
6789     char buffer[MAX_PATH];
6790     UINT r;
6791
6792     DeleteFile(msifile);
6793
6794     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
6795     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6796
6797     query = "SELECT * FROM `_ForceCodepage`";
6798     r = run_query(hdb, 0, query);
6799     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6800
6801     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6802     r = run_query(hdb, 0, query);
6803     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6804
6805     query = "SELECT * FROM `_ForceCodepage`";
6806     r = run_query(hdb, 0, query);
6807     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6808
6809     r = MsiDatabaseCommit(hdb);
6810     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6811
6812     query = "SELECT * FROM `_ForceCodepage`";
6813     r = run_query(hdb, 0, query);
6814     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6815
6816     MsiCloseHandle(hdb);
6817
6818     r = MsiOpenDatabase(msifile, MSIDBOPEN_DIRECT, &hdb);
6819     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6820
6821     query = "SELECT * FROM `_ForceCodepage`";
6822     r = run_query(hdb, 0, query);
6823     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6824
6825     r = MsiDatabaseExport(hdb, "_ForceCodepage", CURR_DIR, "forcecodepage.idt");
6826     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6827
6828     read_file_data("forcecodepage.idt", buffer);
6829     ok(!lstrcmpA(buffer, "\r\n\r\n0\t_ForceCodepage\r\n"),
6830        "Expected \"\r\n\r\n0\t_ForceCodepage\r\n\", got \"%s\"", buffer);
6831
6832     MsiCloseHandle(hdb);
6833     DeleteFileA(msifile);
6834     DeleteFileA("forcecodepage.idt");
6835 }
6836
6837 static void test_viewmodify_refresh(void)
6838 {
6839     MSIHANDLE hdb, hview, hrec;
6840     const char *query;
6841     char buffer[MAX_PATH];
6842     UINT r;
6843     DWORD size;
6844
6845     DeleteFile(msifile);
6846
6847     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
6848     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6849
6850     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL, `B` INT PRIMARY KEY `A` )";
6851     r = run_query(hdb, 0, query);
6852     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6853
6854     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hi', 1 )";
6855     r = run_query(hdb, 0, query);
6856     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6857
6858     query = "SELECT * FROM `Table`";
6859     r = MsiDatabaseOpenView(hdb, query, &hview);
6860     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6861     r = MsiViewExecute(hview, 0);
6862     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6863
6864     r = MsiViewFetch(hview, &hrec);
6865     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6866
6867     query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hi'";
6868     r = run_query(hdb, 0, query);
6869     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6870
6871     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
6872     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6873
6874     size = MAX_PATH;
6875     r = MsiRecordGetStringA(hrec, 1, buffer, &size);
6876     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6877     ok(!lstrcmpA(buffer, "hi"), "Expected \"hi\", got \"%s\"\n", buffer);
6878     ok(size == 2, "Expected 2, got %d\n", size);
6879
6880     r = MsiRecordGetInteger(hrec, 2);
6881     ok(r == 2, "Expected 2, got %d\n", r);
6882
6883     MsiCloseHandle(hrec);
6884     MsiViewClose(hview);
6885     MsiCloseHandle(hview);
6886
6887     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hello', 3 )";
6888     r = run_query(hdb, 0, query);
6889     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6890
6891     query = "SELECT * FROM `Table` WHERE `B` = 3";
6892     r = MsiDatabaseOpenView(hdb, query, &hview);
6893     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6894     r = MsiViewExecute(hview, 0);
6895     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6896
6897     r = MsiViewFetch(hview, &hrec);
6898     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6899
6900     query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hello'";
6901     r = run_query(hdb, 0, query);
6902     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6903
6904     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hithere', 3 )";
6905     r = run_query(hdb, 0, query);
6906     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6907
6908     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
6909     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6910
6911     size = MAX_PATH;
6912     r = MsiRecordGetStringA(hrec, 1, buffer, &size);
6913     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6914     ok(!lstrcmpA(buffer, "hello"), "Expected \"hello\", got \"%s\"\n", buffer);
6915     ok(size == 5, "Expected 5, got %d\n", size);
6916
6917     r = MsiRecordGetInteger(hrec, 2);
6918     ok(r == 2, "Expected 2, got %d\n", r);
6919
6920     MsiCloseHandle(hrec);
6921     MsiViewClose(hview);
6922     MsiCloseHandle(hview);
6923     MsiCloseHandle(hdb);
6924     DeleteFileA(msifile);
6925 }
6926
6927 static void test_where_viewmodify(void)
6928 {
6929     MSIHANDLE hdb, hview, hrec;
6930     const char *query;
6931     UINT r;
6932
6933     DeleteFile(msifile);
6934
6935     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
6936     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6937
6938     query = "CREATE TABLE `Table` ( `A` INT, `B` INT PRIMARY KEY `A` )";
6939     r = run_query(hdb, 0, query);
6940     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6941
6942     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 1, 2 )";
6943     r = run_query(hdb, 0, query);
6944     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6945
6946     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 3, 4 )";
6947     r = run_query(hdb, 0, query);
6948     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6949
6950     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 5, 6 )";
6951     r = run_query(hdb, 0, query);
6952     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6953
6954     /* `B` = 3 doesn't match, but the view shouldn't be executed */
6955     query = "SELECT * FROM `Table` WHERE `B` = 3";
6956     r = MsiDatabaseOpenView(hdb, query, &hview);
6957     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6958
6959     hrec = MsiCreateRecord(2);
6960     MsiRecordSetInteger(hrec, 1, 7);
6961     MsiRecordSetInteger(hrec, 2, 8);
6962
6963     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
6964     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6965
6966     MsiCloseHandle(hrec);
6967     MsiViewClose(hview);
6968     MsiCloseHandle(hview);
6969
6970     query = "SELECT * FROM `Table` WHERE `A` = 7";
6971     r = MsiDatabaseOpenView(hdb, query, &hview);
6972     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6973     r = MsiViewExecute(hview, 0);
6974     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6975
6976     r = MsiViewFetch(hview, &hrec);
6977     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6978
6979     r = MsiRecordGetInteger(hrec, 1);
6980     ok(r == 7, "Expected 7, got %d\n", r);
6981
6982     r = MsiRecordGetInteger(hrec, 2);
6983     ok(r == 8, "Expected 8, got %d\n", r);
6984
6985     MsiRecordSetInteger(hrec, 2, 9);
6986
6987     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
6988     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6989
6990     MsiCloseHandle(hrec);
6991     MsiViewClose(hview);
6992     MsiCloseHandle(hview);
6993
6994     query = "SELECT * FROM `Table` WHERE `A` = 7";
6995     r = MsiDatabaseOpenView(hdb, query, &hview);
6996     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6997     r = MsiViewExecute(hview, 0);
6998     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6999
7000     r = MsiViewFetch(hview, &hrec);
7001     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7002
7003     r = MsiRecordGetInteger(hrec, 1);
7004     ok(r == 7, "Expected 7, got %d\n", r);
7005
7006     r = MsiRecordGetInteger(hrec, 2);
7007     ok(r == 9, "Expected 9, got %d\n", r);
7008
7009     query = "UPDATE `Table` SET `B` = 10 WHERE `A` = 7";
7010     r = run_query(hdb, 0, query);
7011     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7012
7013     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7014     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7015
7016     r = MsiRecordGetInteger(hrec, 1);
7017     ok(r == 7, "Expected 7, got %d\n", r);
7018
7019     r = MsiRecordGetInteger(hrec, 2);
7020     ok(r == 10, "Expected 10, got %d\n", r);
7021
7022     MsiCloseHandle(hrec);
7023     MsiViewClose(hview);
7024     MsiCloseHandle(hview);
7025     MsiCloseHandle(hdb);
7026 }
7027
7028 static BOOL create_storage(LPCSTR name)
7029 {
7030     WCHAR nameW[MAX_PATH];
7031     IStorage *stg;
7032     IStream *stm;
7033     HRESULT hr;
7034     DWORD count;
7035     BOOL res = FALSE;
7036
7037     MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, MAX_PATH);
7038     hr = StgCreateDocfile(nameW, STGM_CREATE | STGM_READWRITE |
7039                           STGM_DIRECT | STGM_SHARE_EXCLUSIVE, 0, &stg);
7040     if (FAILED(hr))
7041         return FALSE;
7042
7043     hr = IStorage_CreateStream(stg, nameW, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
7044                                0, 0, &stm);
7045     if (FAILED(hr))
7046         goto done;
7047
7048     hr = IStream_Write(stm, "stgdata", 8, &count);
7049     if (SUCCEEDED(hr))
7050         res = TRUE;
7051
7052 done:
7053     IStream_Release(stm);
7054     IStorage_Release(stg);
7055
7056     return res;
7057 }
7058
7059 static void test_storages_table(void)
7060 {
7061     MSIHANDLE hdb, hview, hrec;
7062     IStorage *stg, *inner;
7063     IStream *stm;
7064     char file[MAX_PATH];
7065     char buf[MAX_PATH];
7066     WCHAR name[MAX_PATH];
7067     LPCSTR query;
7068     HRESULT hr;
7069     DWORD size;
7070     UINT r;
7071
7072     hdb = create_db();
7073     ok(hdb, "failed to create db\n");
7074
7075     r = MsiDatabaseCommit(hdb);
7076     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
7077
7078     MsiCloseHandle(hdb);
7079
7080     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb);
7081     ok(r == ERROR_SUCCESS , "Failed to open database\n");
7082
7083     /* check the column types */
7084     hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_TYPES);
7085     ok(hrec, "failed to get column info hrecord\n");
7086     ok(check_record(hrec, 1, "s62"), "wrong hrecord type\n");
7087     ok(check_record(hrec, 2, "V0"), "wrong hrecord type\n");
7088
7089     MsiCloseHandle(hrec);
7090
7091     /* now try the names */
7092     hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_NAMES);
7093     ok(hrec, "failed to get column info hrecord\n");
7094     ok(check_record(hrec, 1, "Name"), "wrong hrecord type\n");
7095     ok(check_record(hrec, 2, "Data"), "wrong hrecord type\n");
7096
7097     MsiCloseHandle(hrec);
7098
7099     create_storage("storage.bin");
7100
7101     hrec = MsiCreateRecord(2);
7102     MsiRecordSetString(hrec, 1, "stgname");
7103
7104     r = MsiRecordSetStream(hrec, 2, "storage.bin");
7105     ok(r == ERROR_SUCCESS, "Failed to add stream data to the hrecord: %d\n", r);
7106
7107     DeleteFileA("storage.bin");
7108
7109     query = "INSERT INTO `_Storages` (`Name`, `Data`) VALUES (?, ?)";
7110     r = MsiDatabaseOpenView(hdb, query, &hview);
7111     ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
7112
7113     r = MsiViewExecute(hview, hrec);
7114     ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
7115
7116     MsiCloseHandle(hrec);
7117     MsiViewClose(hview);
7118     MsiCloseHandle(hview);
7119
7120     query = "SELECT `Name`, `Data` FROM `_Storages`";
7121     r = MsiDatabaseOpenView(hdb, query, &hview);
7122     ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
7123
7124     r = MsiViewExecute(hview, 0);
7125     ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
7126
7127     r = MsiViewFetch(hview, &hrec);
7128     ok(r == ERROR_SUCCESS, "Failed to fetch hrecord: %d\n", r);
7129
7130     size = MAX_PATH;
7131     r = MsiRecordGetString(hrec, 1, file, &size);
7132     ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
7133     ok(!lstrcmp(file, "stgname"), "Expected \"stgname\", got \"%s\"\n", file);
7134
7135     size = MAX_PATH;
7136     lstrcpyA(buf, "apple");
7137     r = MsiRecordReadStream(hrec, 2, buf, &size);
7138     ok(r == ERROR_INVALID_DATA, "Expected ERROR_INVALID_DATA, got %d\n", r);
7139     ok(!lstrcmp(buf, "apple"), "Expected buf to be unchanged, got %s\n", buf);
7140     ok(size == 0, "Expected 0, got %d\n", size);
7141
7142     MsiCloseHandle(hrec);
7143
7144     r = MsiViewFetch(hview, &hrec);
7145     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7146
7147     MsiViewClose(hview);
7148     MsiCloseHandle(hview);
7149
7150     MsiDatabaseCommit(hdb);
7151     MsiCloseHandle(hdb);
7152
7153     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, MAX_PATH);
7154     hr = StgOpenStorage(name, NULL, STGM_DIRECT | STGM_READ |
7155                         STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
7156     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7157     ok(stg != NULL, "Expected non-NULL storage\n");
7158
7159     MultiByteToWideChar(CP_ACP, 0, "stgname", -1, name, MAX_PATH);
7160     hr = IStorage_OpenStorage(stg, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE,
7161                               NULL, 0, &inner);
7162     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7163     ok(inner != NULL, "Expected non-NULL storage\n");
7164
7165     MultiByteToWideChar(CP_ACP, 0, "storage.bin", -1, name, MAX_PATH);
7166     hr = IStorage_OpenStream(inner, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
7167     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7168     ok(stm != NULL, "Expected non-NULL stream\n");
7169
7170     hr = IStream_Read(stm, buf, MAX_PATH, &size);
7171     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
7172     ok(size == 8, "Expected 8, got %d\n", size);
7173     ok(!lstrcmpA(buf, "stgdata"), "Expected \"stgdata\", got \"%s\"\n", buf);
7174
7175     IStream_Release(stm);
7176     IStorage_Release(inner);
7177
7178     IStorage_Release(stg);
7179     DeleteFileA(msifile);
7180 }
7181
7182 static void test_dbtopackage(void)
7183 {
7184     MSIHANDLE hdb, hpkg;
7185     CHAR package[12], buf[MAX_PATH];
7186     DWORD size;
7187     UINT r;
7188
7189     /* create an empty database, transact mode */
7190     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
7191     ok(r == ERROR_SUCCESS, "Failed to create database\n");
7192
7193     set_summary_info(hdb);
7194
7195     r = create_directory_table(hdb);
7196     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7197
7198     r = create_custom_action_table(hdb);
7199     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7200
7201     r = add_custom_action_entry(hdb, "'SetProp', 51, 'MYPROP', 'grape'");
7202     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7203
7204     sprintf(package, "#%u", hdb);
7205     r = MsiOpenPackage(package, &hpkg);
7206     if (r == ERROR_INSTALL_PACKAGE_REJECTED)
7207     {
7208         skip("Not enough rights to perform tests\n");
7209         goto error;
7210     }
7211     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7212
7213     /* property is not set yet */
7214     size = MAX_PATH;
7215     lstrcpyA(buf, "kiwi");
7216     r = MsiGetProperty(hpkg, "MYPROP", buf, &size);
7217     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7218     ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7219     ok(size == 0, "Expected 0, got %d\n", size);
7220
7221     /* run the custom action to set the property */
7222     r = MsiDoAction(hpkg, "SetProp");
7223     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7224
7225     /* property is now set */
7226     size = MAX_PATH;
7227     lstrcpyA(buf, "kiwi");
7228     r = MsiGetProperty(hpkg, "MYPROP", buf, &size);
7229     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7230     ok(!lstrcmpA(buf, "grape"), "Expected \"grape\", got \"%s\"\n", buf);
7231     ok(size == 5, "Expected 5, got %d\n", size);
7232
7233     MsiCloseHandle(hpkg);
7234
7235     /* reset the package */
7236     r = MsiOpenPackage(package, &hpkg);
7237     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7238
7239     /* property is not set anymore */
7240     size = MAX_PATH;
7241     lstrcpyA(buf, "kiwi");
7242     r = MsiGetProperty(hpkg, "MYPROP", buf, &size);
7243     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7244     todo_wine
7245     {
7246         ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7247         ok(size == 0, "Expected 0, got %d\n", size);
7248     }
7249
7250     MsiCloseHandle(hdb);
7251     MsiCloseHandle(hpkg);
7252
7253     /* create an empty database, direct mode */
7254     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATEDIRECT, &hdb);
7255     ok(r == ERROR_SUCCESS, "Failed to create database\n");
7256
7257     set_summary_info(hdb);
7258
7259     r = create_directory_table(hdb);
7260     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7261
7262     r = create_custom_action_table(hdb);
7263     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7264
7265     r = add_custom_action_entry(hdb, "'SetProp', 51, 'MYPROP', 'grape'");
7266     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7267
7268     sprintf(package, "#%u", hdb);
7269     r = MsiOpenPackage(package, &hpkg);
7270     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7271
7272     /* property is not set yet */
7273     size = MAX_PATH;
7274     lstrcpyA(buf, "kiwi");
7275     r = MsiGetProperty(hpkg, "MYPROP", buf, &size);
7276     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7277     ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7278     ok(size == 0, "Expected 0, got %d\n", size);
7279
7280     /* run the custom action to set the property */
7281     r = MsiDoAction(hpkg, "SetProp");
7282     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7283
7284     /* property is now set */
7285     size = MAX_PATH;
7286     lstrcpyA(buf, "kiwi");
7287     r = MsiGetProperty(hpkg, "MYPROP", buf, &size);
7288     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7289     ok(!lstrcmpA(buf, "grape"), "Expected \"grape\", got \"%s\"\n", buf);
7290     ok(size == 5, "Expected 5, got %d\n", size);
7291
7292     MsiCloseHandle(hpkg);
7293
7294     /* reset the package */
7295     r = MsiOpenPackage(package, &hpkg);
7296     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7297
7298     /* property is not set anymore */
7299     size = MAX_PATH;
7300     lstrcpyA(buf, "kiwi");
7301     r = MsiGetProperty(hpkg, "MYPROP", buf, &size);
7302     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7303     todo_wine
7304     {
7305         ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7306         ok(size == 0, "Expected 0, got %d\n", size);
7307     }
7308
7309     MsiCloseHandle(hpkg);
7310
7311 error:
7312     MsiCloseHandle(hdb);
7313     DeleteFileA(msifile);
7314 }
7315
7316 static void test_droptable(void)
7317 {
7318     MSIHANDLE hdb, hview, hrec;
7319     CHAR buf[MAX_PATH];
7320     LPCSTR query;
7321     DWORD size;
7322     UINT r;
7323
7324     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
7325     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7326
7327     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
7328     r = run_query(hdb, 0, query);
7329     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7330
7331     query = "SELECT * FROM `One`";
7332     r = do_query(hdb, query, &hrec);
7333     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7334
7335     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7336     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7337     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7338     r = MsiViewExecute(hview, 0);
7339     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7340
7341     r = MsiViewFetch(hview, &hrec);
7342     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7343
7344     size = MAX_PATH;
7345     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7346     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7347     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7348
7349     MsiCloseHandle(hrec);
7350     MsiViewClose(hview);
7351     MsiCloseHandle(hview);
7352
7353     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7354     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7355     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7356     r = MsiViewExecute(hview, 0);
7357     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7358
7359     r = MsiViewFetch(hview, &hrec);
7360     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7361
7362     size = MAX_PATH;
7363     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7364     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7365     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7366
7367     r = MsiRecordGetInteger(hrec, 2);
7368     ok(r == 1, "Expected 1, got %d\n", r);
7369
7370     size = MAX_PATH;
7371     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7372     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7373     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7374
7375     MsiCloseHandle(hrec);
7376
7377     r = MsiViewFetch(hview, &hrec);
7378     ok(r == ERROR_NO_MORE_ITEMS,
7379        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7380
7381     MsiViewClose(hview);
7382     MsiCloseHandle(hview);
7383
7384     query = "DROP `One`";
7385     r = run_query(hdb, 0, query);
7386     ok(r == ERROR_BAD_QUERY_SYNTAX,
7387        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7388
7389     query = "DROP TABLE";
7390     r = run_query(hdb, 0, query);
7391     ok(r == ERROR_BAD_QUERY_SYNTAX,
7392        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7393
7394     query = "DROP TABLE `One`";
7395     hview = 0;
7396     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7397     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7398     r = MsiViewExecute(hview, 0);
7399     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7400
7401     r = MsiViewFetch(hview, &hrec);
7402     ok(r == ERROR_FUNCTION_FAILED,
7403        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
7404
7405     MsiViewClose(hview);
7406     MsiCloseHandle(hview);
7407
7408     query = "SELECT * FROM `IDontExist`";
7409     r = do_query(hdb, query, &hrec);
7410     ok(r == ERROR_BAD_QUERY_SYNTAX,
7411        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7412
7413     query = "SELECT * FROM `One`";
7414     r = do_query(hdb, query, &hrec);
7415     ok(r == ERROR_BAD_QUERY_SYNTAX,
7416        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7417
7418     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
7419     r = run_query(hdb, 0, query);
7420     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7421
7422     query = "DROP TABLE One";
7423     r = run_query(hdb, 0, query);
7424     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7425
7426     query = "SELECT * FROM `One`";
7427     r = do_query(hdb, query, &hrec);
7428     ok(r == ERROR_BAD_QUERY_SYNTAX,
7429        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7430
7431     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7432     r = do_query(hdb, query, &hrec);
7433     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7434
7435     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7436     r = do_query(hdb, query, &hrec);
7437     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7438
7439     query = "CREATE TABLE `One` ( `B` INT, `C` INT PRIMARY KEY `B` )";
7440     r = run_query(hdb, 0, query);
7441     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7442
7443     query = "SELECT * FROM `One`";
7444     r = do_query(hdb, query, &hrec);
7445     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7446
7447     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7448     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7449     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7450     r = MsiViewExecute(hview, 0);
7451     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7452
7453     r = MsiViewFetch(hview, &hrec);
7454     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7455
7456     size = MAX_PATH;
7457     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7458     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7459     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7460
7461     MsiCloseHandle(hrec);
7462     MsiViewClose(hview);
7463     MsiCloseHandle(hview);
7464
7465     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7466     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7467     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7468     r = MsiViewExecute(hview, 0);
7469     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7470
7471     r = MsiViewFetch(hview, &hrec);
7472     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7473
7474     size = MAX_PATH;
7475     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7476     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7477     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7478
7479     r = MsiRecordGetInteger(hrec, 2);
7480     ok(r == 1, "Expected 1, got %d\n", r);
7481
7482     size = MAX_PATH;
7483     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7484     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7485     ok(!lstrcmpA(buf, "B"), "Expected \"B\", got \"%s\"\n", buf);
7486
7487     MsiCloseHandle(hrec);
7488
7489     r = MsiViewFetch(hview, &hrec);
7490     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7491
7492     size = MAX_PATH;
7493     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7494     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7495     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7496
7497     r = MsiRecordGetInteger(hrec, 2);
7498     ok(r == 2, "Expected 2, got %d\n", r);
7499
7500     size = MAX_PATH;
7501     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7502     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7503     ok(!lstrcmpA(buf, "C"), "Expected \"C\", got \"%s\"\n", buf);
7504
7505     MsiCloseHandle(hrec);
7506
7507     r = MsiViewFetch(hview, &hrec);
7508     ok(r == ERROR_NO_MORE_ITEMS,
7509        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7510
7511     MsiViewClose(hview);
7512     MsiCloseHandle(hview);
7513
7514     query = "DROP TABLE One";
7515     r = run_query(hdb, 0, query);
7516     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7517
7518     query = "SELECT * FROM `One`";
7519     r = do_query(hdb, query, &hrec);
7520     ok(r == ERROR_BAD_QUERY_SYNTAX,
7521        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7522
7523     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7524     r = do_query(hdb, query, &hrec);
7525     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7526
7527     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7528     r = do_query(hdb, query, &hrec);
7529     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7530
7531     MsiCloseHandle(hdb);
7532     DeleteFileA(msifile);
7533 }
7534
7535 static void test_dbmerge(void)
7536 {
7537     MSIHANDLE hdb, href, hview, hrec;
7538     CHAR buf[MAX_PATH];
7539     LPCSTR query;
7540     DWORD size;
7541     UINT r;
7542
7543     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
7544     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7545
7546     r = MsiOpenDatabase("refdb.msi", MSIDBOPEN_CREATE, &href);
7547     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7548
7549     /* hDatabase is invalid */
7550     r = MsiDatabaseMergeA(0, href, "MergeErrors");
7551     ok(r == ERROR_INVALID_HANDLE,
7552        "Expected ERROR_INVALID_HANDLE, got %d\n", r);
7553
7554     /* hDatabaseMerge is invalid */
7555     r = MsiDatabaseMergeA(hdb, 0, "MergeErrors");
7556     ok(r == ERROR_INVALID_HANDLE,
7557        "Expected ERROR_INVALID_HANDLE, got %d\n", r);
7558
7559     /* szTableName is NULL */
7560     r = MsiDatabaseMergeA(hdb, href, NULL);
7561     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7562
7563     /* szTableName is empty */
7564     r = MsiDatabaseMergeA(hdb, href, "");
7565     ok(r == ERROR_INVALID_TABLE, "Expected ERROR_INVALID_TABLE, got %d\n", r);
7566
7567     /* both DBs empty, szTableName is valid */
7568     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7569     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7570
7571     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
7572     r = run_query(hdb, 0, query);
7573     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7574
7575     query = "CREATE TABLE `One` ( `A` CHAR(72) PRIMARY KEY `A` )";
7576     r = run_query(href, 0, query);
7577     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7578
7579     /* column types don't match */
7580     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7581     ok(r == ERROR_DATATYPE_MISMATCH,
7582        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
7583
7584     /* nothing in MergeErrors */
7585     query = "SELECT * FROM `MergeErrors`";
7586     r = do_query(hdb, query, &hrec);
7587     ok(r == ERROR_BAD_QUERY_SYNTAX,
7588        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7589
7590     query = "DROP TABLE `One`";
7591     r = run_query(hdb, 0, query);
7592     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7593
7594     query = "DROP TABLE `One`";
7595     r = run_query(href, 0, query);
7596     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7597
7598     query = "CREATE TABLE `One` ( "
7599         "`A` CHAR(72), "
7600         "`B` CHAR(56), "
7601         "`C` CHAR(64) LOCALIZABLE, "
7602         "`D` LONGCHAR, "
7603         "`E` CHAR(72) NOT NULL, "
7604         "`F` CHAR(56) NOT NULL, "
7605         "`G` CHAR(64) NOT NULL LOCALIZABLE, "
7606         "`H` LONGCHAR NOT NULL "
7607         "PRIMARY KEY `A` )";
7608     r = run_query(hdb, 0, query);
7609     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7610
7611     query = "CREATE TABLE `One` ( "
7612         "`A` CHAR(64), "
7613         "`B` CHAR(64), "
7614         "`C` CHAR(64), "
7615         "`D` CHAR(64), "
7616         "`E` CHAR(64) NOT NULL, "
7617         "`F` CHAR(64) NOT NULL, "
7618         "`G` CHAR(64) NOT NULL, "
7619         "`H` CHAR(64) NOT NULL "
7620         "PRIMARY KEY `A` )";
7621     r = run_query(href, 0, query);
7622     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7623
7624     /* column sting types don't match exactly */
7625     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7626     ok(r == ERROR_SUCCESS,
7627        "Expected ERROR_SUCCESS, got %d\n", r);
7628
7629     /* nothing in MergeErrors */
7630     query = "SELECT * FROM `MergeErrors`";
7631     r = do_query(hdb, query, &hrec);
7632     ok(r == ERROR_BAD_QUERY_SYNTAX,
7633        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7634
7635     query = "DROP TABLE `One`";
7636     r = run_query(hdb, 0, query);
7637     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7638
7639     query = "DROP TABLE `One`";
7640     r = run_query(href, 0, query);
7641     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7642
7643     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
7644     r = run_query(hdb, 0, query);
7645     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7646
7647     query = "CREATE TABLE `One` ( `A` INT, `C` INT PRIMARY KEY `A` )";
7648     r = run_query(href, 0, query);
7649     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7650
7651     /* column names don't match */
7652     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7653     ok(r == ERROR_DATATYPE_MISMATCH,
7654        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
7655
7656     /* nothing in MergeErrors */
7657     query = "SELECT * FROM `MergeErrors`";
7658     r = do_query(hdb, query, &hrec);
7659     ok(r == ERROR_BAD_QUERY_SYNTAX,
7660        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7661
7662     query = "DROP TABLE `One`";
7663     r = run_query(hdb, 0, query);
7664     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7665
7666     query = "DROP TABLE `One`";
7667     r = run_query(href, 0, query);
7668     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7669
7670     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
7671     r = run_query(hdb, 0, query);
7672     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7673
7674     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `B` )";
7675     r = run_query(href, 0, query);
7676     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7677
7678     /* primary keys don't match */
7679     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7680     ok(r == ERROR_DATATYPE_MISMATCH,
7681        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
7682
7683     /* nothing in MergeErrors */
7684     query = "SELECT * FROM `MergeErrors`";
7685     r = do_query(hdb, query, &hrec);
7686     ok(r == ERROR_BAD_QUERY_SYNTAX,
7687        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7688
7689     query = "DROP TABLE `One`";
7690     r = run_query(hdb, 0, query);
7691     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7692
7693     query = "DROP TABLE `One`";
7694     r = run_query(href, 0, query);
7695     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7696
7697     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
7698     r = run_query(hdb, 0, query);
7699     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7700
7701     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A`, `B` )";
7702     r = run_query(href, 0, query);
7703     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7704
7705     /* number of primary keys doesn't match */
7706     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7707     ok(r == ERROR_DATATYPE_MISMATCH,
7708        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
7709
7710     /* nothing in MergeErrors */
7711     query = "SELECT * FROM `MergeErrors`";
7712     r = do_query(hdb, query, &hrec);
7713     ok(r == ERROR_BAD_QUERY_SYNTAX,
7714        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7715
7716     query = "DROP TABLE `One`";
7717     r = run_query(hdb, 0, query);
7718     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7719
7720     query = "DROP TABLE `One`";
7721     r = run_query(href, 0, query);
7722     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7723
7724     query = "CREATE TABLE `One` ( `A` INT, `B` INT, `C` INT PRIMARY KEY `A` )";
7725     r = run_query(hdb, 0, query);
7726     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7727
7728     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
7729     r = run_query(href, 0, query);
7730     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7731
7732     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 2 )";
7733     r = run_query(href, 0, query);
7734     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7735
7736     /* number of columns doesn't match */
7737     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7738     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7739
7740     query = "SELECT * FROM `One`";
7741     r = do_query(hdb, query, &hrec);
7742     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7743
7744     r = MsiRecordGetInteger(hrec, 1);
7745     ok(r == 1, "Expected 1, got %d\n", r);
7746
7747     r = MsiRecordGetInteger(hrec, 2);
7748     ok(r == 2, "Expected 2, got %d\n", r);
7749
7750     r = MsiRecordGetInteger(hrec, 3);
7751     ok(r == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", r);
7752
7753     MsiCloseHandle(hrec);
7754
7755     /* nothing in MergeErrors */
7756     query = "SELECT * FROM `MergeErrors`";
7757     r = do_query(hdb, query, &hrec);
7758     ok(r == ERROR_BAD_QUERY_SYNTAX,
7759        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7760
7761     query = "DROP TABLE `One`";
7762     r = run_query(hdb, 0, query);
7763     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7764
7765     query = "DROP TABLE `One`";
7766     r = run_query(href, 0, query);
7767     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7768
7769     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
7770     r = run_query(hdb, 0, query);
7771     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7772
7773     query = "CREATE TABLE `One` ( `A` INT, `B` INT, `C` INT PRIMARY KEY `A` )";
7774     r = run_query(href, 0, query);
7775     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7776
7777     query = "INSERT INTO `One` ( `A`, `B`, `C` ) VALUES ( 1, 2, 3 )";
7778     r = run_query(href, 0, query);
7779     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7780
7781     /* number of columns doesn't match */
7782     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7783     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7784
7785     query = "SELECT * FROM `One`";
7786     r = do_query(hdb, query, &hrec);
7787     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7788
7789     r = MsiRecordGetInteger(hrec, 1);
7790     ok(r == 1, "Expected 1, got %d\n", r);
7791
7792     r = MsiRecordGetInteger(hrec, 2);
7793     ok(r == 2, "Expected 2, got %d\n", r);
7794
7795     r = MsiRecordGetInteger(hrec, 3);
7796     ok(r == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", r);
7797
7798     MsiCloseHandle(hrec);
7799
7800     /* nothing in MergeErrors */
7801     query = "SELECT * FROM `MergeErrors`";
7802     r = do_query(hdb, query, &hrec);
7803     ok(r == ERROR_BAD_QUERY_SYNTAX,
7804        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7805
7806     query = "DROP TABLE `One`";
7807     r = run_query(hdb, 0, query);
7808     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7809
7810     query = "DROP TABLE `One`";
7811     r = run_query(href, 0, query);
7812     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7813
7814     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
7815     r = run_query(hdb, 0, query);
7816     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7817
7818     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 1 )";
7819     r = run_query(hdb, 0, query);
7820     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7821
7822     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 2 )";
7823     r = run_query(hdb, 0, query);
7824     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7825
7826     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
7827     r = run_query(href, 0, query);
7828     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7829
7830     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 2 )";
7831     r = run_query(href, 0, query);
7832     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7833
7834     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 3 )";
7835     r = run_query(href, 0, query);
7836     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7837
7838     /* primary keys match, rows do not */
7839     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7840     ok(r == ERROR_FUNCTION_FAILED,
7841        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
7842
7843     /* nothing in MergeErrors */
7844     query = "SELECT * FROM `MergeErrors`";
7845     r = do_query(hdb, query, &hrec);
7846     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7847
7848     size = MAX_PATH;
7849     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7850     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7851     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7852
7853     r = MsiRecordGetInteger(hrec, 2);
7854     ok(r == 2, "Expected 2, got %d\n", r);
7855
7856     MsiCloseHandle(hrec);
7857
7858     r = MsiDatabaseOpenViewA(hdb, "SELECT * FROM `MergeErrors`", &hview);
7859     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7860
7861     r = MsiViewGetColumnInfo(hview, MSICOLINFO_NAMES, &hrec);
7862     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7863
7864     size = MAX_PATH;
7865     r = MsiRecordGetString(hrec, 1, buf, &size);
7866     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
7867
7868     size = MAX_PATH;
7869     r = MsiRecordGetString(hrec, 2, buf, &size);
7870     ok(!lstrcmpA(buf, "NumRowMergeConflicts"),
7871        "Expected \"NumRowMergeConflicts\", got \"%s\"\n", buf);
7872
7873     MsiCloseHandle(hrec);
7874
7875     r = MsiViewGetColumnInfo(hview, MSICOLINFO_TYPES, &hrec);
7876     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7877
7878     size = MAX_PATH;
7879     r = MsiRecordGetString(hrec, 1, buf, &size);
7880     ok(!lstrcmpA(buf, "s255"), "Expected \"s255\", got \"%s\"\n", buf);
7881
7882     size = MAX_PATH;
7883     r = MsiRecordGetString(hrec, 2, buf, &size);
7884     ok(!lstrcmpA(buf, "i2"), "Expected \"i2\", got \"%s\"\n", buf);
7885
7886     MsiCloseHandle(hrec);
7887     MsiViewClose(hview);
7888     MsiCloseHandle(hview);
7889
7890     query = "DROP TABLE `MergeErrors`";
7891     r = run_query(hdb, 0, query);
7892     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7893
7894     query = "DROP TABLE `One`";
7895     r = run_query(hdb, 0, query);
7896     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7897
7898     query = "DROP TABLE `One`";
7899     r = run_query(href, 0, query);
7900     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7901
7902     query = "CREATE TABLE `One` ( `A` INT, `B` CHAR(72) PRIMARY KEY `A` )";
7903     r = run_query(href, 0, query);
7904     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7905
7906     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'hi' )";
7907     r = run_query(href, 0, query);
7908     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7909
7910     /* table from merged database is not in target database */
7911     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7912     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7913
7914     query = "SELECT * FROM `One`";
7915     r = do_query(hdb, query, &hrec);
7916     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7917
7918     r = MsiRecordGetInteger(hrec, 1);
7919     ok(r == 1, "Expected 1, got %d\n", r);
7920
7921     size = MAX_PATH;
7922     r = MsiRecordGetStringA(hrec, 2, buf, &size);
7923     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7924     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
7925
7926     MsiCloseHandle(hrec);
7927
7928     /* nothing in MergeErrors */
7929     query = "SELECT * FROM `MergeErrors`";
7930     r = do_query(hdb, query, &hrec);
7931     ok(r == ERROR_BAD_QUERY_SYNTAX,
7932        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7933
7934     query = "DROP TABLE `One`";
7935     r = run_query(hdb, 0, query);
7936     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7937
7938     query = "DROP TABLE `One`";
7939     r = run_query(href, 0, query);
7940     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7941
7942     query = "CREATE TABLE `One` ( "
7943             "`A` CHAR(72), `B` INT PRIMARY KEY `A` )";
7944     r = run_query(hdb, 0, query);
7945     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7946
7947     query = "CREATE TABLE `One` ( "
7948             "`A` CHAR(72), `B` INT PRIMARY KEY `A` )";
7949     r = run_query(href, 0, query);
7950     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7951
7952     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 'hi', 1 )";
7953     r = run_query(href, 0, query);
7954     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7955
7956     /* primary key is string */
7957     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7958     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7959
7960     query = "SELECT * FROM `One`";
7961     r = do_query(hdb, query, &hrec);
7962     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7963
7964     size = MAX_PATH;
7965     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7966     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7967     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
7968
7969     r = MsiRecordGetInteger(hrec, 2);
7970     ok(r == 1, "Expected 1, got %d\n", r);
7971
7972     MsiCloseHandle(hrec);
7973
7974     /* nothing in MergeErrors */
7975     query = "SELECT * FROM `MergeErrors`";
7976     r = do_query(hdb, query, &hrec);
7977     ok(r == ERROR_BAD_QUERY_SYNTAX,
7978        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7979
7980     create_file_data("codepage.idt", "\r\n\r\n850\t_ForceCodepage\r\n", 0);
7981
7982     GetCurrentDirectoryA(MAX_PATH, buf);
7983     r = MsiDatabaseImportA(hdb, buf, "codepage.idt");
7984     todo_wine
7985     {
7986         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7987     }
7988
7989     query = "DROP TABLE `One`";
7990     r = run_query(hdb, 0, query);
7991     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7992
7993     query = "DROP TABLE `One`";
7994     r = run_query(href, 0, query);
7995     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7996
7997     query = "CREATE TABLE `One` ( "
7998             "`A` INT, `B` CHAR(72) LOCALIZABLE PRIMARY KEY `A` )";
7999     r = run_query(hdb, 0, query);
8000     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8001
8002     query = "CREATE TABLE `One` ( "
8003             "`A` INT, `B` CHAR(72) LOCALIZABLE PRIMARY KEY `A` )";
8004     r = run_query(href, 0, query);
8005     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8006
8007     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'hi' )";
8008     r = run_query(href, 0, query);
8009     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8010
8011     /* code page does not match */
8012     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8013     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8014
8015     query = "SELECT * FROM `One`";
8016     r = do_query(hdb, query, &hrec);
8017     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8018
8019     r = MsiRecordGetInteger(hrec, 1);
8020     ok(r == 1, "Expected 1, got %d\n", r);
8021
8022     size = MAX_PATH;
8023     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8024     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8025     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8026
8027     MsiCloseHandle(hrec);
8028
8029     /* nothing in MergeErrors */
8030     query = "SELECT * FROM `MergeErrors`";
8031     r = do_query(hdb, query, &hrec);
8032     ok(r == ERROR_BAD_QUERY_SYNTAX,
8033        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8034
8035     query = "DROP TABLE `One`";
8036     r = run_query(hdb, 0, query);
8037     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8038
8039     query = "DROP TABLE `One`";
8040     r = run_query(href, 0, query);
8041     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8042
8043     query = "CREATE TABLE `One` ( `A` INT, `B` OBJECT PRIMARY KEY `A` )";
8044     r = run_query(hdb, 0, query);
8045     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8046
8047     query = "CREATE TABLE `One` ( `A` INT, `B` OBJECT PRIMARY KEY `A` )";
8048     r = run_query(href, 0, query);
8049     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8050
8051     create_file("binary.dat");
8052     hrec = MsiCreateRecord(1);
8053     MsiRecordSetStreamA(hrec, 1, "binary.dat");
8054
8055     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, ? )";
8056     r = run_query(href, hrec, query);
8057     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8058
8059     MsiCloseHandle(hrec);
8060
8061     /* binary data to merge */
8062     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8063     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8064
8065     query = "SELECT * FROM `One`";
8066     r = do_query(hdb, query, &hrec);
8067     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8068
8069     r = MsiRecordGetInteger(hrec, 1);
8070     ok(r == 1, "Expected 1, got %d\n", r);
8071
8072     size = MAX_PATH;
8073     ZeroMemory(buf, MAX_PATH);
8074     r = MsiRecordReadStream(hrec, 2, buf, &size);
8075     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8076     ok(!lstrcmpA(buf, "binary.dat\n"),
8077        "Expected \"binary.dat\\n\", got \"%s\"\n", buf);
8078
8079     MsiCloseHandle(hrec);
8080
8081     /* nothing in MergeErrors */
8082     query = "SELECT * FROM `MergeErrors`";
8083     r = do_query(hdb, query, &hrec);
8084     ok(r == ERROR_BAD_QUERY_SYNTAX,
8085        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8086
8087     query = "DROP TABLE `One`";
8088     r = run_query(hdb, 0, query);
8089     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8090
8091     query = "DROP TABLE `One`";
8092     r = run_query(href, 0, query);
8093     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8094
8095     query = "CREATE TABLE `One` ( `A` INT, `B` CHAR(72) PRIMARY KEY `A` )";
8096     r = run_query(hdb, 0, query);
8097     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8098     r = run_query(href, 0, query);
8099     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8100
8101     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'foo' )";
8102     r = run_query(href, 0, query);
8103     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8104
8105     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 'bar' )";
8106     r = run_query(href, 0, query);
8107     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8108
8109     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8110     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8111
8112     query = "SELECT * FROM `One`";
8113     r = MsiDatabaseOpenViewA(hdb, query, &hview);
8114     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8115     r = MsiViewExecute(hview, 0);
8116     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8117
8118     r = MsiViewFetch(hview, &hrec);
8119     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8120
8121     r = MsiRecordGetInteger(hrec, 1);
8122     ok(r == 1, "Expected 1, got %d\n", r);
8123
8124     size = MAX_PATH;
8125     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8126     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8127     ok(!lstrcmpA(buf, "foo"), "Expected \"foo\", got \"%s\"\n", buf);
8128
8129     MsiCloseHandle(hrec);
8130
8131     r = MsiViewFetch(hview, &hrec);
8132     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8133
8134     r = MsiRecordGetInteger(hrec, 1);
8135     ok(r == 2, "Expected 2, got %d\n", r);
8136
8137     size = MAX_PATH;
8138     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8139     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8140     ok(!lstrcmpA(buf, "bar"), "Expected \"bar\", got \"%s\"\n", buf);
8141
8142     MsiCloseHandle(hrec);
8143
8144     r = MsiViewFetch(hview, &hrec);
8145     ok(r == ERROR_NO_MORE_ITEMS,
8146        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8147
8148     MsiViewClose(hview);
8149     MsiCloseHandle(hview);
8150
8151     MsiCloseHandle(hdb);
8152     MsiCloseHandle(href);
8153     DeleteFileA(msifile);
8154     DeleteFileA("refdb.msi");
8155     DeleteFileA("codepage.idt");
8156     DeleteFileA("binary.dat");
8157 }
8158
8159 static void test_select_with_tablenames(void)
8160 {
8161     MSIHANDLE hdb, view, rec;
8162     LPCSTR query;
8163     UINT r;
8164     int i;
8165
8166     int vals[4][2] = {
8167         {1,12},
8168         {4,12},
8169         {1,15},
8170         {4,15}};
8171
8172     hdb = create_db();
8173     ok(hdb, "failed to create db\n");
8174
8175     /* Build a pair of tables with the same column names, but unique data */
8176     query = "CREATE TABLE `T1` ( `A` SHORT, `B` SHORT PRIMARY KEY `A`)";
8177     r = run_query(hdb, 0, query);
8178     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8179
8180     query = "INSERT INTO `T1` ( `A`, `B` ) VALUES ( 1, 2 )";
8181     r = run_query(hdb, 0, query);
8182     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8183
8184     query = "INSERT INTO `T1` ( `A`, `B` ) VALUES ( 4, 5 )";
8185     r = run_query(hdb, 0, query);
8186     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8187
8188     query = "CREATE TABLE `T2` ( `A` SHORT, `B` SHORT PRIMARY KEY `A`)";
8189     r = run_query(hdb, 0, query);
8190     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8191
8192     query = "INSERT INTO `T2` ( `A`, `B` ) VALUES ( 11, 12 )";
8193     r = run_query(hdb, 0, query);
8194     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8195
8196     query = "INSERT INTO `T2` ( `A`, `B` ) VALUES ( 14, 15 )";
8197     r = run_query(hdb, 0, query);
8198     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8199
8200
8201     /* Test that selection based on prefixing the column with the table
8202      * actually selects the right data */
8203
8204     query = "SELECT T1.A, T2.B FROM T1,T2";
8205     r = MsiDatabaseOpenView(hdb, query, &view);
8206     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8207     r = MsiViewExecute(view, 0);
8208     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8209
8210     for (i = 0; i < 4; i++)
8211     {
8212         r = MsiViewFetch(view, &rec);
8213         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8214
8215         r = MsiRecordGetInteger(rec, 1);
8216         ok(r == vals[i][0], "Expected %d, got %d\n", vals[i][0], r);
8217
8218         r = MsiRecordGetInteger(rec, 2);
8219         ok(r == vals[i][1], "Expected %d, got %d\n", vals[i][1], r);
8220
8221         MsiCloseHandle(rec);
8222     }
8223
8224     r = MsiViewFetch(view, &rec);
8225     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8226
8227     MsiViewClose(view);
8228     MsiCloseHandle(view);
8229     MsiCloseHandle(hdb);
8230     DeleteFileA(msifile);
8231 }
8232
8233 UINT ordervals[6][3] =
8234 {
8235     { MSI_NULL_INTEGER, 12, 13 },
8236     { 1, 2, 3 },
8237     { 6, 4, 5 },
8238     { 8, 9, 7 },
8239     { 10, 11, MSI_NULL_INTEGER },
8240     { 14, MSI_NULL_INTEGER, 15 }
8241 };
8242
8243 static void test_insertorder(void)
8244 {
8245     MSIHANDLE hdb, view, rec;
8246     LPCSTR query;
8247     UINT r;
8248     int i;
8249
8250     hdb = create_db();
8251     ok(hdb, "failed to create db\n");
8252
8253     query = "CREATE TABLE `T` ( `A` SHORT, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
8254     r = run_query(hdb, 0, query);
8255     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8256
8257     query = "INSERT INTO `T` ( `A`, `B`, `C` ) VALUES ( 1, 2, 3 )";
8258     r = run_query(hdb, 0, query);
8259     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8260
8261     query = "INSERT INTO `T` ( `B`, `C`, `A` ) VALUES ( 4, 5, 6 )";
8262     r = run_query(hdb, 0, query);
8263     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8264
8265     query = "INSERT INTO `T` ( `C`, `A`, `B` ) VALUES ( 7, 8, 9 )";
8266     r = run_query(hdb, 0, query);
8267     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8268
8269     query = "INSERT INTO `T` ( `A`, `B` ) VALUES ( 10, 11 )";
8270     r = run_query(hdb, 0, query);
8271     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8272
8273     query = "INSERT INTO `T` ( `B`, `C` ) VALUES ( 12, 13 )";
8274     r = run_query(hdb, 0, query);
8275     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8276
8277     /* fails because the primary key already
8278      * has an MSI_NULL_INTEGER value set above
8279      */
8280     query = "INSERT INTO `T` ( `C` ) VALUES ( 14 )";
8281     r = run_query(hdb, 0, query);
8282     ok(r == ERROR_FUNCTION_FAILED,
8283        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8284
8285     /* replicate the error where primary key is set twice */
8286     query = "INSERT INTO `T` ( `A`, `C` ) VALUES ( 1, 14 )";
8287     r = run_query(hdb, 0, query);
8288     ok(r == ERROR_FUNCTION_FAILED,
8289        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8290
8291     query = "INSERT INTO `T` ( `A`, `C` ) VALUES ( 14, 15 )";
8292     r = run_query(hdb, 0, query);
8293     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8294
8295     query = "INSERT INTO `T` VALUES ( 16 )";
8296     r = run_query(hdb, 0, query);
8297     ok(r == ERROR_BAD_QUERY_SYNTAX,
8298        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8299
8300     query = "INSERT INTO `T` VALUES ( 17, 18 )";
8301     r = run_query(hdb, 0, query);
8302     ok(r == ERROR_BAD_QUERY_SYNTAX,
8303        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8304
8305     query = "INSERT INTO `T` VALUES ( 19, 20, 21 )";
8306     r = run_query(hdb, 0, query);
8307     ok(r == ERROR_BAD_QUERY_SYNTAX,
8308        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8309
8310     query = "SELECT * FROM `T`";
8311     r = MsiDatabaseOpenView(hdb, query, &view);
8312     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8313     r = MsiViewExecute(view, 0);
8314     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8315
8316     for (i = 0; i < 6; i++)
8317     {
8318         r = MsiViewFetch(view, &rec);
8319         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8320
8321         r = MsiRecordGetInteger(rec, 1);
8322         ok(r == ordervals[i][0], "Expected %d, got %d\n", ordervals[i][0], r);
8323
8324         r = MsiRecordGetInteger(rec, 2);
8325         ok(r == ordervals[i][1], "Expected %d, got %d\n", ordervals[i][1], r);
8326
8327         r = MsiRecordGetInteger(rec, 3);
8328         ok(r == ordervals[i][2], "Expected %d, got %d\n", ordervals[i][2], r);
8329
8330         MsiCloseHandle(rec);
8331     }
8332
8333     r = MsiViewFetch(view, &rec);
8334     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8335
8336     MsiViewClose(view);
8337     MsiCloseHandle(view);
8338
8339     query = "DELETE FROM `T` WHERE `A` IS NULL";
8340     r = run_query(hdb, 0, query);
8341     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8342
8343     query = "INSERT INTO `T` ( `B`, `C` ) VALUES ( 12, 13 ) TEMPORARY";
8344     r = run_query(hdb, 0, query);
8345     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8346
8347     query = "SELECT * FROM `T`";
8348     r = MsiDatabaseOpenView(hdb, query, &view);
8349     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8350     r = MsiViewExecute(view, 0);
8351     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8352
8353     for (i = 0; i < 6; i++)
8354     {
8355         r = MsiViewFetch(view, &rec);
8356         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8357
8358         r = MsiRecordGetInteger(rec, 1);
8359         ok(r == ordervals[i][0], "Expected %d, got %d\n", ordervals[i][0], r);
8360
8361         r = MsiRecordGetInteger(rec, 2);
8362         ok(r == ordervals[i][1], "Expected %d, got %d\n", ordervals[i][1], r);
8363
8364         r = MsiRecordGetInteger(rec, 3);
8365         ok(r == ordervals[i][2], "Expected %d, got %d\n", ordervals[i][2], r);
8366
8367         MsiCloseHandle(rec);
8368     }
8369
8370     r = MsiViewFetch(view, &rec);
8371     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8372
8373     MsiViewClose(view);
8374     MsiCloseHandle(view);
8375     MsiCloseHandle(hdb);
8376     DeleteFileA(msifile);
8377 }
8378
8379 static void test_columnorder(void)
8380 {
8381     MSIHANDLE hdb, view, rec;
8382     char buf[MAX_PATH];
8383     LPCSTR query;
8384     DWORD sz;
8385     UINT r;
8386
8387     hdb = create_db();
8388     ok(hdb, "failed to create db\n");
8389
8390     /* Each column is a slot:
8391      * ---------------------
8392      * | B | C | A | E | D |
8393      * ---------------------
8394      *
8395      * When a column is selected as a primary key,
8396      * the column occupying the nth primary key slot is swapped
8397      * with the current position of the primary key in question:
8398      *
8399      * set primary key `D`
8400      * ---------------------    ---------------------
8401      * | B | C | A | E | D | -> | D | C | A | E | B |
8402      * ---------------------    ---------------------
8403      *
8404      * set primary key `E`
8405      * ---------------------    ---------------------
8406      * | D | C | A | E | B | -> | D | E | A | C | B |
8407      * ---------------------    ---------------------
8408      */
8409
8410     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL, `C` SHORT NOT NULL, "
8411             "`A` CHAR(255), `E` INT, `D` CHAR(255) NOT NULL "
8412             "PRIMARY KEY `D`, `E`)";
8413     r = run_query(hdb, 0, query);
8414     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8415
8416     query = "SELECT * FROM `T`";
8417     r = MsiDatabaseOpenView(hdb, query, &view);
8418     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8419
8420     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
8421     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8422
8423     sz = MAX_PATH;
8424     lstrcpyA(buf, "kiwi");
8425     r = MsiRecordGetString(rec, 1, buf, &sz);
8426     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8427     ok(!lstrcmpA("s255", buf), "Expected \"s255\", got \"%s\"\n", buf);
8428
8429     sz = MAX_PATH;
8430     lstrcpyA(buf, "kiwi");
8431     r = MsiRecordGetString(rec, 2, buf, &sz);
8432     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8433     ok(!lstrcmpA("I2", buf), "Expected \"I2\", got \"%s\"\n", buf);
8434
8435     sz = MAX_PATH;
8436     lstrcpyA(buf, "kiwi");
8437     r = MsiRecordGetString(rec, 3, buf, &sz);
8438     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8439     ok(!lstrcmpA("S255", buf), "Expected \"S255\", got \"%s\"\n", buf);
8440
8441     sz = MAX_PATH;
8442     lstrcpyA(buf, "kiwi");
8443     r = MsiRecordGetString(rec, 4, buf, &sz);
8444     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8445     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
8446
8447     sz = MAX_PATH;
8448     lstrcpyA(buf, "kiwi");
8449     r = MsiRecordGetString(rec, 5, buf, &sz);
8450     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8451     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
8452
8453     MsiCloseHandle(rec);
8454
8455     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
8456     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8457
8458     sz = MAX_PATH;
8459     lstrcpyA(buf, "kiwi");
8460     r = MsiRecordGetString(rec, 1, buf, &sz);
8461     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8462     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
8463
8464     sz = MAX_PATH;
8465     lstrcpyA(buf, "kiwi");
8466     r = MsiRecordGetString(rec, 2, buf, &sz);
8467     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8468     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
8469
8470     sz = MAX_PATH;
8471     lstrcpyA(buf, "kiwi");
8472     r = MsiRecordGetString(rec, 3, buf, &sz);
8473     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8474     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
8475
8476     sz = MAX_PATH;
8477     lstrcpyA(buf, "kiwi");
8478     r = MsiRecordGetString(rec, 4, buf, &sz);
8479     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8480     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
8481
8482     sz = MAX_PATH;
8483     lstrcpyA(buf, "kiwi");
8484     r = MsiRecordGetString(rec, 5, buf, &sz);
8485     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8486     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
8487
8488     MsiCloseHandle(rec);
8489     MsiViewClose(view);
8490     MsiCloseHandle(view);
8491
8492     query = "INSERT INTO `T` ( `B`, `C`, `A`, `E`, `D` ) "
8493             "VALUES ( 1, 2, 'a', 3, 'bc' )";
8494     r = run_query(hdb, 0, query);
8495     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8496
8497     query = "SELECT * FROM `T`";
8498     r = do_query(hdb, query, &rec);
8499
8500     sz = MAX_PATH;
8501     lstrcpyA(buf, "kiwi");
8502     r = MsiRecordGetString(rec, 1, buf, &sz);
8503     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8504     ok(!lstrcmpA("bc", buf), "Expected \"bc\", got \"%s\"\n", buf);
8505
8506     r = MsiRecordGetInteger(rec, 2);
8507     ok(r == 3, "Expected 3, got %d\n", r);
8508
8509     sz = MAX_PATH;
8510     lstrcpyA(buf, "kiwi");
8511     r = MsiRecordGetString(rec, 3, buf, &sz);
8512     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8513     ok(!lstrcmpA("a", buf), "Expected \"a\", got \"%s\"\n", buf);
8514
8515     r = MsiRecordGetInteger(rec, 4);
8516     ok(r == 2, "Expected 2, got %d\n", r);
8517
8518     r = MsiRecordGetInteger(rec, 5);
8519     ok(r == 1, "Expected 1, got %d\n", r);
8520
8521     MsiCloseHandle(rec);
8522
8523     query = "SELECT * FROM `_Columns` WHERE `Table` = 'T'";
8524     r = MsiDatabaseOpenView(hdb, query, &view);
8525     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8526     r = MsiViewExecute(view, 0);
8527     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8528
8529     r = MsiViewFetch(view, &rec);
8530     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8531
8532     sz = MAX_PATH;
8533     lstrcpyA(buf, "kiwi");
8534     r = MsiRecordGetString(rec, 1, buf, &sz);
8535     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8536     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8537
8538     r = MsiRecordGetInteger(rec, 2);
8539     ok(r == 1, "Expected 1, got %d\n", r);
8540
8541     sz = MAX_PATH;
8542     lstrcpyA(buf, "kiwi");
8543     r = MsiRecordGetString(rec, 3, buf, &sz);
8544     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8545     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
8546
8547     MsiCloseHandle(rec);
8548
8549     r = MsiViewFetch(view, &rec);
8550     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8551
8552     sz = MAX_PATH;
8553     lstrcpyA(buf, "kiwi");
8554     r = MsiRecordGetString(rec, 1, buf, &sz);
8555     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8556     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8557
8558     r = MsiRecordGetInteger(rec, 2);
8559     ok(r == 2, "Expected 2, got %d\n", r);
8560
8561     sz = MAX_PATH;
8562     lstrcpyA(buf, "kiwi");
8563     r = MsiRecordGetString(rec, 3, buf, &sz);
8564     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8565     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
8566
8567     MsiCloseHandle(rec);
8568
8569     r = MsiViewFetch(view, &rec);
8570     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8571
8572     sz = MAX_PATH;
8573     lstrcpyA(buf, "kiwi");
8574     r = MsiRecordGetString(rec, 1, buf, &sz);
8575     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8576     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8577
8578     r = MsiRecordGetInteger(rec, 2);
8579     ok(r == 3, "Expected 3, got %d\n", r);
8580
8581     sz = MAX_PATH;
8582     lstrcpyA(buf, "kiwi");
8583     r = MsiRecordGetString(rec, 3, buf, &sz);
8584     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8585     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
8586
8587     MsiCloseHandle(rec);
8588
8589     r = MsiViewFetch(view, &rec);
8590     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8591
8592     sz = MAX_PATH;
8593     lstrcpyA(buf, "kiwi");
8594     r = MsiRecordGetString(rec, 1, buf, &sz);
8595     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8596     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8597
8598     r = MsiRecordGetInteger(rec, 2);
8599     ok(r == 4, "Expected 4, got %d\n", r);
8600
8601     sz = MAX_PATH;
8602     lstrcpyA(buf, "kiwi");
8603     r = MsiRecordGetString(rec, 3, buf, &sz);
8604     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8605     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
8606
8607     MsiCloseHandle(rec);
8608
8609     r = MsiViewFetch(view, &rec);
8610     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8611
8612     sz = MAX_PATH;
8613     lstrcpyA(buf, "kiwi");
8614     r = MsiRecordGetString(rec, 1, buf, &sz);
8615     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8616     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8617
8618     r = MsiRecordGetInteger(rec, 2);
8619     ok(r == 5, "Expected 5, got %d\n", r);
8620
8621     sz = MAX_PATH;
8622     lstrcpyA(buf, "kiwi");
8623     r = MsiRecordGetString(rec, 3, buf, &sz);
8624     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8625     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
8626
8627     MsiCloseHandle(rec);
8628
8629     r = MsiViewFetch(view, &rec);
8630     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8631
8632     MsiViewClose(view);
8633     MsiCloseHandle(view);
8634
8635     query = "CREATE TABLE `Z` ( `B` SHORT NOT NULL, `C` SHORT NOT NULL, "
8636             "`A` CHAR(255), `E` INT, `D` CHAR(255) NOT NULL "
8637             "PRIMARY KEY `C`, `A`, `D`)";
8638     r = run_query(hdb, 0, query);
8639     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8640
8641     query = "SELECT * FROM `Z`";
8642     r = MsiDatabaseOpenView(hdb, query, &view);
8643     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8644
8645     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
8646     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8647
8648     sz = MAX_PATH;
8649     lstrcpyA(buf, "kiwi");
8650     r = MsiRecordGetString(rec, 1, buf, &sz);
8651     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8652     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
8653
8654     sz = MAX_PATH;
8655     lstrcpyA(buf, "kiwi");
8656     r = MsiRecordGetString(rec, 2, buf, &sz);
8657     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8658     ok(!lstrcmpA("S255", buf), "Expected \"S255\", got \"%s\"\n", buf);
8659
8660     sz = MAX_PATH;
8661     lstrcpyA(buf, "kiwi");
8662     r = MsiRecordGetString(rec, 3, buf, &sz);
8663     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8664     ok(!lstrcmpA("s255", buf), "Expected \"s255\", got \"%s\"\n", buf);
8665
8666     sz = MAX_PATH;
8667     lstrcpyA(buf, "kiwi");
8668     r = MsiRecordGetString(rec, 4, buf, &sz);
8669     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8670     ok(!lstrcmpA("I2", buf), "Expected \"I2\", got \"%s\"\n", buf);
8671
8672     sz = MAX_PATH;
8673     lstrcpyA(buf, "kiwi");
8674     r = MsiRecordGetString(rec, 5, buf, &sz);
8675     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8676     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
8677
8678     MsiCloseHandle(rec);
8679
8680     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
8681     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8682
8683     sz = MAX_PATH;
8684     lstrcpyA(buf, "kiwi");
8685     r = MsiRecordGetString(rec, 1, buf, &sz);
8686     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8687     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
8688
8689     sz = MAX_PATH;
8690     lstrcpyA(buf, "kiwi");
8691     r = MsiRecordGetString(rec, 2, buf, &sz);
8692     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8693     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
8694
8695     sz = MAX_PATH;
8696     lstrcpyA(buf, "kiwi");
8697     r = MsiRecordGetString(rec, 3, buf, &sz);
8698     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8699     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
8700
8701     sz = MAX_PATH;
8702     lstrcpyA(buf, "kiwi");
8703     r = MsiRecordGetString(rec, 4, buf, &sz);
8704     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8705     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
8706
8707     sz = MAX_PATH;
8708     lstrcpyA(buf, "kiwi");
8709     r = MsiRecordGetString(rec, 5, buf, &sz);
8710     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8711     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
8712
8713     MsiCloseHandle(rec);
8714     MsiViewClose(view);
8715     MsiCloseHandle(view);
8716
8717     query = "INSERT INTO `Z` ( `B`, `C`, `A`, `E`, `D` ) "
8718             "VALUES ( 1, 2, 'a', 3, 'bc' )";
8719     r = run_query(hdb, 0, query);
8720     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8721
8722     query = "SELECT * FROM `Z`";
8723     r = do_query(hdb, query, &rec);
8724
8725     r = MsiRecordGetInteger(rec, 1);
8726     ok(r == 2, "Expected 2, got %d\n", r);
8727
8728     sz = MAX_PATH;
8729     lstrcpyA(buf, "kiwi");
8730     r = MsiRecordGetString(rec, 2, buf, &sz);
8731     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8732     ok(!lstrcmpA("a", buf), "Expected \"a\", got \"%s\"\n", buf);
8733
8734     sz = MAX_PATH;
8735     lstrcpyA(buf, "kiwi");
8736     r = MsiRecordGetString(rec, 3, buf, &sz);
8737     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8738     ok(!lstrcmpA("bc", buf), "Expected \"bc\", got \"%s\"\n", buf);
8739
8740     r = MsiRecordGetInteger(rec, 4);
8741     ok(r == 3, "Expected 3, got %d\n", r);
8742
8743     r = MsiRecordGetInteger(rec, 5);
8744     ok(r == 1, "Expected 1, got %d\n", r);
8745
8746     MsiCloseHandle(rec);
8747
8748     query = "SELECT * FROM `_Columns` WHERE `Table` = 'T'";
8749     r = MsiDatabaseOpenView(hdb, query, &view);
8750     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8751     r = MsiViewExecute(view, 0);
8752     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8753
8754     r = MsiViewFetch(view, &rec);
8755     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8756
8757     sz = MAX_PATH;
8758     lstrcpyA(buf, "kiwi");
8759     r = MsiRecordGetString(rec, 1, buf, &sz);
8760     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8761     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8762
8763     r = MsiRecordGetInteger(rec, 2);
8764     ok(r == 1, "Expected 1, got %d\n", r);
8765
8766     sz = MAX_PATH;
8767     lstrcpyA(buf, "kiwi");
8768     r = MsiRecordGetString(rec, 3, buf, &sz);
8769     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8770     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
8771
8772     MsiCloseHandle(rec);
8773
8774     r = MsiViewFetch(view, &rec);
8775     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8776
8777     sz = MAX_PATH;
8778     lstrcpyA(buf, "kiwi");
8779     r = MsiRecordGetString(rec, 1, buf, &sz);
8780     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8781     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8782
8783     r = MsiRecordGetInteger(rec, 2);
8784     ok(r == 2, "Expected 2, got %d\n", r);
8785
8786     sz = MAX_PATH;
8787     lstrcpyA(buf, "kiwi");
8788     r = MsiRecordGetString(rec, 3, buf, &sz);
8789     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8790     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
8791
8792     MsiCloseHandle(rec);
8793
8794     r = MsiViewFetch(view, &rec);
8795     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8796
8797     sz = MAX_PATH;
8798     lstrcpyA(buf, "kiwi");
8799     r = MsiRecordGetString(rec, 1, buf, &sz);
8800     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8801     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8802
8803     r = MsiRecordGetInteger(rec, 2);
8804     ok(r == 3, "Expected 3, got %d\n", r);
8805
8806     sz = MAX_PATH;
8807     lstrcpyA(buf, "kiwi");
8808     r = MsiRecordGetString(rec, 3, buf, &sz);
8809     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8810     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
8811
8812     MsiCloseHandle(rec);
8813
8814     r = MsiViewFetch(view, &rec);
8815     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8816
8817     sz = MAX_PATH;
8818     lstrcpyA(buf, "kiwi");
8819     r = MsiRecordGetString(rec, 1, buf, &sz);
8820     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8821     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8822
8823     r = MsiRecordGetInteger(rec, 2);
8824     ok(r == 4, "Expected 4, got %d\n", r);
8825
8826     sz = MAX_PATH;
8827     lstrcpyA(buf, "kiwi");
8828     r = MsiRecordGetString(rec, 3, buf, &sz);
8829     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8830     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
8831
8832     MsiCloseHandle(rec);
8833
8834     r = MsiViewFetch(view, &rec);
8835     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8836
8837     sz = MAX_PATH;
8838     lstrcpyA(buf, "kiwi");
8839     r = MsiRecordGetString(rec, 1, buf, &sz);
8840     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8841     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8842
8843     r = MsiRecordGetInteger(rec, 2);
8844     ok(r == 5, "Expected 5, got %d\n", r);
8845
8846     sz = MAX_PATH;
8847     lstrcpyA(buf, "kiwi");
8848     r = MsiRecordGetString(rec, 3, buf, &sz);
8849     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8850     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
8851
8852     MsiCloseHandle(rec);
8853
8854     r = MsiViewFetch(view, &rec);
8855     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8856
8857     MsiViewClose(view);
8858     MsiCloseHandle(view);
8859
8860     MsiCloseHandle(hdb);
8861     DeleteFileA(msifile);
8862 }
8863
8864 static void test_createtable(void)
8865 {
8866     MSIHANDLE hdb, htab = 0, hrec = 0;
8867     LPCSTR query;
8868     UINT res;
8869     DWORD size;
8870     char buffer[0x20];
8871
8872     hdb = create_db();
8873     ok(hdb, "failed to create db\n");
8874
8875     query = "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL PRIMARY KEY `foo`)";
8876     res = MsiDatabaseOpenView( hdb, query, &htab );
8877     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8878     if(res == ERROR_SUCCESS )
8879     {
8880         res = MsiViewExecute( htab, hrec );
8881         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8882
8883         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
8884         todo_wine ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8885
8886         size = sizeof(buffer);
8887         res = MsiRecordGetString(hrec, 1, buffer, &size );
8888         todo_wine ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8889         MsiCloseHandle( hrec );
8890
8891         res = MsiViewClose( htab );
8892         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8893
8894         res = MsiCloseHandle( htab );
8895         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8896     }
8897
8898     query = "CREATE TABLE `a` (`b` INT PRIMARY KEY `b`)";
8899     res = MsiDatabaseOpenView( hdb, query, &htab );
8900     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8901     if(res == ERROR_SUCCESS )
8902     {
8903         res = MsiViewExecute( htab, 0 );
8904         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8905
8906         res = MsiViewClose( htab );
8907         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8908
8909         res = MsiCloseHandle( htab );
8910         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8911
8912         query = "SELECT * FROM `a`";
8913         res = MsiDatabaseOpenView( hdb, query, &htab );
8914         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8915
8916         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
8917         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8918
8919         buffer[0] = 0;
8920         size = sizeof(buffer);
8921         res = MsiRecordGetString(hrec, 1, buffer, &size );
8922         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8923         ok(!strcmp(buffer,"b"), "b != %s\n", buffer);
8924         MsiCloseHandle( hrec );
8925
8926         res = MsiViewClose( htab );
8927         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8928
8929         res = MsiCloseHandle( htab );
8930         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8931
8932         res = MsiDatabaseCommit(hdb);
8933         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8934
8935         res = MsiCloseHandle(hdb);
8936         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8937
8938         res = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb );
8939         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8940
8941         query = "SELECT * FROM `a`";
8942         res = MsiDatabaseOpenView( hdb, query, &htab );
8943         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8944
8945         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
8946         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8947
8948         buffer[0] = 0;
8949         size = sizeof(buffer);
8950         res = MsiRecordGetString(hrec, 1, buffer, &size );
8951         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8952         todo_wine ok(!strcmp(buffer,"b"), "b != %s\n", buffer);
8953
8954         res = MsiCloseHandle( hrec );
8955         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8956
8957         res = MsiViewClose( htab );
8958         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8959
8960         res = MsiCloseHandle( htab );
8961         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8962     }
8963
8964     res = MsiDatabaseCommit(hdb);
8965     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8966
8967     res = MsiCloseHandle(hdb);
8968     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
8969
8970     DeleteFileA(msifile);
8971 }
8972
8973
8974 START_TEST(db)
8975 {
8976     test_msidatabase();
8977     test_msiinsert();
8978     test_msidecomposedesc();
8979     test_msibadqueries();
8980     test_viewmodify();
8981     test_viewgetcolumninfo();
8982     test_getcolinfo();
8983     test_msiexport();
8984     test_longstrings();
8985     test_streamtable();
8986     test_binary();
8987     test_where_not_in_selected();
8988     test_where();
8989     test_msiimport();
8990     test_binary_import();
8991     test_markers();
8992     test_handle_limit();
8993     test_try_transform();
8994     test_join();
8995     test_temporary_table();
8996     test_alter();
8997     test_integers();
8998     test_update();
8999     test_special_tables();
9000     test_tables_order();
9001     test_rows_order();
9002     test_select_markers();
9003     test_viewmodify_update();
9004     test_viewmodify_assign();
9005     test_stringtable();
9006     test_viewmodify_delete();
9007     test_defaultdatabase();
9008     test_order();
9009     test_viewmodify_delete_temporary();
9010     test_deleterow();
9011     test_quotes();
9012     test_carriagereturn();
9013     test_noquotes();
9014     test_forcecodepage();
9015     test_viewmodify_refresh();
9016     test_where_viewmodify();
9017     test_storages_table();
9018     test_dbtopackage();
9019     test_droptable();
9020     test_dbmerge();
9021     test_select_with_tablenames();
9022     test_insertorder();
9023     test_columnorder();
9024     test_suminfo_import();
9025     test_createtable();
9026 }