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 <objidl.h>
  27 #include <msi.h>
  28 #include <msidefs.h>
  29 #include <msiquery.h>
  30
  31 #include "wine/test.h"
  32
  33 static const char *msifile = "winetest-db.msi";
  34 static const char *msifile2 = "winetst2-db.msi";
  35 static const char *mstfile = "winetst-db.mst";
  36 static const WCHAR msifileW[] = {'w','i','n','e','t','e','s','t','-','d','b','.','m','s','i',0};
  37 static const WCHAR msifile2W[] = {'w','i','n','e','t','s','t','2','-','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     DeleteFileW(msifileW);
  45
  46     res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb );
  47     ok( res == ERROR_OPEN_FAILED, "expected failure\n");
  48
  49     res = MsiOpenDatabaseW( msifileW, (LPWSTR)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 = MsiOpenDatabaseW(msifileW, 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( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
  63
  64     res = MsiCloseHandle( hdb );
  65     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  66     res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
  67     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  68
  69     ok( GetFileAttributesA( msifile2 ) != INVALID_FILE_ATTRIBUTES, "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 = MsiOpenDatabaseW( msifileW, msifile2W, &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( GetFileAttributesA( msifile2 ) == INVALID_FILE_ATTRIBUTES, "uncommitted database should not exist\n");
  84
  85     res = MsiOpenDatabaseW( msifileW, msifile2W, &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( GetFileAttributesA( msifile2 ) != INVALID_FILE_ATTRIBUTES, "committed database should exist\n");
  95
  96     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_READONLY, &hdb );
  97     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  98
  99     res = MsiDatabaseCommit( hdb );
 100     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 101
 102     res = MsiCloseHandle( hdb );
 103     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 104
 105     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_DIRECT, &hdb );
 106     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 107
 108     res = MsiCloseHandle( hdb );
 109     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 110
 111     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_TRANSACT, &hdb );
 112     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 113
 114     res = MsiCloseHandle( hdb );
 115     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 116     ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 117
 118     /* MSIDBOPEN_CREATE deletes the database if MsiCommitDatabase isn't called */
 119     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
 120     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 121
 122     ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 123
 124     res = MsiCloseHandle( hdb );
 125     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 126
 127     ok( GetFileAttributesA( msifile ) == INVALID_FILE_ATTRIBUTES, "database should exist\n");
 128
 129     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
 130     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 131
 132     res = MsiDatabaseCommit( hdb );
 133     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 134
 135     ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 136
 137     res = MsiCloseHandle( hdb );
 138     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 139
 140     res = DeleteFileA( msifile2 );
 141     ok( res == TRUE, "Failed to delete database\n" );
 142
 143     res = DeleteFileA( msifile );
 144     ok( res == TRUE, "Failed to delete database\n" );
 145 }
 146
 147 static UINT do_query(MSIHANDLE hdb, const char *query, MSIHANDLE *phrec)
 148 {
 149     MSIHANDLE hview = 0;
 150     UINT r, ret;
 151
 152     if (phrec)
 153         *phrec = 0;
 154
 155     /* open a select query */
 156     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 157     if (r != ERROR_SUCCESS)
 158         return r;
 159     r = MsiViewExecute(hview, 0);
 160     if (r != ERROR_SUCCESS)
 161         return r;
 162     ret = MsiViewFetch(hview, phrec);
 163     r = MsiViewClose(hview);
 164     if (r != ERROR_SUCCESS)
 165         return r;
 166     r = MsiCloseHandle(hview);
 167     if (r != ERROR_SUCCESS)
 168         return r;
 169     return ret;
 170 }
 171
 172 static UINT run_query( MSIHANDLE hdb, MSIHANDLE hrec, const char *query )
 173 {
 174     MSIHANDLE hview = 0;
 175     UINT r;
 176
 177     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 178     if( r != ERROR_SUCCESS )
 179         return r;
 180
 181     r = MsiViewExecute(hview, hrec);
 182     if( r == ERROR_SUCCESS )
 183         r = MsiViewClose(hview);
 184     MsiCloseHandle(hview);
 185     return r;
 186 }
 187
 188 static UINT run_queryW( MSIHANDLE hdb, MSIHANDLE hrec, const WCHAR *query )
 189 {
 190     MSIHANDLE hview = 0;
 191     UINT r;
 192
 193     r = MsiDatabaseOpenViewW(hdb, query, &hview);
 194     if( r != ERROR_SUCCESS )
 195         return r;
 196
 197     r = MsiViewExecute(hview, hrec);
 198     if( r == ERROR_SUCCESS )
 199         r = MsiViewClose(hview);
 200     MsiCloseHandle(hview);
 201     return r;
 202 }
 203
 204 static UINT create_component_table( MSIHANDLE hdb )
 205 {
 206     return run_query( hdb, 0,
 207             "CREATE TABLE `Component` ( "
 208             "`Component` CHAR(72) NOT NULL, "
 209             "`ComponentId` CHAR(38), "
 210             "`Directory_` CHAR(72) NOT NULL, "
 211             "`Attributes` SHORT NOT NULL, "
 212             "`Condition` CHAR(255), "
 213             "`KeyPath` CHAR(72) "
 214             "PRIMARY KEY `Component`)" );
 215 }
 216
 217 static UINT create_custom_action_table( MSIHANDLE hdb )
 218 {
 219     return run_query( hdb, 0,
 220             "CREATE TABLE `CustomAction` ( "
 221             "`Action` CHAR(72) NOT NULL, "
 222             "`Type` SHORT NOT NULL, "
 223             "`Source` CHAR(72), "
 224             "`Target` CHAR(255) "
 225             "PRIMARY KEY `Action`)" );
 226 }
 227
 228 static UINT create_directory_table( MSIHANDLE hdb )
 229 {
 230     return run_query( hdb, 0,
 231             "CREATE TABLE `Directory` ( "
 232             "`Directory` CHAR(255) NOT NULL, "
 233             "`Directory_Parent` CHAR(255), "
 234             "`DefaultDir` CHAR(255) NOT NULL "
 235             "PRIMARY KEY `Directory`)" );
 236 }
 237
 238 static UINT create_feature_components_table( MSIHANDLE hdb )
 239 {
 240     return run_query( hdb, 0,
 241             "CREATE TABLE `FeatureComponents` ( "
 242             "`Feature_` CHAR(38) NOT NULL, "
 243             "`Component_` CHAR(72) NOT NULL "
 244             "PRIMARY KEY `Feature_`, `Component_` )" );
 245 }
 246
 247 static UINT create_std_dlls_table( MSIHANDLE hdb )
 248 {
 249     return run_query( hdb, 0,
 250             "CREATE TABLE `StdDlls` ( "
 251             "`File` CHAR(255) NOT NULL, "
 252             "`Binary_` CHAR(72) NOT NULL "
 253             "PRIMARY KEY `File` )" );
 254 }
 255
 256 static UINT create_binary_table( MSIHANDLE hdb )
 257 {
 258     return run_query( hdb, 0,
 259             "CREATE TABLE `Binary` ( "
 260             "`Name` CHAR(72) NOT NULL, "
 261             "`Data` CHAR(72) NOT NULL "
 262             "PRIMARY KEY `Name` )" );
 263 }
 264
 265 #define make_add_entry(type, qtext) \
 266     static UINT add##_##type##_##entry( MSIHANDLE hdb, const char *values ) \
 267     { \
 268         char insert[] = qtext; \
 269         char *query; \
 270         UINT sz, r; \
 271         sz = strlen(values) + sizeof insert; \
 272         query = HeapAlloc(GetProcessHeap(),0,sz); \
 273         sprintf(query,insert,values); \
 274         r = run_query( hdb, 0, query ); \
 275         HeapFree(GetProcessHeap(), 0, query); \
 276         return r; \
 277     }
 278
 279 make_add_entry(component,
 280                "INSERT INTO `Component`  "
 281                "(`Component`, `ComponentId`, `Directory_`, "
 282                "`Attributes`, `Condition`, `KeyPath`) VALUES( %s )")
 283
 284 make_add_entry(custom_action,
 285                "INSERT INTO `CustomAction`  "
 286                "(`Action`, `Type`, `Source`, `Target`) VALUES( %s )")
 287
 288 make_add_entry(feature_components,
 289                "INSERT INTO `FeatureComponents` "
 290                "(`Feature_`, `Component_`) VALUES( %s )")
 291
 292 make_add_entry(std_dlls,
 293                "INSERT INTO `StdDlls` (`File`, `Binary_`) VALUES( %s )")
 294
 295 make_add_entry(binary,
 296                "INSERT INTO `Binary` (`Name`, `Data`) VALUES( %s )")
 297
 298 static void test_msiinsert(void)
 299 {
 300     MSIHANDLE hdb = 0, hview = 0, hview2 = 0, hrec = 0;
 301     UINT r;
 302     const char *query;
 303     char buf[80];
 304     DWORD sz;
 305
 306     DeleteFileA(msifile);
 307
 308     /* just MsiOpenDatabase should not create a file */
 309     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
 310     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 311
 312     /* create a table */
 313     query = "CREATE TABLE `phone` ( "
 314             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 315             "PRIMARY KEY `id`)";
 316     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 317     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 318     r = MsiViewExecute(hview, 0);
 319     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 320     r = MsiViewClose(hview);
 321     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 322     r = MsiCloseHandle(hview);
 323     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 324
 325     query = "SELECT * FROM phone WHERE number = '8675309'";
 326     r = MsiDatabaseOpenViewA(hdb, query, &hview2);
 327     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 328     r = MsiViewExecute(hview2, 0);
 329     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 330     r = MsiViewFetch(hview2, &hrec);
 331     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch produced items\n");
 332
 333     /* insert a value into it */
 334     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 335         "VALUES('1', 'Abe', '8675309')";
 336     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 337     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 338     r = MsiViewExecute(hview, 0);
 339     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 340     r = MsiViewClose(hview);
 341     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 342     r = MsiCloseHandle(hview);
 343     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 344
 345     r = MsiViewFetch(hview2, &hrec);
 346     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch produced items\n");
 347     r = MsiViewExecute(hview2, 0);
 348     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 349     r = MsiViewFetch(hview2, &hrec);
 350     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %u\n", r);
 351
 352     r = MsiCloseHandle(hrec);
 353     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 354     r = MsiViewClose(hview2);
 355     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 356     r = MsiCloseHandle(hview2);
 357     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 358
 359     query = "SELECT * FROM `phone` WHERE `id` = 1";
 360     r = do_query(hdb, query, &hrec);
 361     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 362
 363     /* check the record contains what we put in it */
 364     r = MsiRecordGetFieldCount(hrec);
 365     ok(r == 3, "record count wrong\n");
 366
 367     r = MsiRecordIsNull(hrec, 0);
 368     ok(r == FALSE, "field 0 not null\n");
 369
 370     r = MsiRecordGetInteger(hrec, 1);
 371     ok(r == 1, "field 1 contents wrong\n");
 372     sz = sizeof buf;
 373     r = MsiRecordGetStringA(hrec, 2, buf, &sz);
 374     ok(r == ERROR_SUCCESS, "field 2 content fetch failed\n");
 375     ok(!strcmp(buf,"Abe"), "field 2 content incorrect\n");
 376     sz = sizeof buf;
 377     r = MsiRecordGetStringA(hrec, 3, buf, &sz);
 378     ok(r == ERROR_SUCCESS, "field 3 content fetch failed\n");
 379     ok(!strcmp(buf,"8675309"), "field 3 content incorrect\n");
 380
 381     r = MsiCloseHandle(hrec);
 382     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 383
 384     /* open a select query */
 385     hrec = 100;
 386     query = "SELECT * FROM `phone` WHERE `id` >= 10";
 387     r = do_query(hdb, query, &hrec);
 388     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 389     ok(hrec == 0, "hrec should be null\n");
 390
 391     r = MsiCloseHandle(hrec);
 392     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 393
 394     query = "SELECT * FROM `phone` WHERE `id` < 0";
 395     r = do_query(hdb, query, &hrec);
 396     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 397
 398     query = "SELECT * FROM `phone` WHERE `id` <= 0";
 399     r = do_query(hdb, query, &hrec);
 400     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 401
 402     query = "SELECT * FROM `phone` WHERE `id` <> 1";
 403     r = do_query(hdb, query, &hrec);
 404     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 405
 406     query = "SELECT * FROM `phone` WHERE `id` > 10";
 407     r = do_query(hdb, query, &hrec);
 408     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 409
 410     /* now try a few bad INSERT xqueries */
 411     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 412         "VALUES(?, ?)";
 413     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 414     ok(r == ERROR_BAD_QUERY_SYNTAX, "MsiDatabaseOpenView failed\n");
 415
 416     /* construct a record to insert */
 417     hrec = MsiCreateRecord(4);
 418     r = MsiRecordSetInteger(hrec, 1, 2);
 419     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 420     r = MsiRecordSetStringA(hrec, 2, "Adam");
 421     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 422     r = MsiRecordSetStringA(hrec, 3, "96905305");
 423     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 424
 425     /* insert another value, using a record and wildcards */
 426     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 427         "VALUES(?, ?, ?)";
 428     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 429     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 430
 431     if (r == ERROR_SUCCESS)
 432     {
 433         r = MsiViewExecute(hview, hrec);
 434         ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 435         r = MsiViewClose(hview);
 436         ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 437         r = MsiCloseHandle(hview);
 438         ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 439     }
 440     r = MsiCloseHandle(hrec);
 441     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 442
 443     r = MsiViewFetch(0, NULL);
 444     ok(r == ERROR_INVALID_PARAMETER, "MsiViewFetch failed\n");
 445
 446     r = MsiDatabaseCommit(hdb);
 447     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
 448
 449     r = MsiCloseHandle(hdb);
 450     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 451
 452     r = DeleteFileA(msifile);
 453     ok(r == TRUE, "file didn't exist after commit\n");
 454 }
 455
 456 static void test_msidecomposedesc(void)
 457 {
 458     UINT (WINAPI *pMsiDecomposeDescriptorA)(LPCSTR, LPCSTR, LPSTR, LPSTR, DWORD *);
 459     char prod[MAX_FEATURE_CHARS+1], comp[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1];
 460     const char *desc;
 461     UINT r;
 462     DWORD len;
 463     HMODULE hmod;
 464
 465     hmod = GetModuleHandleA("msi.dll");
 466     pMsiDecomposeDescriptorA = (void*)GetProcAddress(hmod, "MsiDecomposeDescriptorA");
 467     if (!pMsiDecomposeDescriptorA)
 468         return;
 469
 470     /* test a valid feature descriptor */
 471     desc = "']gAVn-}f(ZXfeAR6.jiFollowTheWhiteRabbit>3w2x^IGfe?CxI5heAvk.";
 472     len = 0;
 473     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 474     ok(r == ERROR_SUCCESS, "returned an error\n");
 475     ok(len == strlen(desc), "length was wrong\n");
 476     ok(strcmp(prod,"{90110409-6000-11D3-8CFE-0150048383C9}")==0, "product wrong\n");
 477     ok(strcmp(feature,"FollowTheWhiteRabbit")==0, "feature wrong\n");
 478     ok(strcmp(comp,"{A7CD68DB-EF74-49C8-FBB2-A7C463B2AC24}")==0,"component wrong\n");
 479
 480     /* test an invalid feature descriptor with too many characters */
 481     desc = "']gAVn-}f(ZXfeAR6.ji"
 482            "ThisWillFailIfTheresMoreThanAGuidsChars>"
 483            "3w2x^IGfe?CxI5heAvk.";
 484     len = 0;
 485     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 486     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 487
 488     /*
 489      * Test a valid feature descriptor with the
 490      * maximum number of characters and some trailing characters.
 491      */
 492     desc = "']gAVn-}f(ZXfeAR6.ji"
 493            "ThisWillWorkIfTheresLTEThanAGuidsChars>"
 494            "3w2x^IGfe?CxI5heAvk."
 495            "extra";
 496     len = 0;
 497     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 498     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 499     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 500
 501     len = 0;
 502     r = pMsiDecomposeDescriptorA(desc, prod, feature, NULL, &len);
 503     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 504     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 505
 506     len = 0;
 507     r = pMsiDecomposeDescriptorA(desc, prod, NULL, NULL, &len);
 508     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 509     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 510
 511     len = 0;
 512     r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, &len);
 513     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 514     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 515
 516     len = 0;
 517     r = pMsiDecomposeDescriptorA(NULL, NULL, NULL, NULL, &len);
 518     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 519     ok(len == 0, "length wrong\n");
 520
 521     r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, NULL);
 522     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 523 }
 524
 525 static UINT try_query_param( MSIHANDLE hdb, LPCSTR szQuery, MSIHANDLE hrec )
 526 {
 527     MSIHANDLE htab = 0;
 528     UINT res;
 529
 530     res = MsiDatabaseOpenViewA( hdb, szQuery, &htab );
 531     if(res == ERROR_SUCCESS )
 532     {
 533         UINT r;
 534
 535         r = MsiViewExecute( htab, hrec );
 536         if(r != ERROR_SUCCESS )
 537             res = r;
 538
 539         r = MsiViewClose( htab );
 540         if(r != ERROR_SUCCESS )
 541             res = r;
 542
 543         r = MsiCloseHandle( htab );
 544         if(r != ERROR_SUCCESS )
 545             res = r;
 546     }
 547     return res;
 548 }
 549
 550 static UINT try_query( MSIHANDLE hdb, LPCSTR szQuery )
 551 {
 552     return try_query_param( hdb, szQuery, 0 );
 553 }
 554
 555 static UINT try_insert_query( MSIHANDLE hdb, LPCSTR szQuery )
 556 {
 557     MSIHANDLE hrec = 0;
 558     UINT r;
 559
 560     hrec = MsiCreateRecord( 1 );
 561     MsiRecordSetStringA( hrec, 1, "Hello");
 562
 563     r = try_query_param( hdb, szQuery, hrec );
 564
 565     MsiCloseHandle( hrec );
 566     return r;
 567 }
 568
 569 static void test_msibadqueries(void)
 570 {
 571     MSIHANDLE hdb = 0;
 572     UINT r;
 573
 574     DeleteFileA(msifile);
 575
 576     /* just MsiOpenDatabase should not create a file */
 577     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
 578     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 579
 580     r = MsiDatabaseCommit( hdb );
 581     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
 582
 583     r = MsiCloseHandle( hdb );
 584     ok(r == ERROR_SUCCESS , "Failed to close database\n");
 585
 586     /* open it readonly */
 587     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb );
 588     ok(r == ERROR_SUCCESS , "Failed to open database r/o\n");
 589
 590     /* add a table to it */
 591     r = try_query( hdb, "select * from _Tables");
 592     ok(r == ERROR_SUCCESS , "query 1 failed\n");
 593
 594     r = MsiCloseHandle( hdb );
 595     ok(r == ERROR_SUCCESS , "Failed to close database r/o\n");
 596
 597     /* open it read/write */
 598     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
 599     ok(r == ERROR_SUCCESS , "Failed to open database r/w\n");
 600
 601     /* a bunch of test queries that fail with the native MSI */
 602
 603     r = try_query( hdb, "CREATE TABLE");
 604     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2a return code\n");
 605
 606     r = try_query( hdb, "CREATE TABLE `a`");
 607     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2b return code\n");
 608
 609     r = try_query( hdb, "CREATE TABLE `a` ()");
 610     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2c return code\n");
 611
 612     r = try_query( hdb, "CREATE TABLE `a` (`b`)");
 613     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2d return code\n");
 614
 615     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) )");
 616     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2e return code\n");
 617
 618     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL)");
 619     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2f return code\n");
 620
 621     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY)");
 622     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2g return code\n");
 623
 624     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 625     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2h return code\n");
 626
 627     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 628     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2i return code\n");
 629
 630     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY 'b')");
 631     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2j return code\n");
 632
 633     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 634     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2k return code\n");
 635
 636     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 637     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2l return code\n");
 638
 639     r = try_query( hdb, "CREATE TABLE `a` (`b` CHA(72) NOT NULL PRIMARY KEY `b`)");
 640     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2m return code\n");
 641
 642     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(-1) NOT NULL PRIMARY KEY `b`)");
 643     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2n return code\n");
 644
 645     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(720) NOT NULL PRIMARY KEY `b`)");
 646     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2o return code\n");
 647
 648     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL KEY `b`)");
 649     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 650
 651     r = try_query( hdb, "CREATE TABLE `a` (`` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 652     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 653
 654     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 655     ok(r == ERROR_SUCCESS , "valid query 2z failed\n");
 656
 657     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 658     ok(r == ERROR_BAD_QUERY_SYNTAX , "created same table again\n");
 659
 660     r = try_query( hdb, "CREATE TABLE `aa` (`b` CHAR(72) NOT NULL, `c` "
 661           "CHAR(72), `d` CHAR(255) NOT NULL LOCALIZABLE PRIMARY KEY `b`)");
 662     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 663
 664     r = MsiDatabaseCommit( hdb );
 665     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 666
 667     r = try_query( hdb, "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL "
 668                           "PRIMARY KEY `foo`)");
 669     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 670
 671     r = try_insert_query( hdb, "insert into a  ( `b` ) VALUES ( ? )");
 672     ok(r == ERROR_SUCCESS , "failed to insert record in db\n");
 673
 674     r = MsiDatabaseCommit( hdb );
 675     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 676
 677     r = try_query( hdb, "CREATE TABLE `boo` (`foo` CHAR(72) NOT NULL "
 678                           "PRIMARY KEY `ba`)");
 679     ok(r != ERROR_SUCCESS , "query 5 succeeded\n");
 680
 681     r = try_query( hdb,"CREATE TABLE `bee` (`foo` CHAR(72) NOT NULL )");
 682     ok(r != ERROR_SUCCESS , "query 6 succeeded\n");
 683
 684     r = try_query( hdb, "CREATE TABLE `temp` (`t` CHAR(72) NOT NULL "
 685                           "PRIMARY KEY `t`)");
 686     ok(r == ERROR_SUCCESS , "query 7 failed\n");
 687
 688     r = try_query( hdb, "CREATE TABLE `c` (`b` CHAR NOT NULL PRIMARY KEY `b`)");
 689     ok(r == ERROR_SUCCESS , "query 8 failed\n");
 690
 691     r = try_query( hdb, "select * from c");
 692     ok(r == ERROR_SUCCESS , "query failed\n");
 693
 694     r = try_query( hdb, "select * from c where b = 'x");
 695     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 696
 697     r = try_query( hdb, "select * from c where b = 'x'");
 698     ok(r == ERROR_SUCCESS, "query failed\n");
 699
 700     r = try_query( hdb, "select * from 'c'");
 701     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 702
 703     r = try_query( hdb, "select * from ''");
 704     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 705
 706     r = try_query( hdb, "select * from c where b = x");
 707     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 708
 709     r = try_query( hdb, "select * from c where b = \"x\"");
 710     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 711
 712     r = try_query( hdb, "select * from c where b = 'x'");
 713     ok(r == ERROR_SUCCESS, "query failed\n");
 714
 715     r = try_query( hdb, "select * from c where b = '\"x'");
 716     ok(r == ERROR_SUCCESS, "query failed\n");
 717
 718     if (0)  /* FIXME: this query causes trouble with other tests */
 719     {
 720         r = try_query( hdb, "select * from c where b = '\\\'x'");
 721         ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 722     }
 723
 724     r = try_query( hdb, "select * from 'c'");
 725     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 726
 727     r = try_query( hdb, "select `c`.`b` from `c` order by `c`.`order`");
 728     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 729
 730     r = try_query( hdb, "select `c`.b` from `c`");
 731     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 732
 733     r = try_query( hdb, "select `c`.`b from `c`");
 734     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 735
 736     r = try_query( hdb, "select `c`.b from `c`");
 737     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 738
 739     r = try_query( hdb, "select `c.`b` from `c`");
 740     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 741
 742     r = try_query( hdb, "select c`.`b` from `c`");
 743     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 744
 745     r = try_query( hdb, "select c.`b` from `c`");
 746     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 747
 748     r = try_query( hdb, "select `c`.`b` from c`");
 749     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 750
 751     r = try_query( hdb, "select `c`.`b` from `c");
 752     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 753
 754     r = try_query( hdb, "select `c`.`b` from c");
 755     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 756
 757     r = try_query( hdb, "CREATE TABLE `\5a` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 758     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 759
 760     r = try_query( hdb, "SELECT * FROM \5a" );
 761     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 762
 763     r = try_query( hdb, "CREATE TABLE `a\5` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 764     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 765
 766     r = try_query( hdb, "SELECT * FROM a\5" );
 767     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 768
 769     r = try_query( hdb, "CREATE TABLE `-a` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 770     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 771
 772     r = try_query( hdb, "SELECT * FROM -a" );
 773     todo_wine ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 774
 775     r = try_query( hdb, "CREATE TABLE `a-` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 776     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 777
 778     r = try_query( hdb, "SELECT * FROM a-" );
 779     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 780
 781     r = MsiCloseHandle( hdb );
 782     ok(r == ERROR_SUCCESS , "Failed to close database transact\n");
 783
 784     r = DeleteFileA( msifile );
 785     ok(r == TRUE, "file didn't exist after commit\n");
 786 }
 787
 788 static void test_viewmodify(void)
 789 {
 790     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 791     UINT r;
 792     MSIDBERROR err;
 793     const char *query;
 794     char buffer[0x100];
 795     DWORD sz;
 796
 797     DeleteFileA(msifile);
 798
 799     /* just MsiOpenDatabase should not create a file */
 800     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
 801     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 802
 803     query = "CREATE TABLE `phone` ( "
 804             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 805             "PRIMARY KEY `id`)";
 806     r = run_query( hdb, 0, query );
 807     ok(r == ERROR_SUCCESS, "query failed\n");
 808
 809     query = "CREATE TABLE `_Validation` ( "
 810             "`Table` CHAR(32) NOT NULL, `Column` CHAR(32) NOT NULL, "
 811             "`Nullable` CHAR(4) NOT NULL, `MinValue` INT, `MaxValue` INT, "
 812             "`KeyTable` CHAR(255), `KeyColumn` SHORT, `Category` CHAR(32), "
 813             "`Set` CHAR(255), `Description` CHAR(255) PRIMARY KEY `Table`, `Column`)";
 814     r = run_query( hdb, 0, query );
 815     ok(r == ERROR_SUCCESS, "query failed\n");
 816
 817     query = "INSERT INTO `_Validation` ( `Table`, `Column`, `Nullable` ) "
 818             "VALUES('phone', 'id', 'N')";
 819     r = run_query( hdb, 0, query );
 820     ok(r == ERROR_SUCCESS, "query failed\n");
 821
 822     /* check what the error function reports without doing anything */
 823     sz = 0;
 824     /* passing NULL as the 3rd param make function to crash on older platforms */
 825     err = MsiViewGetErrorA( 0, NULL, &sz );
 826     ok(err == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 827
 828     /* open a view */
 829     query = "SELECT * FROM `phone`";
 830     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 831     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 832
 833     /* see what happens with a good hview and bad args */
 834     err = MsiViewGetErrorA( hview, NULL, NULL );
 835     ok(err == MSIDBERROR_INVALIDARG || err == MSIDBERROR_NOERROR,
 836        "MsiViewGetError returns %u (expected -3)\n", err);
 837     err = MsiViewGetErrorA( hview, buffer, NULL );
 838     ok(err == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 839
 840     /* see what happens with a zero length buffer */
 841     sz = 0;
 842     buffer[0] = 'x';
 843     err = MsiViewGetErrorA( hview, buffer, &sz );
 844     ok(err == MSIDBERROR_MOREDATA, "MsiViewGetError return\n");
 845     ok(buffer[0] == 'x', "buffer cleared\n");
 846     ok(sz == 0, "size not zero\n");
 847
 848     /* ok this one is strange */
 849     sz = 0;
 850     err = MsiViewGetErrorA( hview, NULL, &sz );
 851     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 852     ok(sz == 0, "size not zero\n");
 853
 854     /* see if it really has an error */
 855     sz = sizeof buffer;
 856     buffer[0] = 'x';
 857     err = MsiViewGetErrorA( hview, buffer, &sz );
 858     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 859     ok(buffer[0] == 0, "buffer not cleared\n");
 860     ok(sz == 0, "size not zero\n");
 861
 862     r = MsiViewExecute(hview, 0);
 863     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 864
 865     /* try some invalid records */
 866     r = MsiViewModify(hview, MSIMODIFY_INSERT, 0 );
 867     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 868     r = MsiViewModify(hview, -1, 0 );
 869     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 870
 871     /* try an small record */
 872     hrec = MsiCreateRecord(1);
 873     r = MsiViewModify(hview, -1, hrec );
 874     ok(r == ERROR_INVALID_DATA, "MsiViewModify failed\n");
 875
 876     sz = sizeof buffer;
 877     buffer[0] = 'x';
 878     err = MsiViewGetErrorA( hview, buffer, &sz );
 879     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 880     ok(buffer[0] == 0, "buffer not cleared\n");
 881     ok(sz == 0, "size not zero\n");
 882
 883     r = MsiCloseHandle(hrec);
 884     ok(r == ERROR_SUCCESS, "failed to close record\n");
 885
 886     /* insert a valid record */
 887     hrec = MsiCreateRecord(3);
 888
 889     r = MsiRecordSetInteger(hrec, 1, 1);
 890     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 891     r = MsiRecordSetStringA(hrec, 2, "bob");
 892     ok(r == ERROR_SUCCESS, "failed to set string\n");
 893     r = MsiRecordSetStringA(hrec, 3, "7654321");
 894     ok(r == ERROR_SUCCESS, "failed to set string\n");
 895
 896     r = MsiViewExecute(hview, 0);
 897     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 898     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 899     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 900
 901     /* validate it */
 902     r = MsiViewExecute(hview, 0);
 903     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 904
 905     r = MsiViewModify(hview, MSIMODIFY_VALIDATE_NEW, hrec );
 906     ok(r == ERROR_INVALID_DATA, "MsiViewModify failed %u\n", r);
 907
 908     sz = sizeof buffer;
 909     buffer[0] = 'x';
 910     err = MsiViewGetErrorA( hview, buffer, &sz );
 911     ok(err == MSIDBERROR_DUPLICATEKEY, "MsiViewGetError returned %u\n", err);
 912     ok(!strcmp(buffer, "id"), "expected \"id\" c, got \"%s\"\n", buffer);
 913     ok(sz == 2, "size not 2\n");
 914
 915     /* insert the same thing again */
 916     r = MsiViewExecute(hview, 0);
 917     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 918
 919     /* should fail ... */
 920     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 921     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 922
 923     /* try to merge the same record */
 924     r = MsiViewExecute(hview, 0);
 925     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 926     r = MsiViewModify(hview, MSIMODIFY_MERGE, hrec );
 927     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 928
 929     r = MsiCloseHandle(hrec);
 930     ok(r == ERROR_SUCCESS, "failed to close record\n");
 931
 932     /* try merging a new record */
 933     hrec = MsiCreateRecord(3);
 934
 935     r = MsiRecordSetInteger(hrec, 1, 10);
 936     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 937     r = MsiRecordSetStringA(hrec, 2, "pepe");
 938     ok(r == ERROR_SUCCESS, "failed to set string\n");
 939     r = MsiRecordSetStringA(hrec, 3, "7654321");
 940     ok(r == ERROR_SUCCESS, "failed to set string\n");
 941
 942     r = MsiViewModify(hview, MSIMODIFY_MERGE, hrec );
 943     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 944     r = MsiViewExecute(hview, 0);
 945     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 946
 947     r = MsiCloseHandle(hrec);
 948     ok(r == ERROR_SUCCESS, "failed to close record\n");
 949
 950     r = MsiViewClose(hview);
 951     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 952     r = MsiCloseHandle(hview);
 953     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 954
 955     query = "SELECT * FROM `phone`";
 956     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 957     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 958
 959     r = MsiViewExecute(hview, 0);
 960     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 961
 962     r = MsiViewFetch(hview, &hrec);
 963     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 964
 965     r = MsiRecordGetInteger(hrec, 1);
 966     ok(r == 1, "Expected 1, got %d\n", r);
 967
 968     sz = sizeof(buffer);
 969     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
 970     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 971     ok(!lstrcmpA(buffer, "bob"), "Expected bob, got %s\n", buffer);
 972
 973     sz = sizeof(buffer);
 974     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
 975     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 976     ok(!lstrcmpA(buffer, "7654321"), "Expected 7654321, got %s\n", buffer);
 977
 978     /* update the view, non-primary key */
 979     r = MsiRecordSetStringA(hrec, 3, "3141592");
 980     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 981
 982     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 983     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 984
 985     /* do it again */
 986     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 987     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
 988
 989     /* update the view, primary key */
 990     r = MsiRecordSetInteger(hrec, 1, 5);
 991     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 992
 993     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 994     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 995
 996     r = MsiCloseHandle(hrec);
 997     ok(r == ERROR_SUCCESS, "failed to close record\n");
 998
 999     r = MsiViewClose(hview);
1000     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1001     r = MsiCloseHandle(hview);
1002     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1003
1004     query = "SELECT * FROM `phone`";
1005     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1006     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1007
1008     r = MsiViewExecute(hview, 0);
1009     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1010
1011     r = MsiViewFetch(hview, &hrec);
1012     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1013
1014     r = MsiRecordGetInteger(hrec, 1);
1015     ok(r == 1, "Expected 1, got %d\n", r);
1016
1017     sz = sizeof(buffer);
1018     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
1019     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
1020     ok(!lstrcmpA(buffer, "bob"), "Expected bob, got %s\n", buffer);
1021
1022     sz = sizeof(buffer);
1023     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
1024     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
1025     ok(!lstrcmpA(buffer, "3141592"), "Expected 3141592, got %s\n", buffer);
1026
1027     r = MsiCloseHandle(hrec);
1028     ok(r == ERROR_SUCCESS, "failed to close record\n");
1029
1030     /* use a record that doesn't come from a view fetch */
1031     hrec = MsiCreateRecord(3);
1032     ok(hrec != 0, "MsiCreateRecord failed\n");
1033
1034     r = MsiRecordSetInteger(hrec, 1, 3);
1035     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1036     r = MsiRecordSetStringA(hrec, 2, "jane");
1037     ok(r == ERROR_SUCCESS, "failed to set string\n");
1038     r = MsiRecordSetStringA(hrec, 3, "112358");
1039     ok(r == ERROR_SUCCESS, "failed to set string\n");
1040
1041     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
1042     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
1043
1044     r = MsiCloseHandle(hrec);
1045     ok(r == ERROR_SUCCESS, "failed to close record\n");
1046
1047     /* use a record that doesn't come from a view fetch, primary key matches */
1048     hrec = MsiCreateRecord(3);
1049     ok(hrec != 0, "MsiCreateRecord failed\n");
1050
1051     r = MsiRecordSetInteger(hrec, 1, 1);
1052     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1053     r = MsiRecordSetStringA(hrec, 2, "jane");
1054     ok(r == ERROR_SUCCESS, "failed to set string\n");
1055     r = MsiRecordSetStringA(hrec, 3, "112358");
1056     ok(r == ERROR_SUCCESS, "failed to set string\n");
1057
1058     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
1059     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
1060
1061     r = MsiCloseHandle(hrec);
1062     ok(r == ERROR_SUCCESS, "failed to close record\n");
1063
1064     hrec = MsiCreateRecord(3);
1065
1066     r = MsiRecordSetInteger(hrec, 1, 2);
1067     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1068     r = MsiRecordSetStringA(hrec, 2, "nick");
1069     ok(r == ERROR_SUCCESS, "failed to set string\n");
1070     r = MsiRecordSetStringA(hrec, 3, "141421");
1071     ok(r == ERROR_SUCCESS, "failed to set string\n");
1072
1073     r = MsiViewExecute(hview, 0);
1074     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1075     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
1076     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
1077
1078     r = MsiCloseHandle(hrec);
1079     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1080     r = MsiViewClose(hview);
1081     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1082     r = MsiCloseHandle(hview);
1083     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1084
1085     query = "SELECT * FROM `phone` WHERE `id` = 1";
1086     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1087     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1088     r = MsiViewExecute(hview, 0);
1089     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1090     r = MsiViewFetch(hview, &hrec);
1091     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1092
1093     /* change the id to match the second row */
1094     r = MsiRecordSetInteger(hrec, 1, 2);
1095     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1096     r = MsiRecordSetStringA(hrec, 2, "jerry");
1097     ok(r == ERROR_SUCCESS, "failed to set string\n");
1098
1099     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
1100     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
1101
1102     r = MsiCloseHandle(hrec);
1103     ok(r == ERROR_SUCCESS, "failed to close record\n");
1104     r = MsiViewClose(hview);
1105     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1106     r = MsiCloseHandle(hview);
1107     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1108
1109     /* broader search */
1110     query = "SELECT * FROM `phone` ORDER BY `id`";
1111     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1112     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1113     r = MsiViewExecute(hview, 0);
1114     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1115     r = MsiViewFetch(hview, &hrec);
1116     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1117
1118     /* change the id to match the second row */
1119     r = MsiRecordSetInteger(hrec, 1, 2);
1120     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1121     r = MsiRecordSetStringA(hrec, 2, "jerry");
1122     ok(r == ERROR_SUCCESS, "failed to set string\n");
1123
1124     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
1125     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
1126
1127     r = MsiCloseHandle(hrec);
1128     ok(r == ERROR_SUCCESS, "failed to close record\n");
1129     r = MsiViewClose(hview);
1130     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1131     r = MsiCloseHandle(hview);
1132     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1133
1134     r = MsiCloseHandle( hdb );
1135     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
1136 }
1137
1138 static MSIHANDLE create_db(void)
1139 {
1140     MSIHANDLE hdb = 0;
1141     UINT res;
1142
1143     DeleteFileW(msifileW);
1144
1145     /* create an empty database */
1146     res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
1147     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
1148     if( res != ERROR_SUCCESS )
1149         return hdb;
1150
1151     res = MsiDatabaseCommit( hdb );
1152     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
1153
1154     return hdb;
1155 }
1156
1157 static void test_getcolinfo(void)
1158 {
1159     MSIHANDLE hdb, hview = 0, rec = 0;
1160     UINT r;
1161     DWORD sz;
1162     char buffer[0x20];
1163
1164     /* create an empty db */
1165     hdb = create_db();
1166     ok( hdb, "failed to create db\n");
1167
1168     /* tables should be present */
1169     r = MsiDatabaseOpenViewA(hdb, "select * from _Tables", &hview);
1170     ok( r == ERROR_SUCCESS, "failed to open query\n");
1171
1172     r = MsiViewExecute(hview, 0);
1173     ok( r == ERROR_SUCCESS, "failed to execute query\n");
1174
1175     /* check that NAMES works */
1176     rec = 0;
1177     r = MsiViewGetColumnInfo( hview, MSICOLINFO_NAMES, &rec );
1178     ok( r == ERROR_SUCCESS, "failed to get names\n");
1179     sz = sizeof buffer;
1180     r = MsiRecordGetStringA(rec, 1, buffer, &sz );
1181     ok( r == ERROR_SUCCESS, "failed to get string\n");
1182     ok( !strcmp(buffer,"Name"), "_Tables has wrong column name\n");
1183     r = MsiCloseHandle( rec );
1184     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
1185
1186     /* check that TYPES works */
1187     rec = 0;
1188     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, &rec );
1189     ok( r == ERROR_SUCCESS, "failed to get names\n");
1190     sz = sizeof buffer;
1191     r = MsiRecordGetStringA(rec, 1, buffer, &sz );
1192     ok( r == ERROR_SUCCESS, "failed to get string\n");
1193     ok( !strcmp(buffer,"s64"), "_Tables has wrong column type\n");
1194     r = MsiCloseHandle( rec );
1195     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
1196
1197     /* check that invalid values fail */
1198     rec = 0;
1199     r = MsiViewGetColumnInfo( hview, 100, &rec );
1200     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
1201     ok( rec == 0, "returned a record\n");
1202
1203     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, NULL );
1204     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
1205
1206     r = MsiViewGetColumnInfo( 0, MSICOLINFO_TYPES, &rec );
1207     ok( r == ERROR_INVALID_HANDLE, "wrong error code\n");
1208
1209     r = MsiViewClose(hview);
1210     ok( r == ERROR_SUCCESS, "failed to close view\n");
1211     r = MsiCloseHandle(hview);
1212     ok( r == ERROR_SUCCESS, "failed to close view handle\n");
1213     r = MsiCloseHandle(hdb);
1214     ok( r == ERROR_SUCCESS, "failed to close database\n");
1215 }
1216
1217 static MSIHANDLE get_column_info(MSIHANDLE hdb, const char *query, MSICOLINFO type)
1218 {
1219     MSIHANDLE hview = 0, rec = 0;
1220     UINT r;
1221
1222     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1223     if( r != ERROR_SUCCESS )
1224         return r;
1225
1226     r = MsiViewExecute(hview, 0);
1227     if( r == ERROR_SUCCESS )
1228     {
1229         MsiViewGetColumnInfo( hview, type, &rec );
1230     }
1231     MsiViewClose(hview);
1232     MsiCloseHandle(hview);
1233     return rec;
1234 }
1235
1236 static UINT get_columns_table_type(MSIHANDLE hdb, const char *table, UINT field)
1237 {
1238     MSIHANDLE hview = 0, rec = 0;
1239     UINT r, type = 0;
1240     char query[0x100];
1241
1242     sprintf(query, "select * from `_Columns` where  `Table` = '%s'", table );
1243
1244     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1245     if( r != ERROR_SUCCESS )
1246         return r;
1247
1248     r = MsiViewExecute(hview, 0);
1249     if( r == ERROR_SUCCESS )
1250     {
1251         while (1)
1252         {
1253             r = MsiViewFetch( hview, &rec );
1254             if( r != ERROR_SUCCESS)
1255                 break;
1256             r = MsiRecordGetInteger( rec, 2 );
1257             if (r == field)
1258                 type = MsiRecordGetInteger( rec, 4 );
1259             MsiCloseHandle( rec );
1260         }
1261     }
1262     MsiViewClose(hview);
1263     MsiCloseHandle(hview);
1264     return type;
1265 }
1266
1267 static BOOL check_record( MSIHANDLE rec, UINT field, LPCSTR val )
1268 {
1269     CHAR buffer[0x20];
1270     UINT r;
1271     DWORD sz;
1272
1273     sz = sizeof buffer;
1274     r = MsiRecordGetStringA( rec, field, buffer, &sz );
1275     return (r == ERROR_SUCCESS ) && !strcmp(val, buffer);
1276 }
1277
1278 static void test_viewgetcolumninfo(void)
1279 {
1280     MSIHANDLE hdb = 0, rec;
1281     UINT r;
1282
1283     hdb = create_db();
1284     ok( hdb, "failed to create db\n");
1285
1286     r = run_query( hdb, 0,
1287             "CREATE TABLE `Properties` "
1288             "( `Property` CHAR(255), "
1289             "  `Value` CHAR(1), "
1290             "  `Intvalue` INT, "
1291             "  `Integervalue` INTEGER, "
1292             "  `Shortvalue` SHORT, "
1293             "  `Longvalue` LONG, "
1294             "  `Longcharvalue` LONGCHAR "
1295             "  PRIMARY KEY `Property`)" );
1296     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1297
1298     /* check the column types */
1299     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_TYPES );
1300     ok( rec, "failed to get column info record\n" );
1301
1302     ok( check_record( rec, 1, "S255"), "wrong record type\n");
1303     ok( check_record( rec, 2, "S1"), "wrong record type\n");
1304     ok( check_record( rec, 3, "I2"), "wrong record type\n");
1305     ok( check_record( rec, 4, "I2"), "wrong record type\n");
1306     ok( check_record( rec, 5, "I2"), "wrong record type\n");
1307     ok( check_record( rec, 6, "I4"), "wrong record type\n");
1308     ok( check_record( rec, 7, "S0"), "wrong record type\n");
1309
1310     MsiCloseHandle( rec );
1311
1312     /* check the type in _Columns */
1313     ok( 0x3dff == get_columns_table_type(hdb, "Properties", 1 ), "_columns table wrong\n");
1314     ok( 0x1d01 == get_columns_table_type(hdb, "Properties", 2 ), "_columns table wrong\n");
1315     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 3 ), "_columns table wrong\n");
1316     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 4 ), "_columns table wrong\n");
1317     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 5 ), "_columns table wrong\n");
1318     ok( 0x1104 == get_columns_table_type(hdb, "Properties", 6 ), "_columns table wrong\n");
1319     ok( 0x1d00 == get_columns_table_type(hdb, "Properties", 7 ), "_columns table wrong\n");
1320
1321     /* now try the names */
1322     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_NAMES );
1323     ok( rec, "failed to get column info record\n" );
1324
1325     ok( check_record( rec, 1, "Property"), "wrong record type\n");
1326     ok( check_record( rec, 2, "Value"), "wrong record type\n");
1327     ok( check_record( rec, 3, "Intvalue"), "wrong record type\n");
1328     ok( check_record( rec, 4, "Integervalue"), "wrong record type\n");
1329     ok( check_record( rec, 5, "Shortvalue"), "wrong record type\n");
1330     ok( check_record( rec, 6, "Longvalue"), "wrong record type\n");
1331     ok( check_record( rec, 7, "Longcharvalue"), "wrong record type\n");
1332
1333     MsiCloseHandle( rec );
1334
1335     r = run_query( hdb, 0,
1336             "CREATE TABLE `Binary` "
1337             "( `Name` CHAR(255), `Data` OBJECT  PRIMARY KEY `Name`)" );
1338     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1339
1340     /* check the column types */
1341     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_TYPES );
1342     ok( rec, "failed to get column info record\n" );
1343
1344     ok( check_record( rec, 1, "S255"), "wrong record type\n");
1345     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1346
1347     MsiCloseHandle( rec );
1348
1349     /* check the type in _Columns */
1350     ok( 0x3dff == get_columns_table_type(hdb, "Binary", 1 ), "_columns table wrong\n");
1351     ok( 0x1900 == get_columns_table_type(hdb, "Binary", 2 ), "_columns table wrong\n");
1352
1353     /* now try the names */
1354     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_NAMES );
1355     ok( rec, "failed to get column info record\n" );
1356
1357     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1358     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1359     MsiCloseHandle( rec );
1360
1361     r = run_query( hdb, 0,
1362             "CREATE TABLE `UIText` "
1363             "( `Key` CHAR(72) NOT NULL, `Text` CHAR(255) LOCALIZABLE PRIMARY KEY `Key`)" );
1364     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1365
1366     ok( 0x2d48 == get_columns_table_type(hdb, "UIText", 1 ), "_columns table wrong\n");
1367     ok( 0x1fff == get_columns_table_type(hdb, "UIText", 2 ), "_columns table wrong\n");
1368
1369     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_NAMES );
1370     ok( rec, "failed to get column info record\n" );
1371     ok( check_record( rec, 1, "Key"), "wrong record type\n");
1372     ok( check_record( rec, 2, "Text"), "wrong record type\n");
1373     MsiCloseHandle( rec );
1374
1375     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_TYPES );
1376     ok( rec, "failed to get column info record\n" );
1377     ok( check_record( rec, 1, "s72"), "wrong record type\n");
1378     ok( check_record( rec, 2, "L255"), "wrong record type\n");
1379     MsiCloseHandle( rec );
1380
1381     MsiCloseHandle( hdb );
1382 }
1383
1384 static void test_msiexport(void)
1385 {
1386     MSIHANDLE hdb = 0, hview = 0;
1387     UINT r;
1388     const char *query;
1389     char path[MAX_PATH];
1390     const char file[] = "phone.txt";
1391     HANDLE handle;
1392     char buffer[0x100];
1393     DWORD length;
1394     const char expected[] =
1395         "id\tname\tnumber\r\n"
1396         "I2\tS32\tS32\r\n"
1397         "phone\tid\r\n"
1398         "1\tAbe\t8675309\r\n";
1399
1400     DeleteFileW(msifileW);
1401
1402     /* just MsiOpenDatabase should not create a file */
1403     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
1404     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1405
1406     /* create a table */
1407     query = "CREATE TABLE `phone` ( "
1408             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
1409             "PRIMARY KEY `id`)";
1410     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1411     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1412     r = MsiViewExecute(hview, 0);
1413     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1414     r = MsiViewClose(hview);
1415     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1416     r = MsiCloseHandle(hview);
1417     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1418
1419     /* insert a value into it */
1420     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
1421         "VALUES('1', 'Abe', '8675309')";
1422     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1423     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1424     r = MsiViewExecute(hview, 0);
1425     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1426     r = MsiViewClose(hview);
1427     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1428     r = MsiCloseHandle(hview);
1429     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1430
1431     GetCurrentDirectoryA(MAX_PATH, path);
1432
1433     r = MsiDatabaseExportA(hdb, "phone", path, file);
1434     ok(r == ERROR_SUCCESS, "MsiDatabaseExport failed\n");
1435
1436     MsiCloseHandle(hdb);
1437
1438     lstrcatA(path, "\\");
1439     lstrcatA(path, file);
1440
1441     /* check the data that was written */
1442     length = 0;
1443     memset(buffer, 0, sizeof buffer);
1444     handle = CreateFileA(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
1445     if (handle != INVALID_HANDLE_VALUE)
1446     {
1447         ReadFile(handle, buffer, sizeof buffer, &length, NULL);
1448         CloseHandle(handle);
1449         DeleteFileA(path);
1450     }
1451     else
1452         ok(0, "failed to open file %s\n", path);
1453
1454     ok( length == strlen(expected), "length of data wrong\n");
1455     ok( !lstrcmpA(buffer, expected), "data doesn't match\n");
1456     DeleteFileA(msifile);
1457 }
1458
1459 static void test_longstrings(void)
1460 {
1461     const char insert_query[] =
1462         "INSERT INTO `strings` ( `id`, `val` ) VALUES('1', 'Z')";
1463     char *str;
1464     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
1465     DWORD len;
1466     UINT r;
1467     const DWORD STRING_LENGTH = 0x10005;
1468
1469     DeleteFileW(msifileW);
1470     /* just MsiOpenDatabase should not create a file */
1471     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
1472     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1473
1474     /* create a table */
1475     r = try_query( hdb,
1476         "CREATE TABLE `strings` ( `id` INT, `val` CHAR(0) PRIMARY KEY `id`)");
1477     ok(r == ERROR_SUCCESS, "query failed\n");
1478
1479     /* try to insert a very long string */
1480     str = HeapAlloc(GetProcessHeap(), 0, STRING_LENGTH+sizeof insert_query);
1481     len = strchr(insert_query, 'Z') - insert_query;
1482     strcpy(str, insert_query);
1483     memset(str+len, 'Z', STRING_LENGTH);
1484     strcpy(str+len+STRING_LENGTH, insert_query+len+1);
1485     r = try_query( hdb, str );
1486     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1487
1488     HeapFree(GetProcessHeap(), 0, str);
1489
1490     r = MsiDatabaseCommit(hdb);
1491     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
1492     MsiCloseHandle(hdb);
1493
1494     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
1495     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1496
1497     r = MsiDatabaseOpenViewA(hdb, "select * from `strings` where `id` = 1", &hview);
1498     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1499
1500     r = MsiViewExecute(hview, 0);
1501     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1502
1503     r = MsiViewFetch(hview, &hrec);
1504     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1505
1506     MsiViewClose(hview);
1507     MsiCloseHandle(hview);
1508
1509     r = MsiRecordGetStringA(hrec, 2, NULL, &len);
1510     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1511     ok(len == STRING_LENGTH, "string length wrong\n");
1512
1513     MsiCloseHandle(hrec);
1514     MsiCloseHandle(hdb);
1515     DeleteFileA(msifile);
1516 }
1517
1518 static void create_file_data(LPCSTR name, LPCSTR data, DWORD size)
1519 {
1520     HANDLE file;
1521     DWORD written;
1522
1523     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
1524     if (file == INVALID_HANDLE_VALUE)
1525         return;
1526
1527     WriteFile(file, data, strlen(data), &written, NULL);
1528     WriteFile(file, "\n", strlen("\n"), &written, NULL);
1529
1530     if (size)
1531     {
1532         SetFilePointer(file, size, NULL, FILE_BEGIN);
1533         SetEndOfFile(file);
1534     }
1535
1536     CloseHandle(file);
1537 }
1538
1539 #define create_file(name) create_file_data(name, name, 0)
1540
1541 static void test_streamtable(void)
1542 {
1543     MSIHANDLE hdb = 0, rec, view, hsi;
1544     char file[MAX_PATH];
1545     char buf[MAX_PATH];
1546     DWORD size;
1547     UINT r;
1548
1549     hdb = create_db();
1550     ok( hdb, "failed to create db\n");
1551
1552     r = run_query( hdb, 0,
1553             "CREATE TABLE `Properties` "
1554             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
1555     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1556
1557     r = run_query( hdb, 0,
1558             "INSERT INTO `Properties` "
1559             "( `Value`, `Property` ) VALUES ( 'Prop', 'value' )" );
1560     ok( r == ERROR_SUCCESS, "Failed to add to table\n" );
1561
1562     r = MsiDatabaseCommit( hdb );
1563     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1564
1565     MsiCloseHandle( hdb );
1566
1567     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
1568     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1569
1570     /* check the column types */
1571     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_TYPES );
1572     ok( rec, "failed to get column info record\n" );
1573
1574     ok( check_record( rec, 1, "s62"), "wrong record type\n");
1575     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1576
1577     MsiCloseHandle( rec );
1578
1579     /* now try the names */
1580     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_NAMES );
1581     ok( rec, "failed to get column info record\n" );
1582
1583     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1584     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1585
1586     MsiCloseHandle( rec );
1587
1588     r = MsiDatabaseOpenViewA( hdb,
1589             "SELECT * FROM `_Streams` WHERE `Name` = '\5SummaryInformation'", &view );
1590     ok( r == ERROR_SUCCESS, "Failed to open database view: %u\n", r );
1591
1592     r = MsiViewExecute( view, 0 );
1593     ok( r == ERROR_SUCCESS, "Failed to execute view: %u\n", r );
1594
1595     r = MsiViewFetch( view, &rec );
1596     ok( r == ERROR_NO_MORE_ITEMS, "Unexpected result: %u\n", r );
1597
1598     MsiCloseHandle( rec );
1599     MsiViewClose( view );
1600     MsiCloseHandle( view );
1601
1602     /* create a summary information stream */
1603     r = MsiGetSummaryInformationA( hdb, NULL, 1, &hsi );
1604     ok( r == ERROR_SUCCESS, "Failed to get summary information handle: %u\n", r );
1605
1606     r = MsiSummaryInfoSetPropertyA( hsi, PID_SECURITY, VT_I4, 2, NULL, NULL );
1607     ok( r == ERROR_SUCCESS, "Failed to set property: %u\n", r );
1608
1609     r = MsiSummaryInfoPersist( hsi );
1610     ok( r == ERROR_SUCCESS, "Failed to save summary information: %u\n", r );
1611
1612     MsiCloseHandle( hsi );
1613
1614     r = MsiDatabaseOpenViewA( hdb,
1615             "SELECT * FROM `_Streams` WHERE `Name` = '\5SummaryInformation'", &view );
1616     ok( r == ERROR_SUCCESS, "Failed to open database view: %u\n", r );
1617
1618     r = MsiViewExecute( view, 0 );
1619     ok( r == ERROR_SUCCESS, "Failed to execute view: %u\n", r );
1620
1621     r = MsiViewFetch( view, &rec );
1622     ok( r == ERROR_SUCCESS, "Unexpected result: %u\n", r );
1623
1624     MsiCloseHandle( rec );
1625     MsiViewClose( view );
1626     MsiCloseHandle( view );
1627
1628     /* insert a file into the _Streams table */
1629     create_file( "test.txt" );
1630
1631     rec = MsiCreateRecord( 2 );
1632     MsiRecordSetStringA( rec, 1, "data" );
1633
1634     r = MsiRecordSetStreamA( rec, 2, "test.txt" );
1635     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1636
1637     DeleteFileA("test.txt");
1638
1639     r = MsiDatabaseOpenViewA( hdb,
1640             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1641     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1642
1643     r = MsiViewExecute( view, rec );
1644     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1645
1646     MsiCloseHandle( rec );
1647     MsiViewClose( view );
1648     MsiCloseHandle( view );
1649
1650     /* insert another one */
1651     create_file( "test1.txt" );
1652
1653     rec = MsiCreateRecord( 2 );
1654     MsiRecordSetStringA( rec, 1, "data1" );
1655
1656     r = MsiRecordSetStreamA( rec, 2, "test1.txt" );
1657     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1658
1659     DeleteFileA("test1.txt");
1660
1661     r = MsiDatabaseOpenViewA( hdb,
1662             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1663     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1664
1665     r = MsiViewExecute( view, rec );
1666     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1667
1668     MsiCloseHandle( rec );
1669     MsiViewClose( view );
1670     MsiCloseHandle( view );
1671
1672     /* try again */
1673     create_file( "test1.txt" );
1674
1675     rec = MsiCreateRecord( 2 );
1676     MsiRecordSetStringA( rec, 1, "data1" );
1677
1678     r = MsiRecordSetStreamA( rec, 2, "test1.txt" );
1679     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r );
1680
1681     DeleteFileA( "test1.txt" );
1682
1683     r = MsiDatabaseOpenViewA( hdb,
1684             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1685     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r );
1686
1687     r = MsiViewExecute( view, rec );
1688     ok( r == ERROR_FUNCTION_FAILED, "got %u\n", r );
1689
1690     MsiCloseHandle( rec );
1691     MsiViewClose( view );
1692     MsiCloseHandle( view );
1693
1694     r = MsiDatabaseOpenViewA( hdb,
1695             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data'", &view );
1696     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1697
1698     r = MsiViewExecute( view, 0 );
1699     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1700
1701     r = MsiViewFetch( view, &rec );
1702     ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1703
1704     size = MAX_PATH;
1705     r = MsiRecordGetStringA( rec, 1, file, &size );
1706     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1707     ok( !lstrcmpA(file, "data"), "Expected 'data', got %s\n", file);
1708
1709     size = MAX_PATH;
1710     memset(buf, 0, MAX_PATH);
1711     r = MsiRecordReadStream( rec, 2, buf, &size );
1712     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1713     ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf);
1714
1715     MsiCloseHandle( rec );
1716     MsiViewClose( view );
1717     MsiCloseHandle( view );
1718
1719     r = MsiDatabaseOpenViewA( hdb,
1720             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data1'", &view );
1721     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1722
1723     r = MsiViewExecute( view, 0 );
1724     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1725
1726     r = MsiViewFetch( view, &rec );
1727     ok( r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1728
1729     size = MAX_PATH;
1730     r = MsiRecordGetStringA( rec, 1, file, &size );
1731     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1732     ok( !lstrcmpA(file, "data1"), "Expected 'data1', got %s\n", file);
1733
1734     size = MAX_PATH;
1735     memset(buf, 0, MAX_PATH);
1736     r = MsiRecordReadStream( rec, 2, buf, &size );
1737     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1738     ok( !lstrcmpA(buf, "test1.txt\n"), "Expected 'test1.txt\\n', got %s\n", buf);
1739
1740     MsiCloseHandle( rec );
1741     MsiViewClose( view );
1742     MsiCloseHandle( view );
1743
1744     /* perform an update */
1745     create_file( "test2.txt" );
1746     rec = MsiCreateRecord( 1 );
1747
1748     r = MsiRecordSetStreamA( rec, 1, "test2.txt" );
1749     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1750
1751     DeleteFileA("test2.txt");
1752
1753     r = MsiDatabaseOpenViewA( hdb,
1754             "UPDATE `_Streams` SET `Data` = ? WHERE `Name` = 'data1'", &view );
1755     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1756
1757     r = MsiViewExecute( view, rec );
1758     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1759
1760     MsiCloseHandle( rec );
1761     MsiViewClose( view );
1762     MsiCloseHandle( view );
1763
1764     r = MsiDatabaseOpenViewA( hdb,
1765             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data1'", &view );
1766     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1767
1768     r = MsiViewExecute( view, 0 );
1769     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1770
1771     r = MsiViewFetch( view, &rec );
1772     ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1773
1774     size = MAX_PATH;
1775     r = MsiRecordGetStringA( rec, 1, file, &size );
1776     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1777     ok( !lstrcmpA(file, "data1"), "Expected 'data1', got %s\n", file);
1778
1779     size = MAX_PATH;
1780     memset(buf, 0, MAX_PATH);
1781     r = MsiRecordReadStream( rec, 2, buf, &size );
1782     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1783     ok( !lstrcmpA(buf, "test2.txt\n"), "Expected 'test2.txt\\n', got %s\n", buf);
1784
1785     MsiCloseHandle( rec );
1786     MsiViewClose( view );
1787     MsiCloseHandle( view );
1788     MsiCloseHandle( hdb );
1789     DeleteFileA(msifile);
1790 }
1791
1792 static void test_binary(void)
1793 {
1794     MSIHANDLE hdb = 0, rec;
1795     char file[MAX_PATH];
1796     char buf[MAX_PATH];
1797     DWORD size;
1798     LPCSTR query;
1799     UINT r;
1800
1801     /* insert a file into the Binary table */
1802     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
1803     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1804
1805     query = "CREATE TABLE `Binary` ( `Name` CHAR(72) NOT NULL, `ID` INT NOT NULL, `Data` OBJECT  PRIMARY KEY `Name`, `ID`)";
1806     r = run_query( hdb, 0, query );
1807     ok( r == ERROR_SUCCESS, "Cannot create Binary table: %d\n", r );
1808
1809     create_file( "test.txt" );
1810     rec = MsiCreateRecord( 1 );
1811     r = MsiRecordSetStreamA( rec, 1, "test.txt" );
1812     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1813     DeleteFileA( "test.txt" );
1814
1815     /* try a name that exceeds maximum OLE stream name length */
1816     query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'encryption.dll.CB4E6205_F99A_4C51_ADD4_184506EFAB87', 10000, ? )";
1817     r = run_query( hdb, rec, query );
1818     ok( r == ERROR_SUCCESS, "Insert into Binary table failed: %d\n", r );
1819
1820     r = MsiCloseHandle( rec );
1821     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1822
1823     r = MsiDatabaseCommit( hdb );
1824     ok( r == ERROR_FUNCTION_FAILED , "got %u\n", r );
1825
1826     r = MsiCloseHandle( hdb );
1827     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1828
1829     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
1830     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1831
1832     query = "CREATE TABLE `Binary` ( `Name` CHAR(72) NOT NULL, `ID` INT NOT NULL, `Data` OBJECT  PRIMARY KEY `Name`, `ID`)";
1833     r = run_query( hdb, 0, query );
1834     ok( r == ERROR_SUCCESS, "Cannot create Binary table: %d\n", r );
1835
1836     create_file( "test.txt" );
1837     rec = MsiCreateRecord( 1 );
1838     r = MsiRecordSetStreamA( rec, 1, "test.txt" );
1839     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r );
1840     DeleteFileA( "test.txt" );
1841
1842     query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'filename1', 1, ? )";
1843     r = run_query( hdb, rec, query );
1844     ok( r == ERROR_SUCCESS, "Insert into Binary table failed: %d\n", r );
1845
1846     query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'filename1', 1, ? )";
1847     r = run_query( hdb, rec, query );
1848     ok( r == ERROR_FUNCTION_FAILED, "got %u\n", r );
1849
1850     r = MsiCloseHandle( rec );
1851     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1852
1853     r = MsiDatabaseCommit( hdb );
1854     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1855
1856     r = MsiCloseHandle( hdb );
1857     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1858
1859     /* read file from the Stream table */
1860     r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_READONLY, &hdb );
1861     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1862
1863     query = "SELECT * FROM `_Streams`";
1864     r = do_query( hdb, query, &rec );
1865     ok( r == ERROR_SUCCESS, "SELECT query failed: %d\n", r );
1866
1867     size = MAX_PATH;
1868     r = MsiRecordGetStringA( rec, 1, file, &size );
1869     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
1870     ok( !lstrcmpA(file, "Binary.filename1.1"), "Expected 'Binary.filename1.1', got %s\n", file );
1871
1872     size = MAX_PATH;
1873     memset( buf, 0, MAX_PATH );
1874     r = MsiRecordReadStream( rec, 2, buf, &size );
1875     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r );
1876     ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf );
1877
1878     r = MsiCloseHandle( rec );
1879     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1880
1881     /* read file from the Binary table */
1882     query = "SELECT * FROM `Binary`";
1883     r = do_query( hdb, query, &rec );
1884     ok( r == ERROR_SUCCESS, "SELECT query failed: %d\n", r );
1885
1886     size = MAX_PATH;
1887     r = MsiRecordGetStringA( rec, 1, file, &size );
1888     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
1889     ok( !lstrcmpA(file, "filename1"), "Expected 'filename1', got %s\n", file );
1890
1891     size = MAX_PATH;
1892     memset( buf, 0, MAX_PATH );
1893     r = MsiRecordReadStream( rec, 3, buf, &size );
1894     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r );
1895     ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf );
1896
1897     r = MsiCloseHandle( rec );
1898     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1899
1900     r = MsiCloseHandle( hdb );
1901     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1902
1903     DeleteFileA( msifile );
1904 }
1905
1906 static void test_where_not_in_selected(void)
1907 {
1908     MSIHANDLE hdb = 0, rec, view;
1909     LPCSTR query;
1910     UINT r;
1911
1912     hdb = create_db();
1913     ok( hdb, "failed to create db\n");
1914
1915     r = run_query(hdb, 0,
1916             "CREATE TABLE `IESTable` ("
1917             "`Action` CHAR(64), "
1918             "`Condition` CHAR(64), "
1919             "`Sequence` LONG PRIMARY KEY `Sequence`)");
1920     ok( r == S_OK, "Cannot create IESTable table: %d\n", r);
1921
1922     r = run_query(hdb, 0,
1923             "CREATE TABLE `CATable` ("
1924             "`Action` CHAR(64), "
1925             "`Type` LONG PRIMARY KEY `Type`)");
1926     ok( r == S_OK, "Cannot create CATable table: %d\n", r);
1927
1928     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1929             "( `Action`, `Condition`, `Sequence`) "
1930             "VALUES ( 'clean', 'cond4', 4)");
1931     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1932
1933     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1934             "( `Action`, `Condition`, `Sequence`) "
1935             "VALUES ( 'depends', 'cond1', 1)");
1936     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1937
1938     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1939             "( `Action`, `Condition`, `Sequence`) "
1940             "VALUES ( 'build', 'cond2', 2)");
1941     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1942
1943     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1944             "( `Action`, `Condition`, `Sequence`) "
1945             "VALUES ( 'build2', 'cond6', 6)");
1946     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1947
1948     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1949             "( `Action`, `Condition`, `Sequence`) "
1950             "VALUES ( 'build', 'cond3', 3)");
1951     ok(r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1952
1953     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1954             "( `Action`, `Type` ) "
1955             "VALUES ( 'build', 32)");
1956     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1957
1958     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1959             "( `Action`, `Type` ) "
1960             "VALUES ( 'depends', 64)");
1961     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1962
1963     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1964             "( `Action`, `Type` ) "
1965             "VALUES ( 'clean', 63)");
1966     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1967
1968     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1969             "( `Action`, `Type` ) "
1970             "VALUES ( 'build2', 34)");
1971     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1972     query = "Select IESTable.Condition from CATable, IESTable where "
1973             "CATable.Action = IESTable.Action and CATable.Type = 32";
1974     r = MsiDatabaseOpenViewA(hdb, query, &view);
1975     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1976
1977     r = MsiViewExecute(view, 0);
1978     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1979
1980     r = MsiViewFetch(view, &rec);
1981     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1982
1983     ok( check_record( rec, 1, "cond2"), "wrong condition\n");
1984
1985     MsiCloseHandle( rec );
1986     r = MsiViewFetch(view, &rec);
1987     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1988
1989     ok( check_record( rec, 1, "cond3"), "wrong condition\n");
1990
1991     MsiCloseHandle( rec );
1992     MsiViewClose(view);
1993     MsiCloseHandle(view);
1994
1995     MsiCloseHandle( hdb );
1996     DeleteFileA(msifile);
1997 }
1998
1999
2000 static void test_where(void)
2001 {
2002     MSIHANDLE hdb = 0, rec, view;
2003     LPCSTR query;
2004     UINT r;
2005     DWORD size;
2006     CHAR buf[MAX_PATH];
2007     UINT count;
2008
2009     hdb = create_db();
2010     ok( hdb, "failed to create db\n");
2011
2012     r = run_query( hdb, 0,
2013             "CREATE TABLE `Media` ("
2014             "`DiskId` SHORT NOT NULL, "
2015             "`LastSequence` LONG, "
2016             "`DiskPrompt` CHAR(64) LOCALIZABLE, "
2017             "`Cabinet` CHAR(255), "
2018             "`VolumeLabel` CHAR(32), "
2019             "`Source` CHAR(72) "
2020             "PRIMARY KEY `DiskId`)" );
2021     ok( r == S_OK, "cannot create Media table: %d\n", r );
2022
2023     r = run_query( hdb, 0, "INSERT INTO `Media` "
2024             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
2025             "VALUES ( 1, 0, '', 'zero.cab', '', '' )" );
2026     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
2027
2028     r = run_query( hdb, 0, "INSERT INTO `Media` "
2029             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
2030             "VALUES ( 2, 1, '', 'one.cab', '', '' )" );
2031     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
2032
2033     r = run_query( hdb, 0, "INSERT INTO `Media` "
2034             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
2035             "VALUES ( 3, 2, '', 'two.cab', '', '' )" );
2036     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
2037
2038     query = "SELECT * FROM `Media`";
2039     r = do_query(hdb, query, &rec);
2040     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
2041     ok( check_record( rec, 4, "zero.cab"), "wrong cabinet\n");
2042     MsiCloseHandle( rec );
2043
2044     query = "SELECT * FROM `Media` WHERE `LastSequence` >= 1";
2045     r = do_query(hdb, query, &rec);
2046     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
2047     ok( check_record( rec, 4, "one.cab"), "wrong cabinet\n");
2048
2049     r = MsiRecordGetInteger(rec, 1);
2050     ok( 2 == r, "field wrong\n");
2051     r = MsiRecordGetInteger(rec, 2);
2052     ok( 1 == r, "field wrong\n");
2053     MsiCloseHandle( rec );
2054
2055     query = "SELECT `DiskId` FROM `Media` WHERE `LastSequence` >= 1 AND DiskId >= 0";
2056     r = MsiDatabaseOpenViewA(hdb, query, &view);
2057     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2058
2059     r = MsiViewExecute(view, 0);
2060     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2061
2062     r = MsiViewFetch(view, &rec);
2063     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
2064
2065     count = MsiRecordGetFieldCount( rec );
2066     ok( count == 1, "Expected 1 record fields, got %d\n", count );
2067
2068     size = MAX_PATH;
2069     r = MsiRecordGetStringA( rec, 1, buf, &size );
2070     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2071     ok( !lstrcmpA( buf, "2" ), "For (row %d, column 1) expected '%d', got %s\n", 0, 2, buf );
2072     MsiCloseHandle( rec );
2073
2074     r = MsiViewFetch(view, &rec);
2075     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
2076
2077     size = MAX_PATH;
2078     r = MsiRecordGetStringA( rec, 1, buf, &size );
2079     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2080     ok( !lstrcmpA( buf, "3" ), "For (row %d, column 1) expected '%d', got %s\n", 1, 3, buf );
2081     MsiCloseHandle( rec );
2082
2083     r = MsiViewFetch(view, &rec);
2084     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2085
2086     MsiViewClose(view);
2087     MsiCloseHandle(view);
2088
2089     MsiCloseHandle( rec );
2090
2091     rec = 0;
2092     query = "SELECT * FROM `Media` WHERE `DiskPrompt` IS NULL";
2093     r = do_query(hdb, query, &rec);
2094     ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
2095     MsiCloseHandle( rec );
2096
2097     rec = 0;
2098     query = "SELECT * FROM `Media` WHERE `DiskPrompt` < 'Cabinet'";
2099     r = do_query(hdb, query, &rec);
2100     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %d\n", r );
2101     MsiCloseHandle( rec );
2102
2103     rec = 0;
2104     query = "SELECT * FROM `Media` WHERE `DiskPrompt` > 'Cabinet'";
2105     r = do_query(hdb, query, &rec);
2106     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %d\n", r );
2107     MsiCloseHandle( rec );
2108
2109     rec = 0;
2110     query = "SELECT * FROM `Media` WHERE `DiskPrompt` <> 'Cabinet'";
2111     r = do_query(hdb, query, &rec);
2112     ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
2113     MsiCloseHandle( rec );
2114
2115     rec = 0;
2116     query = "SELECT * FROM `Media` WHERE `DiskPrompt` = 'Cabinet'";
2117     r = do_query(hdb, query, &rec);
2118     ok( r == ERROR_NO_MORE_ITEMS, "query failed: %d\n", r );
2119     MsiCloseHandle( rec );
2120
2121     rec = MsiCreateRecord(1);
2122     MsiRecordSetStringA(rec, 1, "");
2123
2124     query = "SELECT * FROM `Media` WHERE `DiskPrompt` = ?";
2125     r = MsiDatabaseOpenViewA(hdb, query, &view);
2126     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2127     r = MsiViewExecute(view, rec);
2128     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2129
2130     MsiCloseHandle(rec);
2131
2132     r = MsiViewFetch(view, &rec);
2133     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2134
2135     MsiCloseHandle(rec);
2136     MsiViewClose(view);
2137     MsiCloseHandle(view);
2138
2139     MsiCloseHandle( hdb );
2140     DeleteFileA(msifile);
2141 }
2142
2143 static CHAR CURR_DIR[MAX_PATH];
2144
2145 static const CHAR test_data[] = "FirstPrimaryColumn\tSecondPrimaryColumn\tShortInt\tShortIntNullable\tLongInt\tLongIntNullable\tString\tLocalizableString\tLocalizableStringNullable\n"
2146                                 "s255\ti2\ti2\tI2\ti4\tI4\tS255\tS0\ts0\n"
2147                                 "TestTable\tFirstPrimaryColumn\n"
2148                                 "stringage\t5\t2\t\t2147483640\t-2147483640\tanother string\tlocalizable\tduh\n";
2149
2150 static const CHAR two_primary[] = "PrimaryOne\tPrimaryTwo\n"
2151                                   "s255\ts255\n"
2152                                   "TwoPrimary\tPrimaryOne\tPrimaryTwo\n"
2153                                   "papaya\tleaf\n"
2154                                   "papaya\tflower\n";
2155
2156 static const CHAR endlines1[] = "A\tB\tC\tD\tE\tF\r\n"
2157                                 "s72\ts72\ts72\ts72\ts72\ts72\n"
2158                                 "Table\tA\r\n"
2159                                 "a\tb\tc\td\te\tf\n"
2160                                 "g\th\ti\t\rj\tk\tl\r\n";
2161
2162 static const CHAR endlines2[] = "A\tB\tC\tD\tE\tF\r"
2163                                 "s72\ts72\ts72\ts72\ts72\ts72\n"
2164                                 "Table2\tA\r\n"
2165                                 "a\tb\tc\td\te\tf\n"
2166                                 "g\th\ti\tj\tk\tl\r\n";
2167
2168 static const CHAR suminfo[] = "PropertyId\tValue\n"
2169                               "i2\tl255\n"
2170                               "_SummaryInformation\tPropertyId\n"
2171                               "1\t1252\n"
2172                               "2\tInstaller Database\n"
2173                               "3\tInstaller description\n"
2174                               "4\tWineHQ\n"
2175                               "5\tInstaller\n"
2176                               "6\tInstaller comments\n"
2177                               "7\tIntel;1033,2057\n"
2178                               "9\t{12345678-1234-1234-1234-123456789012}\n"
2179                               "12\t2009/04/12 15:46:11\n"
2180                               "13\t2009/04/12 15:46:11\n"
2181                               "14\t200\n"
2182                               "15\t2\n"
2183                               "18\tVim\n"
2184                               "19\t2\n";
2185
2186 static void write_file(const CHAR *filename, const char *data, int data_size)
2187 {
2188     DWORD size;
2189
2190     HANDLE hf = CreateFileA(filename, GENERIC_WRITE, 0, NULL,
2191                             CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2192     WriteFile(hf, data, data_size, &size, NULL);
2193     CloseHandle(hf);
2194 }
2195
2196 static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
2197 {
2198     UINT r;
2199
2200     write_file("temp_file", table_data, (lstrlenA(table_data) - 1) * sizeof(char));
2201     r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
2202     DeleteFileA("temp_file");
2203
2204     return r;
2205 }
2206
2207 static void test_suminfo_import(void)
2208 {
2209     MSIHANDLE hdb, hsi, view = 0;
2210     LPCSTR query;
2211     UINT r, count, size, type;
2212     char str_value[50];
2213     INT int_value;
2214     FILETIME ft_value;
2215
2216     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
2217
2218     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
2219     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2220
2221     r = add_table_to_db(hdb, suminfo);
2222     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2223
2224     /* _SummaryInformation is not imported as a regular table... */
2225
2226     query = "SELECT * FROM `_SummaryInformation`";
2227     r = MsiDatabaseOpenViewA(hdb, query, &view);
2228     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %u\n", r);
2229     MsiCloseHandle(view);
2230
2231     /* ...its data is added to the special summary information stream */
2232
2233     r = MsiGetSummaryInformationA(hdb, NULL, 0, &hsi);
2234     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2235
2236     r = MsiSummaryInfoGetPropertyCount(hsi, &count);
2237     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2238     ok(count == 14, "Expected 14, got %u\n", count);
2239
2240     r = MsiSummaryInfoGetPropertyA(hsi, PID_CODEPAGE, &type, &int_value, NULL, NULL, NULL);
2241     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2242     ok(type ==  VT_I2, "Expected VT_I2, got %u\n", type);
2243     ok(int_value == 1252, "Expected 1252, got %d\n", int_value);
2244
2245     size = sizeof(str_value);
2246     r = MsiSummaryInfoGetPropertyA(hsi, PID_TITLE, &type, NULL, NULL, str_value, &size);
2247     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2248     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2249     ok(size == 18, "Expected 18, got %u\n", size);
2250     ok(!strcmp(str_value, "Installer Database"),
2251        "Expected \"Installer Database\", got %s\n", str_value);
2252
2253     size = sizeof(str_value);
2254     r = MsiSummaryInfoGetPropertyA(hsi, PID_SUBJECT, &type, NULL, NULL, str_value, &size);
2255     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2256     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2257     ok(!strcmp(str_value, "Installer description"),
2258        "Expected \"Installer description\", got %s\n", str_value);
2259
2260     size = sizeof(str_value);
2261     r = MsiSummaryInfoGetPropertyA(hsi, PID_AUTHOR, &type, NULL, NULL, str_value, &size);
2262     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2263     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2264     ok(!strcmp(str_value, "WineHQ"),
2265        "Expected \"WineHQ\", got %s\n", str_value);
2266
2267     size = sizeof(str_value);
2268     r = MsiSummaryInfoGetPropertyA(hsi, PID_KEYWORDS, &type, NULL, NULL, str_value, &size);
2269     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2270     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2271     ok(!strcmp(str_value, "Installer"),
2272        "Expected \"Installer\", got %s\n", str_value);
2273
2274     size = sizeof(str_value);
2275     r = MsiSummaryInfoGetPropertyA(hsi, PID_COMMENTS, &type, NULL, NULL, str_value, &size);
2276     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2277     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2278     ok(!strcmp(str_value, "Installer comments"),
2279        "Expected \"Installer comments\", got %s\n", str_value);
2280
2281     size = sizeof(str_value);
2282     r = MsiSummaryInfoGetPropertyA(hsi, PID_TEMPLATE, &type, NULL, NULL, str_value, &size);
2283     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2284     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2285     ok(!strcmp(str_value, "Intel;1033,2057"),
2286        "Expected \"Intel;1033,2057\", got %s\n", str_value);
2287
2288     size = sizeof(str_value);
2289     r = MsiSummaryInfoGetPropertyA(hsi, PID_REVNUMBER, &type, NULL, NULL, str_value, &size);
2290     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2291     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2292     ok(!strcmp(str_value, "{12345678-1234-1234-1234-123456789012}"),
2293        "Expected \"{12345678-1234-1234-1234-123456789012}\", got %s\n", str_value);
2294
2295     r = MsiSummaryInfoGetPropertyA(hsi, PID_CREATE_DTM, &type, NULL, &ft_value, NULL, NULL);
2296     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2297     ok(type == VT_FILETIME, "Expected VT_FILETIME, got %u\n", type);
2298
2299     r = MsiSummaryInfoGetPropertyA(hsi, PID_LASTSAVE_DTM, &type, NULL, &ft_value, NULL, NULL);
2300     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2301     ok(type == VT_FILETIME, "Expected VT_FILETIME, got %u\n", type);
2302
2303     r = MsiSummaryInfoGetPropertyA(hsi, PID_PAGECOUNT, &type, &int_value, NULL, NULL, NULL);
2304     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2305     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2306     ok(int_value == 200, "Expected 200, got %d\n", int_value);
2307
2308     r = MsiSummaryInfoGetPropertyA(hsi, PID_WORDCOUNT, &type, &int_value, NULL, NULL, NULL);
2309     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2310     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2311     ok(int_value == 2, "Expected 2, got %d\n", int_value);
2312
2313     r = MsiSummaryInfoGetPropertyA(hsi, PID_SECURITY, &type, &int_value, NULL, NULL, NULL);
2314     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2315     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2316     ok(int_value == 2, "Expected 2, got %d\n", int_value);
2317
2318     size = sizeof(str_value);
2319     r = MsiSummaryInfoGetPropertyA(hsi, PID_APPNAME, &type, NULL, NULL, str_value, &size);
2320     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2321     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2322     ok(!strcmp(str_value, "Vim"), "Expected \"Vim\", got %s\n", str_value);
2323
2324     MsiCloseHandle(hsi);
2325     MsiCloseHandle(hdb);
2326     DeleteFileA(msifile);
2327 }
2328
2329 static void test_msiimport(void)
2330 {
2331     MSIHANDLE hdb, view, rec;
2332     LPCSTR query;
2333     UINT r, count;
2334     signed int i;
2335
2336     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
2337
2338     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
2339     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2340
2341     r = add_table_to_db(hdb, test_data);
2342     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2343
2344     r = add_table_to_db(hdb, two_primary);
2345     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2346
2347     r = add_table_to_db(hdb, endlines1);
2348     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2349
2350     r = add_table_to_db(hdb, endlines2);
2351     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
2352
2353     query = "SELECT * FROM `TestTable`";
2354     r = MsiDatabaseOpenViewA(hdb, query, &view);
2355     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2356
2357     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2358     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2359     count = MsiRecordGetFieldCount(rec);
2360     ok(count == 9, "Expected 9, got %d\n", count);
2361     ok(check_record(rec, 1, "FirstPrimaryColumn"), "Expected FirstPrimaryColumn\n");
2362     ok(check_record(rec, 2, "SecondPrimaryColumn"), "Expected SecondPrimaryColumn\n");
2363     ok(check_record(rec, 3, "ShortInt"), "Expected ShortInt\n");
2364     ok(check_record(rec, 4, "ShortIntNullable"), "Expected ShortIntNullalble\n");
2365     ok(check_record(rec, 5, "LongInt"), "Expected LongInt\n");
2366     ok(check_record(rec, 6, "LongIntNullable"), "Expected LongIntNullalble\n");
2367     ok(check_record(rec, 7, "String"), "Expected String\n");
2368     ok(check_record(rec, 8, "LocalizableString"), "Expected LocalizableString\n");
2369     ok(check_record(rec, 9, "LocalizableStringNullable"), "Expected LocalizableStringNullable\n");
2370     MsiCloseHandle(rec);
2371
2372     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2373     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2374     count = MsiRecordGetFieldCount(rec);
2375     ok(count == 9, "Expected 9, got %d\n", count);
2376     ok(check_record(rec, 1, "s255"), "Expected s255\n");
2377     ok(check_record(rec, 2, "i2"), "Expected i2\n");
2378     ok(check_record(rec, 3, "i2"), "Expected i2\n");
2379     ok(check_record(rec, 4, "I2"), "Expected I2\n");
2380     ok(check_record(rec, 5, "i4"), "Expected i4\n");
2381     ok(check_record(rec, 6, "I4"), "Expected I4\n");
2382     ok(check_record(rec, 7, "S255"), "Expected S255\n");
2383     ok(check_record(rec, 8, "S0"), "Expected S0\n");
2384     ok(check_record(rec, 9, "s0"), "Expected s0\n");
2385     MsiCloseHandle(rec);
2386
2387     query = "SELECT * FROM `TestTable`";
2388     r = do_query(hdb, query, &rec);
2389     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2390     ok(check_record(rec, 1, "stringage"), "Expected 'stringage'\n");
2391     ok(check_record(rec, 7, "another string"), "Expected 'another string'\n");
2392     ok(check_record(rec, 8, "localizable"), "Expected 'localizable'\n");
2393     ok(check_record(rec, 9, "duh"), "Expected 'duh'\n");
2394
2395     i = MsiRecordGetInteger(rec, 2);
2396     ok(i == 5, "Expected 5, got %d\n", i);
2397
2398     i = MsiRecordGetInteger(rec, 3);
2399     ok(i == 2, "Expected 2, got %d\n", i);
2400
2401     i = MsiRecordGetInteger(rec, 4);
2402     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
2403
2404     i = MsiRecordGetInteger(rec, 5);
2405     ok(i == 2147483640, "Expected 2147483640, got %d\n", i);
2406
2407     i = MsiRecordGetInteger(rec, 6);
2408     ok(i == -2147483640, "Expected -2147483640, got %d\n", i);
2409
2410     MsiCloseHandle(rec);
2411     MsiViewClose(view);
2412     MsiCloseHandle(view);
2413
2414     query = "SELECT * FROM `TwoPrimary`";
2415     r = MsiDatabaseOpenViewA(hdb, query, &view);
2416     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2417
2418     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2419     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2420     count = MsiRecordGetFieldCount(rec);
2421     ok(count == 2, "Expected 2, got %d\n", count);
2422     ok(check_record(rec, 1, "PrimaryOne"), "Expected PrimaryOne\n");
2423     ok(check_record(rec, 2, "PrimaryTwo"), "Expected PrimaryTwo\n");
2424
2425     MsiCloseHandle(rec);
2426
2427     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2428     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2429     count = MsiRecordGetFieldCount(rec);
2430     ok(count == 2, "Expected 2, got %d\n", count);
2431     ok(check_record(rec, 1, "s255"), "Expected s255\n");
2432     ok(check_record(rec, 2, "s255"), "Expected s255\n");
2433     MsiCloseHandle(rec);
2434
2435     r = MsiViewExecute(view, 0);
2436     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2437
2438     r = MsiViewFetch(view, &rec);
2439     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2440
2441     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
2442     ok(check_record(rec, 2, "leaf"), "Expected 'leaf'\n");
2443
2444     MsiCloseHandle(rec);
2445
2446     r = MsiViewFetch(view, &rec);
2447     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2448
2449     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
2450     ok(check_record(rec, 2, "flower"), "Expected 'flower'\n");
2451
2452     MsiCloseHandle(rec);
2453
2454     r = MsiViewFetch(view, &rec);
2455     ok(r == ERROR_NO_MORE_ITEMS,
2456        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
2457
2458     r = MsiViewClose(view);
2459     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2460
2461     MsiCloseHandle(view);
2462
2463     query = "SELECT * FROM `Table`";
2464     r = MsiDatabaseOpenViewA(hdb, query, &view);
2465     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2466
2467     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2468     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2469     count = MsiRecordGetFieldCount(rec);
2470     ok(count == 6, "Expected 6, got %d\n", count);
2471     ok(check_record(rec, 1, "A"), "Expected A\n");
2472     ok(check_record(rec, 2, "B"), "Expected B\n");
2473     ok(check_record(rec, 3, "C"), "Expected C\n");
2474     ok(check_record(rec, 4, "D"), "Expected D\n");
2475     ok(check_record(rec, 5, "E"), "Expected E\n");
2476     ok(check_record(rec, 6, "F"), "Expected F\n");
2477     MsiCloseHandle(rec);
2478
2479     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2480     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2481     count = MsiRecordGetFieldCount(rec);
2482     ok(count == 6, "Expected 6, got %d\n", count);
2483     ok(check_record(rec, 1, "s72"), "Expected s72\n");
2484     ok(check_record(rec, 2, "s72"), "Expected s72\n");
2485     ok(check_record(rec, 3, "s72"), "Expected s72\n");
2486     ok(check_record(rec, 4, "s72"), "Expected s72\n");
2487     ok(check_record(rec, 5, "s72"), "Expected s72\n");
2488     ok(check_record(rec, 6, "s72"), "Expected s72\n");
2489     MsiCloseHandle(rec);
2490
2491     MsiViewClose(view);
2492     MsiCloseHandle(view);
2493
2494     query = "SELECT * FROM `Table`";
2495     r = MsiDatabaseOpenViewA(hdb, query, &view);
2496     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2497
2498     r = MsiViewExecute(view, 0);
2499     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2500
2501     r = MsiViewFetch(view, &rec);
2502     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2503     ok(check_record(rec, 1, "a"), "Expected 'a'\n");
2504     ok(check_record(rec, 2, "b"), "Expected 'b'\n");
2505     ok(check_record(rec, 3, "c"), "Expected 'c'\n");
2506     ok(check_record(rec, 4, "d"), "Expected 'd'\n");
2507     ok(check_record(rec, 5, "e"), "Expected 'e'\n");
2508     ok(check_record(rec, 6, "f"), "Expected 'f'\n");
2509
2510     MsiCloseHandle(rec);
2511
2512     r = MsiViewFetch(view, &rec);
2513     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2514     ok(check_record(rec, 1, "g"), "Expected 'g'\n");
2515     ok(check_record(rec, 2, "h"), "Expected 'h'\n");
2516     ok(check_record(rec, 3, "i"), "Expected 'i'\n");
2517     ok(check_record(rec, 4, "j"), "Expected 'j'\n");
2518     ok(check_record(rec, 5, "k"), "Expected 'k'\n");
2519     ok(check_record(rec, 6, "l"), "Expected 'l'\n");
2520
2521     MsiCloseHandle(rec);
2522
2523     r = MsiViewFetch(view, &rec);
2524     ok(r == ERROR_NO_MORE_ITEMS,
2525        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
2526
2527     MsiViewClose(view);
2528     MsiCloseHandle(view);
2529     MsiCloseHandle(hdb);
2530     DeleteFileA(msifile);
2531 }
2532
2533 static const CHAR bin_import_dat[] = "Name\tData\r\n"
2534                                      "s72\tV0\r\n"
2535                                      "Binary\tName\r\n"
2536                                      "filename1\tfilename1.ibd\r\n";
2537
2538 static void test_binary_import(void)
2539 {
2540     MSIHANDLE hdb = 0, rec;
2541     char file[MAX_PATH];
2542     char buf[MAX_PATH];
2543     char path[MAX_PATH];
2544     DWORD size;
2545     LPCSTR query;
2546     UINT r;
2547
2548     /* create files to import */
2549     write_file("bin_import.idt", bin_import_dat,
2550           (sizeof(bin_import_dat) - 1) * sizeof(char));
2551     CreateDirectoryA("bin_import", NULL);
2552     create_file_data("bin_import/filename1.ibd", "just some words", 15);
2553
2554     /* import files into database */
2555     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
2556     ok( r == ERROR_SUCCESS , "Failed to open database\n");
2557
2558     GetCurrentDirectoryA(MAX_PATH, path);
2559     r = MsiDatabaseImportA(hdb, path, "bin_import.idt");
2560     ok(r == ERROR_SUCCESS , "Failed to import Binary table\n");
2561
2562     /* read file from the Binary table */
2563     query = "SELECT * FROM `Binary`";
2564     r = do_query(hdb, query, &rec);
2565     ok(r == ERROR_SUCCESS, "SELECT query failed: %d\n", r);
2566
2567     size = MAX_PATH;
2568     r = MsiRecordGetStringA(rec, 1, file, &size);
2569     ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
2570     ok(!lstrcmpA(file, "filename1"), "Expected 'filename1', got %s\n", file);
2571
2572     size = MAX_PATH;
2573     memset(buf, 0, MAX_PATH);
2574     r = MsiRecordReadStream(rec, 2, buf, &size);
2575     ok(r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
2576     ok(!lstrcmpA(buf, "just some words"), "Expected 'just some words', got %s\n", buf);
2577
2578     r = MsiCloseHandle(rec);
2579     ok(r == ERROR_SUCCESS , "Failed to close record handle\n");
2580
2581     r = MsiCloseHandle(hdb);
2582     ok(r == ERROR_SUCCESS , "Failed to close database\n");
2583
2584     DeleteFileA("bin_import/filename1.ibd");
2585     RemoveDirectoryA("bin_import");
2586     DeleteFileA("bin_import.idt");
2587 }
2588
2589 static void test_markers(void)
2590 {
2591     MSIHANDLE hdb, rec;
2592     LPCSTR query;
2593     UINT r;
2594
2595     hdb = create_db();
2596     ok( hdb, "failed to create db\n");
2597
2598     rec = MsiCreateRecord(3);
2599     MsiRecordSetStringA(rec, 1, "Table");
2600     MsiRecordSetStringA(rec, 2, "Apples");
2601     MsiRecordSetStringA(rec, 3, "Oranges");
2602
2603     /* try a legit create */
2604     query = "CREATE TABLE `Table` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2605     r = run_query(hdb, 0, query);
2606     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2607     MsiCloseHandle(rec);
2608
2609     /* try table name as marker */
2610     rec = MsiCreateRecord(1);
2611     MsiRecordSetStringA(rec, 1, "Fable");
2612     query = "CREATE TABLE `?` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2613     r = run_query(hdb, rec, query);
2614     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2615
2616     /* verify that we just created a table called '?', not 'Fable' */
2617     r = try_query(hdb, "SELECT * from `Fable`");
2618     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2619
2620     r = try_query(hdb, "SELECT * from `?`");
2621     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2622
2623     /* try table name as marker without backticks */
2624     MsiRecordSetStringA(rec, 1, "Mable");
2625     query = "CREATE TABLE ? ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2626     r = run_query(hdb, rec, query);
2627     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2628
2629     /* try one column name as marker */
2630     MsiRecordSetStringA(rec, 1, "One");
2631     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2632     r = run_query(hdb, rec, query);
2633     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2634     MsiCloseHandle(rec);
2635
2636     /* try column names as markers */
2637     rec = MsiCreateRecord(2);
2638     MsiRecordSetStringA(rec, 1, "One");
2639     MsiRecordSetStringA(rec, 2, "Two");
2640     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `One`)";
2641     r = run_query(hdb, rec, query);
2642     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2643     MsiCloseHandle(rec);
2644
2645     /* try names with backticks */
2646     rec = MsiCreateRecord(3);
2647     MsiRecordSetStringA(rec, 1, "One");
2648     MsiRecordSetStringA(rec, 2, "Two");
2649     MsiRecordSetStringA(rec, 3, "One");
2650     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
2651     r = run_query(hdb, rec, query);
2652     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2653
2654     /* try names with backticks, minus definitions */
2655     query = "CREATE TABLE `Mable` ( `?`, `?` PRIMARY KEY `?`)";
2656     r = run_query(hdb, rec, query);
2657     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2658
2659     /* try names without backticks */
2660     query = "CREATE TABLE `Mable` ( ? SHORT NOT NULL, ? CHAR(255) PRIMARY KEY ?)";
2661     r = run_query(hdb, rec, query);
2662     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2663     MsiCloseHandle(rec);
2664
2665     /* try one long marker */
2666     rec = MsiCreateRecord(1);
2667     MsiRecordSetStringA(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
2668     query = "CREATE TABLE `Mable` ( ? )";
2669     r = run_query(hdb, rec, query);
2670     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2671     MsiCloseHandle(rec);
2672
2673     /* try all names as markers */
2674     rec = MsiCreateRecord(4);
2675     MsiRecordSetStringA(rec, 1, "Mable");
2676     MsiRecordSetStringA(rec, 2, "One");
2677     MsiRecordSetStringA(rec, 3, "Two");
2678     MsiRecordSetStringA(rec, 4, "One");
2679     query = "CREATE TABLE `?` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
2680     r = run_query(hdb, rec, query);
2681     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2682     MsiCloseHandle(rec);
2683
2684     /* try a legit insert */
2685     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( 5, 'hello' )";
2686     r = run_query(hdb, 0, query);
2687     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2688
2689     r = try_query(hdb, "SELECT * from `Table`");
2690     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2691
2692     /* try values as markers */
2693     rec = MsiCreateRecord(2);
2694     MsiRecordSetInteger(rec, 1, 4);
2695     MsiRecordSetStringA(rec, 2, "hi");
2696     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
2697     r = run_query(hdb, rec, query);
2698     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2699     MsiCloseHandle(rec);
2700
2701     /* try column names and values as markers */
2702     rec = MsiCreateRecord(4);
2703     MsiRecordSetStringA(rec, 1, "One");
2704     MsiRecordSetStringA(rec, 2, "Two");
2705     MsiRecordSetInteger(rec, 3, 5);
2706     MsiRecordSetStringA(rec, 4, "hi");
2707     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( ?, '?' )";
2708     r = run_query(hdb, rec, query);
2709     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2710     MsiCloseHandle(rec);
2711
2712     /* try column names as markers */
2713     rec = MsiCreateRecord(2);
2714     MsiRecordSetStringA(rec, 1, "One");
2715     MsiRecordSetStringA(rec, 2, "Two");
2716     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( 3, 'yellow' )";
2717     r = run_query(hdb, rec, query);
2718     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2719     MsiCloseHandle(rec);
2720
2721     /* try table name as a marker */
2722     rec = MsiCreateRecord(1);
2723     MsiRecordSetStringA(rec, 1, "Table");
2724     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( 2, 'green' )";
2725     r = run_query(hdb, rec, query);
2726     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2727     MsiCloseHandle(rec);
2728
2729     /* try table name and values as markers */
2730     rec = MsiCreateRecord(3);
2731     MsiRecordSetStringA(rec, 1, "Table");
2732     MsiRecordSetInteger(rec, 2, 10);
2733     MsiRecordSetStringA(rec, 3, "haha");
2734     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
2735     r = run_query(hdb, rec, query);
2736     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
2737     MsiCloseHandle(rec);
2738
2739     /* try all markers */
2740     rec = MsiCreateRecord(5);
2741     MsiRecordSetStringA(rec, 1, "Table");
2742     MsiRecordSetStringA(rec, 1, "One");
2743     MsiRecordSetStringA(rec, 1, "Two");
2744     MsiRecordSetInteger(rec, 2, 10);
2745     MsiRecordSetStringA(rec, 3, "haha");
2746     query = "INSERT INTO `?` ( `?`, `?` ) VALUES ( ?, '?' )";
2747     r = run_query(hdb, rec, query);
2748     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2749     MsiCloseHandle(rec);
2750
2751     /* insert an integer as a string */
2752     rec = MsiCreateRecord(2);
2753     MsiRecordSetStringA(rec, 1, "11");
2754     MsiRecordSetStringA(rec, 2, "hi");
2755     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
2756     r = run_query(hdb, rec, query);
2757     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2758     MsiCloseHandle(rec);
2759
2760     /* leave off the '' for the string */
2761     rec = MsiCreateRecord(2);
2762     MsiRecordSetInteger(rec, 1, 12);
2763     MsiRecordSetStringA(rec, 2, "hi");
2764     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, ? )";
2765     r = run_query(hdb, rec, query);
2766     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2767     MsiCloseHandle(rec);
2768
2769     MsiCloseHandle(hdb);
2770     DeleteFileA(msifile);
2771 }
2772
2773 #define MY_NVIEWS 4000    /* Largest installer I've seen uses < 2000 */
2774 static void test_handle_limit(void)
2775 {
2776     int i;
2777     MSIHANDLE hdb;
2778     MSIHANDLE hviews[MY_NVIEWS];
2779     UINT r;
2780
2781     /* create an empty db */
2782     hdb = create_db();
2783     ok( hdb, "failed to create db\n");
2784
2785     memset(hviews, 0, sizeof(hviews));
2786
2787     for (i=0; i<MY_NVIEWS; i++) {
2788         static char szQueryBuf[256] = "SELECT * from `_Tables`";
2789         hviews[i] = 0xdeadbeeb;
2790         r = MsiDatabaseOpenViewA(hdb, szQueryBuf, &hviews[i]);
2791         if( r != ERROR_SUCCESS || hviews[i] == 0xdeadbeeb ||
2792             hviews[i] == 0 || (i && (hviews[i] == hviews[i-1])))
2793             break;
2794     }
2795
2796     ok( i == MY_NVIEWS, "problem opening views\n");
2797
2798     for (i=0; i<MY_NVIEWS; i++) {
2799         if (hviews[i] != 0 && hviews[i] != 0xdeadbeeb) {
2800             MsiViewClose(hviews[i]);
2801             r = MsiCloseHandle(hviews[i]);
2802             if (r != ERROR_SUCCESS)
2803                 break;
2804         }
2805     }
2806
2807     ok( i == MY_NVIEWS, "problem closing views\n");
2808
2809     r = MsiCloseHandle(hdb);
2810     ok( r == ERROR_SUCCESS, "failed to close database\n");
2811 }
2812
2813 static void generate_transform(void)
2814 {
2815     MSIHANDLE hdb1, hdb2, hrec;
2816     LPCSTR query;
2817     UINT r;
2818
2819     /* start with two identical databases */
2820     CopyFileA(msifile2, msifile, FALSE);
2821
2822     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb1 );
2823     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2824
2825     r = MsiDatabaseCommit( hdb1 );
2826     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
2827
2828     r = MsiOpenDatabaseW(msifile2W, MSIDBOPEN_READONLY, &hdb2 );
2829     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2830
2831     /* the transform between two identical database should be empty */
2832     r = MsiDatabaseGenerateTransformA(hdb1, hdb2, NULL, 0, 0);
2833     todo_wine {
2834     ok( r == ERROR_NO_DATA, "return code %d, should be ERROR_NO_DATA\n", r );
2835     }
2836
2837     query = "CREATE TABLE `AAR` ( `BAR` SHORT NOT NULL, `CAR` CHAR(255) PRIMARY KEY `CAR`)";
2838     r = run_query(hdb1, 0, query);
2839     ok(r == ERROR_SUCCESS, "failed to add table\n");
2840
2841     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 1, 'vw' )";
2842     r = run_query(hdb1, 0, query);
2843     ok(r == ERROR_SUCCESS, "failed to add row 1\n");
2844
2845     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 2, 'bmw' )";
2846     r = run_query(hdb1, 0, query);
2847     ok(r == ERROR_SUCCESS, "failed to add row 2\n");
2848
2849     query = "UPDATE `MOO` SET `OOO` = 'c' WHERE `NOO` = 1";
2850     r = run_query(hdb1, 0, query);
2851     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2852
2853     query = "DELETE FROM `MOO` WHERE `NOO` = 3";
2854     r = run_query(hdb1, 0, query);
2855     ok(r == ERROR_SUCCESS, "failed to delete row\n");
2856
2857     hrec = MsiCreateRecord(2);
2858     r = MsiRecordSetInteger(hrec, 1, 1);
2859     ok(r == ERROR_SUCCESS, "failed to set integer\n");
2860
2861     write_file("testdata.bin", "naengmyon", 9);
2862     r = MsiRecordSetStreamA(hrec, 2, "testdata.bin");
2863     ok(r == ERROR_SUCCESS, "failed to set stream\n");
2864
2865     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
2866     r = run_query(hdb1, hrec, query);
2867     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
2868
2869     MsiCloseHandle(hrec);
2870
2871     query = "ALTER TABLE `MOO` ADD `COW` INTEGER";
2872     r = run_query(hdb1, 0, query);
2873     ok(r == ERROR_SUCCESS, "failed to add column\n");
2874
2875     query = "ALTER TABLE `MOO` ADD `PIG` INTEGER";
2876     r = run_query(hdb1, 0, query);
2877     ok(r == ERROR_SUCCESS, "failed to add column\n");
2878
2879     query = "UPDATE `MOO` SET `PIG` = 5 WHERE `NOO` = 1";
2880     r = run_query(hdb1, 0, query);
2881     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2882
2883     query = "CREATE TABLE `Property` ( `Property` CHAR(72) NOT NULL, "
2884             "`Value` CHAR(0) PRIMARY KEY `Property`)";
2885     r = run_query(hdb1, 0, query);
2886     ok(r == ERROR_SUCCESS, "failed to add property table\n");
2887
2888     query = "INSERT INTO `Property` ( `Property`, `Value` ) VALUES ( 'prop', 'val' )";
2889     r = run_query(hdb1, 0, query);
2890     ok(r == ERROR_SUCCESS, "failed to add property\n");
2891
2892     /* database needs to be committed */
2893     MsiDatabaseCommit(hdb1);
2894
2895     r = MsiDatabaseGenerateTransformA(hdb1, hdb2, mstfile, 0, 0);
2896     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
2897
2898     MsiCloseHandle( hdb1 );
2899     MsiCloseHandle( hdb2 );
2900
2901     DeleteFileA("testdata.bin");
2902 }
2903
2904 /* data for generating a transform */
2905
2906 /* tables transform names - encoded as they would be in an msi database file */
2907 static const WCHAR name1[] = { 0x4840, 0x3a8a, 0x481b, 0 }; /* AAR */
2908 static const WCHAR name2[] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }; /* _Columns */
2909 static const WCHAR name3[] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }; /* _Tables */
2910 static const WCHAR name4[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }; /* _StringData */
2911 static const WCHAR name5[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }; /* _StringPool */
2912 static const WCHAR name6[] = { 0x4840, 0x3e16, 0x4818, 0}; /* MOO */
2913 static const WCHAR name7[] = { 0x4840, 0x3c8b, 0x3a97, 0x409b, 0 }; /* BINARY */
2914 static const WCHAR name8[] = { 0x3c8b, 0x3a97, 0x409b, 0x387e, 0 }; /* BINARY.1 */
2915 static const WCHAR name9[] = { 0x4840, 0x4559, 0x44f2, 0x4568, 0x4737, 0 }; /* Property */
2916
2917 /* data in each table */
2918 static const WCHAR data1[] = { /* AAR */
2919     0x0201, 0x0008, 0x8001,  /* 0x0201 = add row (1), two shorts */
2920     0x0201, 0x0009, 0x8002,
2921 };
2922 static const WCHAR data2[] = { /* _Columns */
2923     0x0401, 0x0001, 0x8003, 0x0002, 0x9502,
2924     0x0401, 0x0001, 0x8004, 0x0003, 0x9502,
2925     0x0401, 0x0005, 0x0000, 0x0006, 0xbdff,  /* 0x0401 = add row (1), 4 shorts */
2926     0x0401, 0x0005, 0x0000, 0x0007, 0x8502,
2927     0x0401, 0x000a, 0x0000, 0x000a, 0xad48,
2928     0x0401, 0x000a, 0x0000, 0x000b, 0x9d00,
2929 };
2930 static const WCHAR data3[] = { /* _Tables */
2931     0x0101, 0x0005, /* 0x0101 = add row (1), 1 short */
2932     0x0101, 0x000a,
2933 };
2934 static const char data4[] = /* _StringData */
2935     "MOOCOWPIGcAARCARBARvwbmwPropertyValuepropval";  /* all the strings squashed together */
2936 static const WCHAR data5[] = { /* _StringPool */
2937 /*  len, refs */
2938     0,   0,    /* string 0 ''    */
2939     3,   2,    /* string 1 'MOO' */
2940     3,   1,    /* string 2 'COW' */
2941     3,   1,    /* string 3 'PIG' */
2942     1,   1,    /* string 4 'c'   */
2943     3,   3,    /* string 5 'AAR' */
2944     3,   1,    /* string 6 'CAR' */
2945     3,   1,    /* string 7 'BAR' */
2946     2,   1,    /* string 8 'vw'  */
2947     3,   1,    /* string 9 'bmw' */
2948     8,   4,    /* string 10 'Property' */
2949     5,   1,    /* string 11 'Value' */
2950     4,   1,    /* string 12 'prop' */
2951     3,   1,    /* string 13 'val' */
2952 };
2953 /* update row, 0x0002 is a bitmask of present column data, keys are excluded */
2954 static const WCHAR data6[] = { /* MOO */
2955     0x000a, 0x8001, 0x0004, 0x8005, /* update row */
2956     0x0000, 0x8003,         /* delete row */
2957 };
2958
2959 static const WCHAR data7[] = { /* BINARY */
2960     0x0201, 0x8001, 0x0001,
2961 };
2962
2963 static const char data8[] =  /* stream data for the BINARY table */
2964     "naengmyon";
2965
2966 static const WCHAR data9[] = { /* Property */
2967     0x0201, 0x000c, 0x000d,
2968 };
2969
2970 static const struct {
2971     LPCWSTR name;
2972     const void *data;
2973     DWORD size;
2974 } table_transform_data[] =
2975 {
2976     { name1, data1, sizeof data1 },
2977     { name2, data2, sizeof data2 },
2978     { name3, data3, sizeof data3 },
2979     { name4, data4, sizeof data4 - 1 },
2980     { name5, data5, sizeof data5 },
2981     { name6, data6, sizeof data6 },
2982     { name7, data7, sizeof data7 },
2983     { name8, data8, sizeof data8 - 1 },
2984     { name9, data9, sizeof data9 },
2985 };
2986
2987 #define NUM_TRANSFORM_TABLES (sizeof table_transform_data/sizeof table_transform_data[0])
2988
2989 static void generate_transform_manual(void)
2990 {
2991     IStorage *stg = NULL;
2992     IStream *stm;
2993     WCHAR name[0x20];
2994     HRESULT r;
2995     DWORD i, count;
2996     const DWORD mode = STGM_CREATE|STGM_READWRITE|STGM_DIRECT|STGM_SHARE_EXCLUSIVE;
2997
2998     const CLSID CLSID_MsiTransform = { 0xc1082,0,0,{0xc0,0,0,0,0,0,0,0x46}};
2999
3000     MultiByteToWideChar(CP_ACP, 0, mstfile, -1, name, 0x20);
3001
3002     r = StgCreateDocfile(name, mode, 0, &stg);
3003     ok(r == S_OK, "failed to create storage\n");
3004     if (!stg)
3005         return;
3006
3007     r = IStorage_SetClass( stg, &CLSID_MsiTransform );
3008     ok(r == S_OK, "failed to set storage type\n");
3009
3010     for (i=0; i<NUM_TRANSFORM_TABLES; i++)
3011     {
3012         r = IStorage_CreateStream( stg, table_transform_data[i].name,
3013                             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
3014         if (FAILED(r))
3015         {
3016             ok(0, "failed to create stream %08x\n", r);
3017             continue;
3018         }
3019
3020         r = IStream_Write( stm, table_transform_data[i].data,
3021                           table_transform_data[i].size, &count );
3022         if (FAILED(r) || count != table_transform_data[i].size)
3023             ok(0, "failed to write stream\n");
3024         IStream_Release(stm);
3025     }
3026
3027     IStorage_Release(stg);
3028 }
3029
3030 static UINT set_summary_info(MSIHANDLE hdb)
3031 {
3032     UINT res;
3033     MSIHANDLE suminfo;
3034
3035     /* build summary info */
3036     res = MsiGetSummaryInformationA(hdb, NULL, 7, &suminfo);
3037     ok( res == ERROR_SUCCESS , "Failed to open summaryinfo\n" );
3038
3039     res = MsiSummaryInfoSetPropertyA(suminfo,2, VT_LPSTR, 0,NULL,
3040                         "Installation Database");
3041     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3042
3043     res = MsiSummaryInfoSetPropertyA(suminfo,3, VT_LPSTR, 0,NULL,
3044                         "Installation Database");
3045     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3046
3047     res = MsiSummaryInfoSetPropertyA(suminfo,4, VT_LPSTR, 0,NULL,
3048                         "Wine Hackers");
3049     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3050
3051     res = MsiSummaryInfoSetPropertyA(suminfo,7, VT_LPSTR, 0,NULL,
3052                     ";1033,2057");
3053     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3054
3055     res = MsiSummaryInfoSetPropertyA(suminfo,9, VT_LPSTR, 0,NULL,
3056                     "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}");
3057     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3058
3059     res = MsiSummaryInfoSetPropertyA(suminfo, 14, VT_I4, 100, NULL, NULL);
3060     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3061
3062     res = MsiSummaryInfoSetPropertyA(suminfo, 15, VT_I4, 0, NULL, NULL);
3063     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3064
3065     res = MsiSummaryInfoPersist(suminfo);
3066     ok( res == ERROR_SUCCESS , "Failed to make summary info persist\n" );
3067
3068     res = MsiCloseHandle( suminfo);
3069     ok( res == ERROR_SUCCESS , "Failed to close suminfo\n" );
3070
3071     return res;
3072 }
3073
3074 static MSIHANDLE create_package_db(const WCHAR *filename)
3075 {
3076     MSIHANDLE hdb = 0;
3077     UINT res;
3078
3079     DeleteFileW(msifileW);
3080
3081     /* create an empty database */
3082     res = MsiOpenDatabaseW(filename, MSIDBOPEN_CREATE, &hdb );
3083     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
3084     if( res != ERROR_SUCCESS )
3085         return hdb;
3086
3087     res = MsiDatabaseCommit( hdb );
3088     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
3089
3090     res = set_summary_info(hdb);
3091     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3092
3093     res = create_directory_table(hdb);
3094     ok( res == ERROR_SUCCESS , "Failed to create directory table\n" );
3095
3096     return hdb;
3097 }
3098
3099 static UINT package_from_db(MSIHANDLE hdb, MSIHANDLE *handle)
3100 {
3101     UINT res;
3102     CHAR szPackage[12];
3103     MSIHANDLE hPackage;
3104
3105     sprintf(szPackage, "#%u", hdb);
3106     res = MsiOpenPackageA(szPackage, &hPackage);
3107     if (res != ERROR_SUCCESS)
3108         return res;
3109
3110     res = MsiCloseHandle(hdb);
3111     if (res != ERROR_SUCCESS)
3112     {
3113         MsiCloseHandle(hPackage);
3114         return res;
3115     }
3116
3117     *handle = hPackage;
3118     return ERROR_SUCCESS;
3119 }
3120
3121 static void test_try_transform(void)
3122 {
3123     MSIHANDLE hdb, hview, hrec, hpkg = 0;
3124     LPCSTR query;
3125     UINT r;
3126     DWORD sz;
3127     char buffer[MAX_PATH];
3128
3129     DeleteFileA(msifile);
3130     DeleteFileA(mstfile);
3131
3132     /* create the database */
3133     hdb = create_package_db(msifileW);
3134     ok(hdb, "Failed to create package db\n");
3135
3136     query = "CREATE TABLE `MOO` ( `NOO` SHORT NOT NULL, `OOO` CHAR(255) PRIMARY KEY `NOO`)";
3137     r = run_query(hdb, 0, query);
3138     ok(r == ERROR_SUCCESS, "failed to add table\n");
3139
3140     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 1, 'a' )";
3141     r = run_query(hdb, 0, query);
3142     ok(r == ERROR_SUCCESS, "failed to add row\n");
3143
3144     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 2, 'b' )";
3145     r = run_query(hdb, 0, query);
3146     ok(r == ERROR_SUCCESS, "failed to add row\n");
3147
3148     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 3, 'c' )";
3149     r = run_query(hdb, 0, query);
3150     ok(r == ERROR_SUCCESS, "failed to add row\n");
3151
3152     query = "CREATE TABLE `BINARY` ( `ID` SHORT NOT NULL, `BLOB` OBJECT PRIMARY KEY `ID`)";
3153     r = run_query(hdb, 0, query);
3154     ok(r == ERROR_SUCCESS, "failed to add table\n");
3155
3156     hrec = MsiCreateRecord(2);
3157     r = MsiRecordSetInteger(hrec, 1, 2);
3158     ok(r == ERROR_SUCCESS, "failed to set integer\n");
3159
3160     write_file("testdata.bin", "lamyon", 6);
3161     r = MsiRecordSetStreamA(hrec, 2, "testdata.bin");
3162     ok(r == ERROR_SUCCESS, "failed to set stream\n");
3163
3164     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
3165     r = run_query(hdb, hrec, query);
3166     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
3167
3168     MsiCloseHandle(hrec);
3169
3170     r = MsiDatabaseCommit( hdb );
3171     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
3172
3173     MsiCloseHandle( hdb );
3174     DeleteFileA("testdata.bin");
3175
3176     /*
3177      * Both these generate an equivalent transform,
3178      *  but the first doesn't work in Wine yet
3179      *  because MsiDatabaseGenerateTransform is unimplemented.
3180      */
3181     if (0)
3182         generate_transform();
3183     else
3184         generate_transform_manual();
3185
3186     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_DIRECT, &hdb );
3187     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
3188
3189     r = MsiDatabaseApplyTransformA( hdb, mstfile, 0 );
3190     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
3191
3192     r = MsiDatabaseCommit( hdb );
3193     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
3194
3195     /* check new values */
3196     hrec = 0;
3197     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 1 AND `CAR` = 'vw'";
3198     r = do_query(hdb, query, &hrec);
3199     ok(r == ERROR_SUCCESS, "select query failed\n");
3200     MsiCloseHandle(hrec);
3201
3202     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 2 AND `CAR` = 'bmw'";
3203     hrec = 0;
3204     r = do_query(hdb, query, &hrec);
3205     ok(r == ERROR_SUCCESS, "select query failed\n");
3206     MsiCloseHandle(hrec);
3207
3208     /* check updated values */
3209     hrec = 0;
3210     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 1 AND `OOO` = 'c'";
3211     r = do_query(hdb, query, &hrec);
3212     ok(r == ERROR_SUCCESS, "select query failed\n");
3213     MsiCloseHandle(hrec);
3214
3215     /* check unchanged value */
3216     hrec = 0;
3217     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 2 AND `OOO` = 'b'";
3218     r = do_query(hdb, query, &hrec);
3219     ok(r == ERROR_SUCCESS, "select query failed\n");
3220     MsiCloseHandle(hrec);
3221
3222     /* check deleted value */
3223     hrec = 0;
3224     query = "select * from `MOO` where `NOO` = 3";
3225     r = do_query(hdb, query, &hrec);
3226     ok(r == ERROR_NO_MORE_ITEMS, "select query failed\n");
3227     if (hrec) MsiCloseHandle(hrec);
3228
3229     /* check added stream */
3230     hrec = 0;
3231     query = "select `BLOB` from `BINARY` where `ID` = 1";
3232     r = do_query(hdb, query, &hrec);
3233     ok(r == ERROR_SUCCESS, "select query failed\n");
3234
3235     /* check the contents of the stream */
3236     sz = sizeof buffer;
3237     r = MsiRecordReadStream( hrec, 1, buffer, &sz );
3238     ok(r == ERROR_SUCCESS, "read stream failed\n");
3239     ok(!memcmp(buffer, "naengmyon", 9), "stream data was wrong\n");
3240     ok(sz == 9, "stream data was wrong size\n");
3241     if (hrec) MsiCloseHandle(hrec);
3242
3243     /* check the validity of the table with a deleted row */
3244     hrec = 0;
3245     query = "select * from `MOO`";
3246     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3247     ok(r == ERROR_SUCCESS, "open view failed\n");
3248
3249     r = MsiViewExecute(hview, 0);
3250     ok(r == ERROR_SUCCESS, "view execute failed\n");
3251
3252     r = MsiViewFetch(hview, &hrec);
3253     ok(r == ERROR_SUCCESS, "view fetch failed\n");
3254
3255     r = MsiRecordGetInteger(hrec, 1);
3256     ok(r == 1, "Expected 1, got %d\n", r);
3257
3258     sz = sizeof buffer;
3259     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
3260     ok(r == ERROR_SUCCESS, "record get string failed\n");
3261     ok(!lstrcmpA(buffer, "c"), "Expected c, got %s\n", buffer);
3262
3263     r = MsiRecordGetInteger(hrec, 3);
3264     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3265
3266     r = MsiRecordGetInteger(hrec, 4);
3267     ok(r == 5, "Expected 5, got %d\n", r);
3268
3269     MsiCloseHandle(hrec);
3270
3271     r = MsiViewFetch(hview, &hrec);
3272     ok(r == ERROR_SUCCESS, "view fetch failed\n");
3273
3274     r = MsiRecordGetInteger(hrec, 1);
3275     ok(r == 2, "Expected 2, got %d\n", r);
3276
3277     sz = sizeof buffer;
3278     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
3279     ok(r == ERROR_SUCCESS, "record get string failed\n");
3280     ok(!lstrcmpA(buffer, "b"), "Expected b, got %s\n", buffer);
3281
3282     r = MsiRecordGetInteger(hrec, 3);
3283     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3284
3285     r = MsiRecordGetInteger(hrec, 4);
3286     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3287
3288     MsiCloseHandle(hrec);
3289
3290     r = MsiViewFetch(hview, &hrec);
3291     ok(r == ERROR_NO_MORE_ITEMS, "view fetch succeeded\n");
3292
3293     MsiCloseHandle(hrec);
3294     MsiViewClose(hview);
3295     MsiCloseHandle(hview);
3296
3297     /* check that the property was added */
3298     r = package_from_db(hdb, &hpkg);
3299     if (r == ERROR_INSTALL_PACKAGE_REJECTED)
3300     {
3301         skip("Not enough rights to perform tests\n");
3302         goto error;
3303     }
3304     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
3305
3306     sz = MAX_PATH;
3307     r = MsiGetPropertyA(hpkg, "prop", buffer, &sz);
3308     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3309     ok(!lstrcmpA(buffer, "val"), "Expected val, got %s\n", buffer);
3310
3311     MsiCloseHandle(hpkg);
3312
3313 error:
3314     MsiCloseHandle(hdb);
3315     DeleteFileA(msifile);
3316     DeleteFileA(mstfile);
3317 }
3318
3319 struct join_res
3320 {
3321     const CHAR one[MAX_PATH];
3322     const CHAR two[MAX_PATH];
3323 };
3324
3325 struct join_res_4col
3326 {
3327     const CHAR one[MAX_PATH];
3328     const CHAR two[MAX_PATH];
3329     const CHAR three[MAX_PATH];
3330     const CHAR four[MAX_PATH];
3331 };
3332
3333 struct join_res_uint
3334 {
3335     UINT one;
3336     UINT two;
3337     UINT three;
3338     UINT four;
3339     UINT five;
3340     UINT six;
3341 };
3342
3343 static const struct join_res join_res_first[] =
3344 {
3345     { "alveolar", "procerus" },
3346     { "septum", "procerus" },
3347     { "septum", "nasalis" },
3348     { "ramus", "nasalis" },
3349     { "malar", "mentalis" },
3350 };
3351
3352 static const struct join_res join_res_second[] =
3353 {
3354     { "nasal", "septum" },
3355     { "mandible", "ramus" },
3356 };
3357
3358 static const struct join_res join_res_third[] =
3359 {
3360     { "msvcp.dll", "abcdefgh" },
3361     { "msvcr.dll", "ijklmnop" },
3362 };
3363
3364 static const struct join_res join_res_fourth[] =
3365 {
3366     { "msvcp.dll.01234", "single.dll.31415" },
3367 };
3368
3369 static const struct join_res join_res_fifth[] =
3370 {
3371     { "malar", "procerus" },
3372 };
3373
3374 static const struct join_res join_res_sixth[] =
3375 {
3376     { "malar", "procerus" },
3377     { "malar", "procerus" },
3378     { "malar", "nasalis" },
3379     { "malar", "nasalis" },
3380     { "malar", "nasalis" },
3381     { "malar", "mentalis" },
3382 };
3383
3384 static const struct join_res join_res_seventh[] =
3385 {
3386     { "malar", "nasalis" },
3387     { "malar", "nasalis" },
3388     { "malar", "nasalis" },
3389 };
3390
3391 static const struct join_res_4col join_res_eighth[] =
3392 {
3393     { "msvcp.dll", "msvcp.dll.01234", "msvcp.dll.01234", "abcdefgh" },
3394     { "msvcr.dll", "msvcr.dll.56789", "msvcp.dll.01234", "abcdefgh" },
3395     { "msvcp.dll", "msvcp.dll.01234", "msvcr.dll.56789", "ijklmnop" },
3396     { "msvcr.dll", "msvcr.dll.56789", "msvcr.dll.56789", "ijklmnop" },
3397     { "msvcp.dll", "msvcp.dll.01234", "single.dll.31415", "msvcp.dll" },
3398     { "msvcr.dll", "msvcr.dll.56789", "single.dll.31415", "msvcp.dll" },
3399 };
3400
3401 static const struct join_res_uint join_res_ninth[] =
3402 {
3403     { 1, 2, 3, 4, 7, 8 },
3404     { 1, 2, 5, 6, 7, 8 },
3405     { 1, 2, 3, 4, 9, 10 },
3406     { 1, 2, 5, 6, 9, 10 },
3407     { 1, 2, 3, 4, 11, 12 },
3408     { 1, 2, 5, 6, 11, 12 },
3409 };
3410
3411 static void test_join(void)
3412 {
3413     MSIHANDLE hdb, hview, hrec;
3414     LPCSTR query;
3415     CHAR buf[MAX_PATH];
3416     UINT r, count;
3417     DWORD size, i;
3418     BOOL data_correct;
3419
3420     hdb = create_db();
3421     ok( hdb, "failed to create db\n");
3422
3423     r = create_component_table( hdb );
3424     ok( r == ERROR_SUCCESS, "cannot create Component table: %d\n", r );
3425
3426     r = add_component_entry( hdb, "'zygomatic', 'malar', 'INSTALLDIR', 0, '', ''" );
3427     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3428
3429     r = add_component_entry( hdb, "'maxilla', 'alveolar', 'INSTALLDIR', 0, '', ''" );
3430     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3431
3432     r = add_component_entry( hdb, "'nasal', 'septum', 'INSTALLDIR', 0, '', ''" );
3433     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3434
3435     r = add_component_entry( hdb, "'mandible', 'ramus', 'INSTALLDIR', 0, '', ''" );
3436     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3437
3438     r = create_feature_components_table( hdb );
3439     ok( r == ERROR_SUCCESS, "cannot create FeatureComponents table: %d\n", r );
3440
3441     r = add_feature_components_entry( hdb, "'procerus', 'maxilla'" );
3442     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3443
3444     r = add_feature_components_entry( hdb, "'procerus', 'nasal'" );
3445     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3446
3447     r = add_feature_components_entry( hdb, "'nasalis', 'nasal'" );
3448     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3449
3450     r = add_feature_components_entry( hdb, "'nasalis', 'mandible'" );
3451     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3452
3453     r = add_feature_components_entry( hdb, "'nasalis', 'notacomponent'" );
3454     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3455
3456     r = add_feature_components_entry( hdb, "'mentalis', 'zygomatic'" );
3457     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3458
3459     r = create_std_dlls_table( hdb );
3460     ok( r == ERROR_SUCCESS, "cannot create StdDlls table: %d\n", r );
3461
3462     r = add_std_dlls_entry( hdb, "'msvcp.dll', 'msvcp.dll.01234'" );
3463     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
3464
3465     r = add_std_dlls_entry( hdb, "'msvcr.dll', 'msvcr.dll.56789'" );
3466     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
3467
3468     r = create_binary_table( hdb );
3469     ok( r == ERROR_SUCCESS, "cannot create Binary table: %d\n", r );
3470
3471     r = add_binary_entry( hdb, "'msvcp.dll.01234', 'abcdefgh'" );
3472     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3473
3474     r = add_binary_entry( hdb, "'msvcr.dll.56789', 'ijklmnop'" );
3475     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3476
3477     r = add_binary_entry( hdb, "'single.dll.31415', 'msvcp.dll'" );
3478     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3479
3480     query = "CREATE TABLE `One` (`A` SHORT, `B` SHORT PRIMARY KEY `A`)";
3481     r = run_query( hdb, 0, query);
3482     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3483
3484     query = "CREATE TABLE `Two` (`C` SHORT, `D` SHORT PRIMARY KEY `C`)";
3485     r = run_query( hdb, 0, query);
3486     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3487
3488     query = "CREATE TABLE `Three` (`E` SHORT, `F` SHORT PRIMARY KEY `E`)";
3489     r = run_query( hdb, 0, query);
3490     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3491
3492     query = "INSERT INTO `One` (`A`, `B`) VALUES (1, 2)";
3493     r = run_query( hdb, 0, query);
3494     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3495
3496     query = "INSERT INTO `Two` (`C`, `D`) VALUES (3, 4)";
3497     r = run_query( hdb, 0, query);
3498     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3499
3500     query = "INSERT INTO `Two` (`C`, `D`) VALUES (5, 6)";
3501     r = run_query( hdb, 0, query);
3502     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3503
3504     query = "INSERT INTO `Three` (`E`, `F`) VALUES (7, 8)";
3505     r = run_query( hdb, 0, query);
3506     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3507
3508     query = "INSERT INTO `Three` (`E`, `F`) VALUES (9, 10)";
3509     r = run_query( hdb, 0, query);
3510     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3511
3512     query = "INSERT INTO `Three` (`E`, `F`) VALUES (11, 12)";
3513     r = run_query( hdb, 0, query);
3514     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3515
3516     query = "CREATE TABLE `Four` (`G` SHORT, `H` SHORT PRIMARY KEY `G`)";
3517     r = run_query( hdb, 0, query);
3518     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3519
3520     query = "CREATE TABLE `Five` (`I` SHORT, `J` SHORT PRIMARY KEY `I`)";
3521     r = run_query( hdb, 0, query);
3522     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3523
3524     query = "INSERT INTO `Five` (`I`, `J`) VALUES (13, 14)";
3525     r = run_query( hdb, 0, query);
3526     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3527
3528     query = "INSERT INTO `Five` (`I`, `J`) VALUES (15, 16)";
3529     r = run_query( hdb, 0, query);
3530     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3531
3532     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3533             "FROM `Component`, `FeatureComponents` "
3534             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
3535             "ORDER BY `Feature_`";
3536     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3537     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3538
3539     r = MsiViewExecute(hview, 0);
3540     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3541
3542     i = 0;
3543     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3544     {
3545         count = MsiRecordGetFieldCount( hrec );
3546         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3547
3548         size = MAX_PATH;
3549         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3550         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3551         ok( !lstrcmpA( buf, join_res_first[i].one ),
3552             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_first[i].one, buf );
3553
3554         size = MAX_PATH;
3555         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3556         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3557         ok( !lstrcmpA( buf, join_res_first[i].two ),
3558             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_first[i].two, buf );
3559
3560         i++;
3561         MsiCloseHandle(hrec);
3562     }
3563
3564     ok( i == 5, "Expected 5 rows, got %d\n", i );
3565     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3566
3567     MsiViewClose(hview);
3568     MsiCloseHandle(hview);
3569
3570     /* try a join without a WHERE condition */
3571     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3572             "FROM `Component`, `FeatureComponents` ";
3573     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3574     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3575
3576     r = MsiViewExecute(hview, 0);
3577     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3578
3579     i = 0;
3580     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3581     {
3582         i++;
3583         MsiCloseHandle(hrec);
3584     }
3585     ok( i == 24, "Expected 24 rows, got %d\n", i );
3586
3587     MsiViewClose(hview);
3588     MsiCloseHandle(hview);
3589
3590     query = "SELECT DISTINCT Component, ComponentId FROM FeatureComponents, Component "
3591             "WHERE FeatureComponents.Component_=Component.Component "
3592             "AND (Feature_='nasalis') ORDER BY Feature_";
3593     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3594     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3595
3596     r = MsiViewExecute(hview, 0);
3597     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3598
3599     i = 0;
3600     data_correct = TRUE;
3601     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3602     {
3603         count = MsiRecordGetFieldCount( hrec );
3604         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3605
3606         size = MAX_PATH;
3607         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3608         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3609         if( lstrcmpA( buf, join_res_second[i].one ))
3610             data_correct = FALSE;
3611
3612         size = MAX_PATH;
3613         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3614         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3615         if( lstrcmpA( buf, join_res_second[i].two ))
3616             data_correct = FALSE;
3617
3618         i++;
3619         MsiCloseHandle(hrec);
3620     }
3621
3622     ok( data_correct, "data returned in the wrong order\n");
3623
3624     ok( i == 2, "Expected 2 rows, got %d\n", i );
3625     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3626
3627     MsiViewClose(hview);
3628     MsiCloseHandle(hview);
3629
3630     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
3631             "FROM `StdDlls`, `Binary` "
3632             "WHERE `StdDlls`.`Binary_` = `Binary`.`Name` "
3633             "ORDER BY `File`";
3634     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3635     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3636
3637     r = MsiViewExecute(hview, 0);
3638     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3639
3640     i = 0;
3641     data_correct = TRUE;
3642     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3643     {
3644         count = MsiRecordGetFieldCount( hrec );
3645         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3646
3647         size = MAX_PATH;
3648         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3649         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3650         if( lstrcmpA( buf, join_res_third[i].one ) )
3651             data_correct = FALSE;
3652
3653         size = MAX_PATH;
3654         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3655         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3656         if( lstrcmpA( buf, join_res_third[i].two ) )
3657             data_correct = FALSE;
3658
3659         i++;
3660         MsiCloseHandle(hrec);
3661     }
3662     ok( data_correct, "data returned in the wrong order\n");
3663
3664     ok( i == 2, "Expected 2 rows, got %d\n", i );
3665
3666     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3667
3668     MsiViewClose(hview);
3669     MsiCloseHandle(hview);
3670
3671     query = "SELECT `StdDlls`.`Binary_`, `Binary`.`Name` "
3672             "FROM `StdDlls`, `Binary` "
3673             "WHERE `StdDlls`.`File` = `Binary`.`Data` "
3674             "ORDER BY `Name`";
3675     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3676     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3677
3678     r = MsiViewExecute(hview, 0);
3679     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3680
3681     i = 0;
3682     data_correct = TRUE;
3683     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3684     {
3685         count = MsiRecordGetFieldCount( hrec );
3686         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3687
3688         size = MAX_PATH;
3689         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3690         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3691         if( lstrcmpA( buf, join_res_fourth[i].one ))
3692             data_correct = FALSE;
3693
3694         size = MAX_PATH;
3695         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3696         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3697         if( lstrcmpA( buf, join_res_fourth[i].two ))
3698             data_correct = FALSE;
3699
3700         i++;
3701         MsiCloseHandle(hrec);
3702     }
3703     ok( data_correct, "data returned in the wrong order\n");
3704
3705     ok( i == 1, "Expected 1 rows, got %d\n", i );
3706     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3707
3708     MsiViewClose(hview);
3709     MsiCloseHandle(hview);
3710
3711     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3712             "FROM `Component`, `FeatureComponents` "
3713             "WHERE `Component`.`Component` = 'zygomatic' "
3714             "AND `FeatureComponents`.`Component_` = 'maxilla' "
3715             "ORDER BY `Feature_`";
3716     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3717     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3718
3719     r = MsiViewExecute(hview, 0);
3720     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3721
3722     i = 0;
3723     data_correct = TRUE;
3724     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3725     {
3726         count = MsiRecordGetFieldCount( hrec );
3727         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3728
3729         size = MAX_PATH;
3730         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3731         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3732         if( lstrcmpA( buf, join_res_fifth[i].one ))
3733             data_correct = FALSE;
3734
3735         size = MAX_PATH;
3736         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3737         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3738         if( lstrcmpA( buf, join_res_fifth[i].two ))
3739             data_correct = FALSE;
3740
3741         i++;
3742         MsiCloseHandle(hrec);
3743     }
3744     ok( data_correct, "data returned in the wrong order\n");
3745
3746     ok( i == 1, "Expected 1 rows, got %d\n", i );
3747     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3748
3749     MsiViewClose(hview);
3750     MsiCloseHandle(hview);
3751
3752     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3753             "FROM `Component`, `FeatureComponents` "
3754             "WHERE `Component` = 'zygomatic' "
3755             "ORDER BY `Feature_`";
3756     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3757     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3758
3759     r = MsiViewExecute(hview, 0);
3760     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3761
3762     i = 0;
3763     data_correct = TRUE;
3764     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3765     {
3766         count = MsiRecordGetFieldCount( hrec );
3767         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3768
3769         size = MAX_PATH;
3770         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3771         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3772         if( lstrcmpA( buf, join_res_sixth[i].one ))
3773             data_correct = FALSE;
3774
3775         size = MAX_PATH;
3776         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3777         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3778         if( lstrcmpA( buf, join_res_sixth[i].two ))
3779             data_correct = FALSE;
3780
3781         i++;
3782         MsiCloseHandle(hrec);
3783     }
3784     ok( data_correct, "data returned in the wrong order\n");
3785
3786     ok( i == 6, "Expected 6 rows, got %d\n", i );
3787     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3788
3789     MsiViewClose(hview);
3790     MsiCloseHandle(hview);
3791
3792     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3793             "FROM `Component`, `FeatureComponents` "
3794             "WHERE `Component` = 'zygomatic' "
3795             "AND `Feature_` = 'nasalis' "
3796             "ORDER BY `Feature_`";
3797     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3798     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3799
3800     r = MsiViewExecute(hview, 0);
3801     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3802
3803     i = 0;
3804     data_correct = TRUE;
3805     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3806     {
3807         count = MsiRecordGetFieldCount( hrec );
3808         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3809
3810         size = MAX_PATH;
3811         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3812         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3813         if( lstrcmpA( buf, join_res_seventh[i].one ))
3814             data_correct = FALSE;
3815
3816         size = MAX_PATH;
3817         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3818         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3819         if( lstrcmpA( buf, join_res_seventh[i].two ))
3820             data_correct = FALSE;
3821
3822         i++;
3823         MsiCloseHandle(hrec);
3824     }
3825
3826     ok( data_correct, "data returned in the wrong order\n");
3827     ok( i == 3, "Expected 3 rows, got %d\n", i );
3828     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3829
3830     MsiViewClose(hview);
3831     MsiCloseHandle(hview);
3832
3833     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
3834             "FROM `StdDlls`, `Binary` ";
3835     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3836     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3837
3838     r = MsiViewExecute(hview, 0);
3839     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3840
3841     i = 0;
3842     data_correct = TRUE;
3843     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3844     {
3845         count = MsiRecordGetFieldCount( hrec );
3846         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3847
3848         size = MAX_PATH;
3849         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3850         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3851         if( lstrcmpA( buf, join_res_eighth[i].one ))
3852             data_correct = FALSE;
3853
3854         size = MAX_PATH;
3855         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3856         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3857         if( lstrcmpA( buf, join_res_eighth[i].four ))
3858             data_correct = FALSE;
3859
3860         i++;
3861         MsiCloseHandle(hrec);
3862     }
3863
3864     ok( data_correct, "data returned in the wrong order\n");
3865     ok( i == 6, "Expected 6 rows, got %d\n", i );
3866     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3867
3868     MsiViewClose(hview);
3869     MsiCloseHandle(hview);
3870
3871     query = "SELECT * FROM `StdDlls`, `Binary` ";
3872     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3873     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3874
3875     r = MsiViewExecute(hview, 0);
3876     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3877
3878     i = 0;
3879     data_correct = TRUE;
3880     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3881     {
3882         count = MsiRecordGetFieldCount( hrec );
3883         ok( count == 4, "Expected 4 record fields, got %d\n", count );
3884
3885         size = MAX_PATH;
3886         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3887         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3888         if( lstrcmpA( buf, join_res_eighth[i].one ))
3889             data_correct = FALSE;
3890
3891         size = MAX_PATH;
3892         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3893         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3894         if( lstrcmpA( buf, join_res_eighth[i].two ))
3895             data_correct = FALSE;
3896
3897         size = MAX_PATH;
3898         r = MsiRecordGetStringA( hrec, 3, buf, &size );
3899         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3900         if( lstrcmpA( buf, join_res_eighth[i].three ))
3901             data_correct = FALSE;
3902
3903         size = MAX_PATH;
3904         r = MsiRecordGetStringA( hrec, 4, buf, &size );
3905         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3906         if( lstrcmpA( buf, join_res_eighth[i].four ))
3907             data_correct = FALSE;
3908
3909         i++;
3910         MsiCloseHandle(hrec);
3911     }
3912     ok( data_correct, "data returned in the wrong order\n");
3913
3914     ok( i == 6, "Expected 6 rows, got %d\n", i );
3915     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3916
3917     MsiViewClose(hview);
3918     MsiCloseHandle(hview);
3919
3920     query = "SELECT * FROM `One`, `Two`, `Three` ";
3921     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3922     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3923
3924     r = MsiViewExecute(hview, 0);
3925     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3926
3927     i = 0;
3928     data_correct = TRUE;
3929     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3930     {
3931         count = MsiRecordGetFieldCount( hrec );
3932         ok( count == 6, "Expected 6 record fields, got %d\n", count );
3933
3934         r = MsiRecordGetInteger( hrec, 1 );
3935         if( r != join_res_ninth[i].one )
3936             data_correct = FALSE;
3937
3938         r = MsiRecordGetInteger( hrec, 2 );
3939         if( r != join_res_ninth[i].two )
3940             data_correct = FALSE;
3941
3942         r = MsiRecordGetInteger( hrec, 3 );
3943         if( r != join_res_ninth[i].three )
3944             data_correct = FALSE;
3945
3946         r = MsiRecordGetInteger( hrec, 4 );
3947         if( r != join_res_ninth[i].four )
3948             data_correct = FALSE;
3949
3950         r = MsiRecordGetInteger( hrec, 5 );
3951         if( r != join_res_ninth[i].five )
3952             data_correct = FALSE;
3953
3954         r = MsiRecordGetInteger( hrec, 6);
3955         if( r != join_res_ninth[i].six )
3956             data_correct = FALSE;
3957
3958         i++;
3959         MsiCloseHandle(hrec);
3960     }
3961     ok( data_correct, "data returned in the wrong order\n");
3962
3963     ok( i == 6, "Expected 6 rows, got %d\n", i );
3964     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3965
3966     MsiViewClose(hview);
3967     MsiCloseHandle(hview);
3968
3969     query = "SELECT * FROM `Four`, `Five`";
3970     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3971     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3972
3973     r = MsiViewExecute(hview, 0);
3974     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3975
3976     r = MsiViewFetch(hview, &hrec);
3977     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3978
3979     MsiViewClose(hview);
3980     MsiCloseHandle(hview);
3981
3982     query = "SELECT * FROM `Nonexistent`, `One`";
3983     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3984     ok( r == ERROR_BAD_QUERY_SYNTAX,
3985         "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r );
3986
3987     /* try updating a row in a join table */
3988     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3989             "FROM `Component`, `FeatureComponents` "
3990             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
3991             "ORDER BY `Feature_`";
3992     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3993     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3994
3995     r = MsiViewExecute(hview, 0);
3996     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3997
3998     r = MsiViewFetch(hview, &hrec);
3999     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
4000
4001     r = MsiRecordSetStringA( hrec, 1, "epicranius" );
4002     ok( r == ERROR_SUCCESS, "failed to set string: %d\n", r );
4003
4004     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
4005     ok( r == ERROR_SUCCESS, "failed to update row: %d\n", r );
4006
4007     /* try another valid operation for joins */
4008     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
4009     todo_wine ok( r == ERROR_SUCCESS, "failed to refresh row: %d\n", r );
4010
4011     /* try an invalid operation for joins */
4012     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
4013     ok( r == ERROR_FUNCTION_FAILED, "unexpected result: %d\n", r );
4014
4015     r = MsiRecordSetStringA( hrec, 2, "epicranius" );
4016     ok( r == ERROR_SUCCESS, "failed to set string: %d\n", r );
4017
4018     /* primary key cannot be updated */
4019     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
4020     ok( r == ERROR_FUNCTION_FAILED, "failed to update row: %d\n", r );
4021
4022     MsiCloseHandle(hrec);
4023     MsiViewClose(hview);
4024     MsiCloseHandle(hview);
4025
4026     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4027     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4028
4029     r = MsiViewExecute(hview, 0);
4030     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4031
4032     r = MsiViewFetch(hview, &hrec);
4033     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4034
4035     size = MAX_PATH;
4036     r = MsiRecordGetStringA( hrec, 1, buf, &size );
4037     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
4038     ok( !lstrcmpA( buf, "epicranius" ), "expected 'epicranius', got %s\n", buf );
4039
4040     MsiCloseHandle(hrec);
4041     MsiViewClose(hview);
4042     MsiCloseHandle(hview);
4043
4044     MsiCloseHandle(hdb);
4045     DeleteFileA(msifile);
4046 }
4047
4048 static void test_temporary_table(void)
4049 {
4050     MSICONDITION cond;
4051     MSIHANDLE hdb = 0, view = 0, rec;
4052     const char *query;
4053     UINT r;
4054     char buf[0x10];
4055     DWORD sz;
4056
4057     cond = MsiDatabaseIsTablePersistentA(0, NULL);
4058     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
4059
4060     hdb = create_db();
4061     ok( hdb, "failed to create db\n");
4062
4063     cond = MsiDatabaseIsTablePersistentA(hdb, NULL);
4064     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
4065
4066     cond = MsiDatabaseIsTablePersistentA(hdb, "_Tables");
4067     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4068
4069     cond = MsiDatabaseIsTablePersistentA(hdb, "_Columns");
4070     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4071
4072     cond = MsiDatabaseIsTablePersistentA(hdb, "_Storages");
4073     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4074
4075     cond = MsiDatabaseIsTablePersistentA(hdb, "_Streams");
4076     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4077
4078     query = "CREATE TABLE `P` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`)";
4079     r = run_query(hdb, 0, query);
4080     ok(r == ERROR_SUCCESS, "failed to add table\n");
4081
4082     cond = MsiDatabaseIsTablePersistentA(hdb, "P");
4083     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
4084
4085     query = "CREATE TABLE `P2` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`) HOLD";
4086     r = run_query(hdb, 0, query);
4087     ok(r == ERROR_SUCCESS, "failed to add table\n");
4088
4089     cond = MsiDatabaseIsTablePersistentA(hdb, "P2");
4090     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
4091
4092     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
4093     r = run_query(hdb, 0, query);
4094     ok(r == ERROR_SUCCESS, "failed to add table\n");
4095
4096     cond = MsiDatabaseIsTablePersistentA(hdb, "T");
4097     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
4098
4099     query = "CREATE TABLE `T2` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
4100     r = run_query(hdb, 0, query);
4101     ok(r == ERROR_SUCCESS, "failed to add table\n");
4102
4103     query = "SELECT * FROM `T2`";
4104     r = MsiDatabaseOpenViewA(hdb, query, &view);
4105     ok(r == ERROR_BAD_QUERY_SYNTAX,
4106        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4107
4108     cond = MsiDatabaseIsTablePersistentA(hdb, "T2");
4109     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4110
4111     query = "CREATE TABLE `T3` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) PRIMARY KEY `C`)";
4112     r = run_query(hdb, 0, query);
4113     ok(r == ERROR_SUCCESS, "failed to add table\n");
4114
4115     cond = MsiDatabaseIsTablePersistentA(hdb, "T3");
4116     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
4117
4118     query = "CREATE TABLE `T4` ( `B` SHORT NOT NULL, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
4119     r = run_query(hdb, 0, query);
4120     ok(r == ERROR_FUNCTION_FAILED, "failed to add table\n");
4121
4122     cond = MsiDatabaseIsTablePersistentA(hdb, "T4");
4123     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4124
4125     query = "CREATE TABLE `T5` ( `B` SHORT NOT NULL TEMP, `C` CHAR(255) TEMP PRIMARY KEY `C`) HOLD";
4126     r = run_query(hdb, 0, query);
4127     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to add table\n");
4128
4129     query = "select * from `T`";
4130     r = MsiDatabaseOpenViewA(hdb, query, &view);
4131     ok(r == ERROR_SUCCESS, "failed to query table\n");
4132     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
4133     ok(r == ERROR_SUCCESS, "failed to get column info\n");
4134
4135     sz = sizeof buf;
4136     r = MsiRecordGetStringA(rec, 1, buf, &sz);
4137     ok(r == ERROR_SUCCESS, "failed to get string\n");
4138     ok( 0 == strcmp("G255", buf), "wrong column type\n");
4139
4140     sz = sizeof buf;
4141     r = MsiRecordGetStringA(rec, 2, buf, &sz);
4142     ok(r == ERROR_SUCCESS, "failed to get string\n");
4143     ok( 0 == strcmp("j2", buf), "wrong column type\n");
4144
4145     MsiCloseHandle( rec );
4146     MsiViewClose( view );
4147     MsiCloseHandle( view );
4148
4149     /* query the table data */
4150     rec = 0;
4151     r = do_query(hdb, "select * from `_Tables` where `Name` = 'T'", &rec);
4152     ok( r == ERROR_SUCCESS, "temporary table exists in _Tables\n");
4153     MsiCloseHandle( rec );
4154
4155     /* query the column data */
4156     rec = 0;
4157     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'B'", &rec);
4158     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
4159     if (rec) MsiCloseHandle( rec );
4160
4161     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'C'", &rec);
4162     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
4163     if (rec) MsiCloseHandle( rec );
4164
4165     MsiCloseHandle( hdb );
4166     DeleteFileA(msifile);
4167 }
4168
4169 static void test_alter(void)
4170 {
4171     MSICONDITION cond;
4172     MSIHANDLE hdb = 0;
4173     const char *query;
4174     UINT r;
4175
4176     hdb = create_db();
4177     ok( hdb, "failed to create db\n");
4178
4179     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
4180     r = run_query(hdb, 0, query);
4181     ok(r == ERROR_SUCCESS, "failed to add table\n");
4182
4183     cond = MsiDatabaseIsTablePersistentA(hdb, "T");
4184     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
4185
4186     query = "ALTER TABLE `T` HOLD";
4187     r = run_query(hdb, 0, query);
4188     ok(r == ERROR_SUCCESS, "failed to hold table %d\n", r);
4189
4190     query = "ALTER TABLE `T` FREE";
4191     r = run_query(hdb, 0, query);
4192     ok(r == ERROR_SUCCESS, "failed to free table\n");
4193
4194     query = "ALTER TABLE `T` FREE";
4195     r = run_query(hdb, 0, query);
4196     ok(r == ERROR_SUCCESS, "failed to free table\n");
4197
4198     query = "ALTER TABLE `T` FREE";
4199     r = run_query(hdb, 0, query);
4200     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to free table\n");
4201
4202     query = "ALTER TABLE `T` HOLD";
4203     r = run_query(hdb, 0, query);
4204     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to hold table %d\n", r);
4205
4206     /* table T is removed */
4207     query = "SELECT * FROM `T`";
4208     r = run_query(hdb, 0, query);
4209     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4210
4211     /* create the table again */
4212     query = "CREATE TABLE `U` ( `A` INTEGER, `B` INTEGER PRIMARY KEY `B`)";
4213     r = run_query(hdb, 0, query);
4214     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4215
4216     /* up the ref count */
4217     query = "ALTER TABLE `U` HOLD";
4218     r = run_query(hdb, 0, query);
4219     ok(r == ERROR_SUCCESS, "failed to free table\n");
4220
4221     /* add column, no data type */
4222     query = "ALTER TABLE `U` ADD `C`";
4223     r = run_query(hdb, 0, query);
4224     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4225
4226     query = "ALTER TABLE `U` ADD `C` INTEGER";
4227     r = run_query(hdb, 0, query);
4228     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4229
4230     /* add column C again */
4231     query = "ALTER TABLE `U` ADD `C` INTEGER";
4232     r = run_query(hdb, 0, query);
4233     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4234
4235     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY";
4236     r = run_query(hdb, 0, query);
4237     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4238
4239     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 1, 2, 3, 4 )";
4240     r = run_query(hdb, 0, query);
4241     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4242
4243     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY HOLD";
4244     r = run_query(hdb, 0, query);
4245     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4246
4247     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 5, 6, 7, 8 )";
4248     r = run_query(hdb, 0, query);
4249     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4250
4251     query = "SELECT * FROM `U` WHERE `D` = 8";
4252     r = run_query(hdb, 0, query);
4253     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4254
4255     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY FREE";
4256     r = run_query(hdb, 0, query);
4257     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4258
4259     query = "ALTER COLUMN `D` FREE";
4260     r = run_query(hdb, 0, query);
4261     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4262
4263     /* drop the ref count */
4264     query = "ALTER TABLE `U` FREE";
4265     r = run_query(hdb, 0, query);
4266     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4267
4268     /* table is not empty */
4269     query = "SELECT * FROM `U`";
4270     r = run_query(hdb, 0, query);
4271     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4272
4273     /* column D is removed */
4274     query = "SELECT * FROM `U` WHERE `D` = 8";
4275     r = run_query(hdb, 0, query);
4276     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4277
4278     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 9, 10, 11, 12 )";
4279     r = run_query(hdb, 0, query);
4280     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4281
4282     /* add the column again */
4283     query = "ALTER TABLE `U` ADD `E` INTEGER TEMPORARY HOLD";
4284     r = run_query(hdb, 0, query);
4285     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4286
4287     /* up the ref count */
4288     query = "ALTER TABLE `U` HOLD";
4289     r = run_query(hdb, 0, query);
4290     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4291
4292     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 13, 14, 15, 16 )";
4293     r = run_query(hdb, 0, query);
4294     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4295
4296     query = "SELECT * FROM `U` WHERE `E` = 16";
4297     r = run_query(hdb, 0, query);
4298     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4299
4300     /* drop the ref count */
4301     query = "ALTER TABLE `U` FREE";
4302     r = run_query(hdb, 0, query);
4303     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4304
4305     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 17, 18, 19, 20 )";
4306     r = run_query(hdb, 0, query);
4307     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4308
4309     query = "SELECT * FROM `U` WHERE `E` = 20";
4310     r = run_query(hdb, 0, query);
4311     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4312
4313     /* drop the ref count */
4314     query = "ALTER TABLE `U` FREE";
4315     r = run_query(hdb, 0, query);
4316     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4317
4318     /* table still exists */
4319     query = "SELECT * FROM `U`";
4320     r = run_query(hdb, 0, query);
4321     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4322
4323     /* col E is removed */
4324     query = "SELECT * FROM `U` WHERE `E` = 20";
4325     r = run_query(hdb, 0, query);
4326     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4327
4328     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 20, 21, 22, 23 )";
4329     r = run_query(hdb, 0, query);
4330     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4331
4332     /* drop the ref count once more */
4333     query = "ALTER TABLE `U` FREE";
4334     r = run_query(hdb, 0, query);
4335     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4336
4337     /* table still exists */
4338     query = "SELECT * FROM `U`";
4339     r = run_query(hdb, 0, query);
4340     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4341
4342     MsiCloseHandle( hdb );
4343     DeleteFileA(msifile);
4344 }
4345
4346 static void test_integers(void)
4347 {
4348     MSIHANDLE hdb = 0, view = 0, rec = 0;
4349     DWORD count, i;
4350     const char *query;
4351     UINT r;
4352
4353     /* just MsiOpenDatabase should not create a file */
4354     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4355     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4356
4357     /* create a table */
4358     query = "CREATE TABLE `integers` ( "
4359             "`one` SHORT, `two` INT, `three` INTEGER, `four` LONG, "
4360             "`five` SHORT NOT NULL, `six` INT NOT NULL, "
4361             "`seven` INTEGER NOT NULL, `eight` LONG NOT NULL "
4362             "PRIMARY KEY `one`)";
4363     r = MsiDatabaseOpenViewA(hdb, query, &view);
4364     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4365     r = MsiViewExecute(view, 0);
4366     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4367     r = MsiViewClose(view);
4368     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4369     r = MsiCloseHandle(view);
4370     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4371
4372     query = "SELECT * FROM `integers`";
4373     r = MsiDatabaseOpenViewA(hdb, query, &view);
4374     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4375
4376     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
4377     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4378     count = MsiRecordGetFieldCount(rec);
4379     ok(count == 8, "Expected 8, got %d\n", count);
4380     ok(check_record(rec, 1, "one"), "Expected one\n");
4381     ok(check_record(rec, 2, "two"), "Expected two\n");
4382     ok(check_record(rec, 3, "three"), "Expected three\n");
4383     ok(check_record(rec, 4, "four"), "Expected four\n");
4384     ok(check_record(rec, 5, "five"), "Expected five\n");
4385     ok(check_record(rec, 6, "six"), "Expected six\n");
4386     ok(check_record(rec, 7, "seven"), "Expected seven\n");
4387     ok(check_record(rec, 8, "eight"), "Expected eight\n");
4388     MsiCloseHandle(rec);
4389
4390     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
4391     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4392     count = MsiRecordGetFieldCount(rec);
4393     ok(count == 8, "Expected 8, got %d\n", count);
4394     ok(check_record(rec, 1, "I2"), "Expected I2\n");
4395     ok(check_record(rec, 2, "I2"), "Expected I2\n");
4396     ok(check_record(rec, 3, "I2"), "Expected I2\n");
4397     ok(check_record(rec, 4, "I4"), "Expected I4\n");
4398     ok(check_record(rec, 5, "i2"), "Expected i2\n");
4399     ok(check_record(rec, 6, "i2"), "Expected i2\n");
4400     ok(check_record(rec, 7, "i2"), "Expected i2\n");
4401     ok(check_record(rec, 8, "i4"), "Expected i4\n");
4402     MsiCloseHandle(rec);
4403
4404     MsiViewClose(view);
4405     MsiCloseHandle(view);
4406
4407     /* insert values into it, NULL where NOT NULL is specified */
4408     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
4409         "VALUES('', '', '', '', '', '', '', '')";
4410     r = MsiDatabaseOpenViewA(hdb, query, &view);
4411     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4412     r = MsiViewExecute(view, 0);
4413     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
4414
4415     MsiViewClose(view);
4416     MsiCloseHandle(view);
4417
4418     query = "SELECT * FROM `integers`";
4419     r = do_query(hdb, query, &rec);
4420     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4421
4422     r = MsiRecordGetFieldCount(rec);
4423     ok(r == -1, "record count wrong: %d\n", r);
4424
4425     MsiCloseHandle(rec);
4426
4427     /* insert legitimate values into it */
4428     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
4429         "VALUES('', '2', '', '4', '5', '6', '7', '8')";
4430     r = MsiDatabaseOpenViewA(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
4435     query = "SELECT * FROM `integers`";
4436     r = do_query(hdb, query, &rec);
4437     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4438
4439     r = MsiRecordGetFieldCount(rec);
4440     ok(r == 8, "record count wrong: %d\n", r);
4441
4442     i = MsiRecordGetInteger(rec, 1);
4443     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
4444     i = MsiRecordGetInteger(rec, 3);
4445     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
4446     i = MsiRecordGetInteger(rec, 2);
4447     ok(i == 2, "Expected 2, got %d\n", i);
4448     i = MsiRecordGetInteger(rec, 4);
4449     ok(i == 4, "Expected 4, got %d\n", i);
4450     i = MsiRecordGetInteger(rec, 5);
4451     ok(i == 5, "Expected 5, got %d\n", i);
4452     i = MsiRecordGetInteger(rec, 6);
4453     ok(i == 6, "Expected 6, got %d\n", i);
4454     i = MsiRecordGetInteger(rec, 7);
4455     ok(i == 7, "Expected 7, got %d\n", i);
4456     i = MsiRecordGetInteger(rec, 8);
4457     ok(i == 8, "Expected 8, got %d\n", i);
4458
4459     MsiCloseHandle(rec);
4460     MsiViewClose(view);
4461     MsiCloseHandle(view);
4462
4463     r = MsiDatabaseCommit(hdb);
4464     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
4465
4466     r = MsiCloseHandle(hdb);
4467     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4468
4469     r = DeleteFileA(msifile);
4470     ok(r == TRUE, "file didn't exist after commit\n");
4471 }
4472
4473 static void test_update(void)
4474 {
4475     MSIHANDLE hdb = 0, view = 0, rec = 0;
4476     CHAR result[MAX_PATH];
4477     const char *query;
4478     DWORD size;
4479     UINT r;
4480
4481     /* just MsiOpenDatabase should not create a file */
4482     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4483     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4484
4485     /* create the Control table */
4486     query = "CREATE TABLE `Control` ( "
4487         "`Dialog_` CHAR(72) NOT NULL, `Control` CHAR(50) NOT NULL, `Type` SHORT NOT NULL, "
4488         "`X` SHORT NOT NULL, `Y` SHORT NOT NULL, `Width` SHORT NOT NULL, `Height` SHORT NOT NULL,"
4489         "`Attributes` LONG, `Property` CHAR(50), `Text` CHAR(0) LOCALIZABLE, "
4490         "`Control_Next` CHAR(50), `Help` CHAR(50) LOCALIZABLE PRIMARY KEY `Dialog_`, `Control`)";
4491     r = MsiDatabaseOpenViewA(hdb, query, &view);
4492     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4493     r = MsiViewExecute(view, 0);
4494     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4495     r = MsiViewClose(view);
4496     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4497     r = MsiCloseHandle(view);
4498     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4499
4500     /* add a control */
4501     query = "INSERT INTO `Control` ( "
4502         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4503         "`Property`, `Text`, `Control_Next`, `Help` )"
4504         "VALUES('ErrorDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
4505     r = MsiDatabaseOpenViewA(hdb, query, &view);
4506     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4507     r = MsiViewExecute(view, 0);
4508     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4509     r = MsiViewClose(view);
4510     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4511     r = MsiCloseHandle(view);
4512     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4513
4514     /* add a second control */
4515     query = "INSERT INTO `Control` ( "
4516         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4517         "`Property`, `Text`, `Control_Next`, `Help` )"
4518         "VALUES('ErrorDialog', 'Button', '1', '5', '5', '5', '5', '', '', '', '')";
4519     r = MsiDatabaseOpenViewA(hdb, query, &view);
4520     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4521     r = MsiViewExecute(view, 0);
4522     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4523     r = MsiViewClose(view);
4524     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4525     r = MsiCloseHandle(view);
4526     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4527
4528     /* add a third control */
4529     query = "INSERT INTO `Control` ( "
4530         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4531         "`Property`, `Text`, `Control_Next`, `Help` )"
4532         "VALUES('AnotherDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
4533     r = MsiDatabaseOpenViewA(hdb, query, &view);
4534     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4535     r = MsiViewExecute(view, 0);
4536     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4537     r = MsiViewClose(view);
4538     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4539     r = MsiCloseHandle(view);
4540     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4541
4542     /* bad table */
4543     query = "UPDATE `NotATable` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4544     r = MsiDatabaseOpenViewA(hdb, query, &view);
4545     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4546
4547     /* bad set column */
4548     query = "UPDATE `Control` SET `NotAColumn` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4549     r = MsiDatabaseOpenViewA(hdb, query, &view);
4550     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4551
4552     /* bad where condition */
4553     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `NotAColumn` = 'ErrorDialog'";
4554     r = MsiDatabaseOpenViewA(hdb, query, &view);
4555     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4556
4557     /* just the dialog_ specified */
4558     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4559     r = MsiDatabaseOpenViewA(hdb, query, &view);
4560     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4561     r = MsiViewExecute(view, 0);
4562     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4563     r = MsiViewClose(view);
4564     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4565     r = MsiCloseHandle(view);
4566     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4567
4568     /* check the modified text */
4569     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
4570     r = MsiDatabaseOpenViewA(hdb, query, &view);
4571     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4572     r = MsiViewExecute(view, 0);
4573     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4574
4575     r = MsiViewFetch(view, &rec);
4576     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4577
4578     size = MAX_PATH;
4579     r = MsiRecordGetStringA(rec, 1, result, &size);
4580     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4581     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4582
4583     MsiCloseHandle(rec);
4584
4585     r = MsiViewFetch(view, &rec);
4586     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4587
4588     size = MAX_PATH;
4589     r = MsiRecordGetStringA(rec, 1, result, &size);
4590     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4591     ok(!result[0], "Expected an empty string, got %s\n", result);
4592
4593     MsiCloseHandle(rec);
4594
4595     r = MsiViewFetch(view, &rec);
4596     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4597
4598     r = MsiViewClose(view);
4599     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4600     r = MsiCloseHandle(view);
4601     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4602
4603     /* dialog_ and control specified */
4604     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog' AND `Control` = 'ErrorText'";
4605     r = MsiDatabaseOpenViewA(hdb, query, &view);
4606     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4607     r = MsiViewExecute(view, 0);
4608     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4609     r = MsiViewClose(view);
4610     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4611     r = MsiCloseHandle(view);
4612     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4613
4614     /* check the modified text */
4615     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
4616     r = MsiDatabaseOpenViewA(hdb, query, &view);
4617     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4618     r = MsiViewExecute(view, 0);
4619     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4620
4621     r = MsiViewFetch(view, &rec);
4622     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4623
4624     size = MAX_PATH;
4625     r = MsiRecordGetStringA(rec, 1, result, &size);
4626     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4627     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4628
4629     MsiCloseHandle(rec);
4630
4631     r = MsiViewFetch(view, &rec);
4632     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4633
4634     size = MAX_PATH;
4635     r = MsiRecordGetStringA(rec, 1, result, &size);
4636     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4637     ok(!result[0], "Expected an empty string, got %s\n", result);
4638
4639     MsiCloseHandle(rec);
4640
4641     r = MsiViewFetch(view, &rec);
4642     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4643
4644     r = MsiViewClose(view);
4645     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4646     r = MsiCloseHandle(view);
4647     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4648
4649     /* no where condition */
4650     query = "UPDATE `Control` SET `Text` = 'this is text'";
4651     r = MsiDatabaseOpenViewA(hdb, query, &view);
4652     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4653     r = MsiViewExecute(view, 0);
4654     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4655     r = MsiViewClose(view);
4656     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4657     r = MsiCloseHandle(view);
4658     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4659
4660     /* check the modified text */
4661     query = "SELECT `Text` FROM `Control`";
4662     r = MsiDatabaseOpenViewA(hdb, query, &view);
4663     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4664     r = MsiViewExecute(view, 0);
4665     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4666
4667     r = MsiViewFetch(view, &rec);
4668     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4669
4670     size = MAX_PATH;
4671     r = MsiRecordGetStringA(rec, 1, result, &size);
4672     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4673     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4674
4675     MsiCloseHandle(rec);
4676
4677     r = MsiViewFetch(view, &rec);
4678     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4679
4680     size = MAX_PATH;
4681     r = MsiRecordGetStringA(rec, 1, result, &size);
4682     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4683     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4684
4685     MsiCloseHandle(rec);
4686
4687     r = MsiViewFetch(view, &rec);
4688     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4689
4690     size = MAX_PATH;
4691     r = MsiRecordGetStringA(rec, 1, result, &size);
4692     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4693     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4694
4695     MsiCloseHandle(rec);
4696
4697     r = MsiViewFetch(view, &rec);
4698     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4699
4700     r = MsiViewClose(view);
4701     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4702     r = MsiCloseHandle(view);
4703     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4704
4705     query = "CREATE TABLE `Apple` ( `Banana` CHAR(72) NOT NULL, "
4706         "`Orange` CHAR(72),  `Pear` INT PRIMARY KEY `Banana`)";
4707     r = run_query(hdb, 0, query);
4708     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4709
4710     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4711         "VALUES('one', 'two', 3)";
4712     r = run_query(hdb, 0, query);
4713     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4714
4715     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4716         "VALUES('three', 'four', 5)";
4717     r = run_query(hdb, 0, query);
4718     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4719
4720     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4721         "VALUES('six', 'two', 7)";
4722     r = run_query(hdb, 0, query);
4723     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4724
4725     rec = MsiCreateRecord(2);
4726     MsiRecordSetInteger(rec, 1, 8);
4727     MsiRecordSetStringA(rec, 2, "two");
4728
4729     query = "UPDATE `Apple` SET `Pear` = ? WHERE `Orange` = ?";
4730     r = run_query(hdb, rec, query);
4731     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4732
4733     MsiCloseHandle(rec);
4734
4735     query = "SELECT `Pear` FROM `Apple` ORDER BY `Orange`";
4736     r = MsiDatabaseOpenViewA(hdb, query, &view);
4737     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4738     r = MsiViewExecute(view, 0);
4739     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4740
4741     r = MsiViewFetch(view, &rec);
4742     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4743
4744     r = MsiRecordGetInteger(rec, 1);
4745     ok(r == 8, "Expected 8, got %d\n", r);
4746
4747     MsiCloseHandle(rec);
4748
4749     r = MsiViewFetch(view, &rec);
4750     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4751
4752     r = MsiRecordGetInteger(rec, 1);
4753     ok(r == 8, "Expected 8, got %d\n", r);
4754
4755     MsiCloseHandle(rec);
4756
4757     r = MsiViewFetch(view, &rec);
4758     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4759
4760     r = MsiRecordGetInteger(rec, 1);
4761     ok(r == 5, "Expected 5, got %d\n", r);
4762
4763     MsiCloseHandle(rec);
4764
4765     r = MsiViewFetch(view, &rec);
4766     ok(r == ERROR_NO_MORE_ITEMS, "Expectd ERROR_NO_MORE_ITEMS, got %d\n", r);
4767
4768     MsiViewClose(view);
4769     MsiCloseHandle(view);
4770
4771     r = MsiDatabaseCommit(hdb);
4772     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
4773     r = MsiCloseHandle(hdb);
4774     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4775
4776     DeleteFileA(msifile);
4777 }
4778
4779 static void test_special_tables(void)
4780 {
4781     const char *query;
4782     MSIHANDLE hdb = 0;
4783     UINT r;
4784
4785     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4786     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4787
4788     query = "CREATE TABLE `_Properties` ( "
4789         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4790     r = run_query(hdb, 0, query);
4791     ok(r == ERROR_SUCCESS, "failed to create table\n");
4792
4793     query = "CREATE TABLE `_Storages` ( "
4794         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4795     r = run_query(hdb, 0, query);
4796     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
4797
4798     query = "CREATE TABLE `_Streams` ( "
4799         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4800     r = run_query(hdb, 0, query);
4801     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
4802
4803     query = "CREATE TABLE `_Tables` ( "
4804         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4805     r = run_query(hdb, 0, query);
4806     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Tables table\n");
4807
4808     query = "CREATE TABLE `_Columns` ( "
4809         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4810     r = run_query(hdb, 0, query);
4811     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Columns table\n");
4812
4813     r = MsiCloseHandle(hdb);
4814     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4815 }
4816
4817 static void test_tables_order(void)
4818 {
4819     const char *query;
4820     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4821     UINT r;
4822     char buffer[100];
4823     DWORD sz;
4824
4825     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4826     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4827
4828     query = "CREATE TABLE `foo` ( "
4829         "`baz` INT NOT NULL PRIMARY KEY `baz`)";
4830     r = run_query(hdb, 0, query);
4831     ok(r == ERROR_SUCCESS, "failed to create table\n");
4832
4833     query = "CREATE TABLE `bar` ( "
4834         "`foo` INT NOT NULL PRIMARY KEY `foo`)";
4835     r = run_query(hdb, 0, query);
4836     ok(r == ERROR_SUCCESS, "failed to create table\n");
4837
4838     query = "CREATE TABLE `baz` ( "
4839         "`bar` INT NOT NULL, "
4840         "`baz` INT NOT NULL, "
4841         "`foo` INT NOT NULL PRIMARY KEY `bar`)";
4842     r = run_query(hdb, 0, query);
4843     ok(r == ERROR_SUCCESS, "failed to create table\n");
4844
4845     /* The names of the tables in the _Tables table must
4846        be in the same order as these names are created in
4847        the strings table. */
4848     query = "SELECT * FROM `_Tables`";
4849     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4850     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4851     r = MsiViewExecute(hview, 0);
4852     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4853
4854     r = MsiViewFetch(hview, &hrec);
4855     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4856     sz = sizeof(buffer);
4857     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4858     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4859     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4860     r = MsiCloseHandle(hrec);
4861     ok(r == ERROR_SUCCESS, "failed to close record\n");
4862
4863     r = MsiViewFetch(hview, &hrec);
4864     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4865     sz = sizeof(buffer);
4866     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4867     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4868     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4869     r = MsiCloseHandle(hrec);
4870     ok(r == ERROR_SUCCESS, "failed to close record\n");
4871
4872     r = MsiViewFetch(hview, &hrec);
4873     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4874     sz = sizeof(buffer);
4875     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4876     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4877     ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
4878     r = MsiCloseHandle(hrec);
4879     ok(r == ERROR_SUCCESS, "failed to close record\n");
4880
4881     r = MsiViewClose(hview);
4882     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4883     r = MsiCloseHandle(hview);
4884     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4885
4886     /* The names of the tables in the _Columns table must
4887        be in the same order as these names are created in
4888        the strings table. */
4889     query = "SELECT * FROM `_Columns`";
4890     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4891     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4892     r = MsiViewExecute(hview, 0);
4893     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4894
4895     r = MsiViewFetch(hview, &hrec);
4896     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4897     sz = sizeof(buffer);
4898     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4899     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4900     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4901     sz = sizeof(buffer);
4902     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4903     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4904     ok(!lstrcmpA(buffer, "baz"), "Expected baz, 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 = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4912     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4913     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4914     sz = sizeof(buffer);
4915     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4916     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4917     ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
4918     r = MsiCloseHandle(hrec);
4919     ok(r == ERROR_SUCCESS, "failed to close record\n");
4920
4921     r = MsiViewFetch(hview, &hrec);
4922     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4923     sz = sizeof(buffer);
4924     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4925     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4926     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4927     sz = sizeof(buffer);
4928     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4929     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4930     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4931     r = MsiCloseHandle(hrec);
4932     ok(r == ERROR_SUCCESS, "failed to close record\n");
4933
4934     r = MsiViewFetch(hview, &hrec);
4935     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4936     sz = sizeof(buffer);
4937     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4938     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4939     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4940     sz = sizeof(buffer);
4941     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4942     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4943     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4944     r = MsiCloseHandle(hrec);
4945     ok(r == ERROR_SUCCESS, "failed to close record\n");
4946
4947     r = MsiViewFetch(hview, &hrec);
4948     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4949     sz = sizeof(buffer);
4950     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4951     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4952     ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
4953     sz = sizeof(buffer);
4954     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4955     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4956     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4957     r = MsiCloseHandle(hrec);
4958     ok(r == ERROR_SUCCESS, "failed to close record\n");
4959
4960     r = MsiViewClose(hview);
4961     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4962     r = MsiCloseHandle(hview);
4963     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4964
4965     r = MsiCloseHandle(hdb);
4966     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4967
4968     DeleteFileA(msifile);
4969 }
4970
4971 static void test_rows_order(void)
4972 {
4973     const char *query;
4974     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4975     UINT r;
4976     char buffer[100];
4977     DWORD sz;
4978
4979     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4980     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4981
4982     query = "CREATE TABLE `foo` ( "
4983         "`bar` LONGCHAR NOT NULL PRIMARY KEY `bar`)";
4984     r = run_query(hdb, 0, query);
4985     ok(r == ERROR_SUCCESS, "failed to create table\n");
4986
4987     r = run_query(hdb, 0, "INSERT INTO `foo` "
4988             "( `bar` ) VALUES ( 'A' )");
4989     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4990
4991     r = run_query(hdb, 0, "INSERT INTO `foo` "
4992             "( `bar` ) VALUES ( 'B' )");
4993     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4994
4995     r = run_query(hdb, 0, "INSERT INTO `foo` "
4996             "( `bar` ) VALUES ( 'C' )");
4997     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4998
4999     r = run_query(hdb, 0, "INSERT INTO `foo` "
5000             "( `bar` ) VALUES ( 'D' )");
5001     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5002
5003     r = run_query(hdb, 0, "INSERT INTO `foo` "
5004             "( `bar` ) VALUES ( 'E' )");
5005     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5006
5007     r = run_query(hdb, 0, "INSERT INTO `foo` "
5008             "( `bar` ) VALUES ( 'F' )");
5009     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5010
5011     query = "CREATE TABLE `bar` ( "
5012         "`foo` LONGCHAR NOT NULL, "
5013         "`baz` LONGCHAR NOT NULL "
5014         "PRIMARY KEY `foo` )";
5015     r = run_query(hdb, 0, query);
5016     ok(r == ERROR_SUCCESS, "failed to create table\n");
5017
5018     r = run_query(hdb, 0, "INSERT INTO `bar` "
5019             "( `foo`, `baz` ) VALUES ( 'C', 'E' )");
5020     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5021
5022     r = run_query(hdb, 0, "INSERT INTO `bar` "
5023             "( `foo`, `baz` ) VALUES ( 'F', 'A' )");
5024     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5025
5026     r = run_query(hdb, 0, "INSERT INTO `bar` "
5027             "( `foo`, `baz` ) VALUES ( 'A', 'B' )");
5028     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5029
5030     r = run_query(hdb, 0, "INSERT INTO `bar` "
5031             "( `foo`, `baz` ) VALUES ( 'D', 'E' )");
5032     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5033
5034     /* The rows of the table must be ordered by the column values of
5035        each row. For strings, the column value is the string id
5036        in the string table.  */
5037
5038     query = "SELECT * FROM `bar`";
5039     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5040     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5041     r = MsiViewExecute(hview, 0);
5042     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5043
5044     r = MsiViewFetch(hview, &hrec);
5045     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5046     sz = sizeof(buffer);
5047     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5048     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5049     ok(!lstrcmpA(buffer, "A"), "Expected A, got %s\n", buffer);
5050     sz = sizeof(buffer);
5051     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5052     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5053     ok(!lstrcmpA(buffer, "B"), "Expected B, got %s\n", buffer);
5054     r = MsiCloseHandle(hrec);
5055     ok(r == ERROR_SUCCESS, "failed to close record\n");
5056
5057     r = MsiViewFetch(hview, &hrec);
5058     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5059     sz = sizeof(buffer);
5060     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5061     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5062     ok(!lstrcmpA(buffer, "C"), "Expected E, got %s\n", buffer);
5063     sz = sizeof(buffer);
5064     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5065     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5066     ok(!lstrcmpA(buffer, "E"), "Expected E, got %s\n", buffer);
5067     r = MsiCloseHandle(hrec);
5068     ok(r == ERROR_SUCCESS, "failed to close record\n");
5069
5070     r = MsiViewFetch(hview, &hrec);
5071     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5072     sz = sizeof(buffer);
5073     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5074     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5075     ok(!lstrcmpA(buffer, "D"), "Expected D, got %s\n", buffer);
5076     sz = sizeof(buffer);
5077     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5078     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5079     ok(!lstrcmpA(buffer, "E"), "Expected E, got %s\n", buffer);
5080     r = MsiCloseHandle(hrec);
5081     ok(r == ERROR_SUCCESS, "failed to close record\n");
5082
5083     r = MsiViewFetch(hview, &hrec);
5084     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5085     sz = sizeof(buffer);
5086     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5087     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5088     ok(!lstrcmpA(buffer, "F"), "Expected F, got %s\n", buffer);
5089     sz = sizeof(buffer);
5090     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5091     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5092     ok(!lstrcmpA(buffer, "A"), "Expected A, got %s\n", buffer);
5093     r = MsiCloseHandle(hrec);
5094     ok(r == ERROR_SUCCESS, "failed to close record\n");
5095
5096     r = MsiViewClose(hview);
5097     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5098     r = MsiCloseHandle(hview);
5099     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5100
5101     r = MsiCloseHandle(hdb);
5102     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5103
5104     DeleteFileA(msifile);
5105 }
5106
5107 static void test_collation(void)
5108 {
5109     static const WCHAR query1[] =
5110         {'I','N','S','E','R','T',' ','I','N','T','O',' ','`','b','a','r','`',' ',
5111          '(','`','f','o','o','`',',','`','b','a','z','`',')',' ','V','A','L','U','E','S',' ',
5112          '(','\'','a',0x30a,'\'',',','\'','C','\'',')',0};
5113     static const WCHAR query2[] =
5114         {'I','N','S','E','R','T',' ','I','N','T','O',' ','`','b','a','r','`',' ',
5115          '(','`','f','o','o','`',',','`','b','a','z','`',')',' ','V','A','L','U','E','S',' ',
5116          '(','\'',0xe5,'\'',',','\'','D','\'',')',0};
5117     static const WCHAR query3[] =
5118         {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','b','a','z','`',' ',
5119          '(',' ','`','a',0x30a,'`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ','N','U','L','L',',',
5120            ' ','`',0xe5,'`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ','N','U','L','L',' ',
5121            'P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','a',0x30a,'`',')',0};
5122     static const WCHAR query4[] =
5123         {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','a',0x30a,'`',' ',
5124          '(',' ','`','f','o','o','`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ',
5125          'N','U','L','L',' ','P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','f','o','o','`',')',0};
5126     static const WCHAR query5[] =
5127         {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`',0xe5,'`',' ',
5128          '(',' ','`','f','o','o','`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ',
5129          'N','U','L','L',' ','P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','f','o','o','`',')',0};
5130     static const WCHAR query6[] =
5131         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','`','b','a','r','`',' ','W','H','E','R','E',
5132          ' ','`','f','o','o','`',' ','=','\'',0xe5,'\'',0};
5133     static const WCHAR letter_C[] = {'C',0};
5134     static const WCHAR letter_D[] = {'D',0};
5135     static const WCHAR letter_a_ring[] = {'a',0x30a,0};
5136     static const WCHAR letter_a_with_ring[] = {0xe5,0};
5137     const char *query;
5138     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5139     UINT r;
5140     char buffer[100];
5141     WCHAR bufferW[100];
5142     DWORD sz;
5143
5144     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5145     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5146
5147     query = "CREATE TABLE `bar` ( "
5148         "`foo` LONGCHAR NOT NULL, "
5149         "`baz` LONGCHAR NOT NULL "
5150         "PRIMARY KEY `foo` )";
5151     r = run_query(hdb, 0, query);
5152     ok(r == ERROR_SUCCESS, "failed to create table\n");
5153
5154     r = run_query(hdb, 0, query);
5155     ok(r == ERROR_BAD_QUERY_SYNTAX, "wrong error %u\n", r);
5156
5157     r = run_query(hdb, 0, "INSERT INTO `bar` "
5158             "( `foo`, `baz` ) VALUES ( '\2', 'A' )");
5159     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5160
5161     r = run_query(hdb, 0, "INSERT INTO `bar` "
5162             "( `foo`, `baz` ) VALUES ( '\1', 'B' )");
5163     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5164
5165     r = run_queryW(hdb, 0, query1);
5166     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5167
5168     r = run_queryW(hdb, 0, query2);
5169     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5170
5171     r = run_queryW(hdb, 0, query3);
5172     ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
5173
5174     r = run_queryW(hdb, 0, query4);
5175     ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
5176
5177     r = run_queryW(hdb, 0, query5);
5178     ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
5179
5180     query = "SELECT * FROM `bar`";
5181     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5182     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5183     r = MsiViewExecute(hview, 0);
5184     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5185
5186     r = MsiViewFetch(hview, &hrec);
5187     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5188     sz = sizeof(buffer);
5189     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5190     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5191     ok(!lstrcmpA(buffer, "\2"), "Expected \\2, got '%s'\n", buffer);
5192     sz = sizeof(buffer);
5193     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5194     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5195     ok(!lstrcmpA(buffer, "A"), "Expected A, got '%s'\n", buffer);
5196     MsiCloseHandle(hrec);
5197
5198     r = MsiViewFetch(hview, &hrec);
5199     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5200     sz = sizeof(buffer);
5201     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5202     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5203     ok(!lstrcmpA(buffer, "\1"), "Expected \\1, got '%s'\n", buffer);
5204     sz = sizeof(buffer);
5205     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5206     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5207     ok(!lstrcmpA(buffer, "B"), "Expected B, got '%s'\n", buffer);
5208     MsiCloseHandle(hrec);
5209
5210     r = MsiViewFetch(hview, &hrec);
5211     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5212     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5213     r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
5214     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5215     ok(!memcmp(bufferW, letter_a_ring, sizeof(letter_a_ring)),
5216        "Expected %s, got %s\n", wine_dbgstr_w(letter_a_ring), wine_dbgstr_w(bufferW));
5217     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5218     r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
5219     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5220     ok(!lstrcmpW(bufferW, letter_C), "Expected C, got %s\n", wine_dbgstr_w(bufferW));
5221     MsiCloseHandle(hrec);
5222
5223     r = MsiViewFetch(hview, &hrec);
5224     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5225     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5226     r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
5227     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5228     ok(!memcmp(bufferW, letter_a_with_ring, sizeof(letter_a_with_ring)),
5229        "Expected %s, got %s\n", wine_dbgstr_w(letter_a_with_ring), wine_dbgstr_w(bufferW));
5230     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5231     r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
5232     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5233     ok(!lstrcmpW(bufferW, letter_D), "Expected D, got %s\n", wine_dbgstr_w(bufferW));
5234     MsiCloseHandle(hrec);
5235
5236     r = MsiViewClose(hview);
5237     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5238     r = MsiCloseHandle(hview);
5239     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5240
5241     r = MsiDatabaseOpenViewW(hdb, query6, &hview);
5242     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5243     r = MsiViewExecute(hview, 0);
5244     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5245
5246     r = MsiViewFetch(hview, &hrec);
5247     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5248     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5249     r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
5250     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5251     ok(!memcmp(bufferW, letter_a_with_ring, sizeof(letter_a_with_ring)),
5252        "Expected %s, got %s\n", wine_dbgstr_w(letter_a_with_ring), wine_dbgstr_w(bufferW));
5253     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5254     r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
5255     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5256     ok(!lstrcmpW(bufferW, letter_D), "Expected D, got %s\n", wine_dbgstr_w(bufferW));
5257     MsiCloseHandle(hrec);
5258
5259     r = MsiViewFetch(hview, &hrec);
5260     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
5261
5262     r = MsiViewClose(hview);
5263     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5264     r = MsiCloseHandle(hview);
5265     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5266
5267     r = MsiCloseHandle(hdb);
5268     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5269
5270     DeleteFileA(msifile);
5271 }
5272
5273 static void test_select_markers(void)
5274 {
5275     MSIHANDLE hdb = 0, rec, view, res;
5276     LPCSTR query;
5277     UINT r;
5278     DWORD size;
5279     CHAR buf[MAX_PATH];
5280
5281     hdb = create_db();
5282     ok( hdb, "failed to create db\n");
5283
5284     r = run_query(hdb, 0,
5285             "CREATE TABLE `Table` (`One` CHAR(72), `Two` CHAR(72), `Three` SHORT PRIMARY KEY `One`, `Two`, `Three`)");
5286     ok(r == S_OK, "cannot create table: %d\n", r);
5287
5288     r = run_query(hdb, 0, "INSERT INTO `Table` "
5289             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'one', 1 )");
5290     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5291
5292     r = run_query(hdb, 0, "INSERT INTO `Table` "
5293             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 1 )");
5294     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5295
5296     r = run_query(hdb, 0, "INSERT INTO `Table` "
5297             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 2 )");
5298     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5299
5300     r = run_query(hdb, 0, "INSERT INTO `Table` "
5301             "( `One`, `Two`, `Three` ) VALUES ( 'banana', 'three', 3 )");
5302     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5303
5304     rec = MsiCreateRecord(2);
5305     MsiRecordSetStringA(rec, 1, "apple");
5306     MsiRecordSetStringA(rec, 2, "two");
5307
5308     query = "SELECT * FROM `Table` WHERE `One`=? AND `Two`=? ORDER BY `Three`";
5309     r = MsiDatabaseOpenViewA(hdb, query, &view);
5310     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5311
5312     r = MsiViewExecute(view, rec);
5313     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5314
5315     r = MsiViewFetch(view, &res);
5316     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5317
5318     size = MAX_PATH;
5319     r = MsiRecordGetStringA(res, 1, buf, &size);
5320     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5321     ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
5322
5323     size = MAX_PATH;
5324     r = MsiRecordGetStringA(res, 2, buf, &size);
5325     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5326     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5327
5328     r = MsiRecordGetInteger(res, 3);
5329     ok(r == 1, "Expected 1, got %d\n", r);
5330
5331     MsiCloseHandle(res);
5332
5333     r = MsiViewFetch(view, &res);
5334     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5335
5336     size = MAX_PATH;
5337     r = MsiRecordGetStringA(res, 1, buf, &size);
5338     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5339     ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
5340
5341     size = MAX_PATH;
5342     r = MsiRecordGetStringA(res, 2, buf, &size);
5343     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5344     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5345
5346     r = MsiRecordGetInteger(res, 3);
5347     ok(r == 2, "Expected 2, got %d\n", r);
5348
5349     MsiCloseHandle(res);
5350
5351     r = MsiViewFetch(view, &res);
5352     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5353
5354     MsiCloseHandle(rec);
5355     MsiViewClose(view);
5356     MsiCloseHandle(view);
5357
5358     rec = MsiCreateRecord(2);
5359     MsiRecordSetStringA(rec, 1, "one");
5360     MsiRecordSetInteger(rec, 2, 1);
5361
5362     query = "SELECT * FROM `Table` WHERE `Two`<>? AND `Three`>? ORDER BY `Three`";
5363     r = MsiDatabaseOpenViewA(hdb, query, &view);
5364     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5365     r = MsiViewExecute(view, rec);
5366     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5367
5368     r = MsiViewFetch(view, &res);
5369     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5370
5371     size = MAX_PATH;
5372     r = MsiRecordGetStringA(res, 1, buf, &size);
5373     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5374     ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
5375
5376     size = MAX_PATH;
5377     r = MsiRecordGetStringA(res, 2, buf, &size);
5378     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5379     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5380
5381     r = MsiRecordGetInteger(res, 3);
5382     ok(r == 2, "Expected 2, got %d\n", r);
5383
5384     MsiCloseHandle(res);
5385
5386     r = MsiViewFetch(view, &res);
5387     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5388
5389     size = MAX_PATH;
5390     r = MsiRecordGetStringA(res, 1, buf, &size);
5391     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5392     ok(!lstrcmpA(buf, "banana"), "Expected banana, got %s\n", buf);
5393
5394     size = MAX_PATH;
5395     r = MsiRecordGetStringA(res, 2, buf, &size);
5396     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5397     ok(!lstrcmpA(buf, "three"), "Expected three, got %s\n", buf);
5398
5399     r = MsiRecordGetInteger(res, 3);
5400     ok(r == 3, "Expected 3, got %d\n", r);
5401
5402     MsiCloseHandle(res);
5403
5404     r = MsiViewFetch(view, &res);
5405     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5406
5407     MsiCloseHandle(rec);
5408     MsiViewClose(view);
5409     MsiCloseHandle(view);
5410     MsiCloseHandle(hdb);
5411     DeleteFileA(msifile);
5412 }
5413
5414 static void test_viewmodify_update(void)
5415 {
5416     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5417     UINT i, test_max, offset, count;
5418     const char *query;
5419     UINT r;
5420
5421     DeleteFileA(msifile);
5422
5423     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5424     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5425
5426     query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
5427     r = run_query( hdb, 0, query );
5428     ok(r == ERROR_SUCCESS, "query failed\n");
5429
5430     query = "INSERT INTO `table` (`A`, `B`) VALUES (1, 2)";
5431     r = run_query( hdb, 0, query );
5432     ok(r == ERROR_SUCCESS, "query failed\n");
5433
5434     query = "INSERT INTO `table` (`A`, `B`) VALUES (3, 4)";
5435     r = run_query( hdb, 0, query );
5436     ok(r == ERROR_SUCCESS, "query failed\n");
5437
5438     query = "INSERT INTO `table` (`A`, `B`) VALUES (5, 6)";
5439     r = run_query( hdb, 0, query );
5440     ok(r == ERROR_SUCCESS, "query failed\n");
5441
5442     query = "SELECT `B` FROM `table`";
5443     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5444     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5445     r = MsiViewExecute(hview, 0);
5446     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5447     r = MsiViewFetch(hview, &hrec);
5448     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5449
5450     r = MsiRecordSetInteger(hrec, 1, 0);
5451     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5452
5453     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
5454     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5455
5456     r = MsiCloseHandle(hrec);
5457     ok(r == ERROR_SUCCESS, "failed to close record\n");
5458
5459     r = MsiViewClose(hview);
5460     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5461     r = MsiCloseHandle(hview);
5462     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5463
5464     query = "SELECT * FROM `table`";
5465     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5466     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5467     r = MsiViewExecute(hview, 0);
5468     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5469     r = MsiViewFetch(hview, &hrec);
5470     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5471
5472     r = MsiRecordGetInteger(hrec, 1);
5473     ok(r == 1, "Expected 1, got %d\n", r);
5474     r = MsiRecordGetInteger(hrec, 2);
5475     ok(r == 0, "Expected 0, got %d\n", r);
5476
5477     r = MsiCloseHandle(hrec);
5478     ok(r == ERROR_SUCCESS, "failed to close record\n");
5479
5480     r = MsiViewFetch(hview, &hrec);
5481     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5482
5483     r = MsiRecordGetInteger(hrec, 1);
5484     ok(r == 3, "Expected 3, got %d\n", r);
5485     r = MsiRecordGetInteger(hrec, 2);
5486     ok(r == 4, "Expected 4, got %d\n", r);
5487
5488     r = MsiCloseHandle(hrec);
5489     ok(r == ERROR_SUCCESS, "failed to close record\n");
5490
5491     r = MsiViewFetch(hview, &hrec);
5492     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5493
5494     r = MsiRecordGetInteger(hrec, 1);
5495     ok(r == 5, "Expected 5, got %d\n", r);
5496     r = MsiRecordGetInteger(hrec, 2);
5497     ok(r == 6, "Expected 6, got %d\n", r);
5498
5499     r = MsiCloseHandle(hrec);
5500     ok(r == ERROR_SUCCESS, "failed to close record\n");
5501
5502     r = MsiViewFetch(hview, &hrec);
5503     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5504
5505     r = MsiViewClose(hview);
5506     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5507     r = MsiCloseHandle(hview);
5508     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5509
5510     /* loop through all elements */
5511     query = "SELECT `B` FROM `table`";
5512     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5513     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5514     r = MsiViewExecute(hview, 0);
5515     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5516
5517     while (TRUE)
5518     {
5519         r = MsiViewFetch(hview, &hrec);
5520         if (r != ERROR_SUCCESS)
5521             break;
5522
5523         r = MsiRecordSetInteger(hrec, 1, 0);
5524         ok(r == ERROR_SUCCESS, "failed to set integer\n");
5525
5526         r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
5527         ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5528
5529         r = MsiCloseHandle(hrec);
5530         ok(r == ERROR_SUCCESS, "failed to close record\n");
5531     }
5532
5533     r = MsiViewClose(hview);
5534     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5535     r = MsiCloseHandle(hview);
5536     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5537
5538     query = "SELECT * FROM `table`";
5539     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5540     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5541     r = MsiViewExecute(hview, 0);
5542     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5543     r = MsiViewFetch(hview, &hrec);
5544     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5545
5546     r = MsiRecordGetInteger(hrec, 1);
5547     ok(r == 1, "Expected 1, got %d\n", r);
5548     r = MsiRecordGetInteger(hrec, 2);
5549     ok(r == 0, "Expected 0, got %d\n", r);
5550
5551     r = MsiCloseHandle(hrec);
5552     ok(r == ERROR_SUCCESS, "failed to close record\n");
5553
5554     r = MsiViewFetch(hview, &hrec);
5555     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5556
5557     r = MsiRecordGetInteger(hrec, 1);
5558     ok(r == 3, "Expected 3, got %d\n", r);
5559     r = MsiRecordGetInteger(hrec, 2);
5560     ok(r == 0, "Expected 0, got %d\n", r);
5561
5562     r = MsiCloseHandle(hrec);
5563     ok(r == ERROR_SUCCESS, "failed to close record\n");
5564
5565     r = MsiViewFetch(hview, &hrec);
5566     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5567
5568     r = MsiRecordGetInteger(hrec, 1);
5569     ok(r == 5, "Expected 5, got %d\n", r);
5570     r = MsiRecordGetInteger(hrec, 2);
5571     ok(r == 0, "Expected 0, got %d\n", r);
5572
5573     r = MsiCloseHandle(hrec);
5574     ok(r == ERROR_SUCCESS, "failed to close record\n");
5575
5576     r = MsiViewFetch(hview, &hrec);
5577     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5578
5579     r = MsiViewClose(hview);
5580     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5581     r = MsiCloseHandle(hview);
5582     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5583
5584     query = "CREATE TABLE `table2` (`A` INT, `B` INT PRIMARY KEY `A`)";
5585     r = run_query( hdb, 0, query );
5586     ok(r == ERROR_SUCCESS, "query failed\n");
5587
5588     query = "INSERT INTO `table2` (`A`, `B`) VALUES (?, ?)";
5589     r = MsiDatabaseOpenViewA( hdb, query, &hview );
5590     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5591
5592     test_max = 100;
5593     offset = 1234;
5594     for(i = 0; i < test_max; i++)
5595     {
5596
5597         hrec = MsiCreateRecord( 2 );
5598         MsiRecordSetInteger( hrec, 1, test_max - i );
5599         MsiRecordSetInteger( hrec, 2, i );
5600
5601         r = MsiViewExecute( hview, hrec );
5602         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5603
5604         r = MsiCloseHandle( hrec );
5605         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5606     }
5607
5608     r = MsiViewClose( hview );
5609     ok(r == ERROR_SUCCESS, "Got %d\n", r);
5610     r = MsiCloseHandle( hview );
5611     ok(r == ERROR_SUCCESS, "Got %d\n", r);
5612
5613     /* Update. */
5614     query = "SELECT * FROM `table2` ORDER BY `B`";
5615     r = MsiDatabaseOpenViewA( hdb, query, &hview);
5616     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5617     r = MsiViewExecute( hview, 0 );
5618     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5619
5620     count = 0;
5621     while (MsiViewFetch( hview, &hrec ) == ERROR_SUCCESS)
5622     {
5623         UINT b = MsiRecordGetInteger( hrec, 2 );
5624
5625         r = MsiRecordSetInteger( hrec, 2, b + offset);
5626         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5627
5628         r = MsiViewModify( hview, MSIMODIFY_UPDATE, hrec );
5629         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5630
5631         r = MsiCloseHandle(hrec);
5632         ok(r == ERROR_SUCCESS, "failed to close record\n");
5633         count++;
5634     }
5635     ok(count == test_max, "Got count %d\n", count);
5636
5637     r = MsiViewClose(hview);
5638     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5639     r = MsiCloseHandle(hview);
5640     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5641
5642     /* Recheck. */
5643     query = "SELECT * FROM `table2` ORDER BY `B`";
5644     r = MsiDatabaseOpenViewA( hdb, query, &hview);
5645     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5646     r = MsiViewExecute( hview, 0 );
5647     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5648
5649     count = 0;
5650     while (MsiViewFetch( hview, &hrec ) == ERROR_SUCCESS)
5651     {
5652         UINT a = MsiRecordGetInteger( hrec, 1 );
5653         UINT b = MsiRecordGetInteger( hrec, 2 );
5654         ok( ( test_max - a + offset) == b, "Got (%d, %d), expected (%d, %d)\n",
5655             a, b, test_max - a + offset, b);
5656
5657         r = MsiCloseHandle(hrec);
5658         ok(r == ERROR_SUCCESS, "failed to close record\n");
5659         count++;
5660     }
5661     ok(count == test_max, "Got count %d\n", count);
5662
5663     r = MsiViewClose(hview);
5664     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5665     r = MsiCloseHandle(hview);
5666     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5667
5668     r = MsiCloseHandle( hdb );
5669     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
5670 }
5671
5672 static void test_viewmodify_assign(void)
5673 {
5674     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5675     const char *query;
5676     UINT r;
5677
5678     /* setup database */
5679     DeleteFileA(msifile);
5680
5681     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5682     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5683
5684     query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
5685     r = run_query( hdb, 0, query );
5686     ok(r == ERROR_SUCCESS, "query failed\n");
5687
5688     /* assign to view, new primary key */
5689     query = "SELECT * FROM `table`";
5690     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5691     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5692     r = MsiViewExecute(hview, 0);
5693     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5694
5695     hrec = MsiCreateRecord(2);
5696     ok(hrec != 0, "MsiCreateRecord failed\n");
5697
5698     r = MsiRecordSetInteger(hrec, 1, 1);
5699     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5700     r = MsiRecordSetInteger(hrec, 2, 2);
5701     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5702
5703     r = MsiViewModify(hview, MSIMODIFY_ASSIGN, hrec);
5704     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5705
5706     r = MsiCloseHandle(hrec);
5707     ok(r == ERROR_SUCCESS, "failed to close record\n");
5708
5709     r = MsiViewClose(hview);
5710     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5711     r = MsiCloseHandle(hview);
5712     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5713
5714     query = "SELECT * FROM `table`";
5715     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5716     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5717     r = MsiViewExecute(hview, 0);
5718     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5719     r = MsiViewFetch(hview, &hrec);
5720     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5721
5722     r = MsiRecordGetInteger(hrec, 1);
5723     ok(r == 1, "Expected 1, got %d\n", r);
5724     r = MsiRecordGetInteger(hrec, 2);
5725     ok(r == 2, "Expected 2, got %d\n", r);
5726
5727     r = MsiCloseHandle(hrec);
5728     ok(r == ERROR_SUCCESS, "failed to close record\n");
5729
5730     r = MsiViewFetch(hview, &hrec);
5731     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5732
5733     r = MsiViewClose(hview);
5734     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5735     r = MsiCloseHandle(hview);
5736     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5737
5738     /* assign to view, primary key matches */
5739     query = "SELECT * FROM `table`";
5740     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5741     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5742     r = MsiViewExecute(hview, 0);
5743     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5744
5745     hrec = MsiCreateRecord(2);
5746     ok(hrec != 0, "MsiCreateRecord failed\n");
5747
5748     r = MsiRecordSetInteger(hrec, 1, 1);
5749     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5750     r = MsiRecordSetInteger(hrec, 2, 4);
5751     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5752
5753     r = MsiViewModify(hview, MSIMODIFY_ASSIGN, hrec);
5754     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5755
5756     r = MsiCloseHandle(hrec);
5757     ok(r == ERROR_SUCCESS, "failed to close record\n");
5758
5759     r = MsiViewClose(hview);
5760     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5761     r = MsiCloseHandle(hview);
5762     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5763
5764     query = "SELECT * FROM `table`";
5765     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5766     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5767     r = MsiViewExecute(hview, 0);
5768     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5769     r = MsiViewFetch(hview, &hrec);
5770     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5771
5772     r = MsiRecordGetInteger(hrec, 1);
5773     ok(r == 1, "Expected 1, got %d\n", r);
5774     r = MsiRecordGetInteger(hrec, 2);
5775     ok(r == 4, "Expected 4, got %d\n", r);
5776
5777     r = MsiCloseHandle(hrec);
5778     ok(r == ERROR_SUCCESS, "failed to close record\n");
5779
5780     r = MsiViewFetch(hview, &hrec);
5781     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5782
5783     r = MsiViewClose(hview);
5784     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5785     r = MsiCloseHandle(hview);
5786     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5787
5788     /* close database */
5789     r = MsiCloseHandle( hdb );
5790     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
5791 }
5792
5793 static const WCHAR data10[] = { /* MOO */
5794     0x8001, 0x000b,
5795 };
5796 static const WCHAR data11[] = { /* AAR */
5797     0x8002, 0x8005,
5798     0x000c, 0x000f,
5799 };
5800 static const char data12[] = /* _StringData */
5801     "MOOABAARCDonetwofourfive";
5802 static const WCHAR data13[] = { /* _StringPool */
5803 /*  len, refs */
5804     0,   0,    /* string 0 ''     */
5805     0,   0,    /* string 1 ''     */
5806     0,   0,    /* string 2 ''     */
5807     0,   0,    /* string 3 ''     */
5808     0,   0,    /* string 4 ''     */
5809     3,   3,    /* string 5 'MOO'  */
5810     1,   1,    /* string 6 'A'    */
5811     1,   1,    /* string 7 'B'    */
5812     3,   3,    /* string 8 'AAR'  */
5813     1,   1,    /* string 9 'C'    */
5814     1,   1,    /* string a 'D'    */
5815     3,   1,    /* string b 'one'  */
5816     3,   1,    /* string c 'two'  */
5817     0,   0,    /* string d ''     */
5818     4,   1,    /* string e 'four' */
5819     4,   1,    /* string f 'five' */
5820 };
5821
5822 static void test_stringtable(void)
5823 {
5824     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5825     IStorage *stg = NULL;
5826     IStream *stm;
5827     WCHAR name[0x20];
5828     HRESULT hr;
5829     const char *query;
5830     char buffer[MAX_PATH];
5831     WCHAR data[MAX_PATH];
5832     DWORD sz, read;
5833     UINT r;
5834
5835     static const DWORD mode = STGM_DIRECT | STGM_READ | STGM_SHARE_DENY_WRITE;
5836     static const WCHAR stringdata[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0}; /* _StringData */
5837     static const WCHAR stringpool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0}; /* _StringPool */
5838     static const WCHAR moo[] = {0x4840, 0x3e16, 0x4818, 0}; /* MOO */
5839     static const WCHAR aar[] = {0x4840, 0x3a8a, 0x481b, 0}; /* AAR */
5840
5841     DeleteFileA(msifile);
5842
5843     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5844     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5845
5846     query = "CREATE TABLE `MOO` (`A` INT, `B` CHAR(72) PRIMARY KEY `A`)";
5847     r = run_query(hdb, 0, query);
5848     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5849
5850     query = "CREATE TABLE `AAR` (`C` INT, `D` CHAR(72) PRIMARY KEY `C`)";
5851     r = run_query(hdb, 0, query);
5852     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5853
5854     /* insert persistent row */
5855     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (1, 'one')";
5856     r = run_query(hdb, 0, query);
5857     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5858
5859     /* insert persistent row */
5860     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (2, 'two')";
5861     r = run_query(hdb, 0, query);
5862     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5863
5864     /* open a view */
5865     query = "SELECT * FROM `MOO`";
5866     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5867     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5868     r = MsiViewExecute(hview, 0);
5869     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5870
5871     hrec = MsiCreateRecord(2);
5872
5873     r = MsiRecordSetInteger(hrec, 1, 3);
5874     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5875     r = MsiRecordSetStringA(hrec, 2, "three");
5876     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5877
5878     /* insert a nonpersistent row */
5879     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
5880     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5881
5882     r = MsiCloseHandle(hrec);
5883     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5884     r = MsiViewClose(hview);
5885     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5886     r = MsiCloseHandle(hview);
5887     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5888
5889     /* insert persistent row */
5890     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (4, 'four')";
5891     r = run_query(hdb, 0, query);
5892     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5893
5894     /* insert persistent row */
5895     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (5, 'five')";
5896     r = run_query(hdb, 0, query);
5897     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5898
5899     r = MsiDatabaseCommit(hdb);
5900     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5901
5902     r = MsiCloseHandle(hdb);
5903     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5904
5905     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
5906     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5907
5908     query = "SELECT * FROM `MOO`";
5909     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5910     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5911
5912     r = MsiViewExecute(hview, 0);
5913     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5914
5915     r = MsiViewFetch(hview, &hrec);
5916     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5917
5918     r = MsiRecordGetFieldCount(hrec);
5919     ok(r == 2, "Expected 2, got %d\n", r);
5920
5921     r = MsiRecordGetInteger(hrec, 1);
5922     ok(r == 1, "Expected 1, got %d\n", r);
5923
5924     sz = sizeof(buffer);
5925     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5926     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5927     ok(!lstrcmpA(buffer, "one"), "Expected one, got '%s'\n", buffer);
5928
5929     r = MsiCloseHandle(hrec);
5930     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5931
5932     r = MsiViewFetch(hview, &hrec);
5933     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5934
5935     r = MsiViewClose(hview);
5936     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5937     r = MsiCloseHandle(hview);
5938     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5939     r = MsiCloseHandle(hrec);
5940     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5941
5942     query = "SELECT * FROM `AAR`";
5943     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5944     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5945
5946     r = MsiViewExecute(hview, 0);
5947     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5948
5949     r = MsiViewFetch(hview, &hrec);
5950     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5951
5952     r = MsiRecordGetFieldCount(hrec);
5953     ok(r == 2, "Expected 2, got %d\n", r);
5954
5955     r = MsiRecordGetInteger(hrec, 1);
5956     ok(r == 2, "Expected 2, got %d\n", r);
5957
5958     sz = sizeof(buffer);
5959     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5960     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5961     ok(!lstrcmpA(buffer, "two"), "Expected two, got '%s'\n", buffer);
5962
5963     r = MsiCloseHandle(hrec);
5964     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5965
5966     r = MsiViewFetch(hview, &hrec);
5967     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5968
5969     r = MsiRecordGetFieldCount(hrec);
5970     ok(r == 2, "Expected 2, got %d\n", r);
5971
5972     r = MsiRecordGetInteger(hrec, 1);
5973     ok(r == 5, "Expected 5, got %d\n", r);
5974
5975     sz = sizeof(buffer);
5976     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5977     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5978     ok(!lstrcmpA(buffer, "five"), "Expected five, got '%s'\n", buffer);
5979
5980     r = MsiCloseHandle(hrec);
5981     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5982
5983     r = MsiViewFetch(hview, &hrec);
5984     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5985
5986     r = MsiViewClose(hview);
5987     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5988     r = MsiCloseHandle(hview);
5989     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5990     r = MsiCloseHandle(hrec);
5991     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5992     r = MsiCloseHandle(hdb);
5993     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5994
5995     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, 0x20);
5996     hr = StgOpenStorage(name, NULL, mode, NULL, 0, &stg);
5997     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5998     ok(stg != NULL, "Expected non-NULL storage\n");
5999
6000     hr = IStorage_OpenStream(stg, moo, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6001     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6002     ok(stm != NULL, "Expected non-NULL stream\n");
6003
6004     hr = IStream_Read(stm, data, MAX_PATH, &read);
6005     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6006     ok(read == 4, "Expected 4, got %d\n", read);
6007     todo_wine ok(!memcmp(data, data10, read), "Unexpected data\n");
6008
6009     hr = IStream_Release(stm);
6010     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6011
6012     hr = IStorage_OpenStream(stg, aar, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6013     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6014     ok(stm != NULL, "Expected non-NULL stream\n");
6015
6016     hr = IStream_Read(stm, data, MAX_PATH, &read);
6017     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6018     ok(read == 8, "Expected 8, got %d\n", read);
6019     todo_wine
6020     {
6021         ok(!memcmp(data, data11, read), "Unexpected data\n");
6022     }
6023
6024     hr = IStream_Release(stm);
6025     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6026
6027     hr = IStorage_OpenStream(stg, stringdata, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6028     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6029     ok(stm != NULL, "Expected non-NULL stream\n");
6030
6031     hr = IStream_Read(stm, buffer, MAX_PATH, &read);
6032     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6033     ok(read == 24, "Expected 24, got %d\n", read);
6034     ok(!memcmp(buffer, data12, read), "Unexpected data\n");
6035
6036     hr = IStream_Release(stm);
6037     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6038
6039     hr = IStorage_OpenStream(stg, stringpool, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6040     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6041     ok(stm != NULL, "Expected non-NULL stream\n");
6042
6043     hr = IStream_Read(stm, data, MAX_PATH, &read);
6044     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6045     todo_wine
6046     {
6047         ok(read == 64, "Expected 64, got %d\n", read);
6048         ok(!memcmp(data, data13, read), "Unexpected data\n");
6049     }
6050
6051     hr = IStream_Release(stm);
6052     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6053
6054     hr = IStorage_Release(stg);
6055     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6056
6057     DeleteFileA(msifile);
6058 }
6059
6060 static void test_viewmodify_delete(void)
6061 {
6062     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
6063     UINT r;
6064     const char *query;
6065     char buffer[0x100];
6066     DWORD sz;
6067
6068     DeleteFileA(msifile);
6069
6070     /* just MsiOpenDatabase should not create a file */
6071     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6072     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6073
6074     query = "CREATE TABLE `phone` ( "
6075             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
6076             "PRIMARY KEY `id`)";
6077     r = run_query(hdb, 0, query);
6078     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6079
6080     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
6081         "VALUES('1', 'Alan', '5030581')";
6082     r = run_query(hdb, 0, query);
6083     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6084
6085     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
6086         "VALUES('2', 'Barry', '928440')";
6087     r = run_query(hdb, 0, query);
6088     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6089
6090     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
6091         "VALUES('3', 'Cindy', '2937550')";
6092     r = run_query(hdb, 0, query);
6093     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6094
6095     query = "SELECT * FROM `phone` WHERE `id` <= 2";
6096     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6097     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6098     r = MsiViewExecute(hview, 0);
6099     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6100     r = MsiViewFetch(hview, &hrec);
6101     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6102
6103     /* delete 1 */
6104     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6105     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6106
6107     r = MsiCloseHandle(hrec);
6108     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6109     r = MsiViewFetch(hview, &hrec);
6110     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6111
6112     /* delete 2 */
6113     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6114     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6115
6116     r = MsiCloseHandle(hrec);
6117     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6118     r = MsiViewClose(hview);
6119     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6120     r = MsiCloseHandle(hview);
6121     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6122
6123     query = "SELECT * FROM `phone`";
6124     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6125     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6126     r = MsiViewExecute(hview, 0);
6127     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6128     r = MsiViewFetch(hview, &hrec);
6129     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6130
6131     r = MsiRecordGetInteger(hrec, 1);
6132     ok(r == 3, "Expected 3, got %d\n", r);
6133
6134     sz = sizeof(buffer);
6135     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
6136     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6137     ok(!lstrcmpA(buffer, "Cindy"), "Expected Cindy, got %s\n", buffer);
6138
6139     sz = sizeof(buffer);
6140     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
6141     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6142     ok(!lstrcmpA(buffer, "2937550"), "Expected 2937550, got %s\n", buffer);
6143
6144     r = MsiCloseHandle(hrec);
6145     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6146
6147     r = MsiViewFetch(hview, &hrec);
6148     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6149
6150     r = MsiViewClose(hview);
6151     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6152     r = MsiCloseHandle(hview);
6153     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6154     r = MsiCloseHandle(hdb);
6155     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6156 }
6157
6158 static const WCHAR _Tables[] = {0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0};
6159 static const WCHAR _StringData[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0};
6160 static const WCHAR _StringPool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0};
6161
6162 static const WCHAR data14[] = { /* _StringPool */
6163 /*  len, refs */
6164     0,   0,    /* string 0 ''    */
6165 };
6166
6167 static const struct {
6168     LPCWSTR name;
6169     const void *data;
6170     DWORD size;
6171 } database_table_data[] =
6172 {
6173     {_Tables, NULL, 0},
6174     {_StringData, NULL, 0},
6175     {_StringPool, data14, sizeof data14},
6176 };
6177
6178 static void enum_stream_names(IStorage *stg)
6179 {
6180     IEnumSTATSTG *stgenum = NULL;
6181     IStream *stm;
6182     HRESULT hr;
6183     STATSTG stat;
6184     ULONG n, count;
6185     BYTE data[MAX_PATH];
6186     BYTE check[MAX_PATH];
6187     DWORD sz;
6188
6189     memset(check, 'a', MAX_PATH);
6190
6191     hr = IStorage_EnumElements(stg, 0, NULL, 0, &stgenum);
6192     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6193
6194     n = 0;
6195     while(TRUE)
6196     {
6197         count = 0;
6198         hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &count);
6199         if(FAILED(hr) || !count)
6200             break;
6201
6202         ok(!lstrcmpW(stat.pwcsName, database_table_data[n].name),
6203            "Expected table %d name to match\n", n);
6204
6205         stm = NULL;
6206         hr = IStorage_OpenStream(stg, stat.pwcsName, NULL,
6207                                  STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6208         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6209         ok(stm != NULL, "Expected non-NULL stream\n");
6210
6211         CoTaskMemFree(stat.pwcsName);
6212
6213         sz = MAX_PATH;
6214         memset(data, 'a', MAX_PATH);
6215         hr = IStream_Read(stm, data, sz, &count);
6216         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6217
6218         ok(count == database_table_data[n].size,
6219            "Expected %d, got %d\n", database_table_data[n].size, count);
6220
6221         if (!database_table_data[n].size)
6222             ok(!memcmp(data, check, MAX_PATH), "data should not be changed\n");
6223         else
6224             ok(!memcmp(data, database_table_data[n].data, database_table_data[n].size),
6225                "Expected table %d data to match\n", n);
6226
6227         IStream_Release(stm);
6228         n++;
6229     }
6230
6231     ok(n == 3, "Expected 3, got %d\n", n);
6232
6233     IEnumSTATSTG_Release(stgenum);
6234 }
6235
6236 static void test_defaultdatabase(void)
6237 {
6238     UINT r;
6239     HRESULT hr;
6240     MSIHANDLE hdb;
6241     IStorage *stg = NULL;
6242
6243     DeleteFileA(msifile);
6244
6245     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6246     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6247
6248     r = MsiDatabaseCommit(hdb);
6249     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6250
6251     MsiCloseHandle(hdb);
6252
6253     hr = StgOpenStorage(msifileW, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
6254     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6255     ok(stg != NULL, "Expected non-NULL stg\n");
6256
6257     enum_stream_names(stg);
6258
6259     IStorage_Release(stg);
6260     DeleteFileA(msifile);
6261 }
6262
6263 static void test_order(void)
6264 {
6265     MSIHANDLE hdb, hview, hrec;
6266     CHAR buffer[MAX_PATH];
6267     LPCSTR query;
6268     UINT r, sz;
6269     int val;
6270
6271     hdb = create_db();
6272     ok(hdb, "failed to create db\n");
6273
6274     query = "CREATE TABLE `Empty` ( `A` SHORT NOT NULL PRIMARY KEY `A`)";
6275     r = run_query(hdb, 0, query);
6276     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6277
6278     query = "CREATE TABLE `Mesa` ( `A` SHORT NOT NULL, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
6279     r = run_query(hdb, 0, query);
6280     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6281
6282     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 1, 2, 9 )";
6283     r = run_query(hdb, 0, query);
6284     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6285
6286     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 3, 4, 7 )";
6287     r = run_query(hdb, 0, query);
6288     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6289
6290     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 5, 6, 8 )";
6291     r = run_query(hdb, 0, query);
6292     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6293
6294     query = "CREATE TABLE `Sideboard` ( `D` SHORT NOT NULL, `E` SHORT, `F` SHORT PRIMARY KEY `D`)";
6295     r = run_query(hdb, 0, query);
6296     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6297
6298     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 10, 11, 18 )";
6299     r = run_query(hdb, 0, query);
6300     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6301
6302     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 12, 13, 16 )";
6303     r = run_query(hdb, 0, query);
6304     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6305
6306     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 14, 15, 17 )";
6307     r = run_query(hdb, 0, query);
6308     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6309
6310     query = "SELECT `A`, `B` FROM `Mesa` ORDER BY `C`";
6311     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6312     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6313     r = MsiViewExecute(hview, 0);
6314     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6315
6316     r = MsiViewFetch(hview, &hrec);
6317     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6318
6319     val = MsiRecordGetInteger(hrec, 1);
6320     ok(val == 3, "Expected 3, got %d\n", val);
6321
6322     val = MsiRecordGetInteger(hrec, 2);
6323     ok(val == 4, "Expected 3, got %d\n", val);
6324
6325     MsiCloseHandle(hrec);
6326
6327     r = MsiViewFetch(hview, &hrec);
6328     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6329
6330     val = MsiRecordGetInteger(hrec, 1);
6331     ok(val == 5, "Expected 5, got %d\n", val);
6332
6333     val = MsiRecordGetInteger(hrec, 2);
6334     ok(val == 6, "Expected 6, got %d\n", val);
6335
6336     MsiCloseHandle(hrec);
6337
6338     r = MsiViewFetch(hview, &hrec);
6339     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6340
6341     val = MsiRecordGetInteger(hrec, 1);
6342     ok(val == 1, "Expected 1, got %d\n", val);
6343
6344     val = MsiRecordGetInteger(hrec, 2);
6345     ok(val == 2, "Expected 2, got %d\n", val);
6346
6347     MsiCloseHandle(hrec);
6348
6349     r = MsiViewFetch(hview, &hrec);
6350     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6351
6352     MsiViewClose(hview);
6353     MsiCloseHandle(hview);
6354
6355     query = "SELECT `A`, `D` FROM `Mesa`, `Sideboard` ORDER BY `F`";
6356     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6357     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6358     r = MsiViewExecute(hview, 0);
6359     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6360
6361     r = MsiViewFetch(hview, &hrec);
6362     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6363
6364     val = MsiRecordGetInteger(hrec, 1);
6365     ok(val == 1, "Expected 1, got %d\n", val);
6366
6367     val = MsiRecordGetInteger(hrec, 2);
6368     ok(val == 12, "Expected 12, got %d\n", val);
6369
6370     MsiCloseHandle(hrec);
6371
6372     r = MsiViewFetch(hview, &hrec);
6373     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6374
6375     val = MsiRecordGetInteger(hrec, 1);
6376     ok(val == 3, "Expected 3, got %d\n", val);
6377
6378     val = MsiRecordGetInteger(hrec, 2);
6379     ok(val == 12, "Expected 12, got %d\n", val);
6380
6381     MsiCloseHandle(hrec);
6382
6383     r = MsiViewFetch(hview, &hrec);
6384     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6385
6386     val = MsiRecordGetInteger(hrec, 1);
6387     ok(val == 5, "Expected 5, got %d\n", val);
6388
6389     val = MsiRecordGetInteger(hrec, 2);
6390     ok(val == 12, "Expected 12, got %d\n", val);
6391
6392     MsiCloseHandle(hrec);
6393
6394     r = MsiViewFetch(hview, &hrec);
6395     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6396
6397     val = MsiRecordGetInteger(hrec, 1);
6398     ok(val == 1, "Expected 1, got %d\n", val);
6399
6400     val = MsiRecordGetInteger(hrec, 2);
6401     ok(val == 14, "Expected 14, got %d\n", val);
6402
6403     MsiCloseHandle(hrec);
6404
6405     r = MsiViewFetch(hview, &hrec);
6406     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6407
6408     val = MsiRecordGetInteger(hrec, 1);
6409     ok(val == 3, "Expected 3, got %d\n", val);
6410
6411     val = MsiRecordGetInteger(hrec, 2);
6412     ok(val == 14, "Expected 14, got %d\n", val);
6413
6414     MsiCloseHandle(hrec);
6415
6416     r = MsiViewFetch(hview, &hrec);
6417     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6418
6419     val = MsiRecordGetInteger(hrec, 1);
6420     ok(val == 5, "Expected 5, got %d\n", val);
6421
6422     val = MsiRecordGetInteger(hrec, 2);
6423     ok(val == 14, "Expected 14, got %d\n", val);
6424
6425     MsiCloseHandle(hrec);
6426
6427     r = MsiViewFetch(hview, &hrec);
6428     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6429
6430     val = MsiRecordGetInteger(hrec, 1);
6431     ok(val == 1, "Expected 1, got %d\n", val);
6432
6433     val = MsiRecordGetInteger(hrec, 2);
6434     ok(val == 10, "Expected 10, got %d\n", val);
6435
6436     MsiCloseHandle(hrec);
6437
6438     r = MsiViewFetch(hview, &hrec);
6439     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6440
6441     val = MsiRecordGetInteger(hrec, 1);
6442     ok(val == 3, "Expected 3, got %d\n", val);
6443
6444     val = MsiRecordGetInteger(hrec, 2);
6445     ok(val == 10, "Expected 10, got %d\n", val);
6446
6447     MsiCloseHandle(hrec);
6448
6449     r = MsiViewFetch(hview, &hrec);
6450     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6451
6452     val = MsiRecordGetInteger(hrec, 1);
6453     ok(val == 5, "Expected 5, got %d\n", val);
6454
6455     val = MsiRecordGetInteger(hrec, 2);
6456     ok(val == 10, "Expected 10, got %d\n", val);
6457
6458     MsiCloseHandle(hrec);
6459
6460     r = MsiViewFetch(hview, &hrec);
6461     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6462
6463     MsiViewClose(hview);
6464     MsiCloseHandle(hview);
6465
6466     query = "SELECT * FROM `Empty` ORDER BY `A`";
6467     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6468     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6469     r = MsiViewExecute(hview, 0);
6470     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6471
6472     r = MsiViewFetch(hview, &hrec);
6473     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6474
6475     MsiViewClose(hview);
6476     MsiCloseHandle(hview);
6477
6478     query = "CREATE TABLE `Buffet` ( `One` CHAR(72), `Two` SHORT PRIMARY KEY `One`)";
6479     r = run_query(hdb, 0, query);
6480     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6481
6482     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'uno',  2)";
6483     r = run_query(hdb, 0, query);
6484     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6485
6486     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'dos',  3)";
6487     r = run_query(hdb, 0, query);
6488     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6489
6490     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'tres',  1)";
6491     r = run_query(hdb, 0, query);
6492     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6493
6494     query = "SELECT * FROM `Buffet` WHERE `One` = 'dos' ORDER BY `Two`";
6495     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6496     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6497     r = MsiViewExecute(hview, 0);
6498     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6499
6500     r = MsiViewFetch(hview, &hrec);
6501     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6502
6503     sz = sizeof(buffer);
6504     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
6505     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6506     ok(!lstrcmpA(buffer, "dos"), "Expected \"dos\", got \"%s\"\n", buffer);
6507
6508     r = MsiRecordGetInteger(hrec, 2);
6509     ok(r == 3, "Expected 3, got %d\n", r);
6510
6511     MsiCloseHandle(hrec);
6512
6513     r = MsiViewFetch(hview, &hrec);
6514     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6515
6516     MsiViewClose(hview);
6517     MsiCloseHandle(hview);
6518     MsiCloseHandle(hdb);
6519 }
6520
6521 static void test_viewmodify_delete_temporary(void)
6522 {
6523     MSIHANDLE hdb, hview, hrec;
6524     const char *query;
6525     UINT r;
6526
6527     DeleteFileA(msifile);
6528
6529     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6530     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6531
6532     query = "CREATE TABLE `Table` ( `A` SHORT PRIMARY KEY `A` )";
6533     r = run_query(hdb, 0, query);
6534     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6535
6536     query = "SELECT * FROM `Table`";
6537     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6538     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6539     r = MsiViewExecute(hview, 0);
6540     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6541
6542     hrec = MsiCreateRecord(1);
6543     MsiRecordSetInteger(hrec, 1, 1);
6544
6545     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
6546     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6547
6548     MsiCloseHandle(hrec);
6549
6550     hrec = MsiCreateRecord(1);
6551     MsiRecordSetInteger(hrec, 1, 2);
6552
6553     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
6554     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6555
6556     MsiCloseHandle(hrec);
6557
6558     hrec = MsiCreateRecord(1);
6559     MsiRecordSetInteger(hrec, 1, 3);
6560
6561     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
6562     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6563
6564     MsiCloseHandle(hrec);
6565
6566     hrec = MsiCreateRecord(1);
6567     MsiRecordSetInteger(hrec, 1, 4);
6568
6569     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
6570     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6571
6572     MsiCloseHandle(hrec);
6573     MsiViewClose(hview);
6574     MsiCloseHandle(hview);
6575
6576     query = "SELECT * FROM `Table` WHERE  `A` = 2";
6577     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6578     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6579     r = MsiViewExecute(hview, 0);
6580     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6581     r = MsiViewFetch(hview, &hrec);
6582     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6583
6584     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6585     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6586
6587     MsiCloseHandle(hrec);
6588     MsiViewClose(hview);
6589     MsiCloseHandle(hview);
6590
6591     query = "SELECT * FROM `Table` WHERE  `A` = 3";
6592     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6593     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6594     r = MsiViewExecute(hview, 0);
6595     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6596     r = MsiViewFetch(hview, &hrec);
6597     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6598
6599     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6600     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6601
6602     MsiCloseHandle(hrec);
6603     MsiViewClose(hview);
6604     MsiCloseHandle(hview);
6605
6606     query = "SELECT * FROM `Table` ORDER BY `A`";
6607     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6608     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6609     r = MsiViewExecute(hview, 0);
6610     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6611
6612     r = MsiViewFetch(hview, &hrec);
6613     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6614
6615     r = MsiRecordGetInteger(hrec, 1);
6616     ok(r == 1, "Expected 1, got %d\n", r);
6617
6618     MsiCloseHandle(hrec);
6619
6620     r = MsiViewFetch(hview, &hrec);
6621     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6622
6623     r = MsiRecordGetInteger(hrec, 1);
6624     ok(r == 4, "Expected 4, got %d\n", r);
6625
6626     MsiCloseHandle(hrec);
6627
6628     r = MsiViewFetch(hview, &hrec);
6629     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6630
6631     MsiViewClose(hview);
6632     MsiCloseHandle(hview);
6633     MsiCloseHandle(hdb);
6634     DeleteFileA(msifile);
6635 }
6636
6637 static void test_deleterow(void)
6638 {
6639     MSIHANDLE hdb, hview, hrec;
6640     const char *query;
6641     char buf[MAX_PATH];
6642     UINT r;
6643     DWORD size;
6644
6645     DeleteFileA(msifile);
6646
6647     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6648     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6649
6650     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6651     r = run_query(hdb, 0, query);
6652     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6653
6654     query = "INSERT INTO `Table` (`A`) VALUES ('one')";
6655     r = run_query(hdb, 0, query);
6656     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6657
6658     query = "INSERT INTO `Table` (`A`) VALUES ('two')";
6659     r = run_query(hdb, 0, query);
6660     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6661
6662     query = "DELETE FROM `Table` WHERE `A` = 'one'";
6663     r = run_query(hdb, 0, query);
6664     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6665
6666     r = MsiDatabaseCommit(hdb);
6667     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6668
6669     MsiCloseHandle(hdb);
6670
6671     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
6672     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6673
6674     query = "SELECT * FROM `Table`";
6675     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6676     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6677     r = MsiViewExecute(hview, 0);
6678     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6679
6680     r = MsiViewFetch(hview, &hrec);
6681     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6682
6683     size = MAX_PATH;
6684     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6685     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6686     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
6687
6688     MsiCloseHandle(hrec);
6689
6690     r = MsiViewFetch(hview, &hrec);
6691     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6692
6693     MsiViewClose(hview);
6694     MsiCloseHandle(hview);
6695     MsiCloseHandle(hdb);
6696     DeleteFileA(msifile);
6697 }
6698
6699 static const CHAR import_dat[] = "A\n"
6700                                  "s72\n"
6701                                  "Table\tA\n"
6702                                  "This is a new 'string' ok\n";
6703
6704 static void test_quotes(void)
6705 {
6706     MSIHANDLE hdb, hview, hrec;
6707     const char *query;
6708     char buf[MAX_PATH];
6709     UINT r;
6710     DWORD size;
6711
6712     DeleteFileA(msifile);
6713
6714     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6715     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6716
6717     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
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 ( 'This is a 'string' ok' )";
6722     r = run_query(hdb, 0, query);
6723     ok(r == ERROR_BAD_QUERY_SYNTAX,
6724        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6725
6726     query = "INSERT INTO `Table` ( `A` ) VALUES ( \"This is a 'string' ok\" )";
6727     r = run_query(hdb, 0, query);
6728     ok(r == ERROR_BAD_QUERY_SYNTAX,
6729        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6730
6731     query = "INSERT INTO `Table` ( `A` ) VALUES ( \"test\" )";
6732     r = run_query(hdb, 0, query);
6733     ok(r == ERROR_BAD_QUERY_SYNTAX,
6734        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6735
6736     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a ''string'' ok' )";
6737     r = run_query(hdb, 0, query);
6738     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6739
6740     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a '''string''' ok' )";
6741     r = run_query(hdb, 0, query);
6742     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6743
6744     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \'string\' ok' )";
6745     r = run_query(hdb, 0, query);
6746     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6747
6748     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \"string\" ok' )";
6749     r = run_query(hdb, 0, query);
6750     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6751
6752     query = "SELECT * FROM `Table`";
6753     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6754     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6755
6756     r = MsiViewExecute(hview, 0);
6757     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6758
6759     r = MsiViewFetch(hview, &hrec);
6760     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6761
6762     size = MAX_PATH;
6763     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6764     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6765     ok(!lstrcmpA(buf, "This is a \"string\" ok"),
6766        "Expected \"This is a \"string\" ok\", got %s\n", buf);
6767
6768     MsiCloseHandle(hrec);
6769
6770     r = MsiViewFetch(hview, &hrec);
6771     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6772
6773     MsiViewClose(hview);
6774     MsiCloseHandle(hview);
6775
6776     write_file("import.idt", import_dat, (sizeof(import_dat) - 1) * sizeof(char));
6777
6778     r = MsiDatabaseImportA(hdb, CURR_DIR, "import.idt");
6779     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6780
6781     DeleteFileA("import.idt");
6782
6783     query = "SELECT * FROM `Table`";
6784     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6785     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6786
6787     r = MsiViewExecute(hview, 0);
6788     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6789
6790     r = MsiViewFetch(hview, &hrec);
6791     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6792
6793     size = MAX_PATH;
6794     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6795     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6796     ok(!lstrcmpA(buf, "This is a new 'string' ok"),
6797        "Expected \"This is a new 'string' ok\", got %s\n", buf);
6798
6799     MsiCloseHandle(hrec);
6800
6801     r = MsiViewFetch(hview, &hrec);
6802     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6803
6804     MsiViewClose(hview);
6805     MsiCloseHandle(hview);
6806     MsiCloseHandle(hdb);
6807     DeleteFileA(msifile);
6808 }
6809
6810 static void test_carriagereturn(void)
6811 {
6812     MSIHANDLE hdb, hview, hrec;
6813     const char *query;
6814     char buf[MAX_PATH];
6815     UINT r;
6816     DWORD size;
6817
6818     DeleteFileA(msifile);
6819
6820     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6821     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6822
6823     query = "CREATE TABLE `Table`\r ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6824     r = run_query(hdb, 0, query);
6825     ok(r == ERROR_BAD_QUERY_SYNTAX,
6826        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6827
6828     query = "CREATE TABLE `Table` \r( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6829     r = run_query(hdb, 0, query);
6830     ok(r == ERROR_BAD_QUERY_SYNTAX,
6831        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6832
6833     query = "CREATE\r TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6834     r = run_query(hdb, 0, query);
6835     ok(r == ERROR_BAD_QUERY_SYNTAX,
6836        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6837
6838     query = "CREATE TABLE\r `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6839     r = run_query(hdb, 0, query);
6840     ok(r == ERROR_BAD_QUERY_SYNTAX,
6841        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6842
6843     query = "CREATE TABLE `Table` (\r `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6844     r = run_query(hdb, 0, query);
6845     ok(r == ERROR_BAD_QUERY_SYNTAX,
6846        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6847
6848     query = "CREATE TABLE `Table` ( `A`\r CHAR(72) NOT NULL PRIMARY KEY `A` )";
6849     r = run_query(hdb, 0, query);
6850     ok(r == ERROR_BAD_QUERY_SYNTAX,
6851        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6852
6853     query = "CREATE TABLE `Table` ( `A` CHAR(72)\r NOT NULL PRIMARY KEY `A` )";
6854     r = run_query(hdb, 0, query);
6855     ok(r == ERROR_BAD_QUERY_SYNTAX,
6856        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6857
6858     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT\r NULL PRIMARY KEY `A` )";
6859     r = run_query(hdb, 0, query);
6860     ok(r == ERROR_BAD_QUERY_SYNTAX,
6861        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6862
6863     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT \rNULL PRIMARY KEY `A` )";
6864     r = run_query(hdb, 0, query);
6865     ok(r == ERROR_BAD_QUERY_SYNTAX,
6866        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6867
6868     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL\r PRIMARY KEY `A` )";
6869     r = run_query(hdb, 0, query);
6870     ok(r == ERROR_BAD_QUERY_SYNTAX,
6871        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6872
6873     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL \rPRIMARY KEY `A` )";
6874     r = run_query(hdb, 0, query);
6875     ok(r == ERROR_BAD_QUERY_SYNTAX,
6876        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6877
6878     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY\r KEY `A` )";
6879     r = run_query(hdb, 0, query);
6880     ok(r == ERROR_BAD_QUERY_SYNTAX,
6881        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6882
6883     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY \rKEY `A` )";
6884     r = run_query(hdb, 0, query);
6885     ok(r == ERROR_BAD_QUERY_SYNTAX,
6886        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6887
6888     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY\r `A` )";
6889     r = run_query(hdb, 0, query);
6890     ok(r == ERROR_BAD_QUERY_SYNTAX,
6891        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6892
6893     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A`\r )";
6894     r = run_query(hdb, 0, query);
6895     ok(r == ERROR_BAD_QUERY_SYNTAX,
6896        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6897
6898     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )\r";
6899     r = run_query(hdb, 0, query);
6900     ok(r == ERROR_BAD_QUERY_SYNTAX,
6901        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6902
6903     query = "CREATE TABLE `\rOne` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6904     r = run_query(hdb, 0, query);
6905     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6906
6907     query = "CREATE TABLE `Tw\ro` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6908     r = run_query(hdb, 0, query);
6909     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6910
6911     query = "CREATE TABLE `Three\r` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6912     r = run_query(hdb, 0, query);
6913     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6914
6915     query = "CREATE TABLE `Four` ( `A\r` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6916     r = run_query(hdb, 0, query);
6917     ok(r == ERROR_BAD_QUERY_SYNTAX,
6918        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6919
6920     query = "CREATE TABLE `Four` ( `\rA` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6921     r = run_query(hdb, 0, query);
6922     ok(r == ERROR_BAD_QUERY_SYNTAX,
6923        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6924
6925     query = "CREATE TABLE `Four` ( `A` CHAR(72\r) NOT NULL PRIMARY KEY `A` )";
6926     r = run_query(hdb, 0, query);
6927     ok(r == ERROR_BAD_QUERY_SYNTAX,
6928        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6929
6930     query = "CREATE TABLE `Four` ( `A` CHAR(\r72) NOT NULL PRIMARY KEY `A` )";
6931     r = run_query(hdb, 0, query);
6932     ok(r == ERROR_BAD_QUERY_SYNTAX,
6933        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6934
6935     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `\rA` )";
6936     r = run_query(hdb, 0, query);
6937     ok(r == ERROR_BAD_QUERY_SYNTAX,
6938        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6939
6940     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
6941     r = run_query(hdb, 0, query);
6942     ok(r == ERROR_BAD_QUERY_SYNTAX,
6943        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6944
6945     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
6946     r = run_query(hdb, 0, query);
6947     ok(r == ERROR_BAD_QUERY_SYNTAX,
6948        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6949
6950     query = "SELECT * FROM `_Tables`";
6951     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6952     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6953     r = MsiViewExecute(hview, 0);
6954     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6955
6956     r = MsiViewFetch(hview, &hrec);
6957     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6958
6959     size = MAX_PATH;
6960     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6961     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6962     ok(!lstrcmpA(buf, "\rOne"), "Expected \"\\rOne\", got \"%s\"\n", buf);
6963
6964     MsiCloseHandle(hrec);
6965
6966     r = MsiViewFetch(hview, &hrec);
6967     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6968
6969     size = MAX_PATH;
6970     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6971     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6972     ok(!lstrcmpA(buf, "Tw\ro"), "Expected \"Tw\\ro\", got \"%s\"\n", buf);
6973
6974     MsiCloseHandle(hrec);
6975
6976     r = MsiViewFetch(hview, &hrec);
6977     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6978
6979     size = MAX_PATH;
6980     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6981     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6982     ok(!lstrcmpA(buf, "Three\r"), "Expected \"Three\r\", got \"%s\"\n", buf);
6983
6984     MsiCloseHandle(hrec);
6985
6986     r = MsiViewFetch(hview, &hrec);
6987     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6988
6989     MsiViewClose(hview);
6990     MsiCloseHandle(hview);
6991
6992     MsiCloseHandle(hdb);
6993     DeleteFileA(msifile);
6994 }
6995
6996 static void test_noquotes(void)
6997 {
6998     MSIHANDLE hdb, hview, hrec;
6999     const char *query;
7000     char buf[MAX_PATH];
7001     UINT r;
7002     DWORD size;
7003
7004     DeleteFileA(msifile);
7005
7006     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7007     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7008
7009     query = "CREATE TABLE Table ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
7010     r = run_query(hdb, 0, query);
7011     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7012
7013     query = "CREATE TABLE `Table` ( A CHAR(72) NOT NULL PRIMARY KEY `A` )";
7014     r = run_query(hdb, 0, query);
7015     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7016
7017     query = "CREATE TABLE `Table2` ( `A` CHAR(72) NOT NULL PRIMARY KEY A )";
7018     r = run_query(hdb, 0, query);
7019     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7020
7021     query = "CREATE TABLE `Table3` ( A CHAR(72) NOT NULL PRIMARY KEY A )";
7022     r = run_query(hdb, 0, query);
7023     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7024
7025     query = "SELECT * FROM `_Tables`";
7026     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7027     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7028     r = MsiViewExecute(hview, 0);
7029     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7030
7031     r = MsiViewFetch(hview, &hrec);
7032     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7033
7034     size = MAX_PATH;
7035     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7036     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7037     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
7038
7039     MsiCloseHandle(hrec);
7040
7041     r = MsiViewFetch(hview, &hrec);
7042     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7043
7044     size = MAX_PATH;
7045     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7046     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7047     ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
7048
7049     MsiCloseHandle(hrec);
7050
7051     r = MsiViewFetch(hview, &hrec);
7052     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7053
7054     size = MAX_PATH;
7055     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7056     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7057     ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
7058
7059     MsiCloseHandle(hrec);
7060
7061     r = MsiViewFetch(hview, &hrec);
7062     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7063
7064     MsiViewClose(hview);
7065     MsiCloseHandle(hview);
7066
7067     query = "SELECT * FROM `_Columns`";
7068     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7069     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7070     r = MsiViewExecute(hview, 0);
7071     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7072
7073     r = MsiViewFetch(hview, &hrec);
7074     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7075
7076     size = MAX_PATH;
7077     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7078     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7079     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
7080
7081     r = MsiRecordGetInteger(hrec, 2);
7082     ok(r == 1, "Expected 1, got %d\n", r);
7083
7084     size = MAX_PATH;
7085     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7086     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7087     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7088
7089     MsiCloseHandle(hrec);
7090
7091     r = MsiViewFetch(hview, &hrec);
7092     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7093
7094     size = MAX_PATH;
7095     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7096     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7097     ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
7098
7099     r = MsiRecordGetInteger(hrec, 2);
7100     ok(r == 1, "Expected 1, got %d\n", r);
7101
7102     size = MAX_PATH;
7103     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7104     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7105     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7106
7107     MsiCloseHandle(hrec);
7108
7109     r = MsiViewFetch(hview, &hrec);
7110     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7111
7112     size = MAX_PATH;
7113     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7114     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7115     ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
7116
7117     r = MsiRecordGetInteger(hrec, 2);
7118     ok(r == 1, "Expected 1, got %d\n", r);
7119
7120     size = MAX_PATH;
7121     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7122     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7123     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7124
7125     MsiCloseHandle(hrec);
7126
7127     r = MsiViewFetch(hview, &hrec);
7128     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7129
7130     MsiViewClose(hview);
7131     MsiCloseHandle(hview);
7132
7133     query = "INSERT INTO Table ( `A` ) VALUES ( 'hi' )";
7134     r = run_query(hdb, 0, query);
7135     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7136
7137     query = "INSERT INTO `Table` ( A ) VALUES ( 'hi' )";
7138     r = run_query(hdb, 0, query);
7139     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7140
7141     query = "INSERT INTO `Table` ( `A` ) VALUES ( hi )";
7142     r = run_query(hdb, 0, query);
7143     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7144
7145     query = "SELECT * FROM Table WHERE `A` = 'hi'";
7146     r = run_query(hdb, 0, query);
7147     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7148
7149     query = "SELECT * FROM `Table` WHERE `A` = hi";
7150     r = run_query(hdb, 0, query);
7151     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7152
7153     query = "SELECT * FROM Table";
7154     r = run_query(hdb, 0, query);
7155     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7156
7157     query = "SELECT * FROM Table2";
7158     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7159     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7160     r = MsiViewExecute(hview, 0);
7161     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7162
7163     r = MsiViewFetch(hview, &hrec);
7164     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7165
7166     MsiViewClose(hview);
7167     MsiCloseHandle(hview);
7168
7169     query = "SELECT * FROM `Table` WHERE A = 'hi'";
7170     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7171     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7172     r = MsiViewExecute(hview, 0);
7173     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7174
7175     r = MsiViewFetch(hview, &hrec);
7176     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7177
7178     size = MAX_PATH;
7179     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7180     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7181     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
7182
7183     MsiCloseHandle(hrec);
7184
7185     r = MsiViewFetch(hview, &hrec);
7186     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7187
7188     MsiViewClose(hview);
7189     MsiCloseHandle(hview);
7190     MsiCloseHandle(hdb);
7191     DeleteFileA(msifile);
7192 }
7193
7194 static void read_file_data(LPCSTR filename, LPSTR buffer)
7195 {
7196     HANDLE file;
7197     DWORD read;
7198
7199     file = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
7200     ZeroMemory(buffer, MAX_PATH);
7201     ReadFile(file, buffer, MAX_PATH, &read, NULL);
7202     CloseHandle(file);
7203 }
7204
7205 static void test_forcecodepage(void)
7206 {
7207     MSIHANDLE hdb;
7208     const char *query;
7209     char buffer[MAX_PATH];
7210     UINT r;
7211
7212     DeleteFileA(msifile);
7213     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
7214
7215     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7216     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7217
7218     query = "SELECT * FROM `_ForceCodepage`";
7219     r = run_query(hdb, 0, query);
7220     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7221
7222     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
7223     r = run_query(hdb, 0, query);
7224     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7225
7226     query = "SELECT * FROM `_ForceCodepage`";
7227     r = run_query(hdb, 0, query);
7228     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7229
7230     r = MsiDatabaseCommit(hdb);
7231     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7232
7233     query = "SELECT * FROM `_ForceCodepage`";
7234     r = run_query(hdb, 0, query);
7235     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7236
7237     MsiCloseHandle(hdb);
7238
7239     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_DIRECT, &hdb);
7240     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7241
7242     query = "SELECT * FROM `_ForceCodepage`";
7243     r = run_query(hdb, 0, query);
7244     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7245
7246     r = MsiDatabaseExportA(hdb, "_ForceCodepage", CURR_DIR, "forcecodepage.idt");
7247     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7248
7249     read_file_data("forcecodepage.idt", buffer);
7250     ok(!lstrcmpA(buffer, "\r\n\r\n0\t_ForceCodepage\r\n"),
7251        "Expected \"\r\n\r\n0\t_ForceCodepage\r\n\", got \"%s\"\n", buffer);
7252
7253     create_file_data("forcecodepage.idt", "\r\n\r\n850\t_ForceCodepage\r\n", 0);
7254
7255     r = MsiDatabaseImportA(hdb, CURR_DIR, "forcecodepage.idt");
7256     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7257
7258     r = MsiDatabaseExportA(hdb, "_ForceCodepage", CURR_DIR, "forcecodepage.idt");
7259     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7260
7261     read_file_data("forcecodepage.idt", buffer);
7262     ok(!lstrcmpA(buffer, "\r\n\r\n850\t_ForceCodepage\r\n"),
7263        "Expected \"\r\n\r\n850\t_ForceCodepage\r\n\", got \"%s\"\n", buffer);
7264
7265     create_file_data("forcecodepage.idt", "\r\n\r\n9999\t_ForceCodepage\r\n", 0);
7266
7267     r = MsiDatabaseImportA(hdb, CURR_DIR, "forcecodepage.idt");
7268     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
7269
7270     MsiCloseHandle(hdb);
7271     DeleteFileA(msifile);
7272     DeleteFileA("forcecodepage.idt");
7273 }
7274
7275 static void test_viewmodify_refresh(void)
7276 {
7277     MSIHANDLE hdb, hview, hrec;
7278     const char *query;
7279     char buffer[MAX_PATH];
7280     UINT r;
7281     DWORD size;
7282
7283     DeleteFileA(msifile);
7284
7285     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7286     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7287
7288     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL, `B` INT PRIMARY KEY `A` )";
7289     r = run_query(hdb, 0, query);
7290     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7291
7292     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hi', 1 )";
7293     r = run_query(hdb, 0, query);
7294     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7295
7296     query = "SELECT * FROM `Table`";
7297     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7298     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7299     r = MsiViewExecute(hview, 0);
7300     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7301
7302     r = MsiViewFetch(hview, &hrec);
7303     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7304
7305     query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hi'";
7306     r = run_query(hdb, 0, query);
7307     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7308
7309     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7310     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7311
7312     size = MAX_PATH;
7313     r = MsiRecordGetStringA(hrec, 1, buffer, &size);
7314     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7315     ok(!lstrcmpA(buffer, "hi"), "Expected \"hi\", got \"%s\"\n", buffer);
7316     ok(size == 2, "Expected 2, got %d\n", size);
7317
7318     r = MsiRecordGetInteger(hrec, 2);
7319     ok(r == 2, "Expected 2, got %d\n", r);
7320
7321     MsiCloseHandle(hrec);
7322     MsiViewClose(hview);
7323     MsiCloseHandle(hview);
7324
7325     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hello', 3 )";
7326     r = run_query(hdb, 0, query);
7327     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7328
7329     query = "SELECT * FROM `Table` WHERE `B` = 3";
7330     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7331     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7332     r = MsiViewExecute(hview, 0);
7333     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7334
7335     r = MsiViewFetch(hview, &hrec);
7336     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7337
7338     query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hello'";
7339     r = run_query(hdb, 0, query);
7340     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7341
7342     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hithere', 3 )";
7343     r = run_query(hdb, 0, query);
7344     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7345
7346     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7347     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7348
7349     size = MAX_PATH;
7350     r = MsiRecordGetStringA(hrec, 1, buffer, &size);
7351     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7352     ok(!lstrcmpA(buffer, "hello"), "Expected \"hello\", got \"%s\"\n", buffer);
7353     ok(size == 5, "Expected 5, got %d\n", size);
7354
7355     r = MsiRecordGetInteger(hrec, 2);
7356     ok(r == 2, "Expected 2, got %d\n", r);
7357
7358     MsiCloseHandle(hrec);
7359     MsiViewClose(hview);
7360     MsiCloseHandle(hview);
7361     MsiCloseHandle(hdb);
7362     DeleteFileA(msifile);
7363 }
7364
7365 static void test_where_viewmodify(void)
7366 {
7367     MSIHANDLE hdb, hview, hrec;
7368     const char *query;
7369     UINT r;
7370
7371     DeleteFileA(msifile);
7372
7373     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7374     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7375
7376     query = "CREATE TABLE `Table` ( `A` INT, `B` INT PRIMARY KEY `A` )";
7377     r = run_query(hdb, 0, query);
7378     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7379
7380     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 1, 2 )";
7381     r = run_query(hdb, 0, query);
7382     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7383
7384     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 3, 4 )";
7385     r = run_query(hdb, 0, query);
7386     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7387
7388     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 5, 6 )";
7389     r = run_query(hdb, 0, query);
7390     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7391
7392     /* `B` = 3 doesn't match, but the view shouldn't be executed */
7393     query = "SELECT * FROM `Table` WHERE `B` = 3";
7394     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7395     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7396
7397     hrec = MsiCreateRecord(2);
7398     MsiRecordSetInteger(hrec, 1, 7);
7399     MsiRecordSetInteger(hrec, 2, 8);
7400
7401     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
7402     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7403
7404     MsiCloseHandle(hrec);
7405     MsiViewClose(hview);
7406     MsiCloseHandle(hview);
7407
7408     query = "SELECT * FROM `Table` WHERE `A` = 7";
7409     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7410     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7411     r = MsiViewExecute(hview, 0);
7412     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7413
7414     r = MsiViewFetch(hview, &hrec);
7415     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7416
7417     r = MsiRecordGetInteger(hrec, 1);
7418     ok(r == 7, "Expected 7, got %d\n", r);
7419
7420     r = MsiRecordGetInteger(hrec, 2);
7421     ok(r == 8, "Expected 8, got %d\n", r);
7422
7423     MsiRecordSetInteger(hrec, 2, 9);
7424
7425     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
7426     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7427
7428     MsiCloseHandle(hrec);
7429     MsiViewClose(hview);
7430     MsiCloseHandle(hview);
7431
7432     query = "SELECT * FROM `Table` WHERE `A` = 7";
7433     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7434     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7435     r = MsiViewExecute(hview, 0);
7436     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7437
7438     r = MsiViewFetch(hview, &hrec);
7439     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7440
7441     r = MsiRecordGetInteger(hrec, 1);
7442     ok(r == 7, "Expected 7, got %d\n", r);
7443
7444     r = MsiRecordGetInteger(hrec, 2);
7445     ok(r == 9, "Expected 9, got %d\n", r);
7446
7447     query = "UPDATE `Table` SET `B` = 10 WHERE `A` = 7";
7448     r = run_query(hdb, 0, query);
7449     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7450
7451     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7452     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7453
7454     r = MsiRecordGetInteger(hrec, 1);
7455     ok(r == 7, "Expected 7, got %d\n", r);
7456
7457     r = MsiRecordGetInteger(hrec, 2);
7458     ok(r == 10, "Expected 10, got %d\n", r);
7459
7460     MsiCloseHandle(hrec);
7461     MsiViewClose(hview);
7462     MsiCloseHandle(hview);
7463     MsiCloseHandle(hdb);
7464 }
7465
7466 static BOOL create_storage(LPCSTR name)
7467 {
7468     WCHAR nameW[MAX_PATH];
7469     IStorage *stg;
7470     IStream *stm;
7471     HRESULT hr;
7472     DWORD count;
7473     BOOL res = FALSE;
7474
7475     MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, MAX_PATH);
7476     hr = StgCreateDocfile(nameW, STGM_CREATE | STGM_READWRITE |
7477                           STGM_DIRECT | STGM_SHARE_EXCLUSIVE, 0, &stg);
7478     if (FAILED(hr))
7479         return FALSE;
7480
7481     hr = IStorage_CreateStream(stg, nameW, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
7482                                0, 0, &stm);
7483     if (FAILED(hr))
7484         goto done;
7485
7486     hr = IStream_Write(stm, "stgdata", 8, &count);
7487     if (SUCCEEDED(hr))
7488         res = TRUE;
7489
7490 done:
7491     IStream_Release(stm);
7492     IStorage_Release(stg);
7493
7494     return res;
7495 }
7496
7497 static void test_storages_table(void)
7498 {
7499     MSIHANDLE hdb, hview, hrec;
7500     IStorage *stg, *inner;
7501     IStream *stm;
7502     char file[MAX_PATH];
7503     char buf[MAX_PATH];
7504     WCHAR name[MAX_PATH];
7505     LPCSTR query;
7506     HRESULT hr;
7507     DWORD size;
7508     UINT r;
7509
7510     hdb = create_db();
7511     ok(hdb, "failed to create db\n");
7512
7513     r = MsiDatabaseCommit(hdb);
7514     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
7515
7516     MsiCloseHandle(hdb);
7517
7518     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb);
7519     ok(r == ERROR_SUCCESS , "Failed to open database\n");
7520
7521     /* check the column types */
7522     hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_TYPES);
7523     ok(hrec, "failed to get column info hrecord\n");
7524     ok(check_record(hrec, 1, "s62"), "wrong hrecord type\n");
7525     ok(check_record(hrec, 2, "V0"), "wrong hrecord type\n");
7526
7527     MsiCloseHandle(hrec);
7528
7529     /* now try the names */
7530     hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_NAMES);
7531     ok(hrec, "failed to get column info hrecord\n");
7532     ok(check_record(hrec, 1, "Name"), "wrong hrecord type\n");
7533     ok(check_record(hrec, 2, "Data"), "wrong hrecord type\n");
7534
7535     MsiCloseHandle(hrec);
7536
7537     create_storage("storage.bin");
7538
7539     hrec = MsiCreateRecord(2);
7540     MsiRecordSetStringA(hrec, 1, "stgname");
7541
7542     r = MsiRecordSetStreamA(hrec, 2, "storage.bin");
7543     ok(r == ERROR_SUCCESS, "Failed to add stream data to the hrecord: %d\n", r);
7544
7545     DeleteFileA("storage.bin");
7546
7547     query = "INSERT INTO `_Storages` (`Name`, `Data`) VALUES (?, ?)";
7548     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7549     ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
7550
7551     r = MsiViewExecute(hview, hrec);
7552     ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
7553
7554     MsiCloseHandle(hrec);
7555     MsiViewClose(hview);
7556     MsiCloseHandle(hview);
7557
7558     query = "SELECT `Name`, `Data` FROM `_Storages`";
7559     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7560     ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
7561
7562     r = MsiViewExecute(hview, 0);
7563     ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
7564
7565     r = MsiViewFetch(hview, &hrec);
7566     ok(r == ERROR_SUCCESS, "Failed to fetch hrecord: %d\n", r);
7567
7568     size = MAX_PATH;
7569     r = MsiRecordGetStringA(hrec, 1, file, &size);
7570     ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
7571     ok(!lstrcmpA(file, "stgname"), "Expected \"stgname\", got \"%s\"\n", file);
7572
7573     size = MAX_PATH;
7574     lstrcpyA(buf, "apple");
7575     r = MsiRecordReadStream(hrec, 2, buf, &size);
7576     ok(r == ERROR_INVALID_DATA, "Expected ERROR_INVALID_DATA, got %d\n", r);
7577     ok(!lstrcmpA(buf, "apple"), "Expected buf to be unchanged, got %s\n", buf);
7578     ok(size == 0, "Expected 0, got %d\n", size);
7579
7580     MsiCloseHandle(hrec);
7581
7582     r = MsiViewFetch(hview, &hrec);
7583     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7584
7585     MsiViewClose(hview);
7586     MsiCloseHandle(hview);
7587
7588     MsiDatabaseCommit(hdb);
7589     MsiCloseHandle(hdb);
7590
7591     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, MAX_PATH);
7592     hr = StgOpenStorage(name, NULL, STGM_DIRECT | STGM_READ |
7593                         STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
7594     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7595     ok(stg != NULL, "Expected non-NULL storage\n");
7596
7597     MultiByteToWideChar(CP_ACP, 0, "stgname", -1, name, MAX_PATH);
7598     hr = IStorage_OpenStorage(stg, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE,
7599                               NULL, 0, &inner);
7600     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7601     ok(inner != NULL, "Expected non-NULL storage\n");
7602
7603     MultiByteToWideChar(CP_ACP, 0, "storage.bin", -1, name, MAX_PATH);
7604     hr = IStorage_OpenStream(inner, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
7605     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7606     ok(stm != NULL, "Expected non-NULL stream\n");
7607
7608     hr = IStream_Read(stm, buf, MAX_PATH, &size);
7609     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
7610     ok(size == 8, "Expected 8, got %d\n", size);
7611     ok(!lstrcmpA(buf, "stgdata"), "Expected \"stgdata\", got \"%s\"\n", buf);
7612
7613     IStream_Release(stm);
7614     IStorage_Release(inner);
7615
7616     IStorage_Release(stg);
7617     DeleteFileA(msifile);
7618 }
7619
7620 static void test_dbtopackage(void)
7621 {
7622     MSIHANDLE hdb, hpkg;
7623     CHAR package[12], buf[MAX_PATH];
7624     DWORD size;
7625     UINT r;
7626
7627     /* create an empty database, transact mode */
7628     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7629     ok(r == ERROR_SUCCESS, "Failed to create database\n");
7630
7631     set_summary_info(hdb);
7632
7633     r = create_directory_table(hdb);
7634     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7635
7636     r = create_custom_action_table(hdb);
7637     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7638
7639     r = add_custom_action_entry(hdb, "'SetProp', 51, 'MYPROP', 'grape'");
7640     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7641
7642     sprintf(package, "#%u", hdb);
7643     r = MsiOpenPackageA(package, &hpkg);
7644     if (r == ERROR_INSTALL_PACKAGE_REJECTED)
7645     {
7646         skip("Not enough rights to perform tests\n");
7647         goto error;
7648     }
7649     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7650
7651     /* property is not set yet */
7652     size = MAX_PATH;
7653     lstrcpyA(buf, "kiwi");
7654     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7655     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7656     ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7657     ok(size == 0, "Expected 0, got %d\n", size);
7658
7659     /* run the custom action to set the property */
7660     r = MsiDoActionA(hpkg, "SetProp");
7661     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7662
7663     /* property is now set */
7664     size = MAX_PATH;
7665     lstrcpyA(buf, "kiwi");
7666     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7667     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7668     ok(!lstrcmpA(buf, "grape"), "Expected \"grape\", got \"%s\"\n", buf);
7669     ok(size == 5, "Expected 5, got %d\n", size);
7670
7671     MsiCloseHandle(hpkg);
7672
7673     /* reset the package */
7674     r = MsiOpenPackageA(package, &hpkg);
7675     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7676
7677     /* property is not set anymore */
7678     size = MAX_PATH;
7679     lstrcpyA(buf, "kiwi");
7680     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7681     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7682     todo_wine
7683     {
7684         ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7685         ok(size == 0, "Expected 0, got %d\n", size);
7686     }
7687
7688     MsiCloseHandle(hdb);
7689     MsiCloseHandle(hpkg);
7690
7691     /* create an empty database, direct mode */
7692     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATEDIRECT, &hdb);
7693     ok(r == ERROR_SUCCESS, "Failed to create database\n");
7694
7695     set_summary_info(hdb);
7696
7697     r = create_directory_table(hdb);
7698     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7699
7700     r = create_custom_action_table(hdb);
7701     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7702
7703     r = add_custom_action_entry(hdb, "'SetProp', 51, 'MYPROP', 'grape'");
7704     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7705
7706     sprintf(package, "#%u", hdb);
7707     r = MsiOpenPackageA(package, &hpkg);
7708     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7709
7710     /* property is not set yet */
7711     size = MAX_PATH;
7712     lstrcpyA(buf, "kiwi");
7713     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7714     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7715     ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7716     ok(size == 0, "Expected 0, got %d\n", size);
7717
7718     /* run the custom action to set the property */
7719     r = MsiDoActionA(hpkg, "SetProp");
7720     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7721
7722     /* property is now set */
7723     size = MAX_PATH;
7724     lstrcpyA(buf, "kiwi");
7725     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7726     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7727     ok(!lstrcmpA(buf, "grape"), "Expected \"grape\", got \"%s\"\n", buf);
7728     ok(size == 5, "Expected 5, got %d\n", size);
7729
7730     MsiCloseHandle(hpkg);
7731
7732     /* reset the package */
7733     r = MsiOpenPackageA(package, &hpkg);
7734     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7735
7736     /* property is not set anymore */
7737     size = MAX_PATH;
7738     lstrcpyA(buf, "kiwi");
7739     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7740     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7741     todo_wine
7742     {
7743         ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7744         ok(size == 0, "Expected 0, got %d\n", size);
7745     }
7746
7747     MsiCloseHandle(hpkg);
7748
7749 error:
7750     MsiCloseHandle(hdb);
7751     DeleteFileA(msifile);
7752 }
7753
7754 static void test_droptable(void)
7755 {
7756     MSIHANDLE hdb, hview, hrec;
7757     CHAR buf[MAX_PATH];
7758     LPCSTR query;
7759     DWORD size;
7760     UINT r;
7761
7762     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7763     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7764
7765     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
7766     r = run_query(hdb, 0, query);
7767     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7768
7769     query = "SELECT * FROM `One`";
7770     r = do_query(hdb, query, &hrec);
7771     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7772
7773     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7774     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7775     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7776     r = MsiViewExecute(hview, 0);
7777     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7778
7779     r = MsiViewFetch(hview, &hrec);
7780     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7781
7782     size = MAX_PATH;
7783     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7784     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7785     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7786
7787     MsiCloseHandle(hrec);
7788     MsiViewClose(hview);
7789     MsiCloseHandle(hview);
7790
7791     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7792     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7793     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7794     r = MsiViewExecute(hview, 0);
7795     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7796
7797     r = MsiViewFetch(hview, &hrec);
7798     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7799
7800     size = MAX_PATH;
7801     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7802     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7803     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7804
7805     r = MsiRecordGetInteger(hrec, 2);
7806     ok(r == 1, "Expected 1, got %d\n", r);
7807
7808     size = MAX_PATH;
7809     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7810     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7811     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7812
7813     MsiCloseHandle(hrec);
7814
7815     r = MsiViewFetch(hview, &hrec);
7816     ok(r == ERROR_NO_MORE_ITEMS,
7817        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7818
7819     MsiViewClose(hview);
7820     MsiCloseHandle(hview);
7821
7822     query = "DROP `One`";
7823     r = run_query(hdb, 0, query);
7824     ok(r == ERROR_BAD_QUERY_SYNTAX,
7825        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7826
7827     query = "DROP TABLE";
7828     r = run_query(hdb, 0, query);
7829     ok(r == ERROR_BAD_QUERY_SYNTAX,
7830        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7831
7832     query = "DROP TABLE `One`";
7833     hview = 0;
7834     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7835     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7836     r = MsiViewExecute(hview, 0);
7837     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7838
7839     r = MsiViewFetch(hview, &hrec);
7840     ok(r == ERROR_FUNCTION_FAILED,
7841        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
7842
7843     MsiViewClose(hview);
7844     MsiCloseHandle(hview);
7845
7846     query = "SELECT * FROM `IDontExist`";
7847     r = do_query(hdb, query, &hrec);
7848     ok(r == ERROR_BAD_QUERY_SYNTAX,
7849        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7850
7851     query = "SELECT * FROM `One`";
7852     r = do_query(hdb, query, &hrec);
7853     ok(r == ERROR_BAD_QUERY_SYNTAX,
7854        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7855
7856     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
7857     r = run_query(hdb, 0, query);
7858     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7859
7860     query = "DROP TABLE One";
7861     r = run_query(hdb, 0, query);
7862     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7863
7864     query = "SELECT * FROM `One`";
7865     r = do_query(hdb, query, &hrec);
7866     ok(r == ERROR_BAD_QUERY_SYNTAX,
7867        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7868
7869     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7870     r = do_query(hdb, query, &hrec);
7871     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7872
7873     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7874     r = do_query(hdb, query, &hrec);
7875     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7876
7877     query = "CREATE TABLE `One` ( `B` INT, `C` INT PRIMARY KEY `B` )";
7878     r = run_query(hdb, 0, query);
7879     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7880
7881     query = "SELECT * FROM `One`";
7882     r = do_query(hdb, query, &hrec);
7883     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7884
7885     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7886     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7887     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7888     r = MsiViewExecute(hview, 0);
7889     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7890
7891     r = MsiViewFetch(hview, &hrec);
7892     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7893
7894     size = MAX_PATH;
7895     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7896     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7897     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7898
7899     MsiCloseHandle(hrec);
7900     MsiViewClose(hview);
7901     MsiCloseHandle(hview);
7902
7903     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7904     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7905     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7906     r = MsiViewExecute(hview, 0);
7907     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7908
7909     r = MsiViewFetch(hview, &hrec);
7910     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7911
7912     size = MAX_PATH;
7913     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7914     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7915     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7916
7917     r = MsiRecordGetInteger(hrec, 2);
7918     ok(r == 1, "Expected 1, got %d\n", r);
7919
7920     size = MAX_PATH;
7921     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7922     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7923     ok(!lstrcmpA(buf, "B"), "Expected \"B\", got \"%s\"\n", buf);
7924
7925     MsiCloseHandle(hrec);
7926
7927     r = MsiViewFetch(hview, &hrec);
7928     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7929
7930     size = MAX_PATH;
7931     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7932     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7933     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7934
7935     r = MsiRecordGetInteger(hrec, 2);
7936     ok(r == 2, "Expected 2, got %d\n", r);
7937
7938     size = MAX_PATH;
7939     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7940     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7941     ok(!lstrcmpA(buf, "C"), "Expected \"C\", got \"%s\"\n", buf);
7942
7943     MsiCloseHandle(hrec);
7944
7945     r = MsiViewFetch(hview, &hrec);
7946     ok(r == ERROR_NO_MORE_ITEMS,
7947        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7948
7949     MsiViewClose(hview);
7950     MsiCloseHandle(hview);
7951
7952     query = "DROP TABLE One";
7953     r = run_query(hdb, 0, query);
7954     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7955
7956     query = "SELECT * FROM `One`";
7957     r = do_query(hdb, query, &hrec);
7958     ok(r == ERROR_BAD_QUERY_SYNTAX,
7959        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7960
7961     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7962     r = do_query(hdb, query, &hrec);
7963     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7964
7965     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7966     r = do_query(hdb, query, &hrec);
7967     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7968
7969     MsiCloseHandle(hdb);
7970     DeleteFileA(msifile);
7971 }
7972
7973 static void test_dbmerge(void)
7974 {
7975     static const WCHAR refdbW[] = {'r','e','f','d','b','.','m','s','i',0};
7976     MSIHANDLE hdb, href, hview, hrec;
7977     CHAR buf[MAX_PATH];
7978     LPCSTR query;
7979     DWORD size;
7980     UINT r;
7981
7982     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7983     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7984
7985     r = MsiOpenDatabaseW(refdbW, MSIDBOPEN_CREATE, &href);
7986     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7987
7988     /* hDatabase is invalid */
7989     r = MsiDatabaseMergeA(0, href, "MergeErrors");
7990     ok(r == ERROR_INVALID_HANDLE,
7991        "Expected ERROR_INVALID_HANDLE, got %d\n", r);
7992
7993     /* hDatabaseMerge is invalid */
7994     r = MsiDatabaseMergeA(hdb, 0, "MergeErrors");
7995     ok(r == ERROR_INVALID_HANDLE,
7996        "Expected ERROR_INVALID_HANDLE, got %d\n", r);
7997
7998     /* szTableName is NULL */
7999     r = MsiDatabaseMergeA(hdb, href, NULL);
8000     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8001
8002     /* szTableName is empty */
8003     r = MsiDatabaseMergeA(hdb, href, "");
8004     ok(r == ERROR_INVALID_TABLE, "Expected ERROR_INVALID_TABLE, got %d\n", r);
8005
8006     /* both DBs empty, szTableName is valid */
8007     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8008     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8009
8010     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
8011     r = run_query(hdb, 0, query);
8012     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8013
8014     query = "CREATE TABLE `One` ( `A` CHAR(72) PRIMARY KEY `A` )";
8015     r = run_query(href, 0, query);
8016     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8017
8018     /* column types don't match */
8019     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8020     ok(r == ERROR_DATATYPE_MISMATCH,
8021        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8022
8023     /* nothing in MergeErrors */
8024     query = "SELECT * FROM `MergeErrors`";
8025     r = do_query(hdb, query, &hrec);
8026     ok(r == ERROR_BAD_QUERY_SYNTAX,
8027        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8028
8029     query = "DROP TABLE `One`";
8030     r = run_query(hdb, 0, query);
8031     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8032
8033     query = "DROP TABLE `One`";
8034     r = run_query(href, 0, query);
8035     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8036
8037     query = "CREATE TABLE `One` ( "
8038         "`A` CHAR(72), "
8039         "`B` CHAR(56), "
8040         "`C` CHAR(64) LOCALIZABLE, "
8041         "`D` LONGCHAR, "
8042         "`E` CHAR(72) NOT NULL, "
8043         "`F` CHAR(56) NOT NULL, "
8044         "`G` CHAR(64) NOT NULL LOCALIZABLE, "
8045         "`H` LONGCHAR NOT NULL "
8046         "PRIMARY KEY `A` )";
8047     r = run_query(hdb, 0, query);
8048     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8049
8050     query = "CREATE TABLE `One` ( "
8051         "`A` CHAR(64), "
8052         "`B` CHAR(64), "
8053         "`C` CHAR(64), "
8054         "`D` CHAR(64), "
8055         "`E` CHAR(64) NOT NULL, "
8056         "`F` CHAR(64) NOT NULL, "
8057         "`G` CHAR(64) NOT NULL, "
8058         "`H` CHAR(64) NOT NULL "
8059         "PRIMARY KEY `A` )";
8060     r = run_query(href, 0, query);
8061     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8062
8063     /* column sting types don't match exactly */
8064     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8065     ok(r == ERROR_SUCCESS,
8066        "Expected ERROR_SUCCESS, got %d\n", r);
8067
8068     /* nothing in MergeErrors */
8069     query = "SELECT * FROM `MergeErrors`";
8070     r = do_query(hdb, query, &hrec);
8071     ok(r == ERROR_BAD_QUERY_SYNTAX,
8072        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8073
8074     query = "DROP TABLE `One`";
8075     r = run_query(hdb, 0, query);
8076     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8077
8078     query = "DROP TABLE `One`";
8079     r = run_query(href, 0, query);
8080     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8081
8082     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8083     r = run_query(hdb, 0, query);
8084     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8085
8086     query = "CREATE TABLE `One` ( `A` INT, `C` INT PRIMARY KEY `A` )";
8087     r = run_query(href, 0, query);
8088     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8089
8090     /* column names don't match */
8091     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8092     ok(r == ERROR_DATATYPE_MISMATCH,
8093        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8094
8095     /* nothing in MergeErrors */
8096     query = "SELECT * FROM `MergeErrors`";
8097     r = do_query(hdb, query, &hrec);
8098     ok(r == ERROR_BAD_QUERY_SYNTAX,
8099        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8100
8101     query = "DROP TABLE `One`";
8102     r = run_query(hdb, 0, query);
8103     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8104
8105     query = "DROP TABLE `One`";
8106     r = run_query(href, 0, query);
8107     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8108
8109     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8110     r = run_query(hdb, 0, query);
8111     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8112
8113     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `B` )";
8114     r = run_query(href, 0, query);
8115     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8116
8117     /* primary keys don't match */
8118     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8119     ok(r == ERROR_DATATYPE_MISMATCH,
8120        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8121
8122     /* nothing in MergeErrors */
8123     query = "SELECT * FROM `MergeErrors`";
8124     r = do_query(hdb, query, &hrec);
8125     ok(r == ERROR_BAD_QUERY_SYNTAX,
8126        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8127
8128     query = "DROP TABLE `One`";
8129     r = run_query(hdb, 0, query);
8130     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8131
8132     query = "DROP TABLE `One`";
8133     r = run_query(href, 0, query);
8134     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8135
8136     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8137     r = run_query(hdb, 0, query);
8138     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8139
8140     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A`, `B` )";
8141     r = run_query(href, 0, query);
8142     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8143
8144     /* number of primary keys doesn't match */
8145     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8146     ok(r == ERROR_DATATYPE_MISMATCH,
8147        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8148
8149     /* nothing in MergeErrors */
8150     query = "SELECT * FROM `MergeErrors`";
8151     r = do_query(hdb, query, &hrec);
8152     ok(r == ERROR_BAD_QUERY_SYNTAX,
8153        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8154
8155     query = "DROP TABLE `One`";
8156     r = run_query(hdb, 0, query);
8157     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8158
8159     query = "DROP TABLE `One`";
8160     r = run_query(href, 0, query);
8161     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8162
8163     query = "CREATE TABLE `One` ( `A` INT, `B` INT, `C` INT PRIMARY KEY `A` )";
8164     r = run_query(hdb, 0, query);
8165     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8166
8167     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8168     r = run_query(href, 0, query);
8169     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8170
8171     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 2 )";
8172     r = run_query(href, 0, query);
8173     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8174
8175     /* number of columns doesn't match */
8176     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8177     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8178
8179     query = "SELECT * FROM `One`";
8180     r = do_query(hdb, query, &hrec);
8181     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8182
8183     r = MsiRecordGetInteger(hrec, 1);
8184     ok(r == 1, "Expected 1, got %d\n", r);
8185
8186     r = MsiRecordGetInteger(hrec, 2);
8187     ok(r == 2, "Expected 2, got %d\n", r);
8188
8189     r = MsiRecordGetInteger(hrec, 3);
8190     ok(r == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", r);
8191
8192     MsiCloseHandle(hrec);
8193
8194     /* nothing in MergeErrors */
8195     query = "SELECT * FROM `MergeErrors`";
8196     r = do_query(hdb, query, &hrec);
8197     ok(r == ERROR_BAD_QUERY_SYNTAX,
8198        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8199
8200     query = "DROP TABLE `One`";
8201     r = run_query(hdb, 0, query);
8202     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8203
8204     query = "DROP TABLE `One`";
8205     r = run_query(href, 0, query);
8206     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8207
8208     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8209     r = run_query(hdb, 0, query);
8210     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8211
8212     query = "CREATE TABLE `One` ( `A` INT, `B` INT, `C` INT PRIMARY KEY `A` )";
8213     r = run_query(href, 0, query);
8214     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8215
8216     query = "INSERT INTO `One` ( `A`, `B`, `C` ) VALUES ( 1, 2, 3 )";
8217     r = run_query(href, 0, query);
8218     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8219
8220     /* number of columns doesn't match */
8221     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8222     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8223
8224     query = "SELECT * FROM `One`";
8225     r = do_query(hdb, query, &hrec);
8226     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8227
8228     r = MsiRecordGetInteger(hrec, 1);
8229     ok(r == 1, "Expected 1, got %d\n", r);
8230
8231     r = MsiRecordGetInteger(hrec, 2);
8232     ok(r == 2, "Expected 2, got %d\n", r);
8233
8234     r = MsiRecordGetInteger(hrec, 3);
8235     ok(r == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", r);
8236
8237     MsiCloseHandle(hrec);
8238
8239     /* nothing in MergeErrors */
8240     query = "SELECT * FROM `MergeErrors`";
8241     r = do_query(hdb, query, &hrec);
8242     ok(r == ERROR_BAD_QUERY_SYNTAX,
8243        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8244
8245     query = "DROP TABLE `One`";
8246     r = run_query(hdb, 0, query);
8247     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8248
8249     query = "DROP TABLE `One`";
8250     r = run_query(href, 0, query);
8251     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8252
8253     query = "CREATE TABLE `One` ( `A` INT, `B` INT 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 `One` ( `A`, `B` ) VALUES ( 1, 1 )";
8258     r = run_query(hdb, 0, query);
8259     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8260
8261     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 2 )";
8262     r = run_query(hdb, 0, query);
8263     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8264
8265     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8266     r = run_query(href, 0, query);
8267     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8268
8269     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 2 )";
8270     r = run_query(href, 0, query);
8271     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8272
8273     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 3 )";
8274     r = run_query(href, 0, query);
8275     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8276
8277     /* primary keys match, rows do not */
8278     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8279     ok(r == ERROR_FUNCTION_FAILED,
8280        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8281
8282     /* nothing in MergeErrors */
8283     query = "SELECT * FROM `MergeErrors`";
8284     r = do_query(hdb, query, &hrec);
8285     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8286
8287     size = MAX_PATH;
8288     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8289     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8290     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
8291
8292     r = MsiRecordGetInteger(hrec, 2);
8293     ok(r == 2, "Expected 2, got %d\n", r);
8294
8295     MsiCloseHandle(hrec);
8296
8297     r = MsiDatabaseOpenViewA(hdb, "SELECT * FROM `MergeErrors`", &hview);
8298     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8299
8300     r = MsiViewGetColumnInfo(hview, MSICOLINFO_NAMES, &hrec);
8301     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8302
8303     size = MAX_PATH;
8304     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8305     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8306     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
8307
8308     size = MAX_PATH;
8309     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8310     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8311     ok(!lstrcmpA(buf, "NumRowMergeConflicts"),
8312        "Expected \"NumRowMergeConflicts\", got \"%s\"\n", buf);
8313
8314     MsiCloseHandle(hrec);
8315
8316     r = MsiViewGetColumnInfo(hview, MSICOLINFO_TYPES, &hrec);
8317     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8318
8319     size = MAX_PATH;
8320     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8321     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8322     ok(!lstrcmpA(buf, "s255"), "Expected \"s255\", got \"%s\"\n", buf);
8323
8324     size = MAX_PATH;
8325     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8326     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8327     ok(!lstrcmpA(buf, "i2"), "Expected \"i2\", got \"%s\"\n", buf);
8328
8329     MsiCloseHandle(hrec);
8330     MsiViewClose(hview);
8331     MsiCloseHandle(hview);
8332
8333     query = "DROP TABLE `MergeErrors`";
8334     r = run_query(hdb, 0, query);
8335     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8336
8337     query = "DROP TABLE `One`";
8338     r = run_query(hdb, 0, query);
8339     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8340
8341     query = "DROP TABLE `One`";
8342     r = run_query(href, 0, query);
8343     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8344
8345     query = "CREATE TABLE `One` ( `A` INT, `B` CHAR(72) PRIMARY KEY `A` )";
8346     r = run_query(href, 0, query);
8347     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8348
8349     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'hi' )";
8350     r = run_query(href, 0, query);
8351     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8352
8353     /* table from merged database is not in target database */
8354     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8355     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8356
8357     query = "SELECT * FROM `One`";
8358     r = do_query(hdb, query, &hrec);
8359     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8360
8361     r = MsiRecordGetInteger(hrec, 1);
8362     ok(r == 1, "Expected 1, got %d\n", r);
8363
8364     size = MAX_PATH;
8365     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8366     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8367     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8368
8369     MsiCloseHandle(hrec);
8370
8371     /* nothing in MergeErrors */
8372     query = "SELECT * FROM `MergeErrors`";
8373     r = do_query(hdb, query, &hrec);
8374     ok(r == ERROR_BAD_QUERY_SYNTAX,
8375        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8376
8377     query = "DROP TABLE `One`";
8378     r = run_query(hdb, 0, query);
8379     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8380
8381     query = "DROP TABLE `One`";
8382     r = run_query(href, 0, query);
8383     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8384
8385     query = "CREATE TABLE `One` ( "
8386             "`A` CHAR(72), `B` INT PRIMARY KEY `A` )";
8387     r = run_query(hdb, 0, query);
8388     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8389
8390     query = "CREATE TABLE `One` ( "
8391             "`A` CHAR(72), `B` INT PRIMARY KEY `A` )";
8392     r = run_query(href, 0, query);
8393     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8394
8395     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 'hi', 1 )";
8396     r = run_query(href, 0, query);
8397     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8398
8399     /* primary key is string */
8400     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8401     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8402
8403     query = "SELECT * FROM `One`";
8404     r = do_query(hdb, query, &hrec);
8405     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8406
8407     size = MAX_PATH;
8408     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8409     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8410     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8411
8412     r = MsiRecordGetInteger(hrec, 2);
8413     ok(r == 1, "Expected 1, got %d\n", r);
8414
8415     MsiCloseHandle(hrec);
8416
8417     /* nothing in MergeErrors */
8418     query = "SELECT * FROM `MergeErrors`";
8419     r = do_query(hdb, query, &hrec);
8420     ok(r == ERROR_BAD_QUERY_SYNTAX,
8421        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8422
8423     create_file_data("codepage.idt", "\r\n\r\n850\t_ForceCodepage\r\n", 0);
8424
8425     GetCurrentDirectoryA(MAX_PATH, buf);
8426     r = MsiDatabaseImportA(hdb, buf, "codepage.idt");
8427     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8428
8429     query = "DROP TABLE `One`";
8430     r = run_query(hdb, 0, query);
8431     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8432
8433     query = "DROP TABLE `One`";
8434     r = run_query(href, 0, query);
8435     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8436
8437     query = "CREATE TABLE `One` ( "
8438             "`A` INT, `B` CHAR(72) LOCALIZABLE PRIMARY KEY `A` )";
8439     r = run_query(hdb, 0, query);
8440     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8441
8442     query = "CREATE TABLE `One` ( "
8443             "`A` INT, `B` CHAR(72) LOCALIZABLE PRIMARY KEY `A` )";
8444     r = run_query(href, 0, query);
8445     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8446
8447     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'hi' )";
8448     r = run_query(href, 0, query);
8449     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8450
8451     /* code page does not match */
8452     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8453     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8454
8455     query = "SELECT * FROM `One`";
8456     r = do_query(hdb, query, &hrec);
8457     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8458
8459     r = MsiRecordGetInteger(hrec, 1);
8460     ok(r == 1, "Expected 1, got %d\n", r);
8461
8462     size = MAX_PATH;
8463     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8464     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8465     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8466
8467     MsiCloseHandle(hrec);
8468
8469     /* nothing in MergeErrors */
8470     query = "SELECT * FROM `MergeErrors`";
8471     r = do_query(hdb, query, &hrec);
8472     ok(r == ERROR_BAD_QUERY_SYNTAX,
8473        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8474
8475     query = "DROP TABLE `One`";
8476     r = run_query(hdb, 0, query);
8477     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8478
8479     query = "DROP TABLE `One`";
8480     r = run_query(href, 0, query);
8481     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8482
8483     query = "CREATE TABLE `One` ( `A` INT, `B` OBJECT PRIMARY KEY `A` )";
8484     r = run_query(hdb, 0, query);
8485     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8486
8487     query = "CREATE TABLE `One` ( `A` INT, `B` OBJECT PRIMARY KEY `A` )";
8488     r = run_query(href, 0, query);
8489     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8490
8491     create_file("binary.dat");
8492     hrec = MsiCreateRecord(1);
8493     MsiRecordSetStreamA(hrec, 1, "binary.dat");
8494
8495     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, ? )";
8496     r = run_query(href, hrec, query);
8497     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8498
8499     MsiCloseHandle(hrec);
8500
8501     /* binary data to merge */
8502     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8503     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8504
8505     query = "SELECT * FROM `One`";
8506     r = do_query(hdb, query, &hrec);
8507     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8508
8509     r = MsiRecordGetInteger(hrec, 1);
8510     ok(r == 1, "Expected 1, got %d\n", r);
8511
8512     size = MAX_PATH;
8513     ZeroMemory(buf, MAX_PATH);
8514     r = MsiRecordReadStream(hrec, 2, buf, &size);
8515     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8516     ok(!lstrcmpA(buf, "binary.dat\n"),
8517        "Expected \"binary.dat\\n\", got \"%s\"\n", buf);
8518
8519     MsiCloseHandle(hrec);
8520
8521     /* nothing in MergeErrors */
8522     query = "SELECT * FROM `MergeErrors`";
8523     r = do_query(hdb, query, &hrec);
8524     ok(r == ERROR_BAD_QUERY_SYNTAX,
8525        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8526
8527     query = "DROP TABLE `One`";
8528     r = run_query(hdb, 0, query);
8529     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8530
8531     query = "DROP TABLE `One`";
8532     r = run_query(href, 0, query);
8533     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8534
8535     query = "CREATE TABLE `One` ( `A` INT, `B` CHAR(72) PRIMARY KEY `A` )";
8536     r = run_query(hdb, 0, query);
8537     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8538     r = run_query(href, 0, query);
8539     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8540
8541     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'foo' )";
8542     r = run_query(href, 0, query);
8543     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8544
8545     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 'bar' )";
8546     r = run_query(href, 0, query);
8547     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8548
8549     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8550     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8551
8552     query = "SELECT * FROM `One`";
8553     r = MsiDatabaseOpenViewA(hdb, query, &hview);
8554     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8555     r = MsiViewExecute(hview, 0);
8556     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8557
8558     r = MsiViewFetch(hview, &hrec);
8559     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8560
8561     r = MsiRecordGetInteger(hrec, 1);
8562     ok(r == 1, "Expected 1, got %d\n", r);
8563
8564     size = MAX_PATH;
8565     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8566     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8567     ok(!lstrcmpA(buf, "foo"), "Expected \"foo\", got \"%s\"\n", buf);
8568
8569     MsiCloseHandle(hrec);
8570
8571     r = MsiViewFetch(hview, &hrec);
8572     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8573
8574     r = MsiRecordGetInteger(hrec, 1);
8575     ok(r == 2, "Expected 2, got %d\n", r);
8576
8577     size = MAX_PATH;
8578     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8579     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8580     ok(!lstrcmpA(buf, "bar"), "Expected \"bar\", got \"%s\"\n", buf);
8581
8582     MsiCloseHandle(hrec);
8583
8584     r = MsiViewFetch(hview, &hrec);
8585     ok(r == ERROR_NO_MORE_ITEMS,
8586        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8587
8588     MsiViewClose(hview);
8589     MsiCloseHandle(hview);
8590
8591     MsiCloseHandle(hdb);
8592     MsiCloseHandle(href);
8593     DeleteFileA(msifile);
8594     DeleteFileW(refdbW);
8595     DeleteFileA("codepage.idt");
8596     DeleteFileA("binary.dat");
8597 }
8598
8599 static void test_select_with_tablenames(void)
8600 {
8601     MSIHANDLE hdb, view, rec;
8602     LPCSTR query;
8603     UINT r;
8604     int i;
8605
8606     int vals[4][2] = {
8607         {1,12},
8608         {4,12},
8609         {1,15},
8610         {4,15}};
8611
8612     hdb = create_db();
8613     ok(hdb, "failed to create db\n");
8614
8615     /* Build a pair of tables with the same column names, but unique data */
8616     query = "CREATE TABLE `T1` ( `A` SHORT, `B` SHORT PRIMARY KEY `A`)";
8617     r = run_query(hdb, 0, query);
8618     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8619
8620     query = "INSERT INTO `T1` ( `A`, `B` ) VALUES ( 1, 2 )";
8621     r = run_query(hdb, 0, query);
8622     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8623
8624     query = "INSERT INTO `T1` ( `A`, `B` ) VALUES ( 4, 5 )";
8625     r = run_query(hdb, 0, query);
8626     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8627
8628     query = "CREATE TABLE `T2` ( `A` SHORT, `B` SHORT PRIMARY KEY `A`)";
8629     r = run_query(hdb, 0, query);
8630     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8631
8632     query = "INSERT INTO `T2` ( `A`, `B` ) VALUES ( 11, 12 )";
8633     r = run_query(hdb, 0, query);
8634     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8635
8636     query = "INSERT INTO `T2` ( `A`, `B` ) VALUES ( 14, 15 )";
8637     r = run_query(hdb, 0, query);
8638     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8639
8640
8641     /* Test that selection based on prefixing the column with the table
8642      * actually selects the right data */
8643
8644     query = "SELECT T1.A, T2.B FROM T1,T2";
8645     r = MsiDatabaseOpenViewA(hdb, query, &view);
8646     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8647     r = MsiViewExecute(view, 0);
8648     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8649
8650     for (i = 0; i < 4; i++)
8651     {
8652         r = MsiViewFetch(view, &rec);
8653         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8654
8655         r = MsiRecordGetInteger(rec, 1);
8656         ok(r == vals[i][0], "Expected %d, got %d\n", vals[i][0], r);
8657
8658         r = MsiRecordGetInteger(rec, 2);
8659         ok(r == vals[i][1], "Expected %d, got %d\n", vals[i][1], r);
8660
8661         MsiCloseHandle(rec);
8662     }
8663
8664     r = MsiViewFetch(view, &rec);
8665     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8666
8667     MsiViewClose(view);
8668     MsiCloseHandle(view);
8669     MsiCloseHandle(hdb);
8670     DeleteFileA(msifile);
8671 }
8672
8673 static const UINT ordervals[6][3] =
8674 {
8675     { MSI_NULL_INTEGER, 12, 13 },
8676     { 1, 2, 3 },
8677     { 6, 4, 5 },
8678     { 8, 9, 7 },
8679     { 10, 11, MSI_NULL_INTEGER },
8680     { 14, MSI_NULL_INTEGER, 15 }
8681 };
8682
8683 static void test_insertorder(void)
8684 {
8685     MSIHANDLE hdb, view, rec;
8686     LPCSTR query;
8687     UINT r;
8688     int i;
8689
8690     hdb = create_db();
8691     ok(hdb, "failed to create db\n");
8692
8693     query = "CREATE TABLE `T` ( `A` SHORT, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
8694     r = run_query(hdb, 0, query);
8695     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8696
8697     query = "INSERT INTO `T` ( `A`, `B`, `C` ) VALUES ( 1, 2, 3 )";
8698     r = run_query(hdb, 0, query);
8699     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8700
8701     query = "INSERT INTO `T` ( `B`, `C`, `A` ) VALUES ( 4, 5, 6 )";
8702     r = run_query(hdb, 0, query);
8703     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8704
8705     query = "INSERT INTO `T` ( `C`, `A`, `B` ) VALUES ( 7, 8, 9 )";
8706     r = run_query(hdb, 0, query);
8707     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8708
8709     query = "INSERT INTO `T` ( `A`, `B` ) VALUES ( 10, 11 )";
8710     r = run_query(hdb, 0, query);
8711     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8712
8713     query = "INSERT INTO `T` ( `B`, `C` ) VALUES ( 12, 13 )";
8714     r = run_query(hdb, 0, query);
8715     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8716
8717     /* fails because the primary key already
8718      * has an MSI_NULL_INTEGER value set above
8719      */
8720     query = "INSERT INTO `T` ( `C` ) VALUES ( 14 )";
8721     r = run_query(hdb, 0, query);
8722     ok(r == ERROR_FUNCTION_FAILED,
8723        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8724
8725     /* replicate the error where primary key is set twice */
8726     query = "INSERT INTO `T` ( `A`, `C` ) VALUES ( 1, 14 )";
8727     r = run_query(hdb, 0, query);
8728     ok(r == ERROR_FUNCTION_FAILED,
8729        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8730
8731     query = "INSERT INTO `T` ( `A`, `C` ) VALUES ( 14, 15 )";
8732     r = run_query(hdb, 0, query);
8733     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8734
8735     query = "INSERT INTO `T` VALUES ( 16 )";
8736     r = run_query(hdb, 0, query);
8737     ok(r == ERROR_BAD_QUERY_SYNTAX,
8738        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8739
8740     query = "INSERT INTO `T` VALUES ( 17, 18 )";
8741     r = run_query(hdb, 0, query);
8742     ok(r == ERROR_BAD_QUERY_SYNTAX,
8743        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8744
8745     query = "INSERT INTO `T` VALUES ( 19, 20, 21 )";
8746     r = run_query(hdb, 0, query);
8747     ok(r == ERROR_BAD_QUERY_SYNTAX,
8748        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8749
8750     query = "SELECT * FROM `T`";
8751     r = MsiDatabaseOpenViewA(hdb, query, &view);
8752     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8753     r = MsiViewExecute(view, 0);
8754     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8755
8756     for (i = 0; i < 6; i++)
8757     {
8758         r = MsiViewFetch(view, &rec);
8759         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8760
8761         r = MsiRecordGetInteger(rec, 1);
8762         ok(r == ordervals[i][0], "Expected %d, got %d\n", ordervals[i][0], r);
8763
8764         r = MsiRecordGetInteger(rec, 2);
8765         ok(r == ordervals[i][1], "Expected %d, got %d\n", ordervals[i][1], r);
8766
8767         r = MsiRecordGetInteger(rec, 3);
8768         ok(r == ordervals[i][2], "Expected %d, got %d\n", ordervals[i][2], r);
8769
8770         MsiCloseHandle(rec);
8771     }
8772
8773     r = MsiViewFetch(view, &rec);
8774     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8775
8776     MsiViewClose(view);
8777     MsiCloseHandle(view);
8778
8779     query = "DELETE FROM `T` WHERE `A` IS NULL";
8780     r = run_query(hdb, 0, query);
8781     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8782
8783     query = "INSERT INTO `T` ( `B`, `C` ) VALUES ( 12, 13 ) TEMPORARY";
8784     r = run_query(hdb, 0, query);
8785     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8786
8787     query = "SELECT * FROM `T`";
8788     r = MsiDatabaseOpenViewA(hdb, query, &view);
8789     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8790     r = MsiViewExecute(view, 0);
8791     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8792
8793     for (i = 0; i < 6; i++)
8794     {
8795         r = MsiViewFetch(view, &rec);
8796         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8797
8798         r = MsiRecordGetInteger(rec, 1);
8799         ok(r == ordervals[i][0], "Expected %d, got %d\n", ordervals[i][0], r);
8800
8801         r = MsiRecordGetInteger(rec, 2);
8802         ok(r == ordervals[i][1], "Expected %d, got %d\n", ordervals[i][1], r);
8803
8804         r = MsiRecordGetInteger(rec, 3);
8805         ok(r == ordervals[i][2], "Expected %d, got %d\n", ordervals[i][2], r);
8806
8807         MsiCloseHandle(rec);
8808     }
8809
8810     r = MsiViewFetch(view, &rec);
8811     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8812
8813     MsiViewClose(view);
8814     MsiCloseHandle(view);
8815     MsiCloseHandle(hdb);
8816     DeleteFileA(msifile);
8817 }
8818
8819 static void test_columnorder(void)
8820 {
8821     MSIHANDLE hdb, view, rec;
8822     char buf[MAX_PATH];
8823     LPCSTR query;
8824     DWORD sz;
8825     UINT r;
8826
8827     hdb = create_db();
8828     ok(hdb, "failed to create db\n");
8829
8830     /* Each column is a slot:
8831      * ---------------------
8832      * | B | C | A | E | D |
8833      * ---------------------
8834      *
8835      * When a column is selected as a primary key,
8836      * the column occupying the nth primary key slot is swapped
8837      * with the current position of the primary key in question:
8838      *
8839      * set primary key `D`
8840      * ---------------------    ---------------------
8841      * | B | C | A | E | D | -> | D | C | A | E | B |
8842      * ---------------------    ---------------------
8843      *
8844      * set primary key `E`
8845      * ---------------------    ---------------------
8846      * | D | C | A | E | B | -> | D | E | A | C | B |
8847      * ---------------------    ---------------------
8848      */
8849
8850     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL, `C` SHORT NOT NULL, "
8851             "`A` CHAR(255), `E` INT, `D` CHAR(255) NOT NULL "
8852             "PRIMARY KEY `D`, `E`)";
8853     r = run_query(hdb, 0, query);
8854     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8855
8856     query = "SELECT * FROM `T`";
8857     r = MsiDatabaseOpenViewA(hdb, query, &view);
8858     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8859
8860     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
8861     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8862
8863     sz = MAX_PATH;
8864     lstrcpyA(buf, "kiwi");
8865     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8866     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8867     ok(!lstrcmpA("s255", buf), "Expected \"s255\", got \"%s\"\n", buf);
8868
8869     sz = MAX_PATH;
8870     lstrcpyA(buf, "kiwi");
8871     r = MsiRecordGetStringA(rec, 2, buf, &sz);
8872     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8873     ok(!lstrcmpA("I2", buf), "Expected \"I2\", got \"%s\"\n", buf);
8874
8875     sz = MAX_PATH;
8876     lstrcpyA(buf, "kiwi");
8877     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8878     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8879     ok(!lstrcmpA("S255", buf), "Expected \"S255\", got \"%s\"\n", buf);
8880
8881     sz = MAX_PATH;
8882     lstrcpyA(buf, "kiwi");
8883     r = MsiRecordGetStringA(rec, 4, buf, &sz);
8884     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8885     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
8886
8887     sz = MAX_PATH;
8888     lstrcpyA(buf, "kiwi");
8889     r = MsiRecordGetStringA(rec, 5, buf, &sz);
8890     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8891     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
8892
8893     MsiCloseHandle(rec);
8894
8895     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
8896     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8897
8898     sz = MAX_PATH;
8899     lstrcpyA(buf, "kiwi");
8900     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8901     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8902     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
8903
8904     sz = MAX_PATH;
8905     lstrcpyA(buf, "kiwi");
8906     r = MsiRecordGetStringA(rec, 2, buf, &sz);
8907     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8908     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
8909
8910     sz = MAX_PATH;
8911     lstrcpyA(buf, "kiwi");
8912     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8913     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8914     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
8915
8916     sz = MAX_PATH;
8917     lstrcpyA(buf, "kiwi");
8918     r = MsiRecordGetStringA(rec, 4, buf, &sz);
8919     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8920     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
8921
8922     sz = MAX_PATH;
8923     lstrcpyA(buf, "kiwi");
8924     r = MsiRecordGetStringA(rec, 5, buf, &sz);
8925     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8926     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
8927
8928     MsiCloseHandle(rec);
8929     MsiViewClose(view);
8930     MsiCloseHandle(view);
8931
8932     query = "INSERT INTO `T` ( `B`, `C`, `A`, `E`, `D` ) "
8933             "VALUES ( 1, 2, 'a', 3, 'bc' )";
8934     r = run_query(hdb, 0, query);
8935     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8936
8937     query = "SELECT * FROM `T`";
8938     r = do_query(hdb, query, &rec);
8939     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8940
8941     sz = MAX_PATH;
8942     lstrcpyA(buf, "kiwi");
8943     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8944     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8945     ok(!lstrcmpA("bc", buf), "Expected \"bc\", got \"%s\"\n", buf);
8946
8947     r = MsiRecordGetInteger(rec, 2);
8948     ok(r == 3, "Expected 3, got %d\n", r);
8949
8950     sz = MAX_PATH;
8951     lstrcpyA(buf, "kiwi");
8952     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8953     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8954     ok(!lstrcmpA("a", buf), "Expected \"a\", got \"%s\"\n", buf);
8955
8956     r = MsiRecordGetInteger(rec, 4);
8957     ok(r == 2, "Expected 2, got %d\n", r);
8958
8959     r = MsiRecordGetInteger(rec, 5);
8960     ok(r == 1, "Expected 1, got %d\n", r);
8961
8962     MsiCloseHandle(rec);
8963
8964     query = "SELECT * FROM `_Columns` WHERE `Table` = 'T'";
8965     r = MsiDatabaseOpenViewA(hdb, query, &view);
8966     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8967     r = MsiViewExecute(view, 0);
8968     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8969
8970     r = MsiViewFetch(view, &rec);
8971     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8972
8973     sz = MAX_PATH;
8974     lstrcpyA(buf, "kiwi");
8975     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8976     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8977     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8978
8979     r = MsiRecordGetInteger(rec, 2);
8980     ok(r == 1, "Expected 1, got %d\n", r);
8981
8982     sz = MAX_PATH;
8983     lstrcpyA(buf, "kiwi");
8984     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8985     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8986     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
8987
8988     MsiCloseHandle(rec);
8989
8990     r = MsiViewFetch(view, &rec);
8991     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8992
8993     sz = MAX_PATH;
8994     lstrcpyA(buf, "kiwi");
8995     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8996     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8997     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8998
8999     r = MsiRecordGetInteger(rec, 2);
9000     ok(r == 2, "Expected 2, got %d\n", r);
9001
9002     sz = MAX_PATH;
9003     lstrcpyA(buf, "kiwi");
9004     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9005     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9006     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
9007
9008     MsiCloseHandle(rec);
9009
9010     r = MsiViewFetch(view, &rec);
9011     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9012
9013     sz = MAX_PATH;
9014     lstrcpyA(buf, "kiwi");
9015     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9016     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9017     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9018
9019     r = MsiRecordGetInteger(rec, 2);
9020     ok(r == 3, "Expected 3, got %d\n", r);
9021
9022     sz = MAX_PATH;
9023     lstrcpyA(buf, "kiwi");
9024     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9025     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9026     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
9027
9028     MsiCloseHandle(rec);
9029
9030     r = MsiViewFetch(view, &rec);
9031     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9032
9033     sz = MAX_PATH;
9034     lstrcpyA(buf, "kiwi");
9035     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9036     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9037     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9038
9039     r = MsiRecordGetInteger(rec, 2);
9040     ok(r == 4, "Expected 4, got %d\n", r);
9041
9042     sz = MAX_PATH;
9043     lstrcpyA(buf, "kiwi");
9044     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9045     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9046     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
9047
9048     MsiCloseHandle(rec);
9049
9050     r = MsiViewFetch(view, &rec);
9051     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9052
9053     sz = MAX_PATH;
9054     lstrcpyA(buf, "kiwi");
9055     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9056     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9057     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9058
9059     r = MsiRecordGetInteger(rec, 2);
9060     ok(r == 5, "Expected 5, got %d\n", r);
9061
9062     sz = MAX_PATH;
9063     lstrcpyA(buf, "kiwi");
9064     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9065     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9066     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
9067
9068     MsiCloseHandle(rec);
9069
9070     r = MsiViewFetch(view, &rec);
9071     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
9072
9073     MsiViewClose(view);
9074     MsiCloseHandle(view);
9075
9076     query = "CREATE TABLE `Z` ( `B` SHORT NOT NULL, `C` SHORT NOT NULL, "
9077             "`A` CHAR(255), `E` INT, `D` CHAR(255) NOT NULL "
9078             "PRIMARY KEY `C`, `A`, `D`)";
9079     r = run_query(hdb, 0, query);
9080     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9081
9082     query = "SELECT * FROM `Z`";
9083     r = MsiDatabaseOpenViewA(hdb, query, &view);
9084     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9085
9086     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
9087     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9088
9089     sz = MAX_PATH;
9090     lstrcpyA(buf, "kiwi");
9091     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9092     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9093     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
9094
9095     sz = MAX_PATH;
9096     lstrcpyA(buf, "kiwi");
9097     r = MsiRecordGetStringA(rec, 2, buf, &sz);
9098     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9099     ok(!lstrcmpA("S255", buf), "Expected \"S255\", got \"%s\"\n", buf);
9100
9101     sz = MAX_PATH;
9102     lstrcpyA(buf, "kiwi");
9103     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9104     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9105     ok(!lstrcmpA("s255", buf), "Expected \"s255\", got \"%s\"\n", buf);
9106
9107     sz = MAX_PATH;
9108     lstrcpyA(buf, "kiwi");
9109     r = MsiRecordGetStringA(rec, 4, buf, &sz);
9110     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9111     ok(!lstrcmpA("I2", buf), "Expected \"I2\", got \"%s\"\n", buf);
9112
9113     sz = MAX_PATH;
9114     lstrcpyA(buf, "kiwi");
9115     r = MsiRecordGetStringA(rec, 5, buf, &sz);
9116     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9117     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
9118
9119     MsiCloseHandle(rec);
9120
9121     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
9122     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9123
9124     sz = MAX_PATH;
9125     lstrcpyA(buf, "kiwi");
9126     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9127     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9128     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
9129
9130     sz = MAX_PATH;
9131     lstrcpyA(buf, "kiwi");
9132     r = MsiRecordGetStringA(rec, 2, buf, &sz);
9133     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9134     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
9135
9136     sz = MAX_PATH;
9137     lstrcpyA(buf, "kiwi");
9138     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9139     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9140     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
9141
9142     sz = MAX_PATH;
9143     lstrcpyA(buf, "kiwi");
9144     r = MsiRecordGetStringA(rec, 4, buf, &sz);
9145     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9146     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
9147
9148     sz = MAX_PATH;
9149     lstrcpyA(buf, "kiwi");
9150     r = MsiRecordGetStringA(rec, 5, buf, &sz);
9151     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9152     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
9153
9154     MsiCloseHandle(rec);
9155     MsiViewClose(view);
9156     MsiCloseHandle(view);
9157
9158     query = "INSERT INTO `Z` ( `B`, `C`, `A`, `E`, `D` ) "
9159             "VALUES ( 1, 2, 'a', 3, 'bc' )";
9160     r = run_query(hdb, 0, query);
9161     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9162
9163     query = "SELECT * FROM `Z`";
9164     r = do_query(hdb, query, &rec);
9165     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9166
9167     r = MsiRecordGetInteger(rec, 1);
9168     ok(r == 2, "Expected 2, got %d\n", r);
9169
9170     sz = MAX_PATH;
9171     lstrcpyA(buf, "kiwi");
9172     r = MsiRecordGetStringA(rec, 2, buf, &sz);
9173     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9174     ok(!lstrcmpA("a", buf), "Expected \"a\", got \"%s\"\n", buf);
9175
9176     sz = MAX_PATH;
9177     lstrcpyA(buf, "kiwi");
9178     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9179     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9180     ok(!lstrcmpA("bc", buf), "Expected \"bc\", got \"%s\"\n", buf);
9181
9182     r = MsiRecordGetInteger(rec, 4);
9183     ok(r == 3, "Expected 3, got %d\n", r);
9184
9185     r = MsiRecordGetInteger(rec, 5);
9186     ok(r == 1, "Expected 1, got %d\n", r);
9187
9188     MsiCloseHandle(rec);
9189
9190     query = "SELECT * FROM `_Columns` WHERE `Table` = 'T'";
9191     r = MsiDatabaseOpenViewA(hdb, query, &view);
9192     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9193     r = MsiViewExecute(view, 0);
9194     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9195
9196     r = MsiViewFetch(view, &rec);
9197     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9198
9199     sz = MAX_PATH;
9200     lstrcpyA(buf, "kiwi");
9201     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9202     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9203     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9204
9205     r = MsiRecordGetInteger(rec, 2);
9206     ok(r == 1, "Expected 1, got %d\n", r);
9207
9208     sz = MAX_PATH;
9209     lstrcpyA(buf, "kiwi");
9210     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9211     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9212     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
9213
9214     MsiCloseHandle(rec);
9215
9216     r = MsiViewFetch(view, &rec);
9217     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9218
9219     sz = MAX_PATH;
9220     lstrcpyA(buf, "kiwi");
9221     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9222     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9223     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9224
9225     r = MsiRecordGetInteger(rec, 2);
9226     ok(r == 2, "Expected 2, got %d\n", r);
9227
9228     sz = MAX_PATH;
9229     lstrcpyA(buf, "kiwi");
9230     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9231     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9232     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
9233
9234     MsiCloseHandle(rec);
9235
9236     r = MsiViewFetch(view, &rec);
9237     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9238
9239     sz = MAX_PATH;
9240     lstrcpyA(buf, "kiwi");
9241     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9242     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9243     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9244
9245     r = MsiRecordGetInteger(rec, 2);
9246     ok(r == 3, "Expected 3, got %d\n", r);
9247
9248     sz = MAX_PATH;
9249     lstrcpyA(buf, "kiwi");
9250     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9251     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9252     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
9253
9254     MsiCloseHandle(rec);
9255
9256     r = MsiViewFetch(view, &rec);
9257     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9258
9259     sz = MAX_PATH;
9260     lstrcpyA(buf, "kiwi");
9261     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9262     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9263     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9264
9265     r = MsiRecordGetInteger(rec, 2);
9266     ok(r == 4, "Expected 4, got %d\n", r);
9267
9268     sz = MAX_PATH;
9269     lstrcpyA(buf, "kiwi");
9270     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9271     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9272     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
9273
9274     MsiCloseHandle(rec);
9275
9276     r = MsiViewFetch(view, &rec);
9277     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9278
9279     sz = MAX_PATH;
9280     lstrcpyA(buf, "kiwi");
9281     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9282     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9283     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9284
9285     r = MsiRecordGetInteger(rec, 2);
9286     ok(r == 5, "Expected 5, got %d\n", r);
9287
9288     sz = MAX_PATH;
9289     lstrcpyA(buf, "kiwi");
9290     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9291     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9292     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
9293
9294     MsiCloseHandle(rec);
9295
9296     r = MsiViewFetch(view, &rec);
9297     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
9298
9299     MsiViewClose(view);
9300     MsiCloseHandle(view);
9301
9302     MsiCloseHandle(hdb);
9303     DeleteFileA(msifile);
9304 }
9305
9306 static void test_createtable(void)
9307 {
9308     MSIHANDLE hdb, htab = 0, hrec = 0;
9309     LPCSTR query;
9310     UINT res;
9311     DWORD size;
9312     char buffer[0x20];
9313
9314     hdb = create_db();
9315     ok(hdb, "failed to create db\n");
9316
9317     query = "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL PRIMARY KEY `foo`)";
9318     res = MsiDatabaseOpenViewA( hdb, query, &htab );
9319     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9320     if(res == ERROR_SUCCESS )
9321     {
9322         res = MsiViewExecute( htab, hrec );
9323         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9324
9325         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
9326         todo_wine ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9327
9328         size = sizeof(buffer);
9329         res = MsiRecordGetStringA(hrec, 1, buffer, &size );
9330         todo_wine ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9331         MsiCloseHandle( hrec );
9332
9333         res = MsiViewClose( htab );
9334         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9335
9336         res = MsiCloseHandle( htab );
9337         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9338     }
9339
9340     query = "CREATE TABLE `a` (`b` INT PRIMARY KEY `b`)";
9341     res = MsiDatabaseOpenViewA( hdb, query, &htab );
9342     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9343     if(res == ERROR_SUCCESS )
9344     {
9345         res = MsiViewExecute( htab, 0 );
9346         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9347
9348         res = MsiViewClose( htab );
9349         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9350
9351         res = MsiCloseHandle( htab );
9352         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9353
9354         query = "SELECT * FROM `a`";
9355         res = MsiDatabaseOpenViewA( hdb, query, &htab );
9356         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9357
9358         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
9359         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9360
9361         buffer[0] = 0;
9362         size = sizeof(buffer);
9363         res = MsiRecordGetStringA(hrec, 1, buffer, &size );
9364         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9365         ok(!strcmp(buffer,"b"), "b != %s\n", buffer);
9366         MsiCloseHandle( hrec );
9367
9368         res = MsiViewClose( htab );
9369         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9370
9371         res = MsiCloseHandle( htab );
9372         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9373
9374         res = MsiDatabaseCommit(hdb);
9375         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9376
9377         res = MsiCloseHandle(hdb);
9378         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9379
9380         res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
9381         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9382
9383         query = "SELECT * FROM `a`";
9384         res = MsiDatabaseOpenViewA( hdb, query, &htab );
9385         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9386
9387         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
9388         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9389
9390         buffer[0] = 0;
9391         size = sizeof(buffer);
9392         res = MsiRecordGetStringA(hrec, 1, buffer, &size );
9393         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9394         ok(!strcmp(buffer,"b"), "b != %s\n", buffer);
9395
9396         res = MsiCloseHandle( hrec );
9397         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9398
9399         res = MsiViewClose( htab );
9400         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9401
9402         res = MsiCloseHandle( htab );
9403         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9404     }
9405
9406     res = MsiDatabaseCommit(hdb);
9407     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9408
9409     res = MsiCloseHandle(hdb);
9410     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9411
9412     DeleteFileA(msifile);
9413 }
9414
9415 static void test_embedded_nulls(void)
9416 {
9417     static const char control_table[] =
9418         "Dialog\tText\n"
9419         "s72\tL0\n"
9420         "Control\tDialog\n"
9421         "LicenseAgreementDlg\ttext\x11\x19text\0text";
9422     UINT r, sz;
9423     MSIHANDLE hdb, hrec;
9424     char buffer[32];
9425
9426     r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
9427     ok( r == ERROR_SUCCESS, "failed to open database %u\n", r );
9428
9429     GetCurrentDirectoryA( MAX_PATH, CURR_DIR );
9430     write_file( "temp_file", control_table, sizeof(control_table) );
9431     r = MsiDatabaseImportA( hdb, CURR_DIR, "temp_file" );
9432     ok( r == ERROR_SUCCESS, "failed to import table %u\n", r );
9433     DeleteFileA( "temp_file" );
9434
9435     r = do_query( hdb, "SELECT `Text` FROM `Control` WHERE `Dialog` = 'LicenseAgreementDlg'", &hrec );
9436     ok( r == ERROR_SUCCESS, "query failed %u\n", r );
9437
9438     buffer[0] = 0;
9439     sz = sizeof(buffer);
9440     r = MsiRecordGetStringA( hrec, 1, buffer, &sz );
9441     ok( r == ERROR_SUCCESS, "failed to get string %u\n", r );
9442     ok( !memcmp( "text\r\ntext\ntext", buffer, sizeof("text\r\ntext\ntext") - 1 ), "wrong buffer contents \"%s\"\n", buffer );
9443
9444     MsiCloseHandle( hrec );
9445     MsiCloseHandle( hdb );
9446     DeleteFileA( msifile );
9447 }
9448
9449 static void test_select_column_names(void)
9450 {
9451     MSIHANDLE hdb = 0, rec, rec2, view;
9452     char buffer[32];
9453     UINT r, size;
9454
9455     DeleteFileA(msifile);
9456
9457     r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
9458     ok( r == ERROR_SUCCESS , "failed to open database: %u\n", r );
9459
9460     r = try_query( hdb, "CREATE TABLE `t` (`a` CHAR NOT NULL, `b` CHAR PRIMARY KEY `a`)");
9461     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9462
9463     r = try_query( hdb, "SELECT `t`.`b` FROM `t` WHERE `t`.`b` = `x`" );
9464     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9465
9466     r = try_query( hdb, "SELECT '', `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
9467     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9468
9469     r = try_query( hdb, "SELECT *, `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
9470     todo_wine ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
9471
9472     r = try_query( hdb, "SELECT 'b', `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
9473     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9474
9475     r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x'" );
9476     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9477
9478     r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x' ORDER BY `b`" );
9479     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9480
9481     r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x' ORDER BY 'b'" );
9482     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9483
9484     r = try_query( hdb, "SELECT 't'.'b' FROM `t` WHERE `t`.`b` = 'x'" );
9485     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9486
9487     r = try_query( hdb, "SELECT 'b' FROM `t` WHERE `t`.`b` = 'x'" );
9488     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9489
9490     r = try_query( hdb, "INSERT INTO `t` ( `a`, `b` ) VALUES( '1', '2' )" );
9491     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9492
9493     r = try_query( hdb, "INSERT INTO `t` ( `a`, `b` ) VALUES( '3', '4' )" );
9494     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9495
9496     r = MsiDatabaseOpenViewA( hdb, "SELECT '' FROM `t`", &view );
9497     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9498
9499     r = MsiViewExecute( view, 0 );
9500     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9501
9502     r = MsiViewFetch( view, &rec );
9503     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9504     r = MsiRecordGetFieldCount( rec );
9505     ok( r == 1, "got %u\n",  r );
9506     r = MsiViewGetColumnInfo( view, MSICOLINFO_NAMES, &rec2 );
9507     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9508     r = MsiRecordGetFieldCount( rec2 );
9509     ok( r == 1, "got %u\n",  r );
9510     size = sizeof(buffer);
9511     memset( buffer, 0x55, sizeof(buffer) );
9512     r = MsiRecordGetStringA( rec2, 1, buffer, &size );
9513     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9514     ok( !buffer[0], "got \"%s\"\n", buffer );
9515     MsiCloseHandle( rec2 );
9516     r = MsiViewGetColumnInfo( view, MSICOLINFO_TYPES, &rec2 );
9517     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9518     r = MsiRecordGetFieldCount( rec2 );
9519     ok( r == 1, "got %u\n",  r );
9520     size = sizeof(buffer);
9521     memset( buffer, 0x55, sizeof(buffer) );
9522     r = MsiRecordGetStringA( rec2, 1, buffer, &size );
9523     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9524     ok( !lstrcmpA( buffer, "f0" ), "got \"%s\"\n", buffer );
9525     MsiCloseHandle( rec2 );
9526
9527     size = sizeof(buffer);
9528     memset( buffer, 0x55, sizeof(buffer) );
9529     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9530     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9531     ok( !buffer[0], "got \"%s\"\n", buffer );
9532     MsiCloseHandle( rec );
9533
9534     r = MsiViewFetch( view, &rec );
9535     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9536     size = sizeof(buffer);
9537     memset( buffer, 0x55, sizeof(buffer) );
9538     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9539     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9540     ok( !buffer[0], "got \"%s\"\n", buffer );
9541     MsiCloseHandle( rec );
9542
9543     r = MsiViewFetch( view, &rec );
9544     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9545     MsiCloseHandle( rec );
9546
9547     MsiViewClose( view );
9548     MsiCloseHandle( view );
9549
9550     r = MsiDatabaseOpenViewA( hdb, "SELECT `a`, '' FROM `t`", &view );
9551     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9552
9553     r = MsiViewExecute( view, 0 );
9554     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9555
9556     r = MsiViewFetch( view, &rec );
9557     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9558     r = MsiRecordGetFieldCount( rec );
9559     ok( r == 2, "got %u\n",  r );
9560     size = sizeof(buffer);
9561     memset( buffer, 0x55, sizeof(buffer) );
9562     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9563     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9564     ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
9565     MsiCloseHandle( rec );
9566
9567     r = MsiViewFetch( view, &rec );
9568     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9569     size = sizeof(buffer);
9570     memset( buffer, 0x55, sizeof(buffer) );
9571     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9572     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9573     ok( !buffer[0], "got \"%s\"\n", buffer );
9574     MsiCloseHandle( rec );
9575
9576     r = MsiViewFetch( view, &rec );
9577     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9578     MsiCloseHandle( rec );
9579
9580     MsiViewClose( view );
9581     MsiCloseHandle( view );
9582
9583     r = MsiDatabaseOpenViewA( hdb, "SELECT '', `a` FROM `t`", &view );
9584     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9585
9586     r = MsiViewExecute( view, 0 );
9587     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9588
9589     r = MsiViewFetch( view, &rec );
9590     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9591     r = MsiRecordGetFieldCount( rec );
9592     ok( r == 2, "got %u\n",  r );
9593     size = sizeof(buffer);
9594     memset( buffer, 0x55, sizeof(buffer) );
9595     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9596     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9597     ok( !buffer[0], "got \"%s\"\n", buffer );
9598     size = sizeof(buffer);
9599     memset( buffer, 0x55, sizeof(buffer) );
9600     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9601     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9602     ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
9603     MsiCloseHandle( rec );
9604
9605     r = MsiViewFetch( view, &rec );
9606     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9607     size = sizeof(buffer);
9608     memset( buffer, 0x55, sizeof(buffer) );
9609     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9610     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9611     ok( !buffer[0], "got \"%s\"\n", buffer );
9612     size = sizeof(buffer);
9613     memset( buffer, 0x55, sizeof(buffer) );
9614     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9615     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9616     ok( !lstrcmpA( buffer, "3" ), "got \"%s\"\n", buffer );
9617     MsiCloseHandle( rec );
9618
9619     r = MsiViewFetch( view, &rec );
9620     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9621     MsiCloseHandle( rec );
9622
9623     MsiViewClose( view );
9624     MsiCloseHandle( view );
9625
9626     r = MsiDatabaseOpenViewA( hdb, "SELECT `a`, '', `b` FROM `t`", &view );
9627     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9628
9629     r = MsiViewExecute( view, 0 );
9630     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9631
9632     r = MsiViewFetch( view, &rec );
9633     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9634     r = MsiRecordGetFieldCount( rec );
9635     ok( r == 3, "got %u\n",  r );
9636     size = sizeof(buffer);
9637     memset( buffer, 0x55, sizeof(buffer) );
9638     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9639     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9640     ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
9641     size = sizeof(buffer);
9642     memset( buffer, 0x55, sizeof(buffer) );
9643     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9644     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9645     ok( !buffer[0], "got \"%s\"\n", buffer );
9646     size = sizeof(buffer);
9647     memset( buffer, 0x55, sizeof(buffer) );
9648     r = MsiRecordGetStringA( rec, 3, buffer, &size );
9649     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9650     ok( !lstrcmpA( buffer, "2" ), "got \"%s\"\n", buffer );
9651     MsiCloseHandle( rec );
9652
9653     r = MsiViewFetch( view, &rec );
9654     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9655     size = sizeof(buffer);
9656     memset( buffer, 0x55, sizeof(buffer) );
9657     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9658     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9659     ok( !lstrcmpA( buffer, "3" ), "got \"%s\"\n", buffer );
9660     size = sizeof(buffer);
9661     memset( buffer, 0x55, sizeof(buffer) );
9662     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9663     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9664     ok( !buffer[0], "got \"%s\"\n", buffer );
9665     size = sizeof(buffer);
9666     memset( buffer, 0x55, sizeof(buffer) );
9667     r = MsiRecordGetStringA( rec, 3, buffer, &size );
9668     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9669     ok( !lstrcmpA( buffer, "4" ), "got \"%s\"\n", buffer );
9670     MsiCloseHandle( rec );
9671
9672     r = MsiViewFetch( view, &rec );
9673     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9674     MsiCloseHandle( rec );
9675
9676     MsiViewClose( view );
9677     MsiCloseHandle( view );
9678
9679     r = try_query( hdb, "SELECT '' FROM `t` WHERE `t`.`b` = 'x'" );
9680     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9681
9682     r = try_query( hdb, "SELECT `` FROM `t` WHERE `t`.`b` = 'x'" );
9683     todo_wine ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9684
9685     r = try_query( hdb, "SELECT `b` FROM 't' WHERE `t`.`b` = 'x'" );
9686     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9687
9688     r = try_query( hdb, "SELECT `b` FROM `t` WHERE 'b' = 'x'" );
9689     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9690
9691     r = try_query( hdb, "SELECT `t`.`b`, `` FROM `t` WHERE `t`.`b` = 'x'" );
9692     todo_wine ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9693
9694     r = MsiCloseHandle( hdb );
9695     ok(r == ERROR_SUCCESS , "failed to close database: %u\n", r);
9696 }
9697
9698 START_TEST(db)
9699 {
9700     test_msidatabase();
9701     test_msiinsert();
9702     test_msidecomposedesc();
9703     test_msibadqueries();
9704     test_viewmodify();
9705     test_viewgetcolumninfo();
9706     test_getcolinfo();
9707     test_msiexport();
9708     test_longstrings();
9709     test_streamtable();
9710     test_binary();
9711     test_where_not_in_selected();
9712     test_where();
9713     test_msiimport();
9714     test_binary_import();
9715     test_markers();
9716     test_handle_limit();
9717     test_try_transform();
9718     test_join();
9719     test_temporary_table();
9720     test_alter();
9721     test_integers();
9722     test_update();
9723     test_special_tables();
9724     test_tables_order();
9725     test_rows_order();
9726     test_select_markers();
9727     test_viewmodify_update();
9728     test_viewmodify_assign();
9729     test_stringtable();
9730     test_viewmodify_delete();
9731     test_defaultdatabase();
9732     test_order();
9733     test_viewmodify_delete_temporary();
9734     test_deleterow();
9735     test_quotes();
9736     test_carriagereturn();
9737     test_noquotes();
9738     test_forcecodepage();
9739     test_viewmodify_refresh();
9740     test_where_viewmodify();
9741     test_storages_table();
9742     test_dbtopackage();
9743     test_droptable();
9744     test_dbmerge();
9745     test_select_with_tablenames();
9746     test_insertorder();
9747     test_columnorder();
9748     test_suminfo_import();
9749     test_createtable();
9750     test_collation();
9751     test_embedded_nulls();
9752     test_select_column_names();
9753 }