rostests/winetests/msi/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             "  `Charvalue` CHAR, "
1296             "  `Localizablevalue` CHAR LOCALIZABLE "
1297             "  PRIMARY KEY `Property`)" );
1298     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1299
1300     /* check the column types */
1301     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_TYPES );
1302     ok( rec, "failed to get column info record\n" );
1303
1304     ok( check_record( rec, 1, "S255"), "wrong record type\n");
1305     ok( check_record( rec, 2, "S1"), "wrong record type\n");
1306     ok( check_record( rec, 3, "I2"), "wrong record type\n");
1307     ok( check_record( rec, 4, "I2"), "wrong record type\n");
1308     ok( check_record( rec, 5, "I2"), "wrong record type\n");
1309     ok( check_record( rec, 6, "I4"), "wrong record type\n");
1310     ok( check_record( rec, 7, "S0"), "wrong record type\n");
1311     ok( check_record( rec, 8, "S0"), "wrong record type\n");
1312     ok( check_record( rec, 9, "L0"), "wrong record type\n");
1313
1314     MsiCloseHandle( rec );
1315
1316     /* check the type in _Columns */
1317     ok( 0x3dff == get_columns_table_type(hdb, "Properties", 1 ), "_columns table wrong\n");
1318     ok( 0x1d01 == get_columns_table_type(hdb, "Properties", 2 ), "_columns table wrong\n");
1319     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 3 ), "_columns table wrong\n");
1320     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 4 ), "_columns table wrong\n");
1321     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 5 ), "_columns table wrong\n");
1322     ok( 0x1104 == get_columns_table_type(hdb, "Properties", 6 ), "_columns table wrong\n");
1323     ok( 0x1d00 == get_columns_table_type(hdb, "Properties", 7 ), "_columns table wrong\n");
1324     ok( 0x1d00 == get_columns_table_type(hdb, "Properties", 8 ), "_columns table wrong\n");
1325     ok( 0x1f00 == get_columns_table_type(hdb, "Properties", 9 ), "_columns table wrong\n");
1326
1327     /* now try the names */
1328     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_NAMES );
1329     ok( rec, "failed to get column info record\n" );
1330
1331     ok( check_record( rec, 1, "Property"), "wrong record type\n");
1332     ok( check_record( rec, 2, "Value"), "wrong record type\n");
1333     ok( check_record( rec, 3, "Intvalue"), "wrong record type\n");
1334     ok( check_record( rec, 4, "Integervalue"), "wrong record type\n");
1335     ok( check_record( rec, 5, "Shortvalue"), "wrong record type\n");
1336     ok( check_record( rec, 6, "Longvalue"), "wrong record type\n");
1337     ok( check_record( rec, 7, "Longcharvalue"), "wrong record type\n");
1338     ok( check_record( rec, 8, "Charvalue"), "wrong record type\n");
1339     ok( check_record( rec, 9, "Localizablevalue"), "wrong record type\n");
1340
1341     MsiCloseHandle( rec );
1342
1343     r = run_query( hdb, 0,
1344             "CREATE TABLE `Binary` "
1345             "( `Name` CHAR(255), `Data` OBJECT  PRIMARY KEY `Name`)" );
1346     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1347
1348     /* check the column types */
1349     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_TYPES );
1350     ok( rec, "failed to get column info record\n" );
1351
1352     ok( check_record( rec, 1, "S255"), "wrong record type\n");
1353     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1354
1355     MsiCloseHandle( rec );
1356
1357     /* check the type in _Columns */
1358     ok( 0x3dff == get_columns_table_type(hdb, "Binary", 1 ), "_columns table wrong\n");
1359     ok( 0x1900 == get_columns_table_type(hdb, "Binary", 2 ), "_columns table wrong\n");
1360
1361     /* now try the names */
1362     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_NAMES );
1363     ok( rec, "failed to get column info record\n" );
1364
1365     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1366     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1367     MsiCloseHandle( rec );
1368
1369     r = run_query( hdb, 0,
1370             "CREATE TABLE `UIText` "
1371             "( `Key` CHAR(72) NOT NULL, `Text` CHAR(255) LOCALIZABLE PRIMARY KEY `Key`)" );
1372     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1373
1374     ok( 0x2d48 == get_columns_table_type(hdb, "UIText", 1 ), "_columns table wrong\n");
1375     ok( 0x1fff == get_columns_table_type(hdb, "UIText", 2 ), "_columns table wrong\n");
1376
1377     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_NAMES );
1378     ok( rec, "failed to get column info record\n" );
1379     ok( check_record( rec, 1, "Key"), "wrong record type\n");
1380     ok( check_record( rec, 2, "Text"), "wrong record type\n");
1381     MsiCloseHandle( rec );
1382
1383     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_TYPES );
1384     ok( rec, "failed to get column info record\n" );
1385     ok( check_record( rec, 1, "s72"), "wrong record type\n");
1386     ok( check_record( rec, 2, "L255"), "wrong record type\n");
1387     MsiCloseHandle( rec );
1388
1389     MsiCloseHandle( hdb );
1390 }
1391
1392 static void test_msiexport(void)
1393 {
1394     MSIHANDLE hdb = 0, hview = 0;
1395     UINT r;
1396     const char *query;
1397     char path[MAX_PATH];
1398     const char file[] = "phone.txt";
1399     HANDLE handle;
1400     char buffer[0x100];
1401     DWORD length;
1402     const char expected[] =
1403         "id\tname\tnumber\r\n"
1404         "I2\tS32\tS32\r\n"
1405         "phone\tid\r\n"
1406         "1\tAbe\t8675309\r\n";
1407
1408     DeleteFileW(msifileW);
1409
1410     /* just MsiOpenDatabase should not create a file */
1411     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
1412     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1413
1414     /* create a table */
1415     query = "CREATE TABLE `phone` ( "
1416             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
1417             "PRIMARY KEY `id`)";
1418     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1419     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1420     r = MsiViewExecute(hview, 0);
1421     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1422     r = MsiViewClose(hview);
1423     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1424     r = MsiCloseHandle(hview);
1425     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1426
1427     /* insert a value into it */
1428     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
1429         "VALUES('1', 'Abe', '8675309')";
1430     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1431     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1432     r = MsiViewExecute(hview, 0);
1433     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1434     r = MsiViewClose(hview);
1435     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1436     r = MsiCloseHandle(hview);
1437     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1438
1439     GetCurrentDirectoryA(MAX_PATH, path);
1440
1441     r = MsiDatabaseExportA(hdb, "phone", path, file);
1442     ok(r == ERROR_SUCCESS, "MsiDatabaseExport failed\n");
1443
1444     MsiCloseHandle(hdb);
1445
1446     lstrcatA(path, "\\");
1447     lstrcatA(path, file);
1448
1449     /* check the data that was written */
1450     length = 0;
1451     memset(buffer, 0, sizeof buffer);
1452     handle = CreateFileA(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
1453     if (handle != INVALID_HANDLE_VALUE)
1454     {
1455         ReadFile(handle, buffer, sizeof buffer, &length, NULL);
1456         CloseHandle(handle);
1457         DeleteFileA(path);
1458     }
1459     else
1460         ok(0, "failed to open file %s\n", path);
1461
1462     ok( length == strlen(expected), "length of data wrong\n");
1463     ok( !lstrcmpA(buffer, expected), "data doesn't match\n");
1464     DeleteFileA(msifile);
1465 }
1466
1467 static void test_longstrings(void)
1468 {
1469     const char insert_query[] =
1470         "INSERT INTO `strings` ( `id`, `val` ) VALUES('1', 'Z')";
1471     char *str;
1472     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
1473     DWORD len;
1474     UINT r;
1475     const DWORD STRING_LENGTH = 0x10005;
1476
1477     DeleteFileW(msifileW);
1478     /* just MsiOpenDatabase should not create a file */
1479     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
1480     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1481
1482     /* create a table */
1483     r = try_query( hdb,
1484         "CREATE TABLE `strings` ( `id` INT, `val` CHAR(0) PRIMARY KEY `id`)");
1485     ok(r == ERROR_SUCCESS, "query failed\n");
1486
1487     /* try to insert a very long string */
1488     str = HeapAlloc(GetProcessHeap(), 0, STRING_LENGTH+sizeof insert_query);
1489     len = strchr(insert_query, 'Z') - insert_query;
1490     strcpy(str, insert_query);
1491     memset(str+len, 'Z', STRING_LENGTH);
1492     strcpy(str+len+STRING_LENGTH, insert_query+len+1);
1493     r = try_query( hdb, str );
1494     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1495
1496     HeapFree(GetProcessHeap(), 0, str);
1497
1498     r = MsiDatabaseCommit(hdb);
1499     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
1500     MsiCloseHandle(hdb);
1501
1502     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
1503     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1504
1505     r = MsiDatabaseOpenViewA(hdb, "select * from `strings` where `id` = 1", &hview);
1506     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1507
1508     r = MsiViewExecute(hview, 0);
1509     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1510
1511     r = MsiViewFetch(hview, &hrec);
1512     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1513
1514     MsiViewClose(hview);
1515     MsiCloseHandle(hview);
1516
1517     r = MsiRecordGetStringA(hrec, 2, NULL, &len);
1518     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1519     ok(len == STRING_LENGTH, "string length wrong\n");
1520
1521     MsiCloseHandle(hrec);
1522     MsiCloseHandle(hdb);
1523     DeleteFileA(msifile);
1524 }
1525
1526 static void create_file_data(LPCSTR name, LPCSTR data, DWORD size)
1527 {
1528     HANDLE file;
1529     DWORD written;
1530
1531     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
1532     if (file == INVALID_HANDLE_VALUE)
1533         return;
1534
1535     WriteFile(file, data, strlen(data), &written, NULL);
1536     WriteFile(file, "\n", strlen("\n"), &written, NULL);
1537
1538     if (size)
1539     {
1540         SetFilePointer(file, size, NULL, FILE_BEGIN);
1541         SetEndOfFile(file);
1542     }
1543
1544     CloseHandle(file);
1545 }
1546
1547 #define create_file(name) create_file_data(name, name, 0)
1548
1549 static void test_streamtable(void)
1550 {
1551     MSIHANDLE hdb = 0, rec, view, hsi;
1552     char file[MAX_PATH];
1553     char buf[MAX_PATH];
1554     DWORD size;
1555     UINT r;
1556
1557     hdb = create_db();
1558     ok( hdb, "failed to create db\n");
1559
1560     r = run_query( hdb, 0,
1561             "CREATE TABLE `Properties` "
1562             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
1563     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1564
1565     r = run_query( hdb, 0,
1566             "INSERT INTO `Properties` "
1567             "( `Value`, `Property` ) VALUES ( 'Prop', 'value' )" );
1568     ok( r == ERROR_SUCCESS, "Failed to add to table\n" );
1569
1570     r = MsiDatabaseCommit( hdb );
1571     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1572
1573     MsiCloseHandle( hdb );
1574
1575     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
1576     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1577
1578     /* check the column types */
1579     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_TYPES );
1580     ok( rec, "failed to get column info record\n" );
1581
1582     ok( check_record( rec, 1, "s62"), "wrong record type\n");
1583     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1584
1585     MsiCloseHandle( rec );
1586
1587     /* now try the names */
1588     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_NAMES );
1589     ok( rec, "failed to get column info record\n" );
1590
1591     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1592     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1593
1594     MsiCloseHandle( rec );
1595
1596     r = MsiDatabaseOpenViewA( hdb,
1597             "SELECT * FROM `_Streams` WHERE `Name` = '\5SummaryInformation'", &view );
1598     ok( r == ERROR_SUCCESS, "Failed to open database view: %u\n", r );
1599
1600     r = MsiViewExecute( view, 0 );
1601     ok( r == ERROR_SUCCESS, "Failed to execute view: %u\n", r );
1602
1603     r = MsiViewFetch( view, &rec );
1604     ok( r == ERROR_NO_MORE_ITEMS, "Unexpected result: %u\n", r );
1605
1606     MsiCloseHandle( rec );
1607     MsiViewClose( view );
1608     MsiCloseHandle( view );
1609
1610     /* create a summary information stream */
1611     r = MsiGetSummaryInformationA( hdb, NULL, 1, &hsi );
1612     ok( r == ERROR_SUCCESS, "Failed to get summary information handle: %u\n", r );
1613
1614     r = MsiSummaryInfoSetPropertyA( hsi, PID_SECURITY, VT_I4, 2, NULL, NULL );
1615     ok( r == ERROR_SUCCESS, "Failed to set property: %u\n", r );
1616
1617     r = MsiSummaryInfoPersist( hsi );
1618     ok( r == ERROR_SUCCESS, "Failed to save summary information: %u\n", r );
1619
1620     MsiCloseHandle( hsi );
1621
1622     r = MsiDatabaseOpenViewA( hdb,
1623             "SELECT * FROM `_Streams` WHERE `Name` = '\5SummaryInformation'", &view );
1624     ok( r == ERROR_SUCCESS, "Failed to open database view: %u\n", r );
1625
1626     r = MsiViewExecute( view, 0 );
1627     ok( r == ERROR_SUCCESS, "Failed to execute view: %u\n", r );
1628
1629     r = MsiViewFetch( view, &rec );
1630     ok( r == ERROR_SUCCESS, "Unexpected result: %u\n", r );
1631
1632     MsiCloseHandle( rec );
1633     MsiViewClose( view );
1634     MsiCloseHandle( view );
1635
1636     /* insert a file into the _Streams table */
1637     create_file( "test.txt" );
1638
1639     rec = MsiCreateRecord( 2 );
1640     MsiRecordSetStringA( rec, 1, "data" );
1641
1642     r = MsiRecordSetStreamA( rec, 2, "test.txt" );
1643     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1644
1645     DeleteFileA("test.txt");
1646
1647     r = MsiDatabaseOpenViewA( hdb,
1648             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1649     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1650
1651     r = MsiViewExecute( view, rec );
1652     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1653
1654     MsiCloseHandle( rec );
1655     MsiViewClose( view );
1656     MsiCloseHandle( view );
1657
1658     /* insert another one */
1659     create_file( "test1.txt" );
1660
1661     rec = MsiCreateRecord( 2 );
1662     MsiRecordSetStringA( rec, 1, "data1" );
1663
1664     r = MsiRecordSetStreamA( rec, 2, "test1.txt" );
1665     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1666
1667     DeleteFileA("test1.txt");
1668
1669     r = MsiDatabaseOpenViewA( hdb,
1670             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1671     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1672
1673     r = MsiViewExecute( view, rec );
1674     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1675
1676     MsiCloseHandle( rec );
1677     MsiViewClose( view );
1678     MsiCloseHandle( view );
1679
1680     /* try again */
1681     create_file( "test1.txt" );
1682
1683     rec = MsiCreateRecord( 2 );
1684     MsiRecordSetStringA( rec, 1, "data1" );
1685
1686     r = MsiRecordSetStreamA( rec, 2, "test1.txt" );
1687     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r );
1688
1689     DeleteFileA( "test1.txt" );
1690
1691     r = MsiDatabaseOpenViewA( hdb,
1692             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1693     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r );
1694
1695     r = MsiViewExecute( view, rec );
1696     ok( r == ERROR_FUNCTION_FAILED, "got %u\n", r );
1697
1698     MsiCloseHandle( rec );
1699     MsiViewClose( view );
1700     MsiCloseHandle( view );
1701
1702     r = MsiDatabaseOpenViewA( hdb,
1703             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data'", &view );
1704     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1705
1706     r = MsiViewExecute( view, 0 );
1707     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1708
1709     r = MsiViewFetch( view, &rec );
1710     ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1711
1712     size = MAX_PATH;
1713     r = MsiRecordGetStringA( rec, 1, file, &size );
1714     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1715     ok( !lstrcmpA(file, "data"), "Expected 'data', got %s\n", file);
1716
1717     size = MAX_PATH;
1718     memset(buf, 0, MAX_PATH);
1719     r = MsiRecordReadStream( rec, 2, buf, &size );
1720     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1721     ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf);
1722
1723     MsiCloseHandle( rec );
1724     MsiViewClose( view );
1725     MsiCloseHandle( view );
1726
1727     r = MsiDatabaseOpenViewA( hdb,
1728             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data1'", &view );
1729     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1730
1731     r = MsiViewExecute( view, 0 );
1732     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1733
1734     r = MsiViewFetch( view, &rec );
1735     ok( r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1736
1737     size = MAX_PATH;
1738     r = MsiRecordGetStringA( rec, 1, file, &size );
1739     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1740     ok( !lstrcmpA(file, "data1"), "Expected 'data1', got %s\n", file);
1741
1742     size = MAX_PATH;
1743     memset(buf, 0, MAX_PATH);
1744     r = MsiRecordReadStream( rec, 2, buf, &size );
1745     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1746     ok( !lstrcmpA(buf, "test1.txt\n"), "Expected 'test1.txt\\n', got %s\n", buf);
1747
1748     MsiCloseHandle( rec );
1749     MsiViewClose( view );
1750     MsiCloseHandle( view );
1751
1752     /* perform an update */
1753     create_file( "test2.txt" );
1754     rec = MsiCreateRecord( 1 );
1755
1756     r = MsiRecordSetStreamA( rec, 1, "test2.txt" );
1757     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1758
1759     DeleteFileA("test2.txt");
1760
1761     r = MsiDatabaseOpenViewA( hdb,
1762             "UPDATE `_Streams` SET `Data` = ? WHERE `Name` = 'data1'", &view );
1763     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1764
1765     r = MsiViewExecute( view, rec );
1766     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1767
1768     MsiCloseHandle( rec );
1769     MsiViewClose( view );
1770     MsiCloseHandle( view );
1771
1772     r = MsiDatabaseOpenViewA( hdb,
1773             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data1'", &view );
1774     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1775
1776     r = MsiViewExecute( view, 0 );
1777     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1778
1779     r = MsiViewFetch( view, &rec );
1780     ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1781
1782     size = MAX_PATH;
1783     r = MsiRecordGetStringA( rec, 1, file, &size );
1784     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1785     ok( !lstrcmpA(file, "data1"), "Expected 'data1', got %s\n", file);
1786
1787     size = MAX_PATH;
1788     memset(buf, 0, MAX_PATH);
1789     r = MsiRecordReadStream( rec, 2, buf, &size );
1790     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1791     ok( !lstrcmpA(buf, "test2.txt\n"), "Expected 'test2.txt\\n', got %s\n", buf);
1792
1793     MsiCloseHandle( rec );
1794     MsiViewClose( view );
1795     MsiCloseHandle( view );
1796     MsiCloseHandle( hdb );
1797     DeleteFileA(msifile);
1798 }
1799
1800 static void test_binary(void)
1801 {
1802     MSIHANDLE hdb = 0, rec;
1803     char file[MAX_PATH];
1804     char buf[MAX_PATH];
1805     DWORD size;
1806     LPCSTR query;
1807     UINT r;
1808
1809     /* insert a file into the Binary table */
1810     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
1811     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1812
1813     query = "CREATE TABLE `Binary` ( `Name` CHAR(72) NOT NULL, `ID` INT NOT NULL, `Data` OBJECT  PRIMARY KEY `Name`, `ID`)";
1814     r = run_query( hdb, 0, query );
1815     ok( r == ERROR_SUCCESS, "Cannot create Binary table: %d\n", r );
1816
1817     create_file( "test.txt" );
1818     rec = MsiCreateRecord( 1 );
1819     r = MsiRecordSetStreamA( rec, 1, "test.txt" );
1820     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1821     DeleteFileA( "test.txt" );
1822
1823     /* try a name that exceeds maximum OLE stream name length */
1824     query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'encryption.dll.CB4E6205_F99A_4C51_ADD4_184506EFAB87', 10000, ? )";
1825     r = run_query( hdb, rec, query );
1826     ok( r == ERROR_SUCCESS, "Insert into Binary table failed: %d\n", r );
1827
1828     r = MsiCloseHandle( rec );
1829     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1830
1831     r = MsiDatabaseCommit( hdb );
1832     ok( r == ERROR_FUNCTION_FAILED , "got %u\n", r );
1833
1834     r = MsiCloseHandle( hdb );
1835     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1836
1837     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
1838     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1839
1840     query = "CREATE TABLE `Binary` ( `Name` CHAR(72) NOT NULL, `ID` INT NOT NULL, `Data` OBJECT  PRIMARY KEY `Name`, `ID`)";
1841     r = run_query( hdb, 0, query );
1842     ok( r == ERROR_SUCCESS, "Cannot create Binary table: %d\n", r );
1843
1844     create_file( "test.txt" );
1845     rec = MsiCreateRecord( 1 );
1846     r = MsiRecordSetStreamA( rec, 1, "test.txt" );
1847     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r );
1848     DeleteFileA( "test.txt" );
1849
1850     query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'filename1', 1, ? )";
1851     r = run_query( hdb, rec, query );
1852     ok( r == ERROR_SUCCESS, "Insert into Binary table failed: %d\n", r );
1853
1854     query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'filename1', 1, ? )";
1855     r = run_query( hdb, rec, query );
1856     ok( r == ERROR_FUNCTION_FAILED, "got %u\n", r );
1857
1858     r = MsiCloseHandle( rec );
1859     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1860
1861     r = MsiDatabaseCommit( hdb );
1862     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1863
1864     r = MsiCloseHandle( hdb );
1865     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1866
1867     /* read file from the Stream table */
1868     r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_READONLY, &hdb );
1869     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1870
1871     query = "SELECT * FROM `_Streams`";
1872     r = do_query( hdb, query, &rec );
1873     ok( r == ERROR_SUCCESS, "SELECT query failed: %d\n", r );
1874
1875     size = MAX_PATH;
1876     r = MsiRecordGetStringA( rec, 1, file, &size );
1877     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
1878     ok( !lstrcmpA(file, "Binary.filename1.1"), "Expected 'Binary.filename1.1', got %s\n", file );
1879
1880     size = MAX_PATH;
1881     memset( buf, 0, MAX_PATH );
1882     r = MsiRecordReadStream( rec, 2, buf, &size );
1883     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r );
1884     ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf );
1885
1886     r = MsiCloseHandle( rec );
1887     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1888
1889     /* read file from the Binary table */
1890     query = "SELECT * FROM `Binary`";
1891     r = do_query( hdb, query, &rec );
1892     ok( r == ERROR_SUCCESS, "SELECT query failed: %d\n", r );
1893
1894     size = MAX_PATH;
1895     r = MsiRecordGetStringA( rec, 1, file, &size );
1896     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
1897     ok( !lstrcmpA(file, "filename1"), "Expected 'filename1', got %s\n", file );
1898
1899     size = MAX_PATH;
1900     memset( buf, 0, MAX_PATH );
1901     r = MsiRecordReadStream( rec, 3, buf, &size );
1902     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r );
1903     ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf );
1904
1905     r = MsiCloseHandle( rec );
1906     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1907
1908     r = MsiCloseHandle( hdb );
1909     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1910
1911     DeleteFileA( msifile );
1912 }
1913
1914 static void test_where_not_in_selected(void)
1915 {
1916     MSIHANDLE hdb = 0, rec, view;
1917     LPCSTR query;
1918     UINT r;
1919
1920     hdb = create_db();
1921     ok( hdb, "failed to create db\n");
1922
1923     r = run_query(hdb, 0,
1924             "CREATE TABLE `IESTable` ("
1925             "`Action` CHAR(64), "
1926             "`Condition` CHAR(64), "
1927             "`Sequence` LONG PRIMARY KEY `Sequence`)");
1928     ok( r == S_OK, "Cannot create IESTable table: %d\n", r);
1929
1930     r = run_query(hdb, 0,
1931             "CREATE TABLE `CATable` ("
1932             "`Action` CHAR(64), "
1933             "`Type` LONG PRIMARY KEY `Type`)");
1934     ok( r == S_OK, "Cannot create CATable table: %d\n", r);
1935
1936     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1937             "( `Action`, `Condition`, `Sequence`) "
1938             "VALUES ( 'clean', 'cond4', 4)");
1939     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1940
1941     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1942             "( `Action`, `Condition`, `Sequence`) "
1943             "VALUES ( 'depends', 'cond1', 1)");
1944     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1945
1946     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1947             "( `Action`, `Condition`, `Sequence`) "
1948             "VALUES ( 'build', 'cond2', 2)");
1949     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1950
1951     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1952             "( `Action`, `Condition`, `Sequence`) "
1953             "VALUES ( 'build2', 'cond6', 6)");
1954     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1955
1956     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1957             "( `Action`, `Condition`, `Sequence`) "
1958             "VALUES ( 'build', 'cond3', 3)");
1959     ok(r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1960
1961     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1962             "( `Action`, `Type` ) "
1963             "VALUES ( 'build', 32)");
1964     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1965
1966     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1967             "( `Action`, `Type` ) "
1968             "VALUES ( 'depends', 64)");
1969     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1970
1971     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1972             "( `Action`, `Type` ) "
1973             "VALUES ( 'clean', 63)");
1974     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1975
1976     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1977             "( `Action`, `Type` ) "
1978             "VALUES ( 'build2', 34)");
1979     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1980     query = "Select IESTable.Condition from CATable, IESTable where "
1981             "CATable.Action = IESTable.Action and CATable.Type = 32";
1982     r = MsiDatabaseOpenViewA(hdb, query, &view);
1983     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1984
1985     r = MsiViewExecute(view, 0);
1986     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1987
1988     r = MsiViewFetch(view, &rec);
1989     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1990
1991     ok( check_record( rec, 1, "cond2"), "wrong condition\n");
1992
1993     MsiCloseHandle( rec );
1994     r = MsiViewFetch(view, &rec);
1995     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1996
1997     ok( check_record( rec, 1, "cond3"), "wrong condition\n");
1998
1999     MsiCloseHandle( rec );
2000     MsiViewClose(view);
2001     MsiCloseHandle(view);
2002
2003     MsiCloseHandle( hdb );
2004     DeleteFileA(msifile);
2005 }
2006
2007
2008 static void test_where(void)
2009 {
2010     MSIHANDLE hdb = 0, rec, view;
2011     LPCSTR query;
2012     UINT r;
2013     DWORD size;
2014     CHAR buf[MAX_PATH];
2015     UINT count;
2016
2017     hdb = create_db();
2018     ok( hdb, "failed to create db\n");
2019
2020     r = run_query( hdb, 0,
2021             "CREATE TABLE `Media` ("
2022             "`DiskId` SHORT NOT NULL, "
2023             "`LastSequence` LONG, "
2024             "`DiskPrompt` CHAR(64) LOCALIZABLE, "
2025             "`Cabinet` CHAR(255), "
2026             "`VolumeLabel` CHAR(32), "
2027             "`Source` CHAR(72) "
2028             "PRIMARY KEY `DiskId`)" );
2029     ok( r == S_OK, "cannot create Media table: %d\n", r );
2030
2031     r = run_query( hdb, 0, "INSERT INTO `Media` "
2032             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
2033             "VALUES ( 1, 0, '', 'zero.cab', '', '' )" );
2034     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
2035
2036     r = run_query( hdb, 0, "INSERT INTO `Media` "
2037             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
2038             "VALUES ( 2, 1, '', 'one.cab', '', '' )" );
2039     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
2040
2041     r = run_query( hdb, 0, "INSERT INTO `Media` "
2042             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
2043             "VALUES ( 3, 2, '', 'two.cab', '', '' )" );
2044     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
2045
2046     query = "SELECT * FROM `Media`";
2047     r = do_query(hdb, query, &rec);
2048     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
2049     ok( check_record( rec, 4, "zero.cab"), "wrong cabinet\n");
2050     MsiCloseHandle( rec );
2051
2052     query = "SELECT * FROM `Media` WHERE `LastSequence` >= 1";
2053     r = do_query(hdb, query, &rec);
2054     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
2055     ok( check_record( rec, 4, "one.cab"), "wrong cabinet\n");
2056
2057     r = MsiRecordGetInteger(rec, 1);
2058     ok( 2 == r, "field wrong\n");
2059     r = MsiRecordGetInteger(rec, 2);
2060     ok( 1 == r, "field wrong\n");
2061     MsiCloseHandle( rec );
2062
2063     query = "SELECT `DiskId` FROM `Media` WHERE `LastSequence` >= 1 AND DiskId >= 0";
2064     r = MsiDatabaseOpenViewA(hdb, query, &view);
2065     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2066
2067     r = MsiViewExecute(view, 0);
2068     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2069
2070     r = MsiViewFetch(view, &rec);
2071     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
2072
2073     count = MsiRecordGetFieldCount( rec );
2074     ok( count == 1, "Expected 1 record fields, got %d\n", count );
2075
2076     size = MAX_PATH;
2077     r = MsiRecordGetStringA( rec, 1, buf, &size );
2078     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2079     ok( !lstrcmpA( buf, "2" ), "For (row %d, column 1) expected '%d', got %s\n", 0, 2, buf );
2080     MsiCloseHandle( rec );
2081
2082     r = MsiViewFetch(view, &rec);
2083     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
2084
2085     size = MAX_PATH;
2086     r = MsiRecordGetStringA( rec, 1, buf, &size );
2087     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2088     ok( !lstrcmpA( buf, "3" ), "For (row %d, column 1) expected '%d', got %s\n", 1, 3, buf );
2089     MsiCloseHandle( rec );
2090
2091     r = MsiViewFetch(view, &rec);
2092     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2093
2094     MsiViewClose(view);
2095     MsiCloseHandle(view);
2096
2097     MsiCloseHandle( rec );
2098
2099     rec = 0;
2100     query = "SELECT * FROM `Media` WHERE `DiskPrompt` IS NULL";
2101     r = do_query(hdb, query, &rec);
2102     ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
2103     MsiCloseHandle( rec );
2104
2105     rec = 0;
2106     query = "SELECT * FROM `Media` WHERE `DiskPrompt` < 'Cabinet'";
2107     r = do_query(hdb, query, &rec);
2108     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %d\n", r );
2109     MsiCloseHandle( rec );
2110
2111     rec = 0;
2112     query = "SELECT * FROM `Media` WHERE `DiskPrompt` > 'Cabinet'";
2113     r = do_query(hdb, query, &rec);
2114     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %d\n", r );
2115     MsiCloseHandle( rec );
2116
2117     rec = 0;
2118     query = "SELECT * FROM `Media` WHERE `DiskPrompt` <> 'Cabinet'";
2119     r = do_query(hdb, query, &rec);
2120     ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
2121     MsiCloseHandle( rec );
2122
2123     rec = 0;
2124     query = "SELECT * FROM `Media` WHERE `DiskPrompt` = 'Cabinet'";
2125     r = do_query(hdb, query, &rec);
2126     ok( r == ERROR_NO_MORE_ITEMS, "query failed: %d\n", r );
2127     MsiCloseHandle( rec );
2128
2129     rec = MsiCreateRecord(1);
2130     MsiRecordSetStringA(rec, 1, "");
2131
2132     query = "SELECT * FROM `Media` WHERE `DiskPrompt` = ?";
2133     r = MsiDatabaseOpenViewA(hdb, query, &view);
2134     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2135     r = MsiViewExecute(view, rec);
2136     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2137
2138     MsiCloseHandle(rec);
2139
2140     r = MsiViewFetch(view, &rec);
2141     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2142
2143     MsiCloseHandle(rec);
2144     MsiViewClose(view);
2145     MsiCloseHandle(view);
2146
2147     MsiCloseHandle( hdb );
2148     DeleteFileA(msifile);
2149 }
2150
2151 static CHAR CURR_DIR[MAX_PATH];
2152
2153 static const CHAR test_data[] = "FirstPrimaryColumn\tSecondPrimaryColumn\tShortInt\tShortIntNullable\tLongInt\tLongIntNullable\tString\tLocalizableString\tLocalizableStringNullable\n"
2154                                 "s255\ti2\ti2\tI2\ti4\tI4\tS255\tS0\ts0\n"
2155                                 "TestTable\tFirstPrimaryColumn\n"
2156                                 "stringage\t5\t2\t\t2147483640\t-2147483640\tanother string\tlocalizable\tduh\n";
2157
2158 static const CHAR two_primary[] = "PrimaryOne\tPrimaryTwo\n"
2159                                   "s255\ts255\n"
2160                                   "TwoPrimary\tPrimaryOne\tPrimaryTwo\n"
2161                                   "papaya\tleaf\n"
2162                                   "papaya\tflower\n";
2163
2164 static const CHAR endlines1[] = "A\tB\tC\tD\tE\tF\r\n"
2165                                 "s72\ts72\ts72\ts72\ts72\ts72\n"
2166                                 "Table\tA\r\n"
2167                                 "a\tb\tc\td\te\tf\n"
2168                                 "g\th\ti\t\rj\tk\tl\r\n";
2169
2170 static const CHAR endlines2[] = "A\tB\tC\tD\tE\tF\r"
2171                                 "s72\ts72\ts72\ts72\ts72\ts72\n"
2172                                 "Table2\tA\r\n"
2173                                 "a\tb\tc\td\te\tf\n"
2174                                 "g\th\ti\tj\tk\tl\r\n";
2175
2176 static const CHAR suminfo[] = "PropertyId\tValue\n"
2177                               "i2\tl255\n"
2178                               "_SummaryInformation\tPropertyId\n"
2179                               "1\t1252\n"
2180                               "2\tInstaller Database\n"
2181                               "3\tInstaller description\n"
2182                               "4\tWineHQ\n"
2183                               "5\tInstaller\n"
2184                               "6\tInstaller comments\n"
2185                               "7\tIntel;1033,2057\n"
2186                               "9\t{12345678-1234-1234-1234-123456789012}\n"
2187                               "12\t2009/04/12 15:46:11\n"
2188                               "13\t2009/04/12 15:46:11\n"
2189                               "14\t200\n"
2190                               "15\t2\n"
2191                               "18\tVim\n"
2192                               "19\t2\n";
2193
2194 static void write_file(const CHAR *filename, const char *data, int data_size)
2195 {
2196     DWORD size;
2197
2198     HANDLE hf = CreateFileA(filename, GENERIC_WRITE, 0, NULL,
2199                             CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2200     WriteFile(hf, data, data_size, &size, NULL);
2201     CloseHandle(hf);
2202 }
2203
2204 static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
2205 {
2206     UINT r;
2207
2208     write_file("temp_file", table_data, (lstrlenA(table_data) - 1) * sizeof(char));
2209     r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
2210     DeleteFileA("temp_file");
2211
2212     return r;
2213 }
2214
2215 static void test_suminfo_import(void)
2216 {
2217     MSIHANDLE hdb, hsi, view = 0;
2218     LPCSTR query;
2219     UINT r, count, size, type;
2220     char str_value[50];
2221     INT int_value;
2222     FILETIME ft_value;
2223
2224     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
2225
2226     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
2227     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2228
2229     r = add_table_to_db(hdb, suminfo);
2230     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2231
2232     /* _SummaryInformation is not imported as a regular table... */
2233
2234     query = "SELECT * FROM `_SummaryInformation`";
2235     r = MsiDatabaseOpenViewA(hdb, query, &view);
2236     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %u\n", r);
2237     MsiCloseHandle(view);
2238
2239     /* ...its data is added to the special summary information stream */
2240
2241     r = MsiGetSummaryInformationA(hdb, NULL, 0, &hsi);
2242     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2243
2244     r = MsiSummaryInfoGetPropertyCount(hsi, &count);
2245     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2246     ok(count == 14, "Expected 14, got %u\n", count);
2247
2248     r = MsiSummaryInfoGetPropertyA(hsi, PID_CODEPAGE, &type, &int_value, NULL, NULL, NULL);
2249     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2250     ok(type ==  VT_I2, "Expected VT_I2, got %u\n", type);
2251     ok(int_value == 1252, "Expected 1252, got %d\n", int_value);
2252
2253     size = sizeof(str_value);
2254     r = MsiSummaryInfoGetPropertyA(hsi, PID_TITLE, &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(size == 18, "Expected 18, got %u\n", size);
2258     ok(!strcmp(str_value, "Installer Database"),
2259        "Expected \"Installer Database\", got %s\n", str_value);
2260
2261     size = sizeof(str_value);
2262     r = MsiSummaryInfoGetPropertyA(hsi, PID_SUBJECT, &type, NULL, NULL, str_value, &size);
2263     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2264     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2265     ok(!strcmp(str_value, "Installer description"),
2266        "Expected \"Installer description\", got %s\n", str_value);
2267
2268     size = sizeof(str_value);
2269     r = MsiSummaryInfoGetPropertyA(hsi, PID_AUTHOR, &type, NULL, NULL, str_value, &size);
2270     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2271     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2272     ok(!strcmp(str_value, "WineHQ"),
2273        "Expected \"WineHQ\", got %s\n", str_value);
2274
2275     size = sizeof(str_value);
2276     r = MsiSummaryInfoGetPropertyA(hsi, PID_KEYWORDS, &type, NULL, NULL, str_value, &size);
2277     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2278     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2279     ok(!strcmp(str_value, "Installer"),
2280        "Expected \"Installer\", got %s\n", str_value);
2281
2282     size = sizeof(str_value);
2283     r = MsiSummaryInfoGetPropertyA(hsi, PID_COMMENTS, &type, NULL, NULL, str_value, &size);
2284     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2285     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2286     ok(!strcmp(str_value, "Installer comments"),
2287        "Expected \"Installer comments\", got %s\n", str_value);
2288
2289     size = sizeof(str_value);
2290     r = MsiSummaryInfoGetPropertyA(hsi, PID_TEMPLATE, &type, NULL, NULL, str_value, &size);
2291     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2292     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2293     ok(!strcmp(str_value, "Intel;1033,2057"),
2294        "Expected \"Intel;1033,2057\", got %s\n", str_value);
2295
2296     size = sizeof(str_value);
2297     r = MsiSummaryInfoGetPropertyA(hsi, PID_REVNUMBER, &type, NULL, NULL, str_value, &size);
2298     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2299     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2300     ok(!strcmp(str_value, "{12345678-1234-1234-1234-123456789012}"),
2301        "Expected \"{12345678-1234-1234-1234-123456789012}\", got %s\n", str_value);
2302
2303     r = MsiSummaryInfoGetPropertyA(hsi, PID_CREATE_DTM, &type, NULL, &ft_value, NULL, NULL);
2304     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2305     ok(type == VT_FILETIME, "Expected VT_FILETIME, got %u\n", type);
2306
2307     r = MsiSummaryInfoGetPropertyA(hsi, PID_LASTSAVE_DTM, &type, NULL, &ft_value, NULL, NULL);
2308     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2309     ok(type == VT_FILETIME, "Expected VT_FILETIME, got %u\n", type);
2310
2311     r = MsiSummaryInfoGetPropertyA(hsi, PID_PAGECOUNT, &type, &int_value, NULL, NULL, NULL);
2312     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2313     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2314     ok(int_value == 200, "Expected 200, got %d\n", int_value);
2315
2316     r = MsiSummaryInfoGetPropertyA(hsi, PID_WORDCOUNT, &type, &int_value, NULL, NULL, NULL);
2317     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2318     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2319     ok(int_value == 2, "Expected 2, got %d\n", int_value);
2320
2321     r = MsiSummaryInfoGetPropertyA(hsi, PID_SECURITY, &type, &int_value, NULL, NULL, NULL);
2322     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2323     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2324     ok(int_value == 2, "Expected 2, got %d\n", int_value);
2325
2326     size = sizeof(str_value);
2327     r = MsiSummaryInfoGetPropertyA(hsi, PID_APPNAME, &type, NULL, NULL, str_value, &size);
2328     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2329     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2330     ok(!strcmp(str_value, "Vim"), "Expected \"Vim\", got %s\n", str_value);
2331
2332     MsiCloseHandle(hsi);
2333     MsiCloseHandle(hdb);
2334     DeleteFileA(msifile);
2335 }
2336
2337 static void test_msiimport(void)
2338 {
2339     MSIHANDLE hdb, view, rec;
2340     LPCSTR query;
2341     UINT r, count;
2342     signed int i;
2343
2344     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
2345
2346     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
2347     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2348
2349     r = add_table_to_db(hdb, test_data);
2350     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2351
2352     r = add_table_to_db(hdb, two_primary);
2353     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2354
2355     r = add_table_to_db(hdb, endlines1);
2356     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2357
2358     r = add_table_to_db(hdb, endlines2);
2359     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
2360
2361     query = "SELECT * FROM `TestTable`";
2362     r = MsiDatabaseOpenViewA(hdb, query, &view);
2363     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2364
2365     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2366     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2367     count = MsiRecordGetFieldCount(rec);
2368     ok(count == 9, "Expected 9, got %d\n", count);
2369     ok(check_record(rec, 1, "FirstPrimaryColumn"), "Expected FirstPrimaryColumn\n");
2370     ok(check_record(rec, 2, "SecondPrimaryColumn"), "Expected SecondPrimaryColumn\n");
2371     ok(check_record(rec, 3, "ShortInt"), "Expected ShortInt\n");
2372     ok(check_record(rec, 4, "ShortIntNullable"), "Expected ShortIntNullalble\n");
2373     ok(check_record(rec, 5, "LongInt"), "Expected LongInt\n");
2374     ok(check_record(rec, 6, "LongIntNullable"), "Expected LongIntNullalble\n");
2375     ok(check_record(rec, 7, "String"), "Expected String\n");
2376     ok(check_record(rec, 8, "LocalizableString"), "Expected LocalizableString\n");
2377     ok(check_record(rec, 9, "LocalizableStringNullable"), "Expected LocalizableStringNullable\n");
2378     MsiCloseHandle(rec);
2379
2380     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2381     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2382     count = MsiRecordGetFieldCount(rec);
2383     ok(count == 9, "Expected 9, got %d\n", count);
2384     ok(check_record(rec, 1, "s255"), "Expected s255\n");
2385     ok(check_record(rec, 2, "i2"), "Expected i2\n");
2386     ok(check_record(rec, 3, "i2"), "Expected i2\n");
2387     ok(check_record(rec, 4, "I2"), "Expected I2\n");
2388     ok(check_record(rec, 5, "i4"), "Expected i4\n");
2389     ok(check_record(rec, 6, "I4"), "Expected I4\n");
2390     ok(check_record(rec, 7, "S255"), "Expected S255\n");
2391     ok(check_record(rec, 8, "S0"), "Expected S0\n");
2392     ok(check_record(rec, 9, "s0"), "Expected s0\n");
2393     MsiCloseHandle(rec);
2394
2395     query = "SELECT * FROM `TestTable`";
2396     r = do_query(hdb, query, &rec);
2397     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2398     ok(check_record(rec, 1, "stringage"), "Expected 'stringage'\n");
2399     ok(check_record(rec, 7, "another string"), "Expected 'another string'\n");
2400     ok(check_record(rec, 8, "localizable"), "Expected 'localizable'\n");
2401     ok(check_record(rec, 9, "duh"), "Expected 'duh'\n");
2402
2403     i = MsiRecordGetInteger(rec, 2);
2404     ok(i == 5, "Expected 5, got %d\n", i);
2405
2406     i = MsiRecordGetInteger(rec, 3);
2407     ok(i == 2, "Expected 2, got %d\n", i);
2408
2409     i = MsiRecordGetInteger(rec, 4);
2410     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
2411
2412     i = MsiRecordGetInteger(rec, 5);
2413     ok(i == 2147483640, "Expected 2147483640, got %d\n", i);
2414
2415     i = MsiRecordGetInteger(rec, 6);
2416     ok(i == -2147483640, "Expected -2147483640, got %d\n", i);
2417
2418     MsiCloseHandle(rec);
2419     MsiViewClose(view);
2420     MsiCloseHandle(view);
2421
2422     query = "SELECT * FROM `TwoPrimary`";
2423     r = MsiDatabaseOpenViewA(hdb, query, &view);
2424     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2425
2426     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2427     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2428     count = MsiRecordGetFieldCount(rec);
2429     ok(count == 2, "Expected 2, got %d\n", count);
2430     ok(check_record(rec, 1, "PrimaryOne"), "Expected PrimaryOne\n");
2431     ok(check_record(rec, 2, "PrimaryTwo"), "Expected PrimaryTwo\n");
2432
2433     MsiCloseHandle(rec);
2434
2435     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2436     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2437     count = MsiRecordGetFieldCount(rec);
2438     ok(count == 2, "Expected 2, got %d\n", count);
2439     ok(check_record(rec, 1, "s255"), "Expected s255\n");
2440     ok(check_record(rec, 2, "s255"), "Expected s255\n");
2441     MsiCloseHandle(rec);
2442
2443     r = MsiViewExecute(view, 0);
2444     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
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, "leaf"), "Expected 'leaf'\n");
2451
2452     MsiCloseHandle(rec);
2453
2454     r = MsiViewFetch(view, &rec);
2455     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2456
2457     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
2458     ok(check_record(rec, 2, "flower"), "Expected 'flower'\n");
2459
2460     MsiCloseHandle(rec);
2461
2462     r = MsiViewFetch(view, &rec);
2463     ok(r == ERROR_NO_MORE_ITEMS,
2464        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
2465
2466     r = MsiViewClose(view);
2467     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2468
2469     MsiCloseHandle(view);
2470
2471     query = "SELECT * FROM `Table`";
2472     r = MsiDatabaseOpenViewA(hdb, query, &view);
2473     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2474
2475     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2476     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2477     count = MsiRecordGetFieldCount(rec);
2478     ok(count == 6, "Expected 6, got %d\n", count);
2479     ok(check_record(rec, 1, "A"), "Expected A\n");
2480     ok(check_record(rec, 2, "B"), "Expected B\n");
2481     ok(check_record(rec, 3, "C"), "Expected C\n");
2482     ok(check_record(rec, 4, "D"), "Expected D\n");
2483     ok(check_record(rec, 5, "E"), "Expected E\n");
2484     ok(check_record(rec, 6, "F"), "Expected F\n");
2485     MsiCloseHandle(rec);
2486
2487     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2488     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2489     count = MsiRecordGetFieldCount(rec);
2490     ok(count == 6, "Expected 6, got %d\n", count);
2491     ok(check_record(rec, 1, "s72"), "Expected s72\n");
2492     ok(check_record(rec, 2, "s72"), "Expected s72\n");
2493     ok(check_record(rec, 3, "s72"), "Expected s72\n");
2494     ok(check_record(rec, 4, "s72"), "Expected s72\n");
2495     ok(check_record(rec, 5, "s72"), "Expected s72\n");
2496     ok(check_record(rec, 6, "s72"), "Expected s72\n");
2497     MsiCloseHandle(rec);
2498
2499     MsiViewClose(view);
2500     MsiCloseHandle(view);
2501
2502     query = "SELECT * FROM `Table`";
2503     r = MsiDatabaseOpenViewA(hdb, query, &view);
2504     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2505
2506     r = MsiViewExecute(view, 0);
2507     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2508
2509     r = MsiViewFetch(view, &rec);
2510     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2511     ok(check_record(rec, 1, "a"), "Expected 'a'\n");
2512     ok(check_record(rec, 2, "b"), "Expected 'b'\n");
2513     ok(check_record(rec, 3, "c"), "Expected 'c'\n");
2514     ok(check_record(rec, 4, "d"), "Expected 'd'\n");
2515     ok(check_record(rec, 5, "e"), "Expected 'e'\n");
2516     ok(check_record(rec, 6, "f"), "Expected 'f'\n");
2517
2518     MsiCloseHandle(rec);
2519
2520     r = MsiViewFetch(view, &rec);
2521     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2522     ok(check_record(rec, 1, "g"), "Expected 'g'\n");
2523     ok(check_record(rec, 2, "h"), "Expected 'h'\n");
2524     ok(check_record(rec, 3, "i"), "Expected 'i'\n");
2525     ok(check_record(rec, 4, "j"), "Expected 'j'\n");
2526     ok(check_record(rec, 5, "k"), "Expected 'k'\n");
2527     ok(check_record(rec, 6, "l"), "Expected 'l'\n");
2528
2529     MsiCloseHandle(rec);
2530
2531     r = MsiViewFetch(view, &rec);
2532     ok(r == ERROR_NO_MORE_ITEMS,
2533        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
2534
2535     MsiViewClose(view);
2536     MsiCloseHandle(view);
2537     MsiCloseHandle(hdb);
2538     DeleteFileA(msifile);
2539 }
2540
2541 static const CHAR bin_import_dat[] = "Name\tData\r\n"
2542                                      "s72\tV0\r\n"
2543                                      "Binary\tName\r\n"
2544                                      "filename1\tfilename1.ibd\r\n";
2545
2546 static void test_binary_import(void)
2547 {
2548     MSIHANDLE hdb = 0, rec;
2549     char file[MAX_PATH];
2550     char buf[MAX_PATH];
2551     char path[MAX_PATH];
2552     DWORD size;
2553     LPCSTR query;
2554     UINT r;
2555
2556     /* create files to import */
2557     write_file("bin_import.idt", bin_import_dat,
2558           (sizeof(bin_import_dat) - 1) * sizeof(char));
2559     CreateDirectoryA("bin_import", NULL);
2560     create_file_data("bin_import/filename1.ibd", "just some words", 15);
2561
2562     /* import files into database */
2563     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
2564     ok( r == ERROR_SUCCESS , "Failed to open database\n");
2565
2566     GetCurrentDirectoryA(MAX_PATH, path);
2567     r = MsiDatabaseImportA(hdb, path, "bin_import.idt");
2568     ok(r == ERROR_SUCCESS , "Failed to import Binary table\n");
2569
2570     /* read file from the Binary table */
2571     query = "SELECT * FROM `Binary`";
2572     r = do_query(hdb, query, &rec);
2573     ok(r == ERROR_SUCCESS, "SELECT query failed: %d\n", r);
2574
2575     size = MAX_PATH;
2576     r = MsiRecordGetStringA(rec, 1, file, &size);
2577     ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
2578     ok(!lstrcmpA(file, "filename1"), "Expected 'filename1', got %s\n", file);
2579
2580     size = MAX_PATH;
2581     memset(buf, 0, MAX_PATH);
2582     r = MsiRecordReadStream(rec, 2, buf, &size);
2583     ok(r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
2584     ok(!lstrcmpA(buf, "just some words"), "Expected 'just some words', got %s\n", buf);
2585
2586     r = MsiCloseHandle(rec);
2587     ok(r == ERROR_SUCCESS , "Failed to close record handle\n");
2588
2589     r = MsiCloseHandle(hdb);
2590     ok(r == ERROR_SUCCESS , "Failed to close database\n");
2591
2592     DeleteFileA("bin_import/filename1.ibd");
2593     RemoveDirectoryA("bin_import");
2594     DeleteFileA("bin_import.idt");
2595 }
2596
2597 static void test_markers(void)
2598 {
2599     MSIHANDLE hdb, rec;
2600     LPCSTR query;
2601     UINT r;
2602
2603     hdb = create_db();
2604     ok( hdb, "failed to create db\n");
2605
2606     rec = MsiCreateRecord(3);
2607     MsiRecordSetStringA(rec, 1, "Table");
2608     MsiRecordSetStringA(rec, 2, "Apples");
2609     MsiRecordSetStringA(rec, 3, "Oranges");
2610
2611     /* try a legit create */
2612     query = "CREATE TABLE `Table` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2613     r = run_query(hdb, 0, query);
2614     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2615     MsiCloseHandle(rec);
2616
2617     /* try table name as marker */
2618     rec = MsiCreateRecord(1);
2619     MsiRecordSetStringA(rec, 1, "Fable");
2620     query = "CREATE TABLE `?` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2621     r = run_query(hdb, rec, query);
2622     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2623
2624     /* verify that we just created a table called '?', not 'Fable' */
2625     r = try_query(hdb, "SELECT * from `Fable`");
2626     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2627
2628     r = try_query(hdb, "SELECT * from `?`");
2629     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2630
2631     /* try table name as marker without backticks */
2632     MsiRecordSetStringA(rec, 1, "Mable");
2633     query = "CREATE TABLE ? ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2634     r = run_query(hdb, rec, query);
2635     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2636
2637     /* try one column name as marker */
2638     MsiRecordSetStringA(rec, 1, "One");
2639     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2640     r = run_query(hdb, rec, query);
2641     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2642     MsiCloseHandle(rec);
2643
2644     /* try column names as markers */
2645     rec = MsiCreateRecord(2);
2646     MsiRecordSetStringA(rec, 1, "One");
2647     MsiRecordSetStringA(rec, 2, "Two");
2648     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `One`)";
2649     r = run_query(hdb, rec, query);
2650     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2651     MsiCloseHandle(rec);
2652
2653     /* try names with backticks */
2654     rec = MsiCreateRecord(3);
2655     MsiRecordSetStringA(rec, 1, "One");
2656     MsiRecordSetStringA(rec, 2, "Two");
2657     MsiRecordSetStringA(rec, 3, "One");
2658     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
2659     r = run_query(hdb, rec, query);
2660     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2661
2662     /* try names with backticks, minus definitions */
2663     query = "CREATE TABLE `Mable` ( `?`, `?` PRIMARY KEY `?`)";
2664     r = run_query(hdb, rec, query);
2665     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2666
2667     /* try names without backticks */
2668     query = "CREATE TABLE `Mable` ( ? SHORT NOT NULL, ? CHAR(255) PRIMARY KEY ?)";
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 one long marker */
2674     rec = MsiCreateRecord(1);
2675     MsiRecordSetStringA(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
2676     query = "CREATE TABLE `Mable` ( ? )";
2677     r = run_query(hdb, rec, query);
2678     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2679     MsiCloseHandle(rec);
2680
2681     /* try all names as markers */
2682     rec = MsiCreateRecord(4);
2683     MsiRecordSetStringA(rec, 1, "Mable");
2684     MsiRecordSetStringA(rec, 2, "One");
2685     MsiRecordSetStringA(rec, 3, "Two");
2686     MsiRecordSetStringA(rec, 4, "One");
2687     query = "CREATE TABLE `?` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
2688     r = run_query(hdb, rec, query);
2689     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2690     MsiCloseHandle(rec);
2691
2692     /* try a legit insert */
2693     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( 5, 'hello' )";
2694     r = run_query(hdb, 0, query);
2695     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2696
2697     r = try_query(hdb, "SELECT * from `Table`");
2698     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2699
2700     /* try values as markers */
2701     rec = MsiCreateRecord(2);
2702     MsiRecordSetInteger(rec, 1, 4);
2703     MsiRecordSetStringA(rec, 2, "hi");
2704     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
2705     r = run_query(hdb, rec, query);
2706     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2707     MsiCloseHandle(rec);
2708
2709     /* try column names and values as markers */
2710     rec = MsiCreateRecord(4);
2711     MsiRecordSetStringA(rec, 1, "One");
2712     MsiRecordSetStringA(rec, 2, "Two");
2713     MsiRecordSetInteger(rec, 3, 5);
2714     MsiRecordSetStringA(rec, 4, "hi");
2715     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( ?, '?' )";
2716     r = run_query(hdb, rec, query);
2717     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2718     MsiCloseHandle(rec);
2719
2720     /* try column names as markers */
2721     rec = MsiCreateRecord(2);
2722     MsiRecordSetStringA(rec, 1, "One");
2723     MsiRecordSetStringA(rec, 2, "Two");
2724     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( 3, 'yellow' )";
2725     r = run_query(hdb, rec, query);
2726     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2727     MsiCloseHandle(rec);
2728
2729     /* try table name as a marker */
2730     rec = MsiCreateRecord(1);
2731     MsiRecordSetStringA(rec, 1, "Table");
2732     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( 2, 'green' )";
2733     r = run_query(hdb, rec, query);
2734     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2735     MsiCloseHandle(rec);
2736
2737     /* try table name and values as markers */
2738     rec = MsiCreateRecord(3);
2739     MsiRecordSetStringA(rec, 1, "Table");
2740     MsiRecordSetInteger(rec, 2, 10);
2741     MsiRecordSetStringA(rec, 3, "haha");
2742     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
2743     r = run_query(hdb, rec, query);
2744     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
2745     MsiCloseHandle(rec);
2746
2747     /* try all markers */
2748     rec = MsiCreateRecord(5);
2749     MsiRecordSetStringA(rec, 1, "Table");
2750     MsiRecordSetStringA(rec, 1, "One");
2751     MsiRecordSetStringA(rec, 1, "Two");
2752     MsiRecordSetInteger(rec, 2, 10);
2753     MsiRecordSetStringA(rec, 3, "haha");
2754     query = "INSERT INTO `?` ( `?`, `?` ) VALUES ( ?, '?' )";
2755     r = run_query(hdb, rec, query);
2756     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2757     MsiCloseHandle(rec);
2758
2759     /* insert an integer as a string */
2760     rec = MsiCreateRecord(2);
2761     MsiRecordSetStringA(rec, 1, "11");
2762     MsiRecordSetStringA(rec, 2, "hi");
2763     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
2764     r = run_query(hdb, rec, query);
2765     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2766     MsiCloseHandle(rec);
2767
2768     /* leave off the '' for the string */
2769     rec = MsiCreateRecord(2);
2770     MsiRecordSetInteger(rec, 1, 12);
2771     MsiRecordSetStringA(rec, 2, "hi");
2772     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, ? )";
2773     r = run_query(hdb, rec, query);
2774     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2775     MsiCloseHandle(rec);
2776
2777     MsiCloseHandle(hdb);
2778     DeleteFileA(msifile);
2779 }
2780
2781 #define MY_NVIEWS 4000    /* Largest installer I've seen uses < 2000 */
2782 static void test_handle_limit(void)
2783 {
2784     int i;
2785     MSIHANDLE hdb;
2786     MSIHANDLE hviews[MY_NVIEWS];
2787     UINT r;
2788
2789     /* create an empty db */
2790     hdb = create_db();
2791     ok( hdb, "failed to create db\n");
2792
2793     memset(hviews, 0, sizeof(hviews));
2794
2795     for (i=0; i<MY_NVIEWS; i++) {
2796         static char szQueryBuf[256] = "SELECT * from `_Tables`";
2797         hviews[i] = 0xdeadbeeb;
2798         r = MsiDatabaseOpenViewA(hdb, szQueryBuf, &hviews[i]);
2799         if( r != ERROR_SUCCESS || hviews[i] == 0xdeadbeeb ||
2800             hviews[i] == 0 || (i && (hviews[i] == hviews[i-1])))
2801             break;
2802     }
2803
2804     ok( i == MY_NVIEWS, "problem opening views\n");
2805
2806     for (i=0; i<MY_NVIEWS; i++) {
2807         if (hviews[i] != 0 && hviews[i] != 0xdeadbeeb) {
2808             MsiViewClose(hviews[i]);
2809             r = MsiCloseHandle(hviews[i]);
2810             if (r != ERROR_SUCCESS)
2811                 break;
2812         }
2813     }
2814
2815     ok( i == MY_NVIEWS, "problem closing views\n");
2816
2817     r = MsiCloseHandle(hdb);
2818     ok( r == ERROR_SUCCESS, "failed to close database\n");
2819 }
2820
2821 static void generate_transform(void)
2822 {
2823     MSIHANDLE hdb1, hdb2, hrec;
2824     LPCSTR query;
2825     UINT r;
2826
2827     /* start with two identical databases */
2828     CopyFileA(msifile2, msifile, FALSE);
2829
2830     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb1 );
2831     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2832
2833     r = MsiDatabaseCommit( hdb1 );
2834     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
2835
2836     r = MsiOpenDatabaseW(msifile2W, MSIDBOPEN_READONLY, &hdb2 );
2837     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2838
2839     /* the transform between two identical database should be empty */
2840     r = MsiDatabaseGenerateTransformA(hdb1, hdb2, NULL, 0, 0);
2841     todo_wine {
2842     ok( r == ERROR_NO_DATA, "return code %d, should be ERROR_NO_DATA\n", r );
2843     }
2844
2845     query = "CREATE TABLE `AAR` ( `BAR` SHORT NOT NULL, `CAR` CHAR(255) PRIMARY KEY `CAR`)";
2846     r = run_query(hdb1, 0, query);
2847     ok(r == ERROR_SUCCESS, "failed to add table\n");
2848
2849     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 1, 'vw' )";
2850     r = run_query(hdb1, 0, query);
2851     ok(r == ERROR_SUCCESS, "failed to add row 1\n");
2852
2853     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 2, 'bmw' )";
2854     r = run_query(hdb1, 0, query);
2855     ok(r == ERROR_SUCCESS, "failed to add row 2\n");
2856
2857     query = "UPDATE `MOO` SET `OOO` = 'c' WHERE `NOO` = 1";
2858     r = run_query(hdb1, 0, query);
2859     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2860
2861     query = "DELETE FROM `MOO` WHERE `NOO` = 3";
2862     r = run_query(hdb1, 0, query);
2863     ok(r == ERROR_SUCCESS, "failed to delete row\n");
2864
2865     hrec = MsiCreateRecord(2);
2866     r = MsiRecordSetInteger(hrec, 1, 1);
2867     ok(r == ERROR_SUCCESS, "failed to set integer\n");
2868
2869     write_file("testdata.bin", "naengmyon", 9);
2870     r = MsiRecordSetStreamA(hrec, 2, "testdata.bin");
2871     ok(r == ERROR_SUCCESS, "failed to set stream\n");
2872
2873     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
2874     r = run_query(hdb1, hrec, query);
2875     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
2876
2877     MsiCloseHandle(hrec);
2878
2879     query = "ALTER TABLE `MOO` ADD `COW` INTEGER";
2880     r = run_query(hdb1, 0, query);
2881     ok(r == ERROR_SUCCESS, "failed to add column\n");
2882
2883     query = "ALTER TABLE `MOO` ADD `PIG` INTEGER";
2884     r = run_query(hdb1, 0, query);
2885     ok(r == ERROR_SUCCESS, "failed to add column\n");
2886
2887     query = "UPDATE `MOO` SET `PIG` = 5 WHERE `NOO` = 1";
2888     r = run_query(hdb1, 0, query);
2889     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2890
2891     query = "CREATE TABLE `Property` ( `Property` CHAR(72) NOT NULL, "
2892             "`Value` CHAR(0) PRIMARY KEY `Property`)";
2893     r = run_query(hdb1, 0, query);
2894     ok(r == ERROR_SUCCESS, "failed to add property table\n");
2895
2896     query = "INSERT INTO `Property` ( `Property`, `Value` ) VALUES ( 'prop', 'val' )";
2897     r = run_query(hdb1, 0, query);
2898     ok(r == ERROR_SUCCESS, "failed to add property\n");
2899
2900     /* database needs to be committed */
2901     MsiDatabaseCommit(hdb1);
2902
2903     r = MsiDatabaseGenerateTransformA(hdb1, hdb2, mstfile, 0, 0);
2904     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
2905
2906     MsiCloseHandle( hdb1 );
2907     MsiCloseHandle( hdb2 );
2908
2909     DeleteFileA("testdata.bin");
2910 }
2911
2912 /* data for generating a transform */
2913
2914 /* tables transform names - encoded as they would be in an msi database file */
2915 static const WCHAR name1[] = { 0x4840, 0x3a8a, 0x481b, 0 }; /* AAR */
2916 static const WCHAR name2[] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }; /* _Columns */
2917 static const WCHAR name3[] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }; /* _Tables */
2918 static const WCHAR name4[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }; /* _StringData */
2919 static const WCHAR name5[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }; /* _StringPool */
2920 static const WCHAR name6[] = { 0x4840, 0x3e16, 0x4818, 0}; /* MOO */
2921 static const WCHAR name7[] = { 0x4840, 0x3c8b, 0x3a97, 0x409b, 0 }; /* BINARY */
2922 static const WCHAR name8[] = { 0x3c8b, 0x3a97, 0x409b, 0x387e, 0 }; /* BINARY.1 */
2923 static const WCHAR name9[] = { 0x4840, 0x4559, 0x44f2, 0x4568, 0x4737, 0 }; /* Property */
2924
2925 /* data in each table */
2926 static const WCHAR data1[] = { /* AAR */
2927     0x0201, 0x0008, 0x8001,  /* 0x0201 = add row (1), two shorts */
2928     0x0201, 0x0009, 0x8002,
2929 };
2930 static const WCHAR data2[] = { /* _Columns */
2931     0x0401, 0x0001, 0x8003, 0x0002, 0x9502,
2932     0x0401, 0x0001, 0x8004, 0x0003, 0x9502,
2933     0x0401, 0x0005, 0x0000, 0x0006, 0xbdff,  /* 0x0401 = add row (1), 4 shorts */
2934     0x0401, 0x0005, 0x0000, 0x0007, 0x8502,
2935     0x0401, 0x000a, 0x0000, 0x000a, 0xad48,
2936     0x0401, 0x000a, 0x0000, 0x000b, 0x9d00,
2937 };
2938 static const WCHAR data3[] = { /* _Tables */
2939     0x0101, 0x0005, /* 0x0101 = add row (1), 1 short */
2940     0x0101, 0x000a,
2941 };
2942 static const char data4[] = /* _StringData */
2943     "MOOCOWPIGcAARCARBARvwbmwPropertyValuepropval";  /* all the strings squashed together */
2944 static const WCHAR data5[] = { /* _StringPool */
2945 /*  len, refs */
2946     0,   0,    /* string 0 ''    */
2947     3,   2,    /* string 1 'MOO' */
2948     3,   1,    /* string 2 'COW' */
2949     3,   1,    /* string 3 'PIG' */
2950     1,   1,    /* string 4 'c'   */
2951     3,   3,    /* string 5 'AAR' */
2952     3,   1,    /* string 6 'CAR' */
2953     3,   1,    /* string 7 'BAR' */
2954     2,   1,    /* string 8 'vw'  */
2955     3,   1,    /* string 9 'bmw' */
2956     8,   4,    /* string 10 'Property' */
2957     5,   1,    /* string 11 'Value' */
2958     4,   1,    /* string 12 'prop' */
2959     3,   1,    /* string 13 'val' */
2960 };
2961 /* update row, 0x0002 is a bitmask of present column data, keys are excluded */
2962 static const WCHAR data6[] = { /* MOO */
2963     0x000a, 0x8001, 0x0004, 0x8005, /* update row */
2964     0x0000, 0x8003,         /* delete row */
2965 };
2966
2967 static const WCHAR data7[] = { /* BINARY */
2968     0x0201, 0x8001, 0x0001,
2969 };
2970
2971 static const char data8[] =  /* stream data for the BINARY table */
2972     "naengmyon";
2973
2974 static const WCHAR data9[] = { /* Property */
2975     0x0201, 0x000c, 0x000d,
2976 };
2977
2978 static const struct {
2979     LPCWSTR name;
2980     const void *data;
2981     DWORD size;
2982 } table_transform_data[] =
2983 {
2984     { name1, data1, sizeof data1 },
2985     { name2, data2, sizeof data2 },
2986     { name3, data3, sizeof data3 },
2987     { name4, data4, sizeof data4 - 1 },
2988     { name5, data5, sizeof data5 },
2989     { name6, data6, sizeof data6 },
2990     { name7, data7, sizeof data7 },
2991     { name8, data8, sizeof data8 - 1 },
2992     { name9, data9, sizeof data9 },
2993 };
2994
2995 #define NUM_TRANSFORM_TABLES (sizeof table_transform_data/sizeof table_transform_data[0])
2996
2997 static void generate_transform_manual(void)
2998 {
2999     IStorage *stg = NULL;
3000     IStream *stm;
3001     WCHAR name[0x20];
3002     HRESULT r;
3003     DWORD i, count;
3004     const DWORD mode = STGM_CREATE|STGM_READWRITE|STGM_DIRECT|STGM_SHARE_EXCLUSIVE;
3005
3006     const CLSID CLSID_MsiTransform = { 0xc1082,0,0,{0xc0,0,0,0,0,0,0,0x46}};
3007
3008     MultiByteToWideChar(CP_ACP, 0, mstfile, -1, name, 0x20);
3009
3010     r = StgCreateDocfile(name, mode, 0, &stg);
3011     ok(r == S_OK, "failed to create storage\n");
3012     if (!stg)
3013         return;
3014
3015     r = IStorage_SetClass( stg, &CLSID_MsiTransform );
3016     ok(r == S_OK, "failed to set storage type\n");
3017
3018     for (i=0; i<NUM_TRANSFORM_TABLES; i++)
3019     {
3020         r = IStorage_CreateStream( stg, table_transform_data[i].name,
3021                             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
3022         if (FAILED(r))
3023         {
3024             ok(0, "failed to create stream %08x\n", r);
3025             continue;
3026         }
3027
3028         r = IStream_Write( stm, table_transform_data[i].data,
3029                           table_transform_data[i].size, &count );
3030         if (FAILED(r) || count != table_transform_data[i].size)
3031             ok(0, "failed to write stream\n");
3032         IStream_Release(stm);
3033     }
3034
3035     IStorage_Release(stg);
3036 }
3037
3038 static UINT set_summary_info(MSIHANDLE hdb)
3039 {
3040     UINT res;
3041     MSIHANDLE suminfo;
3042
3043     /* build summary info */
3044     res = MsiGetSummaryInformationA(hdb, NULL, 7, &suminfo);
3045     ok( res == ERROR_SUCCESS , "Failed to open summaryinfo\n" );
3046
3047     res = MsiSummaryInfoSetPropertyA(suminfo,2, VT_LPSTR, 0,NULL,
3048                         "Installation Database");
3049     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3050
3051     res = MsiSummaryInfoSetPropertyA(suminfo,3, VT_LPSTR, 0,NULL,
3052                         "Installation Database");
3053     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3054
3055     res = MsiSummaryInfoSetPropertyA(suminfo,4, VT_LPSTR, 0,NULL,
3056                         "Wine Hackers");
3057     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3058
3059     res = MsiSummaryInfoSetPropertyA(suminfo,7, VT_LPSTR, 0,NULL,
3060                     ";1033,2057");
3061     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3062
3063     res = MsiSummaryInfoSetPropertyA(suminfo,9, VT_LPSTR, 0,NULL,
3064                     "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}");
3065     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3066
3067     res = MsiSummaryInfoSetPropertyA(suminfo, 14, VT_I4, 100, NULL, NULL);
3068     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3069
3070     res = MsiSummaryInfoSetPropertyA(suminfo, 15, VT_I4, 0, NULL, NULL);
3071     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3072
3073     res = MsiSummaryInfoPersist(suminfo);
3074     ok( res == ERROR_SUCCESS , "Failed to make summary info persist\n" );
3075
3076     res = MsiCloseHandle( suminfo);
3077     ok( res == ERROR_SUCCESS , "Failed to close suminfo\n" );
3078
3079     return res;
3080 }
3081
3082 static MSIHANDLE create_package_db(const WCHAR *filename)
3083 {
3084     MSIHANDLE hdb = 0;
3085     UINT res;
3086
3087     DeleteFileW(msifileW);
3088
3089     /* create an empty database */
3090     res = MsiOpenDatabaseW(filename, MSIDBOPEN_CREATE, &hdb );
3091     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
3092     if( res != ERROR_SUCCESS )
3093         return hdb;
3094
3095     res = MsiDatabaseCommit( hdb );
3096     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
3097
3098     res = set_summary_info(hdb);
3099     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3100
3101     res = create_directory_table(hdb);
3102     ok( res == ERROR_SUCCESS , "Failed to create directory table\n" );
3103
3104     return hdb;
3105 }
3106
3107 static UINT package_from_db(MSIHANDLE hdb, MSIHANDLE *handle)
3108 {
3109     UINT res;
3110     CHAR szPackage[12];
3111     MSIHANDLE hPackage;
3112
3113     sprintf(szPackage, "#%u", hdb);
3114     res = MsiOpenPackageA(szPackage, &hPackage);
3115     if (res != ERROR_SUCCESS)
3116         return res;
3117
3118     res = MsiCloseHandle(hdb);
3119     if (res != ERROR_SUCCESS)
3120     {
3121         MsiCloseHandle(hPackage);
3122         return res;
3123     }
3124
3125     *handle = hPackage;
3126     return ERROR_SUCCESS;
3127 }
3128
3129 static void test_try_transform(void)
3130 {
3131     MSIHANDLE hdb, hview, hrec, hpkg = 0;
3132     LPCSTR query;
3133     UINT r;
3134     DWORD sz;
3135     char buffer[MAX_PATH];
3136
3137     DeleteFileA(msifile);
3138     DeleteFileA(mstfile);
3139
3140     /* create the database */
3141     hdb = create_package_db(msifileW);
3142     ok(hdb, "Failed to create package db\n");
3143
3144     query = "CREATE TABLE `MOO` ( `NOO` SHORT NOT NULL, `OOO` CHAR(255) PRIMARY KEY `NOO`)";
3145     r = run_query(hdb, 0, query);
3146     ok(r == ERROR_SUCCESS, "failed to add table\n");
3147
3148     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 1, 'a' )";
3149     r = run_query(hdb, 0, query);
3150     ok(r == ERROR_SUCCESS, "failed to add row\n");
3151
3152     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 2, 'b' )";
3153     r = run_query(hdb, 0, query);
3154     ok(r == ERROR_SUCCESS, "failed to add row\n");
3155
3156     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 3, 'c' )";
3157     r = run_query(hdb, 0, query);
3158     ok(r == ERROR_SUCCESS, "failed to add row\n");
3159
3160     query = "CREATE TABLE `BINARY` ( `ID` SHORT NOT NULL, `BLOB` OBJECT PRIMARY KEY `ID`)";
3161     r = run_query(hdb, 0, query);
3162     ok(r == ERROR_SUCCESS, "failed to add table\n");
3163
3164     hrec = MsiCreateRecord(2);
3165     r = MsiRecordSetInteger(hrec, 1, 2);
3166     ok(r == ERROR_SUCCESS, "failed to set integer\n");
3167
3168     write_file("testdata.bin", "lamyon", 6);
3169     r = MsiRecordSetStreamA(hrec, 2, "testdata.bin");
3170     ok(r == ERROR_SUCCESS, "failed to set stream\n");
3171
3172     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
3173     r = run_query(hdb, hrec, query);
3174     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
3175
3176     MsiCloseHandle(hrec);
3177
3178     r = MsiDatabaseCommit( hdb );
3179     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
3180
3181     MsiCloseHandle( hdb );
3182     DeleteFileA("testdata.bin");
3183
3184     /*
3185      * Both these generate an equivalent transform,
3186      *  but the first doesn't work in Wine yet
3187      *  because MsiDatabaseGenerateTransform is unimplemented.
3188      */
3189     if (0)
3190         generate_transform();
3191     else
3192         generate_transform_manual();
3193
3194     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_DIRECT, &hdb );
3195     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
3196
3197     r = MsiDatabaseApplyTransformA( hdb, mstfile, 0 );
3198     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
3199
3200     r = MsiDatabaseCommit( hdb );
3201     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
3202
3203     /* check new values */
3204     hrec = 0;
3205     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 1 AND `CAR` = 'vw'";
3206     r = do_query(hdb, query, &hrec);
3207     ok(r == ERROR_SUCCESS, "select query failed\n");
3208     MsiCloseHandle(hrec);
3209
3210     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 2 AND `CAR` = 'bmw'";
3211     hrec = 0;
3212     r = do_query(hdb, query, &hrec);
3213     ok(r == ERROR_SUCCESS, "select query failed\n");
3214     MsiCloseHandle(hrec);
3215
3216     /* check updated values */
3217     hrec = 0;
3218     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 1 AND `OOO` = 'c'";
3219     r = do_query(hdb, query, &hrec);
3220     ok(r == ERROR_SUCCESS, "select query failed\n");
3221     MsiCloseHandle(hrec);
3222
3223     /* check unchanged value */
3224     hrec = 0;
3225     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 2 AND `OOO` = 'b'";
3226     r = do_query(hdb, query, &hrec);
3227     ok(r == ERROR_SUCCESS, "select query failed\n");
3228     MsiCloseHandle(hrec);
3229
3230     /* check deleted value */
3231     hrec = 0;
3232     query = "select * from `MOO` where `NOO` = 3";
3233     r = do_query(hdb, query, &hrec);
3234     ok(r == ERROR_NO_MORE_ITEMS, "select query failed\n");
3235     if (hrec) MsiCloseHandle(hrec);
3236
3237     /* check added stream */
3238     hrec = 0;
3239     query = "select `BLOB` from `BINARY` where `ID` = 1";
3240     r = do_query(hdb, query, &hrec);
3241     ok(r == ERROR_SUCCESS, "select query failed\n");
3242
3243     /* check the contents of the stream */
3244     sz = sizeof buffer;
3245     r = MsiRecordReadStream( hrec, 1, buffer, &sz );
3246     ok(r == ERROR_SUCCESS, "read stream failed\n");
3247     ok(!memcmp(buffer, "naengmyon", 9), "stream data was wrong\n");
3248     ok(sz == 9, "stream data was wrong size\n");
3249     if (hrec) MsiCloseHandle(hrec);
3250
3251     /* check the validity of the table with a deleted row */
3252     hrec = 0;
3253     query = "select * from `MOO`";
3254     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3255     ok(r == ERROR_SUCCESS, "open view failed\n");
3256
3257     r = MsiViewExecute(hview, 0);
3258     ok(r == ERROR_SUCCESS, "view execute failed\n");
3259
3260     r = MsiViewFetch(hview, &hrec);
3261     ok(r == ERROR_SUCCESS, "view fetch failed\n");
3262
3263     r = MsiRecordGetInteger(hrec, 1);
3264     ok(r == 1, "Expected 1, got %d\n", r);
3265
3266     sz = sizeof buffer;
3267     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
3268     ok(r == ERROR_SUCCESS, "record get string failed\n");
3269     ok(!lstrcmpA(buffer, "c"), "Expected c, got %s\n", buffer);
3270
3271     r = MsiRecordGetInteger(hrec, 3);
3272     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3273
3274     r = MsiRecordGetInteger(hrec, 4);
3275     ok(r == 5, "Expected 5, got %d\n", r);
3276
3277     MsiCloseHandle(hrec);
3278
3279     r = MsiViewFetch(hview, &hrec);
3280     ok(r == ERROR_SUCCESS, "view fetch failed\n");
3281
3282     r = MsiRecordGetInteger(hrec, 1);
3283     ok(r == 2, "Expected 2, got %d\n", r);
3284
3285     sz = sizeof buffer;
3286     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
3287     ok(r == ERROR_SUCCESS, "record get string failed\n");
3288     ok(!lstrcmpA(buffer, "b"), "Expected b, got %s\n", buffer);
3289
3290     r = MsiRecordGetInteger(hrec, 3);
3291     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3292
3293     r = MsiRecordGetInteger(hrec, 4);
3294     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3295
3296     MsiCloseHandle(hrec);
3297
3298     r = MsiViewFetch(hview, &hrec);
3299     ok(r == ERROR_NO_MORE_ITEMS, "view fetch succeeded\n");
3300
3301     MsiCloseHandle(hrec);
3302     MsiViewClose(hview);
3303     MsiCloseHandle(hview);
3304
3305     /* check that the property was added */
3306     r = package_from_db(hdb, &hpkg);
3307     if (r == ERROR_INSTALL_PACKAGE_REJECTED)
3308     {
3309         skip("Not enough rights to perform tests\n");
3310         goto error;
3311     }
3312     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
3313
3314     sz = MAX_PATH;
3315     r = MsiGetPropertyA(hpkg, "prop", buffer, &sz);
3316     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3317     ok(!lstrcmpA(buffer, "val"), "Expected val, got %s\n", buffer);
3318
3319     MsiCloseHandle(hpkg);
3320
3321 error:
3322     MsiCloseHandle(hdb);
3323     DeleteFileA(msifile);
3324     DeleteFileA(mstfile);
3325 }
3326
3327 struct join_res
3328 {
3329     const CHAR one[MAX_PATH];
3330     const CHAR two[MAX_PATH];
3331 };
3332
3333 struct join_res_4col
3334 {
3335     const CHAR one[MAX_PATH];
3336     const CHAR two[MAX_PATH];
3337     const CHAR three[MAX_PATH];
3338     const CHAR four[MAX_PATH];
3339 };
3340
3341 struct join_res_uint
3342 {
3343     UINT one;
3344     UINT two;
3345     UINT three;
3346     UINT four;
3347     UINT five;
3348     UINT six;
3349 };
3350
3351 static const struct join_res join_res_first[] =
3352 {
3353     { "alveolar", "procerus" },
3354     { "septum", "procerus" },
3355     { "septum", "nasalis" },
3356     { "ramus", "nasalis" },
3357     { "malar", "mentalis" },
3358 };
3359
3360 static const struct join_res join_res_second[] =
3361 {
3362     { "nasal", "septum" },
3363     { "mandible", "ramus" },
3364 };
3365
3366 static const struct join_res join_res_third[] =
3367 {
3368     { "msvcp.dll", "abcdefgh" },
3369     { "msvcr.dll", "ijklmnop" },
3370 };
3371
3372 static const struct join_res join_res_fourth[] =
3373 {
3374     { "msvcp.dll.01234", "single.dll.31415" },
3375 };
3376
3377 static const struct join_res join_res_fifth[] =
3378 {
3379     { "malar", "procerus" },
3380 };
3381
3382 static const struct join_res join_res_sixth[] =
3383 {
3384     { "malar", "procerus" },
3385     { "malar", "procerus" },
3386     { "malar", "nasalis" },
3387     { "malar", "nasalis" },
3388     { "malar", "nasalis" },
3389     { "malar", "mentalis" },
3390 };
3391
3392 static const struct join_res join_res_seventh[] =
3393 {
3394     { "malar", "nasalis" },
3395     { "malar", "nasalis" },
3396     { "malar", "nasalis" },
3397 };
3398
3399 static const struct join_res_4col join_res_eighth[] =
3400 {
3401     { "msvcp.dll", "msvcp.dll.01234", "msvcp.dll.01234", "abcdefgh" },
3402     { "msvcr.dll", "msvcr.dll.56789", "msvcp.dll.01234", "abcdefgh" },
3403     { "msvcp.dll", "msvcp.dll.01234", "msvcr.dll.56789", "ijklmnop" },
3404     { "msvcr.dll", "msvcr.dll.56789", "msvcr.dll.56789", "ijklmnop" },
3405     { "msvcp.dll", "msvcp.dll.01234", "single.dll.31415", "msvcp.dll" },
3406     { "msvcr.dll", "msvcr.dll.56789", "single.dll.31415", "msvcp.dll" },
3407 };
3408
3409 static const struct join_res_uint join_res_ninth[] =
3410 {
3411     { 1, 2, 3, 4, 7, 8 },
3412     { 1, 2, 5, 6, 7, 8 },
3413     { 1, 2, 3, 4, 9, 10 },
3414     { 1, 2, 5, 6, 9, 10 },
3415     { 1, 2, 3, 4, 11, 12 },
3416     { 1, 2, 5, 6, 11, 12 },
3417 };
3418
3419 static void test_join(void)
3420 {
3421     MSIHANDLE hdb, hview, hrec;
3422     LPCSTR query;
3423     CHAR buf[MAX_PATH];
3424     UINT r, count;
3425     DWORD size, i;
3426     BOOL data_correct;
3427
3428     hdb = create_db();
3429     ok( hdb, "failed to create db\n");
3430
3431     r = create_component_table( hdb );
3432     ok( r == ERROR_SUCCESS, "cannot create Component table: %d\n", r );
3433
3434     r = add_component_entry( hdb, "'zygomatic', 'malar', 'INSTALLDIR', 0, '', ''" );
3435     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3436
3437     r = add_component_entry( hdb, "'maxilla', 'alveolar', 'INSTALLDIR', 0, '', ''" );
3438     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3439
3440     r = add_component_entry( hdb, "'nasal', 'septum', 'INSTALLDIR', 0, '', ''" );
3441     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3442
3443     r = add_component_entry( hdb, "'mandible', 'ramus', 'INSTALLDIR', 0, '', ''" );
3444     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3445
3446     r = create_feature_components_table( hdb );
3447     ok( r == ERROR_SUCCESS, "cannot create FeatureComponents table: %d\n", r );
3448
3449     r = add_feature_components_entry( hdb, "'procerus', 'maxilla'" );
3450     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3451
3452     r = add_feature_components_entry( hdb, "'procerus', 'nasal'" );
3453     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3454
3455     r = add_feature_components_entry( hdb, "'nasalis', 'nasal'" );
3456     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3457
3458     r = add_feature_components_entry( hdb, "'nasalis', 'mandible'" );
3459     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3460
3461     r = add_feature_components_entry( hdb, "'nasalis', 'notacomponent'" );
3462     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3463
3464     r = add_feature_components_entry( hdb, "'mentalis', 'zygomatic'" );
3465     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3466
3467     r = create_std_dlls_table( hdb );
3468     ok( r == ERROR_SUCCESS, "cannot create StdDlls table: %d\n", r );
3469
3470     r = add_std_dlls_entry( hdb, "'msvcp.dll', 'msvcp.dll.01234'" );
3471     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
3472
3473     r = add_std_dlls_entry( hdb, "'msvcr.dll', 'msvcr.dll.56789'" );
3474     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
3475
3476     r = create_binary_table( hdb );
3477     ok( r == ERROR_SUCCESS, "cannot create Binary table: %d\n", r );
3478
3479     r = add_binary_entry( hdb, "'msvcp.dll.01234', 'abcdefgh'" );
3480     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3481
3482     r = add_binary_entry( hdb, "'msvcr.dll.56789', 'ijklmnop'" );
3483     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3484
3485     r = add_binary_entry( hdb, "'single.dll.31415', 'msvcp.dll'" );
3486     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3487
3488     query = "CREATE TABLE `One` (`A` SHORT, `B` SHORT PRIMARY KEY `A`)";
3489     r = run_query( hdb, 0, query);
3490     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3491
3492     query = "CREATE TABLE `Two` (`C` SHORT, `D` SHORT PRIMARY KEY `C`)";
3493     r = run_query( hdb, 0, query);
3494     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3495
3496     query = "CREATE TABLE `Three` (`E` SHORT, `F` SHORT PRIMARY KEY `E`)";
3497     r = run_query( hdb, 0, query);
3498     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3499
3500     query = "INSERT INTO `One` (`A`, `B`) VALUES (1, 2)";
3501     r = run_query( hdb, 0, query);
3502     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3503
3504     query = "INSERT INTO `Two` (`C`, `D`) VALUES (3, 4)";
3505     r = run_query( hdb, 0, query);
3506     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3507
3508     query = "INSERT INTO `Two` (`C`, `D`) VALUES (5, 6)";
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 (7, 8)";
3513     r = run_query( hdb, 0, query);
3514     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3515
3516     query = "INSERT INTO `Three` (`E`, `F`) VALUES (9, 10)";
3517     r = run_query( hdb, 0, query);
3518     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3519
3520     query = "INSERT INTO `Three` (`E`, `F`) VALUES (11, 12)";
3521     r = run_query( hdb, 0, query);
3522     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3523
3524     query = "CREATE TABLE `Four` (`G` SHORT, `H` SHORT PRIMARY KEY `G`)";
3525     r = run_query( hdb, 0, query);
3526     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3527
3528     query = "CREATE TABLE `Five` (`I` SHORT, `J` SHORT PRIMARY KEY `I`)";
3529     r = run_query( hdb, 0, query);
3530     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3531
3532     query = "INSERT INTO `Five` (`I`, `J`) VALUES (13, 14)";
3533     r = run_query( hdb, 0, query);
3534     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3535
3536     query = "INSERT INTO `Five` (`I`, `J`) VALUES (15, 16)";
3537     r = run_query( hdb, 0, query);
3538     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3539
3540     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3541             "FROM `Component`, `FeatureComponents` "
3542             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
3543             "ORDER BY `Feature_`";
3544     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3545     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3546
3547     r = MsiViewExecute(hview, 0);
3548     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3549
3550     i = 0;
3551     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3552     {
3553         count = MsiRecordGetFieldCount( hrec );
3554         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3555
3556         size = MAX_PATH;
3557         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3558         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3559         ok( !lstrcmpA( buf, join_res_first[i].one ),
3560             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_first[i].one, buf );
3561
3562         size = MAX_PATH;
3563         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3564         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3565         ok( !lstrcmpA( buf, join_res_first[i].two ),
3566             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_first[i].two, buf );
3567
3568         i++;
3569         MsiCloseHandle(hrec);
3570     }
3571
3572     ok( i == 5, "Expected 5 rows, got %d\n", i );
3573     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3574
3575     MsiViewClose(hview);
3576     MsiCloseHandle(hview);
3577
3578     /* try a join without a WHERE condition */
3579     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3580             "FROM `Component`, `FeatureComponents` ";
3581     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3582     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3583
3584     r = MsiViewExecute(hview, 0);
3585     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3586
3587     i = 0;
3588     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3589     {
3590         i++;
3591         MsiCloseHandle(hrec);
3592     }
3593     ok( i == 24, "Expected 24 rows, got %d\n", i );
3594
3595     MsiViewClose(hview);
3596     MsiCloseHandle(hview);
3597
3598     query = "SELECT DISTINCT Component, ComponentId FROM FeatureComponents, Component "
3599             "WHERE FeatureComponents.Component_=Component.Component "
3600             "AND (Feature_='nasalis') ORDER BY Feature_";
3601     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3602     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3603
3604     r = MsiViewExecute(hview, 0);
3605     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3606
3607     i = 0;
3608     data_correct = TRUE;
3609     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3610     {
3611         count = MsiRecordGetFieldCount( hrec );
3612         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3613
3614         size = MAX_PATH;
3615         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3616         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3617         if( lstrcmpA( buf, join_res_second[i].one ))
3618             data_correct = FALSE;
3619
3620         size = MAX_PATH;
3621         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3622         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3623         if( lstrcmpA( buf, join_res_second[i].two ))
3624             data_correct = FALSE;
3625
3626         i++;
3627         MsiCloseHandle(hrec);
3628     }
3629
3630     ok( data_correct, "data returned in the wrong order\n");
3631
3632     ok( i == 2, "Expected 2 rows, got %d\n", i );
3633     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3634
3635     MsiViewClose(hview);
3636     MsiCloseHandle(hview);
3637
3638     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
3639             "FROM `StdDlls`, `Binary` "
3640             "WHERE `StdDlls`.`Binary_` = `Binary`.`Name` "
3641             "ORDER BY `File`";
3642     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3643     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3644
3645     r = MsiViewExecute(hview, 0);
3646     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3647
3648     i = 0;
3649     data_correct = TRUE;
3650     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3651     {
3652         count = MsiRecordGetFieldCount( hrec );
3653         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3654
3655         size = MAX_PATH;
3656         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3657         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3658         if( lstrcmpA( buf, join_res_third[i].one ) )
3659             data_correct = FALSE;
3660
3661         size = MAX_PATH;
3662         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3663         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3664         if( lstrcmpA( buf, join_res_third[i].two ) )
3665             data_correct = FALSE;
3666
3667         i++;
3668         MsiCloseHandle(hrec);
3669     }
3670     ok( data_correct, "data returned in the wrong order\n");
3671
3672     ok( i == 2, "Expected 2 rows, got %d\n", i );
3673
3674     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3675
3676     MsiViewClose(hview);
3677     MsiCloseHandle(hview);
3678
3679     query = "SELECT `StdDlls`.`Binary_`, `Binary`.`Name` "
3680             "FROM `StdDlls`, `Binary` "
3681             "WHERE `StdDlls`.`File` = `Binary`.`Data` "
3682             "ORDER BY `Name`";
3683     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3684     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3685
3686     r = MsiViewExecute(hview, 0);
3687     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3688
3689     i = 0;
3690     data_correct = TRUE;
3691     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3692     {
3693         count = MsiRecordGetFieldCount( hrec );
3694         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3695
3696         size = MAX_PATH;
3697         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3698         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3699         if( lstrcmpA( buf, join_res_fourth[i].one ))
3700             data_correct = FALSE;
3701
3702         size = MAX_PATH;
3703         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3704         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3705         if( lstrcmpA( buf, join_res_fourth[i].two ))
3706             data_correct = FALSE;
3707
3708         i++;
3709         MsiCloseHandle(hrec);
3710     }
3711     ok( data_correct, "data returned in the wrong order\n");
3712
3713     ok( i == 1, "Expected 1 rows, got %d\n", i );
3714     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3715
3716     MsiViewClose(hview);
3717     MsiCloseHandle(hview);
3718
3719     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3720             "FROM `Component`, `FeatureComponents` "
3721             "WHERE `Component`.`Component` = 'zygomatic' "
3722             "AND `FeatureComponents`.`Component_` = 'maxilla' "
3723             "ORDER BY `Feature_`";
3724     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3725     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3726
3727     r = MsiViewExecute(hview, 0);
3728     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3729
3730     i = 0;
3731     data_correct = TRUE;
3732     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3733     {
3734         count = MsiRecordGetFieldCount( hrec );
3735         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3736
3737         size = MAX_PATH;
3738         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3739         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3740         if( lstrcmpA( buf, join_res_fifth[i].one ))
3741             data_correct = FALSE;
3742
3743         size = MAX_PATH;
3744         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3745         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3746         if( lstrcmpA( buf, join_res_fifth[i].two ))
3747             data_correct = FALSE;
3748
3749         i++;
3750         MsiCloseHandle(hrec);
3751     }
3752     ok( data_correct, "data returned in the wrong order\n");
3753
3754     ok( i == 1, "Expected 1 rows, got %d\n", i );
3755     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3756
3757     MsiViewClose(hview);
3758     MsiCloseHandle(hview);
3759
3760     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3761             "FROM `Component`, `FeatureComponents` "
3762             "WHERE `Component` = 'zygomatic' "
3763             "ORDER BY `Feature_`";
3764     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3765     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3766
3767     r = MsiViewExecute(hview, 0);
3768     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3769
3770     i = 0;
3771     data_correct = TRUE;
3772     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3773     {
3774         count = MsiRecordGetFieldCount( hrec );
3775         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3776
3777         size = MAX_PATH;
3778         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3779         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3780         if( lstrcmpA( buf, join_res_sixth[i].one ))
3781             data_correct = FALSE;
3782
3783         size = MAX_PATH;
3784         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3785         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3786         if( lstrcmpA( buf, join_res_sixth[i].two ))
3787             data_correct = FALSE;
3788
3789         i++;
3790         MsiCloseHandle(hrec);
3791     }
3792     ok( data_correct, "data returned in the wrong order\n");
3793
3794     ok( i == 6, "Expected 6 rows, got %d\n", i );
3795     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3796
3797     MsiViewClose(hview);
3798     MsiCloseHandle(hview);
3799
3800     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3801             "FROM `Component`, `FeatureComponents` "
3802             "WHERE `Component` = 'zygomatic' "
3803             "AND `Feature_` = 'nasalis' "
3804             "ORDER BY `Feature_`";
3805     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3806     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3807
3808     r = MsiViewExecute(hview, 0);
3809     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3810
3811     i = 0;
3812     data_correct = TRUE;
3813     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3814     {
3815         count = MsiRecordGetFieldCount( hrec );
3816         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3817
3818         size = MAX_PATH;
3819         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3820         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3821         if( lstrcmpA( buf, join_res_seventh[i].one ))
3822             data_correct = FALSE;
3823
3824         size = MAX_PATH;
3825         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3826         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3827         if( lstrcmpA( buf, join_res_seventh[i].two ))
3828             data_correct = FALSE;
3829
3830         i++;
3831         MsiCloseHandle(hrec);
3832     }
3833
3834     ok( data_correct, "data returned in the wrong order\n");
3835     ok( i == 3, "Expected 3 rows, got %d\n", i );
3836     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3837
3838     MsiViewClose(hview);
3839     MsiCloseHandle(hview);
3840
3841     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
3842             "FROM `StdDlls`, `Binary` ";
3843     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3844     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3845
3846     r = MsiViewExecute(hview, 0);
3847     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3848
3849     i = 0;
3850     data_correct = TRUE;
3851     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3852     {
3853         count = MsiRecordGetFieldCount( hrec );
3854         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3855
3856         size = MAX_PATH;
3857         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3858         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3859         if( lstrcmpA( buf, join_res_eighth[i].one ))
3860             data_correct = FALSE;
3861
3862         size = MAX_PATH;
3863         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3864         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3865         if( lstrcmpA( buf, join_res_eighth[i].four ))
3866             data_correct = FALSE;
3867
3868         i++;
3869         MsiCloseHandle(hrec);
3870     }
3871
3872     ok( data_correct, "data returned in the wrong order\n");
3873     ok( i == 6, "Expected 6 rows, got %d\n", i );
3874     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3875
3876     MsiViewClose(hview);
3877     MsiCloseHandle(hview);
3878
3879     query = "SELECT * FROM `StdDlls`, `Binary` ";
3880     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3881     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3882
3883     r = MsiViewExecute(hview, 0);
3884     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3885
3886     i = 0;
3887     data_correct = TRUE;
3888     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3889     {
3890         count = MsiRecordGetFieldCount( hrec );
3891         ok( count == 4, "Expected 4 record fields, got %d\n", count );
3892
3893         size = MAX_PATH;
3894         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3895         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3896         if( lstrcmpA( buf, join_res_eighth[i].one ))
3897             data_correct = FALSE;
3898
3899         size = MAX_PATH;
3900         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3901         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3902         if( lstrcmpA( buf, join_res_eighth[i].two ))
3903             data_correct = FALSE;
3904
3905         size = MAX_PATH;
3906         r = MsiRecordGetStringA( hrec, 3, buf, &size );
3907         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3908         if( lstrcmpA( buf, join_res_eighth[i].three ))
3909             data_correct = FALSE;
3910
3911         size = MAX_PATH;
3912         r = MsiRecordGetStringA( hrec, 4, buf, &size );
3913         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3914         if( lstrcmpA( buf, join_res_eighth[i].four ))
3915             data_correct = FALSE;
3916
3917         i++;
3918         MsiCloseHandle(hrec);
3919     }
3920     ok( data_correct, "data returned in the wrong order\n");
3921
3922     ok( i == 6, "Expected 6 rows, got %d\n", i );
3923     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3924
3925     MsiViewClose(hview);
3926     MsiCloseHandle(hview);
3927
3928     query = "SELECT * FROM `One`, `Two`, `Three` ";
3929     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3930     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3931
3932     r = MsiViewExecute(hview, 0);
3933     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3934
3935     i = 0;
3936     data_correct = TRUE;
3937     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3938     {
3939         count = MsiRecordGetFieldCount( hrec );
3940         ok( count == 6, "Expected 6 record fields, got %d\n", count );
3941
3942         r = MsiRecordGetInteger( hrec, 1 );
3943         if( r != join_res_ninth[i].one )
3944             data_correct = FALSE;
3945
3946         r = MsiRecordGetInteger( hrec, 2 );
3947         if( r != join_res_ninth[i].two )
3948             data_correct = FALSE;
3949
3950         r = MsiRecordGetInteger( hrec, 3 );
3951         if( r != join_res_ninth[i].three )
3952             data_correct = FALSE;
3953
3954         r = MsiRecordGetInteger( hrec, 4 );
3955         if( r != join_res_ninth[i].four )
3956             data_correct = FALSE;
3957
3958         r = MsiRecordGetInteger( hrec, 5 );
3959         if( r != join_res_ninth[i].five )
3960             data_correct = FALSE;
3961
3962         r = MsiRecordGetInteger( hrec, 6);
3963         if( r != join_res_ninth[i].six )
3964             data_correct = FALSE;
3965
3966         i++;
3967         MsiCloseHandle(hrec);
3968     }
3969     ok( data_correct, "data returned in the wrong order\n");
3970
3971     ok( i == 6, "Expected 6 rows, got %d\n", i );
3972     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3973
3974     MsiViewClose(hview);
3975     MsiCloseHandle(hview);
3976
3977     query = "SELECT * FROM `Four`, `Five`";
3978     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3979     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3980
3981     r = MsiViewExecute(hview, 0);
3982     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3983
3984     r = MsiViewFetch(hview, &hrec);
3985     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3986
3987     MsiViewClose(hview);
3988     MsiCloseHandle(hview);
3989
3990     query = "SELECT * FROM `Nonexistent`, `One`";
3991     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3992     ok( r == ERROR_BAD_QUERY_SYNTAX,
3993         "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r );
3994
3995     /* try updating a row in a join table */
3996     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3997             "FROM `Component`, `FeatureComponents` "
3998             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
3999             "ORDER BY `Feature_`";
4000     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4001     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
4002
4003     r = MsiViewExecute(hview, 0);
4004     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
4005
4006     r = MsiViewFetch(hview, &hrec);
4007     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
4008
4009     r = MsiRecordSetStringA( hrec, 1, "epicranius" );
4010     ok( r == ERROR_SUCCESS, "failed to set string: %d\n", r );
4011
4012     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
4013     ok( r == ERROR_SUCCESS, "failed to update row: %d\n", r );
4014
4015     /* try another valid operation for joins */
4016     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
4017     todo_wine ok( r == ERROR_SUCCESS, "failed to refresh row: %d\n", r );
4018
4019     /* try an invalid operation for joins */
4020     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
4021     ok( r == ERROR_FUNCTION_FAILED, "unexpected result: %d\n", r );
4022
4023     r = MsiRecordSetStringA( hrec, 2, "epicranius" );
4024     ok( r == ERROR_SUCCESS, "failed to set string: %d\n", r );
4025
4026     /* primary key cannot be updated */
4027     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
4028     ok( r == ERROR_FUNCTION_FAILED, "failed to update row: %d\n", r );
4029
4030     MsiCloseHandle(hrec);
4031     MsiViewClose(hview);
4032     MsiCloseHandle(hview);
4033
4034     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4035     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4036
4037     r = MsiViewExecute(hview, 0);
4038     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4039
4040     r = MsiViewFetch(hview, &hrec);
4041     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4042
4043     size = MAX_PATH;
4044     r = MsiRecordGetStringA( hrec, 1, buf, &size );
4045     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
4046     ok( !lstrcmpA( buf, "epicranius" ), "expected 'epicranius', got %s\n", buf );
4047
4048     MsiCloseHandle(hrec);
4049     MsiViewClose(hview);
4050     MsiCloseHandle(hview);
4051
4052     MsiCloseHandle(hdb);
4053     DeleteFileA(msifile);
4054 }
4055
4056 static void test_temporary_table(void)
4057 {
4058     MSICONDITION cond;
4059     MSIHANDLE hdb = 0, view = 0, rec;
4060     const char *query;
4061     UINT r;
4062     char buf[0x10];
4063     DWORD sz;
4064
4065     cond = MsiDatabaseIsTablePersistentA(0, NULL);
4066     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
4067
4068     hdb = create_db();
4069     ok( hdb, "failed to create db\n");
4070
4071     cond = MsiDatabaseIsTablePersistentA(hdb, NULL);
4072     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
4073
4074     cond = MsiDatabaseIsTablePersistentA(hdb, "_Tables");
4075     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4076
4077     cond = MsiDatabaseIsTablePersistentA(hdb, "_Columns");
4078     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4079
4080     cond = MsiDatabaseIsTablePersistentA(hdb, "_Storages");
4081     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4082
4083     cond = MsiDatabaseIsTablePersistentA(hdb, "_Streams");
4084     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4085
4086     query = "CREATE TABLE `P` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`)";
4087     r = run_query(hdb, 0, query);
4088     ok(r == ERROR_SUCCESS, "failed to add table\n");
4089
4090     cond = MsiDatabaseIsTablePersistentA(hdb, "P");
4091     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
4092
4093     query = "CREATE TABLE `P2` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`) HOLD";
4094     r = run_query(hdb, 0, query);
4095     ok(r == ERROR_SUCCESS, "failed to add table\n");
4096
4097     cond = MsiDatabaseIsTablePersistentA(hdb, "P2");
4098     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
4099
4100     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
4101     r = run_query(hdb, 0, query);
4102     ok(r == ERROR_SUCCESS, "failed to add table\n");
4103
4104     cond = MsiDatabaseIsTablePersistentA(hdb, "T");
4105     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
4106
4107     query = "CREATE TABLE `T2` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
4108     r = run_query(hdb, 0, query);
4109     ok(r == ERROR_SUCCESS, "failed to add table\n");
4110
4111     query = "SELECT * FROM `T2`";
4112     r = MsiDatabaseOpenViewA(hdb, query, &view);
4113     ok(r == ERROR_BAD_QUERY_SYNTAX,
4114        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4115
4116     cond = MsiDatabaseIsTablePersistentA(hdb, "T2");
4117     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4118
4119     query = "CREATE TABLE `T3` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) PRIMARY KEY `C`)";
4120     r = run_query(hdb, 0, query);
4121     ok(r == ERROR_SUCCESS, "failed to add table\n");
4122
4123     cond = MsiDatabaseIsTablePersistentA(hdb, "T3");
4124     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
4125
4126     query = "CREATE TABLE `T4` ( `B` SHORT NOT NULL, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
4127     r = run_query(hdb, 0, query);
4128     ok(r == ERROR_FUNCTION_FAILED, "failed to add table\n");
4129
4130     cond = MsiDatabaseIsTablePersistentA(hdb, "T4");
4131     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4132
4133     query = "CREATE TABLE `T5` ( `B` SHORT NOT NULL TEMP, `C` CHAR(255) TEMP PRIMARY KEY `C`) HOLD";
4134     r = run_query(hdb, 0, query);
4135     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to add table\n");
4136
4137     query = "select * from `T`";
4138     r = MsiDatabaseOpenViewA(hdb, query, &view);
4139     ok(r == ERROR_SUCCESS, "failed to query table\n");
4140     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
4141     ok(r == ERROR_SUCCESS, "failed to get column info\n");
4142
4143     sz = sizeof buf;
4144     r = MsiRecordGetStringA(rec, 1, buf, &sz);
4145     ok(r == ERROR_SUCCESS, "failed to get string\n");
4146     ok( 0 == strcmp("G255", buf), "wrong column type\n");
4147
4148     sz = sizeof buf;
4149     r = MsiRecordGetStringA(rec, 2, buf, &sz);
4150     ok(r == ERROR_SUCCESS, "failed to get string\n");
4151     ok( 0 == strcmp("j2", buf), "wrong column type\n");
4152
4153     MsiCloseHandle( rec );
4154     MsiViewClose( view );
4155     MsiCloseHandle( view );
4156
4157     /* query the table data */
4158     rec = 0;
4159     r = do_query(hdb, "select * from `_Tables` where `Name` = 'T'", &rec);
4160     ok( r == ERROR_SUCCESS, "temporary table exists in _Tables\n");
4161     MsiCloseHandle( rec );
4162
4163     /* query the column data */
4164     rec = 0;
4165     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'B'", &rec);
4166     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
4167     if (rec) MsiCloseHandle( rec );
4168
4169     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'C'", &rec);
4170     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
4171     if (rec) MsiCloseHandle( rec );
4172
4173     MsiCloseHandle( hdb );
4174     DeleteFileA(msifile);
4175 }
4176
4177 static void test_alter(void)
4178 {
4179     MSICONDITION cond;
4180     MSIHANDLE hdb = 0;
4181     const char *query;
4182     UINT r;
4183
4184     hdb = create_db();
4185     ok( hdb, "failed to create db\n");
4186
4187     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
4188     r = run_query(hdb, 0, query);
4189     ok(r == ERROR_SUCCESS, "failed to add table\n");
4190
4191     cond = MsiDatabaseIsTablePersistentA(hdb, "T");
4192     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
4193
4194     query = "ALTER TABLE `T` HOLD";
4195     r = run_query(hdb, 0, query);
4196     ok(r == ERROR_SUCCESS, "failed to hold table %d\n", r);
4197
4198     query = "ALTER TABLE `T` FREE";
4199     r = run_query(hdb, 0, query);
4200     ok(r == ERROR_SUCCESS, "failed to free table\n");
4201
4202     query = "ALTER TABLE `T` FREE";
4203     r = run_query(hdb, 0, query);
4204     ok(r == ERROR_SUCCESS, "failed to free table\n");
4205
4206     query = "ALTER TABLE `T` FREE";
4207     r = run_query(hdb, 0, query);
4208     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to free table\n");
4209
4210     query = "ALTER TABLE `T` HOLD";
4211     r = run_query(hdb, 0, query);
4212     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to hold table %d\n", r);
4213
4214     /* table T is removed */
4215     query = "SELECT * FROM `T`";
4216     r = run_query(hdb, 0, query);
4217     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4218
4219     /* create the table again */
4220     query = "CREATE TABLE `U` ( `A` INTEGER, `B` INTEGER PRIMARY KEY `B`)";
4221     r = run_query(hdb, 0, query);
4222     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4223
4224     /* up the ref count */
4225     query = "ALTER TABLE `U` HOLD";
4226     r = run_query(hdb, 0, query);
4227     ok(r == ERROR_SUCCESS, "failed to free table\n");
4228
4229     /* add column, no data type */
4230     query = "ALTER TABLE `U` ADD `C`";
4231     r = run_query(hdb, 0, query);
4232     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4233
4234     query = "ALTER TABLE `U` ADD `C` INTEGER";
4235     r = run_query(hdb, 0, query);
4236     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4237
4238     /* add column C again */
4239     query = "ALTER TABLE `U` ADD `C` INTEGER";
4240     r = run_query(hdb, 0, query);
4241     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4242
4243     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY";
4244     r = run_query(hdb, 0, query);
4245     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4246
4247     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 1, 2, 3, 4 )";
4248     r = run_query(hdb, 0, query);
4249     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4250
4251     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY HOLD";
4252     r = run_query(hdb, 0, query);
4253     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4254
4255     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 5, 6, 7, 8 )";
4256     r = run_query(hdb, 0, query);
4257     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4258
4259     query = "SELECT * FROM `U` WHERE `D` = 8";
4260     r = run_query(hdb, 0, query);
4261     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4262
4263     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY FREE";
4264     r = run_query(hdb, 0, query);
4265     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4266
4267     query = "ALTER COLUMN `D` FREE";
4268     r = run_query(hdb, 0, query);
4269     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4270
4271     /* drop the ref count */
4272     query = "ALTER TABLE `U` FREE";
4273     r = run_query(hdb, 0, query);
4274     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4275
4276     /* table is not empty */
4277     query = "SELECT * FROM `U`";
4278     r = run_query(hdb, 0, query);
4279     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4280
4281     /* column D is removed */
4282     query = "SELECT * FROM `U` WHERE `D` = 8";
4283     r = run_query(hdb, 0, query);
4284     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4285
4286     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 9, 10, 11, 12 )";
4287     r = run_query(hdb, 0, query);
4288     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4289
4290     /* add the column again */
4291     query = "ALTER TABLE `U` ADD `E` INTEGER TEMPORARY HOLD";
4292     r = run_query(hdb, 0, query);
4293     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4294
4295     /* up the ref count */
4296     query = "ALTER TABLE `U` HOLD";
4297     r = run_query(hdb, 0, query);
4298     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4299
4300     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 13, 14, 15, 16 )";
4301     r = run_query(hdb, 0, query);
4302     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4303
4304     query = "SELECT * FROM `U` WHERE `E` = 16";
4305     r = run_query(hdb, 0, query);
4306     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4307
4308     /* drop the ref count */
4309     query = "ALTER TABLE `U` FREE";
4310     r = run_query(hdb, 0, query);
4311     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4312
4313     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 17, 18, 19, 20 )";
4314     r = run_query(hdb, 0, query);
4315     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4316
4317     query = "SELECT * FROM `U` WHERE `E` = 20";
4318     r = run_query(hdb, 0, query);
4319     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4320
4321     /* drop the ref count */
4322     query = "ALTER TABLE `U` FREE";
4323     r = run_query(hdb, 0, query);
4324     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4325
4326     /* table still exists */
4327     query = "SELECT * FROM `U`";
4328     r = run_query(hdb, 0, query);
4329     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4330
4331     /* col E is removed */
4332     query = "SELECT * FROM `U` WHERE `E` = 20";
4333     r = run_query(hdb, 0, query);
4334     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4335
4336     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 20, 21, 22, 23 )";
4337     r = run_query(hdb, 0, query);
4338     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4339
4340     /* drop the ref count once more */
4341     query = "ALTER TABLE `U` FREE";
4342     r = run_query(hdb, 0, query);
4343     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4344
4345     /* table still exists */
4346     query = "SELECT * FROM `U`";
4347     r = run_query(hdb, 0, query);
4348     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4349
4350     MsiCloseHandle( hdb );
4351     DeleteFileA(msifile);
4352 }
4353
4354 static void test_integers(void)
4355 {
4356     MSIHANDLE hdb = 0, view = 0, rec = 0;
4357     DWORD count, i;
4358     const char *query;
4359     UINT r;
4360
4361     /* just MsiOpenDatabase should not create a file */
4362     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4363     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4364
4365     /* create a table */
4366     query = "CREATE TABLE `integers` ( "
4367             "`one` SHORT, `two` INT, `three` INTEGER, `four` LONG, "
4368             "`five` SHORT NOT NULL, `six` INT NOT NULL, "
4369             "`seven` INTEGER NOT NULL, `eight` LONG NOT NULL "
4370             "PRIMARY KEY `one`)";
4371     r = MsiDatabaseOpenViewA(hdb, query, &view);
4372     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4373     r = MsiViewExecute(view, 0);
4374     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4375     r = MsiViewClose(view);
4376     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4377     r = MsiCloseHandle(view);
4378     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4379
4380     query = "SELECT * FROM `integers`";
4381     r = MsiDatabaseOpenViewA(hdb, query, &view);
4382     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4383
4384     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
4385     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4386     count = MsiRecordGetFieldCount(rec);
4387     ok(count == 8, "Expected 8, got %d\n", count);
4388     ok(check_record(rec, 1, "one"), "Expected one\n");
4389     ok(check_record(rec, 2, "two"), "Expected two\n");
4390     ok(check_record(rec, 3, "three"), "Expected three\n");
4391     ok(check_record(rec, 4, "four"), "Expected four\n");
4392     ok(check_record(rec, 5, "five"), "Expected five\n");
4393     ok(check_record(rec, 6, "six"), "Expected six\n");
4394     ok(check_record(rec, 7, "seven"), "Expected seven\n");
4395     ok(check_record(rec, 8, "eight"), "Expected eight\n");
4396     MsiCloseHandle(rec);
4397
4398     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
4399     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4400     count = MsiRecordGetFieldCount(rec);
4401     ok(count == 8, "Expected 8, got %d\n", count);
4402     ok(check_record(rec, 1, "I2"), "Expected I2\n");
4403     ok(check_record(rec, 2, "I2"), "Expected I2\n");
4404     ok(check_record(rec, 3, "I2"), "Expected I2\n");
4405     ok(check_record(rec, 4, "I4"), "Expected I4\n");
4406     ok(check_record(rec, 5, "i2"), "Expected i2\n");
4407     ok(check_record(rec, 6, "i2"), "Expected i2\n");
4408     ok(check_record(rec, 7, "i2"), "Expected i2\n");
4409     ok(check_record(rec, 8, "i4"), "Expected i4\n");
4410     MsiCloseHandle(rec);
4411
4412     MsiViewClose(view);
4413     MsiCloseHandle(view);
4414
4415     /* insert values into it, NULL where NOT NULL is specified */
4416     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
4417         "VALUES('', '', '', '', '', '', '', '')";
4418     r = MsiDatabaseOpenViewA(hdb, query, &view);
4419     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4420     r = MsiViewExecute(view, 0);
4421     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
4422
4423     MsiViewClose(view);
4424     MsiCloseHandle(view);
4425
4426     query = "SELECT * FROM `integers`";
4427     r = do_query(hdb, query, &rec);
4428     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4429
4430     r = MsiRecordGetFieldCount(rec);
4431     ok(r == -1, "record count wrong: %d\n", r);
4432
4433     MsiCloseHandle(rec);
4434
4435     /* insert legitimate values into it */
4436     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
4437         "VALUES('', '2', '', '4', '5', '6', '7', '8')";
4438     r = MsiDatabaseOpenViewA(hdb, query, &view);
4439     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4440     r = MsiViewExecute(view, 0);
4441     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4442
4443     query = "SELECT * FROM `integers`";
4444     r = do_query(hdb, query, &rec);
4445     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4446
4447     r = MsiRecordGetFieldCount(rec);
4448     ok(r == 8, "record count wrong: %d\n", r);
4449
4450     i = MsiRecordGetInteger(rec, 1);
4451     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
4452     i = MsiRecordGetInteger(rec, 3);
4453     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
4454     i = MsiRecordGetInteger(rec, 2);
4455     ok(i == 2, "Expected 2, got %d\n", i);
4456     i = MsiRecordGetInteger(rec, 4);
4457     ok(i == 4, "Expected 4, got %d\n", i);
4458     i = MsiRecordGetInteger(rec, 5);
4459     ok(i == 5, "Expected 5, got %d\n", i);
4460     i = MsiRecordGetInteger(rec, 6);
4461     ok(i == 6, "Expected 6, got %d\n", i);
4462     i = MsiRecordGetInteger(rec, 7);
4463     ok(i == 7, "Expected 7, got %d\n", i);
4464     i = MsiRecordGetInteger(rec, 8);
4465     ok(i == 8, "Expected 8, got %d\n", i);
4466
4467     MsiCloseHandle(rec);
4468     MsiViewClose(view);
4469     MsiCloseHandle(view);
4470
4471     r = MsiDatabaseCommit(hdb);
4472     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
4473
4474     r = MsiCloseHandle(hdb);
4475     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4476
4477     r = DeleteFileA(msifile);
4478     ok(r == TRUE, "file didn't exist after commit\n");
4479 }
4480
4481 static void test_update(void)
4482 {
4483     MSIHANDLE hdb = 0, view = 0, rec = 0;
4484     CHAR result[MAX_PATH];
4485     const char *query;
4486     DWORD size;
4487     UINT r;
4488
4489     /* just MsiOpenDatabase should not create a file */
4490     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4491     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4492
4493     /* create the Control table */
4494     query = "CREATE TABLE `Control` ( "
4495         "`Dialog_` CHAR(72) NOT NULL, `Control` CHAR(50) NOT NULL, `Type` SHORT NOT NULL, "
4496         "`X` SHORT NOT NULL, `Y` SHORT NOT NULL, `Width` SHORT NOT NULL, `Height` SHORT NOT NULL,"
4497         "`Attributes` LONG, `Property` CHAR(50), `Text` CHAR(0) LOCALIZABLE, "
4498         "`Control_Next` CHAR(50), `Help` CHAR(50) LOCALIZABLE PRIMARY KEY `Dialog_`, `Control`)";
4499     r = MsiDatabaseOpenViewA(hdb, query, &view);
4500     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4501     r = MsiViewExecute(view, 0);
4502     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4503     r = MsiViewClose(view);
4504     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4505     r = MsiCloseHandle(view);
4506     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4507
4508     /* add a control */
4509     query = "INSERT INTO `Control` ( "
4510         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4511         "`Property`, `Text`, `Control_Next`, `Help` )"
4512         "VALUES('ErrorDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
4513     r = MsiDatabaseOpenViewA(hdb, query, &view);
4514     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4515     r = MsiViewExecute(view, 0);
4516     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4517     r = MsiViewClose(view);
4518     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4519     r = MsiCloseHandle(view);
4520     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4521
4522     /* add a second control */
4523     query = "INSERT INTO `Control` ( "
4524         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4525         "`Property`, `Text`, `Control_Next`, `Help` )"
4526         "VALUES('ErrorDialog', 'Button', '1', '5', '5', '5', '5', '', '', '', '')";
4527     r = MsiDatabaseOpenViewA(hdb, query, &view);
4528     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4529     r = MsiViewExecute(view, 0);
4530     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4531     r = MsiViewClose(view);
4532     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4533     r = MsiCloseHandle(view);
4534     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4535
4536     /* add a third control */
4537     query = "INSERT INTO `Control` ( "
4538         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4539         "`Property`, `Text`, `Control_Next`, `Help` )"
4540         "VALUES('AnotherDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
4541     r = MsiDatabaseOpenViewA(hdb, query, &view);
4542     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4543     r = MsiViewExecute(view, 0);
4544     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4545     r = MsiViewClose(view);
4546     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4547     r = MsiCloseHandle(view);
4548     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4549
4550     /* bad table */
4551     query = "UPDATE `NotATable` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4552     r = MsiDatabaseOpenViewA(hdb, query, &view);
4553     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4554
4555     /* bad set column */
4556     query = "UPDATE `Control` SET `NotAColumn` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4557     r = MsiDatabaseOpenViewA(hdb, query, &view);
4558     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4559
4560     /* bad where condition */
4561     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `NotAColumn` = 'ErrorDialog'";
4562     r = MsiDatabaseOpenViewA(hdb, query, &view);
4563     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4564
4565     /* just the dialog_ specified */
4566     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4567     r = MsiDatabaseOpenViewA(hdb, query, &view);
4568     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4569     r = MsiViewExecute(view, 0);
4570     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4571     r = MsiViewClose(view);
4572     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4573     r = MsiCloseHandle(view);
4574     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4575
4576     /* check the modified text */
4577     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
4578     r = MsiDatabaseOpenViewA(hdb, query, &view);
4579     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4580     r = MsiViewExecute(view, 0);
4581     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4582
4583     r = MsiViewFetch(view, &rec);
4584     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4585
4586     size = MAX_PATH;
4587     r = MsiRecordGetStringA(rec, 1, result, &size);
4588     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4589     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4590
4591     MsiCloseHandle(rec);
4592
4593     r = MsiViewFetch(view, &rec);
4594     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4595
4596     size = MAX_PATH;
4597     r = MsiRecordGetStringA(rec, 1, result, &size);
4598     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4599     ok(!result[0], "Expected an empty string, got %s\n", result);
4600
4601     MsiCloseHandle(rec);
4602
4603     r = MsiViewFetch(view, &rec);
4604     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4605
4606     r = MsiViewClose(view);
4607     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4608     r = MsiCloseHandle(view);
4609     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4610
4611     /* dialog_ and control specified */
4612     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog' AND `Control` = 'ErrorText'";
4613     r = MsiDatabaseOpenViewA(hdb, query, &view);
4614     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4615     r = MsiViewExecute(view, 0);
4616     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4617     r = MsiViewClose(view);
4618     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4619     r = MsiCloseHandle(view);
4620     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4621
4622     /* check the modified text */
4623     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
4624     r = MsiDatabaseOpenViewA(hdb, query, &view);
4625     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4626     r = MsiViewExecute(view, 0);
4627     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4628
4629     r = MsiViewFetch(view, &rec);
4630     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4631
4632     size = MAX_PATH;
4633     r = MsiRecordGetStringA(rec, 1, result, &size);
4634     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4635     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4636
4637     MsiCloseHandle(rec);
4638
4639     r = MsiViewFetch(view, &rec);
4640     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4641
4642     size = MAX_PATH;
4643     r = MsiRecordGetStringA(rec, 1, result, &size);
4644     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4645     ok(!result[0], "Expected an empty string, got %s\n", result);
4646
4647     MsiCloseHandle(rec);
4648
4649     r = MsiViewFetch(view, &rec);
4650     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4651
4652     r = MsiViewClose(view);
4653     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4654     r = MsiCloseHandle(view);
4655     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4656
4657     /* no where condition */
4658     query = "UPDATE `Control` SET `Text` = 'this is text'";
4659     r = MsiDatabaseOpenViewA(hdb, query, &view);
4660     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4661     r = MsiViewExecute(view, 0);
4662     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4663     r = MsiViewClose(view);
4664     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4665     r = MsiCloseHandle(view);
4666     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4667
4668     /* check the modified text */
4669     query = "SELECT `Text` FROM `Control`";
4670     r = MsiDatabaseOpenViewA(hdb, query, &view);
4671     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4672     r = MsiViewExecute(view, 0);
4673     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4674
4675     r = MsiViewFetch(view, &rec);
4676     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4677
4678     size = MAX_PATH;
4679     r = MsiRecordGetStringA(rec, 1, result, &size);
4680     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4681     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4682
4683     MsiCloseHandle(rec);
4684
4685     r = MsiViewFetch(view, &rec);
4686     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4687
4688     size = MAX_PATH;
4689     r = MsiRecordGetStringA(rec, 1, result, &size);
4690     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4691     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4692
4693     MsiCloseHandle(rec);
4694
4695     r = MsiViewFetch(view, &rec);
4696     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4697
4698     size = MAX_PATH;
4699     r = MsiRecordGetStringA(rec, 1, result, &size);
4700     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4701     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4702
4703     MsiCloseHandle(rec);
4704
4705     r = MsiViewFetch(view, &rec);
4706     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4707
4708     r = MsiViewClose(view);
4709     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4710     r = MsiCloseHandle(view);
4711     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4712
4713     query = "CREATE TABLE `Apple` ( `Banana` CHAR(72) NOT NULL, "
4714         "`Orange` CHAR(72),  `Pear` INT PRIMARY KEY `Banana`)";
4715     r = run_query(hdb, 0, query);
4716     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4717
4718     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4719         "VALUES('one', 'two', 3)";
4720     r = run_query(hdb, 0, query);
4721     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4722
4723     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4724         "VALUES('three', 'four', 5)";
4725     r = run_query(hdb, 0, query);
4726     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4727
4728     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4729         "VALUES('six', 'two', 7)";
4730     r = run_query(hdb, 0, query);
4731     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4732
4733     rec = MsiCreateRecord(2);
4734     MsiRecordSetInteger(rec, 1, 8);
4735     MsiRecordSetStringA(rec, 2, "two");
4736
4737     query = "UPDATE `Apple` SET `Pear` = ? WHERE `Orange` = ?";
4738     r = run_query(hdb, rec, query);
4739     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4740
4741     MsiCloseHandle(rec);
4742
4743     query = "SELECT `Pear` FROM `Apple` ORDER BY `Orange`";
4744     r = MsiDatabaseOpenViewA(hdb, query, &view);
4745     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4746     r = MsiViewExecute(view, 0);
4747     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
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 == 8, "Expected 8, got %d\n", r);
4762
4763     MsiCloseHandle(rec);
4764
4765     r = MsiViewFetch(view, &rec);
4766     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4767
4768     r = MsiRecordGetInteger(rec, 1);
4769     ok(r == 5, "Expected 5, got %d\n", r);
4770
4771     MsiCloseHandle(rec);
4772
4773     r = MsiViewFetch(view, &rec);
4774     ok(r == ERROR_NO_MORE_ITEMS, "Expectd ERROR_NO_MORE_ITEMS, got %d\n", r);
4775
4776     MsiViewClose(view);
4777     MsiCloseHandle(view);
4778
4779     r = MsiDatabaseCommit(hdb);
4780     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
4781     r = MsiCloseHandle(hdb);
4782     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4783
4784     DeleteFileA(msifile);
4785 }
4786
4787 static void test_special_tables(void)
4788 {
4789     const char *query;
4790     MSIHANDLE hdb = 0;
4791     UINT r;
4792
4793     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4794     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4795
4796     query = "CREATE TABLE `_Properties` ( "
4797         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4798     r = run_query(hdb, 0, query);
4799     ok(r == ERROR_SUCCESS, "failed to create table\n");
4800
4801     query = "CREATE TABLE `_Storages` ( "
4802         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4803     r = run_query(hdb, 0, query);
4804     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
4805
4806     query = "CREATE TABLE `_Streams` ( "
4807         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4808     r = run_query(hdb, 0, query);
4809     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
4810
4811     query = "CREATE TABLE `_Tables` ( "
4812         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4813     r = run_query(hdb, 0, query);
4814     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Tables table\n");
4815
4816     query = "CREATE TABLE `_Columns` ( "
4817         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4818     r = run_query(hdb, 0, query);
4819     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Columns table\n");
4820
4821     r = MsiCloseHandle(hdb);
4822     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4823 }
4824
4825 static void test_tables_order(void)
4826 {
4827     const char *query;
4828     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4829     UINT r;
4830     char buffer[100];
4831     DWORD sz;
4832
4833     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4834     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4835
4836     query = "CREATE TABLE `foo` ( "
4837         "`baz` INT NOT NULL PRIMARY KEY `baz`)";
4838     r = run_query(hdb, 0, query);
4839     ok(r == ERROR_SUCCESS, "failed to create table\n");
4840
4841     query = "CREATE TABLE `bar` ( "
4842         "`foo` INT NOT NULL PRIMARY KEY `foo`)";
4843     r = run_query(hdb, 0, query);
4844     ok(r == ERROR_SUCCESS, "failed to create table\n");
4845
4846     query = "CREATE TABLE `baz` ( "
4847         "`bar` INT NOT NULL, "
4848         "`baz` INT NOT NULL, "
4849         "`foo` INT NOT NULL PRIMARY KEY `bar`)";
4850     r = run_query(hdb, 0, query);
4851     ok(r == ERROR_SUCCESS, "failed to create table\n");
4852
4853     /* The names of the tables in the _Tables table must
4854        be in the same order as these names are created in
4855        the strings table. */
4856     query = "SELECT * FROM `_Tables`";
4857     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4858     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4859     r = MsiViewExecute(hview, 0);
4860     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4861
4862     r = MsiViewFetch(hview, &hrec);
4863     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4864     sz = sizeof(buffer);
4865     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4866     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4867     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4868     r = MsiCloseHandle(hrec);
4869     ok(r == ERROR_SUCCESS, "failed to close record\n");
4870
4871     r = MsiViewFetch(hview, &hrec);
4872     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4873     sz = sizeof(buffer);
4874     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4875     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4876     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4877     r = MsiCloseHandle(hrec);
4878     ok(r == ERROR_SUCCESS, "failed to close record\n");
4879
4880     r = MsiViewFetch(hview, &hrec);
4881     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4882     sz = sizeof(buffer);
4883     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4884     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4885     ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
4886     r = MsiCloseHandle(hrec);
4887     ok(r == ERROR_SUCCESS, "failed to close record\n");
4888
4889     r = MsiViewClose(hview);
4890     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4891     r = MsiCloseHandle(hview);
4892     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4893
4894     /* The names of the tables in the _Columns table must
4895        be in the same order as these names are created in
4896        the strings table. */
4897     query = "SELECT * FROM `_Columns`";
4898     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4899     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4900     r = MsiViewExecute(hview, 0);
4901     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4902
4903     r = MsiViewFetch(hview, &hrec);
4904     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4905     sz = sizeof(buffer);
4906     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4907     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4908     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4909     sz = sizeof(buffer);
4910     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4911     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4912     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4913     r = MsiCloseHandle(hrec);
4914     ok(r == ERROR_SUCCESS, "failed to close record\n");
4915
4916     r = MsiViewFetch(hview, &hrec);
4917     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4918     sz = sizeof(buffer);
4919     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4920     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4921     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4922     sz = sizeof(buffer);
4923     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4924     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4925     ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
4926     r = MsiCloseHandle(hrec);
4927     ok(r == ERROR_SUCCESS, "failed to close record\n");
4928
4929     r = MsiViewFetch(hview, &hrec);
4930     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4931     sz = sizeof(buffer);
4932     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4933     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4934     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4935     sz = sizeof(buffer);
4936     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4937     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4938     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4939     r = MsiCloseHandle(hrec);
4940     ok(r == ERROR_SUCCESS, "failed to close record\n");
4941
4942     r = MsiViewFetch(hview, &hrec);
4943     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4944     sz = sizeof(buffer);
4945     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4946     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4947     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4948     sz = sizeof(buffer);
4949     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4950     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4951     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4952     r = MsiCloseHandle(hrec);
4953     ok(r == ERROR_SUCCESS, "failed to close record\n");
4954
4955     r = MsiViewFetch(hview, &hrec);
4956     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4957     sz = sizeof(buffer);
4958     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4959     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4960     ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
4961     sz = sizeof(buffer);
4962     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4963     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4964     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4965     r = MsiCloseHandle(hrec);
4966     ok(r == ERROR_SUCCESS, "failed to close record\n");
4967
4968     r = MsiViewClose(hview);
4969     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4970     r = MsiCloseHandle(hview);
4971     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4972
4973     r = MsiCloseHandle(hdb);
4974     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4975
4976     DeleteFileA(msifile);
4977 }
4978
4979 static void test_rows_order(void)
4980 {
4981     const char *query;
4982     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4983     UINT r;
4984     char buffer[100];
4985     DWORD sz;
4986
4987     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4988     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4989
4990     query = "CREATE TABLE `foo` ( "
4991         "`bar` LONGCHAR NOT NULL PRIMARY KEY `bar`)";
4992     r = run_query(hdb, 0, query);
4993     ok(r == ERROR_SUCCESS, "failed to create table\n");
4994
4995     r = run_query(hdb, 0, "INSERT INTO `foo` "
4996             "( `bar` ) VALUES ( 'A' )");
4997     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4998
4999     r = run_query(hdb, 0, "INSERT INTO `foo` "
5000             "( `bar` ) VALUES ( 'B' )");
5001     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5002
5003     r = run_query(hdb, 0, "INSERT INTO `foo` "
5004             "( `bar` ) VALUES ( 'C' )");
5005     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5006
5007     r = run_query(hdb, 0, "INSERT INTO `foo` "
5008             "( `bar` ) VALUES ( 'D' )");
5009     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5010
5011     r = run_query(hdb, 0, "INSERT INTO `foo` "
5012             "( `bar` ) VALUES ( 'E' )");
5013     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5014
5015     r = run_query(hdb, 0, "INSERT INTO `foo` "
5016             "( `bar` ) VALUES ( 'F' )");
5017     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5018
5019     query = "CREATE TABLE `bar` ( "
5020         "`foo` LONGCHAR NOT NULL, "
5021         "`baz` LONGCHAR NOT NULL "
5022         "PRIMARY KEY `foo` )";
5023     r = run_query(hdb, 0, query);
5024     ok(r == ERROR_SUCCESS, "failed to create table\n");
5025
5026     r = run_query(hdb, 0, "INSERT INTO `bar` "
5027             "( `foo`, `baz` ) VALUES ( 'C', 'E' )");
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 ( 'F', 'A' )");
5032     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5033
5034     r = run_query(hdb, 0, "INSERT INTO `bar` "
5035             "( `foo`, `baz` ) VALUES ( 'A', 'B' )");
5036     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5037
5038     r = run_query(hdb, 0, "INSERT INTO `bar` "
5039             "( `foo`, `baz` ) VALUES ( 'D', 'E' )");
5040     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5041
5042     /* The rows of the table must be ordered by the column values of
5043        each row. For strings, the column value is the string id
5044        in the string table.  */
5045
5046     query = "SELECT * FROM `bar`";
5047     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5048     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5049     r = MsiViewExecute(hview, 0);
5050     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5051
5052     r = MsiViewFetch(hview, &hrec);
5053     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5054     sz = sizeof(buffer);
5055     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5056     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5057     ok(!lstrcmpA(buffer, "A"), "Expected A, got %s\n", buffer);
5058     sz = sizeof(buffer);
5059     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5060     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5061     ok(!lstrcmpA(buffer, "B"), "Expected B, got %s\n", buffer);
5062     r = MsiCloseHandle(hrec);
5063     ok(r == ERROR_SUCCESS, "failed to close record\n");
5064
5065     r = MsiViewFetch(hview, &hrec);
5066     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5067     sz = sizeof(buffer);
5068     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5069     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5070     ok(!lstrcmpA(buffer, "C"), "Expected E, got %s\n", buffer);
5071     sz = sizeof(buffer);
5072     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5073     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5074     ok(!lstrcmpA(buffer, "E"), "Expected E, got %s\n", buffer);
5075     r = MsiCloseHandle(hrec);
5076     ok(r == ERROR_SUCCESS, "failed to close record\n");
5077
5078     r = MsiViewFetch(hview, &hrec);
5079     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5080     sz = sizeof(buffer);
5081     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5082     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5083     ok(!lstrcmpA(buffer, "D"), "Expected D, got %s\n", buffer);
5084     sz = sizeof(buffer);
5085     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5086     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5087     ok(!lstrcmpA(buffer, "E"), "Expected E, got %s\n", buffer);
5088     r = MsiCloseHandle(hrec);
5089     ok(r == ERROR_SUCCESS, "failed to close record\n");
5090
5091     r = MsiViewFetch(hview, &hrec);
5092     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5093     sz = sizeof(buffer);
5094     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5095     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5096     ok(!lstrcmpA(buffer, "F"), "Expected F, got %s\n", buffer);
5097     sz = sizeof(buffer);
5098     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5099     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5100     ok(!lstrcmpA(buffer, "A"), "Expected A, got %s\n", buffer);
5101     r = MsiCloseHandle(hrec);
5102     ok(r == ERROR_SUCCESS, "failed to close record\n");
5103
5104     r = MsiViewClose(hview);
5105     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5106     r = MsiCloseHandle(hview);
5107     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5108
5109     r = MsiCloseHandle(hdb);
5110     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5111
5112     DeleteFileA(msifile);
5113 }
5114
5115 static void test_collation(void)
5116 {
5117     static const WCHAR query1[] =
5118         {'I','N','S','E','R','T',' ','I','N','T','O',' ','`','b','a','r','`',' ',
5119          '(','`','f','o','o','`',',','`','b','a','z','`',')',' ','V','A','L','U','E','S',' ',
5120          '(','\'','a',0x30a,'\'',',','\'','C','\'',')',0};
5121     static const WCHAR query2[] =
5122         {'I','N','S','E','R','T',' ','I','N','T','O',' ','`','b','a','r','`',' ',
5123          '(','`','f','o','o','`',',','`','b','a','z','`',')',' ','V','A','L','U','E','S',' ',
5124          '(','\'',0xe5,'\'',',','\'','D','\'',')',0};
5125     static const WCHAR query3[] =
5126         {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','b','a','z','`',' ',
5127          '(',' ','`','a',0x30a,'`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ','N','U','L','L',',',
5128            ' ','`',0xe5,'`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ','N','U','L','L',' ',
5129            'P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','a',0x30a,'`',')',0};
5130     static const WCHAR query4[] =
5131         {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','a',0x30a,'`',' ',
5132          '(',' ','`','f','o','o','`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ',
5133          'N','U','L','L',' ','P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','f','o','o','`',')',0};
5134     static const WCHAR query5[] =
5135         {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`',0xe5,'`',' ',
5136          '(',' ','`','f','o','o','`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ',
5137          'N','U','L','L',' ','P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','f','o','o','`',')',0};
5138     static const WCHAR query6[] =
5139         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','`','b','a','r','`',' ','W','H','E','R','E',
5140          ' ','`','f','o','o','`',' ','=','\'',0xe5,'\'',0};
5141     static const WCHAR letter_C[] = {'C',0};
5142     static const WCHAR letter_D[] = {'D',0};
5143     static const WCHAR letter_a_ring[] = {'a',0x30a,0};
5144     static const WCHAR letter_a_with_ring[] = {0xe5,0};
5145     const char *query;
5146     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5147     UINT r;
5148     char buffer[100];
5149     WCHAR bufferW[100];
5150     DWORD sz;
5151
5152     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5153     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5154
5155     query = "CREATE TABLE `bar` ( "
5156         "`foo` LONGCHAR NOT NULL, "
5157         "`baz` LONGCHAR NOT NULL "
5158         "PRIMARY KEY `foo` )";
5159     r = run_query(hdb, 0, query);
5160     ok(r == ERROR_SUCCESS, "failed to create table\n");
5161
5162     r = run_query(hdb, 0, query);
5163     ok(r == ERROR_BAD_QUERY_SYNTAX, "wrong error %u\n", r);
5164
5165     r = run_query(hdb, 0, "INSERT INTO `bar` "
5166             "( `foo`, `baz` ) VALUES ( '\2', 'A' )");
5167     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5168
5169     r = run_query(hdb, 0, "INSERT INTO `bar` "
5170             "( `foo`, `baz` ) VALUES ( '\1', 'B' )");
5171     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5172
5173     r = run_queryW(hdb, 0, query1);
5174     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5175
5176     r = run_queryW(hdb, 0, query2);
5177     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5178
5179     r = run_queryW(hdb, 0, query3);
5180     ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
5181
5182     r = run_queryW(hdb, 0, query4);
5183     ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
5184
5185     r = run_queryW(hdb, 0, query5);
5186     ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
5187
5188     query = "SELECT * FROM `bar`";
5189     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5190     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5191     r = MsiViewExecute(hview, 0);
5192     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5193
5194     r = MsiViewFetch(hview, &hrec);
5195     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5196     sz = sizeof(buffer);
5197     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5198     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5199     ok(!lstrcmpA(buffer, "\2"), "Expected \\2, got '%s'\n", buffer);
5200     sz = sizeof(buffer);
5201     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5202     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5203     ok(!lstrcmpA(buffer, "A"), "Expected A, got '%s'\n", buffer);
5204     MsiCloseHandle(hrec);
5205
5206     r = MsiViewFetch(hview, &hrec);
5207     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5208     sz = sizeof(buffer);
5209     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5210     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5211     ok(!lstrcmpA(buffer, "\1"), "Expected \\1, got '%s'\n", buffer);
5212     sz = sizeof(buffer);
5213     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5214     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5215     ok(!lstrcmpA(buffer, "B"), "Expected B, got '%s'\n", buffer);
5216     MsiCloseHandle(hrec);
5217
5218     r = MsiViewFetch(hview, &hrec);
5219     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5220     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5221     r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
5222     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5223     ok(!memcmp(bufferW, letter_a_ring, sizeof(letter_a_ring)),
5224        "Expected %s, got %s\n", wine_dbgstr_w(letter_a_ring), wine_dbgstr_w(bufferW));
5225     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5226     r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
5227     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5228     ok(!lstrcmpW(bufferW, letter_C), "Expected C, got %s\n", wine_dbgstr_w(bufferW));
5229     MsiCloseHandle(hrec);
5230
5231     r = MsiViewFetch(hview, &hrec);
5232     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5233     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5234     r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
5235     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5236     ok(!memcmp(bufferW, letter_a_with_ring, sizeof(letter_a_with_ring)),
5237        "Expected %s, got %s\n", wine_dbgstr_w(letter_a_with_ring), wine_dbgstr_w(bufferW));
5238     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5239     r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
5240     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5241     ok(!lstrcmpW(bufferW, letter_D), "Expected D, got %s\n", wine_dbgstr_w(bufferW));
5242     MsiCloseHandle(hrec);
5243
5244     r = MsiViewClose(hview);
5245     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5246     r = MsiCloseHandle(hview);
5247     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5248
5249     r = MsiDatabaseOpenViewW(hdb, query6, &hview);
5250     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5251     r = MsiViewExecute(hview, 0);
5252     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5253
5254     r = MsiViewFetch(hview, &hrec);
5255     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5256     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5257     r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
5258     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5259     ok(!memcmp(bufferW, letter_a_with_ring, sizeof(letter_a_with_ring)),
5260        "Expected %s, got %s\n", wine_dbgstr_w(letter_a_with_ring), wine_dbgstr_w(bufferW));
5261     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5262     r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
5263     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5264     ok(!lstrcmpW(bufferW, letter_D), "Expected D, got %s\n", wine_dbgstr_w(bufferW));
5265     MsiCloseHandle(hrec);
5266
5267     r = MsiViewFetch(hview, &hrec);
5268     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
5269
5270     r = MsiViewClose(hview);
5271     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5272     r = MsiCloseHandle(hview);
5273     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5274
5275     r = MsiCloseHandle(hdb);
5276     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5277
5278     DeleteFileA(msifile);
5279 }
5280
5281 static void test_select_markers(void)
5282 {
5283     MSIHANDLE hdb = 0, rec, view, res;
5284     LPCSTR query;
5285     UINT r;
5286     DWORD size;
5287     CHAR buf[MAX_PATH];
5288
5289     hdb = create_db();
5290     ok( hdb, "failed to create db\n");
5291
5292     r = run_query(hdb, 0,
5293             "CREATE TABLE `Table` (`One` CHAR(72), `Two` CHAR(72), `Three` SHORT PRIMARY KEY `One`, `Two`, `Three`)");
5294     ok(r == S_OK, "cannot create table: %d\n", r);
5295
5296     r = run_query(hdb, 0, "INSERT INTO `Table` "
5297             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'one', 1 )");
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 ( 'apple', 'two', 1 )");
5302     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5303
5304     r = run_query(hdb, 0, "INSERT INTO `Table` "
5305             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 2 )");
5306     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5307
5308     r = run_query(hdb, 0, "INSERT INTO `Table` "
5309             "( `One`, `Two`, `Three` ) VALUES ( 'banana', 'three', 3 )");
5310     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5311
5312     rec = MsiCreateRecord(2);
5313     MsiRecordSetStringA(rec, 1, "apple");
5314     MsiRecordSetStringA(rec, 2, "two");
5315
5316     query = "SELECT * FROM `Table` WHERE `One`=? AND `Two`=? ORDER BY `Three`";
5317     r = MsiDatabaseOpenViewA(hdb, query, &view);
5318     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5319
5320     r = MsiViewExecute(view, rec);
5321     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5322
5323     r = MsiViewFetch(view, &res);
5324     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5325
5326     size = MAX_PATH;
5327     r = MsiRecordGetStringA(res, 1, buf, &size);
5328     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5329     ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
5330
5331     size = MAX_PATH;
5332     r = MsiRecordGetStringA(res, 2, buf, &size);
5333     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5334     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5335
5336     r = MsiRecordGetInteger(res, 3);
5337     ok(r == 1, "Expected 1, got %d\n", r);
5338
5339     MsiCloseHandle(res);
5340
5341     r = MsiViewFetch(view, &res);
5342     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5343
5344     size = MAX_PATH;
5345     r = MsiRecordGetStringA(res, 1, buf, &size);
5346     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5347     ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
5348
5349     size = MAX_PATH;
5350     r = MsiRecordGetStringA(res, 2, buf, &size);
5351     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5352     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5353
5354     r = MsiRecordGetInteger(res, 3);
5355     ok(r == 2, "Expected 2, got %d\n", r);
5356
5357     MsiCloseHandle(res);
5358
5359     r = MsiViewFetch(view, &res);
5360     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5361
5362     MsiCloseHandle(rec);
5363     MsiViewClose(view);
5364     MsiCloseHandle(view);
5365
5366     rec = MsiCreateRecord(2);
5367     MsiRecordSetStringA(rec, 1, "one");
5368     MsiRecordSetInteger(rec, 2, 1);
5369
5370     query = "SELECT * FROM `Table` WHERE `Two`<>? AND `Three`>? ORDER BY `Three`";
5371     r = MsiDatabaseOpenViewA(hdb, query, &view);
5372     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5373     r = MsiViewExecute(view, rec);
5374     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5375
5376     r = MsiViewFetch(view, &res);
5377     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5378
5379     size = MAX_PATH;
5380     r = MsiRecordGetStringA(res, 1, buf, &size);
5381     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5382     ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
5383
5384     size = MAX_PATH;
5385     r = MsiRecordGetStringA(res, 2, buf, &size);
5386     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5387     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5388
5389     r = MsiRecordGetInteger(res, 3);
5390     ok(r == 2, "Expected 2, got %d\n", r);
5391
5392     MsiCloseHandle(res);
5393
5394     r = MsiViewFetch(view, &res);
5395     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5396
5397     size = MAX_PATH;
5398     r = MsiRecordGetStringA(res, 1, buf, &size);
5399     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5400     ok(!lstrcmpA(buf, "banana"), "Expected banana, got %s\n", buf);
5401
5402     size = MAX_PATH;
5403     r = MsiRecordGetStringA(res, 2, buf, &size);
5404     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5405     ok(!lstrcmpA(buf, "three"), "Expected three, got %s\n", buf);
5406
5407     r = MsiRecordGetInteger(res, 3);
5408     ok(r == 3, "Expected 3, got %d\n", r);
5409
5410     MsiCloseHandle(res);
5411
5412     r = MsiViewFetch(view, &res);
5413     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5414
5415     MsiCloseHandle(rec);
5416     MsiViewClose(view);
5417     MsiCloseHandle(view);
5418     MsiCloseHandle(hdb);
5419     DeleteFileA(msifile);
5420 }
5421
5422 static void test_viewmodify_update(void)
5423 {
5424     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5425     UINT i, test_max, offset, count;
5426     const char *query;
5427     UINT r;
5428
5429     DeleteFileA(msifile);
5430
5431     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5432     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5433
5434     query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
5435     r = run_query( hdb, 0, query );
5436     ok(r == ERROR_SUCCESS, "query failed\n");
5437
5438     query = "INSERT INTO `table` (`A`, `B`) VALUES (1, 2)";
5439     r = run_query( hdb, 0, query );
5440     ok(r == ERROR_SUCCESS, "query failed\n");
5441
5442     query = "INSERT INTO `table` (`A`, `B`) VALUES (3, 4)";
5443     r = run_query( hdb, 0, query );
5444     ok(r == ERROR_SUCCESS, "query failed\n");
5445
5446     query = "INSERT INTO `table` (`A`, `B`) VALUES (5, 6)";
5447     r = run_query( hdb, 0, query );
5448     ok(r == ERROR_SUCCESS, "query failed\n");
5449
5450     query = "SELECT `B` FROM `table`";
5451     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5452     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5453     r = MsiViewExecute(hview, 0);
5454     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5455     r = MsiViewFetch(hview, &hrec);
5456     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5457
5458     r = MsiRecordSetInteger(hrec, 1, 0);
5459     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5460
5461     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
5462     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5463
5464     r = MsiCloseHandle(hrec);
5465     ok(r == ERROR_SUCCESS, "failed to close record\n");
5466
5467     r = MsiViewClose(hview);
5468     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5469     r = MsiCloseHandle(hview);
5470     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5471
5472     query = "SELECT * FROM `table`";
5473     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5474     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5475     r = MsiViewExecute(hview, 0);
5476     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5477     r = MsiViewFetch(hview, &hrec);
5478     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5479
5480     r = MsiRecordGetInteger(hrec, 1);
5481     ok(r == 1, "Expected 1, got %d\n", r);
5482     r = MsiRecordGetInteger(hrec, 2);
5483     ok(r == 0, "Expected 0, got %d\n", r);
5484
5485     r = MsiCloseHandle(hrec);
5486     ok(r == ERROR_SUCCESS, "failed to close record\n");
5487
5488     r = MsiViewFetch(hview, &hrec);
5489     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5490
5491     r = MsiRecordGetInteger(hrec, 1);
5492     ok(r == 3, "Expected 3, got %d\n", r);
5493     r = MsiRecordGetInteger(hrec, 2);
5494     ok(r == 4, "Expected 4, got %d\n", r);
5495
5496     r = MsiCloseHandle(hrec);
5497     ok(r == ERROR_SUCCESS, "failed to close record\n");
5498
5499     r = MsiViewFetch(hview, &hrec);
5500     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5501
5502     r = MsiRecordGetInteger(hrec, 1);
5503     ok(r == 5, "Expected 5, got %d\n", r);
5504     r = MsiRecordGetInteger(hrec, 2);
5505     ok(r == 6, "Expected 6, got %d\n", r);
5506
5507     r = MsiCloseHandle(hrec);
5508     ok(r == ERROR_SUCCESS, "failed to close record\n");
5509
5510     r = MsiViewFetch(hview, &hrec);
5511     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5512
5513     r = MsiViewClose(hview);
5514     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5515     r = MsiCloseHandle(hview);
5516     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5517
5518     /* loop through all elements */
5519     query = "SELECT `B` FROM `table`";
5520     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5521     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5522     r = MsiViewExecute(hview, 0);
5523     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5524
5525     while (TRUE)
5526     {
5527         r = MsiViewFetch(hview, &hrec);
5528         if (r != ERROR_SUCCESS)
5529             break;
5530
5531         r = MsiRecordSetInteger(hrec, 1, 0);
5532         ok(r == ERROR_SUCCESS, "failed to set integer\n");
5533
5534         r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
5535         ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5536
5537         r = MsiCloseHandle(hrec);
5538         ok(r == ERROR_SUCCESS, "failed to close record\n");
5539     }
5540
5541     r = MsiViewClose(hview);
5542     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5543     r = MsiCloseHandle(hview);
5544     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5545
5546     query = "SELECT * FROM `table`";
5547     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5548     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5549     r = MsiViewExecute(hview, 0);
5550     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5551     r = MsiViewFetch(hview, &hrec);
5552     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5553
5554     r = MsiRecordGetInteger(hrec, 1);
5555     ok(r == 1, "Expected 1, got %d\n", r);
5556     r = MsiRecordGetInteger(hrec, 2);
5557     ok(r == 0, "Expected 0, got %d\n", r);
5558
5559     r = MsiCloseHandle(hrec);
5560     ok(r == ERROR_SUCCESS, "failed to close record\n");
5561
5562     r = MsiViewFetch(hview, &hrec);
5563     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5564
5565     r = MsiRecordGetInteger(hrec, 1);
5566     ok(r == 3, "Expected 3, got %d\n", r);
5567     r = MsiRecordGetInteger(hrec, 2);
5568     ok(r == 0, "Expected 0, got %d\n", r);
5569
5570     r = MsiCloseHandle(hrec);
5571     ok(r == ERROR_SUCCESS, "failed to close record\n");
5572
5573     r = MsiViewFetch(hview, &hrec);
5574     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5575
5576     r = MsiRecordGetInteger(hrec, 1);
5577     ok(r == 5, "Expected 5, got %d\n", r);
5578     r = MsiRecordGetInteger(hrec, 2);
5579     ok(r == 0, "Expected 0, got %d\n", r);
5580
5581     r = MsiCloseHandle(hrec);
5582     ok(r == ERROR_SUCCESS, "failed to close record\n");
5583
5584     r = MsiViewFetch(hview, &hrec);
5585     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5586
5587     r = MsiViewClose(hview);
5588     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5589     r = MsiCloseHandle(hview);
5590     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5591
5592     query = "CREATE TABLE `table2` (`A` INT, `B` INT PRIMARY KEY `A`)";
5593     r = run_query( hdb, 0, query );
5594     ok(r == ERROR_SUCCESS, "query failed\n");
5595
5596     query = "INSERT INTO `table2` (`A`, `B`) VALUES (?, ?)";
5597     r = MsiDatabaseOpenViewA( hdb, query, &hview );
5598     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5599
5600     test_max = 100;
5601     offset = 1234;
5602     for(i = 0; i < test_max; i++)
5603     {
5604
5605         hrec = MsiCreateRecord( 2 );
5606         MsiRecordSetInteger( hrec, 1, test_max - i );
5607         MsiRecordSetInteger( hrec, 2, i );
5608
5609         r = MsiViewExecute( hview, hrec );
5610         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5611
5612         r = MsiCloseHandle( hrec );
5613         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5614     }
5615
5616     r = MsiViewClose( hview );
5617     ok(r == ERROR_SUCCESS, "Got %d\n", r);
5618     r = MsiCloseHandle( hview );
5619     ok(r == ERROR_SUCCESS, "Got %d\n", r);
5620
5621     /* Update. */
5622     query = "SELECT * FROM `table2` ORDER BY `B`";
5623     r = MsiDatabaseOpenViewA( hdb, query, &hview);
5624     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5625     r = MsiViewExecute( hview, 0 );
5626     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5627
5628     count = 0;
5629     while (MsiViewFetch( hview, &hrec ) == ERROR_SUCCESS)
5630     {
5631         UINT b = MsiRecordGetInteger( hrec, 2 );
5632
5633         r = MsiRecordSetInteger( hrec, 2, b + offset);
5634         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5635
5636         r = MsiViewModify( hview, MSIMODIFY_UPDATE, hrec );
5637         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5638
5639         r = MsiCloseHandle(hrec);
5640         ok(r == ERROR_SUCCESS, "failed to close record\n");
5641         count++;
5642     }
5643     ok(count == test_max, "Got count %d\n", count);
5644
5645     r = MsiViewClose(hview);
5646     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5647     r = MsiCloseHandle(hview);
5648     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5649
5650     /* Recheck. */
5651     query = "SELECT * FROM `table2` ORDER BY `B`";
5652     r = MsiDatabaseOpenViewA( hdb, query, &hview);
5653     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5654     r = MsiViewExecute( hview, 0 );
5655     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5656
5657     count = 0;
5658     while (MsiViewFetch( hview, &hrec ) == ERROR_SUCCESS)
5659     {
5660         UINT a = MsiRecordGetInteger( hrec, 1 );
5661         UINT b = MsiRecordGetInteger( hrec, 2 );
5662         ok( ( test_max - a + offset) == b, "Got (%d, %d), expected (%d, %d)\n",
5663             a, b, test_max - a + offset, b);
5664
5665         r = MsiCloseHandle(hrec);
5666         ok(r == ERROR_SUCCESS, "failed to close record\n");
5667         count++;
5668     }
5669     ok(count == test_max, "Got count %d\n", count);
5670
5671     r = MsiViewClose(hview);
5672     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5673     r = MsiCloseHandle(hview);
5674     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5675
5676     r = MsiCloseHandle( hdb );
5677     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
5678 }
5679
5680 static void test_viewmodify_assign(void)
5681 {
5682     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5683     const char *query;
5684     UINT r;
5685
5686     /* setup database */
5687     DeleteFileA(msifile);
5688
5689     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5690     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5691
5692     query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
5693     r = run_query( hdb, 0, query );
5694     ok(r == ERROR_SUCCESS, "query failed\n");
5695
5696     /* assign to view, new primary key */
5697     query = "SELECT * FROM `table`";
5698     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5699     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5700     r = MsiViewExecute(hview, 0);
5701     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5702
5703     hrec = MsiCreateRecord(2);
5704     ok(hrec != 0, "MsiCreateRecord failed\n");
5705
5706     r = MsiRecordSetInteger(hrec, 1, 1);
5707     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5708     r = MsiRecordSetInteger(hrec, 2, 2);
5709     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5710
5711     r = MsiViewModify(hview, MSIMODIFY_ASSIGN, hrec);
5712     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5713
5714     r = MsiCloseHandle(hrec);
5715     ok(r == ERROR_SUCCESS, "failed to close record\n");
5716
5717     r = MsiViewClose(hview);
5718     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5719     r = MsiCloseHandle(hview);
5720     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5721
5722     query = "SELECT * FROM `table`";
5723     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5724     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5725     r = MsiViewExecute(hview, 0);
5726     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5727     r = MsiViewFetch(hview, &hrec);
5728     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5729
5730     r = MsiRecordGetInteger(hrec, 1);
5731     ok(r == 1, "Expected 1, got %d\n", r);
5732     r = MsiRecordGetInteger(hrec, 2);
5733     ok(r == 2, "Expected 2, got %d\n", r);
5734
5735     r = MsiCloseHandle(hrec);
5736     ok(r == ERROR_SUCCESS, "failed to close record\n");
5737
5738     r = MsiViewFetch(hview, &hrec);
5739     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5740
5741     r = MsiViewClose(hview);
5742     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5743     r = MsiCloseHandle(hview);
5744     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5745
5746     /* assign to view, primary key matches */
5747     query = "SELECT * FROM `table`";
5748     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5749     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5750     r = MsiViewExecute(hview, 0);
5751     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5752
5753     hrec = MsiCreateRecord(2);
5754     ok(hrec != 0, "MsiCreateRecord failed\n");
5755
5756     r = MsiRecordSetInteger(hrec, 1, 1);
5757     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5758     r = MsiRecordSetInteger(hrec, 2, 4);
5759     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5760
5761     r = MsiViewModify(hview, MSIMODIFY_ASSIGN, hrec);
5762     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5763
5764     r = MsiCloseHandle(hrec);
5765     ok(r == ERROR_SUCCESS, "failed to close record\n");
5766
5767     r = MsiViewClose(hview);
5768     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5769     r = MsiCloseHandle(hview);
5770     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5771
5772     query = "SELECT * FROM `table`";
5773     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5774     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5775     r = MsiViewExecute(hview, 0);
5776     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5777     r = MsiViewFetch(hview, &hrec);
5778     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5779
5780     r = MsiRecordGetInteger(hrec, 1);
5781     ok(r == 1, "Expected 1, got %d\n", r);
5782     r = MsiRecordGetInteger(hrec, 2);
5783     ok(r == 4, "Expected 4, got %d\n", r);
5784
5785     r = MsiCloseHandle(hrec);
5786     ok(r == ERROR_SUCCESS, "failed to close record\n");
5787
5788     r = MsiViewFetch(hview, &hrec);
5789     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5790
5791     r = MsiViewClose(hview);
5792     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5793     r = MsiCloseHandle(hview);
5794     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5795
5796     /* close database */
5797     r = MsiCloseHandle( hdb );
5798     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
5799 }
5800
5801 static const WCHAR data10[] = { /* MOO */
5802     0x8001, 0x000b,
5803 };
5804 static const WCHAR data11[] = { /* AAR */
5805     0x8002, 0x8005,
5806     0x000c, 0x000f,
5807 };
5808 static const char data12[] = /* _StringData */
5809     "MOOABAARCDonetwofourfive";
5810 static const WCHAR data13[] = { /* _StringPool */
5811 /*  len, refs */
5812     0,   0,    /* string 0 ''     */
5813     0,   0,    /* string 1 ''     */
5814     0,   0,    /* string 2 ''     */
5815     0,   0,    /* string 3 ''     */
5816     0,   0,    /* string 4 ''     */
5817     3,   3,    /* string 5 'MOO'  */
5818     1,   1,    /* string 6 'A'    */
5819     1,   1,    /* string 7 'B'    */
5820     3,   3,    /* string 8 'AAR'  */
5821     1,   1,    /* string 9 'C'    */
5822     1,   1,    /* string a 'D'    */
5823     3,   1,    /* string b 'one'  */
5824     3,   1,    /* string c 'two'  */
5825     0,   0,    /* string d ''     */
5826     4,   1,    /* string e 'four' */
5827     4,   1,    /* string f 'five' */
5828 };
5829
5830 static void test_stringtable(void)
5831 {
5832     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5833     IStorage *stg = NULL;
5834     IStream *stm;
5835     WCHAR name[0x20];
5836     HRESULT hr;
5837     const char *query;
5838     char buffer[MAX_PATH];
5839     WCHAR data[MAX_PATH];
5840     DWORD sz, read;
5841     UINT r;
5842
5843     static const DWORD mode = STGM_DIRECT | STGM_READ | STGM_SHARE_DENY_WRITE;
5844     static const WCHAR stringdata[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0}; /* _StringData */
5845     static const WCHAR stringpool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0}; /* _StringPool */
5846     static const WCHAR moo[] = {0x4840, 0x3e16, 0x4818, 0}; /* MOO */
5847     static const WCHAR aar[] = {0x4840, 0x3a8a, 0x481b, 0}; /* AAR */
5848
5849     DeleteFileA(msifile);
5850
5851     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5852     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5853
5854     query = "CREATE TABLE `MOO` (`A` INT, `B` CHAR(72) PRIMARY KEY `A`)";
5855     r = run_query(hdb, 0, query);
5856     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5857
5858     query = "CREATE TABLE `AAR` (`C` INT, `D` CHAR(72) PRIMARY KEY `C`)";
5859     r = run_query(hdb, 0, query);
5860     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5861
5862     /* insert persistent row */
5863     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (1, 'one')";
5864     r = run_query(hdb, 0, query);
5865     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5866
5867     /* insert persistent row */
5868     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (2, 'two')";
5869     r = run_query(hdb, 0, query);
5870     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5871
5872     /* open a view */
5873     query = "SELECT * FROM `MOO`";
5874     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5875     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5876     r = MsiViewExecute(hview, 0);
5877     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5878
5879     hrec = MsiCreateRecord(2);
5880
5881     r = MsiRecordSetInteger(hrec, 1, 3);
5882     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5883     r = MsiRecordSetStringA(hrec, 2, "three");
5884     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5885
5886     /* insert a nonpersistent row */
5887     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
5888     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5889
5890     r = MsiCloseHandle(hrec);
5891     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5892     r = MsiViewClose(hview);
5893     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5894     r = MsiCloseHandle(hview);
5895     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5896
5897     /* insert persistent row */
5898     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (4, 'four')";
5899     r = run_query(hdb, 0, query);
5900     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5901
5902     /* insert persistent row */
5903     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (5, 'five')";
5904     r = run_query(hdb, 0, query);
5905     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5906
5907     r = MsiDatabaseCommit(hdb);
5908     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5909
5910     r = MsiCloseHandle(hdb);
5911     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5912
5913     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
5914     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5915
5916     query = "SELECT * FROM `MOO`";
5917     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5918     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5919
5920     r = MsiViewExecute(hview, 0);
5921     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5922
5923     r = MsiViewFetch(hview, &hrec);
5924     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5925
5926     r = MsiRecordGetFieldCount(hrec);
5927     ok(r == 2, "Expected 2, got %d\n", r);
5928
5929     r = MsiRecordGetInteger(hrec, 1);
5930     ok(r == 1, "Expected 1, got %d\n", r);
5931
5932     sz = sizeof(buffer);
5933     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5934     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5935     ok(!lstrcmpA(buffer, "one"), "Expected one, got '%s'\n", buffer);
5936
5937     r = MsiCloseHandle(hrec);
5938     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5939
5940     r = MsiViewFetch(hview, &hrec);
5941     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5942
5943     r = MsiViewClose(hview);
5944     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5945     r = MsiCloseHandle(hview);
5946     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5947     r = MsiCloseHandle(hrec);
5948     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5949
5950     query = "SELECT * FROM `AAR`";
5951     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5952     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5953
5954     r = MsiViewExecute(hview, 0);
5955     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5956
5957     r = MsiViewFetch(hview, &hrec);
5958     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5959
5960     r = MsiRecordGetFieldCount(hrec);
5961     ok(r == 2, "Expected 2, got %d\n", r);
5962
5963     r = MsiRecordGetInteger(hrec, 1);
5964     ok(r == 2, "Expected 2, got %d\n", r);
5965
5966     sz = sizeof(buffer);
5967     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5968     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5969     ok(!lstrcmpA(buffer, "two"), "Expected two, got '%s'\n", buffer);
5970
5971     r = MsiCloseHandle(hrec);
5972     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5973
5974     r = MsiViewFetch(hview, &hrec);
5975     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5976
5977     r = MsiRecordGetFieldCount(hrec);
5978     ok(r == 2, "Expected 2, got %d\n", r);
5979
5980     r = MsiRecordGetInteger(hrec, 1);
5981     ok(r == 5, "Expected 5, got %d\n", r);
5982
5983     sz = sizeof(buffer);
5984     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5985     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5986     ok(!lstrcmpA(buffer, "five"), "Expected five, got '%s'\n", buffer);
5987
5988     r = MsiCloseHandle(hrec);
5989     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5990
5991     r = MsiViewFetch(hview, &hrec);
5992     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5993
5994     r = MsiViewClose(hview);
5995     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5996     r = MsiCloseHandle(hview);
5997     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5998     r = MsiCloseHandle(hrec);
5999     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6000     r = MsiCloseHandle(hdb);
6001     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6002
6003     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, 0x20);
6004     hr = StgOpenStorage(name, NULL, mode, NULL, 0, &stg);
6005     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6006     ok(stg != NULL, "Expected non-NULL storage\n");
6007
6008     hr = IStorage_OpenStream(stg, moo, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6009     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6010     ok(stm != NULL, "Expected non-NULL stream\n");
6011
6012     hr = IStream_Read(stm, data, MAX_PATH, &read);
6013     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6014     ok(read == 4, "Expected 4, got %d\n", read);
6015     todo_wine ok(!memcmp(data, data10, read), "Unexpected data\n");
6016
6017     hr = IStream_Release(stm);
6018     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6019
6020     hr = IStorage_OpenStream(stg, aar, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6021     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6022     ok(stm != NULL, "Expected non-NULL stream\n");
6023
6024     hr = IStream_Read(stm, data, MAX_PATH, &read);
6025     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6026     ok(read == 8, "Expected 8, got %d\n", read);
6027     todo_wine
6028     {
6029         ok(!memcmp(data, data11, read), "Unexpected data\n");
6030     }
6031
6032     hr = IStream_Release(stm);
6033     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6034
6035     hr = IStorage_OpenStream(stg, stringdata, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6036     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6037     ok(stm != NULL, "Expected non-NULL stream\n");
6038
6039     hr = IStream_Read(stm, buffer, MAX_PATH, &read);
6040     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6041     ok(read == 24, "Expected 24, got %d\n", read);
6042     ok(!memcmp(buffer, data12, read), "Unexpected data\n");
6043
6044     hr = IStream_Release(stm);
6045     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6046
6047     hr = IStorage_OpenStream(stg, stringpool, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6048     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6049     ok(stm != NULL, "Expected non-NULL stream\n");
6050
6051     hr = IStream_Read(stm, data, MAX_PATH, &read);
6052     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6053     todo_wine
6054     {
6055         ok(read == 64, "Expected 64, got %d\n", read);
6056         ok(!memcmp(data, data13, read), "Unexpected data\n");
6057     }
6058
6059     hr = IStream_Release(stm);
6060     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6061
6062     hr = IStorage_Release(stg);
6063     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6064
6065     DeleteFileA(msifile);
6066 }
6067
6068 static void test_viewmodify_delete(void)
6069 {
6070     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
6071     UINT r;
6072     const char *query;
6073     char buffer[0x100];
6074     DWORD sz;
6075
6076     DeleteFileA(msifile);
6077
6078     /* just MsiOpenDatabase should not create a file */
6079     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6080     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6081
6082     query = "CREATE TABLE `phone` ( "
6083             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
6084             "PRIMARY KEY `id`)";
6085     r = run_query(hdb, 0, query);
6086     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6087
6088     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
6089         "VALUES('1', 'Alan', '5030581')";
6090     r = run_query(hdb, 0, query);
6091     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6092
6093     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
6094         "VALUES('2', 'Barry', '928440')";
6095     r = run_query(hdb, 0, query);
6096     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6097
6098     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
6099         "VALUES('3', 'Cindy', '2937550')";
6100     r = run_query(hdb, 0, query);
6101     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6102
6103     query = "SELECT * FROM `phone` WHERE `id` <= 2";
6104     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6105     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6106     r = MsiViewExecute(hview, 0);
6107     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6108     r = MsiViewFetch(hview, &hrec);
6109     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6110
6111     /* delete 1 */
6112     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6113     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6114
6115     r = MsiCloseHandle(hrec);
6116     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6117     r = MsiViewFetch(hview, &hrec);
6118     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6119
6120     /* delete 2 */
6121     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6122     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6123
6124     r = MsiCloseHandle(hrec);
6125     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6126     r = MsiViewClose(hview);
6127     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6128     r = MsiCloseHandle(hview);
6129     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6130
6131     query = "SELECT * FROM `phone`";
6132     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6133     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6134     r = MsiViewExecute(hview, 0);
6135     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6136     r = MsiViewFetch(hview, &hrec);
6137     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6138
6139     r = MsiRecordGetInteger(hrec, 1);
6140     ok(r == 3, "Expected 3, got %d\n", r);
6141
6142     sz = sizeof(buffer);
6143     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
6144     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6145     ok(!lstrcmpA(buffer, "Cindy"), "Expected Cindy, got %s\n", buffer);
6146
6147     sz = sizeof(buffer);
6148     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
6149     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6150     ok(!lstrcmpA(buffer, "2937550"), "Expected 2937550, got %s\n", buffer);
6151
6152     r = MsiCloseHandle(hrec);
6153     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6154
6155     r = MsiViewFetch(hview, &hrec);
6156     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6157
6158     r = MsiViewClose(hview);
6159     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6160     r = MsiCloseHandle(hview);
6161     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6162     r = MsiCloseHandle(hdb);
6163     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6164 }
6165
6166 static const WCHAR _Tables[] = {0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0};
6167 static const WCHAR _StringData[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0};
6168 static const WCHAR _StringPool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0};
6169
6170 static const WCHAR data14[] = { /* _StringPool */
6171 /*  len, refs */
6172     0,   0,    /* string 0 ''    */
6173 };
6174
6175 static const struct {
6176     LPCWSTR name;
6177     const void *data;
6178     DWORD size;
6179 } database_table_data[] =
6180 {
6181     {_Tables, NULL, 0},
6182     {_StringData, NULL, 0},
6183     {_StringPool, data14, sizeof data14},
6184 };
6185
6186 static void enum_stream_names(IStorage *stg)
6187 {
6188     IEnumSTATSTG *stgenum = NULL;
6189     IStream *stm;
6190     HRESULT hr;
6191     STATSTG stat;
6192     ULONG n, count;
6193     BYTE data[MAX_PATH];
6194     BYTE check[MAX_PATH];
6195     DWORD sz;
6196
6197     memset(check, 'a', MAX_PATH);
6198
6199     hr = IStorage_EnumElements(stg, 0, NULL, 0, &stgenum);
6200     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6201
6202     n = 0;
6203     while(TRUE)
6204     {
6205         count = 0;
6206         hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &count);
6207         if(FAILED(hr) || !count)
6208             break;
6209
6210         ok(!lstrcmpW(stat.pwcsName, database_table_data[n].name),
6211            "Expected table %d name to match\n", n);
6212
6213         stm = NULL;
6214         hr = IStorage_OpenStream(stg, stat.pwcsName, NULL,
6215                                  STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6216         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6217         ok(stm != NULL, "Expected non-NULL stream\n");
6218
6219         CoTaskMemFree(stat.pwcsName);
6220
6221         sz = MAX_PATH;
6222         memset(data, 'a', MAX_PATH);
6223         hr = IStream_Read(stm, data, sz, &count);
6224         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6225
6226         ok(count == database_table_data[n].size,
6227            "Expected %d, got %d\n", database_table_data[n].size, count);
6228
6229         if (!database_table_data[n].size)
6230             ok(!memcmp(data, check, MAX_PATH), "data should not be changed\n");
6231         else
6232             ok(!memcmp(data, database_table_data[n].data, database_table_data[n].size),
6233                "Expected table %d data to match\n", n);
6234
6235         IStream_Release(stm);
6236         n++;
6237     }
6238
6239     ok(n == 3, "Expected 3, got %d\n", n);
6240
6241     IEnumSTATSTG_Release(stgenum);
6242 }
6243
6244 static void test_defaultdatabase(void)
6245 {
6246     UINT r;
6247     HRESULT hr;
6248     MSIHANDLE hdb;
6249     IStorage *stg = NULL;
6250
6251     DeleteFileA(msifile);
6252
6253     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6254     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6255
6256     r = MsiDatabaseCommit(hdb);
6257     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6258
6259     MsiCloseHandle(hdb);
6260
6261     hr = StgOpenStorage(msifileW, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
6262     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6263     ok(stg != NULL, "Expected non-NULL stg\n");
6264
6265     enum_stream_names(stg);
6266
6267     IStorage_Release(stg);
6268     DeleteFileA(msifile);
6269 }
6270
6271 static void test_order(void)
6272 {
6273     MSIHANDLE hdb, hview, hrec;
6274     CHAR buffer[MAX_PATH];
6275     LPCSTR query;
6276     UINT r, sz;
6277     int val;
6278
6279     hdb = create_db();
6280     ok(hdb, "failed to create db\n");
6281
6282     query = "CREATE TABLE `Empty` ( `A` SHORT NOT NULL PRIMARY KEY `A`)";
6283     r = run_query(hdb, 0, query);
6284     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6285
6286     query = "CREATE TABLE `Mesa` ( `A` SHORT NOT NULL, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
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 ( 1, 2, 9 )";
6291     r = run_query(hdb, 0, query);
6292     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6293
6294     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 3, 4, 7 )";
6295     r = run_query(hdb, 0, query);
6296     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6297
6298     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 5, 6, 8 )";
6299     r = run_query(hdb, 0, query);
6300     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6301
6302     query = "CREATE TABLE `Sideboard` ( `D` SHORT NOT NULL, `E` SHORT, `F` SHORT PRIMARY KEY `D`)";
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 ( 10, 11, 18 )";
6307     r = run_query(hdb, 0, query);
6308     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6309
6310     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 12, 13, 16 )";
6311     r = run_query(hdb, 0, query);
6312     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6313
6314     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 14, 15, 17 )";
6315     r = run_query(hdb, 0, query);
6316     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6317
6318     query = "SELECT `A`, `B` FROM `Mesa` ORDER BY `C`";
6319     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6320     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6321     r = MsiViewExecute(hview, 0);
6322     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6323
6324     r = MsiViewFetch(hview, &hrec);
6325     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6326
6327     val = MsiRecordGetInteger(hrec, 1);
6328     ok(val == 3, "Expected 3, got %d\n", val);
6329
6330     val = MsiRecordGetInteger(hrec, 2);
6331     ok(val == 4, "Expected 3, got %d\n", val);
6332
6333     MsiCloseHandle(hrec);
6334
6335     r = MsiViewFetch(hview, &hrec);
6336     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6337
6338     val = MsiRecordGetInteger(hrec, 1);
6339     ok(val == 5, "Expected 5, got %d\n", val);
6340
6341     val = MsiRecordGetInteger(hrec, 2);
6342     ok(val == 6, "Expected 6, got %d\n", val);
6343
6344     MsiCloseHandle(hrec);
6345
6346     r = MsiViewFetch(hview, &hrec);
6347     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6348
6349     val = MsiRecordGetInteger(hrec, 1);
6350     ok(val == 1, "Expected 1, got %d\n", val);
6351
6352     val = MsiRecordGetInteger(hrec, 2);
6353     ok(val == 2, "Expected 2, got %d\n", val);
6354
6355     MsiCloseHandle(hrec);
6356
6357     r = MsiViewFetch(hview, &hrec);
6358     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6359
6360     MsiViewClose(hview);
6361     MsiCloseHandle(hview);
6362
6363     query = "SELECT `A`, `D` FROM `Mesa`, `Sideboard` ORDER BY `F`";
6364     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6365     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6366     r = MsiViewExecute(hview, 0);
6367     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6368
6369     r = MsiViewFetch(hview, &hrec);
6370     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6371
6372     val = MsiRecordGetInteger(hrec, 1);
6373     ok(val == 1, "Expected 1, got %d\n", val);
6374
6375     val = MsiRecordGetInteger(hrec, 2);
6376     ok(val == 12, "Expected 12, got %d\n", val);
6377
6378     MsiCloseHandle(hrec);
6379
6380     r = MsiViewFetch(hview, &hrec);
6381     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6382
6383     val = MsiRecordGetInteger(hrec, 1);
6384     ok(val == 3, "Expected 3, got %d\n", val);
6385
6386     val = MsiRecordGetInteger(hrec, 2);
6387     ok(val == 12, "Expected 12, got %d\n", val);
6388
6389     MsiCloseHandle(hrec);
6390
6391     r = MsiViewFetch(hview, &hrec);
6392     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6393
6394     val = MsiRecordGetInteger(hrec, 1);
6395     ok(val == 5, "Expected 5, got %d\n", val);
6396
6397     val = MsiRecordGetInteger(hrec, 2);
6398     ok(val == 12, "Expected 12, got %d\n", val);
6399
6400     MsiCloseHandle(hrec);
6401
6402     r = MsiViewFetch(hview, &hrec);
6403     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6404
6405     val = MsiRecordGetInteger(hrec, 1);
6406     ok(val == 1, "Expected 1, got %d\n", val);
6407
6408     val = MsiRecordGetInteger(hrec, 2);
6409     ok(val == 14, "Expected 14, got %d\n", val);
6410
6411     MsiCloseHandle(hrec);
6412
6413     r = MsiViewFetch(hview, &hrec);
6414     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6415
6416     val = MsiRecordGetInteger(hrec, 1);
6417     ok(val == 3, "Expected 3, got %d\n", val);
6418
6419     val = MsiRecordGetInteger(hrec, 2);
6420     ok(val == 14, "Expected 14, got %d\n", val);
6421
6422     MsiCloseHandle(hrec);
6423
6424     r = MsiViewFetch(hview, &hrec);
6425     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6426
6427     val = MsiRecordGetInteger(hrec, 1);
6428     ok(val == 5, "Expected 5, got %d\n", val);
6429
6430     val = MsiRecordGetInteger(hrec, 2);
6431     ok(val == 14, "Expected 14, got %d\n", val);
6432
6433     MsiCloseHandle(hrec);
6434
6435     r = MsiViewFetch(hview, &hrec);
6436     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6437
6438     val = MsiRecordGetInteger(hrec, 1);
6439     ok(val == 1, "Expected 1, got %d\n", val);
6440
6441     val = MsiRecordGetInteger(hrec, 2);
6442     ok(val == 10, "Expected 10, got %d\n", val);
6443
6444     MsiCloseHandle(hrec);
6445
6446     r = MsiViewFetch(hview, &hrec);
6447     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6448
6449     val = MsiRecordGetInteger(hrec, 1);
6450     ok(val == 3, "Expected 3, got %d\n", val);
6451
6452     val = MsiRecordGetInteger(hrec, 2);
6453     ok(val == 10, "Expected 10, got %d\n", val);
6454
6455     MsiCloseHandle(hrec);
6456
6457     r = MsiViewFetch(hview, &hrec);
6458     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6459
6460     val = MsiRecordGetInteger(hrec, 1);
6461     ok(val == 5, "Expected 5, got %d\n", val);
6462
6463     val = MsiRecordGetInteger(hrec, 2);
6464     ok(val == 10, "Expected 10, got %d\n", val);
6465
6466     MsiCloseHandle(hrec);
6467
6468     r = MsiViewFetch(hview, &hrec);
6469     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6470
6471     MsiViewClose(hview);
6472     MsiCloseHandle(hview);
6473
6474     query = "SELECT * FROM `Empty` ORDER BY `A`";
6475     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6476     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6477     r = MsiViewExecute(hview, 0);
6478     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6479
6480     r = MsiViewFetch(hview, &hrec);
6481     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6482
6483     MsiViewClose(hview);
6484     MsiCloseHandle(hview);
6485
6486     query = "CREATE TABLE `Buffet` ( `One` CHAR(72), `Two` SHORT PRIMARY KEY `One`)";
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 ( 'uno',  2)";
6491     r = run_query(hdb, 0, query);
6492     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6493
6494     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'dos',  3)";
6495     r = run_query(hdb, 0, query);
6496     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6497
6498     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'tres',  1)";
6499     r = run_query(hdb, 0, query);
6500     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6501
6502     query = "SELECT * FROM `Buffet` WHERE `One` = 'dos' ORDER BY `Two`";
6503     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6504     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6505     r = MsiViewExecute(hview, 0);
6506     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6507
6508     r = MsiViewFetch(hview, &hrec);
6509     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6510
6511     sz = sizeof(buffer);
6512     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
6513     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6514     ok(!lstrcmpA(buffer, "dos"), "Expected \"dos\", got \"%s\"\n", buffer);
6515
6516     r = MsiRecordGetInteger(hrec, 2);
6517     ok(r == 3, "Expected 3, got %d\n", r);
6518
6519     MsiCloseHandle(hrec);
6520
6521     r = MsiViewFetch(hview, &hrec);
6522     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6523
6524     MsiViewClose(hview);
6525     MsiCloseHandle(hview);
6526     MsiCloseHandle(hdb);
6527 }
6528
6529 static void test_viewmodify_delete_temporary(void)
6530 {
6531     MSIHANDLE hdb, hview, hrec;
6532     const char *query;
6533     UINT r;
6534
6535     DeleteFileA(msifile);
6536
6537     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6538     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6539
6540     query = "CREATE TABLE `Table` ( `A` SHORT PRIMARY KEY `A` )";
6541     r = run_query(hdb, 0, query);
6542     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6543
6544     query = "SELECT * FROM `Table`";
6545     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6546     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6547     r = MsiViewExecute(hview, 0);
6548     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6549
6550     hrec = MsiCreateRecord(1);
6551     MsiRecordSetInteger(hrec, 1, 1);
6552
6553     r = MsiViewModify(hview, MSIMODIFY_INSERT, 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, 2);
6560
6561     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, 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, 3);
6568
6569     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
6570     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6571
6572     MsiCloseHandle(hrec);
6573
6574     hrec = MsiCreateRecord(1);
6575     MsiRecordSetInteger(hrec, 1, 4);
6576
6577     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
6578     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6579
6580     MsiCloseHandle(hrec);
6581     MsiViewClose(hview);
6582     MsiCloseHandle(hview);
6583
6584     query = "SELECT * FROM `Table` WHERE  `A` = 2";
6585     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6586     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6587     r = MsiViewExecute(hview, 0);
6588     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6589     r = MsiViewFetch(hview, &hrec);
6590     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6591
6592     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6593     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6594
6595     MsiCloseHandle(hrec);
6596     MsiViewClose(hview);
6597     MsiCloseHandle(hview);
6598
6599     query = "SELECT * FROM `Table` WHERE  `A` = 3";
6600     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6601     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6602     r = MsiViewExecute(hview, 0);
6603     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6604     r = MsiViewFetch(hview, &hrec);
6605     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6606
6607     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6608     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6609
6610     MsiCloseHandle(hrec);
6611     MsiViewClose(hview);
6612     MsiCloseHandle(hview);
6613
6614     query = "SELECT * FROM `Table` ORDER BY `A`";
6615     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6616     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6617     r = MsiViewExecute(hview, 0);
6618     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
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 == 1, "Expected 1, got %d\n", r);
6625
6626     MsiCloseHandle(hrec);
6627
6628     r = MsiViewFetch(hview, &hrec);
6629     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6630
6631     r = MsiRecordGetInteger(hrec, 1);
6632     ok(r == 4, "Expected 4, got %d\n", r);
6633
6634     MsiCloseHandle(hrec);
6635
6636     r = MsiViewFetch(hview, &hrec);
6637     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6638
6639     MsiViewClose(hview);
6640     MsiCloseHandle(hview);
6641     MsiCloseHandle(hdb);
6642     DeleteFileA(msifile);
6643 }
6644
6645 static void test_deleterow(void)
6646 {
6647     MSIHANDLE hdb, hview, hrec;
6648     const char *query;
6649     char buf[MAX_PATH];
6650     UINT r;
6651     DWORD size;
6652
6653     DeleteFileA(msifile);
6654
6655     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6656     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6657
6658     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6659     r = run_query(hdb, 0, query);
6660     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6661
6662     query = "INSERT INTO `Table` (`A`) VALUES ('one')";
6663     r = run_query(hdb, 0, query);
6664     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6665
6666     query = "INSERT INTO `Table` (`A`) VALUES ('two')";
6667     r = run_query(hdb, 0, query);
6668     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6669
6670     query = "DELETE FROM `Table` WHERE `A` = 'one'";
6671     r = run_query(hdb, 0, query);
6672     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6673
6674     r = MsiDatabaseCommit(hdb);
6675     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6676
6677     MsiCloseHandle(hdb);
6678
6679     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
6680     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6681
6682     query = "SELECT * FROM `Table`";
6683     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6684     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6685     r = MsiViewExecute(hview, 0);
6686     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6687
6688     r = MsiViewFetch(hview, &hrec);
6689     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6690
6691     size = MAX_PATH;
6692     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6693     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6694     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
6695
6696     MsiCloseHandle(hrec);
6697
6698     r = MsiViewFetch(hview, &hrec);
6699     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6700
6701     MsiViewClose(hview);
6702     MsiCloseHandle(hview);
6703     MsiCloseHandle(hdb);
6704     DeleteFileA(msifile);
6705 }
6706
6707 static const CHAR import_dat[] = "A\n"
6708                                  "s72\n"
6709                                  "Table\tA\n"
6710                                  "This is a new 'string' ok\n";
6711
6712 static void test_quotes(void)
6713 {
6714     MSIHANDLE hdb, hview, hrec;
6715     const char *query;
6716     char buf[MAX_PATH];
6717     UINT r;
6718     DWORD size;
6719
6720     DeleteFileA(msifile);
6721
6722     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6723     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6724
6725     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6726     r = run_query(hdb, 0, query);
6727     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6728
6729     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a 'string' ok' )";
6730     r = run_query(hdb, 0, query);
6731     ok(r == ERROR_BAD_QUERY_SYNTAX,
6732        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6733
6734     query = "INSERT INTO `Table` ( `A` ) VALUES ( \"This is a 'string' ok\" )";
6735     r = run_query(hdb, 0, query);
6736     ok(r == ERROR_BAD_QUERY_SYNTAX,
6737        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6738
6739     query = "INSERT INTO `Table` ( `A` ) VALUES ( \"test\" )";
6740     r = run_query(hdb, 0, query);
6741     ok(r == ERROR_BAD_QUERY_SYNTAX,
6742        "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_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6751
6752     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \'string\' ok' )";
6753     r = run_query(hdb, 0, query);
6754     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6755
6756     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \"string\" ok' )";
6757     r = run_query(hdb, 0, query);
6758     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6759
6760     query = "SELECT * FROM `Table`";
6761     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6762     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6763
6764     r = MsiViewExecute(hview, 0);
6765     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6766
6767     r = MsiViewFetch(hview, &hrec);
6768     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6769
6770     size = MAX_PATH;
6771     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6772     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6773     ok(!lstrcmpA(buf, "This is a \"string\" ok"),
6774        "Expected \"This is a \"string\" ok\", got %s\n", buf);
6775
6776     MsiCloseHandle(hrec);
6777
6778     r = MsiViewFetch(hview, &hrec);
6779     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6780
6781     MsiViewClose(hview);
6782     MsiCloseHandle(hview);
6783
6784     write_file("import.idt", import_dat, (sizeof(import_dat) - 1) * sizeof(char));
6785
6786     r = MsiDatabaseImportA(hdb, CURR_DIR, "import.idt");
6787     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6788
6789     DeleteFileA("import.idt");
6790
6791     query = "SELECT * FROM `Table`";
6792     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6793     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6794
6795     r = MsiViewExecute(hview, 0);
6796     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6797
6798     r = MsiViewFetch(hview, &hrec);
6799     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6800
6801     size = MAX_PATH;
6802     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6803     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6804     ok(!lstrcmpA(buf, "This is a new 'string' ok"),
6805        "Expected \"This is a new 'string' ok\", got %s\n", buf);
6806
6807     MsiCloseHandle(hrec);
6808
6809     r = MsiViewFetch(hview, &hrec);
6810     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6811
6812     MsiViewClose(hview);
6813     MsiCloseHandle(hview);
6814     MsiCloseHandle(hdb);
6815     DeleteFileA(msifile);
6816 }
6817
6818 static void test_carriagereturn(void)
6819 {
6820     MSIHANDLE hdb, hview, hrec;
6821     const char *query;
6822     char buf[MAX_PATH];
6823     UINT r;
6824     DWORD size;
6825
6826     DeleteFileA(msifile);
6827
6828     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6829     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6830
6831     query = "CREATE TABLE `Table`\r ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6832     r = run_query(hdb, 0, query);
6833     ok(r == ERROR_BAD_QUERY_SYNTAX,
6834        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6835
6836     query = "CREATE TABLE `Table` \r( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6837     r = run_query(hdb, 0, query);
6838     ok(r == ERROR_BAD_QUERY_SYNTAX,
6839        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6840
6841     query = "CREATE\r TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6842     r = run_query(hdb, 0, query);
6843     ok(r == ERROR_BAD_QUERY_SYNTAX,
6844        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6845
6846     query = "CREATE TABLE\r `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6847     r = run_query(hdb, 0, query);
6848     ok(r == ERROR_BAD_QUERY_SYNTAX,
6849        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6850
6851     query = "CREATE TABLE `Table` (\r `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6852     r = run_query(hdb, 0, query);
6853     ok(r == ERROR_BAD_QUERY_SYNTAX,
6854        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6855
6856     query = "CREATE TABLE `Table` ( `A`\r CHAR(72) NOT NULL PRIMARY KEY `A` )";
6857     r = run_query(hdb, 0, query);
6858     ok(r == ERROR_BAD_QUERY_SYNTAX,
6859        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6860
6861     query = "CREATE TABLE `Table` ( `A` CHAR(72)\r NOT NULL PRIMARY KEY `A` )";
6862     r = run_query(hdb, 0, query);
6863     ok(r == ERROR_BAD_QUERY_SYNTAX,
6864        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6865
6866     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT\r NULL PRIMARY KEY `A` )";
6867     r = run_query(hdb, 0, query);
6868     ok(r == ERROR_BAD_QUERY_SYNTAX,
6869        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6870
6871     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT \rNULL PRIMARY KEY `A` )";
6872     r = run_query(hdb, 0, query);
6873     ok(r == ERROR_BAD_QUERY_SYNTAX,
6874        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6875
6876     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL\r PRIMARY KEY `A` )";
6877     r = run_query(hdb, 0, query);
6878     ok(r == ERROR_BAD_QUERY_SYNTAX,
6879        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6880
6881     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL \rPRIMARY KEY `A` )";
6882     r = run_query(hdb, 0, query);
6883     ok(r == ERROR_BAD_QUERY_SYNTAX,
6884        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6885
6886     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY\r KEY `A` )";
6887     r = run_query(hdb, 0, query);
6888     ok(r == ERROR_BAD_QUERY_SYNTAX,
6889        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6890
6891     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY \rKEY `A` )";
6892     r = run_query(hdb, 0, query);
6893     ok(r == ERROR_BAD_QUERY_SYNTAX,
6894        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6895
6896     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY\r `A` )";
6897     r = run_query(hdb, 0, query);
6898     ok(r == ERROR_BAD_QUERY_SYNTAX,
6899        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6900
6901     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A`\r )";
6902     r = run_query(hdb, 0, query);
6903     ok(r == ERROR_BAD_QUERY_SYNTAX,
6904        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6905
6906     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )\r";
6907     r = run_query(hdb, 0, query);
6908     ok(r == ERROR_BAD_QUERY_SYNTAX,
6909        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6910
6911     query = "CREATE TABLE `\rOne` ( `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 `Tw\ro` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6916     r = run_query(hdb, 0, query);
6917     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6918
6919     query = "CREATE TABLE `Three\r` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6920     r = run_query(hdb, 0, query);
6921     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6922
6923     query = "CREATE TABLE `Four` ( `A\r` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6924     r = run_query(hdb, 0, query);
6925     ok(r == ERROR_BAD_QUERY_SYNTAX,
6926        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6927
6928     query = "CREATE TABLE `Four` ( `\rA` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6929     r = run_query(hdb, 0, query);
6930     ok(r == ERROR_BAD_QUERY_SYNTAX,
6931        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6932
6933     query = "CREATE TABLE `Four` ( `A` CHAR(72\r) NOT NULL PRIMARY KEY `A` )";
6934     r = run_query(hdb, 0, query);
6935     ok(r == ERROR_BAD_QUERY_SYNTAX,
6936        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6937
6938     query = "CREATE TABLE `Four` ( `A` CHAR(\r72) NOT NULL PRIMARY KEY `A` )";
6939     r = run_query(hdb, 0, query);
6940     ok(r == ERROR_BAD_QUERY_SYNTAX,
6941        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6942
6943     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `\rA` )";
6944     r = run_query(hdb, 0, query);
6945     ok(r == ERROR_BAD_QUERY_SYNTAX,
6946        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6947
6948     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
6949     r = run_query(hdb, 0, query);
6950     ok(r == ERROR_BAD_QUERY_SYNTAX,
6951        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6952
6953     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
6954     r = run_query(hdb, 0, query);
6955     ok(r == ERROR_BAD_QUERY_SYNTAX,
6956        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6957
6958     query = "SELECT * FROM `_Tables`";
6959     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6960     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6961     r = MsiViewExecute(hview, 0);
6962     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6963
6964     r = MsiViewFetch(hview, &hrec);
6965     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6966
6967     size = MAX_PATH;
6968     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6969     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6970     ok(!lstrcmpA(buf, "\rOne"), "Expected \"\\rOne\", got \"%s\"\n", buf);
6971
6972     MsiCloseHandle(hrec);
6973
6974     r = MsiViewFetch(hview, &hrec);
6975     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6976
6977     size = MAX_PATH;
6978     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6979     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6980     ok(!lstrcmpA(buf, "Tw\ro"), "Expected \"Tw\\ro\", got \"%s\"\n", buf);
6981
6982     MsiCloseHandle(hrec);
6983
6984     r = MsiViewFetch(hview, &hrec);
6985     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6986
6987     size = MAX_PATH;
6988     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6989     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6990     ok(!lstrcmpA(buf, "Three\r"), "Expected \"Three\r\", got \"%s\"\n", buf);
6991
6992     MsiCloseHandle(hrec);
6993
6994     r = MsiViewFetch(hview, &hrec);
6995     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6996
6997     MsiViewClose(hview);
6998     MsiCloseHandle(hview);
6999
7000     MsiCloseHandle(hdb);
7001     DeleteFileA(msifile);
7002 }
7003
7004 static void test_noquotes(void)
7005 {
7006     MSIHANDLE hdb, hview, hrec;
7007     const char *query;
7008     char buf[MAX_PATH];
7009     UINT r;
7010     DWORD size;
7011
7012     DeleteFileA(msifile);
7013
7014     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7015     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7016
7017     query = "CREATE TABLE Table ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
7018     r = run_query(hdb, 0, query);
7019     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7020
7021     query = "CREATE TABLE `Table` ( 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 = "CREATE TABLE `Table2` ( `A` CHAR(72) NOT NULL PRIMARY KEY A )";
7026     r = run_query(hdb, 0, query);
7027     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7028
7029     query = "CREATE TABLE `Table3` ( A CHAR(72) NOT NULL PRIMARY KEY A )";
7030     r = run_query(hdb, 0, query);
7031     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7032
7033     query = "SELECT * FROM `_Tables`";
7034     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7035     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7036     r = MsiViewExecute(hview, 0);
7037     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7038
7039     r = MsiViewFetch(hview, &hrec);
7040     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7041
7042     size = MAX_PATH;
7043     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7044     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7045     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
7046
7047     MsiCloseHandle(hrec);
7048
7049     r = MsiViewFetch(hview, &hrec);
7050     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7051
7052     size = MAX_PATH;
7053     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7054     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7055     ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
7056
7057     MsiCloseHandle(hrec);
7058
7059     r = MsiViewFetch(hview, &hrec);
7060     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7061
7062     size = MAX_PATH;
7063     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7064     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7065     ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
7066
7067     MsiCloseHandle(hrec);
7068
7069     r = MsiViewFetch(hview, &hrec);
7070     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7071
7072     MsiViewClose(hview);
7073     MsiCloseHandle(hview);
7074
7075     query = "SELECT * FROM `_Columns`";
7076     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7077     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7078     r = MsiViewExecute(hview, 0);
7079     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7080
7081     r = MsiViewFetch(hview, &hrec);
7082     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7083
7084     size = MAX_PATH;
7085     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7086     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7087     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
7088
7089     r = MsiRecordGetInteger(hrec, 2);
7090     ok(r == 1, "Expected 1, got %d\n", r);
7091
7092     size = MAX_PATH;
7093     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7094     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7095     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7096
7097     MsiCloseHandle(hrec);
7098
7099     r = MsiViewFetch(hview, &hrec);
7100     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7101
7102     size = MAX_PATH;
7103     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7104     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7105     ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
7106
7107     r = MsiRecordGetInteger(hrec, 2);
7108     ok(r == 1, "Expected 1, got %d\n", r);
7109
7110     size = MAX_PATH;
7111     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7112     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7113     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7114
7115     MsiCloseHandle(hrec);
7116
7117     r = MsiViewFetch(hview, &hrec);
7118     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7119
7120     size = MAX_PATH;
7121     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7122     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7123     ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
7124
7125     r = MsiRecordGetInteger(hrec, 2);
7126     ok(r == 1, "Expected 1, got %d\n", r);
7127
7128     size = MAX_PATH;
7129     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7130     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7131     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7132
7133     MsiCloseHandle(hrec);
7134
7135     r = MsiViewFetch(hview, &hrec);
7136     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7137
7138     MsiViewClose(hview);
7139     MsiCloseHandle(hview);
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 = "INSERT INTO `Table` ( A ) VALUES ( 'hi' )";
7146     r = run_query(hdb, 0, query);
7147     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7148
7149     query = "INSERT INTO `Table` ( `A` ) VALUES ( 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 WHERE `A` = 'hi'";
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 `Table` WHERE `A` = hi";
7158     r = run_query(hdb, 0, query);
7159     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7160
7161     query = "SELECT * FROM Table";
7162     r = run_query(hdb, 0, query);
7163     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7164
7165     query = "SELECT * FROM Table2";
7166     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7167     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7168     r = MsiViewExecute(hview, 0);
7169     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7170
7171     r = MsiViewFetch(hview, &hrec);
7172     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7173
7174     MsiViewClose(hview);
7175     MsiCloseHandle(hview);
7176
7177     query = "SELECT * FROM `Table` WHERE A = 'hi'";
7178     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7179     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7180     r = MsiViewExecute(hview, 0);
7181     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7182
7183     r = MsiViewFetch(hview, &hrec);
7184     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7185
7186     size = MAX_PATH;
7187     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7188     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7189     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
7190
7191     MsiCloseHandle(hrec);
7192
7193     r = MsiViewFetch(hview, &hrec);
7194     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7195
7196     MsiViewClose(hview);
7197     MsiCloseHandle(hview);
7198     MsiCloseHandle(hdb);
7199     DeleteFileA(msifile);
7200 }
7201
7202 static void read_file_data(LPCSTR filename, LPSTR buffer)
7203 {
7204     HANDLE file;
7205     DWORD read;
7206
7207     file = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
7208     ZeroMemory(buffer, MAX_PATH);
7209     ReadFile(file, buffer, MAX_PATH, &read, NULL);
7210     CloseHandle(file);
7211 }
7212
7213 static void test_forcecodepage(void)
7214 {
7215     MSIHANDLE hdb;
7216     const char *query;
7217     char buffer[MAX_PATH];
7218     UINT r;
7219
7220     DeleteFileA(msifile);
7221     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
7222
7223     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
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     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
7231     r = run_query(hdb, 0, query);
7232     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7233
7234     query = "SELECT * FROM `_ForceCodepage`";
7235     r = run_query(hdb, 0, query);
7236     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7237
7238     r = MsiDatabaseCommit(hdb);
7239     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7240
7241     query = "SELECT * FROM `_ForceCodepage`";
7242     r = run_query(hdb, 0, query);
7243     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7244
7245     MsiCloseHandle(hdb);
7246
7247     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_DIRECT, &hdb);
7248     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7249
7250     query = "SELECT * FROM `_ForceCodepage`";
7251     r = run_query(hdb, 0, query);
7252     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7253
7254     r = MsiDatabaseExportA(hdb, "_ForceCodepage", CURR_DIR, "forcecodepage.idt");
7255     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7256
7257     read_file_data("forcecodepage.idt", buffer);
7258     ok(!lstrcmpA(buffer, "\r\n\r\n0\t_ForceCodepage\r\n"),
7259        "Expected \"\r\n\r\n0\t_ForceCodepage\r\n\", got \"%s\"\n", buffer);
7260
7261     create_file_data("forcecodepage.idt", "\r\n\r\n850\t_ForceCodepage\r\n", 0);
7262
7263     r = MsiDatabaseImportA(hdb, CURR_DIR, "forcecodepage.idt");
7264     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7265
7266     r = MsiDatabaseExportA(hdb, "_ForceCodepage", CURR_DIR, "forcecodepage.idt");
7267     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7268
7269     read_file_data("forcecodepage.idt", buffer);
7270     ok(!lstrcmpA(buffer, "\r\n\r\n850\t_ForceCodepage\r\n"),
7271        "Expected \"\r\n\r\n850\t_ForceCodepage\r\n\", got \"%s\"\n", buffer);
7272
7273     create_file_data("forcecodepage.idt", "\r\n\r\n9999\t_ForceCodepage\r\n", 0);
7274
7275     r = MsiDatabaseImportA(hdb, CURR_DIR, "forcecodepage.idt");
7276     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
7277
7278     MsiCloseHandle(hdb);
7279     DeleteFileA(msifile);
7280     DeleteFileA("forcecodepage.idt");
7281 }
7282
7283 static void test_viewmodify_refresh(void)
7284 {
7285     MSIHANDLE hdb, hview, hrec;
7286     const char *query;
7287     char buffer[MAX_PATH];
7288     UINT r;
7289     DWORD size;
7290
7291     DeleteFileA(msifile);
7292
7293     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7294     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7295
7296     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL, `B` INT PRIMARY KEY `A` )";
7297     r = run_query(hdb, 0, query);
7298     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7299
7300     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hi', 1 )";
7301     r = run_query(hdb, 0, query);
7302     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7303
7304     query = "SELECT * FROM `Table`";
7305     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7306     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7307     r = MsiViewExecute(hview, 0);
7308     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7309
7310     r = MsiViewFetch(hview, &hrec);
7311     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7312
7313     query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hi'";
7314     r = run_query(hdb, 0, query);
7315     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7316
7317     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7318     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7319
7320     size = MAX_PATH;
7321     r = MsiRecordGetStringA(hrec, 1, buffer, &size);
7322     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7323     ok(!lstrcmpA(buffer, "hi"), "Expected \"hi\", got \"%s\"\n", buffer);
7324     ok(size == 2, "Expected 2, got %d\n", size);
7325
7326     r = MsiRecordGetInteger(hrec, 2);
7327     ok(r == 2, "Expected 2, got %d\n", r);
7328
7329     MsiCloseHandle(hrec);
7330     MsiViewClose(hview);
7331     MsiCloseHandle(hview);
7332
7333     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hello', 3 )";
7334     r = run_query(hdb, 0, query);
7335     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7336
7337     query = "SELECT * FROM `Table` WHERE `B` = 3";
7338     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7339     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7340     r = MsiViewExecute(hview, 0);
7341     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7342
7343     r = MsiViewFetch(hview, &hrec);
7344     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7345
7346     query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hello'";
7347     r = run_query(hdb, 0, query);
7348     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7349
7350     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hithere', 3 )";
7351     r = run_query(hdb, 0, query);
7352     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7353
7354     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7355     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7356
7357     size = MAX_PATH;
7358     r = MsiRecordGetStringA(hrec, 1, buffer, &size);
7359     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7360     ok(!lstrcmpA(buffer, "hello"), "Expected \"hello\", got \"%s\"\n", buffer);
7361     ok(size == 5, "Expected 5, got %d\n", size);
7362
7363     r = MsiRecordGetInteger(hrec, 2);
7364     ok(r == 2, "Expected 2, got %d\n", r);
7365
7366     MsiCloseHandle(hrec);
7367     MsiViewClose(hview);
7368     MsiCloseHandle(hview);
7369     MsiCloseHandle(hdb);
7370     DeleteFileA(msifile);
7371 }
7372
7373 static void test_where_viewmodify(void)
7374 {
7375     MSIHANDLE hdb, hview, hrec;
7376     const char *query;
7377     UINT r;
7378
7379     DeleteFileA(msifile);
7380
7381     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7382     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7383
7384     query = "CREATE TABLE `Table` ( `A` INT, `B` INT PRIMARY KEY `A` )";
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 ( 1, 2 )";
7389     r = run_query(hdb, 0, query);
7390     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7391
7392     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 3, 4 )";
7393     r = run_query(hdb, 0, query);
7394     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7395
7396     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 5, 6 )";
7397     r = run_query(hdb, 0, query);
7398     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7399
7400     /* `B` = 3 doesn't match, but the view shouldn't be executed */
7401     query = "SELECT * FROM `Table` WHERE `B` = 3";
7402     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7403     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7404
7405     hrec = MsiCreateRecord(2);
7406     MsiRecordSetInteger(hrec, 1, 7);
7407     MsiRecordSetInteger(hrec, 2, 8);
7408
7409     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
7410     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7411
7412     MsiCloseHandle(hrec);
7413     MsiViewClose(hview);
7414     MsiCloseHandle(hview);
7415
7416     query = "SELECT * FROM `Table` WHERE `A` = 7";
7417     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7418     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7419     r = MsiViewExecute(hview, 0);
7420     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7421
7422     r = MsiViewFetch(hview, &hrec);
7423     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7424
7425     r = MsiRecordGetInteger(hrec, 1);
7426     ok(r == 7, "Expected 7, got %d\n", r);
7427
7428     r = MsiRecordGetInteger(hrec, 2);
7429     ok(r == 8, "Expected 8, got %d\n", r);
7430
7431     MsiRecordSetInteger(hrec, 2, 9);
7432
7433     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
7434     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7435
7436     MsiCloseHandle(hrec);
7437     MsiViewClose(hview);
7438     MsiCloseHandle(hview);
7439
7440     query = "SELECT * FROM `Table` WHERE `A` = 7";
7441     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7442     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7443     r = MsiViewExecute(hview, 0);
7444     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7445
7446     r = MsiViewFetch(hview, &hrec);
7447     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7448
7449     r = MsiRecordGetInteger(hrec, 1);
7450     ok(r == 7, "Expected 7, got %d\n", r);
7451
7452     r = MsiRecordGetInteger(hrec, 2);
7453     ok(r == 9, "Expected 9, got %d\n", r);
7454
7455     query = "UPDATE `Table` SET `B` = 10 WHERE `A` = 7";
7456     r = run_query(hdb, 0, query);
7457     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7458
7459     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7460     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7461
7462     r = MsiRecordGetInteger(hrec, 1);
7463     ok(r == 7, "Expected 7, got %d\n", r);
7464
7465     r = MsiRecordGetInteger(hrec, 2);
7466     ok(r == 10, "Expected 10, got %d\n", r);
7467
7468     MsiCloseHandle(hrec);
7469     MsiViewClose(hview);
7470     MsiCloseHandle(hview);
7471     MsiCloseHandle(hdb);
7472 }
7473
7474 static BOOL create_storage(LPCSTR name)
7475 {
7476     WCHAR nameW[MAX_PATH];
7477     IStorage *stg;
7478     IStream *stm;
7479     HRESULT hr;
7480     DWORD count;
7481     BOOL res = FALSE;
7482
7483     MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, MAX_PATH);
7484     hr = StgCreateDocfile(nameW, STGM_CREATE | STGM_READWRITE |
7485                           STGM_DIRECT | STGM_SHARE_EXCLUSIVE, 0, &stg);
7486     if (FAILED(hr))
7487         return FALSE;
7488
7489     hr = IStorage_CreateStream(stg, nameW, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
7490                                0, 0, &stm);
7491     if (FAILED(hr))
7492         goto done;
7493
7494     hr = IStream_Write(stm, "stgdata", 8, &count);
7495     if (SUCCEEDED(hr))
7496         res = TRUE;
7497
7498 done:
7499     IStream_Release(stm);
7500     IStorage_Release(stg);
7501
7502     return res;
7503 }
7504
7505 static void test_storages_table(void)
7506 {
7507     MSIHANDLE hdb, hview, hrec;
7508     IStorage *stg, *inner;
7509     IStream *stm;
7510     char file[MAX_PATH];
7511     char buf[MAX_PATH];
7512     WCHAR name[MAX_PATH];
7513     LPCSTR query;
7514     HRESULT hr;
7515     DWORD size;
7516     UINT r;
7517
7518     hdb = create_db();
7519     ok(hdb, "failed to create db\n");
7520
7521     r = MsiDatabaseCommit(hdb);
7522     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
7523
7524     MsiCloseHandle(hdb);
7525
7526     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb);
7527     ok(r == ERROR_SUCCESS , "Failed to open database\n");
7528
7529     /* check the column types */
7530     hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_TYPES);
7531     ok(hrec, "failed to get column info hrecord\n");
7532     ok(check_record(hrec, 1, "s62"), "wrong hrecord type\n");
7533     ok(check_record(hrec, 2, "V0"), "wrong hrecord type\n");
7534
7535     MsiCloseHandle(hrec);
7536
7537     /* now try the names */
7538     hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_NAMES);
7539     ok(hrec, "failed to get column info hrecord\n");
7540     ok(check_record(hrec, 1, "Name"), "wrong hrecord type\n");
7541     ok(check_record(hrec, 2, "Data"), "wrong hrecord type\n");
7542
7543     MsiCloseHandle(hrec);
7544
7545     create_storage("storage.bin");
7546
7547     hrec = MsiCreateRecord(2);
7548     MsiRecordSetStringA(hrec, 1, "stgname");
7549
7550     r = MsiRecordSetStreamA(hrec, 2, "storage.bin");
7551     ok(r == ERROR_SUCCESS, "Failed to add stream data to the hrecord: %d\n", r);
7552
7553     DeleteFileA("storage.bin");
7554
7555     query = "INSERT INTO `_Storages` (`Name`, `Data`) VALUES (?, ?)";
7556     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7557     ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
7558
7559     r = MsiViewExecute(hview, hrec);
7560     ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
7561
7562     MsiCloseHandle(hrec);
7563     MsiViewClose(hview);
7564     MsiCloseHandle(hview);
7565
7566     query = "SELECT `Name`, `Data` FROM `_Storages`";
7567     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7568     ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
7569
7570     r = MsiViewExecute(hview, 0);
7571     ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
7572
7573     r = MsiViewFetch(hview, &hrec);
7574     ok(r == ERROR_SUCCESS, "Failed to fetch hrecord: %d\n", r);
7575
7576     size = MAX_PATH;
7577     r = MsiRecordGetStringA(hrec, 1, file, &size);
7578     ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
7579     ok(!lstrcmpA(file, "stgname"), "Expected \"stgname\", got \"%s\"\n", file);
7580
7581     size = MAX_PATH;
7582     lstrcpyA(buf, "apple");
7583     r = MsiRecordReadStream(hrec, 2, buf, &size);
7584     ok(r == ERROR_INVALID_DATA, "Expected ERROR_INVALID_DATA, got %d\n", r);
7585     ok(!lstrcmpA(buf, "apple"), "Expected buf to be unchanged, got %s\n", buf);
7586     ok(size == 0, "Expected 0, got %d\n", size);
7587
7588     MsiCloseHandle(hrec);
7589
7590     r = MsiViewFetch(hview, &hrec);
7591     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7592
7593     MsiViewClose(hview);
7594     MsiCloseHandle(hview);
7595
7596     MsiDatabaseCommit(hdb);
7597     MsiCloseHandle(hdb);
7598
7599     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, MAX_PATH);
7600     hr = StgOpenStorage(name, NULL, STGM_DIRECT | STGM_READ |
7601                         STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
7602     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7603     ok(stg != NULL, "Expected non-NULL storage\n");
7604
7605     MultiByteToWideChar(CP_ACP, 0, "stgname", -1, name, MAX_PATH);
7606     hr = IStorage_OpenStorage(stg, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE,
7607                               NULL, 0, &inner);
7608     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7609     ok(inner != NULL, "Expected non-NULL storage\n");
7610
7611     MultiByteToWideChar(CP_ACP, 0, "storage.bin", -1, name, MAX_PATH);
7612     hr = IStorage_OpenStream(inner, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
7613     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7614     ok(stm != NULL, "Expected non-NULL stream\n");
7615
7616     hr = IStream_Read(stm, buf, MAX_PATH, &size);
7617     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
7618     ok(size == 8, "Expected 8, got %d\n", size);
7619     ok(!lstrcmpA(buf, "stgdata"), "Expected \"stgdata\", got \"%s\"\n", buf);
7620
7621     IStream_Release(stm);
7622     IStorage_Release(inner);
7623
7624     IStorage_Release(stg);
7625     DeleteFileA(msifile);
7626 }
7627
7628 static void test_dbtopackage(void)
7629 {
7630     MSIHANDLE hdb, hpkg;
7631     CHAR package[12], buf[MAX_PATH];
7632     DWORD size;
7633     UINT r;
7634
7635     /* create an empty database, transact mode */
7636     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7637     ok(r == ERROR_SUCCESS, "Failed to create database\n");
7638
7639     set_summary_info(hdb);
7640
7641     r = create_directory_table(hdb);
7642     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7643
7644     r = create_custom_action_table(hdb);
7645     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7646
7647     r = add_custom_action_entry(hdb, "'SetProp', 51, 'MYPROP', 'grape'");
7648     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7649
7650     sprintf(package, "#%u", hdb);
7651     r = MsiOpenPackageA(package, &hpkg);
7652     if (r == ERROR_INSTALL_PACKAGE_REJECTED)
7653     {
7654         skip("Not enough rights to perform tests\n");
7655         goto error;
7656     }
7657     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7658
7659     /* property is not set yet */
7660     size = MAX_PATH;
7661     lstrcpyA(buf, "kiwi");
7662     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7663     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7664     ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7665     ok(size == 0, "Expected 0, got %d\n", size);
7666
7667     /* run the custom action to set the property */
7668     r = MsiDoActionA(hpkg, "SetProp");
7669     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7670
7671     /* property is now set */
7672     size = MAX_PATH;
7673     lstrcpyA(buf, "kiwi");
7674     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7675     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7676     ok(!lstrcmpA(buf, "grape"), "Expected \"grape\", got \"%s\"\n", buf);
7677     ok(size == 5, "Expected 5, got %d\n", size);
7678
7679     MsiCloseHandle(hpkg);
7680
7681     /* reset the package */
7682     r = MsiOpenPackageA(package, &hpkg);
7683     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7684
7685     /* property is not set anymore */
7686     size = MAX_PATH;
7687     lstrcpyA(buf, "kiwi");
7688     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7689     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7690     todo_wine
7691     {
7692         ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7693         ok(size == 0, "Expected 0, got %d\n", size);
7694     }
7695
7696     MsiCloseHandle(hdb);
7697     MsiCloseHandle(hpkg);
7698
7699     /* create an empty database, direct mode */
7700     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATEDIRECT, &hdb);
7701     ok(r == ERROR_SUCCESS, "Failed to create database\n");
7702
7703     set_summary_info(hdb);
7704
7705     r = create_directory_table(hdb);
7706     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7707
7708     r = create_custom_action_table(hdb);
7709     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7710
7711     r = add_custom_action_entry(hdb, "'SetProp', 51, 'MYPROP', 'grape'");
7712     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7713
7714     sprintf(package, "#%u", hdb);
7715     r = MsiOpenPackageA(package, &hpkg);
7716     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7717
7718     /* property is not set yet */
7719     size = MAX_PATH;
7720     lstrcpyA(buf, "kiwi");
7721     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7722     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7723     ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7724     ok(size == 0, "Expected 0, got %d\n", size);
7725
7726     /* run the custom action to set the property */
7727     r = MsiDoActionA(hpkg, "SetProp");
7728     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7729
7730     /* property is now set */
7731     size = MAX_PATH;
7732     lstrcpyA(buf, "kiwi");
7733     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7734     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7735     ok(!lstrcmpA(buf, "grape"), "Expected \"grape\", got \"%s\"\n", buf);
7736     ok(size == 5, "Expected 5, got %d\n", size);
7737
7738     MsiCloseHandle(hpkg);
7739
7740     /* reset the package */
7741     r = MsiOpenPackageA(package, &hpkg);
7742     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7743
7744     /* property is not set anymore */
7745     size = MAX_PATH;
7746     lstrcpyA(buf, "kiwi");
7747     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7748     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7749     todo_wine
7750     {
7751         ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7752         ok(size == 0, "Expected 0, got %d\n", size);
7753     }
7754
7755     MsiCloseHandle(hpkg);
7756
7757 error:
7758     MsiCloseHandle(hdb);
7759     DeleteFileA(msifile);
7760 }
7761
7762 static void test_droptable(void)
7763 {
7764     MSIHANDLE hdb, hview, hrec;
7765     CHAR buf[MAX_PATH];
7766     LPCSTR query;
7767     DWORD size;
7768     UINT r;
7769
7770     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7771     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7772
7773     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
7774     r = run_query(hdb, 0, query);
7775     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7776
7777     query = "SELECT * FROM `One`";
7778     r = do_query(hdb, query, &hrec);
7779     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7780
7781     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7782     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7783     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7784     r = MsiViewExecute(hview, 0);
7785     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7786
7787     r = MsiViewFetch(hview, &hrec);
7788     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7789
7790     size = MAX_PATH;
7791     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7792     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7793     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7794
7795     MsiCloseHandle(hrec);
7796     MsiViewClose(hview);
7797     MsiCloseHandle(hview);
7798
7799     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7800     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7801     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7802     r = MsiViewExecute(hview, 0);
7803     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7804
7805     r = MsiViewFetch(hview, &hrec);
7806     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7807
7808     size = MAX_PATH;
7809     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7810     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7811     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7812
7813     r = MsiRecordGetInteger(hrec, 2);
7814     ok(r == 1, "Expected 1, got %d\n", r);
7815
7816     size = MAX_PATH;
7817     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7818     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7819     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7820
7821     MsiCloseHandle(hrec);
7822
7823     r = MsiViewFetch(hview, &hrec);
7824     ok(r == ERROR_NO_MORE_ITEMS,
7825        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7826
7827     MsiViewClose(hview);
7828     MsiCloseHandle(hview);
7829
7830     query = "DROP `One`";
7831     r = run_query(hdb, 0, query);
7832     ok(r == ERROR_BAD_QUERY_SYNTAX,
7833        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7834
7835     query = "DROP TABLE";
7836     r = run_query(hdb, 0, query);
7837     ok(r == ERROR_BAD_QUERY_SYNTAX,
7838        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7839
7840     query = "DROP TABLE `One`";
7841     hview = 0;
7842     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7843     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7844     r = MsiViewExecute(hview, 0);
7845     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7846
7847     r = MsiViewFetch(hview, &hrec);
7848     ok(r == ERROR_FUNCTION_FAILED,
7849        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
7850
7851     MsiViewClose(hview);
7852     MsiCloseHandle(hview);
7853
7854     query = "SELECT * FROM `IDontExist`";
7855     r = do_query(hdb, query, &hrec);
7856     ok(r == ERROR_BAD_QUERY_SYNTAX,
7857        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7858
7859     query = "SELECT * FROM `One`";
7860     r = do_query(hdb, query, &hrec);
7861     ok(r == ERROR_BAD_QUERY_SYNTAX,
7862        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7863
7864     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
7865     r = run_query(hdb, 0, query);
7866     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7867
7868     query = "DROP TABLE One";
7869     r = run_query(hdb, 0, query);
7870     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7871
7872     query = "SELECT * FROM `One`";
7873     r = do_query(hdb, query, &hrec);
7874     ok(r == ERROR_BAD_QUERY_SYNTAX,
7875        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7876
7877     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7878     r = do_query(hdb, query, &hrec);
7879     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7880
7881     query = "SELECT * FROM `_Columns` WHERE `Table` = '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 = "CREATE TABLE `One` ( `B` INT, `C` INT PRIMARY KEY `B` )";
7886     r = run_query(hdb, 0, query);
7887     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7888
7889     query = "SELECT * FROM `One`";
7890     r = do_query(hdb, query, &hrec);
7891     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7892
7893     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7894     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7895     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7896     r = MsiViewExecute(hview, 0);
7897     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7898
7899     r = MsiViewFetch(hview, &hrec);
7900     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7901
7902     size = MAX_PATH;
7903     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7904     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7905     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7906
7907     MsiCloseHandle(hrec);
7908     MsiViewClose(hview);
7909     MsiCloseHandle(hview);
7910
7911     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7912     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7913     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7914     r = MsiViewExecute(hview, 0);
7915     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7916
7917     r = MsiViewFetch(hview, &hrec);
7918     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7919
7920     size = MAX_PATH;
7921     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7922     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7923     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7924
7925     r = MsiRecordGetInteger(hrec, 2);
7926     ok(r == 1, "Expected 1, got %d\n", r);
7927
7928     size = MAX_PATH;
7929     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7930     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7931     ok(!lstrcmpA(buf, "B"), "Expected \"B\", got \"%s\"\n", buf);
7932
7933     MsiCloseHandle(hrec);
7934
7935     r = MsiViewFetch(hview, &hrec);
7936     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7937
7938     size = MAX_PATH;
7939     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7940     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7941     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7942
7943     r = MsiRecordGetInteger(hrec, 2);
7944     ok(r == 2, "Expected 2, got %d\n", r);
7945
7946     size = MAX_PATH;
7947     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7948     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7949     ok(!lstrcmpA(buf, "C"), "Expected \"C\", got \"%s\"\n", buf);
7950
7951     MsiCloseHandle(hrec);
7952
7953     r = MsiViewFetch(hview, &hrec);
7954     ok(r == ERROR_NO_MORE_ITEMS,
7955        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7956
7957     MsiViewClose(hview);
7958     MsiCloseHandle(hview);
7959
7960     query = "DROP TABLE One";
7961     r = run_query(hdb, 0, query);
7962     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7963
7964     query = "SELECT * FROM `One`";
7965     r = do_query(hdb, query, &hrec);
7966     ok(r == ERROR_BAD_QUERY_SYNTAX,
7967        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7968
7969     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7970     r = do_query(hdb, query, &hrec);
7971     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7972
7973     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7974     r = do_query(hdb, query, &hrec);
7975     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7976
7977     MsiCloseHandle(hdb);
7978     DeleteFileA(msifile);
7979 }
7980
7981 static void test_dbmerge(void)
7982 {
7983     static const WCHAR refdbW[] = {'r','e','f','d','b','.','m','s','i',0};
7984     MSIHANDLE hdb, href, hview, hrec;
7985     CHAR buf[MAX_PATH];
7986     LPCSTR query;
7987     DWORD size;
7988     UINT r;
7989
7990     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7991     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7992
7993     r = MsiOpenDatabaseW(refdbW, MSIDBOPEN_CREATE, &href);
7994     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7995
7996     /* hDatabase is invalid */
7997     r = MsiDatabaseMergeA(0, href, "MergeErrors");
7998     ok(r == ERROR_INVALID_HANDLE,
7999        "Expected ERROR_INVALID_HANDLE, got %d\n", r);
8000
8001     /* hDatabaseMerge is invalid */
8002     r = MsiDatabaseMergeA(hdb, 0, "MergeErrors");
8003     ok(r == ERROR_INVALID_HANDLE,
8004        "Expected ERROR_INVALID_HANDLE, got %d\n", r);
8005
8006     /* szTableName is NULL */
8007     r = MsiDatabaseMergeA(hdb, href, NULL);
8008     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8009
8010     /* szTableName is empty */
8011     r = MsiDatabaseMergeA(hdb, href, "");
8012     ok(r == ERROR_INVALID_TABLE, "Expected ERROR_INVALID_TABLE, got %d\n", r);
8013
8014     /* both DBs empty, szTableName is valid */
8015     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8016     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8017
8018     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
8019     r = run_query(hdb, 0, query);
8020     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8021
8022     query = "CREATE TABLE `One` ( `A` CHAR(72) PRIMARY KEY `A` )";
8023     r = run_query(href, 0, query);
8024     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8025
8026     /* column types don't match */
8027     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8028     ok(r == ERROR_DATATYPE_MISMATCH,
8029        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8030
8031     /* nothing in MergeErrors */
8032     query = "SELECT * FROM `MergeErrors`";
8033     r = do_query(hdb, query, &hrec);
8034     ok(r == ERROR_BAD_QUERY_SYNTAX,
8035        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8036
8037     query = "DROP TABLE `One`";
8038     r = run_query(hdb, 0, query);
8039     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8040
8041     query = "DROP TABLE `One`";
8042     r = run_query(href, 0, query);
8043     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8044
8045     query = "CREATE TABLE `One` ( "
8046         "`A` CHAR(72), "
8047         "`B` CHAR(56), "
8048         "`C` CHAR(64) LOCALIZABLE, "
8049         "`D` LONGCHAR, "
8050         "`E` CHAR(72) NOT NULL, "
8051         "`F` CHAR(56) NOT NULL, "
8052         "`G` CHAR(64) NOT NULL LOCALIZABLE, "
8053         "`H` LONGCHAR NOT NULL "
8054         "PRIMARY KEY `A` )";
8055     r = run_query(hdb, 0, query);
8056     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8057
8058     query = "CREATE TABLE `One` ( "
8059         "`A` CHAR(64), "
8060         "`B` CHAR(64), "
8061         "`C` CHAR(64), "
8062         "`D` CHAR(64), "
8063         "`E` CHAR(64) NOT NULL, "
8064         "`F` CHAR(64) NOT NULL, "
8065         "`G` CHAR(64) NOT NULL, "
8066         "`H` CHAR(64) NOT NULL "
8067         "PRIMARY KEY `A` )";
8068     r = run_query(href, 0, query);
8069     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8070
8071     /* column string types don't match exactly */
8072     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8073     ok(r == ERROR_SUCCESS,
8074        "Expected ERROR_SUCCESS, got %d\n", r);
8075
8076     /* nothing in MergeErrors */
8077     query = "SELECT * FROM `MergeErrors`";
8078     r = do_query(hdb, query, &hrec);
8079     ok(r == ERROR_BAD_QUERY_SYNTAX,
8080        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8081
8082     query = "DROP TABLE `One`";
8083     r = run_query(hdb, 0, query);
8084     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8085
8086     query = "DROP TABLE `One`";
8087     r = run_query(href, 0, query);
8088     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8089
8090     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8091     r = run_query(hdb, 0, query);
8092     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8093
8094     query = "CREATE TABLE `One` ( `A` INT, `C` INT PRIMARY KEY `A` )";
8095     r = run_query(href, 0, query);
8096     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8097
8098     /* column names don't match */
8099     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8100     ok(r == ERROR_DATATYPE_MISMATCH,
8101        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8102
8103     /* nothing in MergeErrors */
8104     query = "SELECT * FROM `MergeErrors`";
8105     r = do_query(hdb, query, &hrec);
8106     ok(r == ERROR_BAD_QUERY_SYNTAX,
8107        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8108
8109     query = "DROP TABLE `One`";
8110     r = run_query(hdb, 0, query);
8111     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8112
8113     query = "DROP TABLE `One`";
8114     r = run_query(href, 0, query);
8115     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8116
8117     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8118     r = run_query(hdb, 0, query);
8119     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8120
8121     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `B` )";
8122     r = run_query(href, 0, query);
8123     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8124
8125     /* primary keys don't match */
8126     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8127     ok(r == ERROR_DATATYPE_MISMATCH,
8128        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8129
8130     /* nothing in MergeErrors */
8131     query = "SELECT * FROM `MergeErrors`";
8132     r = do_query(hdb, query, &hrec);
8133     ok(r == ERROR_BAD_QUERY_SYNTAX,
8134        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8135
8136     query = "DROP TABLE `One`";
8137     r = run_query(hdb, 0, query);
8138     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8139
8140     query = "DROP TABLE `One`";
8141     r = run_query(href, 0, query);
8142     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8143
8144     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8145     r = run_query(hdb, 0, query);
8146     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8147
8148     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A`, `B` )";
8149     r = run_query(href, 0, query);
8150     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8151
8152     /* number of primary keys doesn't match */
8153     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8154     ok(r == ERROR_DATATYPE_MISMATCH,
8155        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8156
8157     /* nothing in MergeErrors */
8158     query = "SELECT * FROM `MergeErrors`";
8159     r = do_query(hdb, query, &hrec);
8160     ok(r == ERROR_BAD_QUERY_SYNTAX,
8161        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8162
8163     query = "DROP TABLE `One`";
8164     r = run_query(hdb, 0, query);
8165     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8166
8167     query = "DROP TABLE `One`";
8168     r = run_query(href, 0, query);
8169     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8170
8171     query = "CREATE TABLE `One` ( `A` INT, `B` INT, `C` INT PRIMARY KEY `A` )";
8172     r = run_query(hdb, 0, query);
8173     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8174
8175     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8176     r = run_query(href, 0, query);
8177     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8178
8179     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 2 )";
8180     r = run_query(href, 0, query);
8181     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8182
8183     /* number of columns doesn't match */
8184     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8185     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8186
8187     query = "SELECT * FROM `One`";
8188     r = do_query(hdb, query, &hrec);
8189     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8190
8191     r = MsiRecordGetInteger(hrec, 1);
8192     ok(r == 1, "Expected 1, got %d\n", r);
8193
8194     r = MsiRecordGetInteger(hrec, 2);
8195     ok(r == 2, "Expected 2, got %d\n", r);
8196
8197     r = MsiRecordGetInteger(hrec, 3);
8198     ok(r == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", r);
8199
8200     MsiCloseHandle(hrec);
8201
8202     /* nothing in MergeErrors */
8203     query = "SELECT * FROM `MergeErrors`";
8204     r = do_query(hdb, query, &hrec);
8205     ok(r == ERROR_BAD_QUERY_SYNTAX,
8206        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8207
8208     query = "DROP TABLE `One`";
8209     r = run_query(hdb, 0, query);
8210     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8211
8212     query = "DROP TABLE `One`";
8213     r = run_query(href, 0, query);
8214     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8215
8216     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8217     r = run_query(hdb, 0, query);
8218     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8219
8220     query = "CREATE TABLE `One` ( `A` INT, `B` INT, `C` INT PRIMARY KEY `A` )";
8221     r = run_query(href, 0, query);
8222     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8223
8224     query = "INSERT INTO `One` ( `A`, `B`, `C` ) VALUES ( 1, 2, 3 )";
8225     r = run_query(href, 0, query);
8226     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8227
8228     /* number of columns doesn't match */
8229     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8230     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8231
8232     query = "SELECT * FROM `One`";
8233     r = do_query(hdb, query, &hrec);
8234     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8235
8236     r = MsiRecordGetInteger(hrec, 1);
8237     ok(r == 1, "Expected 1, got %d\n", r);
8238
8239     r = MsiRecordGetInteger(hrec, 2);
8240     ok(r == 2, "Expected 2, got %d\n", r);
8241
8242     r = MsiRecordGetInteger(hrec, 3);
8243     ok(r == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", r);
8244
8245     MsiCloseHandle(hrec);
8246
8247     /* nothing in MergeErrors */
8248     query = "SELECT * FROM `MergeErrors`";
8249     r = do_query(hdb, query, &hrec);
8250     ok(r == ERROR_BAD_QUERY_SYNTAX,
8251        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8252
8253     query = "DROP TABLE `One`";
8254     r = run_query(hdb, 0, query);
8255     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8256
8257     query = "DROP TABLE `One`";
8258     r = run_query(href, 0, query);
8259     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8260
8261     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8262     r = run_query(hdb, 0, query);
8263     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8264
8265     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 1 )";
8266     r = run_query(hdb, 0, query);
8267     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8268
8269     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 2 )";
8270     r = run_query(hdb, 0, query);
8271     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8272
8273     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8274     r = run_query(href, 0, query);
8275     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8276
8277     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 2 )";
8278     r = run_query(href, 0, query);
8279     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8280
8281     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 3 )";
8282     r = run_query(href, 0, query);
8283     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8284
8285     /* primary keys match, rows do not */
8286     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8287     ok(r == ERROR_FUNCTION_FAILED,
8288        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8289
8290     /* nothing in MergeErrors */
8291     query = "SELECT * FROM `MergeErrors`";
8292     r = do_query(hdb, query, &hrec);
8293     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8294
8295     size = MAX_PATH;
8296     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8297     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8298     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
8299
8300     r = MsiRecordGetInteger(hrec, 2);
8301     ok(r == 2, "Expected 2, got %d\n", r);
8302
8303     MsiCloseHandle(hrec);
8304
8305     r = MsiDatabaseOpenViewA(hdb, "SELECT * FROM `MergeErrors`", &hview);
8306     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8307
8308     r = MsiViewGetColumnInfo(hview, MSICOLINFO_NAMES, &hrec);
8309     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8310
8311     size = MAX_PATH;
8312     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8313     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8314     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
8315
8316     size = MAX_PATH;
8317     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8318     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8319     ok(!lstrcmpA(buf, "NumRowMergeConflicts"),
8320        "Expected \"NumRowMergeConflicts\", got \"%s\"\n", buf);
8321
8322     MsiCloseHandle(hrec);
8323
8324     r = MsiViewGetColumnInfo(hview, MSICOLINFO_TYPES, &hrec);
8325     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8326
8327     size = MAX_PATH;
8328     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8329     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8330     ok(!lstrcmpA(buf, "s255"), "Expected \"s255\", got \"%s\"\n", buf);
8331
8332     size = MAX_PATH;
8333     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8334     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8335     ok(!lstrcmpA(buf, "i2"), "Expected \"i2\", got \"%s\"\n", buf);
8336
8337     MsiCloseHandle(hrec);
8338     MsiViewClose(hview);
8339     MsiCloseHandle(hview);
8340
8341     query = "DROP TABLE `MergeErrors`";
8342     r = run_query(hdb, 0, query);
8343     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8344
8345     query = "DROP TABLE `One`";
8346     r = run_query(hdb, 0, query);
8347     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8348
8349     query = "DROP TABLE `One`";
8350     r = run_query(href, 0, query);
8351     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8352
8353     query = "CREATE TABLE `One` ( `A` INT, `B` CHAR(72) PRIMARY KEY `A` )";
8354     r = run_query(href, 0, query);
8355     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8356
8357     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'hi' )";
8358     r = run_query(href, 0, query);
8359     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8360
8361     /* table from merged database is not in target database */
8362     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8363     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8364
8365     query = "SELECT * FROM `One`";
8366     r = do_query(hdb, query, &hrec);
8367     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8368
8369     r = MsiRecordGetInteger(hrec, 1);
8370     ok(r == 1, "Expected 1, got %d\n", r);
8371
8372     size = MAX_PATH;
8373     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8374     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8375     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8376
8377     MsiCloseHandle(hrec);
8378
8379     /* nothing in MergeErrors */
8380     query = "SELECT * FROM `MergeErrors`";
8381     r = do_query(hdb, query, &hrec);
8382     ok(r == ERROR_BAD_QUERY_SYNTAX,
8383        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8384
8385     query = "DROP TABLE `One`";
8386     r = run_query(hdb, 0, query);
8387     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8388
8389     query = "DROP TABLE `One`";
8390     r = run_query(href, 0, query);
8391     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8392
8393     query = "CREATE TABLE `One` ( "
8394             "`A` CHAR(72), `B` INT PRIMARY KEY `A` )";
8395     r = run_query(hdb, 0, query);
8396     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8397
8398     query = "CREATE TABLE `One` ( "
8399             "`A` CHAR(72), `B` INT PRIMARY KEY `A` )";
8400     r = run_query(href, 0, query);
8401     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8402
8403     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 'hi', 1 )";
8404     r = run_query(href, 0, query);
8405     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8406
8407     /* primary key is string */
8408     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8409     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8410
8411     query = "SELECT * FROM `One`";
8412     r = do_query(hdb, query, &hrec);
8413     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8414
8415     size = MAX_PATH;
8416     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8417     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8418     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8419
8420     r = MsiRecordGetInteger(hrec, 2);
8421     ok(r == 1, "Expected 1, got %d\n", r);
8422
8423     MsiCloseHandle(hrec);
8424
8425     /* nothing in MergeErrors */
8426     query = "SELECT * FROM `MergeErrors`";
8427     r = do_query(hdb, query, &hrec);
8428     ok(r == ERROR_BAD_QUERY_SYNTAX,
8429        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8430
8431     create_file_data("codepage.idt", "\r\n\r\n850\t_ForceCodepage\r\n", 0);
8432
8433     GetCurrentDirectoryA(MAX_PATH, buf);
8434     r = MsiDatabaseImportA(hdb, buf, "codepage.idt");
8435     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8436
8437     query = "DROP TABLE `One`";
8438     r = run_query(hdb, 0, query);
8439     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8440
8441     query = "DROP TABLE `One`";
8442     r = run_query(href, 0, query);
8443     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8444
8445     query = "CREATE TABLE `One` ( "
8446             "`A` INT, `B` CHAR(72) LOCALIZABLE PRIMARY KEY `A` )";
8447     r = run_query(hdb, 0, query);
8448     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8449
8450     query = "CREATE TABLE `One` ( "
8451             "`A` INT, `B` CHAR(72) LOCALIZABLE PRIMARY KEY `A` )";
8452     r = run_query(href, 0, query);
8453     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8454
8455     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'hi' )";
8456     r = run_query(href, 0, query);
8457     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8458
8459     /* code page does not match */
8460     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8461     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8462
8463     query = "SELECT * FROM `One`";
8464     r = do_query(hdb, query, &hrec);
8465     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8466
8467     r = MsiRecordGetInteger(hrec, 1);
8468     ok(r == 1, "Expected 1, got %d\n", r);
8469
8470     size = MAX_PATH;
8471     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8472     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8473     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8474
8475     MsiCloseHandle(hrec);
8476
8477     /* nothing in MergeErrors */
8478     query = "SELECT * FROM `MergeErrors`";
8479     r = do_query(hdb, query, &hrec);
8480     ok(r == ERROR_BAD_QUERY_SYNTAX,
8481        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8482
8483     query = "DROP TABLE `One`";
8484     r = run_query(hdb, 0, query);
8485     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8486
8487     query = "DROP TABLE `One`";
8488     r = run_query(href, 0, query);
8489     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8490
8491     query = "CREATE TABLE `One` ( `A` INT, `B` OBJECT PRIMARY KEY `A` )";
8492     r = run_query(hdb, 0, query);
8493     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8494
8495     query = "CREATE TABLE `One` ( `A` INT, `B` OBJECT PRIMARY KEY `A` )";
8496     r = run_query(href, 0, query);
8497     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8498
8499     create_file("binary.dat");
8500     hrec = MsiCreateRecord(1);
8501     MsiRecordSetStreamA(hrec, 1, "binary.dat");
8502
8503     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, ? )";
8504     r = run_query(href, hrec, query);
8505     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8506
8507     MsiCloseHandle(hrec);
8508
8509     /* binary data to merge */
8510     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8511     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8512
8513     query = "SELECT * FROM `One`";
8514     r = do_query(hdb, query, &hrec);
8515     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8516
8517     r = MsiRecordGetInteger(hrec, 1);
8518     ok(r == 1, "Expected 1, got %d\n", r);
8519
8520     size = MAX_PATH;
8521     ZeroMemory(buf, MAX_PATH);
8522     r = MsiRecordReadStream(hrec, 2, buf, &size);
8523     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8524     ok(!lstrcmpA(buf, "binary.dat\n"),
8525        "Expected \"binary.dat\\n\", got \"%s\"\n", buf);
8526
8527     MsiCloseHandle(hrec);
8528
8529     /* nothing in MergeErrors */
8530     query = "SELECT * FROM `MergeErrors`";
8531     r = do_query(hdb, query, &hrec);
8532     ok(r == ERROR_BAD_QUERY_SYNTAX,
8533        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8534
8535     query = "DROP TABLE `One`";
8536     r = run_query(hdb, 0, query);
8537     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8538
8539     query = "DROP TABLE `One`";
8540     r = run_query(href, 0, query);
8541     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8542
8543     query = "CREATE TABLE `One` ( `A` INT, `B` CHAR(72) PRIMARY KEY `A` )";
8544     r = run_query(hdb, 0, query);
8545     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8546     r = run_query(href, 0, query);
8547     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8548
8549     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'foo' )";
8550     r = run_query(href, 0, query);
8551     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8552
8553     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 'bar' )";
8554     r = run_query(href, 0, query);
8555     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8556
8557     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8558     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8559
8560     query = "SELECT * FROM `One`";
8561     r = MsiDatabaseOpenViewA(hdb, query, &hview);
8562     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8563     r = MsiViewExecute(hview, 0);
8564     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8565
8566     r = MsiViewFetch(hview, &hrec);
8567     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8568
8569     r = MsiRecordGetInteger(hrec, 1);
8570     ok(r == 1, "Expected 1, got %d\n", r);
8571
8572     size = MAX_PATH;
8573     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8574     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8575     ok(!lstrcmpA(buf, "foo"), "Expected \"foo\", got \"%s\"\n", buf);
8576
8577     MsiCloseHandle(hrec);
8578
8579     r = MsiViewFetch(hview, &hrec);
8580     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8581
8582     r = MsiRecordGetInteger(hrec, 1);
8583     ok(r == 2, "Expected 2, got %d\n", r);
8584
8585     size = MAX_PATH;
8586     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8587     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8588     ok(!lstrcmpA(buf, "bar"), "Expected \"bar\", got \"%s\"\n", buf);
8589
8590     MsiCloseHandle(hrec);
8591
8592     r = MsiViewFetch(hview, &hrec);
8593     ok(r == ERROR_NO_MORE_ITEMS,
8594        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8595
8596     MsiViewClose(hview);
8597     MsiCloseHandle(hview);
8598
8599     MsiCloseHandle(hdb);
8600     MsiCloseHandle(href);
8601     DeleteFileA(msifile);
8602     DeleteFileW(refdbW);
8603     DeleteFileA("codepage.idt");
8604     DeleteFileA("binary.dat");
8605 }
8606
8607 static void test_select_with_tablenames(void)
8608 {
8609     MSIHANDLE hdb, view, rec;
8610     LPCSTR query;
8611     UINT r;
8612     int i;
8613
8614     int vals[4][2] = {
8615         {1,12},
8616         {4,12},
8617         {1,15},
8618         {4,15}};
8619
8620     hdb = create_db();
8621     ok(hdb, "failed to create db\n");
8622
8623     /* Build a pair of tables with the same column names, but unique data */
8624     query = "CREATE TABLE `T1` ( `A` SHORT, `B` SHORT PRIMARY KEY `A`)";
8625     r = run_query(hdb, 0, query);
8626     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8627
8628     query = "INSERT INTO `T1` ( `A`, `B` ) VALUES ( 1, 2 )";
8629     r = run_query(hdb, 0, query);
8630     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8631
8632     query = "INSERT INTO `T1` ( `A`, `B` ) VALUES ( 4, 5 )";
8633     r = run_query(hdb, 0, query);
8634     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8635
8636     query = "CREATE TABLE `T2` ( `A` SHORT, `B` SHORT PRIMARY KEY `A`)";
8637     r = run_query(hdb, 0, query);
8638     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8639
8640     query = "INSERT INTO `T2` ( `A`, `B` ) VALUES ( 11, 12 )";
8641     r = run_query(hdb, 0, query);
8642     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8643
8644     query = "INSERT INTO `T2` ( `A`, `B` ) VALUES ( 14, 15 )";
8645     r = run_query(hdb, 0, query);
8646     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8647
8648
8649     /* Test that selection based on prefixing the column with the table
8650      * actually selects the right data */
8651
8652     query = "SELECT T1.A, T2.B FROM T1,T2";
8653     r = MsiDatabaseOpenViewA(hdb, query, &view);
8654     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8655     r = MsiViewExecute(view, 0);
8656     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8657
8658     for (i = 0; i < 4; i++)
8659     {
8660         r = MsiViewFetch(view, &rec);
8661         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8662
8663         r = MsiRecordGetInteger(rec, 1);
8664         ok(r == vals[i][0], "Expected %d, got %d\n", vals[i][0], r);
8665
8666         r = MsiRecordGetInteger(rec, 2);
8667         ok(r == vals[i][1], "Expected %d, got %d\n", vals[i][1], r);
8668
8669         MsiCloseHandle(rec);
8670     }
8671
8672     r = MsiViewFetch(view, &rec);
8673     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8674
8675     MsiViewClose(view);
8676     MsiCloseHandle(view);
8677     MsiCloseHandle(hdb);
8678     DeleteFileA(msifile);
8679 }
8680
8681 static const UINT ordervals[6][3] =
8682 {
8683     { MSI_NULL_INTEGER, 12, 13 },
8684     { 1, 2, 3 },
8685     { 6, 4, 5 },
8686     { 8, 9, 7 },
8687     { 10, 11, MSI_NULL_INTEGER },
8688     { 14, MSI_NULL_INTEGER, 15 }
8689 };
8690
8691 static void test_insertorder(void)
8692 {
8693     MSIHANDLE hdb, view, rec;
8694     LPCSTR query;
8695     UINT r;
8696     int i;
8697
8698     hdb = create_db();
8699     ok(hdb, "failed to create db\n");
8700
8701     query = "CREATE TABLE `T` ( `A` SHORT, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
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` ( `A`, `B`, `C` ) VALUES ( 1, 2, 3 )";
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` ( `B`, `C`, `A` ) VALUES ( 4, 5, 6 )";
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` ( `C`, `A`, `B` ) VALUES ( 7, 8, 9 )";
8714     r = run_query(hdb, 0, query);
8715     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8716
8717     query = "INSERT INTO `T` ( `A`, `B` ) VALUES ( 10, 11 )";
8718     r = run_query(hdb, 0, query);
8719     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8720
8721     query = "INSERT INTO `T` ( `B`, `C` ) VALUES ( 12, 13 )";
8722     r = run_query(hdb, 0, query);
8723     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8724
8725     /* fails because the primary key already
8726      * has an MSI_NULL_INTEGER value set above
8727      */
8728     query = "INSERT INTO `T` ( `C` ) VALUES ( 14 )";
8729     r = run_query(hdb, 0, query);
8730     ok(r == ERROR_FUNCTION_FAILED,
8731        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8732
8733     /* replicate the error where primary key is set twice */
8734     query = "INSERT INTO `T` ( `A`, `C` ) VALUES ( 1, 14 )";
8735     r = run_query(hdb, 0, query);
8736     ok(r == ERROR_FUNCTION_FAILED,
8737        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8738
8739     query = "INSERT INTO `T` ( `A`, `C` ) VALUES ( 14, 15 )";
8740     r = run_query(hdb, 0, query);
8741     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8742
8743     query = "INSERT INTO `T` VALUES ( 16 )";
8744     r = run_query(hdb, 0, query);
8745     ok(r == ERROR_BAD_QUERY_SYNTAX,
8746        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8747
8748     query = "INSERT INTO `T` VALUES ( 17, 18 )";
8749     r = run_query(hdb, 0, query);
8750     ok(r == ERROR_BAD_QUERY_SYNTAX,
8751        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8752
8753     query = "INSERT INTO `T` VALUES ( 19, 20, 21 )";
8754     r = run_query(hdb, 0, query);
8755     ok(r == ERROR_BAD_QUERY_SYNTAX,
8756        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8757
8758     query = "SELECT * FROM `T`";
8759     r = MsiDatabaseOpenViewA(hdb, query, &view);
8760     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8761     r = MsiViewExecute(view, 0);
8762     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8763
8764     for (i = 0; i < 6; i++)
8765     {
8766         r = MsiViewFetch(view, &rec);
8767         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8768
8769         r = MsiRecordGetInteger(rec, 1);
8770         ok(r == ordervals[i][0], "Expected %d, got %d\n", ordervals[i][0], r);
8771
8772         r = MsiRecordGetInteger(rec, 2);
8773         ok(r == ordervals[i][1], "Expected %d, got %d\n", ordervals[i][1], r);
8774
8775         r = MsiRecordGetInteger(rec, 3);
8776         ok(r == ordervals[i][2], "Expected %d, got %d\n", ordervals[i][2], r);
8777
8778         MsiCloseHandle(rec);
8779     }
8780
8781     r = MsiViewFetch(view, &rec);
8782     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8783
8784     MsiViewClose(view);
8785     MsiCloseHandle(view);
8786
8787     query = "DELETE FROM `T` WHERE `A` IS NULL";
8788     r = run_query(hdb, 0, query);
8789     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8790
8791     query = "INSERT INTO `T` ( `B`, `C` ) VALUES ( 12, 13 ) TEMPORARY";
8792     r = run_query(hdb, 0, query);
8793     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8794
8795     query = "SELECT * FROM `T`";
8796     r = MsiDatabaseOpenViewA(hdb, query, &view);
8797     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8798     r = MsiViewExecute(view, 0);
8799     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8800
8801     for (i = 0; i < 6; i++)
8802     {
8803         r = MsiViewFetch(view, &rec);
8804         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8805
8806         r = MsiRecordGetInteger(rec, 1);
8807         ok(r == ordervals[i][0], "Expected %d, got %d\n", ordervals[i][0], r);
8808
8809         r = MsiRecordGetInteger(rec, 2);
8810         ok(r == ordervals[i][1], "Expected %d, got %d\n", ordervals[i][1], r);
8811
8812         r = MsiRecordGetInteger(rec, 3);
8813         ok(r == ordervals[i][2], "Expected %d, got %d\n", ordervals[i][2], r);
8814
8815         MsiCloseHandle(rec);
8816     }
8817
8818     r = MsiViewFetch(view, &rec);
8819     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8820
8821     MsiViewClose(view);
8822     MsiCloseHandle(view);
8823     MsiCloseHandle(hdb);
8824     DeleteFileA(msifile);
8825 }
8826
8827 static void test_columnorder(void)
8828 {
8829     MSIHANDLE hdb, view, rec;
8830     char buf[MAX_PATH];
8831     LPCSTR query;
8832     DWORD sz;
8833     UINT r;
8834
8835     hdb = create_db();
8836     ok(hdb, "failed to create db\n");
8837
8838     /* Each column is a slot:
8839      * ---------------------
8840      * | B | C | A | E | D |
8841      * ---------------------
8842      *
8843      * When a column is selected as a primary key,
8844      * the column occupying the nth primary key slot is swapped
8845      * with the current position of the primary key in question:
8846      *
8847      * set primary key `D`
8848      * ---------------------    ---------------------
8849      * | B | C | A | E | D | -> | D | C | A | E | B |
8850      * ---------------------    ---------------------
8851      *
8852      * set primary key `E`
8853      * ---------------------    ---------------------
8854      * | D | C | A | E | B | -> | D | E | A | C | B |
8855      * ---------------------    ---------------------
8856      */
8857
8858     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL, `C` SHORT NOT NULL, "
8859             "`A` CHAR(255), `E` INT, `D` CHAR(255) NOT NULL "
8860             "PRIMARY KEY `D`, `E`)";
8861     r = run_query(hdb, 0, query);
8862     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8863
8864     query = "SELECT * FROM `T`";
8865     r = MsiDatabaseOpenViewA(hdb, query, &view);
8866     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8867
8868     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
8869     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8870
8871     sz = MAX_PATH;
8872     lstrcpyA(buf, "kiwi");
8873     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8874     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8875     ok(!lstrcmpA("s255", buf), "Expected \"s255\", got \"%s\"\n", buf);
8876
8877     sz = MAX_PATH;
8878     lstrcpyA(buf, "kiwi");
8879     r = MsiRecordGetStringA(rec, 2, buf, &sz);
8880     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8881     ok(!lstrcmpA("I2", buf), "Expected \"I2\", got \"%s\"\n", buf);
8882
8883     sz = MAX_PATH;
8884     lstrcpyA(buf, "kiwi");
8885     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8886     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8887     ok(!lstrcmpA("S255", buf), "Expected \"S255\", got \"%s\"\n", buf);
8888
8889     sz = MAX_PATH;
8890     lstrcpyA(buf, "kiwi");
8891     r = MsiRecordGetStringA(rec, 4, buf, &sz);
8892     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8893     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
8894
8895     sz = MAX_PATH;
8896     lstrcpyA(buf, "kiwi");
8897     r = MsiRecordGetStringA(rec, 5, buf, &sz);
8898     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8899     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
8900
8901     MsiCloseHandle(rec);
8902
8903     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
8904     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8905
8906     sz = MAX_PATH;
8907     lstrcpyA(buf, "kiwi");
8908     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8909     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8910     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
8911
8912     sz = MAX_PATH;
8913     lstrcpyA(buf, "kiwi");
8914     r = MsiRecordGetStringA(rec, 2, buf, &sz);
8915     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8916     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
8917
8918     sz = MAX_PATH;
8919     lstrcpyA(buf, "kiwi");
8920     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8921     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8922     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
8923
8924     sz = MAX_PATH;
8925     lstrcpyA(buf, "kiwi");
8926     r = MsiRecordGetStringA(rec, 4, buf, &sz);
8927     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8928     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
8929
8930     sz = MAX_PATH;
8931     lstrcpyA(buf, "kiwi");
8932     r = MsiRecordGetStringA(rec, 5, buf, &sz);
8933     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8934     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
8935
8936     MsiCloseHandle(rec);
8937     MsiViewClose(view);
8938     MsiCloseHandle(view);
8939
8940     query = "INSERT INTO `T` ( `B`, `C`, `A`, `E`, `D` ) "
8941             "VALUES ( 1, 2, 'a', 3, 'bc' )";
8942     r = run_query(hdb, 0, query);
8943     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8944
8945     query = "SELECT * FROM `T`";
8946     r = do_query(hdb, query, &rec);
8947     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8948
8949     sz = MAX_PATH;
8950     lstrcpyA(buf, "kiwi");
8951     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8952     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8953     ok(!lstrcmpA("bc", buf), "Expected \"bc\", got \"%s\"\n", buf);
8954
8955     r = MsiRecordGetInteger(rec, 2);
8956     ok(r == 3, "Expected 3, got %d\n", r);
8957
8958     sz = MAX_PATH;
8959     lstrcpyA(buf, "kiwi");
8960     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8961     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8962     ok(!lstrcmpA("a", buf), "Expected \"a\", got \"%s\"\n", buf);
8963
8964     r = MsiRecordGetInteger(rec, 4);
8965     ok(r == 2, "Expected 2, got %d\n", r);
8966
8967     r = MsiRecordGetInteger(rec, 5);
8968     ok(r == 1, "Expected 1, got %d\n", r);
8969
8970     MsiCloseHandle(rec);
8971
8972     query = "SELECT * FROM `_Columns` WHERE `Table` = 'T'";
8973     r = MsiDatabaseOpenViewA(hdb, query, &view);
8974     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8975     r = MsiViewExecute(view, 0);
8976     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8977
8978     r = MsiViewFetch(view, &rec);
8979     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8980
8981     sz = MAX_PATH;
8982     lstrcpyA(buf, "kiwi");
8983     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8984     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8985     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8986
8987     r = MsiRecordGetInteger(rec, 2);
8988     ok(r == 1, "Expected 1, got %d\n", r);
8989
8990     sz = MAX_PATH;
8991     lstrcpyA(buf, "kiwi");
8992     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8993     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8994     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
8995
8996     MsiCloseHandle(rec);
8997
8998     r = MsiViewFetch(view, &rec);
8999     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9000
9001     sz = MAX_PATH;
9002     lstrcpyA(buf, "kiwi");
9003     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9004     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9005     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9006
9007     r = MsiRecordGetInteger(rec, 2);
9008     ok(r == 2, "Expected 2, got %d\n", r);
9009
9010     sz = MAX_PATH;
9011     lstrcpyA(buf, "kiwi");
9012     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9013     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9014     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
9015
9016     MsiCloseHandle(rec);
9017
9018     r = MsiViewFetch(view, &rec);
9019     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9020
9021     sz = MAX_PATH;
9022     lstrcpyA(buf, "kiwi");
9023     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9024     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9025     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9026
9027     r = MsiRecordGetInteger(rec, 2);
9028     ok(r == 3, "Expected 3, got %d\n", r);
9029
9030     sz = MAX_PATH;
9031     lstrcpyA(buf, "kiwi");
9032     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9033     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9034     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
9035
9036     MsiCloseHandle(rec);
9037
9038     r = MsiViewFetch(view, &rec);
9039     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9040
9041     sz = MAX_PATH;
9042     lstrcpyA(buf, "kiwi");
9043     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9044     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9045     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9046
9047     r = MsiRecordGetInteger(rec, 2);
9048     ok(r == 4, "Expected 4, got %d\n", r);
9049
9050     sz = MAX_PATH;
9051     lstrcpyA(buf, "kiwi");
9052     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9053     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9054     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
9055
9056     MsiCloseHandle(rec);
9057
9058     r = MsiViewFetch(view, &rec);
9059     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9060
9061     sz = MAX_PATH;
9062     lstrcpyA(buf, "kiwi");
9063     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9064     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9065     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9066
9067     r = MsiRecordGetInteger(rec, 2);
9068     ok(r == 5, "Expected 5, got %d\n", r);
9069
9070     sz = MAX_PATH;
9071     lstrcpyA(buf, "kiwi");
9072     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9073     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9074     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
9075
9076     MsiCloseHandle(rec);
9077
9078     r = MsiViewFetch(view, &rec);
9079     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
9080
9081     MsiViewClose(view);
9082     MsiCloseHandle(view);
9083
9084     query = "CREATE TABLE `Z` ( `B` SHORT NOT NULL, `C` SHORT NOT NULL, "
9085             "`A` CHAR(255), `E` INT, `D` CHAR(255) NOT NULL "
9086             "PRIMARY KEY `C`, `A`, `D`)";
9087     r = run_query(hdb, 0, query);
9088     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9089
9090     query = "SELECT * FROM `Z`";
9091     r = MsiDatabaseOpenViewA(hdb, query, &view);
9092     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9093
9094     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
9095     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9096
9097     sz = MAX_PATH;
9098     lstrcpyA(buf, "kiwi");
9099     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9100     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9101     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
9102
9103     sz = MAX_PATH;
9104     lstrcpyA(buf, "kiwi");
9105     r = MsiRecordGetStringA(rec, 2, buf, &sz);
9106     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9107     ok(!lstrcmpA("S255", buf), "Expected \"S255\", got \"%s\"\n", buf);
9108
9109     sz = MAX_PATH;
9110     lstrcpyA(buf, "kiwi");
9111     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9112     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9113     ok(!lstrcmpA("s255", buf), "Expected \"s255\", got \"%s\"\n", buf);
9114
9115     sz = MAX_PATH;
9116     lstrcpyA(buf, "kiwi");
9117     r = MsiRecordGetStringA(rec, 4, buf, &sz);
9118     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9119     ok(!lstrcmpA("I2", buf), "Expected \"I2\", got \"%s\"\n", buf);
9120
9121     sz = MAX_PATH;
9122     lstrcpyA(buf, "kiwi");
9123     r = MsiRecordGetStringA(rec, 5, buf, &sz);
9124     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9125     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
9126
9127     MsiCloseHandle(rec);
9128
9129     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
9130     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9131
9132     sz = MAX_PATH;
9133     lstrcpyA(buf, "kiwi");
9134     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9135     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9136     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
9137
9138     sz = MAX_PATH;
9139     lstrcpyA(buf, "kiwi");
9140     r = MsiRecordGetStringA(rec, 2, buf, &sz);
9141     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9142     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
9143
9144     sz = MAX_PATH;
9145     lstrcpyA(buf, "kiwi");
9146     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9147     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9148     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
9149
9150     sz = MAX_PATH;
9151     lstrcpyA(buf, "kiwi");
9152     r = MsiRecordGetStringA(rec, 4, buf, &sz);
9153     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9154     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
9155
9156     sz = MAX_PATH;
9157     lstrcpyA(buf, "kiwi");
9158     r = MsiRecordGetStringA(rec, 5, buf, &sz);
9159     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9160     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
9161
9162     MsiCloseHandle(rec);
9163     MsiViewClose(view);
9164     MsiCloseHandle(view);
9165
9166     query = "INSERT INTO `Z` ( `B`, `C`, `A`, `E`, `D` ) "
9167             "VALUES ( 1, 2, 'a', 3, 'bc' )";
9168     r = run_query(hdb, 0, query);
9169     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9170
9171     query = "SELECT * FROM `Z`";
9172     r = do_query(hdb, query, &rec);
9173     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9174
9175     r = MsiRecordGetInteger(rec, 1);
9176     ok(r == 2, "Expected 2, got %d\n", r);
9177
9178     sz = MAX_PATH;
9179     lstrcpyA(buf, "kiwi");
9180     r = MsiRecordGetStringA(rec, 2, buf, &sz);
9181     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9182     ok(!lstrcmpA("a", buf), "Expected \"a\", got \"%s\"\n", buf);
9183
9184     sz = MAX_PATH;
9185     lstrcpyA(buf, "kiwi");
9186     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9187     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9188     ok(!lstrcmpA("bc", buf), "Expected \"bc\", got \"%s\"\n", buf);
9189
9190     r = MsiRecordGetInteger(rec, 4);
9191     ok(r == 3, "Expected 3, got %d\n", r);
9192
9193     r = MsiRecordGetInteger(rec, 5);
9194     ok(r == 1, "Expected 1, got %d\n", r);
9195
9196     MsiCloseHandle(rec);
9197
9198     query = "SELECT * FROM `_Columns` WHERE `Table` = 'T'";
9199     r = MsiDatabaseOpenViewA(hdb, query, &view);
9200     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9201     r = MsiViewExecute(view, 0);
9202     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9203
9204     r = MsiViewFetch(view, &rec);
9205     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9206
9207     sz = MAX_PATH;
9208     lstrcpyA(buf, "kiwi");
9209     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9210     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9211     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9212
9213     r = MsiRecordGetInteger(rec, 2);
9214     ok(r == 1, "Expected 1, got %d\n", r);
9215
9216     sz = MAX_PATH;
9217     lstrcpyA(buf, "kiwi");
9218     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9219     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9220     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
9221
9222     MsiCloseHandle(rec);
9223
9224     r = MsiViewFetch(view, &rec);
9225     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9226
9227     sz = MAX_PATH;
9228     lstrcpyA(buf, "kiwi");
9229     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9230     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9231     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9232
9233     r = MsiRecordGetInteger(rec, 2);
9234     ok(r == 2, "Expected 2, got %d\n", r);
9235
9236     sz = MAX_PATH;
9237     lstrcpyA(buf, "kiwi");
9238     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9239     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9240     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
9241
9242     MsiCloseHandle(rec);
9243
9244     r = MsiViewFetch(view, &rec);
9245     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9246
9247     sz = MAX_PATH;
9248     lstrcpyA(buf, "kiwi");
9249     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9250     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9251     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9252
9253     r = MsiRecordGetInteger(rec, 2);
9254     ok(r == 3, "Expected 3, got %d\n", r);
9255
9256     sz = MAX_PATH;
9257     lstrcpyA(buf, "kiwi");
9258     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9259     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9260     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
9261
9262     MsiCloseHandle(rec);
9263
9264     r = MsiViewFetch(view, &rec);
9265     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9266
9267     sz = MAX_PATH;
9268     lstrcpyA(buf, "kiwi");
9269     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9270     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9271     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9272
9273     r = MsiRecordGetInteger(rec, 2);
9274     ok(r == 4, "Expected 4, got %d\n", r);
9275
9276     sz = MAX_PATH;
9277     lstrcpyA(buf, "kiwi");
9278     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9279     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9280     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
9281
9282     MsiCloseHandle(rec);
9283
9284     r = MsiViewFetch(view, &rec);
9285     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9286
9287     sz = MAX_PATH;
9288     lstrcpyA(buf, "kiwi");
9289     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9290     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9291     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9292
9293     r = MsiRecordGetInteger(rec, 2);
9294     ok(r == 5, "Expected 5, got %d\n", r);
9295
9296     sz = MAX_PATH;
9297     lstrcpyA(buf, "kiwi");
9298     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9299     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9300     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
9301
9302     MsiCloseHandle(rec);
9303
9304     r = MsiViewFetch(view, &rec);
9305     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
9306
9307     MsiViewClose(view);
9308     MsiCloseHandle(view);
9309
9310     MsiCloseHandle(hdb);
9311     DeleteFileA(msifile);
9312 }
9313
9314 static void test_createtable(void)
9315 {
9316     MSIHANDLE hdb, htab = 0, hrec = 0;
9317     LPCSTR query;
9318     UINT res;
9319     DWORD size;
9320     char buffer[0x20];
9321
9322     hdb = create_db();
9323     ok(hdb, "failed to create db\n");
9324
9325     query = "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL PRIMARY KEY `foo`)";
9326     res = MsiDatabaseOpenViewA( hdb, query, &htab );
9327     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9328     if(res == ERROR_SUCCESS )
9329     {
9330         res = MsiViewExecute( htab, hrec );
9331         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9332
9333         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
9334         todo_wine ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9335
9336         size = sizeof(buffer);
9337         res = MsiRecordGetStringA(hrec, 1, buffer, &size );
9338         todo_wine ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9339         MsiCloseHandle( hrec );
9340
9341         res = MsiViewClose( htab );
9342         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9343
9344         res = MsiCloseHandle( htab );
9345         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9346     }
9347
9348     query = "CREATE TABLE `a` (`b` INT PRIMARY KEY `b`)";
9349     res = MsiDatabaseOpenViewA( hdb, query, &htab );
9350     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9351     if(res == ERROR_SUCCESS )
9352     {
9353         res = MsiViewExecute( htab, 0 );
9354         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9355
9356         res = MsiViewClose( htab );
9357         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9358
9359         res = MsiCloseHandle( htab );
9360         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9361
9362         query = "SELECT * FROM `a`";
9363         res = MsiDatabaseOpenViewA( hdb, query, &htab );
9364         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9365
9366         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
9367         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9368
9369         buffer[0] = 0;
9370         size = sizeof(buffer);
9371         res = MsiRecordGetStringA(hrec, 1, buffer, &size );
9372         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9373         ok(!strcmp(buffer,"b"), "b != %s\n", buffer);
9374         MsiCloseHandle( hrec );
9375
9376         res = MsiViewClose( htab );
9377         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9378
9379         res = MsiCloseHandle( htab );
9380         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9381
9382         res = MsiDatabaseCommit(hdb);
9383         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9384
9385         res = MsiCloseHandle(hdb);
9386         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9387
9388         res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
9389         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9390
9391         query = "SELECT * FROM `a`";
9392         res = MsiDatabaseOpenViewA( hdb, query, &htab );
9393         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9394
9395         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
9396         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9397
9398         buffer[0] = 0;
9399         size = sizeof(buffer);
9400         res = MsiRecordGetStringA(hrec, 1, buffer, &size );
9401         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9402         ok(!strcmp(buffer,"b"), "b != %s\n", buffer);
9403
9404         res = MsiCloseHandle( hrec );
9405         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9406
9407         res = MsiViewClose( htab );
9408         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9409
9410         res = MsiCloseHandle( htab );
9411         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9412     }
9413
9414     res = MsiDatabaseCommit(hdb);
9415     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9416
9417     res = MsiCloseHandle(hdb);
9418     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9419
9420     DeleteFileA(msifile);
9421 }
9422
9423 static void test_embedded_nulls(void)
9424 {
9425     static const char control_table[] =
9426         "Dialog\tText\n"
9427         "s72\tL0\n"
9428         "Control\tDialog\n"
9429         "LicenseAgreementDlg\ttext\x11\x19text\0text";
9430     UINT r, sz;
9431     MSIHANDLE hdb, hrec;
9432     char buffer[32];
9433
9434     r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
9435     ok( r == ERROR_SUCCESS, "failed to open database %u\n", r );
9436
9437     GetCurrentDirectoryA( MAX_PATH, CURR_DIR );
9438     write_file( "temp_file", control_table, sizeof(control_table) );
9439     r = MsiDatabaseImportA( hdb, CURR_DIR, "temp_file" );
9440     ok( r == ERROR_SUCCESS, "failed to import table %u\n", r );
9441     DeleteFileA( "temp_file" );
9442
9443     r = do_query( hdb, "SELECT `Text` FROM `Control` WHERE `Dialog` = 'LicenseAgreementDlg'", &hrec );
9444     ok( r == ERROR_SUCCESS, "query failed %u\n", r );
9445
9446     buffer[0] = 0;
9447     sz = sizeof(buffer);
9448     r = MsiRecordGetStringA( hrec, 1, buffer, &sz );
9449     ok( r == ERROR_SUCCESS, "failed to get string %u\n", r );
9450     ok( !memcmp( "text\r\ntext\ntext", buffer, sizeof("text\r\ntext\ntext") - 1 ), "wrong buffer contents \"%s\"\n", buffer );
9451
9452     MsiCloseHandle( hrec );
9453     MsiCloseHandle( hdb );
9454     DeleteFileA( msifile );
9455 }
9456
9457 static void test_select_column_names(void)
9458 {
9459     MSIHANDLE hdb = 0, rec, rec2, view;
9460     char buffer[32];
9461     UINT r, size;
9462
9463     DeleteFileA(msifile);
9464
9465     r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
9466     ok( r == ERROR_SUCCESS , "failed to open database: %u\n", r );
9467
9468     r = try_query( hdb, "CREATE TABLE `t` (`a` CHAR NOT NULL, `b` CHAR PRIMARY KEY `a`)");
9469     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9470
9471     r = try_query( hdb, "SELECT `t`.`b` FROM `t` WHERE `t`.`b` = `x`" );
9472     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9473
9474     r = try_query( hdb, "SELECT '', `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
9475     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9476
9477     r = try_query( hdb, "SELECT *, `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
9478     todo_wine ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
9479
9480     r = try_query( hdb, "SELECT 'b', `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
9481     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9482
9483     r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x'" );
9484     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9485
9486     r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x' ORDER BY `b`" );
9487     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9488
9489     r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x' ORDER BY 'b'" );
9490     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9491
9492     r = try_query( hdb, "SELECT 't'.'b' FROM `t` WHERE `t`.`b` = 'x'" );
9493     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9494
9495     r = try_query( hdb, "SELECT 'b' FROM `t` WHERE `t`.`b` = 'x'" );
9496     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9497
9498     r = try_query( hdb, "INSERT INTO `t` ( `a`, `b` ) VALUES( '1', '2' )" );
9499     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9500
9501     r = try_query( hdb, "INSERT INTO `t` ( `a`, `b` ) VALUES( '3', '4' )" );
9502     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9503
9504     r = MsiDatabaseOpenViewA( hdb, "SELECT '' FROM `t`", &view );
9505     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9506
9507     r = MsiViewExecute( view, 0 );
9508     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9509
9510     r = MsiViewFetch( view, &rec );
9511     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9512     r = MsiRecordGetFieldCount( rec );
9513     ok( r == 1, "got %u\n",  r );
9514     r = MsiViewGetColumnInfo( view, MSICOLINFO_NAMES, &rec2 );
9515     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9516     r = MsiRecordGetFieldCount( rec2 );
9517     ok( r == 1, "got %u\n",  r );
9518     size = sizeof(buffer);
9519     memset( buffer, 0x55, sizeof(buffer) );
9520     r = MsiRecordGetStringA( rec2, 1, buffer, &size );
9521     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9522     ok( !buffer[0], "got \"%s\"\n", buffer );
9523     MsiCloseHandle( rec2 );
9524     r = MsiViewGetColumnInfo( view, MSICOLINFO_TYPES, &rec2 );
9525     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9526     r = MsiRecordGetFieldCount( rec2 );
9527     ok( r == 1, "got %u\n",  r );
9528     size = sizeof(buffer);
9529     memset( buffer, 0x55, sizeof(buffer) );
9530     r = MsiRecordGetStringA( rec2, 1, buffer, &size );
9531     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9532     ok( !lstrcmpA( buffer, "f0" ), "got \"%s\"\n", buffer );
9533     MsiCloseHandle( rec2 );
9534
9535     size = sizeof(buffer);
9536     memset( buffer, 0x55, sizeof(buffer) );
9537     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9538     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9539     ok( !buffer[0], "got \"%s\"\n", buffer );
9540     MsiCloseHandle( rec );
9541
9542     r = MsiViewFetch( view, &rec );
9543     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9544     size = sizeof(buffer);
9545     memset( buffer, 0x55, sizeof(buffer) );
9546     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9547     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9548     ok( !buffer[0], "got \"%s\"\n", buffer );
9549     MsiCloseHandle( rec );
9550
9551     r = MsiViewFetch( view, &rec );
9552     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9553     MsiCloseHandle( rec );
9554
9555     MsiViewClose( view );
9556     MsiCloseHandle( view );
9557
9558     r = MsiDatabaseOpenViewA( hdb, "SELECT `a`, '' FROM `t`", &view );
9559     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9560
9561     r = MsiViewExecute( view, 0 );
9562     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9563
9564     r = MsiViewFetch( view, &rec );
9565     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9566     r = MsiRecordGetFieldCount( rec );
9567     ok( r == 2, "got %u\n",  r );
9568     size = sizeof(buffer);
9569     memset( buffer, 0x55, sizeof(buffer) );
9570     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9571     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9572     ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
9573     MsiCloseHandle( rec );
9574
9575     r = MsiViewFetch( view, &rec );
9576     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9577     size = sizeof(buffer);
9578     memset( buffer, 0x55, sizeof(buffer) );
9579     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9580     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9581     ok( !buffer[0], "got \"%s\"\n", buffer );
9582     MsiCloseHandle( rec );
9583
9584     r = MsiViewFetch( view, &rec );
9585     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9586     MsiCloseHandle( rec );
9587
9588     MsiViewClose( view );
9589     MsiCloseHandle( view );
9590
9591     r = MsiDatabaseOpenViewA( hdb, "SELECT '', `a` FROM `t`", &view );
9592     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9593
9594     r = MsiViewExecute( view, 0 );
9595     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9596
9597     r = MsiViewFetch( view, &rec );
9598     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9599     r = MsiRecordGetFieldCount( rec );
9600     ok( r == 2, "got %u\n",  r );
9601     size = sizeof(buffer);
9602     memset( buffer, 0x55, sizeof(buffer) );
9603     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9604     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9605     ok( !buffer[0], "got \"%s\"\n", buffer );
9606     size = sizeof(buffer);
9607     memset( buffer, 0x55, sizeof(buffer) );
9608     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9609     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9610     ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
9611     MsiCloseHandle( rec );
9612
9613     r = MsiViewFetch( view, &rec );
9614     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9615     size = sizeof(buffer);
9616     memset( buffer, 0x55, sizeof(buffer) );
9617     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9618     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9619     ok( !buffer[0], "got \"%s\"\n", buffer );
9620     size = sizeof(buffer);
9621     memset( buffer, 0x55, sizeof(buffer) );
9622     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9623     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9624     ok( !lstrcmpA( buffer, "3" ), "got \"%s\"\n", buffer );
9625     MsiCloseHandle( rec );
9626
9627     r = MsiViewFetch( view, &rec );
9628     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9629     MsiCloseHandle( rec );
9630
9631     MsiViewClose( view );
9632     MsiCloseHandle( view );
9633
9634     r = MsiDatabaseOpenViewA( hdb, "SELECT `a`, '', `b` FROM `t`", &view );
9635     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9636
9637     r = MsiViewExecute( view, 0 );
9638     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9639
9640     r = MsiViewFetch( view, &rec );
9641     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9642     r = MsiRecordGetFieldCount( rec );
9643     ok( r == 3, "got %u\n",  r );
9644     size = sizeof(buffer);
9645     memset( buffer, 0x55, sizeof(buffer) );
9646     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9647     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9648     ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
9649     size = sizeof(buffer);
9650     memset( buffer, 0x55, sizeof(buffer) );
9651     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9652     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9653     ok( !buffer[0], "got \"%s\"\n", buffer );
9654     size = sizeof(buffer);
9655     memset( buffer, 0x55, sizeof(buffer) );
9656     r = MsiRecordGetStringA( rec, 3, buffer, &size );
9657     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9658     ok( !lstrcmpA( buffer, "2" ), "got \"%s\"\n", buffer );
9659     MsiCloseHandle( rec );
9660
9661     r = MsiViewFetch( view, &rec );
9662     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9663     size = sizeof(buffer);
9664     memset( buffer, 0x55, sizeof(buffer) );
9665     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9666     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9667     ok( !lstrcmpA( buffer, "3" ), "got \"%s\"\n", buffer );
9668     size = sizeof(buffer);
9669     memset( buffer, 0x55, sizeof(buffer) );
9670     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9671     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9672     ok( !buffer[0], "got \"%s\"\n", buffer );
9673     size = sizeof(buffer);
9674     memset( buffer, 0x55, sizeof(buffer) );
9675     r = MsiRecordGetStringA( rec, 3, buffer, &size );
9676     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9677     ok( !lstrcmpA( buffer, "4" ), "got \"%s\"\n", buffer );
9678     MsiCloseHandle( rec );
9679
9680     r = MsiViewFetch( view, &rec );
9681     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9682     MsiCloseHandle( rec );
9683
9684     MsiViewClose( view );
9685     MsiCloseHandle( view );
9686
9687     r = try_query( hdb, "SELECT '' FROM `t` WHERE `t`.`b` = 'x'" );
9688     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9689
9690     r = try_query( hdb, "SELECT `` FROM `t` WHERE `t`.`b` = 'x'" );
9691     todo_wine ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9692
9693     r = try_query( hdb, "SELECT `b` FROM 't' WHERE `t`.`b` = 'x'" );
9694     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9695
9696     r = try_query( hdb, "SELECT `b` FROM `t` WHERE 'b' = 'x'" );
9697     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9698
9699     r = try_query( hdb, "SELECT `t`.`b`, `` FROM `t` WHERE `t`.`b` = 'x'" );
9700     todo_wine ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9701
9702     r = MsiCloseHandle( hdb );
9703     ok(r == ERROR_SUCCESS , "failed to close database: %u\n", r);
9704 }
9705
9706 START_TEST(db)
9707 {
9708     test_msidatabase();
9709     test_msiinsert();
9710     test_msidecomposedesc();
9711     test_msibadqueries();
9712     test_viewmodify();
9713     test_viewgetcolumninfo();
9714     test_getcolinfo();
9715     test_msiexport();
9716     test_longstrings();
9717     test_streamtable();
9718     test_binary();
9719     test_where_not_in_selected();
9720     test_where();
9721     test_msiimport();
9722     test_binary_import();
9723     test_markers();
9724     test_handle_limit();
9725     test_try_transform();
9726     test_join();
9727     test_temporary_table();
9728     test_alter();
9729     test_integers();
9730     test_update();
9731     test_special_tables();
9732     test_tables_order();
9733     test_rows_order();
9734     test_select_markers();
9735     test_viewmodify_update();
9736     test_viewmodify_assign();
9737     test_stringtable();
9738     test_viewmodify_delete();
9739     test_defaultdatabase();
9740     test_order();
9741     test_viewmodify_delete_temporary();
9742     test_deleterow();
9743     test_quotes();
9744     test_carriagereturn();
9745     test_noquotes();
9746     test_forcecodepage();
9747     test_viewmodify_refresh();
9748     test_where_viewmodify();
9749     test_storages_table();
9750     test_dbtopackage();
9751     test_droptable();
9752     test_dbmerge();
9753     test_select_with_tablenames();
9754     test_insertorder();
9755     test_columnorder();
9756     test_suminfo_import();
9757     test_createtable();
9758     test_collation();
9759     test_embedded_nulls();
9760     test_select_column_names();
9761 }