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 <msi.h>
  27 #include <msidefs.h>
  28 #include <msiquery.h>
  29
  30 #include <objidl.h>
  31
  32 #include "wine/test.h"
  33
  34 static const char *msifile = "winetest-db.msi";
  35 static const char *msifile2 = "winetst2-db.msi";
  36 static const char *mstfile = "winetst-db.mst";
  37 static const WCHAR msifileW[] = {'w','i','n','e','t','e','s','t','-','d','b','.','m','s','i',0};
  38 static const WCHAR msifile2W[] = {'w','i','n','e','t','s','t','2','-','d','b','.','m','s','i',0};
  39
  40 static void test_msidatabase(void)
  41 {
  42     MSIHANDLE hdb = 0, hdb2 = 0;
  43     UINT res;
  44
  45     DeleteFileW(msifileW);
  46
  47     res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb );
  48     ok( res == ERROR_OPEN_FAILED, "expected failure\n");
  49
  50     res = MsiOpenDatabaseW( msifileW, (LPWSTR)0xff, &hdb );
  51     ok( res == ERROR_INVALID_PARAMETER, "expected failure\n");
  52
  53     res = MsiCloseHandle( hdb );
  54     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  55
  56     /* create an empty database */
  57     res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
  58     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
  59
  60     res = MsiDatabaseCommit( hdb );
  61     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  62
  63     ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
  64
  65     res = MsiCloseHandle( hdb );
  66     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  67     res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
  68     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  69
  70     ok( GetFileAttributesA( msifile2 ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
  71
  72     res = MsiDatabaseCommit( hdb2 );
  73     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  74
  75     res = MsiCloseHandle( hdb2 );
  76     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  77
  78     res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
  79     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  80
  81     res = MsiCloseHandle( hdb2 );
  82     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  83
  84     ok( GetFileAttributesA( msifile2 ) == INVALID_FILE_ATTRIBUTES, "uncommitted database should not exist\n");
  85
  86     res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
  87     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  88
  89     res = MsiDatabaseCommit( hdb2 );
  90     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  91
  92     res = MsiCloseHandle( hdb2 );
  93     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  94
  95     ok( GetFileAttributesA( msifile2 ) != INVALID_FILE_ATTRIBUTES, "committed database should exist\n");
  96
  97     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_READONLY, &hdb );
  98     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  99
 100     res = MsiDatabaseCommit( hdb );
 101     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 102
 103     res = MsiCloseHandle( hdb );
 104     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 105
 106     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_DIRECT, &hdb );
 107     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 108
 109     res = MsiCloseHandle( hdb );
 110     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 111
 112     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_TRANSACT, &hdb );
 113     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 114
 115     res = MsiCloseHandle( hdb );
 116     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 117     ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 118
 119     /* MSIDBOPEN_CREATE deletes the database if MsiCommitDatabase isn't called */
 120     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
 121     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 122
 123     ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 124
 125     res = MsiCloseHandle( hdb );
 126     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 127
 128     ok( GetFileAttributesA( msifile ) == INVALID_FILE_ATTRIBUTES, "database should exist\n");
 129
 130     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
 131     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 132
 133     res = MsiDatabaseCommit( hdb );
 134     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 135
 136     ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 137
 138     res = MsiCloseHandle( hdb );
 139     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 140
 141     res = DeleteFileA( msifile2 );
 142     ok( res == TRUE, "Failed to delete database\n" );
 143
 144     res = DeleteFileA( msifile );
 145     ok( res == TRUE, "Failed to delete database\n" );
 146 }
 147
 148 static UINT do_query(MSIHANDLE hdb, const char *query, MSIHANDLE *phrec)
 149 {
 150     MSIHANDLE hview = 0;
 151     UINT r, ret;
 152
 153     if (phrec)
 154         *phrec = 0;
 155
 156     /* open a select query */
 157     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 158     if (r != ERROR_SUCCESS)
 159         return r;
 160     r = MsiViewExecute(hview, 0);
 161     if (r != ERROR_SUCCESS)
 162         return r;
 163     ret = MsiViewFetch(hview, phrec);
 164     r = MsiViewClose(hview);
 165     if (r != ERROR_SUCCESS)
 166         return r;
 167     r = MsiCloseHandle(hview);
 168     if (r != ERROR_SUCCESS)
 169         return r;
 170     return ret;
 171 }
 172
 173 static UINT run_query( MSIHANDLE hdb, MSIHANDLE hrec, const char *query )
 174 {
 175     MSIHANDLE hview = 0;
 176     UINT r;
 177
 178     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 179     if( r != ERROR_SUCCESS )
 180         return r;
 181
 182     r = MsiViewExecute(hview, hrec);
 183     if( r == ERROR_SUCCESS )
 184         r = MsiViewClose(hview);
 185     MsiCloseHandle(hview);
 186     return r;
 187 }
 188
 189 static UINT run_queryW( MSIHANDLE hdb, MSIHANDLE hrec, const WCHAR *query )
 190 {
 191     MSIHANDLE hview = 0;
 192     UINT r;
 193
 194     r = MsiDatabaseOpenViewW(hdb, query, &hview);
 195     if( r != ERROR_SUCCESS )
 196         return r;
 197
 198     r = MsiViewExecute(hview, hrec);
 199     if( r == ERROR_SUCCESS )
 200         r = MsiViewClose(hview);
 201     MsiCloseHandle(hview);
 202     return r;
 203 }
 204
 205 static UINT create_component_table( MSIHANDLE hdb )
 206 {
 207     return run_query( hdb, 0,
 208             "CREATE TABLE `Component` ( "
 209             "`Component` CHAR(72) NOT NULL, "
 210             "`ComponentId` CHAR(38), "
 211             "`Directory_` CHAR(72) NOT NULL, "
 212             "`Attributes` SHORT NOT NULL, "
 213             "`Condition` CHAR(255), "
 214             "`KeyPath` CHAR(72) "
 215             "PRIMARY KEY `Component`)" );
 216 }
 217
 218 static UINT create_custom_action_table( MSIHANDLE hdb )
 219 {
 220     return run_query( hdb, 0,
 221             "CREATE TABLE `CustomAction` ( "
 222             "`Action` CHAR(72) NOT NULL, "
 223             "`Type` SHORT NOT NULL, "
 224             "`Source` CHAR(72), "
 225             "`Target` CHAR(255) "
 226             "PRIMARY KEY `Action`)" );
 227 }
 228
 229 static UINT create_directory_table( MSIHANDLE hdb )
 230 {
 231     return run_query( hdb, 0,
 232             "CREATE TABLE `Directory` ( "
 233             "`Directory` CHAR(255) NOT NULL, "
 234             "`Directory_Parent` CHAR(255), "
 235             "`DefaultDir` CHAR(255) NOT NULL "
 236             "PRIMARY KEY `Directory`)" );
 237 }
 238
 239 static UINT create_feature_components_table( MSIHANDLE hdb )
 240 {
 241     return run_query( hdb, 0,
 242             "CREATE TABLE `FeatureComponents` ( "
 243             "`Feature_` CHAR(38) NOT NULL, "
 244             "`Component_` CHAR(72) NOT NULL "
 245             "PRIMARY KEY `Feature_`, `Component_` )" );
 246 }
 247
 248 static UINT create_std_dlls_table( MSIHANDLE hdb )
 249 {
 250     return run_query( hdb, 0,
 251             "CREATE TABLE `StdDlls` ( "
 252             "`File` CHAR(255) NOT NULL, "
 253             "`Binary_` CHAR(72) NOT NULL "
 254             "PRIMARY KEY `File` )" );
 255 }
 256
 257 static UINT create_binary_table( MSIHANDLE hdb )
 258 {
 259     return run_query( hdb, 0,
 260             "CREATE TABLE `Binary` ( "
 261             "`Name` CHAR(72) NOT NULL, "
 262             "`Data` CHAR(72) NOT NULL "
 263             "PRIMARY KEY `Name` )" );
 264 }
 265
 266 #define make_add_entry(type, qtext) \
 267     static UINT add##_##type##_##entry( MSIHANDLE hdb, const char *values ) \
 268     { \
 269         char insert[] = qtext; \
 270         char *query; \
 271         UINT sz, r; \
 272         sz = strlen(values) + sizeof insert; \
 273         query = HeapAlloc(GetProcessHeap(),0,sz); \
 274         sprintf(query,insert,values); \
 275         r = run_query( hdb, 0, query ); \
 276         HeapFree(GetProcessHeap(), 0, query); \
 277         return r; \
 278     }
 279
 280 make_add_entry(component,
 281                "INSERT INTO `Component`  "
 282                "(`Component`, `ComponentId`, `Directory_`, "
 283                "`Attributes`, `Condition`, `KeyPath`) VALUES( %s )")
 284
 285 make_add_entry(custom_action,
 286                "INSERT INTO `CustomAction`  "
 287                "(`Action`, `Type`, `Source`, `Target`) VALUES( %s )")
 288
 289 make_add_entry(feature_components,
 290                "INSERT INTO `FeatureComponents` "
 291                "(`Feature_`, `Component_`) VALUES( %s )")
 292
 293 make_add_entry(std_dlls,
 294                "INSERT INTO `StdDlls` (`File`, `Binary_`) VALUES( %s )")
 295
 296 make_add_entry(binary,
 297                "INSERT INTO `Binary` (`Name`, `Data`) VALUES( %s )")
 298
 299 static void test_msiinsert(void)
 300 {
 301     MSIHANDLE hdb = 0, hview = 0, hview2 = 0, hrec = 0;
 302     UINT r;
 303     const char *query;
 304     char buf[80];
 305     DWORD sz;
 306
 307     DeleteFileA(msifile);
 308
 309     /* just MsiOpenDatabase should not create a file */
 310     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
 311     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 312
 313     /* create a table */
 314     query = "CREATE TABLE `phone` ( "
 315             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 316             "PRIMARY KEY `id`)";
 317     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 318     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 319     r = MsiViewExecute(hview, 0);
 320     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 321     r = MsiViewClose(hview);
 322     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 323     r = MsiCloseHandle(hview);
 324     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 325
 326     query = "SELECT * FROM phone WHERE number = '8675309'";
 327     r = MsiDatabaseOpenViewA(hdb, query, &hview2);
 328     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 329     r = MsiViewExecute(hview2, 0);
 330     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 331     r = MsiViewFetch(hview2, &hrec);
 332     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch produced items\n");
 333
 334     /* insert a value into it */
 335     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 336         "VALUES('1', 'Abe', '8675309')";
 337     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 338     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 339     r = MsiViewExecute(hview, 0);
 340     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 341     r = MsiViewClose(hview);
 342     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 343     r = MsiCloseHandle(hview);
 344     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 345
 346     r = MsiViewFetch(hview2, &hrec);
 347     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch produced items\n");
 348     r = MsiViewExecute(hview2, 0);
 349     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 350     r = MsiViewFetch(hview2, &hrec);
 351     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %u\n", r);
 352
 353     r = MsiCloseHandle(hrec);
 354     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 355     r = MsiViewClose(hview2);
 356     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 357     r = MsiCloseHandle(hview2);
 358     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 359
 360     query = "SELECT * FROM `phone` WHERE `id` = 1";
 361     r = do_query(hdb, query, &hrec);
 362     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 363
 364     /* check the record contains what we put in it */
 365     r = MsiRecordGetFieldCount(hrec);
 366     ok(r == 3, "record count wrong\n");
 367
 368     r = MsiRecordIsNull(hrec, 0);
 369     ok(r == FALSE, "field 0 not null\n");
 370
 371     r = MsiRecordGetInteger(hrec, 1);
 372     ok(r == 1, "field 1 contents wrong\n");
 373     sz = sizeof buf;
 374     r = MsiRecordGetStringA(hrec, 2, buf, &sz);
 375     ok(r == ERROR_SUCCESS, "field 2 content fetch failed\n");
 376     ok(!strcmp(buf,"Abe"), "field 2 content incorrect\n");
 377     sz = sizeof buf;
 378     r = MsiRecordGetStringA(hrec, 3, buf, &sz);
 379     ok(r == ERROR_SUCCESS, "field 3 content fetch failed\n");
 380     ok(!strcmp(buf,"8675309"), "field 3 content incorrect\n");
 381
 382     r = MsiCloseHandle(hrec);
 383     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 384
 385     /* open a select query */
 386     hrec = 100;
 387     query = "SELECT * FROM `phone` WHERE `id` >= 10";
 388     r = do_query(hdb, query, &hrec);
 389     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 390     ok(hrec == 0, "hrec should be null\n");
 391
 392     r = MsiCloseHandle(hrec);
 393     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 394
 395     query = "SELECT * FROM `phone` WHERE `id` < 0";
 396     r = do_query(hdb, query, &hrec);
 397     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 398
 399     query = "SELECT * FROM `phone` WHERE `id` <= 0";
 400     r = do_query(hdb, query, &hrec);
 401     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 402
 403     query = "SELECT * FROM `phone` WHERE `id` <> 1";
 404     r = do_query(hdb, query, &hrec);
 405     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 406
 407     query = "SELECT * FROM `phone` WHERE `id` > 10";
 408     r = do_query(hdb, query, &hrec);
 409     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 410
 411     /* now try a few bad INSERT xqueries */
 412     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 413         "VALUES(?, ?)";
 414     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 415     ok(r == ERROR_BAD_QUERY_SYNTAX, "MsiDatabaseOpenView failed\n");
 416
 417     /* construct a record to insert */
 418     hrec = MsiCreateRecord(4);
 419     r = MsiRecordSetInteger(hrec, 1, 2);
 420     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 421     r = MsiRecordSetStringA(hrec, 2, "Adam");
 422     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 423     r = MsiRecordSetStringA(hrec, 3, "96905305");
 424     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 425
 426     /* insert another value, using a record and wildcards */
 427     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 428         "VALUES(?, ?, ?)";
 429     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 430     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 431
 432     if (r == ERROR_SUCCESS)
 433     {
 434         r = MsiViewExecute(hview, hrec);
 435         ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 436         r = MsiViewClose(hview);
 437         ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 438         r = MsiCloseHandle(hview);
 439         ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 440     }
 441     r = MsiCloseHandle(hrec);
 442     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 443
 444     r = MsiViewFetch(0, NULL);
 445     ok(r == ERROR_INVALID_PARAMETER, "MsiViewFetch failed\n");
 446
 447     r = MsiDatabaseCommit(hdb);
 448     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
 449
 450     r = MsiCloseHandle(hdb);
 451     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 452
 453     r = DeleteFileA(msifile);
 454     ok(r == TRUE, "file didn't exist after commit\n");
 455 }
 456
 457 static void test_msidecomposedesc(void)
 458 {
 459     UINT (WINAPI *pMsiDecomposeDescriptorA)(LPCSTR, LPCSTR, LPSTR, LPSTR, DWORD *);
 460     char prod[MAX_FEATURE_CHARS+1], comp[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1];
 461     const char *desc;
 462     UINT r;
 463     DWORD len;
 464     HMODULE hmod;
 465
 466     hmod = GetModuleHandleA("msi.dll");
 467     pMsiDecomposeDescriptorA = (void*)GetProcAddress(hmod, "MsiDecomposeDescriptorA");
 468     if (!pMsiDecomposeDescriptorA)
 469         return;
 470
 471     /* test a valid feature descriptor */
 472     desc = "']gAVn-}f(ZXfeAR6.jiFollowTheWhiteRabbit>3w2x^IGfe?CxI5heAvk.";
 473     len = 0;
 474     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 475     ok(r == ERROR_SUCCESS, "returned an error\n");
 476     ok(len == strlen(desc), "length was wrong\n");
 477     ok(strcmp(prod,"{90110409-6000-11D3-8CFE-0150048383C9}")==0, "product wrong\n");
 478     ok(strcmp(feature,"FollowTheWhiteRabbit")==0, "feature wrong\n");
 479     ok(strcmp(comp,"{A7CD68DB-EF74-49C8-FBB2-A7C463B2AC24}")==0,"component wrong\n");
 480
 481     /* test an invalid feature descriptor with too many characters */
 482     desc = "']gAVn-}f(ZXfeAR6.ji"
 483            "ThisWillFailIfTheresMoreThanAGuidsChars>"
 484            "3w2x^IGfe?CxI5heAvk.";
 485     len = 0;
 486     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 487     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 488
 489     /*
 490      * Test a valid feature descriptor with the
 491      * maximum number of characters and some trailing characters.
 492      */
 493     desc = "']gAVn-}f(ZXfeAR6.ji"
 494            "ThisWillWorkIfTheresLTEThanAGuidsChars>"
 495            "3w2x^IGfe?CxI5heAvk."
 496            "extra";
 497     len = 0;
 498     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 499     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 500     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 501
 502     len = 0;
 503     r = pMsiDecomposeDescriptorA(desc, prod, feature, NULL, &len);
 504     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 505     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 506
 507     len = 0;
 508     r = pMsiDecomposeDescriptorA(desc, prod, NULL, NULL, &len);
 509     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 510     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 511
 512     len = 0;
 513     r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, &len);
 514     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 515     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 516
 517     len = 0;
 518     r = pMsiDecomposeDescriptorA(NULL, NULL, NULL, NULL, &len);
 519     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 520     ok(len == 0, "length wrong\n");
 521
 522     r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, NULL);
 523     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 524 }
 525
 526 static UINT try_query_param( MSIHANDLE hdb, LPCSTR szQuery, MSIHANDLE hrec )
 527 {
 528     MSIHANDLE htab = 0;
 529     UINT res;
 530
 531     res = MsiDatabaseOpenViewA( hdb, szQuery, &htab );
 532     if(res == ERROR_SUCCESS )
 533     {
 534         UINT r;
 535
 536         r = MsiViewExecute( htab, hrec );
 537         if(r != ERROR_SUCCESS )
 538             res = r;
 539
 540         r = MsiViewClose( htab );
 541         if(r != ERROR_SUCCESS )
 542             res = r;
 543
 544         r = MsiCloseHandle( htab );
 545         if(r != ERROR_SUCCESS )
 546             res = r;
 547     }
 548     return res;
 549 }
 550
 551 static UINT try_query( MSIHANDLE hdb, LPCSTR szQuery )
 552 {
 553     return try_query_param( hdb, szQuery, 0 );
 554 }
 555
 556 static UINT try_insert_query( MSIHANDLE hdb, LPCSTR szQuery )
 557 {
 558     MSIHANDLE hrec = 0;
 559     UINT r;
 560
 561     hrec = MsiCreateRecord( 1 );
 562     MsiRecordSetStringA( hrec, 1, "Hello");
 563
 564     r = try_query_param( hdb, szQuery, hrec );
 565
 566     MsiCloseHandle( hrec );
 567     return r;
 568 }
 569
 570 static void test_msibadqueries(void)
 571 {
 572     MSIHANDLE hdb = 0;
 573     UINT r;
 574
 575     DeleteFileA(msifile);
 576
 577     /* just MsiOpenDatabase should not create a file */
 578     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
 579     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 580
 581     r = MsiDatabaseCommit( hdb );
 582     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
 583
 584     r = MsiCloseHandle( hdb );
 585     ok(r == ERROR_SUCCESS , "Failed to close database\n");
 586
 587     /* open it readonly */
 588     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb );
 589     ok(r == ERROR_SUCCESS , "Failed to open database r/o\n");
 590
 591     /* add a table to it */
 592     r = try_query( hdb, "select * from _Tables");
 593     ok(r == ERROR_SUCCESS , "query 1 failed\n");
 594
 595     r = MsiCloseHandle( hdb );
 596     ok(r == ERROR_SUCCESS , "Failed to close database r/o\n");
 597
 598     /* open it read/write */
 599     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
 600     ok(r == ERROR_SUCCESS , "Failed to open database r/w\n");
 601
 602     /* a bunch of test queries that fail with the native MSI */
 603
 604     r = try_query( hdb, "CREATE TABLE");
 605     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2a return code\n");
 606
 607     r = try_query( hdb, "CREATE TABLE `a`");
 608     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2b return code\n");
 609
 610     r = try_query( hdb, "CREATE TABLE `a` ()");
 611     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2c return code\n");
 612
 613     r = try_query( hdb, "CREATE TABLE `a` (`b`)");
 614     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2d return code\n");
 615
 616     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) )");
 617     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2e return code\n");
 618
 619     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL)");
 620     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2f return code\n");
 621
 622     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY)");
 623     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2g return code\n");
 624
 625     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 626     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2h return code\n");
 627
 628     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 629     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2i return code\n");
 630
 631     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY 'b')");
 632     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2j return code\n");
 633
 634     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 635     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2k return code\n");
 636
 637     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 638     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2l return code\n");
 639
 640     r = try_query( hdb, "CREATE TABLE `a` (`b` CHA(72) NOT NULL PRIMARY KEY `b`)");
 641     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2m return code\n");
 642
 643     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(-1) NOT NULL PRIMARY KEY `b`)");
 644     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2n return code\n");
 645
 646     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(720) NOT NULL PRIMARY KEY `b`)");
 647     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2o return code\n");
 648
 649     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL KEY `b`)");
 650     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 651
 652     r = try_query( hdb, "CREATE TABLE `a` (`` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 653     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 654
 655     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 656     ok(r == ERROR_SUCCESS , "valid query 2z failed\n");
 657
 658     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 659     ok(r == ERROR_BAD_QUERY_SYNTAX , "created same table again\n");
 660
 661     r = try_query( hdb, "CREATE TABLE `aa` (`b` CHAR(72) NOT NULL, `c` "
 662           "CHAR(72), `d` CHAR(255) NOT NULL LOCALIZABLE PRIMARY KEY `b`)");
 663     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 664
 665     r = MsiDatabaseCommit( hdb );
 666     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 667
 668     r = try_query( hdb, "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL "
 669                           "PRIMARY KEY `foo`)");
 670     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 671
 672     r = try_insert_query( hdb, "insert into a  ( `b` ) VALUES ( ? )");
 673     ok(r == ERROR_SUCCESS , "failed to insert record in db\n");
 674
 675     r = MsiDatabaseCommit( hdb );
 676     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 677
 678     r = try_query( hdb, "CREATE TABLE `boo` (`foo` CHAR(72) NOT NULL "
 679                           "PRIMARY KEY `ba`)");
 680     ok(r != ERROR_SUCCESS , "query 5 succeeded\n");
 681
 682     r = try_query( hdb,"CREATE TABLE `bee` (`foo` CHAR(72) NOT NULL )");
 683     ok(r != ERROR_SUCCESS , "query 6 succeeded\n");
 684
 685     r = try_query( hdb, "CREATE TABLE `temp` (`t` CHAR(72) NOT NULL "
 686                           "PRIMARY KEY `t`)");
 687     ok(r == ERROR_SUCCESS , "query 7 failed\n");
 688
 689     r = try_query( hdb, "CREATE TABLE `c` (`b` CHAR NOT NULL PRIMARY KEY `b`)");
 690     ok(r == ERROR_SUCCESS , "query 8 failed\n");
 691
 692     r = try_query( hdb, "select * from c");
 693     ok(r == ERROR_SUCCESS , "query failed\n");
 694
 695     r = try_query( hdb, "select * from c where b = 'x");
 696     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 697
 698     r = try_query( hdb, "select * from c where b = 'x'");
 699     ok(r == ERROR_SUCCESS, "query failed\n");
 700
 701     r = try_query( hdb, "select * from 'c'");
 702     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 703
 704     r = try_query( hdb, "select * from ''");
 705     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 706
 707     r = try_query( hdb, "select * from c where b = x");
 708     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 709
 710     r = try_query( hdb, "select * from c where b = \"x\"");
 711     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 712
 713     r = try_query( hdb, "select * from c where b = 'x'");
 714     ok(r == ERROR_SUCCESS, "query failed\n");
 715
 716     r = try_query( hdb, "select * from c where b = '\"x'");
 717     ok(r == ERROR_SUCCESS, "query failed\n");
 718
 719     if (0)  /* FIXME: this query causes trouble with other tests */
 720     {
 721         r = try_query( hdb, "select * from c where b = '\\\'x'");
 722         ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 723     }
 724
 725     r = try_query( hdb, "select * from 'c'");
 726     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 727
 728     r = try_query( hdb, "select `c`.`b` from `c` order by `c`.`order`");
 729     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 730
 731     r = try_query( hdb, "select `c`.b` from `c`");
 732     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 733
 734     r = try_query( hdb, "select `c`.`b from `c`");
 735     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 736
 737     r = try_query( hdb, "select `c`.b from `c`");
 738     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 739
 740     r = try_query( hdb, "select `c.`b` from `c`");
 741     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 742
 743     r = try_query( hdb, "select c`.`b` from `c`");
 744     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 745
 746     r = try_query( hdb, "select c.`b` from `c`");
 747     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 748
 749     r = try_query( hdb, "select `c`.`b` from c`");
 750     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 751
 752     r = try_query( hdb, "select `c`.`b` from `c");
 753     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 754
 755     r = try_query( hdb, "select `c`.`b` from c");
 756     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 757
 758     r = try_query( hdb, "CREATE TABLE `\5a` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 759     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 760
 761     r = try_query( hdb, "SELECT * FROM \5a" );
 762     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 763
 764     r = try_query( hdb, "CREATE TABLE `a\5` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 765     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 766
 767     r = try_query( hdb, "SELECT * FROM a\5" );
 768     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 769
 770     r = try_query( hdb, "CREATE TABLE `-a` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 771     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 772
 773     r = try_query( hdb, "SELECT * FROM -a" );
 774     todo_wine ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 775
 776     r = try_query( hdb, "CREATE TABLE `a-` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 777     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 778
 779     r = try_query( hdb, "SELECT * FROM a-" );
 780     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 781
 782     r = MsiCloseHandle( hdb );
 783     ok(r == ERROR_SUCCESS , "Failed to close database transact\n");
 784
 785     r = DeleteFileA( msifile );
 786     ok(r == TRUE, "file didn't exist after commit\n");
 787 }
 788
 789 static void test_viewmodify(void)
 790 {
 791     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 792     UINT r;
 793     MSIDBERROR err;
 794     const char *query;
 795     char buffer[0x100];
 796     DWORD sz;
 797
 798     DeleteFileA(msifile);
 799
 800     /* just MsiOpenDatabase should not create a file */
 801     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
 802     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 803
 804     query = "CREATE TABLE `phone` ( "
 805             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 806             "PRIMARY KEY `id`)";
 807     r = run_query( hdb, 0, query );
 808     ok(r == ERROR_SUCCESS, "query failed\n");
 809
 810     query = "CREATE TABLE `_Validation` ( "
 811             "`Table` CHAR(32) NOT NULL, `Column` CHAR(32) NOT NULL, "
 812             "`Nullable` CHAR(4) NOT NULL, `MinValue` INT, `MaxValue` INT, "
 813             "`KeyTable` CHAR(255), `KeyColumn` SHORT, `Category` CHAR(32), "
 814             "`Set` CHAR(255), `Description` CHAR(255) PRIMARY KEY `Table`, `Column`)";
 815     r = run_query( hdb, 0, query );
 816     ok(r == ERROR_SUCCESS, "query failed\n");
 817
 818     query = "INSERT INTO `_Validation` ( `Table`, `Column`, `Nullable` ) "
 819             "VALUES('phone', 'id', 'N')";
 820     r = run_query( hdb, 0, query );
 821     ok(r == ERROR_SUCCESS, "query failed\n");
 822
 823     /* check what the error function reports without doing anything */
 824     sz = 0;
 825     /* passing NULL as the 3rd param make function to crash on older platforms */
 826     err = MsiViewGetErrorA( 0, NULL, &sz );
 827     ok(err == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 828
 829     /* open a view */
 830     query = "SELECT * FROM `phone`";
 831     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 832     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 833
 834     /* see what happens with a good hview and bad args */
 835     err = MsiViewGetErrorA( hview, NULL, NULL );
 836     ok(err == MSIDBERROR_INVALIDARG || err == MSIDBERROR_NOERROR,
 837        "MsiViewGetError returns %u (expected -3)\n", err);
 838     err = MsiViewGetErrorA( hview, buffer, NULL );
 839     ok(err == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 840
 841     /* see what happens with a zero length buffer */
 842     sz = 0;
 843     buffer[0] = 'x';
 844     err = MsiViewGetErrorA( hview, buffer, &sz );
 845     ok(err == MSIDBERROR_MOREDATA, "MsiViewGetError return\n");
 846     ok(buffer[0] == 'x', "buffer cleared\n");
 847     ok(sz == 0, "size not zero\n");
 848
 849     /* ok this one is strange */
 850     sz = 0;
 851     err = MsiViewGetErrorA( hview, NULL, &sz );
 852     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 853     ok(sz == 0, "size not zero\n");
 854
 855     /* see if it really has an error */
 856     sz = sizeof buffer;
 857     buffer[0] = 'x';
 858     err = MsiViewGetErrorA( hview, buffer, &sz );
 859     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 860     ok(buffer[0] == 0, "buffer not cleared\n");
 861     ok(sz == 0, "size not zero\n");
 862
 863     r = MsiViewExecute(hview, 0);
 864     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 865
 866     /* try some invalid records */
 867     r = MsiViewModify(hview, MSIMODIFY_INSERT, 0 );
 868     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 869     r = MsiViewModify(hview, -1, 0 );
 870     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 871
 872     /* try an small record */
 873     hrec = MsiCreateRecord(1);
 874     r = MsiViewModify(hview, -1, hrec );
 875     ok(r == ERROR_INVALID_DATA, "MsiViewModify failed\n");
 876
 877     sz = sizeof buffer;
 878     buffer[0] = 'x';
 879     err = MsiViewGetErrorA( hview, buffer, &sz );
 880     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 881     ok(buffer[0] == 0, "buffer not cleared\n");
 882     ok(sz == 0, "size not zero\n");
 883
 884     r = MsiCloseHandle(hrec);
 885     ok(r == ERROR_SUCCESS, "failed to close record\n");
 886
 887     /* insert a valid record */
 888     hrec = MsiCreateRecord(3);
 889
 890     r = MsiRecordSetInteger(hrec, 1, 1);
 891     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 892     r = MsiRecordSetStringA(hrec, 2, "bob");
 893     ok(r == ERROR_SUCCESS, "failed to set string\n");
 894     r = MsiRecordSetStringA(hrec, 3, "7654321");
 895     ok(r == ERROR_SUCCESS, "failed to set string\n");
 896
 897     r = MsiViewExecute(hview, 0);
 898     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 899     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 900     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 901
 902     /* validate it */
 903     r = MsiViewExecute(hview, 0);
 904     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 905
 906     r = MsiViewModify(hview, MSIMODIFY_VALIDATE_NEW, hrec );
 907     ok(r == ERROR_INVALID_DATA, "MsiViewModify failed %u\n", r);
 908
 909     sz = sizeof buffer;
 910     buffer[0] = 'x';
 911     err = MsiViewGetErrorA( hview, buffer, &sz );
 912     ok(err == MSIDBERROR_DUPLICATEKEY, "MsiViewGetError returned %u\n", err);
 913     ok(!strcmp(buffer, "id"), "expected \"id\" c, got \"%s\"\n", buffer);
 914     ok(sz == 2, "size not 2\n");
 915
 916     /* insert the same thing again */
 917     r = MsiViewExecute(hview, 0);
 918     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 919
 920     /* should fail ... */
 921     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 922     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 923
 924     /* try to merge the same record */
 925     r = MsiViewExecute(hview, 0);
 926     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 927     r = MsiViewModify(hview, MSIMODIFY_MERGE, hrec );
 928     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 929
 930     r = MsiCloseHandle(hrec);
 931     ok(r == ERROR_SUCCESS, "failed to close record\n");
 932
 933     /* try merging a new record */
 934     hrec = MsiCreateRecord(3);
 935
 936     r = MsiRecordSetInteger(hrec, 1, 10);
 937     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 938     r = MsiRecordSetStringA(hrec, 2, "pepe");
 939     ok(r == ERROR_SUCCESS, "failed to set string\n");
 940     r = MsiRecordSetStringA(hrec, 3, "7654321");
 941     ok(r == ERROR_SUCCESS, "failed to set string\n");
 942
 943     r = MsiViewModify(hview, MSIMODIFY_MERGE, hrec );
 944     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 945     r = MsiViewExecute(hview, 0);
 946     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 947
 948     r = MsiCloseHandle(hrec);
 949     ok(r == ERROR_SUCCESS, "failed to close record\n");
 950
 951     r = MsiViewClose(hview);
 952     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 953     r = MsiCloseHandle(hview);
 954     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 955
 956     query = "SELECT * FROM `phone`";
 957     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 958     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 959
 960     r = MsiViewExecute(hview, 0);
 961     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 962
 963     r = MsiViewFetch(hview, &hrec);
 964     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 965
 966     r = MsiRecordGetInteger(hrec, 1);
 967     ok(r == 1, "Expected 1, got %d\n", r);
 968
 969     sz = sizeof(buffer);
 970     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
 971     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 972     ok(!lstrcmpA(buffer, "bob"), "Expected bob, got %s\n", buffer);
 973
 974     sz = sizeof(buffer);
 975     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
 976     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 977     ok(!lstrcmpA(buffer, "7654321"), "Expected 7654321, got %s\n", buffer);
 978
 979     /* update the view, non-primary key */
 980     r = MsiRecordSetStringA(hrec, 3, "3141592");
 981     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 982
 983     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 984     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 985
 986     /* do it again */
 987     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 988     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
 989
 990     /* update the view, primary key */
 991     r = MsiRecordSetInteger(hrec, 1, 5);
 992     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 993
 994     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 995     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 996
 997     r = MsiCloseHandle(hrec);
 998     ok(r == ERROR_SUCCESS, "failed to close record\n");
 999
1000     r = MsiViewClose(hview);
1001     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1002     r = MsiCloseHandle(hview);
1003     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1004
1005     query = "SELECT * FROM `phone`";
1006     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1007     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1008
1009     r = MsiViewExecute(hview, 0);
1010     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1011
1012     r = MsiViewFetch(hview, &hrec);
1013     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1014
1015     r = MsiRecordGetInteger(hrec, 1);
1016     ok(r == 1, "Expected 1, got %d\n", r);
1017
1018     sz = sizeof(buffer);
1019     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
1020     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
1021     ok(!lstrcmpA(buffer, "bob"), "Expected bob, got %s\n", buffer);
1022
1023     sz = sizeof(buffer);
1024     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
1025     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
1026     ok(!lstrcmpA(buffer, "3141592"), "Expected 3141592, got %s\n", buffer);
1027
1028     r = MsiCloseHandle(hrec);
1029     ok(r == ERROR_SUCCESS, "failed to close record\n");
1030
1031     /* use a record that doesn't come from a view fetch */
1032     hrec = MsiCreateRecord(3);
1033     ok(hrec != 0, "MsiCreateRecord failed\n");
1034
1035     r = MsiRecordSetInteger(hrec, 1, 3);
1036     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1037     r = MsiRecordSetStringA(hrec, 2, "jane");
1038     ok(r == ERROR_SUCCESS, "failed to set string\n");
1039     r = MsiRecordSetStringA(hrec, 3, "112358");
1040     ok(r == ERROR_SUCCESS, "failed to set string\n");
1041
1042     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
1043     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
1044
1045     r = MsiCloseHandle(hrec);
1046     ok(r == ERROR_SUCCESS, "failed to close record\n");
1047
1048     /* use a record that doesn't come from a view fetch, primary key matches */
1049     hrec = MsiCreateRecord(3);
1050     ok(hrec != 0, "MsiCreateRecord failed\n");
1051
1052     r = MsiRecordSetInteger(hrec, 1, 1);
1053     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1054     r = MsiRecordSetStringA(hrec, 2, "jane");
1055     ok(r == ERROR_SUCCESS, "failed to set string\n");
1056     r = MsiRecordSetStringA(hrec, 3, "112358");
1057     ok(r == ERROR_SUCCESS, "failed to set string\n");
1058
1059     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
1060     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
1061
1062     r = MsiCloseHandle(hrec);
1063     ok(r == ERROR_SUCCESS, "failed to close record\n");
1064
1065     hrec = MsiCreateRecord(3);
1066
1067     r = MsiRecordSetInteger(hrec, 1, 2);
1068     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1069     r = MsiRecordSetStringA(hrec, 2, "nick");
1070     ok(r == ERROR_SUCCESS, "failed to set string\n");
1071     r = MsiRecordSetStringA(hrec, 3, "141421");
1072     ok(r == ERROR_SUCCESS, "failed to set string\n");
1073
1074     r = MsiViewExecute(hview, 0);
1075     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1076     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
1077     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
1078
1079     r = MsiCloseHandle(hrec);
1080     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1081     r = MsiViewClose(hview);
1082     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1083     r = MsiCloseHandle(hview);
1084     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1085
1086     query = "SELECT * FROM `phone` WHERE `id` = 1";
1087     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1088     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1089     r = MsiViewExecute(hview, 0);
1090     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1091     r = MsiViewFetch(hview, &hrec);
1092     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1093
1094     /* change the id to match the second row */
1095     r = MsiRecordSetInteger(hrec, 1, 2);
1096     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1097     r = MsiRecordSetStringA(hrec, 2, "jerry");
1098     ok(r == ERROR_SUCCESS, "failed to set string\n");
1099
1100     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
1101     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
1102
1103     r = MsiCloseHandle(hrec);
1104     ok(r == ERROR_SUCCESS, "failed to close record\n");
1105     r = MsiViewClose(hview);
1106     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1107     r = MsiCloseHandle(hview);
1108     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1109
1110     /* broader search */
1111     query = "SELECT * FROM `phone` ORDER BY `id`";
1112     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1113     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1114     r = MsiViewExecute(hview, 0);
1115     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1116     r = MsiViewFetch(hview, &hrec);
1117     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1118
1119     /* change the id to match the second row */
1120     r = MsiRecordSetInteger(hrec, 1, 2);
1121     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1122     r = MsiRecordSetStringA(hrec, 2, "jerry");
1123     ok(r == ERROR_SUCCESS, "failed to set string\n");
1124
1125     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
1126     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
1127
1128     r = MsiCloseHandle(hrec);
1129     ok(r == ERROR_SUCCESS, "failed to close record\n");
1130     r = MsiViewClose(hview);
1131     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1132     r = MsiCloseHandle(hview);
1133     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1134
1135     r = MsiCloseHandle( hdb );
1136     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
1137 }
1138
1139 static MSIHANDLE create_db(void)
1140 {
1141     MSIHANDLE hdb = 0;
1142     UINT res;
1143
1144     DeleteFileW(msifileW);
1145
1146     /* create an empty database */
1147     res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
1148     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
1149     if( res != ERROR_SUCCESS )
1150         return hdb;
1151
1152     res = MsiDatabaseCommit( hdb );
1153     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
1154
1155     return hdb;
1156 }
1157
1158 static void test_getcolinfo(void)
1159 {
1160     MSIHANDLE hdb, hview = 0, rec = 0;
1161     UINT r;
1162     DWORD sz;
1163     char buffer[0x20];
1164
1165     /* create an empty db */
1166     hdb = create_db();
1167     ok( hdb, "failed to create db\n");
1168
1169     /* tables should be present */
1170     r = MsiDatabaseOpenViewA(hdb, "select * from _Tables", &hview);
1171     ok( r == ERROR_SUCCESS, "failed to open query\n");
1172
1173     r = MsiViewExecute(hview, 0);
1174     ok( r == ERROR_SUCCESS, "failed to execute query\n");
1175
1176     /* check that NAMES works */
1177     rec = 0;
1178     r = MsiViewGetColumnInfo( hview, MSICOLINFO_NAMES, &rec );
1179     ok( r == ERROR_SUCCESS, "failed to get names\n");
1180     sz = sizeof buffer;
1181     r = MsiRecordGetStringA(rec, 1, buffer, &sz );
1182     ok( r == ERROR_SUCCESS, "failed to get string\n");
1183     ok( !strcmp(buffer,"Name"), "_Tables has wrong column name\n");
1184     r = MsiCloseHandle( rec );
1185     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
1186
1187     /* check that TYPES works */
1188     rec = 0;
1189     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, &rec );
1190     ok( r == ERROR_SUCCESS, "failed to get names\n");
1191     sz = sizeof buffer;
1192     r = MsiRecordGetStringA(rec, 1, buffer, &sz );
1193     ok( r == ERROR_SUCCESS, "failed to get string\n");
1194     ok( !strcmp(buffer,"s64"), "_Tables has wrong column type\n");
1195     r = MsiCloseHandle( rec );
1196     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
1197
1198     /* check that invalid values fail */
1199     rec = 0;
1200     r = MsiViewGetColumnInfo( hview, 100, &rec );
1201     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
1202     ok( rec == 0, "returned a record\n");
1203
1204     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, NULL );
1205     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
1206
1207     r = MsiViewGetColumnInfo( 0, MSICOLINFO_TYPES, &rec );
1208     ok( r == ERROR_INVALID_HANDLE, "wrong error code\n");
1209
1210     r = MsiViewClose(hview);
1211     ok( r == ERROR_SUCCESS, "failed to close view\n");
1212     r = MsiCloseHandle(hview);
1213     ok( r == ERROR_SUCCESS, "failed to close view handle\n");
1214     r = MsiCloseHandle(hdb);
1215     ok( r == ERROR_SUCCESS, "failed to close database\n");
1216 }
1217
1218 static MSIHANDLE get_column_info(MSIHANDLE hdb, const char *query, MSICOLINFO type)
1219 {
1220     MSIHANDLE hview = 0, rec = 0;
1221     UINT r;
1222
1223     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1224     if( r != ERROR_SUCCESS )
1225         return r;
1226
1227     r = MsiViewExecute(hview, 0);
1228     if( r == ERROR_SUCCESS )
1229     {
1230         MsiViewGetColumnInfo( hview, type, &rec );
1231     }
1232     MsiViewClose(hview);
1233     MsiCloseHandle(hview);
1234     return rec;
1235 }
1236
1237 static UINT get_columns_table_type(MSIHANDLE hdb, const char *table, UINT field)
1238 {
1239     MSIHANDLE hview = 0, rec = 0;
1240     UINT r, type = 0;
1241     char query[0x100];
1242
1243     sprintf(query, "select * from `_Columns` where  `Table` = '%s'", table );
1244
1245     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1246     if( r != ERROR_SUCCESS )
1247         return r;
1248
1249     r = MsiViewExecute(hview, 0);
1250     if( r == ERROR_SUCCESS )
1251     {
1252         while (1)
1253         {
1254             r = MsiViewFetch( hview, &rec );
1255             if( r != ERROR_SUCCESS)
1256                 break;
1257             r = MsiRecordGetInteger( rec, 2 );
1258             if (r == field)
1259                 type = MsiRecordGetInteger( rec, 4 );
1260             MsiCloseHandle( rec );
1261         }
1262     }
1263     MsiViewClose(hview);
1264     MsiCloseHandle(hview);
1265     return type;
1266 }
1267
1268 static BOOL check_record( MSIHANDLE rec, UINT field, LPCSTR val )
1269 {
1270     CHAR buffer[0x20];
1271     UINT r;
1272     DWORD sz;
1273
1274     sz = sizeof buffer;
1275     r = MsiRecordGetStringA( rec, field, buffer, &sz );
1276     return (r == ERROR_SUCCESS ) && !strcmp(val, buffer);
1277 }
1278
1279 static void test_viewgetcolumninfo(void)
1280 {
1281     MSIHANDLE hdb = 0, rec;
1282     UINT r;
1283
1284     hdb = create_db();
1285     ok( hdb, "failed to create db\n");
1286
1287     r = run_query( hdb, 0,
1288             "CREATE TABLE `Properties` "
1289             "( `Property` CHAR(255), "
1290             "  `Value` CHAR(1), "
1291             "  `Intvalue` INT, "
1292             "  `Integervalue` INTEGER, "
1293             "  `Shortvalue` SHORT, "
1294             "  `Longvalue` LONG, "
1295             "  `Longcharvalue` LONGCHAR "
1296             "  PRIMARY KEY `Property`)" );
1297     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1298
1299     /* check the column types */
1300     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_TYPES );
1301     ok( rec, "failed to get column info record\n" );
1302
1303     ok( check_record( rec, 1, "S255"), "wrong record type\n");
1304     ok( check_record( rec, 2, "S1"), "wrong record type\n");
1305     ok( check_record( rec, 3, "I2"), "wrong record type\n");
1306     ok( check_record( rec, 4, "I2"), "wrong record type\n");
1307     ok( check_record( rec, 5, "I2"), "wrong record type\n");
1308     ok( check_record( rec, 6, "I4"), "wrong record type\n");
1309     ok( check_record( rec, 7, "S0"), "wrong record type\n");
1310
1311     MsiCloseHandle( rec );
1312
1313     /* check the type in _Columns */
1314     ok( 0x3dff == get_columns_table_type(hdb, "Properties", 1 ), "_columns table wrong\n");
1315     ok( 0x1d01 == get_columns_table_type(hdb, "Properties", 2 ), "_columns table wrong\n");
1316     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 3 ), "_columns table wrong\n");
1317     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 4 ), "_columns table wrong\n");
1318     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 5 ), "_columns table wrong\n");
1319     ok( 0x1104 == get_columns_table_type(hdb, "Properties", 6 ), "_columns table wrong\n");
1320     ok( 0x1d00 == get_columns_table_type(hdb, "Properties", 7 ), "_columns table wrong\n");
1321
1322     /* now try the names */
1323     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_NAMES );
1324     ok( rec, "failed to get column info record\n" );
1325
1326     ok( check_record( rec, 1, "Property"), "wrong record type\n");
1327     ok( check_record( rec, 2, "Value"), "wrong record type\n");
1328     ok( check_record( rec, 3, "Intvalue"), "wrong record type\n");
1329     ok( check_record( rec, 4, "Integervalue"), "wrong record type\n");
1330     ok( check_record( rec, 5, "Shortvalue"), "wrong record type\n");
1331     ok( check_record( rec, 6, "Longvalue"), "wrong record type\n");
1332     ok( check_record( rec, 7, "Longcharvalue"), "wrong record type\n");
1333
1334     MsiCloseHandle( rec );
1335
1336     r = run_query( hdb, 0,
1337             "CREATE TABLE `Binary` "
1338             "( `Name` CHAR(255), `Data` OBJECT  PRIMARY KEY `Name`)" );
1339     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1340
1341     /* check the column types */
1342     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_TYPES );
1343     ok( rec, "failed to get column info record\n" );
1344
1345     ok( check_record( rec, 1, "S255"), "wrong record type\n");
1346     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1347
1348     MsiCloseHandle( rec );
1349
1350     /* check the type in _Columns */
1351     ok( 0x3dff == get_columns_table_type(hdb, "Binary", 1 ), "_columns table wrong\n");
1352     ok( 0x1900 == get_columns_table_type(hdb, "Binary", 2 ), "_columns table wrong\n");
1353
1354     /* now try the names */
1355     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_NAMES );
1356     ok( rec, "failed to get column info record\n" );
1357
1358     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1359     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1360     MsiCloseHandle( rec );
1361
1362     r = run_query( hdb, 0,
1363             "CREATE TABLE `UIText` "
1364             "( `Key` CHAR(72) NOT NULL, `Text` CHAR(255) LOCALIZABLE PRIMARY KEY `Key`)" );
1365     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1366
1367     ok( 0x2d48 == get_columns_table_type(hdb, "UIText", 1 ), "_columns table wrong\n");
1368     ok( 0x1fff == get_columns_table_type(hdb, "UIText", 2 ), "_columns table wrong\n");
1369
1370     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_NAMES );
1371     ok( rec, "failed to get column info record\n" );
1372     ok( check_record( rec, 1, "Key"), "wrong record type\n");
1373     ok( check_record( rec, 2, "Text"), "wrong record type\n");
1374     MsiCloseHandle( rec );
1375
1376     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_TYPES );
1377     ok( rec, "failed to get column info record\n" );
1378     ok( check_record( rec, 1, "s72"), "wrong record type\n");
1379     ok( check_record( rec, 2, "L255"), "wrong record type\n");
1380     MsiCloseHandle( rec );
1381
1382     MsiCloseHandle( hdb );
1383 }
1384
1385 static void test_msiexport(void)
1386 {
1387     MSIHANDLE hdb = 0, hview = 0;
1388     UINT r;
1389     const char *query;
1390     char path[MAX_PATH];
1391     const char file[] = "phone.txt";
1392     HANDLE handle;
1393     char buffer[0x100];
1394     DWORD length;
1395     const char expected[] =
1396         "id\tname\tnumber\r\n"
1397         "I2\tS32\tS32\r\n"
1398         "phone\tid\r\n"
1399         "1\tAbe\t8675309\r\n";
1400
1401     DeleteFileW(msifileW);
1402
1403     /* just MsiOpenDatabase should not create a file */
1404     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
1405     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1406
1407     /* create a table */
1408     query = "CREATE TABLE `phone` ( "
1409             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
1410             "PRIMARY KEY `id`)";
1411     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1412     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1413     r = MsiViewExecute(hview, 0);
1414     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1415     r = MsiViewClose(hview);
1416     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1417     r = MsiCloseHandle(hview);
1418     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1419
1420     /* insert a value into it */
1421     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
1422         "VALUES('1', 'Abe', '8675309')";
1423     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1424     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1425     r = MsiViewExecute(hview, 0);
1426     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1427     r = MsiViewClose(hview);
1428     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1429     r = MsiCloseHandle(hview);
1430     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1431
1432     GetCurrentDirectoryA(MAX_PATH, path);
1433
1434     r = MsiDatabaseExportA(hdb, "phone", path, file);
1435     ok(r == ERROR_SUCCESS, "MsiDatabaseExport failed\n");
1436
1437     MsiCloseHandle(hdb);
1438
1439     lstrcatA(path, "\\");
1440     lstrcatA(path, file);
1441
1442     /* check the data that was written */
1443     length = 0;
1444     memset(buffer, 0, sizeof buffer);
1445     handle = CreateFileA(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
1446     if (handle != INVALID_HANDLE_VALUE)
1447     {
1448         ReadFile(handle, buffer, sizeof buffer, &length, NULL);
1449         CloseHandle(handle);
1450         DeleteFileA(path);
1451     }
1452     else
1453         ok(0, "failed to open file %s\n", path);
1454
1455     ok( length == strlen(expected), "length of data wrong\n");
1456     ok( !lstrcmpA(buffer, expected), "data doesn't match\n");
1457     DeleteFileA(msifile);
1458 }
1459
1460 static void test_longstrings(void)
1461 {
1462     const char insert_query[] =
1463         "INSERT INTO `strings` ( `id`, `val` ) VALUES('1', 'Z')";
1464     char *str;
1465     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
1466     DWORD len;
1467     UINT r;
1468     const DWORD STRING_LENGTH = 0x10005;
1469
1470     DeleteFileW(msifileW);
1471     /* just MsiOpenDatabase should not create a file */
1472     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
1473     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1474
1475     /* create a table */
1476     r = try_query( hdb,
1477         "CREATE TABLE `strings` ( `id` INT, `val` CHAR(0) PRIMARY KEY `id`)");
1478     ok(r == ERROR_SUCCESS, "query failed\n");
1479
1480     /* try to insert a very long string */
1481     str = HeapAlloc(GetProcessHeap(), 0, STRING_LENGTH+sizeof insert_query);
1482     len = strchr(insert_query, 'Z') - insert_query;
1483     strcpy(str, insert_query);
1484     memset(str+len, 'Z', STRING_LENGTH);
1485     strcpy(str+len+STRING_LENGTH, insert_query+len+1);
1486     r = try_query( hdb, str );
1487     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1488
1489     HeapFree(GetProcessHeap(), 0, str);
1490
1491     r = MsiDatabaseCommit(hdb);
1492     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
1493     MsiCloseHandle(hdb);
1494
1495     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
1496     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1497
1498     r = MsiDatabaseOpenViewA(hdb, "select * from `strings` where `id` = 1", &hview);
1499     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1500
1501     r = MsiViewExecute(hview, 0);
1502     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1503
1504     r = MsiViewFetch(hview, &hrec);
1505     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1506
1507     MsiViewClose(hview);
1508     MsiCloseHandle(hview);
1509
1510     r = MsiRecordGetStringA(hrec, 2, NULL, &len);
1511     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1512     ok(len == STRING_LENGTH, "string length wrong\n");
1513
1514     MsiCloseHandle(hrec);
1515     MsiCloseHandle(hdb);
1516     DeleteFileA(msifile);
1517 }
1518
1519 static void create_file_data(LPCSTR name, LPCSTR data, DWORD size)
1520 {
1521     HANDLE file;
1522     DWORD written;
1523
1524     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
1525     if (file == INVALID_HANDLE_VALUE)
1526         return;
1527
1528     WriteFile(file, data, strlen(data), &written, NULL);
1529     WriteFile(file, "\n", strlen("\n"), &written, NULL);
1530
1531     if (size)
1532     {
1533         SetFilePointer(file, size, NULL, FILE_BEGIN);
1534         SetEndOfFile(file);
1535     }
1536
1537     CloseHandle(file);
1538 }
1539
1540 #define create_file(name) create_file_data(name, name, 0)
1541
1542 static void test_streamtable(void)
1543 {
1544     MSIHANDLE hdb = 0, rec, view, hsi;
1545     char file[MAX_PATH];
1546     char buf[MAX_PATH];
1547     DWORD size;
1548     UINT r;
1549
1550     hdb = create_db();
1551     ok( hdb, "failed to create db\n");
1552
1553     r = run_query( hdb, 0,
1554             "CREATE TABLE `Properties` "
1555             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
1556     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1557
1558     r = run_query( hdb, 0,
1559             "INSERT INTO `Properties` "
1560             "( `Value`, `Property` ) VALUES ( 'Prop', 'value' )" );
1561     ok( r == ERROR_SUCCESS, "Failed to add to table\n" );
1562
1563     r = MsiDatabaseCommit( hdb );
1564     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1565
1566     MsiCloseHandle( hdb );
1567
1568     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
1569     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1570
1571     /* check the column types */
1572     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_TYPES );
1573     ok( rec, "failed to get column info record\n" );
1574
1575     ok( check_record( rec, 1, "s62"), "wrong record type\n");
1576     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1577
1578     MsiCloseHandle( rec );
1579
1580     /* now try the names */
1581     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_NAMES );
1582     ok( rec, "failed to get column info record\n" );
1583
1584     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1585     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1586
1587     MsiCloseHandle( rec );
1588
1589     r = MsiDatabaseOpenViewA( hdb,
1590             "SELECT * FROM `_Streams` WHERE `Name` = '\5SummaryInformation'", &view );
1591     ok( r == ERROR_SUCCESS, "Failed to open database view: %u\n", r );
1592
1593     r = MsiViewExecute( view, 0 );
1594     ok( r == ERROR_SUCCESS, "Failed to execute view: %u\n", r );
1595
1596     r = MsiViewFetch( view, &rec );
1597     ok( r == ERROR_NO_MORE_ITEMS, "Unexpected result: %u\n", r );
1598
1599     MsiCloseHandle( rec );
1600     MsiViewClose( view );
1601     MsiCloseHandle( view );
1602
1603     /* create a summary information stream */
1604     r = MsiGetSummaryInformationA( hdb, NULL, 1, &hsi );
1605     ok( r == ERROR_SUCCESS, "Failed to get summary information handle: %u\n", r );
1606
1607     r = MsiSummaryInfoSetPropertyA( hsi, PID_SECURITY, VT_I4, 2, NULL, NULL );
1608     ok( r == ERROR_SUCCESS, "Failed to set property: %u\n", r );
1609
1610     r = MsiSummaryInfoPersist( hsi );
1611     ok( r == ERROR_SUCCESS, "Failed to save summary information: %u\n", r );
1612
1613     MsiCloseHandle( hsi );
1614
1615     r = MsiDatabaseOpenViewA( hdb,
1616             "SELECT * FROM `_Streams` WHERE `Name` = '\5SummaryInformation'", &view );
1617     ok( r == ERROR_SUCCESS, "Failed to open database view: %u\n", r );
1618
1619     r = MsiViewExecute( view, 0 );
1620     ok( r == ERROR_SUCCESS, "Failed to execute view: %u\n", r );
1621
1622     r = MsiViewFetch( view, &rec );
1623     ok( r == ERROR_SUCCESS, "Unexpected result: %u\n", r );
1624
1625     MsiCloseHandle( rec );
1626     MsiViewClose( view );
1627     MsiCloseHandle( view );
1628
1629     /* insert a file into the _Streams table */
1630     create_file( "test.txt" );
1631
1632     rec = MsiCreateRecord( 2 );
1633     MsiRecordSetStringA( rec, 1, "data" );
1634
1635     r = MsiRecordSetStreamA( rec, 2, "test.txt" );
1636     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1637
1638     DeleteFileA("test.txt");
1639
1640     r = MsiDatabaseOpenViewA( hdb,
1641             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1642     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1643
1644     r = MsiViewExecute( view, rec );
1645     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1646
1647     MsiCloseHandle( rec );
1648     MsiViewClose( view );
1649     MsiCloseHandle( view );
1650
1651     /* insert another one */
1652     create_file( "test1.txt" );
1653
1654     rec = MsiCreateRecord( 2 );
1655     MsiRecordSetStringA( rec, 1, "data1" );
1656
1657     r = MsiRecordSetStreamA( rec, 2, "test1.txt" );
1658     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1659
1660     DeleteFileA("test1.txt");
1661
1662     r = MsiDatabaseOpenViewA( hdb,
1663             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1664     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1665
1666     r = MsiViewExecute( view, rec );
1667     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1668
1669     MsiCloseHandle( rec );
1670     MsiViewClose( view );
1671     MsiCloseHandle( view );
1672
1673     /* try again */
1674     create_file( "test1.txt" );
1675
1676     rec = MsiCreateRecord( 2 );
1677     MsiRecordSetStringA( rec, 1, "data1" );
1678
1679     r = MsiRecordSetStreamA( rec, 2, "test1.txt" );
1680     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r );
1681
1682     DeleteFileA( "test1.txt" );
1683
1684     r = MsiDatabaseOpenViewA( hdb,
1685             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1686     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r );
1687
1688     r = MsiViewExecute( view, rec );
1689     ok( r == ERROR_FUNCTION_FAILED, "got %u\n", r );
1690
1691     MsiCloseHandle( rec );
1692     MsiViewClose( view );
1693     MsiCloseHandle( view );
1694
1695     r = MsiDatabaseOpenViewA( hdb,
1696             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data'", &view );
1697     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1698
1699     r = MsiViewExecute( view, 0 );
1700     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1701
1702     r = MsiViewFetch( view, &rec );
1703     ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1704
1705     size = MAX_PATH;
1706     r = MsiRecordGetStringA( rec, 1, file, &size );
1707     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1708     ok( !lstrcmpA(file, "data"), "Expected 'data', got %s\n", file);
1709
1710     size = MAX_PATH;
1711     memset(buf, 0, MAX_PATH);
1712     r = MsiRecordReadStream( rec, 2, buf, &size );
1713     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1714     ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf);
1715
1716     MsiCloseHandle( rec );
1717     MsiViewClose( view );
1718     MsiCloseHandle( view );
1719
1720     r = MsiDatabaseOpenViewA( hdb,
1721             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data1'", &view );
1722     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1723
1724     r = MsiViewExecute( view, 0 );
1725     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1726
1727     r = MsiViewFetch( view, &rec );
1728     ok( r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1729
1730     size = MAX_PATH;
1731     r = MsiRecordGetStringA( rec, 1, file, &size );
1732     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1733     ok( !lstrcmpA(file, "data1"), "Expected 'data1', got %s\n", file);
1734
1735     size = MAX_PATH;
1736     memset(buf, 0, MAX_PATH);
1737     r = MsiRecordReadStream( rec, 2, buf, &size );
1738     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1739     ok( !lstrcmpA(buf, "test1.txt\n"), "Expected 'test1.txt\\n', got %s\n", buf);
1740
1741     MsiCloseHandle( rec );
1742     MsiViewClose( view );
1743     MsiCloseHandle( view );
1744
1745     /* perform an update */
1746     create_file( "test2.txt" );
1747     rec = MsiCreateRecord( 1 );
1748
1749     r = MsiRecordSetStreamA( rec, 1, "test2.txt" );
1750     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1751
1752     DeleteFileA("test2.txt");
1753
1754     r = MsiDatabaseOpenViewA( hdb,
1755             "UPDATE `_Streams` SET `Data` = ? WHERE `Name` = 'data1'", &view );
1756     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1757
1758     r = MsiViewExecute( view, rec );
1759     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1760
1761     MsiCloseHandle( rec );
1762     MsiViewClose( view );
1763     MsiCloseHandle( view );
1764
1765     r = MsiDatabaseOpenViewA( hdb,
1766             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data1'", &view );
1767     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1768
1769     r = MsiViewExecute( view, 0 );
1770     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1771
1772     r = MsiViewFetch( view, &rec );
1773     ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1774
1775     size = MAX_PATH;
1776     r = MsiRecordGetStringA( rec, 1, file, &size );
1777     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1778     ok( !lstrcmpA(file, "data1"), "Expected 'data1', got %s\n", file);
1779
1780     size = MAX_PATH;
1781     memset(buf, 0, MAX_PATH);
1782     r = MsiRecordReadStream( rec, 2, buf, &size );
1783     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1784     ok( !lstrcmpA(buf, "test2.txt\n"), "Expected 'test2.txt\\n', got %s\n", buf);
1785
1786     MsiCloseHandle( rec );
1787     MsiViewClose( view );
1788     MsiCloseHandle( view );
1789     MsiCloseHandle( hdb );
1790     DeleteFileA(msifile);
1791 }
1792
1793 static void test_binary(void)
1794 {
1795     MSIHANDLE hdb = 0, rec;
1796     char file[MAX_PATH];
1797     char buf[MAX_PATH];
1798     DWORD size;
1799     LPCSTR query;
1800     UINT r;
1801
1802     /* insert a file into the Binary table */
1803     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
1804     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1805
1806     query = "CREATE TABLE `Binary` ( `Name` CHAR(72) NOT NULL, `ID` INT NOT NULL, `Data` OBJECT  PRIMARY KEY `Name`, `ID`)";
1807     r = run_query( hdb, 0, query );
1808     ok( r == ERROR_SUCCESS, "Cannot create Binary table: %d\n", r );
1809
1810     create_file( "test.txt" );
1811     rec = MsiCreateRecord( 1 );
1812     r = MsiRecordSetStreamA( rec, 1, "test.txt" );
1813     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1814     DeleteFileA( "test.txt" );
1815
1816     /* try a name that exceeds maximum OLE stream name length */
1817     query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'encryption.dll.CB4E6205_F99A_4C51_ADD4_184506EFAB87', 10000, ? )";
1818     r = run_query( hdb, rec, query );
1819     ok( r == ERROR_SUCCESS, "Insert into Binary table failed: %d\n", r );
1820
1821     r = MsiCloseHandle( rec );
1822     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1823
1824     r = MsiDatabaseCommit( hdb );
1825     ok( r == ERROR_FUNCTION_FAILED , "got %u\n", r );
1826
1827     r = MsiCloseHandle( hdb );
1828     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1829
1830     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
1831     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1832
1833     query = "CREATE TABLE `Binary` ( `Name` CHAR(72) NOT NULL, `ID` INT NOT NULL, `Data` OBJECT  PRIMARY KEY `Name`, `ID`)";
1834     r = run_query( hdb, 0, query );
1835     ok( r == ERROR_SUCCESS, "Cannot create Binary table: %d\n", r );
1836
1837     create_file( "test.txt" );
1838     rec = MsiCreateRecord( 1 );
1839     r = MsiRecordSetStreamA( rec, 1, "test.txt" );
1840     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r );
1841     DeleteFileA( "test.txt" );
1842
1843     query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'filename1', 1, ? )";
1844     r = run_query( hdb, rec, query );
1845     ok( r == ERROR_SUCCESS, "Insert into Binary table failed: %d\n", r );
1846
1847     query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'filename1', 1, ? )";
1848     r = run_query( hdb, rec, query );
1849     ok( r == ERROR_FUNCTION_FAILED, "got %u\n", r );
1850
1851     r = MsiCloseHandle( rec );
1852     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1853
1854     r = MsiDatabaseCommit( hdb );
1855     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1856
1857     r = MsiCloseHandle( hdb );
1858     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1859
1860     /* read file from the Stream table */
1861     r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_READONLY, &hdb );
1862     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1863
1864     query = "SELECT * FROM `_Streams`";
1865     r = do_query( hdb, query, &rec );
1866     ok( r == ERROR_SUCCESS, "SELECT query failed: %d\n", r );
1867
1868     size = MAX_PATH;
1869     r = MsiRecordGetStringA( rec, 1, file, &size );
1870     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
1871     ok( !lstrcmpA(file, "Binary.filename1.1"), "Expected 'Binary.filename1.1', got %s\n", file );
1872
1873     size = MAX_PATH;
1874     memset( buf, 0, MAX_PATH );
1875     r = MsiRecordReadStream( rec, 2, buf, &size );
1876     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r );
1877     ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf );
1878
1879     r = MsiCloseHandle( rec );
1880     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1881
1882     /* read file from the Binary table */
1883     query = "SELECT * FROM `Binary`";
1884     r = do_query( hdb, query, &rec );
1885     ok( r == ERROR_SUCCESS, "SELECT query failed: %d\n", r );
1886
1887     size = MAX_PATH;
1888     r = MsiRecordGetStringA( rec, 1, file, &size );
1889     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
1890     ok( !lstrcmpA(file, "filename1"), "Expected 'filename1', got %s\n", file );
1891
1892     size = MAX_PATH;
1893     memset( buf, 0, MAX_PATH );
1894     r = MsiRecordReadStream( rec, 3, buf, &size );
1895     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r );
1896     ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf );
1897
1898     r = MsiCloseHandle( rec );
1899     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1900
1901     r = MsiCloseHandle( hdb );
1902     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1903
1904     DeleteFileA( msifile );
1905 }
1906
1907 static void test_where_not_in_selected(void)
1908 {
1909     MSIHANDLE hdb = 0, rec, view;
1910     LPCSTR query;
1911     UINT r;
1912
1913     hdb = create_db();
1914     ok( hdb, "failed to create db\n");
1915
1916     r = run_query(hdb, 0,
1917             "CREATE TABLE `IESTable` ("
1918             "`Action` CHAR(64), "
1919             "`Condition` CHAR(64), "
1920             "`Sequence` LONG PRIMARY KEY `Sequence`)");
1921     ok( r == S_OK, "Cannot create IESTable table: %d\n", r);
1922
1923     r = run_query(hdb, 0,
1924             "CREATE TABLE `CATable` ("
1925             "`Action` CHAR(64), "
1926             "`Type` LONG PRIMARY KEY `Type`)");
1927     ok( r == S_OK, "Cannot create CATable table: %d\n", r);
1928
1929     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1930             "( `Action`, `Condition`, `Sequence`) "
1931             "VALUES ( 'clean', 'cond4', 4)");
1932     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1933
1934     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1935             "( `Action`, `Condition`, `Sequence`) "
1936             "VALUES ( 'depends', 'cond1', 1)");
1937     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1938
1939     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1940             "( `Action`, `Condition`, `Sequence`) "
1941             "VALUES ( 'build', 'cond2', 2)");
1942     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1943
1944     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1945             "( `Action`, `Condition`, `Sequence`) "
1946             "VALUES ( 'build2', 'cond6', 6)");
1947     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1948
1949     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1950             "( `Action`, `Condition`, `Sequence`) "
1951             "VALUES ( 'build', 'cond3', 3)");
1952     ok(r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1953
1954     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1955             "( `Action`, `Type` ) "
1956             "VALUES ( 'build', 32)");
1957     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1958
1959     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1960             "( `Action`, `Type` ) "
1961             "VALUES ( 'depends', 64)");
1962     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1963
1964     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1965             "( `Action`, `Type` ) "
1966             "VALUES ( 'clean', 63)");
1967     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1968
1969     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1970             "( `Action`, `Type` ) "
1971             "VALUES ( 'build2', 34)");
1972     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1973     query = "Select IESTable.Condition from CATable, IESTable where "
1974             "CATable.Action = IESTable.Action and CATable.Type = 32";
1975     r = MsiDatabaseOpenViewA(hdb, query, &view);
1976     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1977
1978     r = MsiViewExecute(view, 0);
1979     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1980
1981     r = MsiViewFetch(view, &rec);
1982     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1983
1984     ok( check_record( rec, 1, "cond2"), "wrong condition\n");
1985
1986     MsiCloseHandle( rec );
1987     r = MsiViewFetch(view, &rec);
1988     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1989
1990     ok( check_record( rec, 1, "cond3"), "wrong condition\n");
1991
1992     MsiCloseHandle( rec );
1993     MsiViewClose(view);
1994     MsiCloseHandle(view);
1995
1996     MsiCloseHandle( hdb );
1997     DeleteFileA(msifile);
1998 }
1999
2000
2001 static void test_where(void)
2002 {
2003     MSIHANDLE hdb = 0, rec, view;
2004     LPCSTR query;
2005     UINT r;
2006     DWORD size;
2007     CHAR buf[MAX_PATH];
2008     UINT count;
2009
2010     hdb = create_db();
2011     ok( hdb, "failed to create db\n");
2012
2013     r = run_query( hdb, 0,
2014             "CREATE TABLE `Media` ("
2015             "`DiskId` SHORT NOT NULL, "
2016             "`LastSequence` LONG, "
2017             "`DiskPrompt` CHAR(64) LOCALIZABLE, "
2018             "`Cabinet` CHAR(255), "
2019             "`VolumeLabel` CHAR(32), "
2020             "`Source` CHAR(72) "
2021             "PRIMARY KEY `DiskId`)" );
2022     ok( r == S_OK, "cannot create Media table: %d\n", r );
2023
2024     r = run_query( hdb, 0, "INSERT INTO `Media` "
2025             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
2026             "VALUES ( 1, 0, '', 'zero.cab', '', '' )" );
2027     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
2028
2029     r = run_query( hdb, 0, "INSERT INTO `Media` "
2030             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
2031             "VALUES ( 2, 1, '', 'one.cab', '', '' )" );
2032     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
2033
2034     r = run_query( hdb, 0, "INSERT INTO `Media` "
2035             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
2036             "VALUES ( 3, 2, '', 'two.cab', '', '' )" );
2037     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
2038
2039     query = "SELECT * FROM `Media`";
2040     r = do_query(hdb, query, &rec);
2041     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
2042     ok( check_record( rec, 4, "zero.cab"), "wrong cabinet\n");
2043     MsiCloseHandle( rec );
2044
2045     query = "SELECT * FROM `Media` WHERE `LastSequence` >= 1";
2046     r = do_query(hdb, query, &rec);
2047     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
2048     ok( check_record( rec, 4, "one.cab"), "wrong cabinet\n");
2049
2050     r = MsiRecordGetInteger(rec, 1);
2051     ok( 2 == r, "field wrong\n");
2052     r = MsiRecordGetInteger(rec, 2);
2053     ok( 1 == r, "field wrong\n");
2054     MsiCloseHandle( rec );
2055
2056     query = "SELECT `DiskId` FROM `Media` WHERE `LastSequence` >= 1 AND DiskId >= 0";
2057     r = MsiDatabaseOpenViewA(hdb, query, &view);
2058     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2059
2060     r = MsiViewExecute(view, 0);
2061     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2062
2063     r = MsiViewFetch(view, &rec);
2064     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
2065
2066     count = MsiRecordGetFieldCount( rec );
2067     ok( count == 1, "Expected 1 record fields, got %d\n", count );
2068
2069     size = MAX_PATH;
2070     r = MsiRecordGetStringA( rec, 1, buf, &size );
2071     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2072     ok( !lstrcmpA( buf, "2" ), "For (row %d, column 1) expected '%d', got %s\n", 0, 2, buf );
2073     MsiCloseHandle( rec );
2074
2075     r = MsiViewFetch(view, &rec);
2076     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
2077
2078     size = MAX_PATH;
2079     r = MsiRecordGetStringA( rec, 1, buf, &size );
2080     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2081     ok( !lstrcmpA( buf, "3" ), "For (row %d, column 1) expected '%d', got %s\n", 1, 3, buf );
2082     MsiCloseHandle( rec );
2083
2084     r = MsiViewFetch(view, &rec);
2085     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2086
2087     MsiViewClose(view);
2088     MsiCloseHandle(view);
2089
2090     MsiCloseHandle( rec );
2091
2092     rec = 0;
2093     query = "SELECT * FROM `Media` WHERE `DiskPrompt` IS NULL";
2094     r = do_query(hdb, query, &rec);
2095     ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
2096     MsiCloseHandle( rec );
2097
2098     rec = 0;
2099     query = "SELECT * FROM `Media` WHERE `DiskPrompt` < 'Cabinet'";
2100     r = do_query(hdb, query, &rec);
2101     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %d\n", r );
2102     MsiCloseHandle( rec );
2103
2104     rec = 0;
2105     query = "SELECT * FROM `Media` WHERE `DiskPrompt` > 'Cabinet'";
2106     r = do_query(hdb, query, &rec);
2107     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %d\n", r );
2108     MsiCloseHandle( rec );
2109
2110     rec = 0;
2111     query = "SELECT * FROM `Media` WHERE `DiskPrompt` <> 'Cabinet'";
2112     r = do_query(hdb, query, &rec);
2113     ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
2114     MsiCloseHandle( rec );
2115
2116     rec = 0;
2117     query = "SELECT * FROM `Media` WHERE `DiskPrompt` = 'Cabinet'";
2118     r = do_query(hdb, query, &rec);
2119     ok( r == ERROR_NO_MORE_ITEMS, "query failed: %d\n", r );
2120     MsiCloseHandle( rec );
2121
2122     rec = MsiCreateRecord(1);
2123     MsiRecordSetStringA(rec, 1, "");
2124
2125     query = "SELECT * FROM `Media` WHERE `DiskPrompt` = ?";
2126     r = MsiDatabaseOpenViewA(hdb, query, &view);
2127     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2128     r = MsiViewExecute(view, rec);
2129     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2130
2131     MsiCloseHandle(rec);
2132
2133     r = MsiViewFetch(view, &rec);
2134     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2135
2136     MsiCloseHandle(rec);
2137     MsiViewClose(view);
2138     MsiCloseHandle(view);
2139
2140     MsiCloseHandle( hdb );
2141     DeleteFileA(msifile);
2142 }
2143
2144 static CHAR CURR_DIR[MAX_PATH];
2145
2146 static const CHAR test_data[] = "FirstPrimaryColumn\tSecondPrimaryColumn\tShortInt\tShortIntNullable\tLongInt\tLongIntNullable\tString\tLocalizableString\tLocalizableStringNullable\n"
2147                                 "s255\ti2\ti2\tI2\ti4\tI4\tS255\tS0\ts0\n"
2148                                 "TestTable\tFirstPrimaryColumn\n"
2149                                 "stringage\t5\t2\t\t2147483640\t-2147483640\tanother string\tlocalizable\tduh\n";
2150
2151 static const CHAR two_primary[] = "PrimaryOne\tPrimaryTwo\n"
2152                                   "s255\ts255\n"
2153                                   "TwoPrimary\tPrimaryOne\tPrimaryTwo\n"
2154                                   "papaya\tleaf\n"
2155                                   "papaya\tflower\n";
2156
2157 static const CHAR endlines1[] = "A\tB\tC\tD\tE\tF\r\n"
2158                                 "s72\ts72\ts72\ts72\ts72\ts72\n"
2159                                 "Table\tA\r\n"
2160                                 "a\tb\tc\td\te\tf\n"
2161                                 "g\th\ti\t\rj\tk\tl\r\n";
2162
2163 static const CHAR endlines2[] = "A\tB\tC\tD\tE\tF\r"
2164                                 "s72\ts72\ts72\ts72\ts72\ts72\n"
2165                                 "Table2\tA\r\n"
2166                                 "a\tb\tc\td\te\tf\n"
2167                                 "g\th\ti\tj\tk\tl\r\n";
2168
2169 static const CHAR suminfo[] = "PropertyId\tValue\n"
2170                               "i2\tl255\n"
2171                               "_SummaryInformation\tPropertyId\n"
2172                               "1\t1252\n"
2173                               "2\tInstaller Database\n"
2174                               "3\tInstaller description\n"
2175                               "4\tWineHQ\n"
2176                               "5\tInstaller\n"
2177                               "6\tInstaller comments\n"
2178                               "7\tIntel;1033,2057\n"
2179                               "9\t{12345678-1234-1234-1234-123456789012}\n"
2180                               "12\t2009/04/12 15:46:11\n"
2181                               "13\t2009/04/12 15:46:11\n"
2182                               "14\t200\n"
2183                               "15\t2\n"
2184                               "18\tVim\n"
2185                               "19\t2\n";
2186
2187 static void write_file(const CHAR *filename, const char *data, int data_size)
2188 {
2189     DWORD size;
2190
2191     HANDLE hf = CreateFileA(filename, GENERIC_WRITE, 0, NULL,
2192                             CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2193     WriteFile(hf, data, data_size, &size, NULL);
2194     CloseHandle(hf);
2195 }
2196
2197 static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
2198 {
2199     UINT r;
2200
2201     write_file("temp_file", table_data, (lstrlenA(table_data) - 1) * sizeof(char));
2202     r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
2203     DeleteFileA("temp_file");
2204
2205     return r;
2206 }
2207
2208 static void test_suminfo_import(void)
2209 {
2210     MSIHANDLE hdb, hsi, view = 0;
2211     LPCSTR query;
2212     UINT r, count, size, type;
2213     char str_value[50];
2214     INT int_value;
2215     FILETIME ft_value;
2216
2217     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
2218
2219     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
2220     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2221
2222     r = add_table_to_db(hdb, suminfo);
2223     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2224
2225     /* _SummaryInformation is not imported as a regular table... */
2226
2227     query = "SELECT * FROM `_SummaryInformation`";
2228     r = MsiDatabaseOpenViewA(hdb, query, &view);
2229     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %u\n", r);
2230     MsiCloseHandle(view);
2231
2232     /* ...its data is added to the special summary information stream */
2233
2234     r = MsiGetSummaryInformationA(hdb, NULL, 0, &hsi);
2235     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2236
2237     r = MsiSummaryInfoGetPropertyCount(hsi, &count);
2238     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2239     ok(count == 14, "Expected 14, got %u\n", count);
2240
2241     r = MsiSummaryInfoGetPropertyA(hsi, PID_CODEPAGE, &type, &int_value, NULL, NULL, NULL);
2242     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2243     ok(type ==  VT_I2, "Expected VT_I2, got %u\n", type);
2244     ok(int_value == 1252, "Expected 1252, got %d\n", int_value);
2245
2246     size = sizeof(str_value);
2247     r = MsiSummaryInfoGetPropertyA(hsi, PID_TITLE, &type, NULL, NULL, str_value, &size);
2248     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2249     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2250     ok(size == 18, "Expected 18, got %u\n", size);
2251     ok(!strcmp(str_value, "Installer Database"),
2252        "Expected \"Installer Database\", got %s\n", str_value);
2253
2254     size = sizeof(str_value);
2255     r = MsiSummaryInfoGetPropertyA(hsi, PID_SUBJECT, &type, NULL, NULL, str_value, &size);
2256     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2257     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2258     ok(!strcmp(str_value, "Installer description"),
2259        "Expected \"Installer description\", got %s\n", str_value);
2260
2261     size = sizeof(str_value);
2262     r = MsiSummaryInfoGetPropertyA(hsi, PID_AUTHOR, &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, "WineHQ"),
2266        "Expected \"WineHQ\", got %s\n", str_value);
2267
2268     size = sizeof(str_value);
2269     r = MsiSummaryInfoGetPropertyA(hsi, PID_KEYWORDS, &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, "Installer"),
2273        "Expected \"Installer\", got %s\n", str_value);
2274
2275     size = sizeof(str_value);
2276     r = MsiSummaryInfoGetPropertyA(hsi, PID_COMMENTS, &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 comments"),
2280        "Expected \"Installer comments\", got %s\n", str_value);
2281
2282     size = sizeof(str_value);
2283     r = MsiSummaryInfoGetPropertyA(hsi, PID_TEMPLATE, &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, "Intel;1033,2057"),
2287        "Expected \"Intel;1033,2057\", got %s\n", str_value);
2288
2289     size = sizeof(str_value);
2290     r = MsiSummaryInfoGetPropertyA(hsi, PID_REVNUMBER, &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, "{12345678-1234-1234-1234-123456789012}"),
2294        "Expected \"{12345678-1234-1234-1234-123456789012}\", got %s\n", str_value);
2295
2296     r = MsiSummaryInfoGetPropertyA(hsi, PID_CREATE_DTM, &type, NULL, &ft_value, NULL, NULL);
2297     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2298     ok(type == VT_FILETIME, "Expected VT_FILETIME, got %u\n", type);
2299
2300     r = MsiSummaryInfoGetPropertyA(hsi, PID_LASTSAVE_DTM, &type, NULL, &ft_value, NULL, NULL);
2301     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2302     ok(type == VT_FILETIME, "Expected VT_FILETIME, got %u\n", type);
2303
2304     r = MsiSummaryInfoGetPropertyA(hsi, PID_PAGECOUNT, &type, &int_value, NULL, NULL, NULL);
2305     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2306     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2307     ok(int_value == 200, "Expected 200, got %d\n", int_value);
2308
2309     r = MsiSummaryInfoGetPropertyA(hsi, PID_WORDCOUNT, &type, &int_value, NULL, NULL, NULL);
2310     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2311     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2312     ok(int_value == 2, "Expected 2, got %d\n", int_value);
2313
2314     r = MsiSummaryInfoGetPropertyA(hsi, PID_SECURITY, &type, &int_value, NULL, NULL, NULL);
2315     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2316     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2317     ok(int_value == 2, "Expected 2, got %d\n", int_value);
2318
2319     size = sizeof(str_value);
2320     r = MsiSummaryInfoGetPropertyA(hsi, PID_APPNAME, &type, NULL, NULL, str_value, &size);
2321     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2322     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2323     ok(!strcmp(str_value, "Vim"), "Expected \"Vim\", got %s\n", str_value);
2324
2325     MsiCloseHandle(hsi);
2326     MsiCloseHandle(hdb);
2327     DeleteFileA(msifile);
2328 }
2329
2330 static void test_msiimport(void)
2331 {
2332     MSIHANDLE hdb, view, rec;
2333     LPCSTR query;
2334     UINT r, count;
2335     signed int i;
2336
2337     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
2338
2339     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
2340     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2341
2342     r = add_table_to_db(hdb, test_data);
2343     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2344
2345     r = add_table_to_db(hdb, two_primary);
2346     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2347
2348     r = add_table_to_db(hdb, endlines1);
2349     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2350
2351     r = add_table_to_db(hdb, endlines2);
2352     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
2353
2354     query = "SELECT * FROM `TestTable`";
2355     r = MsiDatabaseOpenViewA(hdb, query, &view);
2356     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2357
2358     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2359     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2360     count = MsiRecordGetFieldCount(rec);
2361     ok(count == 9, "Expected 9, got %d\n", count);
2362     ok(check_record(rec, 1, "FirstPrimaryColumn"), "Expected FirstPrimaryColumn\n");
2363     ok(check_record(rec, 2, "SecondPrimaryColumn"), "Expected SecondPrimaryColumn\n");
2364     ok(check_record(rec, 3, "ShortInt"), "Expected ShortInt\n");
2365     ok(check_record(rec, 4, "ShortIntNullable"), "Expected ShortIntNullalble\n");
2366     ok(check_record(rec, 5, "LongInt"), "Expected LongInt\n");
2367     ok(check_record(rec, 6, "LongIntNullable"), "Expected LongIntNullalble\n");
2368     ok(check_record(rec, 7, "String"), "Expected String\n");
2369     ok(check_record(rec, 8, "LocalizableString"), "Expected LocalizableString\n");
2370     ok(check_record(rec, 9, "LocalizableStringNullable"), "Expected LocalizableStringNullable\n");
2371     MsiCloseHandle(rec);
2372
2373     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2374     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2375     count = MsiRecordGetFieldCount(rec);
2376     ok(count == 9, "Expected 9, got %d\n", count);
2377     ok(check_record(rec, 1, "s255"), "Expected s255\n");
2378     ok(check_record(rec, 2, "i2"), "Expected i2\n");
2379     ok(check_record(rec, 3, "i2"), "Expected i2\n");
2380     ok(check_record(rec, 4, "I2"), "Expected I2\n");
2381     ok(check_record(rec, 5, "i4"), "Expected i4\n");
2382     ok(check_record(rec, 6, "I4"), "Expected I4\n");
2383     ok(check_record(rec, 7, "S255"), "Expected S255\n");
2384     ok(check_record(rec, 8, "S0"), "Expected S0\n");
2385     ok(check_record(rec, 9, "s0"), "Expected s0\n");
2386     MsiCloseHandle(rec);
2387
2388     query = "SELECT * FROM `TestTable`";
2389     r = do_query(hdb, query, &rec);
2390     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2391     ok(check_record(rec, 1, "stringage"), "Expected 'stringage'\n");
2392     ok(check_record(rec, 7, "another string"), "Expected 'another string'\n");
2393     ok(check_record(rec, 8, "localizable"), "Expected 'localizable'\n");
2394     ok(check_record(rec, 9, "duh"), "Expected 'duh'\n");
2395
2396     i = MsiRecordGetInteger(rec, 2);
2397     ok(i == 5, "Expected 5, got %d\n", i);
2398
2399     i = MsiRecordGetInteger(rec, 3);
2400     ok(i == 2, "Expected 2, got %d\n", i);
2401
2402     i = MsiRecordGetInteger(rec, 4);
2403     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
2404
2405     i = MsiRecordGetInteger(rec, 5);
2406     ok(i == 2147483640, "Expected 2147483640, got %d\n", i);
2407
2408     i = MsiRecordGetInteger(rec, 6);
2409     ok(i == -2147483640, "Expected -2147483640, got %d\n", i);
2410
2411     MsiCloseHandle(rec);
2412     MsiViewClose(view);
2413     MsiCloseHandle(view);
2414
2415     query = "SELECT * FROM `TwoPrimary`";
2416     r = MsiDatabaseOpenViewA(hdb, query, &view);
2417     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2418
2419     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2420     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2421     count = MsiRecordGetFieldCount(rec);
2422     ok(count == 2, "Expected 2, got %d\n", count);
2423     ok(check_record(rec, 1, "PrimaryOne"), "Expected PrimaryOne\n");
2424     ok(check_record(rec, 2, "PrimaryTwo"), "Expected PrimaryTwo\n");
2425
2426     MsiCloseHandle(rec);
2427
2428     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2429     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2430     count = MsiRecordGetFieldCount(rec);
2431     ok(count == 2, "Expected 2, got %d\n", count);
2432     ok(check_record(rec, 1, "s255"), "Expected s255\n");
2433     ok(check_record(rec, 2, "s255"), "Expected s255\n");
2434     MsiCloseHandle(rec);
2435
2436     r = MsiViewExecute(view, 0);
2437     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2438
2439     r = MsiViewFetch(view, &rec);
2440     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2441
2442     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
2443     ok(check_record(rec, 2, "leaf"), "Expected 'leaf'\n");
2444
2445     MsiCloseHandle(rec);
2446
2447     r = MsiViewFetch(view, &rec);
2448     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2449
2450     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
2451     ok(check_record(rec, 2, "flower"), "Expected 'flower'\n");
2452
2453     MsiCloseHandle(rec);
2454
2455     r = MsiViewFetch(view, &rec);
2456     ok(r == ERROR_NO_MORE_ITEMS,
2457        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
2458
2459     r = MsiViewClose(view);
2460     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2461
2462     MsiCloseHandle(view);
2463
2464     query = "SELECT * FROM `Table`";
2465     r = MsiDatabaseOpenViewA(hdb, query, &view);
2466     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2467
2468     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2469     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2470     count = MsiRecordGetFieldCount(rec);
2471     ok(count == 6, "Expected 6, got %d\n", count);
2472     ok(check_record(rec, 1, "A"), "Expected A\n");
2473     ok(check_record(rec, 2, "B"), "Expected B\n");
2474     ok(check_record(rec, 3, "C"), "Expected C\n");
2475     ok(check_record(rec, 4, "D"), "Expected D\n");
2476     ok(check_record(rec, 5, "E"), "Expected E\n");
2477     ok(check_record(rec, 6, "F"), "Expected F\n");
2478     MsiCloseHandle(rec);
2479
2480     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2481     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2482     count = MsiRecordGetFieldCount(rec);
2483     ok(count == 6, "Expected 6, got %d\n", count);
2484     ok(check_record(rec, 1, "s72"), "Expected s72\n");
2485     ok(check_record(rec, 2, "s72"), "Expected s72\n");
2486     ok(check_record(rec, 3, "s72"), "Expected s72\n");
2487     ok(check_record(rec, 4, "s72"), "Expected s72\n");
2488     ok(check_record(rec, 5, "s72"), "Expected s72\n");
2489     ok(check_record(rec, 6, "s72"), "Expected s72\n");
2490     MsiCloseHandle(rec);
2491
2492     MsiViewClose(view);
2493     MsiCloseHandle(view);
2494
2495     query = "SELECT * FROM `Table`";
2496     r = MsiDatabaseOpenViewA(hdb, query, &view);
2497     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2498
2499     r = MsiViewExecute(view, 0);
2500     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2501
2502     r = MsiViewFetch(view, &rec);
2503     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2504     ok(check_record(rec, 1, "a"), "Expected 'a'\n");
2505     ok(check_record(rec, 2, "b"), "Expected 'b'\n");
2506     ok(check_record(rec, 3, "c"), "Expected 'c'\n");
2507     ok(check_record(rec, 4, "d"), "Expected 'd'\n");
2508     ok(check_record(rec, 5, "e"), "Expected 'e'\n");
2509     ok(check_record(rec, 6, "f"), "Expected 'f'\n");
2510
2511     MsiCloseHandle(rec);
2512
2513     r = MsiViewFetch(view, &rec);
2514     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2515     ok(check_record(rec, 1, "g"), "Expected 'g'\n");
2516     ok(check_record(rec, 2, "h"), "Expected 'h'\n");
2517     ok(check_record(rec, 3, "i"), "Expected 'i'\n");
2518     ok(check_record(rec, 4, "j"), "Expected 'j'\n");
2519     ok(check_record(rec, 5, "k"), "Expected 'k'\n");
2520     ok(check_record(rec, 6, "l"), "Expected 'l'\n");
2521
2522     MsiCloseHandle(rec);
2523
2524     r = MsiViewFetch(view, &rec);
2525     ok(r == ERROR_NO_MORE_ITEMS,
2526        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
2527
2528     MsiViewClose(view);
2529     MsiCloseHandle(view);
2530     MsiCloseHandle(hdb);
2531     DeleteFileA(msifile);
2532 }
2533
2534 static const CHAR bin_import_dat[] = "Name\tData\r\n"
2535                                      "s72\tV0\r\n"
2536                                      "Binary\tName\r\n"
2537                                      "filename1\tfilename1.ibd\r\n";
2538
2539 static void test_binary_import(void)
2540 {
2541     MSIHANDLE hdb = 0, rec;
2542     char file[MAX_PATH];
2543     char buf[MAX_PATH];
2544     char path[MAX_PATH];
2545     DWORD size;
2546     LPCSTR query;
2547     UINT r;
2548
2549     /* create files to import */
2550     write_file("bin_import.idt", bin_import_dat,
2551           (sizeof(bin_import_dat) - 1) * sizeof(char));
2552     CreateDirectoryA("bin_import", NULL);
2553     create_file_data("bin_import/filename1.ibd", "just some words", 15);
2554
2555     /* import files into database */
2556     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
2557     ok( r == ERROR_SUCCESS , "Failed to open database\n");
2558
2559     GetCurrentDirectoryA(MAX_PATH, path);
2560     r = MsiDatabaseImportA(hdb, path, "bin_import.idt");
2561     ok(r == ERROR_SUCCESS , "Failed to import Binary table\n");
2562
2563     /* read file from the Binary table */
2564     query = "SELECT * FROM `Binary`";
2565     r = do_query(hdb, query, &rec);
2566     ok(r == ERROR_SUCCESS, "SELECT query failed: %d\n", r);
2567
2568     size = MAX_PATH;
2569     r = MsiRecordGetStringA(rec, 1, file, &size);
2570     ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
2571     ok(!lstrcmpA(file, "filename1"), "Expected 'filename1', got %s\n", file);
2572
2573     size = MAX_PATH;
2574     memset(buf, 0, MAX_PATH);
2575     r = MsiRecordReadStream(rec, 2, buf, &size);
2576     ok(r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
2577     ok(!lstrcmpA(buf, "just some words"), "Expected 'just some words', got %s\n", buf);
2578
2579     r = MsiCloseHandle(rec);
2580     ok(r == ERROR_SUCCESS , "Failed to close record handle\n");
2581
2582     r = MsiCloseHandle(hdb);
2583     ok(r == ERROR_SUCCESS , "Failed to close database\n");
2584
2585     DeleteFileA("bin_import/filename1.ibd");
2586     RemoveDirectoryA("bin_import");
2587     DeleteFileA("bin_import.idt");
2588 }
2589
2590 static void test_markers(void)
2591 {
2592     MSIHANDLE hdb, rec;
2593     LPCSTR query;
2594     UINT r;
2595
2596     hdb = create_db();
2597     ok( hdb, "failed to create db\n");
2598
2599     rec = MsiCreateRecord(3);
2600     MsiRecordSetStringA(rec, 1, "Table");
2601     MsiRecordSetStringA(rec, 2, "Apples");
2602     MsiRecordSetStringA(rec, 3, "Oranges");
2603
2604     /* try a legit create */
2605     query = "CREATE TABLE `Table` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2606     r = run_query(hdb, 0, query);
2607     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2608     MsiCloseHandle(rec);
2609
2610     /* try table name as marker */
2611     rec = MsiCreateRecord(1);
2612     MsiRecordSetStringA(rec, 1, "Fable");
2613     query = "CREATE TABLE `?` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2614     r = run_query(hdb, rec, query);
2615     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2616
2617     /* verify that we just created a table called '?', not 'Fable' */
2618     r = try_query(hdb, "SELECT * from `Fable`");
2619     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2620
2621     r = try_query(hdb, "SELECT * from `?`");
2622     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2623
2624     /* try table name as marker without backticks */
2625     MsiRecordSetStringA(rec, 1, "Mable");
2626     query = "CREATE TABLE ? ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2627     r = run_query(hdb, rec, query);
2628     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2629
2630     /* try one column name as marker */
2631     MsiRecordSetStringA(rec, 1, "One");
2632     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2633     r = run_query(hdb, rec, query);
2634     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2635     MsiCloseHandle(rec);
2636
2637     /* try column names as markers */
2638     rec = MsiCreateRecord(2);
2639     MsiRecordSetStringA(rec, 1, "One");
2640     MsiRecordSetStringA(rec, 2, "Two");
2641     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `One`)";
2642     r = run_query(hdb, rec, query);
2643     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2644     MsiCloseHandle(rec);
2645
2646     /* try names with backticks */
2647     rec = MsiCreateRecord(3);
2648     MsiRecordSetStringA(rec, 1, "One");
2649     MsiRecordSetStringA(rec, 2, "Two");
2650     MsiRecordSetStringA(rec, 3, "One");
2651     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
2652     r = run_query(hdb, rec, query);
2653     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2654
2655     /* try names with backticks, minus definitions */
2656     query = "CREATE TABLE `Mable` ( `?`, `?` PRIMARY KEY `?`)";
2657     r = run_query(hdb, rec, query);
2658     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2659
2660     /* try names without backticks */
2661     query = "CREATE TABLE `Mable` ( ? SHORT NOT NULL, ? CHAR(255) PRIMARY KEY ?)";
2662     r = run_query(hdb, rec, query);
2663     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2664     MsiCloseHandle(rec);
2665
2666     /* try one long marker */
2667     rec = MsiCreateRecord(1);
2668     MsiRecordSetStringA(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
2669     query = "CREATE TABLE `Mable` ( ? )";
2670     r = run_query(hdb, rec, query);
2671     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2672     MsiCloseHandle(rec);
2673
2674     /* try all names as markers */
2675     rec = MsiCreateRecord(4);
2676     MsiRecordSetStringA(rec, 1, "Mable");
2677     MsiRecordSetStringA(rec, 2, "One");
2678     MsiRecordSetStringA(rec, 3, "Two");
2679     MsiRecordSetStringA(rec, 4, "One");
2680     query = "CREATE TABLE `?` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
2681     r = run_query(hdb, rec, query);
2682     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2683     MsiCloseHandle(rec);
2684
2685     /* try a legit insert */
2686     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( 5, 'hello' )";
2687     r = run_query(hdb, 0, query);
2688     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2689
2690     r = try_query(hdb, "SELECT * from `Table`");
2691     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2692
2693     /* try values as markers */
2694     rec = MsiCreateRecord(2);
2695     MsiRecordSetInteger(rec, 1, 4);
2696     MsiRecordSetStringA(rec, 2, "hi");
2697     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
2698     r = run_query(hdb, rec, query);
2699     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2700     MsiCloseHandle(rec);
2701
2702     /* try column names and values as markers */
2703     rec = MsiCreateRecord(4);
2704     MsiRecordSetStringA(rec, 1, "One");
2705     MsiRecordSetStringA(rec, 2, "Two");
2706     MsiRecordSetInteger(rec, 3, 5);
2707     MsiRecordSetStringA(rec, 4, "hi");
2708     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( ?, '?' )";
2709     r = run_query(hdb, rec, query);
2710     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2711     MsiCloseHandle(rec);
2712
2713     /* try column names as markers */
2714     rec = MsiCreateRecord(2);
2715     MsiRecordSetStringA(rec, 1, "One");
2716     MsiRecordSetStringA(rec, 2, "Two");
2717     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( 3, 'yellow' )";
2718     r = run_query(hdb, rec, query);
2719     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2720     MsiCloseHandle(rec);
2721
2722     /* try table name as a marker */
2723     rec = MsiCreateRecord(1);
2724     MsiRecordSetStringA(rec, 1, "Table");
2725     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( 2, 'green' )";
2726     r = run_query(hdb, rec, query);
2727     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2728     MsiCloseHandle(rec);
2729
2730     /* try table name and values as markers */
2731     rec = MsiCreateRecord(3);
2732     MsiRecordSetStringA(rec, 1, "Table");
2733     MsiRecordSetInteger(rec, 2, 10);
2734     MsiRecordSetStringA(rec, 3, "haha");
2735     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
2736     r = run_query(hdb, rec, query);
2737     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
2738     MsiCloseHandle(rec);
2739
2740     /* try all markers */
2741     rec = MsiCreateRecord(5);
2742     MsiRecordSetStringA(rec, 1, "Table");
2743     MsiRecordSetStringA(rec, 1, "One");
2744     MsiRecordSetStringA(rec, 1, "Two");
2745     MsiRecordSetInteger(rec, 2, 10);
2746     MsiRecordSetStringA(rec, 3, "haha");
2747     query = "INSERT INTO `?` ( `?`, `?` ) VALUES ( ?, '?' )";
2748     r = run_query(hdb, rec, query);
2749     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2750     MsiCloseHandle(rec);
2751
2752     /* insert an integer as a string */
2753     rec = MsiCreateRecord(2);
2754     MsiRecordSetStringA(rec, 1, "11");
2755     MsiRecordSetStringA(rec, 2, "hi");
2756     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
2757     r = run_query(hdb, rec, query);
2758     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2759     MsiCloseHandle(rec);
2760
2761     /* leave off the '' for the string */
2762     rec = MsiCreateRecord(2);
2763     MsiRecordSetInteger(rec, 1, 12);
2764     MsiRecordSetStringA(rec, 2, "hi");
2765     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, ? )";
2766     r = run_query(hdb, rec, query);
2767     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2768     MsiCloseHandle(rec);
2769
2770     MsiCloseHandle(hdb);
2771     DeleteFileA(msifile);
2772 }
2773
2774 #define MY_NVIEWS 4000    /* Largest installer I've seen uses < 2000 */
2775 static void test_handle_limit(void)
2776 {
2777     int i;
2778     MSIHANDLE hdb;
2779     MSIHANDLE hviews[MY_NVIEWS];
2780     UINT r;
2781
2782     /* create an empty db */
2783     hdb = create_db();
2784     ok( hdb, "failed to create db\n");
2785
2786     memset(hviews, 0, sizeof(hviews));
2787
2788     for (i=0; i<MY_NVIEWS; i++) {
2789         static char szQueryBuf[256] = "SELECT * from `_Tables`";
2790         hviews[i] = 0xdeadbeeb;
2791         r = MsiDatabaseOpenViewA(hdb, szQueryBuf, &hviews[i]);
2792         if( r != ERROR_SUCCESS || hviews[i] == 0xdeadbeeb ||
2793             hviews[i] == 0 || (i && (hviews[i] == hviews[i-1])))
2794             break;
2795     }
2796
2797     ok( i == MY_NVIEWS, "problem opening views\n");
2798
2799     for (i=0; i<MY_NVIEWS; i++) {
2800         if (hviews[i] != 0 && hviews[i] != 0xdeadbeeb) {
2801             MsiViewClose(hviews[i]);
2802             r = MsiCloseHandle(hviews[i]);
2803             if (r != ERROR_SUCCESS)
2804                 break;
2805         }
2806     }
2807
2808     ok( i == MY_NVIEWS, "problem closing views\n");
2809
2810     r = MsiCloseHandle(hdb);
2811     ok( r == ERROR_SUCCESS, "failed to close database\n");
2812 }
2813
2814 static void generate_transform(void)
2815 {
2816     MSIHANDLE hdb1, hdb2, hrec;
2817     LPCSTR query;
2818     UINT r;
2819
2820     /* start with two identical databases */
2821     CopyFileA(msifile2, msifile, FALSE);
2822
2823     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb1 );
2824     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2825
2826     r = MsiDatabaseCommit( hdb1 );
2827     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
2828
2829     r = MsiOpenDatabaseW(msifile2W, MSIDBOPEN_READONLY, &hdb2 );
2830     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2831
2832     /* the transform between two identical database should be empty */
2833     r = MsiDatabaseGenerateTransformA(hdb1, hdb2, NULL, 0, 0);
2834     todo_wine {
2835     ok( r == ERROR_NO_DATA, "return code %d, should be ERROR_NO_DATA\n", r );
2836     }
2837
2838     query = "CREATE TABLE `AAR` ( `BAR` SHORT NOT NULL, `CAR` CHAR(255) PRIMARY KEY `CAR`)";
2839     r = run_query(hdb1, 0, query);
2840     ok(r == ERROR_SUCCESS, "failed to add table\n");
2841
2842     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 1, 'vw' )";
2843     r = run_query(hdb1, 0, query);
2844     ok(r == ERROR_SUCCESS, "failed to add row 1\n");
2845
2846     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 2, 'bmw' )";
2847     r = run_query(hdb1, 0, query);
2848     ok(r == ERROR_SUCCESS, "failed to add row 2\n");
2849
2850     query = "UPDATE `MOO` SET `OOO` = 'c' WHERE `NOO` = 1";
2851     r = run_query(hdb1, 0, query);
2852     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2853
2854     query = "DELETE FROM `MOO` WHERE `NOO` = 3";
2855     r = run_query(hdb1, 0, query);
2856     ok(r == ERROR_SUCCESS, "failed to delete row\n");
2857
2858     hrec = MsiCreateRecord(2);
2859     r = MsiRecordSetInteger(hrec, 1, 1);
2860     ok(r == ERROR_SUCCESS, "failed to set integer\n");
2861
2862     write_file("testdata.bin", "naengmyon", 9);
2863     r = MsiRecordSetStreamA(hrec, 2, "testdata.bin");
2864     ok(r == ERROR_SUCCESS, "failed to set stream\n");
2865
2866     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
2867     r = run_query(hdb1, hrec, query);
2868     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
2869
2870     MsiCloseHandle(hrec);
2871
2872     query = "ALTER TABLE `MOO` ADD `COW` INTEGER";
2873     r = run_query(hdb1, 0, query);
2874     ok(r == ERROR_SUCCESS, "failed to add column\n");
2875
2876     query = "ALTER TABLE `MOO` ADD `PIG` INTEGER";
2877     r = run_query(hdb1, 0, query);
2878     ok(r == ERROR_SUCCESS, "failed to add column\n");
2879
2880     query = "UPDATE `MOO` SET `PIG` = 5 WHERE `NOO` = 1";
2881     r = run_query(hdb1, 0, query);
2882     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2883
2884     query = "CREATE TABLE `Property` ( `Property` CHAR(72) NOT NULL, "
2885             "`Value` CHAR(0) PRIMARY KEY `Property`)";
2886     r = run_query(hdb1, 0, query);
2887     ok(r == ERROR_SUCCESS, "failed to add property table\n");
2888
2889     query = "INSERT INTO `Property` ( `Property`, `Value` ) VALUES ( 'prop', 'val' )";
2890     r = run_query(hdb1, 0, query);
2891     ok(r == ERROR_SUCCESS, "failed to add property\n");
2892
2893     /* database needs to be committed */
2894     MsiDatabaseCommit(hdb1);
2895
2896     r = MsiDatabaseGenerateTransformA(hdb1, hdb2, mstfile, 0, 0);
2897     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
2898
2899     MsiCloseHandle( hdb1 );
2900     MsiCloseHandle( hdb2 );
2901
2902     DeleteFileA("testdata.bin");
2903 }
2904
2905 /* data for generating a transform */
2906
2907 /* tables transform names - encoded as they would be in an msi database file */
2908 static const WCHAR name1[] = { 0x4840, 0x3a8a, 0x481b, 0 }; /* AAR */
2909 static const WCHAR name2[] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }; /* _Columns */
2910 static const WCHAR name3[] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }; /* _Tables */
2911 static const WCHAR name4[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }; /* _StringData */
2912 static const WCHAR name5[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }; /* _StringPool */
2913 static const WCHAR name6[] = { 0x4840, 0x3e16, 0x4818, 0}; /* MOO */
2914 static const WCHAR name7[] = { 0x4840, 0x3c8b, 0x3a97, 0x409b, 0 }; /* BINARY */
2915 static const WCHAR name8[] = { 0x3c8b, 0x3a97, 0x409b, 0x387e, 0 }; /* BINARY.1 */
2916 static const WCHAR name9[] = { 0x4840, 0x4559, 0x44f2, 0x4568, 0x4737, 0 }; /* Property */
2917
2918 /* data in each table */
2919 static const WCHAR data1[] = { /* AAR */
2920     0x0201, 0x0008, 0x8001,  /* 0x0201 = add row (1), two shorts */
2921     0x0201, 0x0009, 0x8002,
2922 };
2923 static const WCHAR data2[] = { /* _Columns */
2924     0x0401, 0x0001, 0x8003, 0x0002, 0x9502,
2925     0x0401, 0x0001, 0x8004, 0x0003, 0x9502,
2926     0x0401, 0x0005, 0x0000, 0x0006, 0xbdff,  /* 0x0401 = add row (1), 4 shorts */
2927     0x0401, 0x0005, 0x0000, 0x0007, 0x8502,
2928     0x0401, 0x000a, 0x0000, 0x000a, 0xad48,
2929     0x0401, 0x000a, 0x0000, 0x000b, 0x9d00,
2930 };
2931 static const WCHAR data3[] = { /* _Tables */
2932     0x0101, 0x0005, /* 0x0101 = add row (1), 1 short */
2933     0x0101, 0x000a,
2934 };
2935 static const char data4[] = /* _StringData */
2936     "MOOCOWPIGcAARCARBARvwbmwPropertyValuepropval";  /* all the strings squashed together */
2937 static const WCHAR data5[] = { /* _StringPool */
2938 /*  len, refs */
2939     0,   0,    /* string 0 ''    */
2940     3,   2,    /* string 1 'MOO' */
2941     3,   1,    /* string 2 'COW' */
2942     3,   1,    /* string 3 'PIG' */
2943     1,   1,    /* string 4 'c'   */
2944     3,   3,    /* string 5 'AAR' */
2945     3,   1,    /* string 6 'CAR' */
2946     3,   1,    /* string 7 'BAR' */
2947     2,   1,    /* string 8 'vw'  */
2948     3,   1,    /* string 9 'bmw' */
2949     8,   4,    /* string 10 'Property' */
2950     5,   1,    /* string 11 'Value' */
2951     4,   1,    /* string 12 'prop' */
2952     3,   1,    /* string 13 'val' */
2953 };
2954 /* update row, 0x0002 is a bitmask of present column data, keys are excluded */
2955 static const WCHAR data6[] = { /* MOO */
2956     0x000a, 0x8001, 0x0004, 0x8005, /* update row */
2957     0x0000, 0x8003,         /* delete row */
2958 };
2959
2960 static const WCHAR data7[] = { /* BINARY */
2961     0x0201, 0x8001, 0x0001,
2962 };
2963
2964 static const char data8[] =  /* stream data for the BINARY table */
2965     "naengmyon";
2966
2967 static const WCHAR data9[] = { /* Property */
2968     0x0201, 0x000c, 0x000d,
2969 };
2970
2971 static const struct {
2972     LPCWSTR name;
2973     const void *data;
2974     DWORD size;
2975 } table_transform_data[] =
2976 {
2977     { name1, data1, sizeof data1 },
2978     { name2, data2, sizeof data2 },
2979     { name3, data3, sizeof data3 },
2980     { name4, data4, sizeof data4 - 1 },
2981     { name5, data5, sizeof data5 },
2982     { name6, data6, sizeof data6 },
2983     { name7, data7, sizeof data7 },
2984     { name8, data8, sizeof data8 - 1 },
2985     { name9, data9, sizeof data9 },
2986 };
2987
2988 #define NUM_TRANSFORM_TABLES (sizeof table_transform_data/sizeof table_transform_data[0])
2989
2990 static void generate_transform_manual(void)
2991 {
2992     IStorage *stg = NULL;
2993     IStream *stm;
2994     WCHAR name[0x20];
2995     HRESULT r;
2996     DWORD i, count;
2997     const DWORD mode = STGM_CREATE|STGM_READWRITE|STGM_DIRECT|STGM_SHARE_EXCLUSIVE;
2998
2999     const CLSID CLSID_MsiTransform = { 0xc1082,0,0,{0xc0,0,0,0,0,0,0,0x46}};
3000
3001     MultiByteToWideChar(CP_ACP, 0, mstfile, -1, name, 0x20);
3002
3003     r = StgCreateDocfile(name, mode, 0, &stg);
3004     ok(r == S_OK, "failed to create storage\n");
3005     if (!stg)
3006         return;
3007
3008     r = IStorage_SetClass( stg, &CLSID_MsiTransform );
3009     ok(r == S_OK, "failed to set storage type\n");
3010
3011     for (i=0; i<NUM_TRANSFORM_TABLES; i++)
3012     {
3013         r = IStorage_CreateStream( stg, table_transform_data[i].name,
3014                             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
3015         if (FAILED(r))
3016         {
3017             ok(0, "failed to create stream %08x\n", r);
3018             continue;
3019         }
3020
3021         r = IStream_Write( stm, table_transform_data[i].data,
3022                           table_transform_data[i].size, &count );
3023         if (FAILED(r) || count != table_transform_data[i].size)
3024             ok(0, "failed to write stream\n");
3025         IStream_Release(stm);
3026     }
3027
3028     IStorage_Release(stg);
3029 }
3030
3031 static UINT set_summary_info(MSIHANDLE hdb)
3032 {
3033     UINT res;
3034     MSIHANDLE suminfo;
3035
3036     /* build summary info */
3037     res = MsiGetSummaryInformationA(hdb, NULL, 7, &suminfo);
3038     ok( res == ERROR_SUCCESS , "Failed to open summaryinfo\n" );
3039
3040     res = MsiSummaryInfoSetPropertyA(suminfo,2, VT_LPSTR, 0,NULL,
3041                         "Installation Database");
3042     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3043
3044     res = MsiSummaryInfoSetPropertyA(suminfo,3, VT_LPSTR, 0,NULL,
3045                         "Installation Database");
3046     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3047
3048     res = MsiSummaryInfoSetPropertyA(suminfo,4, VT_LPSTR, 0,NULL,
3049                         "Wine Hackers");
3050     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3051
3052     res = MsiSummaryInfoSetPropertyA(suminfo,7, VT_LPSTR, 0,NULL,
3053                     ";1033,2057");
3054     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3055
3056     res = MsiSummaryInfoSetPropertyA(suminfo,9, VT_LPSTR, 0,NULL,
3057                     "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}");
3058     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3059
3060     res = MsiSummaryInfoSetPropertyA(suminfo, 14, VT_I4, 100, NULL, NULL);
3061     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3062
3063     res = MsiSummaryInfoSetPropertyA(suminfo, 15, VT_I4, 0, NULL, NULL);
3064     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3065
3066     res = MsiSummaryInfoPersist(suminfo);
3067     ok( res == ERROR_SUCCESS , "Failed to make summary info persist\n" );
3068
3069     res = MsiCloseHandle( suminfo);
3070     ok( res == ERROR_SUCCESS , "Failed to close suminfo\n" );
3071
3072     return res;
3073 }
3074
3075 static MSIHANDLE create_package_db(const WCHAR *filename)
3076 {
3077     MSIHANDLE hdb = 0;
3078     UINT res;
3079
3080     DeleteFileW(msifileW);
3081
3082     /* create an empty database */
3083     res = MsiOpenDatabaseW(filename, MSIDBOPEN_CREATE, &hdb );
3084     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
3085     if( res != ERROR_SUCCESS )
3086         return hdb;
3087
3088     res = MsiDatabaseCommit( hdb );
3089     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
3090
3091     res = set_summary_info(hdb);
3092     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3093
3094     res = create_directory_table(hdb);
3095     ok( res == ERROR_SUCCESS , "Failed to create directory table\n" );
3096
3097     return hdb;
3098 }
3099
3100 static UINT package_from_db(MSIHANDLE hdb, MSIHANDLE *handle)
3101 {
3102     UINT res;
3103     CHAR szPackage[12];
3104     MSIHANDLE hPackage;
3105
3106     sprintf(szPackage, "#%u", hdb);
3107     res = MsiOpenPackageA(szPackage, &hPackage);
3108     if (res != ERROR_SUCCESS)
3109         return res;
3110
3111     res = MsiCloseHandle(hdb);
3112     if (res != ERROR_SUCCESS)
3113     {
3114         MsiCloseHandle(hPackage);
3115         return res;
3116     }
3117
3118     *handle = hPackage;
3119     return ERROR_SUCCESS;
3120 }
3121
3122 static void test_try_transform(void)
3123 {
3124     MSIHANDLE hdb, hview, hrec, hpkg = 0;
3125     LPCSTR query;
3126     UINT r;
3127     DWORD sz;
3128     char buffer[MAX_PATH];
3129
3130     DeleteFileA(msifile);
3131     DeleteFileA(mstfile);
3132
3133     /* create the database */
3134     hdb = create_package_db(msifileW);
3135     ok(hdb, "Failed to create package db\n");
3136
3137     query = "CREATE TABLE `MOO` ( `NOO` SHORT NOT NULL, `OOO` CHAR(255) PRIMARY KEY `NOO`)";
3138     r = run_query(hdb, 0, query);
3139     ok(r == ERROR_SUCCESS, "failed to add table\n");
3140
3141     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 1, 'a' )";
3142     r = run_query(hdb, 0, query);
3143     ok(r == ERROR_SUCCESS, "failed to add row\n");
3144
3145     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 2, 'b' )";
3146     r = run_query(hdb, 0, query);
3147     ok(r == ERROR_SUCCESS, "failed to add row\n");
3148
3149     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 3, 'c' )";
3150     r = run_query(hdb, 0, query);
3151     ok(r == ERROR_SUCCESS, "failed to add row\n");
3152
3153     query = "CREATE TABLE `BINARY` ( `ID` SHORT NOT NULL, `BLOB` OBJECT PRIMARY KEY `ID`)";
3154     r = run_query(hdb, 0, query);
3155     ok(r == ERROR_SUCCESS, "failed to add table\n");
3156
3157     hrec = MsiCreateRecord(2);
3158     r = MsiRecordSetInteger(hrec, 1, 2);
3159     ok(r == ERROR_SUCCESS, "failed to set integer\n");
3160
3161     write_file("testdata.bin", "lamyon", 6);
3162     r = MsiRecordSetStreamA(hrec, 2, "testdata.bin");
3163     ok(r == ERROR_SUCCESS, "failed to set stream\n");
3164
3165     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
3166     r = run_query(hdb, hrec, query);
3167     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
3168
3169     MsiCloseHandle(hrec);
3170
3171     r = MsiDatabaseCommit( hdb );
3172     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
3173
3174     MsiCloseHandle( hdb );
3175     DeleteFileA("testdata.bin");
3176
3177     /*
3178      * Both these generate an equivalent transform,
3179      *  but the first doesn't work in Wine yet
3180      *  because MsiDatabaseGenerateTransform is unimplemented.
3181      */
3182     if (0)
3183         generate_transform();
3184     else
3185         generate_transform_manual();
3186
3187     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_DIRECT, &hdb );
3188     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
3189
3190     r = MsiDatabaseApplyTransformA( hdb, mstfile, 0 );
3191     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
3192
3193     r = MsiDatabaseCommit( hdb );
3194     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
3195
3196     /* check new values */
3197     hrec = 0;
3198     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 1 AND `CAR` = 'vw'";
3199     r = do_query(hdb, query, &hrec);
3200     ok(r == ERROR_SUCCESS, "select query failed\n");
3201     MsiCloseHandle(hrec);
3202
3203     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 2 AND `CAR` = 'bmw'";
3204     hrec = 0;
3205     r = do_query(hdb, query, &hrec);
3206     ok(r == ERROR_SUCCESS, "select query failed\n");
3207     MsiCloseHandle(hrec);
3208
3209     /* check updated values */
3210     hrec = 0;
3211     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 1 AND `OOO` = 'c'";
3212     r = do_query(hdb, query, &hrec);
3213     ok(r == ERROR_SUCCESS, "select query failed\n");
3214     MsiCloseHandle(hrec);
3215
3216     /* check unchanged value */
3217     hrec = 0;
3218     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 2 AND `OOO` = 'b'";
3219     r = do_query(hdb, query, &hrec);
3220     ok(r == ERROR_SUCCESS, "select query failed\n");
3221     MsiCloseHandle(hrec);
3222
3223     /* check deleted value */
3224     hrec = 0;
3225     query = "select * from `MOO` where `NOO` = 3";
3226     r = do_query(hdb, query, &hrec);
3227     ok(r == ERROR_NO_MORE_ITEMS, "select query failed\n");
3228     if (hrec) MsiCloseHandle(hrec);
3229
3230     /* check added stream */
3231     hrec = 0;
3232     query = "select `BLOB` from `BINARY` where `ID` = 1";
3233     r = do_query(hdb, query, &hrec);
3234     ok(r == ERROR_SUCCESS, "select query failed\n");
3235
3236     /* check the contents of the stream */
3237     sz = sizeof buffer;
3238     r = MsiRecordReadStream( hrec, 1, buffer, &sz );
3239     ok(r == ERROR_SUCCESS, "read stream failed\n");
3240     ok(!memcmp(buffer, "naengmyon", 9), "stream data was wrong\n");
3241     ok(sz == 9, "stream data was wrong size\n");
3242     if (hrec) MsiCloseHandle(hrec);
3243
3244     /* check the validity of the table with a deleted row */
3245     hrec = 0;
3246     query = "select * from `MOO`";
3247     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3248     ok(r == ERROR_SUCCESS, "open view failed\n");
3249
3250     r = MsiViewExecute(hview, 0);
3251     ok(r == ERROR_SUCCESS, "view execute failed\n");
3252
3253     r = MsiViewFetch(hview, &hrec);
3254     ok(r == ERROR_SUCCESS, "view fetch failed\n");
3255
3256     r = MsiRecordGetInteger(hrec, 1);
3257     ok(r == 1, "Expected 1, got %d\n", r);
3258
3259     sz = sizeof buffer;
3260     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
3261     ok(r == ERROR_SUCCESS, "record get string failed\n");
3262     ok(!lstrcmpA(buffer, "c"), "Expected c, got %s\n", buffer);
3263
3264     r = MsiRecordGetInteger(hrec, 3);
3265     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3266
3267     r = MsiRecordGetInteger(hrec, 4);
3268     ok(r == 5, "Expected 5, got %d\n", r);
3269
3270     MsiCloseHandle(hrec);
3271
3272     r = MsiViewFetch(hview, &hrec);
3273     ok(r == ERROR_SUCCESS, "view fetch failed\n");
3274
3275     r = MsiRecordGetInteger(hrec, 1);
3276     ok(r == 2, "Expected 2, got %d\n", r);
3277
3278     sz = sizeof buffer;
3279     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
3280     ok(r == ERROR_SUCCESS, "record get string failed\n");
3281     ok(!lstrcmpA(buffer, "b"), "Expected b, got %s\n", buffer);
3282
3283     r = MsiRecordGetInteger(hrec, 3);
3284     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3285
3286     r = MsiRecordGetInteger(hrec, 4);
3287     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3288
3289     MsiCloseHandle(hrec);
3290
3291     r = MsiViewFetch(hview, &hrec);
3292     ok(r == ERROR_NO_MORE_ITEMS, "view fetch succeeded\n");
3293
3294     MsiCloseHandle(hrec);
3295     MsiViewClose(hview);
3296     MsiCloseHandle(hview);
3297
3298     /* check that the property was added */
3299     r = package_from_db(hdb, &hpkg);
3300     if (r == ERROR_INSTALL_PACKAGE_REJECTED)
3301     {
3302         skip("Not enough rights to perform tests\n");
3303         goto error;
3304     }
3305     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
3306
3307     sz = MAX_PATH;
3308     r = MsiGetPropertyA(hpkg, "prop", buffer, &sz);
3309     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3310     ok(!lstrcmpA(buffer, "val"), "Expected val, got %s\n", buffer);
3311
3312     MsiCloseHandle(hpkg);
3313
3314 error:
3315     MsiCloseHandle(hdb);
3316     DeleteFileA(msifile);
3317     DeleteFileA(mstfile);
3318 }
3319
3320 struct join_res
3321 {
3322     const CHAR one[MAX_PATH];
3323     const CHAR two[MAX_PATH];
3324 };
3325
3326 struct join_res_4col
3327 {
3328     const CHAR one[MAX_PATH];
3329     const CHAR two[MAX_PATH];
3330     const CHAR three[MAX_PATH];
3331     const CHAR four[MAX_PATH];
3332 };
3333
3334 struct join_res_uint
3335 {
3336     UINT one;
3337     UINT two;
3338     UINT three;
3339     UINT four;
3340     UINT five;
3341     UINT six;
3342 };
3343
3344 static const struct join_res join_res_first[] =
3345 {
3346     { "alveolar", "procerus" },
3347     { "septum", "procerus" },
3348     { "septum", "nasalis" },
3349     { "ramus", "nasalis" },
3350     { "malar", "mentalis" },
3351 };
3352
3353 static const struct join_res join_res_second[] =
3354 {
3355     { "nasal", "septum" },
3356     { "mandible", "ramus" },
3357 };
3358
3359 static const struct join_res join_res_third[] =
3360 {
3361     { "msvcp.dll", "abcdefgh" },
3362     { "msvcr.dll", "ijklmnop" },
3363 };
3364
3365 static const struct join_res join_res_fourth[] =
3366 {
3367     { "msvcp.dll.01234", "single.dll.31415" },
3368 };
3369
3370 static const struct join_res join_res_fifth[] =
3371 {
3372     { "malar", "procerus" },
3373 };
3374
3375 static const struct join_res join_res_sixth[] =
3376 {
3377     { "malar", "procerus" },
3378     { "malar", "procerus" },
3379     { "malar", "nasalis" },
3380     { "malar", "nasalis" },
3381     { "malar", "nasalis" },
3382     { "malar", "mentalis" },
3383 };
3384
3385 static const struct join_res join_res_seventh[] =
3386 {
3387     { "malar", "nasalis" },
3388     { "malar", "nasalis" },
3389     { "malar", "nasalis" },
3390 };
3391
3392 static const struct join_res_4col join_res_eighth[] =
3393 {
3394     { "msvcp.dll", "msvcp.dll.01234", "msvcp.dll.01234", "abcdefgh" },
3395     { "msvcr.dll", "msvcr.dll.56789", "msvcp.dll.01234", "abcdefgh" },
3396     { "msvcp.dll", "msvcp.dll.01234", "msvcr.dll.56789", "ijklmnop" },
3397     { "msvcr.dll", "msvcr.dll.56789", "msvcr.dll.56789", "ijklmnop" },
3398     { "msvcp.dll", "msvcp.dll.01234", "single.dll.31415", "msvcp.dll" },
3399     { "msvcr.dll", "msvcr.dll.56789", "single.dll.31415", "msvcp.dll" },
3400 };
3401
3402 static const struct join_res_uint join_res_ninth[] =
3403 {
3404     { 1, 2, 3, 4, 7, 8 },
3405     { 1, 2, 5, 6, 7, 8 },
3406     { 1, 2, 3, 4, 9, 10 },
3407     { 1, 2, 5, 6, 9, 10 },
3408     { 1, 2, 3, 4, 11, 12 },
3409     { 1, 2, 5, 6, 11, 12 },
3410 };
3411
3412 static void test_join(void)
3413 {
3414     MSIHANDLE hdb, hview, hrec;
3415     LPCSTR query;
3416     CHAR buf[MAX_PATH];
3417     UINT r, count;
3418     DWORD size, i;
3419     BOOL data_correct;
3420
3421     hdb = create_db();
3422     ok( hdb, "failed to create db\n");
3423
3424     r = create_component_table( hdb );
3425     ok( r == ERROR_SUCCESS, "cannot create Component table: %d\n", r );
3426
3427     r = add_component_entry( hdb, "'zygomatic', 'malar', 'INSTALLDIR', 0, '', ''" );
3428     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3429
3430     r = add_component_entry( hdb, "'maxilla', 'alveolar', 'INSTALLDIR', 0, '', ''" );
3431     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3432
3433     r = add_component_entry( hdb, "'nasal', 'septum', 'INSTALLDIR', 0, '', ''" );
3434     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3435
3436     r = add_component_entry( hdb, "'mandible', 'ramus', 'INSTALLDIR', 0, '', ''" );
3437     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3438
3439     r = create_feature_components_table( hdb );
3440     ok( r == ERROR_SUCCESS, "cannot create FeatureComponents table: %d\n", r );
3441
3442     r = add_feature_components_entry( hdb, "'procerus', 'maxilla'" );
3443     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3444
3445     r = add_feature_components_entry( hdb, "'procerus', 'nasal'" );
3446     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3447
3448     r = add_feature_components_entry( hdb, "'nasalis', 'nasal'" );
3449     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3450
3451     r = add_feature_components_entry( hdb, "'nasalis', 'mandible'" );
3452     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3453
3454     r = add_feature_components_entry( hdb, "'nasalis', 'notacomponent'" );
3455     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3456
3457     r = add_feature_components_entry( hdb, "'mentalis', 'zygomatic'" );
3458     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3459
3460     r = create_std_dlls_table( hdb );
3461     ok( r == ERROR_SUCCESS, "cannot create StdDlls table: %d\n", r );
3462
3463     r = add_std_dlls_entry( hdb, "'msvcp.dll', 'msvcp.dll.01234'" );
3464     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
3465
3466     r = add_std_dlls_entry( hdb, "'msvcr.dll', 'msvcr.dll.56789'" );
3467     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
3468
3469     r = create_binary_table( hdb );
3470     ok( r == ERROR_SUCCESS, "cannot create Binary table: %d\n", r );
3471
3472     r = add_binary_entry( hdb, "'msvcp.dll.01234', 'abcdefgh'" );
3473     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3474
3475     r = add_binary_entry( hdb, "'msvcr.dll.56789', 'ijklmnop'" );
3476     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3477
3478     r = add_binary_entry( hdb, "'single.dll.31415', 'msvcp.dll'" );
3479     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3480
3481     query = "CREATE TABLE `One` (`A` SHORT, `B` SHORT PRIMARY KEY `A`)";
3482     r = run_query( hdb, 0, query);
3483     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3484
3485     query = "CREATE TABLE `Two` (`C` SHORT, `D` SHORT PRIMARY KEY `C`)";
3486     r = run_query( hdb, 0, query);
3487     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3488
3489     query = "CREATE TABLE `Three` (`E` SHORT, `F` SHORT PRIMARY KEY `E`)";
3490     r = run_query( hdb, 0, query);
3491     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3492
3493     query = "INSERT INTO `One` (`A`, `B`) VALUES (1, 2)";
3494     r = run_query( hdb, 0, query);
3495     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3496
3497     query = "INSERT INTO `Two` (`C`, `D`) VALUES (3, 4)";
3498     r = run_query( hdb, 0, query);
3499     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3500
3501     query = "INSERT INTO `Two` (`C`, `D`) VALUES (5, 6)";
3502     r = run_query( hdb, 0, query);
3503     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3504
3505     query = "INSERT INTO `Three` (`E`, `F`) VALUES (7, 8)";
3506     r = run_query( hdb, 0, query);
3507     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3508
3509     query = "INSERT INTO `Three` (`E`, `F`) VALUES (9, 10)";
3510     r = run_query( hdb, 0, query);
3511     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3512
3513     query = "INSERT INTO `Three` (`E`, `F`) VALUES (11, 12)";
3514     r = run_query( hdb, 0, query);
3515     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3516
3517     query = "CREATE TABLE `Four` (`G` SHORT, `H` SHORT PRIMARY KEY `G`)";
3518     r = run_query( hdb, 0, query);
3519     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3520
3521     query = "CREATE TABLE `Five` (`I` SHORT, `J` SHORT PRIMARY KEY `I`)";
3522     r = run_query( hdb, 0, query);
3523     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3524
3525     query = "INSERT INTO `Five` (`I`, `J`) VALUES (13, 14)";
3526     r = run_query( hdb, 0, query);
3527     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3528
3529     query = "INSERT INTO `Five` (`I`, `J`) VALUES (15, 16)";
3530     r = run_query( hdb, 0, query);
3531     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3532
3533     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3534             "FROM `Component`, `FeatureComponents` "
3535             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
3536             "ORDER BY `Feature_`";
3537     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3538     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3539
3540     r = MsiViewExecute(hview, 0);
3541     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3542
3543     i = 0;
3544     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3545     {
3546         count = MsiRecordGetFieldCount( hrec );
3547         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3548
3549         size = MAX_PATH;
3550         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3551         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3552         ok( !lstrcmpA( buf, join_res_first[i].one ),
3553             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_first[i].one, buf );
3554
3555         size = MAX_PATH;
3556         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3557         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3558         ok( !lstrcmpA( buf, join_res_first[i].two ),
3559             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_first[i].two, buf );
3560
3561         i++;
3562         MsiCloseHandle(hrec);
3563     }
3564
3565     ok( i == 5, "Expected 5 rows, got %d\n", i );
3566     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3567
3568     MsiViewClose(hview);
3569     MsiCloseHandle(hview);
3570
3571     /* try a join without a WHERE condition */
3572     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3573             "FROM `Component`, `FeatureComponents` ";
3574     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3575     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3576
3577     r = MsiViewExecute(hview, 0);
3578     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3579
3580     i = 0;
3581     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3582     {
3583         i++;
3584         MsiCloseHandle(hrec);
3585     }
3586     ok( i == 24, "Expected 24 rows, got %d\n", i );
3587
3588     MsiViewClose(hview);
3589     MsiCloseHandle(hview);
3590
3591     query = "SELECT DISTINCT Component, ComponentId FROM FeatureComponents, Component "
3592             "WHERE FeatureComponents.Component_=Component.Component "
3593             "AND (Feature_='nasalis') ORDER BY Feature_";
3594     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3595     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3596
3597     r = MsiViewExecute(hview, 0);
3598     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3599
3600     i = 0;
3601     data_correct = TRUE;
3602     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3603     {
3604         count = MsiRecordGetFieldCount( hrec );
3605         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3606
3607         size = MAX_PATH;
3608         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3609         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3610         if( lstrcmpA( buf, join_res_second[i].one ))
3611             data_correct = FALSE;
3612
3613         size = MAX_PATH;
3614         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3615         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3616         if( lstrcmpA( buf, join_res_second[i].two ))
3617             data_correct = FALSE;
3618
3619         i++;
3620         MsiCloseHandle(hrec);
3621     }
3622
3623     ok( data_correct, "data returned in the wrong order\n");
3624
3625     ok( i == 2, "Expected 2 rows, got %d\n", i );
3626     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3627
3628     MsiViewClose(hview);
3629     MsiCloseHandle(hview);
3630
3631     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
3632             "FROM `StdDlls`, `Binary` "
3633             "WHERE `StdDlls`.`Binary_` = `Binary`.`Name` "
3634             "ORDER BY `File`";
3635     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3636     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3637
3638     r = MsiViewExecute(hview, 0);
3639     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3640
3641     i = 0;
3642     data_correct = TRUE;
3643     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3644     {
3645         count = MsiRecordGetFieldCount( hrec );
3646         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3647
3648         size = MAX_PATH;
3649         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3650         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3651         if( lstrcmpA( buf, join_res_third[i].one ) )
3652             data_correct = FALSE;
3653
3654         size = MAX_PATH;
3655         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3656         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3657         if( lstrcmpA( buf, join_res_third[i].two ) )
3658             data_correct = FALSE;
3659
3660         i++;
3661         MsiCloseHandle(hrec);
3662     }
3663     ok( data_correct, "data returned in the wrong order\n");
3664
3665     ok( i == 2, "Expected 2 rows, got %d\n", i );
3666
3667     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3668
3669     MsiViewClose(hview);
3670     MsiCloseHandle(hview);
3671
3672     query = "SELECT `StdDlls`.`Binary_`, `Binary`.`Name` "
3673             "FROM `StdDlls`, `Binary` "
3674             "WHERE `StdDlls`.`File` = `Binary`.`Data` "
3675             "ORDER BY `Name`";
3676     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3677     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3678
3679     r = MsiViewExecute(hview, 0);
3680     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3681
3682     i = 0;
3683     data_correct = TRUE;
3684     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3685     {
3686         count = MsiRecordGetFieldCount( hrec );
3687         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3688
3689         size = MAX_PATH;
3690         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3691         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3692         if( lstrcmpA( buf, join_res_fourth[i].one ))
3693             data_correct = FALSE;
3694
3695         size = MAX_PATH;
3696         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3697         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3698         if( lstrcmpA( buf, join_res_fourth[i].two ))
3699             data_correct = FALSE;
3700
3701         i++;
3702         MsiCloseHandle(hrec);
3703     }
3704     ok( data_correct, "data returned in the wrong order\n");
3705
3706     ok( i == 1, "Expected 1 rows, got %d\n", i );
3707     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3708
3709     MsiViewClose(hview);
3710     MsiCloseHandle(hview);
3711
3712     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3713             "FROM `Component`, `FeatureComponents` "
3714             "WHERE `Component`.`Component` = 'zygomatic' "
3715             "AND `FeatureComponents`.`Component_` = 'maxilla' "
3716             "ORDER BY `Feature_`";
3717     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3718     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3719
3720     r = MsiViewExecute(hview, 0);
3721     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3722
3723     i = 0;
3724     data_correct = TRUE;
3725     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3726     {
3727         count = MsiRecordGetFieldCount( hrec );
3728         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3729
3730         size = MAX_PATH;
3731         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3732         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3733         if( lstrcmpA( buf, join_res_fifth[i].one ))
3734             data_correct = FALSE;
3735
3736         size = MAX_PATH;
3737         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3738         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3739         if( lstrcmpA( buf, join_res_fifth[i].two ))
3740             data_correct = FALSE;
3741
3742         i++;
3743         MsiCloseHandle(hrec);
3744     }
3745     ok( data_correct, "data returned in the wrong order\n");
3746
3747     ok( i == 1, "Expected 1 rows, got %d\n", i );
3748     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3749
3750     MsiViewClose(hview);
3751     MsiCloseHandle(hview);
3752
3753     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3754             "FROM `Component`, `FeatureComponents` "
3755             "WHERE `Component` = 'zygomatic' "
3756             "ORDER BY `Feature_`";
3757     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3758     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3759
3760     r = MsiViewExecute(hview, 0);
3761     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3762
3763     i = 0;
3764     data_correct = TRUE;
3765     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3766     {
3767         count = MsiRecordGetFieldCount( hrec );
3768         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3769
3770         size = MAX_PATH;
3771         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3772         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3773         if( lstrcmpA( buf, join_res_sixth[i].one ))
3774             data_correct = FALSE;
3775
3776         size = MAX_PATH;
3777         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3778         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3779         if( lstrcmpA( buf, join_res_sixth[i].two ))
3780             data_correct = FALSE;
3781
3782         i++;
3783         MsiCloseHandle(hrec);
3784     }
3785     ok( data_correct, "data returned in the wrong order\n");
3786
3787     ok( i == 6, "Expected 6 rows, got %d\n", i );
3788     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3789
3790     MsiViewClose(hview);
3791     MsiCloseHandle(hview);
3792
3793     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3794             "FROM `Component`, `FeatureComponents` "
3795             "WHERE `Component` = 'zygomatic' "
3796             "AND `Feature_` = 'nasalis' "
3797             "ORDER BY `Feature_`";
3798     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3799     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3800
3801     r = MsiViewExecute(hview, 0);
3802     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3803
3804     i = 0;
3805     data_correct = TRUE;
3806     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3807     {
3808         count = MsiRecordGetFieldCount( hrec );
3809         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3810
3811         size = MAX_PATH;
3812         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3813         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3814         if( lstrcmpA( buf, join_res_seventh[i].one ))
3815             data_correct = FALSE;
3816
3817         size = MAX_PATH;
3818         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3819         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3820         if( lstrcmpA( buf, join_res_seventh[i].two ))
3821             data_correct = FALSE;
3822
3823         i++;
3824         MsiCloseHandle(hrec);
3825     }
3826
3827     ok( data_correct, "data returned in the wrong order\n");
3828     ok( i == 3, "Expected 3 rows, got %d\n", i );
3829     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3830
3831     MsiViewClose(hview);
3832     MsiCloseHandle(hview);
3833
3834     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
3835             "FROM `StdDlls`, `Binary` ";
3836     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3837     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3838
3839     r = MsiViewExecute(hview, 0);
3840     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3841
3842     i = 0;
3843     data_correct = TRUE;
3844     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3845     {
3846         count = MsiRecordGetFieldCount( hrec );
3847         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3848
3849         size = MAX_PATH;
3850         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3851         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3852         if( lstrcmpA( buf, join_res_eighth[i].one ))
3853             data_correct = FALSE;
3854
3855         size = MAX_PATH;
3856         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3857         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3858         if( lstrcmpA( buf, join_res_eighth[i].four ))
3859             data_correct = FALSE;
3860
3861         i++;
3862         MsiCloseHandle(hrec);
3863     }
3864
3865     ok( data_correct, "data returned in the wrong order\n");
3866     ok( i == 6, "Expected 6 rows, got %d\n", i );
3867     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3868
3869     MsiViewClose(hview);
3870     MsiCloseHandle(hview);
3871
3872     query = "SELECT * FROM `StdDlls`, `Binary` ";
3873     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3874     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3875
3876     r = MsiViewExecute(hview, 0);
3877     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3878
3879     i = 0;
3880     data_correct = TRUE;
3881     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3882     {
3883         count = MsiRecordGetFieldCount( hrec );
3884         ok( count == 4, "Expected 4 record fields, got %d\n", count );
3885
3886         size = MAX_PATH;
3887         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3888         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3889         if( lstrcmpA( buf, join_res_eighth[i].one ))
3890             data_correct = FALSE;
3891
3892         size = MAX_PATH;
3893         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3894         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3895         if( lstrcmpA( buf, join_res_eighth[i].two ))
3896             data_correct = FALSE;
3897
3898         size = MAX_PATH;
3899         r = MsiRecordGetStringA( hrec, 3, buf, &size );
3900         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3901         if( lstrcmpA( buf, join_res_eighth[i].three ))
3902             data_correct = FALSE;
3903
3904         size = MAX_PATH;
3905         r = MsiRecordGetStringA( hrec, 4, buf, &size );
3906         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3907         if( lstrcmpA( buf, join_res_eighth[i].four ))
3908             data_correct = FALSE;
3909
3910         i++;
3911         MsiCloseHandle(hrec);
3912     }
3913     ok( data_correct, "data returned in the wrong order\n");
3914
3915     ok( i == 6, "Expected 6 rows, got %d\n", i );
3916     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3917
3918     MsiViewClose(hview);
3919     MsiCloseHandle(hview);
3920
3921     query = "SELECT * FROM `One`, `Two`, `Three` ";
3922     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3923     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3924
3925     r = MsiViewExecute(hview, 0);
3926     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3927
3928     i = 0;
3929     data_correct = TRUE;
3930     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3931     {
3932         count = MsiRecordGetFieldCount( hrec );
3933         ok( count == 6, "Expected 6 record fields, got %d\n", count );
3934
3935         r = MsiRecordGetInteger( hrec, 1 );
3936         if( r != join_res_ninth[i].one )
3937             data_correct = FALSE;
3938
3939         r = MsiRecordGetInteger( hrec, 2 );
3940         if( r != join_res_ninth[i].two )
3941             data_correct = FALSE;
3942
3943         r = MsiRecordGetInteger( hrec, 3 );
3944         if( r != join_res_ninth[i].three )
3945             data_correct = FALSE;
3946
3947         r = MsiRecordGetInteger( hrec, 4 );
3948         if( r != join_res_ninth[i].four )
3949             data_correct = FALSE;
3950
3951         r = MsiRecordGetInteger( hrec, 5 );
3952         if( r != join_res_ninth[i].five )
3953             data_correct = FALSE;
3954
3955         r = MsiRecordGetInteger( hrec, 6);
3956         if( r != join_res_ninth[i].six )
3957             data_correct = FALSE;
3958
3959         i++;
3960         MsiCloseHandle(hrec);
3961     }
3962     ok( data_correct, "data returned in the wrong order\n");
3963
3964     ok( i == 6, "Expected 6 rows, got %d\n", i );
3965     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3966
3967     MsiViewClose(hview);
3968     MsiCloseHandle(hview);
3969
3970     query = "SELECT * FROM `Four`, `Five`";
3971     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3972     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3973
3974     r = MsiViewExecute(hview, 0);
3975     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3976
3977     r = MsiViewFetch(hview, &hrec);
3978     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3979
3980     MsiViewClose(hview);
3981     MsiCloseHandle(hview);
3982
3983     query = "SELECT * FROM `Nonexistent`, `One`";
3984     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3985     ok( r == ERROR_BAD_QUERY_SYNTAX,
3986         "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r );
3987
3988     /* try updating a row in a join table */
3989     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3990             "FROM `Component`, `FeatureComponents` "
3991             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
3992             "ORDER BY `Feature_`";
3993     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3994     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3995
3996     r = MsiViewExecute(hview, 0);
3997     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3998
3999     r = MsiViewFetch(hview, &hrec);
4000     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
4001
4002     r = MsiRecordSetStringA( hrec, 1, "epicranius" );
4003     ok( r == ERROR_SUCCESS, "failed to set string: %d\n", r );
4004
4005     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
4006     ok( r == ERROR_SUCCESS, "failed to update row: %d\n", r );
4007
4008     /* try another valid operation for joins */
4009     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
4010     todo_wine ok( r == ERROR_SUCCESS, "failed to refresh row: %d\n", r );
4011
4012     /* try an invalid operation for joins */
4013     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
4014     ok( r == ERROR_FUNCTION_FAILED, "unexpected result: %d\n", r );
4015
4016     r = MsiRecordSetStringA( hrec, 2, "epicranius" );
4017     ok( r == ERROR_SUCCESS, "failed to set string: %d\n", r );
4018
4019     /* primary key cannot be updated */
4020     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
4021     ok( r == ERROR_FUNCTION_FAILED, "failed to update row: %d\n", r );
4022
4023     MsiCloseHandle(hrec);
4024     MsiViewClose(hview);
4025     MsiCloseHandle(hview);
4026
4027     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4028     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4029
4030     r = MsiViewExecute(hview, 0);
4031     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4032
4033     r = MsiViewFetch(hview, &hrec);
4034     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4035
4036     size = MAX_PATH;
4037     r = MsiRecordGetStringA( hrec, 1, buf, &size );
4038     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
4039     ok( !lstrcmpA( buf, "epicranius" ), "expected 'epicranius', got %s\n", buf );
4040
4041     MsiCloseHandle(hrec);
4042     MsiViewClose(hview);
4043     MsiCloseHandle(hview);
4044
4045     MsiCloseHandle(hdb);
4046     DeleteFileA(msifile);
4047 }
4048
4049 static void test_temporary_table(void)
4050 {
4051     MSICONDITION cond;
4052     MSIHANDLE hdb = 0, view = 0, rec;
4053     const char *query;
4054     UINT r;
4055     char buf[0x10];
4056     DWORD sz;
4057
4058     cond = MsiDatabaseIsTablePersistentA(0, NULL);
4059     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
4060
4061     hdb = create_db();
4062     ok( hdb, "failed to create db\n");
4063
4064     cond = MsiDatabaseIsTablePersistentA(hdb, NULL);
4065     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
4066
4067     cond = MsiDatabaseIsTablePersistentA(hdb, "_Tables");
4068     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4069
4070     cond = MsiDatabaseIsTablePersistentA(hdb, "_Columns");
4071     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4072
4073     cond = MsiDatabaseIsTablePersistentA(hdb, "_Storages");
4074     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4075
4076     cond = MsiDatabaseIsTablePersistentA(hdb, "_Streams");
4077     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4078
4079     query = "CREATE TABLE `P` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`)";
4080     r = run_query(hdb, 0, query);
4081     ok(r == ERROR_SUCCESS, "failed to add table\n");
4082
4083     cond = MsiDatabaseIsTablePersistentA(hdb, "P");
4084     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
4085
4086     query = "CREATE TABLE `P2` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`) HOLD";
4087     r = run_query(hdb, 0, query);
4088     ok(r == ERROR_SUCCESS, "failed to add table\n");
4089
4090     cond = MsiDatabaseIsTablePersistentA(hdb, "P2");
4091     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
4092
4093     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY 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, "T");
4098     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
4099
4100     query = "CREATE TABLE `T2` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
4101     r = run_query(hdb, 0, query);
4102     ok(r == ERROR_SUCCESS, "failed to add table\n");
4103
4104     query = "SELECT * FROM `T2`";
4105     r = MsiDatabaseOpenViewA(hdb, query, &view);
4106     ok(r == ERROR_BAD_QUERY_SYNTAX,
4107        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4108
4109     cond = MsiDatabaseIsTablePersistentA(hdb, "T2");
4110     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4111
4112     query = "CREATE TABLE `T3` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) PRIMARY KEY `C`)";
4113     r = run_query(hdb, 0, query);
4114     ok(r == ERROR_SUCCESS, "failed to add table\n");
4115
4116     cond = MsiDatabaseIsTablePersistentA(hdb, "T3");
4117     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
4118
4119     query = "CREATE TABLE `T4` ( `B` SHORT NOT NULL, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
4120     r = run_query(hdb, 0, query);
4121     ok(r == ERROR_FUNCTION_FAILED, "failed to add table\n");
4122
4123     cond = MsiDatabaseIsTablePersistentA(hdb, "T4");
4124     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4125
4126     query = "CREATE TABLE `T5` ( `B` SHORT NOT NULL TEMP, `C` CHAR(255) TEMP PRIMARY KEY `C`) HOLD";
4127     r = run_query(hdb, 0, query);
4128     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to add table\n");
4129
4130     query = "select * from `T`";
4131     r = MsiDatabaseOpenViewA(hdb, query, &view);
4132     ok(r == ERROR_SUCCESS, "failed to query table\n");
4133     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
4134     ok(r == ERROR_SUCCESS, "failed to get column info\n");
4135
4136     sz = sizeof buf;
4137     r = MsiRecordGetStringA(rec, 1, buf, &sz);
4138     ok(r == ERROR_SUCCESS, "failed to get string\n");
4139     ok( 0 == strcmp("G255", buf), "wrong column type\n");
4140
4141     sz = sizeof buf;
4142     r = MsiRecordGetStringA(rec, 2, buf, &sz);
4143     ok(r == ERROR_SUCCESS, "failed to get string\n");
4144     ok( 0 == strcmp("j2", buf), "wrong column type\n");
4145
4146     MsiCloseHandle( rec );
4147     MsiViewClose( view );
4148     MsiCloseHandle( view );
4149
4150     /* query the table data */
4151     rec = 0;
4152     r = do_query(hdb, "select * from `_Tables` where `Name` = 'T'", &rec);
4153     ok( r == ERROR_SUCCESS, "temporary table exists in _Tables\n");
4154     MsiCloseHandle( rec );
4155
4156     /* query the column data */
4157     rec = 0;
4158     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'B'", &rec);
4159     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
4160     if (rec) MsiCloseHandle( rec );
4161
4162     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'C'", &rec);
4163     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
4164     if (rec) MsiCloseHandle( rec );
4165
4166     MsiCloseHandle( hdb );
4167     DeleteFileA(msifile);
4168 }
4169
4170 static void test_alter(void)
4171 {
4172     MSICONDITION cond;
4173     MSIHANDLE hdb = 0;
4174     const char *query;
4175     UINT r;
4176
4177     hdb = create_db();
4178     ok( hdb, "failed to create db\n");
4179
4180     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
4181     r = run_query(hdb, 0, query);
4182     ok(r == ERROR_SUCCESS, "failed to add table\n");
4183
4184     cond = MsiDatabaseIsTablePersistentA(hdb, "T");
4185     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
4186
4187     query = "ALTER TABLE `T` HOLD";
4188     r = run_query(hdb, 0, query);
4189     ok(r == ERROR_SUCCESS, "failed to hold table %d\n", r);
4190
4191     query = "ALTER TABLE `T` FREE";
4192     r = run_query(hdb, 0, query);
4193     ok(r == ERROR_SUCCESS, "failed to free table\n");
4194
4195     query = "ALTER TABLE `T` FREE";
4196     r = run_query(hdb, 0, query);
4197     ok(r == ERROR_SUCCESS, "failed to free table\n");
4198
4199     query = "ALTER TABLE `T` FREE";
4200     r = run_query(hdb, 0, query);
4201     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to free table\n");
4202
4203     query = "ALTER TABLE `T` HOLD";
4204     r = run_query(hdb, 0, query);
4205     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to hold table %d\n", r);
4206
4207     /* table T is removed */
4208     query = "SELECT * FROM `T`";
4209     r = run_query(hdb, 0, query);
4210     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4211
4212     /* create the table again */
4213     query = "CREATE TABLE `U` ( `A` INTEGER, `B` INTEGER PRIMARY KEY `B`)";
4214     r = run_query(hdb, 0, query);
4215     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4216
4217     /* up the ref count */
4218     query = "ALTER TABLE `U` HOLD";
4219     r = run_query(hdb, 0, query);
4220     ok(r == ERROR_SUCCESS, "failed to free table\n");
4221
4222     /* add column, no data type */
4223     query = "ALTER TABLE `U` ADD `C`";
4224     r = run_query(hdb, 0, query);
4225     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4226
4227     query = "ALTER TABLE `U` ADD `C` INTEGER";
4228     r = run_query(hdb, 0, query);
4229     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4230
4231     /* add column C again */
4232     query = "ALTER TABLE `U` ADD `C` INTEGER";
4233     r = run_query(hdb, 0, query);
4234     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4235
4236     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY";
4237     r = run_query(hdb, 0, query);
4238     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4239
4240     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 1, 2, 3, 4 )";
4241     r = run_query(hdb, 0, query);
4242     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4243
4244     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY HOLD";
4245     r = run_query(hdb, 0, query);
4246     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4247
4248     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 5, 6, 7, 8 )";
4249     r = run_query(hdb, 0, query);
4250     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4251
4252     query = "SELECT * FROM `U` WHERE `D` = 8";
4253     r = run_query(hdb, 0, query);
4254     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4255
4256     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY FREE";
4257     r = run_query(hdb, 0, query);
4258     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4259
4260     query = "ALTER COLUMN `D` FREE";
4261     r = run_query(hdb, 0, query);
4262     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4263
4264     /* drop the ref count */
4265     query = "ALTER TABLE `U` FREE";
4266     r = run_query(hdb, 0, query);
4267     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4268
4269     /* table is not empty */
4270     query = "SELECT * FROM `U`";
4271     r = run_query(hdb, 0, query);
4272     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4273
4274     /* column D is removed */
4275     query = "SELECT * FROM `U` WHERE `D` = 8";
4276     r = run_query(hdb, 0, query);
4277     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4278
4279     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 9, 10, 11, 12 )";
4280     r = run_query(hdb, 0, query);
4281     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4282
4283     /* add the column again */
4284     query = "ALTER TABLE `U` ADD `E` INTEGER TEMPORARY HOLD";
4285     r = run_query(hdb, 0, query);
4286     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4287
4288     /* up the ref count */
4289     query = "ALTER TABLE `U` HOLD";
4290     r = run_query(hdb, 0, query);
4291     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4292
4293     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 13, 14, 15, 16 )";
4294     r = run_query(hdb, 0, query);
4295     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4296
4297     query = "SELECT * FROM `U` WHERE `E` = 16";
4298     r = run_query(hdb, 0, query);
4299     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4300
4301     /* drop the ref count */
4302     query = "ALTER TABLE `U` FREE";
4303     r = run_query(hdb, 0, query);
4304     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4305
4306     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 17, 18, 19, 20 )";
4307     r = run_query(hdb, 0, query);
4308     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4309
4310     query = "SELECT * FROM `U` WHERE `E` = 20";
4311     r = run_query(hdb, 0, query);
4312     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4313
4314     /* drop the ref count */
4315     query = "ALTER TABLE `U` FREE";
4316     r = run_query(hdb, 0, query);
4317     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4318
4319     /* table still exists */
4320     query = "SELECT * FROM `U`";
4321     r = run_query(hdb, 0, query);
4322     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4323
4324     /* col E is removed */
4325     query = "SELECT * FROM `U` WHERE `E` = 20";
4326     r = run_query(hdb, 0, query);
4327     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4328
4329     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 20, 21, 22, 23 )";
4330     r = run_query(hdb, 0, query);
4331     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4332
4333     /* drop the ref count once more */
4334     query = "ALTER TABLE `U` FREE";
4335     r = run_query(hdb, 0, query);
4336     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4337
4338     /* table still exists */
4339     query = "SELECT * FROM `U`";
4340     r = run_query(hdb, 0, query);
4341     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4342
4343     MsiCloseHandle( hdb );
4344     DeleteFileA(msifile);
4345 }
4346
4347 static void test_integers(void)
4348 {
4349     MSIHANDLE hdb = 0, view = 0, rec = 0;
4350     DWORD count, i;
4351     const char *query;
4352     UINT r;
4353
4354     /* just MsiOpenDatabase should not create a file */
4355     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4356     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4357
4358     /* create a table */
4359     query = "CREATE TABLE `integers` ( "
4360             "`one` SHORT, `two` INT, `three` INTEGER, `four` LONG, "
4361             "`five` SHORT NOT NULL, `six` INT NOT NULL, "
4362             "`seven` INTEGER NOT NULL, `eight` LONG NOT NULL "
4363             "PRIMARY KEY `one`)";
4364     r = MsiDatabaseOpenViewA(hdb, query, &view);
4365     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4366     r = MsiViewExecute(view, 0);
4367     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4368     r = MsiViewClose(view);
4369     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4370     r = MsiCloseHandle(view);
4371     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4372
4373     query = "SELECT * FROM `integers`";
4374     r = MsiDatabaseOpenViewA(hdb, query, &view);
4375     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4376
4377     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
4378     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4379     count = MsiRecordGetFieldCount(rec);
4380     ok(count == 8, "Expected 8, got %d\n", count);
4381     ok(check_record(rec, 1, "one"), "Expected one\n");
4382     ok(check_record(rec, 2, "two"), "Expected two\n");
4383     ok(check_record(rec, 3, "three"), "Expected three\n");
4384     ok(check_record(rec, 4, "four"), "Expected four\n");
4385     ok(check_record(rec, 5, "five"), "Expected five\n");
4386     ok(check_record(rec, 6, "six"), "Expected six\n");
4387     ok(check_record(rec, 7, "seven"), "Expected seven\n");
4388     ok(check_record(rec, 8, "eight"), "Expected eight\n");
4389     MsiCloseHandle(rec);
4390
4391     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
4392     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4393     count = MsiRecordGetFieldCount(rec);
4394     ok(count == 8, "Expected 8, got %d\n", count);
4395     ok(check_record(rec, 1, "I2"), "Expected I2\n");
4396     ok(check_record(rec, 2, "I2"), "Expected I2\n");
4397     ok(check_record(rec, 3, "I2"), "Expected I2\n");
4398     ok(check_record(rec, 4, "I4"), "Expected I4\n");
4399     ok(check_record(rec, 5, "i2"), "Expected i2\n");
4400     ok(check_record(rec, 6, "i2"), "Expected i2\n");
4401     ok(check_record(rec, 7, "i2"), "Expected i2\n");
4402     ok(check_record(rec, 8, "i4"), "Expected i4\n");
4403     MsiCloseHandle(rec);
4404
4405     MsiViewClose(view);
4406     MsiCloseHandle(view);
4407
4408     /* insert values into it, NULL where NOT NULL is specified */
4409     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
4410         "VALUES('', '', '', '', '', '', '', '')";
4411     r = MsiDatabaseOpenViewA(hdb, query, &view);
4412     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4413     r = MsiViewExecute(view, 0);
4414     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
4415
4416     MsiViewClose(view);
4417     MsiCloseHandle(view);
4418
4419     query = "SELECT * FROM `integers`";
4420     r = do_query(hdb, query, &rec);
4421     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4422
4423     r = MsiRecordGetFieldCount(rec);
4424     ok(r == -1, "record count wrong: %d\n", r);
4425
4426     MsiCloseHandle(rec);
4427
4428     /* insert legitimate values into it */
4429     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
4430         "VALUES('', '2', '', '4', '5', '6', '7', '8')";
4431     r = MsiDatabaseOpenViewA(hdb, query, &view);
4432     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4433     r = MsiViewExecute(view, 0);
4434     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4435
4436     query = "SELECT * FROM `integers`";
4437     r = do_query(hdb, query, &rec);
4438     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4439
4440     r = MsiRecordGetFieldCount(rec);
4441     ok(r == 8, "record count wrong: %d\n", r);
4442
4443     i = MsiRecordGetInteger(rec, 1);
4444     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
4445     i = MsiRecordGetInteger(rec, 3);
4446     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
4447     i = MsiRecordGetInteger(rec, 2);
4448     ok(i == 2, "Expected 2, got %d\n", i);
4449     i = MsiRecordGetInteger(rec, 4);
4450     ok(i == 4, "Expected 4, got %d\n", i);
4451     i = MsiRecordGetInteger(rec, 5);
4452     ok(i == 5, "Expected 5, got %d\n", i);
4453     i = MsiRecordGetInteger(rec, 6);
4454     ok(i == 6, "Expected 6, got %d\n", i);
4455     i = MsiRecordGetInteger(rec, 7);
4456     ok(i == 7, "Expected 7, got %d\n", i);
4457     i = MsiRecordGetInteger(rec, 8);
4458     ok(i == 8, "Expected 8, got %d\n", i);
4459
4460     MsiCloseHandle(rec);
4461     MsiViewClose(view);
4462     MsiCloseHandle(view);
4463
4464     r = MsiDatabaseCommit(hdb);
4465     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
4466
4467     r = MsiCloseHandle(hdb);
4468     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4469
4470     r = DeleteFileA(msifile);
4471     ok(r == TRUE, "file didn't exist after commit\n");
4472 }
4473
4474 static void test_update(void)
4475 {
4476     MSIHANDLE hdb = 0, view = 0, rec = 0;
4477     CHAR result[MAX_PATH];
4478     const char *query;
4479     DWORD size;
4480     UINT r;
4481
4482     /* just MsiOpenDatabase should not create a file */
4483     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4484     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4485
4486     /* create the Control table */
4487     query = "CREATE TABLE `Control` ( "
4488         "`Dialog_` CHAR(72) NOT NULL, `Control` CHAR(50) NOT NULL, `Type` SHORT NOT NULL, "
4489         "`X` SHORT NOT NULL, `Y` SHORT NOT NULL, `Width` SHORT NOT NULL, `Height` SHORT NOT NULL,"
4490         "`Attributes` LONG, `Property` CHAR(50), `Text` CHAR(0) LOCALIZABLE, "
4491         "`Control_Next` CHAR(50), `Help` CHAR(50) LOCALIZABLE PRIMARY KEY `Dialog_`, `Control`)";
4492     r = MsiDatabaseOpenViewA(hdb, query, &view);
4493     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4494     r = MsiViewExecute(view, 0);
4495     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4496     r = MsiViewClose(view);
4497     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4498     r = MsiCloseHandle(view);
4499     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4500
4501     /* add a control */
4502     query = "INSERT INTO `Control` ( "
4503         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4504         "`Property`, `Text`, `Control_Next`, `Help` )"
4505         "VALUES('ErrorDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
4506     r = MsiDatabaseOpenViewA(hdb, query, &view);
4507     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4508     r = MsiViewExecute(view, 0);
4509     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4510     r = MsiViewClose(view);
4511     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4512     r = MsiCloseHandle(view);
4513     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4514
4515     /* add a second control */
4516     query = "INSERT INTO `Control` ( "
4517         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4518         "`Property`, `Text`, `Control_Next`, `Help` )"
4519         "VALUES('ErrorDialog', 'Button', '1', '5', '5', '5', '5', '', '', '', '')";
4520     r = MsiDatabaseOpenViewA(hdb, query, &view);
4521     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4522     r = MsiViewExecute(view, 0);
4523     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4524     r = MsiViewClose(view);
4525     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4526     r = MsiCloseHandle(view);
4527     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4528
4529     /* add a third control */
4530     query = "INSERT INTO `Control` ( "
4531         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4532         "`Property`, `Text`, `Control_Next`, `Help` )"
4533         "VALUES('AnotherDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
4534     r = MsiDatabaseOpenViewA(hdb, query, &view);
4535     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4536     r = MsiViewExecute(view, 0);
4537     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4538     r = MsiViewClose(view);
4539     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4540     r = MsiCloseHandle(view);
4541     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4542
4543     /* bad table */
4544     query = "UPDATE `NotATable` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4545     r = MsiDatabaseOpenViewA(hdb, query, &view);
4546     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4547
4548     /* bad set column */
4549     query = "UPDATE `Control` SET `NotAColumn` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4550     r = MsiDatabaseOpenViewA(hdb, query, &view);
4551     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4552
4553     /* bad where condition */
4554     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `NotAColumn` = 'ErrorDialog'";
4555     r = MsiDatabaseOpenViewA(hdb, query, &view);
4556     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4557
4558     /* just the dialog_ specified */
4559     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4560     r = MsiDatabaseOpenViewA(hdb, query, &view);
4561     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4562     r = MsiViewExecute(view, 0);
4563     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4564     r = MsiViewClose(view);
4565     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4566     r = MsiCloseHandle(view);
4567     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4568
4569     /* check the modified text */
4570     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
4571     r = MsiDatabaseOpenViewA(hdb, query, &view);
4572     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4573     r = MsiViewExecute(view, 0);
4574     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4575
4576     r = MsiViewFetch(view, &rec);
4577     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4578
4579     size = MAX_PATH;
4580     r = MsiRecordGetStringA(rec, 1, result, &size);
4581     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4582     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4583
4584     MsiCloseHandle(rec);
4585
4586     r = MsiViewFetch(view, &rec);
4587     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4588
4589     size = MAX_PATH;
4590     r = MsiRecordGetStringA(rec, 1, result, &size);
4591     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4592     ok(!result[0], "Expected an empty string, got %s\n", result);
4593
4594     MsiCloseHandle(rec);
4595
4596     r = MsiViewFetch(view, &rec);
4597     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4598
4599     r = MsiViewClose(view);
4600     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4601     r = MsiCloseHandle(view);
4602     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4603
4604     /* dialog_ and control specified */
4605     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog' AND `Control` = 'ErrorText'";
4606     r = MsiDatabaseOpenViewA(hdb, query, &view);
4607     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4608     r = MsiViewExecute(view, 0);
4609     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4610     r = MsiViewClose(view);
4611     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4612     r = MsiCloseHandle(view);
4613     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4614
4615     /* check the modified text */
4616     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
4617     r = MsiDatabaseOpenViewA(hdb, query, &view);
4618     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4619     r = MsiViewExecute(view, 0);
4620     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4621
4622     r = MsiViewFetch(view, &rec);
4623     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4624
4625     size = MAX_PATH;
4626     r = MsiRecordGetStringA(rec, 1, result, &size);
4627     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4628     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4629
4630     MsiCloseHandle(rec);
4631
4632     r = MsiViewFetch(view, &rec);
4633     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4634
4635     size = MAX_PATH;
4636     r = MsiRecordGetStringA(rec, 1, result, &size);
4637     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4638     ok(!result[0], "Expected an empty string, got %s\n", result);
4639
4640     MsiCloseHandle(rec);
4641
4642     r = MsiViewFetch(view, &rec);
4643     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4644
4645     r = MsiViewClose(view);
4646     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4647     r = MsiCloseHandle(view);
4648     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4649
4650     /* no where condition */
4651     query = "UPDATE `Control` SET `Text` = 'this is text'";
4652     r = MsiDatabaseOpenViewA(hdb, query, &view);
4653     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4654     r = MsiViewExecute(view, 0);
4655     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4656     r = MsiViewClose(view);
4657     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4658     r = MsiCloseHandle(view);
4659     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4660
4661     /* check the modified text */
4662     query = "SELECT `Text` FROM `Control`";
4663     r = MsiDatabaseOpenViewA(hdb, query, &view);
4664     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4665     r = MsiViewExecute(view, 0);
4666     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4667
4668     r = MsiViewFetch(view, &rec);
4669     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4670
4671     size = MAX_PATH;
4672     r = MsiRecordGetStringA(rec, 1, result, &size);
4673     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4674     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4675
4676     MsiCloseHandle(rec);
4677
4678     r = MsiViewFetch(view, &rec);
4679     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4680
4681     size = MAX_PATH;
4682     r = MsiRecordGetStringA(rec, 1, result, &size);
4683     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4684     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4685
4686     MsiCloseHandle(rec);
4687
4688     r = MsiViewFetch(view, &rec);
4689     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4690
4691     size = MAX_PATH;
4692     r = MsiRecordGetStringA(rec, 1, result, &size);
4693     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4694     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4695
4696     MsiCloseHandle(rec);
4697
4698     r = MsiViewFetch(view, &rec);
4699     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4700
4701     r = MsiViewClose(view);
4702     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4703     r = MsiCloseHandle(view);
4704     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4705
4706     query = "CREATE TABLE `Apple` ( `Banana` CHAR(72) NOT NULL, "
4707         "`Orange` CHAR(72),  `Pear` INT PRIMARY KEY `Banana`)";
4708     r = run_query(hdb, 0, query);
4709     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4710
4711     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4712         "VALUES('one', 'two', 3)";
4713     r = run_query(hdb, 0, query);
4714     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4715
4716     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4717         "VALUES('three', 'four', 5)";
4718     r = run_query(hdb, 0, query);
4719     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4720
4721     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4722         "VALUES('six', 'two', 7)";
4723     r = run_query(hdb, 0, query);
4724     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4725
4726     rec = MsiCreateRecord(2);
4727     MsiRecordSetInteger(rec, 1, 8);
4728     MsiRecordSetStringA(rec, 2, "two");
4729
4730     query = "UPDATE `Apple` SET `Pear` = ? WHERE `Orange` = ?";
4731     r = run_query(hdb, rec, query);
4732     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4733
4734     MsiCloseHandle(rec);
4735
4736     query = "SELECT `Pear` FROM `Apple` ORDER BY `Orange`";
4737     r = MsiDatabaseOpenViewA(hdb, query, &view);
4738     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4739     r = MsiViewExecute(view, 0);
4740     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4741
4742     r = MsiViewFetch(view, &rec);
4743     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4744
4745     r = MsiRecordGetInteger(rec, 1);
4746     ok(r == 8, "Expected 8, got %d\n", r);
4747
4748     MsiCloseHandle(rec);
4749
4750     r = MsiViewFetch(view, &rec);
4751     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4752
4753     r = MsiRecordGetInteger(rec, 1);
4754     ok(r == 8, "Expected 8, got %d\n", r);
4755
4756     MsiCloseHandle(rec);
4757
4758     r = MsiViewFetch(view, &rec);
4759     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4760
4761     r = MsiRecordGetInteger(rec, 1);
4762     ok(r == 5, "Expected 5, got %d\n", r);
4763
4764     MsiCloseHandle(rec);
4765
4766     r = MsiViewFetch(view, &rec);
4767     ok(r == ERROR_NO_MORE_ITEMS, "Expectd ERROR_NO_MORE_ITEMS, got %d\n", r);
4768
4769     MsiViewClose(view);
4770     MsiCloseHandle(view);
4771
4772     r = MsiDatabaseCommit(hdb);
4773     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
4774     r = MsiCloseHandle(hdb);
4775     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4776
4777     DeleteFileA(msifile);
4778 }
4779
4780 static void test_special_tables(void)
4781 {
4782     const char *query;
4783     MSIHANDLE hdb = 0;
4784     UINT r;
4785
4786     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4787     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4788
4789     query = "CREATE TABLE `_Properties` ( "
4790         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4791     r = run_query(hdb, 0, query);
4792     ok(r == ERROR_SUCCESS, "failed to create table\n");
4793
4794     query = "CREATE TABLE `_Storages` ( "
4795         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4796     r = run_query(hdb, 0, query);
4797     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
4798
4799     query = "CREATE TABLE `_Streams` ( "
4800         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4801     r = run_query(hdb, 0, query);
4802     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
4803
4804     query = "CREATE TABLE `_Tables` ( "
4805         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4806     r = run_query(hdb, 0, query);
4807     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Tables table\n");
4808
4809     query = "CREATE TABLE `_Columns` ( "
4810         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4811     r = run_query(hdb, 0, query);
4812     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Columns table\n");
4813
4814     r = MsiCloseHandle(hdb);
4815     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4816 }
4817
4818 static void test_tables_order(void)
4819 {
4820     const char *query;
4821     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4822     UINT r;
4823     char buffer[100];
4824     DWORD sz;
4825
4826     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4827     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4828
4829     query = "CREATE TABLE `foo` ( "
4830         "`baz` INT NOT NULL PRIMARY KEY `baz`)";
4831     r = run_query(hdb, 0, query);
4832     ok(r == ERROR_SUCCESS, "failed to create table\n");
4833
4834     query = "CREATE TABLE `bar` ( "
4835         "`foo` INT NOT NULL PRIMARY KEY `foo`)";
4836     r = run_query(hdb, 0, query);
4837     ok(r == ERROR_SUCCESS, "failed to create table\n");
4838
4839     query = "CREATE TABLE `baz` ( "
4840         "`bar` INT NOT NULL, "
4841         "`baz` INT NOT NULL, "
4842         "`foo` INT NOT NULL PRIMARY KEY `bar`)";
4843     r = run_query(hdb, 0, query);
4844     ok(r == ERROR_SUCCESS, "failed to create table\n");
4845
4846     /* The names of the tables in the _Tables table must
4847        be in the same order as these names are created in
4848        the strings table. */
4849     query = "SELECT * FROM `_Tables`";
4850     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4851     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4852     r = MsiViewExecute(hview, 0);
4853     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4854
4855     r = MsiViewFetch(hview, &hrec);
4856     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4857     sz = sizeof(buffer);
4858     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4859     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4860     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4861     r = MsiCloseHandle(hrec);
4862     ok(r == ERROR_SUCCESS, "failed to close record\n");
4863
4864     r = MsiViewFetch(hview, &hrec);
4865     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4866     sz = sizeof(buffer);
4867     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4868     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4869     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4870     r = MsiCloseHandle(hrec);
4871     ok(r == ERROR_SUCCESS, "failed to close record\n");
4872
4873     r = MsiViewFetch(hview, &hrec);
4874     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4875     sz = sizeof(buffer);
4876     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4877     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4878     ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
4879     r = MsiCloseHandle(hrec);
4880     ok(r == ERROR_SUCCESS, "failed to close record\n");
4881
4882     r = MsiViewClose(hview);
4883     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4884     r = MsiCloseHandle(hview);
4885     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4886
4887     /* The names of the tables in the _Columns table must
4888        be in the same order as these names are created in
4889        the strings table. */
4890     query = "SELECT * FROM `_Columns`";
4891     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4892     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4893     r = MsiViewExecute(hview, 0);
4894     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4895
4896     r = MsiViewFetch(hview, &hrec);
4897     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4898     sz = sizeof(buffer);
4899     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4900     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4901     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4902     sz = sizeof(buffer);
4903     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4904     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4905     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4906     r = MsiCloseHandle(hrec);
4907     ok(r == ERROR_SUCCESS, "failed to close record\n");
4908
4909     r = MsiViewFetch(hview, &hrec);
4910     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4911     sz = sizeof(buffer);
4912     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4913     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4914     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4915     sz = sizeof(buffer);
4916     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4917     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4918     ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
4919     r = MsiCloseHandle(hrec);
4920     ok(r == ERROR_SUCCESS, "failed to close record\n");
4921
4922     r = MsiViewFetch(hview, &hrec);
4923     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4924     sz = sizeof(buffer);
4925     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4926     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4927     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4928     sz = sizeof(buffer);
4929     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4930     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4931     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4932     r = MsiCloseHandle(hrec);
4933     ok(r == ERROR_SUCCESS, "failed to close record\n");
4934
4935     r = MsiViewFetch(hview, &hrec);
4936     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4937     sz = sizeof(buffer);
4938     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4939     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4940     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4941     sz = sizeof(buffer);
4942     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4943     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4944     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4945     r = MsiCloseHandle(hrec);
4946     ok(r == ERROR_SUCCESS, "failed to close record\n");
4947
4948     r = MsiViewFetch(hview, &hrec);
4949     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4950     sz = sizeof(buffer);
4951     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4952     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4953     ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
4954     sz = sizeof(buffer);
4955     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4956     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4957     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4958     r = MsiCloseHandle(hrec);
4959     ok(r == ERROR_SUCCESS, "failed to close record\n");
4960
4961     r = MsiViewClose(hview);
4962     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4963     r = MsiCloseHandle(hview);
4964     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4965
4966     r = MsiCloseHandle(hdb);
4967     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4968
4969     DeleteFileA(msifile);
4970 }
4971
4972 static void test_rows_order(void)
4973 {
4974     const char *query;
4975     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4976     UINT r;
4977     char buffer[100];
4978     DWORD sz;
4979
4980     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4981     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4982
4983     query = "CREATE TABLE `foo` ( "
4984         "`bar` LONGCHAR NOT NULL PRIMARY KEY `bar`)";
4985     r = run_query(hdb, 0, query);
4986     ok(r == ERROR_SUCCESS, "failed to create table\n");
4987
4988     r = run_query(hdb, 0, "INSERT INTO `foo` "
4989             "( `bar` ) VALUES ( 'A' )");
4990     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4991
4992     r = run_query(hdb, 0, "INSERT INTO `foo` "
4993             "( `bar` ) VALUES ( 'B' )");
4994     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4995
4996     r = run_query(hdb, 0, "INSERT INTO `foo` "
4997             "( `bar` ) VALUES ( 'C' )");
4998     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4999
5000     r = run_query(hdb, 0, "INSERT INTO `foo` "
5001             "( `bar` ) VALUES ( 'D' )");
5002     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5003
5004     r = run_query(hdb, 0, "INSERT INTO `foo` "
5005             "( `bar` ) VALUES ( 'E' )");
5006     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5007
5008     r = run_query(hdb, 0, "INSERT INTO `foo` "
5009             "( `bar` ) VALUES ( 'F' )");
5010     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5011
5012     query = "CREATE TABLE `bar` ( "
5013         "`foo` LONGCHAR NOT NULL, "
5014         "`baz` LONGCHAR NOT NULL "
5015         "PRIMARY KEY `foo` )";
5016     r = run_query(hdb, 0, query);
5017     ok(r == ERROR_SUCCESS, "failed to create table\n");
5018
5019     r = run_query(hdb, 0, "INSERT INTO `bar` "
5020             "( `foo`, `baz` ) VALUES ( 'C', 'E' )");
5021     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5022
5023     r = run_query(hdb, 0, "INSERT INTO `bar` "
5024             "( `foo`, `baz` ) VALUES ( 'F', 'A' )");
5025     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5026
5027     r = run_query(hdb, 0, "INSERT INTO `bar` "
5028             "( `foo`, `baz` ) VALUES ( 'A', 'B' )");
5029     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5030
5031     r = run_query(hdb, 0, "INSERT INTO `bar` "
5032             "( `foo`, `baz` ) VALUES ( 'D', 'E' )");
5033     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
5034
5035     /* The rows of the table must be ordered by the column values of
5036        each row. For strings, the column value is the string id
5037        in the string table.  */
5038
5039     query = "SELECT * FROM `bar`";
5040     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5041     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5042     r = MsiViewExecute(hview, 0);
5043     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5044
5045     r = MsiViewFetch(hview, &hrec);
5046     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5047     sz = sizeof(buffer);
5048     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5049     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5050     ok(!lstrcmpA(buffer, "A"), "Expected A, got %s\n", buffer);
5051     sz = sizeof(buffer);
5052     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5053     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5054     ok(!lstrcmpA(buffer, "B"), "Expected B, got %s\n", buffer);
5055     r = MsiCloseHandle(hrec);
5056     ok(r == ERROR_SUCCESS, "failed to close record\n");
5057
5058     r = MsiViewFetch(hview, &hrec);
5059     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5060     sz = sizeof(buffer);
5061     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5062     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5063     ok(!lstrcmpA(buffer, "C"), "Expected E, got %s\n", buffer);
5064     sz = sizeof(buffer);
5065     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5066     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5067     ok(!lstrcmpA(buffer, "E"), "Expected E, got %s\n", buffer);
5068     r = MsiCloseHandle(hrec);
5069     ok(r == ERROR_SUCCESS, "failed to close record\n");
5070
5071     r = MsiViewFetch(hview, &hrec);
5072     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5073     sz = sizeof(buffer);
5074     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5075     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5076     ok(!lstrcmpA(buffer, "D"), "Expected D, got %s\n", buffer);
5077     sz = sizeof(buffer);
5078     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5079     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5080     ok(!lstrcmpA(buffer, "E"), "Expected E, got %s\n", buffer);
5081     r = MsiCloseHandle(hrec);
5082     ok(r == ERROR_SUCCESS, "failed to close record\n");
5083
5084     r = MsiViewFetch(hview, &hrec);
5085     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5086     sz = sizeof(buffer);
5087     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5088     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5089     ok(!lstrcmpA(buffer, "F"), "Expected F, got %s\n", buffer);
5090     sz = sizeof(buffer);
5091     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5092     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5093     ok(!lstrcmpA(buffer, "A"), "Expected A, got %s\n", buffer);
5094     r = MsiCloseHandle(hrec);
5095     ok(r == ERROR_SUCCESS, "failed to close record\n");
5096
5097     r = MsiViewClose(hview);
5098     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5099     r = MsiCloseHandle(hview);
5100     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5101
5102     r = MsiCloseHandle(hdb);
5103     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5104
5105     DeleteFileA(msifile);
5106 }
5107
5108 static void test_collation(void)
5109 {
5110     static const WCHAR query1[] =
5111         {'I','N','S','E','R','T',' ','I','N','T','O',' ','`','b','a','r','`',' ',
5112          '(','`','f','o','o','`',',','`','b','a','z','`',')',' ','V','A','L','U','E','S',' ',
5113          '(','\'','a',0x30a,'\'',',','\'','C','\'',')',0};
5114     static const WCHAR query2[] =
5115         {'I','N','S','E','R','T',' ','I','N','T','O',' ','`','b','a','r','`',' ',
5116          '(','`','f','o','o','`',',','`','b','a','z','`',')',' ','V','A','L','U','E','S',' ',
5117          '(','\'',0xe5,'\'',',','\'','D','\'',')',0};
5118     static const WCHAR query3[] =
5119         {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','b','a','z','`',' ',
5120          '(',' ','`','a',0x30a,'`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ','N','U','L','L',',',
5121            ' ','`',0xe5,'`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ','N','U','L','L',' ',
5122            'P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','a',0x30a,'`',')',0};
5123     static const WCHAR query4[] =
5124         {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','a',0x30a,'`',' ',
5125          '(',' ','`','f','o','o','`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ',
5126          'N','U','L','L',' ','P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','f','o','o','`',')',0};
5127     static const WCHAR query5[] =
5128         {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`',0xe5,'`',' ',
5129          '(',' ','`','f','o','o','`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ',
5130          'N','U','L','L',' ','P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','f','o','o','`',')',0};
5131     static const WCHAR query6[] =
5132         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','`','b','a','r','`',' ','W','H','E','R','E',
5133          ' ','`','f','o','o','`',' ','=','\'',0xe5,'\'',0};
5134     static const WCHAR letter_C[] = {'C',0};
5135     static const WCHAR letter_D[] = {'D',0};
5136     static const WCHAR letter_a_ring[] = {'a',0x30a,0};
5137     static const WCHAR letter_a_with_ring[] = {0xe5,0};
5138     const char *query;
5139     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5140     UINT r;
5141     char buffer[100];
5142     WCHAR bufferW[100];
5143     DWORD sz;
5144
5145     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5146     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5147
5148     query = "CREATE TABLE `bar` ( "
5149         "`foo` LONGCHAR NOT NULL, "
5150         "`baz` LONGCHAR NOT NULL "
5151         "PRIMARY KEY `foo` )";
5152     r = run_query(hdb, 0, query);
5153     ok(r == ERROR_SUCCESS, "failed to create table\n");
5154
5155     r = run_query(hdb, 0, query);
5156     ok(r == ERROR_BAD_QUERY_SYNTAX, "wrong error %u\n", r);
5157
5158     r = run_query(hdb, 0, "INSERT INTO `bar` "
5159             "( `foo`, `baz` ) VALUES ( '\2', 'A' )");
5160     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5161
5162     r = run_query(hdb, 0, "INSERT INTO `bar` "
5163             "( `foo`, `baz` ) VALUES ( '\1', 'B' )");
5164     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5165
5166     r = run_queryW(hdb, 0, query1);
5167     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5168
5169     r = run_queryW(hdb, 0, query2);
5170     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5171
5172     r = run_queryW(hdb, 0, query3);
5173     ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
5174
5175     r = run_queryW(hdb, 0, query4);
5176     ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
5177
5178     r = run_queryW(hdb, 0, query5);
5179     ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
5180
5181     query = "SELECT * FROM `bar`";
5182     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5183     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5184     r = MsiViewExecute(hview, 0);
5185     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5186
5187     r = MsiViewFetch(hview, &hrec);
5188     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5189     sz = sizeof(buffer);
5190     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5191     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5192     ok(!lstrcmpA(buffer, "\2"), "Expected \\2, got '%s'\n", buffer);
5193     sz = sizeof(buffer);
5194     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5195     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5196     ok(!lstrcmpA(buffer, "A"), "Expected A, got '%s'\n", buffer);
5197     MsiCloseHandle(hrec);
5198
5199     r = MsiViewFetch(hview, &hrec);
5200     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5201     sz = sizeof(buffer);
5202     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5203     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5204     ok(!lstrcmpA(buffer, "\1"), "Expected \\1, got '%s'\n", buffer);
5205     sz = sizeof(buffer);
5206     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5207     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5208     ok(!lstrcmpA(buffer, "B"), "Expected B, got '%s'\n", buffer);
5209     MsiCloseHandle(hrec);
5210
5211     r = MsiViewFetch(hview, &hrec);
5212     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5213     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5214     r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
5215     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5216     ok(!memcmp(bufferW, letter_a_ring, sizeof(letter_a_ring)),
5217        "Expected %s, got %s\n", wine_dbgstr_w(letter_a_ring), wine_dbgstr_w(bufferW));
5218     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5219     r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
5220     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5221     ok(!lstrcmpW(bufferW, letter_C), "Expected C, got %s\n", wine_dbgstr_w(bufferW));
5222     MsiCloseHandle(hrec);
5223
5224     r = MsiViewFetch(hview, &hrec);
5225     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5226     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5227     r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
5228     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5229     ok(!memcmp(bufferW, letter_a_with_ring, sizeof(letter_a_with_ring)),
5230        "Expected %s, got %s\n", wine_dbgstr_w(letter_a_with_ring), wine_dbgstr_w(bufferW));
5231     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5232     r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
5233     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5234     ok(!lstrcmpW(bufferW, letter_D), "Expected D, got %s\n", wine_dbgstr_w(bufferW));
5235     MsiCloseHandle(hrec);
5236
5237     r = MsiViewClose(hview);
5238     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5239     r = MsiCloseHandle(hview);
5240     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5241
5242     r = MsiDatabaseOpenViewW(hdb, query6, &hview);
5243     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5244     r = MsiViewExecute(hview, 0);
5245     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5246
5247     r = MsiViewFetch(hview, &hrec);
5248     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5249     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5250     r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
5251     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5252     ok(!memcmp(bufferW, letter_a_with_ring, sizeof(letter_a_with_ring)),
5253        "Expected %s, got %s\n", wine_dbgstr_w(letter_a_with_ring), wine_dbgstr_w(bufferW));
5254     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5255     r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
5256     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5257     ok(!lstrcmpW(bufferW, letter_D), "Expected D, got %s\n", wine_dbgstr_w(bufferW));
5258     MsiCloseHandle(hrec);
5259
5260     r = MsiViewFetch(hview, &hrec);
5261     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
5262
5263     r = MsiViewClose(hview);
5264     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5265     r = MsiCloseHandle(hview);
5266     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5267
5268     r = MsiCloseHandle(hdb);
5269     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5270
5271     DeleteFileA(msifile);
5272 }
5273
5274 static void test_select_markers(void)
5275 {
5276     MSIHANDLE hdb = 0, rec, view, res;
5277     LPCSTR query;
5278     UINT r;
5279     DWORD size;
5280     CHAR buf[MAX_PATH];
5281
5282     hdb = create_db();
5283     ok( hdb, "failed to create db\n");
5284
5285     r = run_query(hdb, 0,
5286             "CREATE TABLE `Table` (`One` CHAR(72), `Two` CHAR(72), `Three` SHORT PRIMARY KEY `One`, `Two`, `Three`)");
5287     ok(r == S_OK, "cannot create table: %d\n", r);
5288
5289     r = run_query(hdb, 0, "INSERT INTO `Table` "
5290             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'one', 1 )");
5291     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5292
5293     r = run_query(hdb, 0, "INSERT INTO `Table` "
5294             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 1 )");
5295     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5296
5297     r = run_query(hdb, 0, "INSERT INTO `Table` "
5298             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 2 )");
5299     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5300
5301     r = run_query(hdb, 0, "INSERT INTO `Table` "
5302             "( `One`, `Two`, `Three` ) VALUES ( 'banana', 'three', 3 )");
5303     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5304
5305     rec = MsiCreateRecord(2);
5306     MsiRecordSetStringA(rec, 1, "apple");
5307     MsiRecordSetStringA(rec, 2, "two");
5308
5309     query = "SELECT * FROM `Table` WHERE `One`=? AND `Two`=? ORDER BY `Three`";
5310     r = MsiDatabaseOpenViewA(hdb, query, &view);
5311     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5312
5313     r = MsiViewExecute(view, rec);
5314     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5315
5316     r = MsiViewFetch(view, &res);
5317     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5318
5319     size = MAX_PATH;
5320     r = MsiRecordGetStringA(res, 1, buf, &size);
5321     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5322     ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
5323
5324     size = MAX_PATH;
5325     r = MsiRecordGetStringA(res, 2, buf, &size);
5326     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5327     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5328
5329     r = MsiRecordGetInteger(res, 3);
5330     ok(r == 1, "Expected 1, got %d\n", r);
5331
5332     MsiCloseHandle(res);
5333
5334     r = MsiViewFetch(view, &res);
5335     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5336
5337     size = MAX_PATH;
5338     r = MsiRecordGetStringA(res, 1, buf, &size);
5339     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5340     ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
5341
5342     size = MAX_PATH;
5343     r = MsiRecordGetStringA(res, 2, buf, &size);
5344     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5345     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5346
5347     r = MsiRecordGetInteger(res, 3);
5348     ok(r == 2, "Expected 2, got %d\n", r);
5349
5350     MsiCloseHandle(res);
5351
5352     r = MsiViewFetch(view, &res);
5353     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5354
5355     MsiCloseHandle(rec);
5356     MsiViewClose(view);
5357     MsiCloseHandle(view);
5358
5359     rec = MsiCreateRecord(2);
5360     MsiRecordSetStringA(rec, 1, "one");
5361     MsiRecordSetInteger(rec, 2, 1);
5362
5363     query = "SELECT * FROM `Table` WHERE `Two`<>? AND `Three`>? ORDER BY `Three`";
5364     r = MsiDatabaseOpenViewA(hdb, query, &view);
5365     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5366     r = MsiViewExecute(view, rec);
5367     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5368
5369     r = MsiViewFetch(view, &res);
5370     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5371
5372     size = MAX_PATH;
5373     r = MsiRecordGetStringA(res, 1, buf, &size);
5374     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5375     ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
5376
5377     size = MAX_PATH;
5378     r = MsiRecordGetStringA(res, 2, buf, &size);
5379     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5380     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5381
5382     r = MsiRecordGetInteger(res, 3);
5383     ok(r == 2, "Expected 2, got %d\n", r);
5384
5385     MsiCloseHandle(res);
5386
5387     r = MsiViewFetch(view, &res);
5388     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5389
5390     size = MAX_PATH;
5391     r = MsiRecordGetStringA(res, 1, buf, &size);
5392     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5393     ok(!lstrcmpA(buf, "banana"), "Expected banana, got %s\n", buf);
5394
5395     size = MAX_PATH;
5396     r = MsiRecordGetStringA(res, 2, buf, &size);
5397     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5398     ok(!lstrcmpA(buf, "three"), "Expected three, got %s\n", buf);
5399
5400     r = MsiRecordGetInteger(res, 3);
5401     ok(r == 3, "Expected 3, got %d\n", r);
5402
5403     MsiCloseHandle(res);
5404
5405     r = MsiViewFetch(view, &res);
5406     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5407
5408     MsiCloseHandle(rec);
5409     MsiViewClose(view);
5410     MsiCloseHandle(view);
5411     MsiCloseHandle(hdb);
5412     DeleteFileA(msifile);
5413 }
5414
5415 static void test_viewmodify_update(void)
5416 {
5417     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5418     UINT i, test_max, offset, count;
5419     const char *query;
5420     UINT r;
5421
5422     DeleteFileA(msifile);
5423
5424     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5425     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5426
5427     query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
5428     r = run_query( hdb, 0, query );
5429     ok(r == ERROR_SUCCESS, "query failed\n");
5430
5431     query = "INSERT INTO `table` (`A`, `B`) VALUES (1, 2)";
5432     r = run_query( hdb, 0, query );
5433     ok(r == ERROR_SUCCESS, "query failed\n");
5434
5435     query = "INSERT INTO `table` (`A`, `B`) VALUES (3, 4)";
5436     r = run_query( hdb, 0, query );
5437     ok(r == ERROR_SUCCESS, "query failed\n");
5438
5439     query = "INSERT INTO `table` (`A`, `B`) VALUES (5, 6)";
5440     r = run_query( hdb, 0, query );
5441     ok(r == ERROR_SUCCESS, "query failed\n");
5442
5443     query = "SELECT `B` FROM `table`";
5444     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5445     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5446     r = MsiViewExecute(hview, 0);
5447     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5448     r = MsiViewFetch(hview, &hrec);
5449     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5450
5451     r = MsiRecordSetInteger(hrec, 1, 0);
5452     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5453
5454     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
5455     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5456
5457     r = MsiCloseHandle(hrec);
5458     ok(r == ERROR_SUCCESS, "failed to close record\n");
5459
5460     r = MsiViewClose(hview);
5461     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5462     r = MsiCloseHandle(hview);
5463     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5464
5465     query = "SELECT * FROM `table`";
5466     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5467     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5468     r = MsiViewExecute(hview, 0);
5469     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5470     r = MsiViewFetch(hview, &hrec);
5471     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5472
5473     r = MsiRecordGetInteger(hrec, 1);
5474     ok(r == 1, "Expected 1, got %d\n", r);
5475     r = MsiRecordGetInteger(hrec, 2);
5476     ok(r == 0, "Expected 0, got %d\n", r);
5477
5478     r = MsiCloseHandle(hrec);
5479     ok(r == ERROR_SUCCESS, "failed to close record\n");
5480
5481     r = MsiViewFetch(hview, &hrec);
5482     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5483
5484     r = MsiRecordGetInteger(hrec, 1);
5485     ok(r == 3, "Expected 3, got %d\n", r);
5486     r = MsiRecordGetInteger(hrec, 2);
5487     ok(r == 4, "Expected 4, got %d\n", r);
5488
5489     r = MsiCloseHandle(hrec);
5490     ok(r == ERROR_SUCCESS, "failed to close record\n");
5491
5492     r = MsiViewFetch(hview, &hrec);
5493     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5494
5495     r = MsiRecordGetInteger(hrec, 1);
5496     ok(r == 5, "Expected 5, got %d\n", r);
5497     r = MsiRecordGetInteger(hrec, 2);
5498     ok(r == 6, "Expected 6, got %d\n", r);
5499
5500     r = MsiCloseHandle(hrec);
5501     ok(r == ERROR_SUCCESS, "failed to close record\n");
5502
5503     r = MsiViewFetch(hview, &hrec);
5504     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5505
5506     r = MsiViewClose(hview);
5507     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5508     r = MsiCloseHandle(hview);
5509     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5510
5511     /* loop through all elements */
5512     query = "SELECT `B` FROM `table`";
5513     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5514     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5515     r = MsiViewExecute(hview, 0);
5516     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5517
5518     while (TRUE)
5519     {
5520         r = MsiViewFetch(hview, &hrec);
5521         if (r != ERROR_SUCCESS)
5522             break;
5523
5524         r = MsiRecordSetInteger(hrec, 1, 0);
5525         ok(r == ERROR_SUCCESS, "failed to set integer\n");
5526
5527         r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
5528         ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5529
5530         r = MsiCloseHandle(hrec);
5531         ok(r == ERROR_SUCCESS, "failed to close record\n");
5532     }
5533
5534     r = MsiViewClose(hview);
5535     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5536     r = MsiCloseHandle(hview);
5537     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5538
5539     query = "SELECT * FROM `table`";
5540     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5541     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5542     r = MsiViewExecute(hview, 0);
5543     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5544     r = MsiViewFetch(hview, &hrec);
5545     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5546
5547     r = MsiRecordGetInteger(hrec, 1);
5548     ok(r == 1, "Expected 1, got %d\n", r);
5549     r = MsiRecordGetInteger(hrec, 2);
5550     ok(r == 0, "Expected 0, got %d\n", r);
5551
5552     r = MsiCloseHandle(hrec);
5553     ok(r == ERROR_SUCCESS, "failed to close record\n");
5554
5555     r = MsiViewFetch(hview, &hrec);
5556     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5557
5558     r = MsiRecordGetInteger(hrec, 1);
5559     ok(r == 3, "Expected 3, got %d\n", r);
5560     r = MsiRecordGetInteger(hrec, 2);
5561     ok(r == 0, "Expected 0, got %d\n", r);
5562
5563     r = MsiCloseHandle(hrec);
5564     ok(r == ERROR_SUCCESS, "failed to close record\n");
5565
5566     r = MsiViewFetch(hview, &hrec);
5567     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5568
5569     r = MsiRecordGetInteger(hrec, 1);
5570     ok(r == 5, "Expected 5, got %d\n", r);
5571     r = MsiRecordGetInteger(hrec, 2);
5572     ok(r == 0, "Expected 0, got %d\n", r);
5573
5574     r = MsiCloseHandle(hrec);
5575     ok(r == ERROR_SUCCESS, "failed to close record\n");
5576
5577     r = MsiViewFetch(hview, &hrec);
5578     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5579
5580     r = MsiViewClose(hview);
5581     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5582     r = MsiCloseHandle(hview);
5583     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5584
5585     query = "CREATE TABLE `table2` (`A` INT, `B` INT PRIMARY KEY `A`)";
5586     r = run_query( hdb, 0, query );
5587     ok(r == ERROR_SUCCESS, "query failed\n");
5588
5589     query = "INSERT INTO `table2` (`A`, `B`) VALUES (?, ?)";
5590     r = MsiDatabaseOpenViewA( hdb, query, &hview );
5591     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5592
5593     test_max = 100;
5594     offset = 1234;
5595     for(i = 0; i < test_max; i++)
5596     {
5597
5598         hrec = MsiCreateRecord( 2 );
5599         MsiRecordSetInteger( hrec, 1, test_max - i );
5600         MsiRecordSetInteger( hrec, 2, i );
5601
5602         r = MsiViewExecute( hview, hrec );
5603         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5604
5605         r = MsiCloseHandle( hrec );
5606         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5607     }
5608
5609     r = MsiViewClose( hview );
5610     ok(r == ERROR_SUCCESS, "Got %d\n", r);
5611     r = MsiCloseHandle( hview );
5612     ok(r == ERROR_SUCCESS, "Got %d\n", r);
5613
5614     /* Update. */
5615     query = "SELECT * FROM `table2` ORDER BY `B`";
5616     r = MsiDatabaseOpenViewA( hdb, query, &hview);
5617     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5618     r = MsiViewExecute( hview, 0 );
5619     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5620
5621     count = 0;
5622     while (MsiViewFetch( hview, &hrec ) == ERROR_SUCCESS)
5623     {
5624         UINT b = MsiRecordGetInteger( hrec, 2 );
5625
5626         r = MsiRecordSetInteger( hrec, 2, b + offset);
5627         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5628
5629         r = MsiViewModify( hview, MSIMODIFY_UPDATE, hrec );
5630         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5631
5632         r = MsiCloseHandle(hrec);
5633         ok(r == ERROR_SUCCESS, "failed to close record\n");
5634         count++;
5635     }
5636     ok(count == test_max, "Got count %d\n", count);
5637
5638     r = MsiViewClose(hview);
5639     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5640     r = MsiCloseHandle(hview);
5641     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5642
5643     /* Recheck. */
5644     query = "SELECT * FROM `table2` ORDER BY `B`";
5645     r = MsiDatabaseOpenViewA( hdb, query, &hview);
5646     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5647     r = MsiViewExecute( hview, 0 );
5648     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5649
5650     count = 0;
5651     while (MsiViewFetch( hview, &hrec ) == ERROR_SUCCESS)
5652     {
5653         UINT a = MsiRecordGetInteger( hrec, 1 );
5654         UINT b = MsiRecordGetInteger( hrec, 2 );
5655         ok( ( test_max - a + offset) == b, "Got (%d, %d), expected (%d, %d)\n",
5656             a, b, test_max - a + offset, b);
5657
5658         r = MsiCloseHandle(hrec);
5659         ok(r == ERROR_SUCCESS, "failed to close record\n");
5660         count++;
5661     }
5662     ok(count == test_max, "Got count %d\n", count);
5663
5664     r = MsiViewClose(hview);
5665     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5666     r = MsiCloseHandle(hview);
5667     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5668
5669     r = MsiCloseHandle( hdb );
5670     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
5671 }
5672
5673 static void test_viewmodify_assign(void)
5674 {
5675     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5676     const char *query;
5677     UINT r;
5678
5679     /* setup database */
5680     DeleteFileA(msifile);
5681
5682     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5683     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5684
5685     query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
5686     r = run_query( hdb, 0, query );
5687     ok(r == ERROR_SUCCESS, "query failed\n");
5688
5689     /* assign to view, new primary key */
5690     query = "SELECT * FROM `table`";
5691     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5692     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5693     r = MsiViewExecute(hview, 0);
5694     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5695
5696     hrec = MsiCreateRecord(2);
5697     ok(hrec != 0, "MsiCreateRecord failed\n");
5698
5699     r = MsiRecordSetInteger(hrec, 1, 1);
5700     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5701     r = MsiRecordSetInteger(hrec, 2, 2);
5702     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5703
5704     r = MsiViewModify(hview, MSIMODIFY_ASSIGN, hrec);
5705     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5706
5707     r = MsiCloseHandle(hrec);
5708     ok(r == ERROR_SUCCESS, "failed to close record\n");
5709
5710     r = MsiViewClose(hview);
5711     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5712     r = MsiCloseHandle(hview);
5713     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5714
5715     query = "SELECT * FROM `table`";
5716     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5717     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5718     r = MsiViewExecute(hview, 0);
5719     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5720     r = MsiViewFetch(hview, &hrec);
5721     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5722
5723     r = MsiRecordGetInteger(hrec, 1);
5724     ok(r == 1, "Expected 1, got %d\n", r);
5725     r = MsiRecordGetInteger(hrec, 2);
5726     ok(r == 2, "Expected 2, got %d\n", r);
5727
5728     r = MsiCloseHandle(hrec);
5729     ok(r == ERROR_SUCCESS, "failed to close record\n");
5730
5731     r = MsiViewFetch(hview, &hrec);
5732     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5733
5734     r = MsiViewClose(hview);
5735     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5736     r = MsiCloseHandle(hview);
5737     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5738
5739     /* assign to view, primary key matches */
5740     query = "SELECT * FROM `table`";
5741     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5742     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5743     r = MsiViewExecute(hview, 0);
5744     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5745
5746     hrec = MsiCreateRecord(2);
5747     ok(hrec != 0, "MsiCreateRecord failed\n");
5748
5749     r = MsiRecordSetInteger(hrec, 1, 1);
5750     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5751     r = MsiRecordSetInteger(hrec, 2, 4);
5752     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5753
5754     r = MsiViewModify(hview, MSIMODIFY_ASSIGN, hrec);
5755     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5756
5757     r = MsiCloseHandle(hrec);
5758     ok(r == ERROR_SUCCESS, "failed to close record\n");
5759
5760     r = MsiViewClose(hview);
5761     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5762     r = MsiCloseHandle(hview);
5763     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5764
5765     query = "SELECT * FROM `table`";
5766     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5767     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5768     r = MsiViewExecute(hview, 0);
5769     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5770     r = MsiViewFetch(hview, &hrec);
5771     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5772
5773     r = MsiRecordGetInteger(hrec, 1);
5774     ok(r == 1, "Expected 1, got %d\n", r);
5775     r = MsiRecordGetInteger(hrec, 2);
5776     ok(r == 4, "Expected 4, got %d\n", r);
5777
5778     r = MsiCloseHandle(hrec);
5779     ok(r == ERROR_SUCCESS, "failed to close record\n");
5780
5781     r = MsiViewFetch(hview, &hrec);
5782     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5783
5784     r = MsiViewClose(hview);
5785     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5786     r = MsiCloseHandle(hview);
5787     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5788
5789     /* close database */
5790     r = MsiCloseHandle( hdb );
5791     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
5792 }
5793
5794 static const WCHAR data10[] = { /* MOO */
5795     0x8001, 0x000b,
5796 };
5797 static const WCHAR data11[] = { /* AAR */
5798     0x8002, 0x8005,
5799     0x000c, 0x000f,
5800 };
5801 static const char data12[] = /* _StringData */
5802     "MOOABAARCDonetwofourfive";
5803 static const WCHAR data13[] = { /* _StringPool */
5804 /*  len, refs */
5805     0,   0,    /* string 0 ''     */
5806     0,   0,    /* string 1 ''     */
5807     0,   0,    /* string 2 ''     */
5808     0,   0,    /* string 3 ''     */
5809     0,   0,    /* string 4 ''     */
5810     3,   3,    /* string 5 'MOO'  */
5811     1,   1,    /* string 6 'A'    */
5812     1,   1,    /* string 7 'B'    */
5813     3,   3,    /* string 8 'AAR'  */
5814     1,   1,    /* string 9 'C'    */
5815     1,   1,    /* string a 'D'    */
5816     3,   1,    /* string b 'one'  */
5817     3,   1,    /* string c 'two'  */
5818     0,   0,    /* string d ''     */
5819     4,   1,    /* string e 'four' */
5820     4,   1,    /* string f 'five' */
5821 };
5822
5823 static void test_stringtable(void)
5824 {
5825     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5826     IStorage *stg = NULL;
5827     IStream *stm;
5828     WCHAR name[0x20];
5829     HRESULT hr;
5830     const char *query;
5831     char buffer[MAX_PATH];
5832     WCHAR data[MAX_PATH];
5833     DWORD sz, read;
5834     UINT r;
5835
5836     static const DWORD mode = STGM_DIRECT | STGM_READ | STGM_SHARE_DENY_WRITE;
5837     static const WCHAR stringdata[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0}; /* _StringData */
5838     static const WCHAR stringpool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0}; /* _StringPool */
5839     static const WCHAR moo[] = {0x4840, 0x3e16, 0x4818, 0}; /* MOO */
5840     static const WCHAR aar[] = {0x4840, 0x3a8a, 0x481b, 0}; /* AAR */
5841
5842     DeleteFileA(msifile);
5843
5844     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5845     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5846
5847     query = "CREATE TABLE `MOO` (`A` INT, `B` CHAR(72) PRIMARY KEY `A`)";
5848     r = run_query(hdb, 0, query);
5849     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5850
5851     query = "CREATE TABLE `AAR` (`C` INT, `D` CHAR(72) PRIMARY KEY `C`)";
5852     r = run_query(hdb, 0, query);
5853     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5854
5855     /* insert persistent row */
5856     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (1, 'one')";
5857     r = run_query(hdb, 0, query);
5858     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5859
5860     /* insert persistent row */
5861     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (2, 'two')";
5862     r = run_query(hdb, 0, query);
5863     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5864
5865     /* open a view */
5866     query = "SELECT * FROM `MOO`";
5867     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5868     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5869     r = MsiViewExecute(hview, 0);
5870     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5871
5872     hrec = MsiCreateRecord(2);
5873
5874     r = MsiRecordSetInteger(hrec, 1, 3);
5875     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5876     r = MsiRecordSetStringA(hrec, 2, "three");
5877     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5878
5879     /* insert a nonpersistent row */
5880     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
5881     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5882
5883     r = MsiCloseHandle(hrec);
5884     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5885     r = MsiViewClose(hview);
5886     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5887     r = MsiCloseHandle(hview);
5888     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5889
5890     /* insert persistent row */
5891     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (4, 'four')";
5892     r = run_query(hdb, 0, query);
5893     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5894
5895     /* insert persistent row */
5896     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (5, 'five')";
5897     r = run_query(hdb, 0, query);
5898     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5899
5900     r = MsiDatabaseCommit(hdb);
5901     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5902
5903     r = MsiCloseHandle(hdb);
5904     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5905
5906     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
5907     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5908
5909     query = "SELECT * FROM `MOO`";
5910     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5911     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5912
5913     r = MsiViewExecute(hview, 0);
5914     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5915
5916     r = MsiViewFetch(hview, &hrec);
5917     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5918
5919     r = MsiRecordGetFieldCount(hrec);
5920     ok(r == 2, "Expected 2, got %d\n", r);
5921
5922     r = MsiRecordGetInteger(hrec, 1);
5923     ok(r == 1, "Expected 1, got %d\n", r);
5924
5925     sz = sizeof(buffer);
5926     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5927     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5928     ok(!lstrcmpA(buffer, "one"), "Expected one, got '%s'\n", buffer);
5929
5930     r = MsiCloseHandle(hrec);
5931     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5932
5933     r = MsiViewFetch(hview, &hrec);
5934     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5935
5936     r = MsiViewClose(hview);
5937     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5938     r = MsiCloseHandle(hview);
5939     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5940     r = MsiCloseHandle(hrec);
5941     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5942
5943     query = "SELECT * FROM `AAR`";
5944     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5945     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5946
5947     r = MsiViewExecute(hview, 0);
5948     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5949
5950     r = MsiViewFetch(hview, &hrec);
5951     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5952
5953     r = MsiRecordGetFieldCount(hrec);
5954     ok(r == 2, "Expected 2, got %d\n", r);
5955
5956     r = MsiRecordGetInteger(hrec, 1);
5957     ok(r == 2, "Expected 2, got %d\n", r);
5958
5959     sz = sizeof(buffer);
5960     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5961     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5962     ok(!lstrcmpA(buffer, "two"), "Expected two, got '%s'\n", buffer);
5963
5964     r = MsiCloseHandle(hrec);
5965     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5966
5967     r = MsiViewFetch(hview, &hrec);
5968     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5969
5970     r = MsiRecordGetFieldCount(hrec);
5971     ok(r == 2, "Expected 2, got %d\n", r);
5972
5973     r = MsiRecordGetInteger(hrec, 1);
5974     ok(r == 5, "Expected 5, got %d\n", r);
5975
5976     sz = sizeof(buffer);
5977     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5978     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5979     ok(!lstrcmpA(buffer, "five"), "Expected five, got '%s'\n", buffer);
5980
5981     r = MsiCloseHandle(hrec);
5982     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5983
5984     r = MsiViewFetch(hview, &hrec);
5985     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5986
5987     r = MsiViewClose(hview);
5988     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5989     r = MsiCloseHandle(hview);
5990     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5991     r = MsiCloseHandle(hrec);
5992     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5993     r = MsiCloseHandle(hdb);
5994     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5995
5996     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, 0x20);
5997     hr = StgOpenStorage(name, NULL, mode, NULL, 0, &stg);
5998     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5999     ok(stg != NULL, "Expected non-NULL storage\n");
6000
6001     hr = IStorage_OpenStream(stg, moo, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6002     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6003     ok(stm != NULL, "Expected non-NULL stream\n");
6004
6005     hr = IStream_Read(stm, data, MAX_PATH, &read);
6006     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6007     ok(read == 4, "Expected 4, got %d\n", read);
6008     todo_wine ok(!memcmp(data, data10, read), "Unexpected data\n");
6009
6010     hr = IStream_Release(stm);
6011     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6012
6013     hr = IStorage_OpenStream(stg, aar, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6014     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6015     ok(stm != NULL, "Expected non-NULL stream\n");
6016
6017     hr = IStream_Read(stm, data, MAX_PATH, &read);
6018     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6019     ok(read == 8, "Expected 8, got %d\n", read);
6020     todo_wine
6021     {
6022         ok(!memcmp(data, data11, read), "Unexpected data\n");
6023     }
6024
6025     hr = IStream_Release(stm);
6026     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6027
6028     hr = IStorage_OpenStream(stg, stringdata, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6029     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6030     ok(stm != NULL, "Expected non-NULL stream\n");
6031
6032     hr = IStream_Read(stm, buffer, MAX_PATH, &read);
6033     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6034     ok(read == 24, "Expected 24, got %d\n", read);
6035     ok(!memcmp(buffer, data12, read), "Unexpected data\n");
6036
6037     hr = IStream_Release(stm);
6038     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6039
6040     hr = IStorage_OpenStream(stg, stringpool, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6041     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6042     ok(stm != NULL, "Expected non-NULL stream\n");
6043
6044     hr = IStream_Read(stm, data, MAX_PATH, &read);
6045     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6046     todo_wine
6047     {
6048         ok(read == 64, "Expected 64, got %d\n", read);
6049         ok(!memcmp(data, data13, read), "Unexpected data\n");
6050     }
6051
6052     hr = IStream_Release(stm);
6053     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6054
6055     hr = IStorage_Release(stg);
6056     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6057
6058     DeleteFileA(msifile);
6059 }
6060
6061 static void test_viewmodify_delete(void)
6062 {
6063     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
6064     UINT r;
6065     const char *query;
6066     char buffer[0x100];
6067     DWORD sz;
6068
6069     DeleteFileA(msifile);
6070
6071     /* just MsiOpenDatabase should not create a file */
6072     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6073     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6074
6075     query = "CREATE TABLE `phone` ( "
6076             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
6077             "PRIMARY KEY `id`)";
6078     r = run_query(hdb, 0, query);
6079     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6080
6081     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
6082         "VALUES('1', 'Alan', '5030581')";
6083     r = run_query(hdb, 0, query);
6084     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6085
6086     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
6087         "VALUES('2', 'Barry', '928440')";
6088     r = run_query(hdb, 0, query);
6089     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6090
6091     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
6092         "VALUES('3', 'Cindy', '2937550')";
6093     r = run_query(hdb, 0, query);
6094     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6095
6096     query = "SELECT * FROM `phone` WHERE `id` <= 2";
6097     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6098     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6099     r = MsiViewExecute(hview, 0);
6100     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6101     r = MsiViewFetch(hview, &hrec);
6102     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6103
6104     /* delete 1 */
6105     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6106     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6107
6108     r = MsiCloseHandle(hrec);
6109     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6110     r = MsiViewFetch(hview, &hrec);
6111     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6112
6113     /* delete 2 */
6114     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6115     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6116
6117     r = MsiCloseHandle(hrec);
6118     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6119     r = MsiViewClose(hview);
6120     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6121     r = MsiCloseHandle(hview);
6122     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6123
6124     query = "SELECT * FROM `phone`";
6125     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6126     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6127     r = MsiViewExecute(hview, 0);
6128     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6129     r = MsiViewFetch(hview, &hrec);
6130     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6131
6132     r = MsiRecordGetInteger(hrec, 1);
6133     ok(r == 3, "Expected 3, got %d\n", r);
6134
6135     sz = sizeof(buffer);
6136     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
6137     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6138     ok(!lstrcmpA(buffer, "Cindy"), "Expected Cindy, got %s\n", buffer);
6139
6140     sz = sizeof(buffer);
6141     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
6142     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6143     ok(!lstrcmpA(buffer, "2937550"), "Expected 2937550, got %s\n", buffer);
6144
6145     r = MsiCloseHandle(hrec);
6146     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6147
6148     r = MsiViewFetch(hview, &hrec);
6149     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6150
6151     r = MsiViewClose(hview);
6152     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6153     r = MsiCloseHandle(hview);
6154     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6155     r = MsiCloseHandle(hdb);
6156     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6157 }
6158
6159 static const WCHAR _Tables[] = {0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0};
6160 static const WCHAR _StringData[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0};
6161 static const WCHAR _StringPool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0};
6162
6163 static const WCHAR data14[] = { /* _StringPool */
6164 /*  len, refs */
6165     0,   0,    /* string 0 ''    */
6166 };
6167
6168 static const struct {
6169     LPCWSTR name;
6170     const void *data;
6171     DWORD size;
6172 } database_table_data[] =
6173 {
6174     {_Tables, NULL, 0},
6175     {_StringData, NULL, 0},
6176     {_StringPool, data14, sizeof data14},
6177 };
6178
6179 static void enum_stream_names(IStorage *stg)
6180 {
6181     IEnumSTATSTG *stgenum = NULL;
6182     IStream *stm;
6183     HRESULT hr;
6184     STATSTG stat;
6185     ULONG n, count;
6186     BYTE data[MAX_PATH];
6187     BYTE check[MAX_PATH];
6188     DWORD sz;
6189
6190     memset(check, 'a', MAX_PATH);
6191
6192     hr = IStorage_EnumElements(stg, 0, NULL, 0, &stgenum);
6193     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6194
6195     n = 0;
6196     while(TRUE)
6197     {
6198         count = 0;
6199         hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &count);
6200         if(FAILED(hr) || !count)
6201             break;
6202
6203         ok(!lstrcmpW(stat.pwcsName, database_table_data[n].name),
6204            "Expected table %d name to match\n", n);
6205
6206         stm = NULL;
6207         hr = IStorage_OpenStream(stg, stat.pwcsName, NULL,
6208                                  STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6209         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6210         ok(stm != NULL, "Expected non-NULL stream\n");
6211
6212         CoTaskMemFree(stat.pwcsName);
6213
6214         sz = MAX_PATH;
6215         memset(data, 'a', MAX_PATH);
6216         hr = IStream_Read(stm, data, sz, &count);
6217         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6218
6219         ok(count == database_table_data[n].size,
6220            "Expected %d, got %d\n", database_table_data[n].size, count);
6221
6222         if (!database_table_data[n].size)
6223             ok(!memcmp(data, check, MAX_PATH), "data should not be changed\n");
6224         else
6225             ok(!memcmp(data, database_table_data[n].data, database_table_data[n].size),
6226                "Expected table %d data to match\n", n);
6227
6228         IStream_Release(stm);
6229         n++;
6230     }
6231
6232     ok(n == 3, "Expected 3, got %d\n", n);
6233
6234     IEnumSTATSTG_Release(stgenum);
6235 }
6236
6237 static void test_defaultdatabase(void)
6238 {
6239     UINT r;
6240     HRESULT hr;
6241     MSIHANDLE hdb;
6242     IStorage *stg = NULL;
6243
6244     DeleteFileA(msifile);
6245
6246     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6247     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6248
6249     r = MsiDatabaseCommit(hdb);
6250     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6251
6252     MsiCloseHandle(hdb);
6253
6254     hr = StgOpenStorage(msifileW, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
6255     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6256     ok(stg != NULL, "Expected non-NULL stg\n");
6257
6258     enum_stream_names(stg);
6259
6260     IStorage_Release(stg);
6261     DeleteFileA(msifile);
6262 }
6263
6264 static void test_order(void)
6265 {
6266     MSIHANDLE hdb, hview, hrec;
6267     CHAR buffer[MAX_PATH];
6268     LPCSTR query;
6269     UINT r, sz;
6270     int val;
6271
6272     hdb = create_db();
6273     ok(hdb, "failed to create db\n");
6274
6275     query = "CREATE TABLE `Empty` ( `A` SHORT NOT NULL PRIMARY KEY `A`)";
6276     r = run_query(hdb, 0, query);
6277     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6278
6279     query = "CREATE TABLE `Mesa` ( `A` SHORT NOT NULL, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
6280     r = run_query(hdb, 0, query);
6281     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6282
6283     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 1, 2, 9 )";
6284     r = run_query(hdb, 0, query);
6285     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6286
6287     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 3, 4, 7 )";
6288     r = run_query(hdb, 0, query);
6289     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6290
6291     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 5, 6, 8 )";
6292     r = run_query(hdb, 0, query);
6293     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6294
6295     query = "CREATE TABLE `Sideboard` ( `D` SHORT NOT NULL, `E` SHORT, `F` SHORT PRIMARY KEY `D`)";
6296     r = run_query(hdb, 0, query);
6297     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6298
6299     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 10, 11, 18 )";
6300     r = run_query(hdb, 0, query);
6301     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6302
6303     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 12, 13, 16 )";
6304     r = run_query(hdb, 0, query);
6305     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6306
6307     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 14, 15, 17 )";
6308     r = run_query(hdb, 0, query);
6309     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6310
6311     query = "SELECT `A`, `B` FROM `Mesa` ORDER BY `C`";
6312     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6313     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6314     r = MsiViewExecute(hview, 0);
6315     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6316
6317     r = MsiViewFetch(hview, &hrec);
6318     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6319
6320     val = MsiRecordGetInteger(hrec, 1);
6321     ok(val == 3, "Expected 3, got %d\n", val);
6322
6323     val = MsiRecordGetInteger(hrec, 2);
6324     ok(val == 4, "Expected 3, got %d\n", val);
6325
6326     MsiCloseHandle(hrec);
6327
6328     r = MsiViewFetch(hview, &hrec);
6329     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6330
6331     val = MsiRecordGetInteger(hrec, 1);
6332     ok(val == 5, "Expected 5, got %d\n", val);
6333
6334     val = MsiRecordGetInteger(hrec, 2);
6335     ok(val == 6, "Expected 6, got %d\n", val);
6336
6337     MsiCloseHandle(hrec);
6338
6339     r = MsiViewFetch(hview, &hrec);
6340     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6341
6342     val = MsiRecordGetInteger(hrec, 1);
6343     ok(val == 1, "Expected 1, got %d\n", val);
6344
6345     val = MsiRecordGetInteger(hrec, 2);
6346     ok(val == 2, "Expected 2, got %d\n", val);
6347
6348     MsiCloseHandle(hrec);
6349
6350     r = MsiViewFetch(hview, &hrec);
6351     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6352
6353     MsiViewClose(hview);
6354     MsiCloseHandle(hview);
6355
6356     query = "SELECT `A`, `D` FROM `Mesa`, `Sideboard` ORDER BY `F`";
6357     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6358     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6359     r = MsiViewExecute(hview, 0);
6360     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6361
6362     r = MsiViewFetch(hview, &hrec);
6363     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6364
6365     val = MsiRecordGetInteger(hrec, 1);
6366     ok(val == 1, "Expected 1, got %d\n", val);
6367
6368     val = MsiRecordGetInteger(hrec, 2);
6369     ok(val == 12, "Expected 12, got %d\n", val);
6370
6371     MsiCloseHandle(hrec);
6372
6373     r = MsiViewFetch(hview, &hrec);
6374     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6375
6376     val = MsiRecordGetInteger(hrec, 1);
6377     ok(val == 3, "Expected 3, got %d\n", val);
6378
6379     val = MsiRecordGetInteger(hrec, 2);
6380     ok(val == 12, "Expected 12, got %d\n", val);
6381
6382     MsiCloseHandle(hrec);
6383
6384     r = MsiViewFetch(hview, &hrec);
6385     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6386
6387     val = MsiRecordGetInteger(hrec, 1);
6388     ok(val == 5, "Expected 5, got %d\n", val);
6389
6390     val = MsiRecordGetInteger(hrec, 2);
6391     ok(val == 12, "Expected 12, got %d\n", val);
6392
6393     MsiCloseHandle(hrec);
6394
6395     r = MsiViewFetch(hview, &hrec);
6396     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6397
6398     val = MsiRecordGetInteger(hrec, 1);
6399     ok(val == 1, "Expected 1, got %d\n", val);
6400
6401     val = MsiRecordGetInteger(hrec, 2);
6402     ok(val == 14, "Expected 14, got %d\n", val);
6403
6404     MsiCloseHandle(hrec);
6405
6406     r = MsiViewFetch(hview, &hrec);
6407     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6408
6409     val = MsiRecordGetInteger(hrec, 1);
6410     ok(val == 3, "Expected 3, got %d\n", val);
6411
6412     val = MsiRecordGetInteger(hrec, 2);
6413     ok(val == 14, "Expected 14, got %d\n", val);
6414
6415     MsiCloseHandle(hrec);
6416
6417     r = MsiViewFetch(hview, &hrec);
6418     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6419
6420     val = MsiRecordGetInteger(hrec, 1);
6421     ok(val == 5, "Expected 5, got %d\n", val);
6422
6423     val = MsiRecordGetInteger(hrec, 2);
6424     ok(val == 14, "Expected 14, got %d\n", val);
6425
6426     MsiCloseHandle(hrec);
6427
6428     r = MsiViewFetch(hview, &hrec);
6429     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6430
6431     val = MsiRecordGetInteger(hrec, 1);
6432     ok(val == 1, "Expected 1, got %d\n", val);
6433
6434     val = MsiRecordGetInteger(hrec, 2);
6435     ok(val == 10, "Expected 10, got %d\n", val);
6436
6437     MsiCloseHandle(hrec);
6438
6439     r = MsiViewFetch(hview, &hrec);
6440     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6441
6442     val = MsiRecordGetInteger(hrec, 1);
6443     ok(val == 3, "Expected 3, got %d\n", val);
6444
6445     val = MsiRecordGetInteger(hrec, 2);
6446     ok(val == 10, "Expected 10, got %d\n", val);
6447
6448     MsiCloseHandle(hrec);
6449
6450     r = MsiViewFetch(hview, &hrec);
6451     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6452
6453     val = MsiRecordGetInteger(hrec, 1);
6454     ok(val == 5, "Expected 5, got %d\n", val);
6455
6456     val = MsiRecordGetInteger(hrec, 2);
6457     ok(val == 10, "Expected 10, got %d\n", val);
6458
6459     MsiCloseHandle(hrec);
6460
6461     r = MsiViewFetch(hview, &hrec);
6462     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6463
6464     MsiViewClose(hview);
6465     MsiCloseHandle(hview);
6466
6467     query = "SELECT * FROM `Empty` ORDER BY `A`";
6468     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6469     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6470     r = MsiViewExecute(hview, 0);
6471     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6472
6473     r = MsiViewFetch(hview, &hrec);
6474     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6475
6476     MsiViewClose(hview);
6477     MsiCloseHandle(hview);
6478
6479     query = "CREATE TABLE `Buffet` ( `One` CHAR(72), `Two` SHORT PRIMARY KEY `One`)";
6480     r = run_query(hdb, 0, query);
6481     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6482
6483     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'uno',  2)";
6484     r = run_query(hdb, 0, query);
6485     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6486
6487     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'dos',  3)";
6488     r = run_query(hdb, 0, query);
6489     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6490
6491     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'tres',  1)";
6492     r = run_query(hdb, 0, query);
6493     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6494
6495     query = "SELECT * FROM `Buffet` WHERE `One` = 'dos' ORDER BY `Two`";
6496     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6497     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6498     r = MsiViewExecute(hview, 0);
6499     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6500
6501     r = MsiViewFetch(hview, &hrec);
6502     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6503
6504     sz = sizeof(buffer);
6505     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
6506     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6507     ok(!lstrcmpA(buffer, "dos"), "Expected \"dos\", got \"%s\"\n", buffer);
6508
6509     r = MsiRecordGetInteger(hrec, 2);
6510     ok(r == 3, "Expected 3, got %d\n", r);
6511
6512     MsiCloseHandle(hrec);
6513
6514     r = MsiViewFetch(hview, &hrec);
6515     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6516
6517     MsiViewClose(hview);
6518     MsiCloseHandle(hview);
6519     MsiCloseHandle(hdb);
6520 }
6521
6522 static void test_viewmodify_delete_temporary(void)
6523 {
6524     MSIHANDLE hdb, hview, hrec;
6525     const char *query;
6526     UINT r;
6527
6528     DeleteFileA(msifile);
6529
6530     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6531     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6532
6533     query = "CREATE TABLE `Table` ( `A` SHORT PRIMARY KEY `A` )";
6534     r = run_query(hdb, 0, query);
6535     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6536
6537     query = "SELECT * FROM `Table`";
6538     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6539     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6540     r = MsiViewExecute(hview, 0);
6541     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6542
6543     hrec = MsiCreateRecord(1);
6544     MsiRecordSetInteger(hrec, 1, 1);
6545
6546     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
6547     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6548
6549     MsiCloseHandle(hrec);
6550
6551     hrec = MsiCreateRecord(1);
6552     MsiRecordSetInteger(hrec, 1, 2);
6553
6554     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
6555     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6556
6557     MsiCloseHandle(hrec);
6558
6559     hrec = MsiCreateRecord(1);
6560     MsiRecordSetInteger(hrec, 1, 3);
6561
6562     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
6563     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6564
6565     MsiCloseHandle(hrec);
6566
6567     hrec = MsiCreateRecord(1);
6568     MsiRecordSetInteger(hrec, 1, 4);
6569
6570     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
6571     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6572
6573     MsiCloseHandle(hrec);
6574     MsiViewClose(hview);
6575     MsiCloseHandle(hview);
6576
6577     query = "SELECT * FROM `Table` WHERE  `A` = 2";
6578     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6579     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6580     r = MsiViewExecute(hview, 0);
6581     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6582     r = MsiViewFetch(hview, &hrec);
6583     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6584
6585     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6586     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6587
6588     MsiCloseHandle(hrec);
6589     MsiViewClose(hview);
6590     MsiCloseHandle(hview);
6591
6592     query = "SELECT * FROM `Table` WHERE  `A` = 3";
6593     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6594     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6595     r = MsiViewExecute(hview, 0);
6596     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6597     r = MsiViewFetch(hview, &hrec);
6598     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6599
6600     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6601     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6602
6603     MsiCloseHandle(hrec);
6604     MsiViewClose(hview);
6605     MsiCloseHandle(hview);
6606
6607     query = "SELECT * FROM `Table` ORDER BY `A`";
6608     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6609     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6610     r = MsiViewExecute(hview, 0);
6611     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6612
6613     r = MsiViewFetch(hview, &hrec);
6614     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6615
6616     r = MsiRecordGetInteger(hrec, 1);
6617     ok(r == 1, "Expected 1, got %d\n", r);
6618
6619     MsiCloseHandle(hrec);
6620
6621     r = MsiViewFetch(hview, &hrec);
6622     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6623
6624     r = MsiRecordGetInteger(hrec, 1);
6625     ok(r == 4, "Expected 4, got %d\n", r);
6626
6627     MsiCloseHandle(hrec);
6628
6629     r = MsiViewFetch(hview, &hrec);
6630     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6631
6632     MsiViewClose(hview);
6633     MsiCloseHandle(hview);
6634     MsiCloseHandle(hdb);
6635     DeleteFileA(msifile);
6636 }
6637
6638 static void test_deleterow(void)
6639 {
6640     MSIHANDLE hdb, hview, hrec;
6641     const char *query;
6642     char buf[MAX_PATH];
6643     UINT r;
6644     DWORD size;
6645
6646     DeleteFileA(msifile);
6647
6648     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6649     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6650
6651     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6652     r = run_query(hdb, 0, query);
6653     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6654
6655     query = "INSERT INTO `Table` (`A`) VALUES ('one')";
6656     r = run_query(hdb, 0, query);
6657     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6658
6659     query = "INSERT INTO `Table` (`A`) VALUES ('two')";
6660     r = run_query(hdb, 0, query);
6661     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6662
6663     query = "DELETE FROM `Table` WHERE `A` = 'one'";
6664     r = run_query(hdb, 0, query);
6665     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6666
6667     r = MsiDatabaseCommit(hdb);
6668     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6669
6670     MsiCloseHandle(hdb);
6671
6672     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
6673     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6674
6675     query = "SELECT * FROM `Table`";
6676     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6677     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6678     r = MsiViewExecute(hview, 0);
6679     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6680
6681     r = MsiViewFetch(hview, &hrec);
6682     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6683
6684     size = MAX_PATH;
6685     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6686     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6687     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
6688
6689     MsiCloseHandle(hrec);
6690
6691     r = MsiViewFetch(hview, &hrec);
6692     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6693
6694     MsiViewClose(hview);
6695     MsiCloseHandle(hview);
6696     MsiCloseHandle(hdb);
6697     DeleteFileA(msifile);
6698 }
6699
6700 static const CHAR import_dat[] = "A\n"
6701                                  "s72\n"
6702                                  "Table\tA\n"
6703                                  "This is a new 'string' ok\n";
6704
6705 static void test_quotes(void)
6706 {
6707     MSIHANDLE hdb, hview, hrec;
6708     const char *query;
6709     char buf[MAX_PATH];
6710     UINT r;
6711     DWORD size;
6712
6713     DeleteFileA(msifile);
6714
6715     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6716     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6717
6718     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6719     r = run_query(hdb, 0, query);
6720     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6721
6722     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a 'string' ok' )";
6723     r = run_query(hdb, 0, query);
6724     ok(r == ERROR_BAD_QUERY_SYNTAX,
6725        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6726
6727     query = "INSERT INTO `Table` ( `A` ) VALUES ( \"This is a 'string' ok\" )";
6728     r = run_query(hdb, 0, query);
6729     ok(r == ERROR_BAD_QUERY_SYNTAX,
6730        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6731
6732     query = "INSERT INTO `Table` ( `A` ) VALUES ( \"test\" )";
6733     r = run_query(hdb, 0, query);
6734     ok(r == ERROR_BAD_QUERY_SYNTAX,
6735        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6736
6737     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a ''string'' ok' )";
6738     r = run_query(hdb, 0, query);
6739     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6740
6741     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a '''string''' ok' )";
6742     r = run_query(hdb, 0, query);
6743     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6744
6745     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \'string\' ok' )";
6746     r = run_query(hdb, 0, query);
6747     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6748
6749     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \"string\" ok' )";
6750     r = run_query(hdb, 0, query);
6751     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6752
6753     query = "SELECT * FROM `Table`";
6754     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6755     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6756
6757     r = MsiViewExecute(hview, 0);
6758     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6759
6760     r = MsiViewFetch(hview, &hrec);
6761     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6762
6763     size = MAX_PATH;
6764     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6765     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6766     ok(!lstrcmpA(buf, "This is a \"string\" ok"),
6767        "Expected \"This is a \"string\" ok\", got %s\n", buf);
6768
6769     MsiCloseHandle(hrec);
6770
6771     r = MsiViewFetch(hview, &hrec);
6772     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6773
6774     MsiViewClose(hview);
6775     MsiCloseHandle(hview);
6776
6777     write_file("import.idt", import_dat, (sizeof(import_dat) - 1) * sizeof(char));
6778
6779     r = MsiDatabaseImportA(hdb, CURR_DIR, "import.idt");
6780     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6781
6782     DeleteFileA("import.idt");
6783
6784     query = "SELECT * FROM `Table`";
6785     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6786     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6787
6788     r = MsiViewExecute(hview, 0);
6789     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6790
6791     r = MsiViewFetch(hview, &hrec);
6792     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6793
6794     size = MAX_PATH;
6795     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6796     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6797     ok(!lstrcmpA(buf, "This is a new 'string' ok"),
6798        "Expected \"This is a new 'string' ok\", got %s\n", buf);
6799
6800     MsiCloseHandle(hrec);
6801
6802     r = MsiViewFetch(hview, &hrec);
6803     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6804
6805     MsiViewClose(hview);
6806     MsiCloseHandle(hview);
6807     MsiCloseHandle(hdb);
6808     DeleteFileA(msifile);
6809 }
6810
6811 static void test_carriagereturn(void)
6812 {
6813     MSIHANDLE hdb, hview, hrec;
6814     const char *query;
6815     char buf[MAX_PATH];
6816     UINT r;
6817     DWORD size;
6818
6819     DeleteFileA(msifile);
6820
6821     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6822     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6823
6824     query = "CREATE TABLE `Table`\r ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6825     r = run_query(hdb, 0, query);
6826     ok(r == ERROR_BAD_QUERY_SYNTAX,
6827        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6828
6829     query = "CREATE TABLE `Table` \r( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6830     r = run_query(hdb, 0, query);
6831     ok(r == ERROR_BAD_QUERY_SYNTAX,
6832        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6833
6834     query = "CREATE\r TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6835     r = run_query(hdb, 0, query);
6836     ok(r == ERROR_BAD_QUERY_SYNTAX,
6837        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6838
6839     query = "CREATE TABLE\r `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6840     r = run_query(hdb, 0, query);
6841     ok(r == ERROR_BAD_QUERY_SYNTAX,
6842        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6843
6844     query = "CREATE TABLE `Table` (\r `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6845     r = run_query(hdb, 0, query);
6846     ok(r == ERROR_BAD_QUERY_SYNTAX,
6847        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6848
6849     query = "CREATE TABLE `Table` ( `A`\r CHAR(72) NOT NULL PRIMARY KEY `A` )";
6850     r = run_query(hdb, 0, query);
6851     ok(r == ERROR_BAD_QUERY_SYNTAX,
6852        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6853
6854     query = "CREATE TABLE `Table` ( `A` CHAR(72)\r NOT NULL PRIMARY KEY `A` )";
6855     r = run_query(hdb, 0, query);
6856     ok(r == ERROR_BAD_QUERY_SYNTAX,
6857        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6858
6859     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT\r NULL PRIMARY KEY `A` )";
6860     r = run_query(hdb, 0, query);
6861     ok(r == ERROR_BAD_QUERY_SYNTAX,
6862        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6863
6864     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT \rNULL PRIMARY KEY `A` )";
6865     r = run_query(hdb, 0, query);
6866     ok(r == ERROR_BAD_QUERY_SYNTAX,
6867        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6868
6869     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL\r PRIMARY KEY `A` )";
6870     r = run_query(hdb, 0, query);
6871     ok(r == ERROR_BAD_QUERY_SYNTAX,
6872        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6873
6874     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL \rPRIMARY KEY `A` )";
6875     r = run_query(hdb, 0, query);
6876     ok(r == ERROR_BAD_QUERY_SYNTAX,
6877        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6878
6879     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY\r KEY `A` )";
6880     r = run_query(hdb, 0, query);
6881     ok(r == ERROR_BAD_QUERY_SYNTAX,
6882        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6883
6884     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY \rKEY `A` )";
6885     r = run_query(hdb, 0, query);
6886     ok(r == ERROR_BAD_QUERY_SYNTAX,
6887        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6888
6889     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY\r `A` )";
6890     r = run_query(hdb, 0, query);
6891     ok(r == ERROR_BAD_QUERY_SYNTAX,
6892        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6893
6894     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A`\r )";
6895     r = run_query(hdb, 0, query);
6896     ok(r == ERROR_BAD_QUERY_SYNTAX,
6897        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6898
6899     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )\r";
6900     r = run_query(hdb, 0, query);
6901     ok(r == ERROR_BAD_QUERY_SYNTAX,
6902        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6903
6904     query = "CREATE TABLE `\rOne` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6905     r = run_query(hdb, 0, query);
6906     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6907
6908     query = "CREATE TABLE `Tw\ro` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6909     r = run_query(hdb, 0, query);
6910     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6911
6912     query = "CREATE TABLE `Three\r` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6913     r = run_query(hdb, 0, query);
6914     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6915
6916     query = "CREATE TABLE `Four` ( `A\r` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6917     r = run_query(hdb, 0, query);
6918     ok(r == ERROR_BAD_QUERY_SYNTAX,
6919        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6920
6921     query = "CREATE TABLE `Four` ( `\rA` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6922     r = run_query(hdb, 0, query);
6923     ok(r == ERROR_BAD_QUERY_SYNTAX,
6924        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6925
6926     query = "CREATE TABLE `Four` ( `A` CHAR(72\r) NOT NULL PRIMARY KEY `A` )";
6927     r = run_query(hdb, 0, query);
6928     ok(r == ERROR_BAD_QUERY_SYNTAX,
6929        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6930
6931     query = "CREATE TABLE `Four` ( `A` CHAR(\r72) NOT NULL PRIMARY KEY `A` )";
6932     r = run_query(hdb, 0, query);
6933     ok(r == ERROR_BAD_QUERY_SYNTAX,
6934        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6935
6936     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `\rA` )";
6937     r = run_query(hdb, 0, query);
6938     ok(r == ERROR_BAD_QUERY_SYNTAX,
6939        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6940
6941     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
6942     r = run_query(hdb, 0, query);
6943     ok(r == ERROR_BAD_QUERY_SYNTAX,
6944        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6945
6946     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
6947     r = run_query(hdb, 0, query);
6948     ok(r == ERROR_BAD_QUERY_SYNTAX,
6949        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6950
6951     query = "SELECT * FROM `_Tables`";
6952     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6953     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6954     r = MsiViewExecute(hview, 0);
6955     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6956
6957     r = MsiViewFetch(hview, &hrec);
6958     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6959
6960     size = MAX_PATH;
6961     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6962     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6963     ok(!lstrcmpA(buf, "\rOne"), "Expected \"\\rOne\", got \"%s\"\n", buf);
6964
6965     MsiCloseHandle(hrec);
6966
6967     r = MsiViewFetch(hview, &hrec);
6968     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6969
6970     size = MAX_PATH;
6971     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6972     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6973     ok(!lstrcmpA(buf, "Tw\ro"), "Expected \"Tw\\ro\", got \"%s\"\n", buf);
6974
6975     MsiCloseHandle(hrec);
6976
6977     r = MsiViewFetch(hview, &hrec);
6978     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6979
6980     size = MAX_PATH;
6981     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6982     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6983     ok(!lstrcmpA(buf, "Three\r"), "Expected \"Three\r\", got \"%s\"\n", buf);
6984
6985     MsiCloseHandle(hrec);
6986
6987     r = MsiViewFetch(hview, &hrec);
6988     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6989
6990     MsiViewClose(hview);
6991     MsiCloseHandle(hview);
6992
6993     MsiCloseHandle(hdb);
6994     DeleteFileA(msifile);
6995 }
6996
6997 static void test_noquotes(void)
6998 {
6999     MSIHANDLE hdb, hview, hrec;
7000     const char *query;
7001     char buf[MAX_PATH];
7002     UINT r;
7003     DWORD size;
7004
7005     DeleteFileA(msifile);
7006
7007     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7008     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7009
7010     query = "CREATE TABLE Table ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
7011     r = run_query(hdb, 0, query);
7012     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7013
7014     query = "CREATE TABLE `Table` ( A CHAR(72) NOT NULL PRIMARY KEY `A` )";
7015     r = run_query(hdb, 0, query);
7016     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7017
7018     query = "CREATE TABLE `Table2` ( `A` CHAR(72) NOT NULL PRIMARY KEY A )";
7019     r = run_query(hdb, 0, query);
7020     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7021
7022     query = "CREATE TABLE `Table3` ( A CHAR(72) NOT NULL PRIMARY KEY A )";
7023     r = run_query(hdb, 0, query);
7024     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7025
7026     query = "SELECT * FROM `_Tables`";
7027     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7028     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7029     r = MsiViewExecute(hview, 0);
7030     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7031
7032     r = MsiViewFetch(hview, &hrec);
7033     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7034
7035     size = MAX_PATH;
7036     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7037     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7038     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
7039
7040     MsiCloseHandle(hrec);
7041
7042     r = MsiViewFetch(hview, &hrec);
7043     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7044
7045     size = MAX_PATH;
7046     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7047     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7048     ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
7049
7050     MsiCloseHandle(hrec);
7051
7052     r = MsiViewFetch(hview, &hrec);
7053     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7054
7055     size = MAX_PATH;
7056     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7057     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7058     ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
7059
7060     MsiCloseHandle(hrec);
7061
7062     r = MsiViewFetch(hview, &hrec);
7063     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7064
7065     MsiViewClose(hview);
7066     MsiCloseHandle(hview);
7067
7068     query = "SELECT * FROM `_Columns`";
7069     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7070     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7071     r = MsiViewExecute(hview, 0);
7072     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7073
7074     r = MsiViewFetch(hview, &hrec);
7075     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7076
7077     size = MAX_PATH;
7078     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7079     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7080     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
7081
7082     r = MsiRecordGetInteger(hrec, 2);
7083     ok(r == 1, "Expected 1, got %d\n", r);
7084
7085     size = MAX_PATH;
7086     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7087     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7088     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7089
7090     MsiCloseHandle(hrec);
7091
7092     r = MsiViewFetch(hview, &hrec);
7093     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7094
7095     size = MAX_PATH;
7096     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7097     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7098     ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
7099
7100     r = MsiRecordGetInteger(hrec, 2);
7101     ok(r == 1, "Expected 1, got %d\n", r);
7102
7103     size = MAX_PATH;
7104     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7105     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7106     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7107
7108     MsiCloseHandle(hrec);
7109
7110     r = MsiViewFetch(hview, &hrec);
7111     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7112
7113     size = MAX_PATH;
7114     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7115     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7116     ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
7117
7118     r = MsiRecordGetInteger(hrec, 2);
7119     ok(r == 1, "Expected 1, got %d\n", r);
7120
7121     size = MAX_PATH;
7122     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7123     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7124     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7125
7126     MsiCloseHandle(hrec);
7127
7128     r = MsiViewFetch(hview, &hrec);
7129     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7130
7131     MsiViewClose(hview);
7132     MsiCloseHandle(hview);
7133
7134     query = "INSERT INTO Table ( `A` ) VALUES ( 'hi' )";
7135     r = run_query(hdb, 0, query);
7136     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7137
7138     query = "INSERT INTO `Table` ( A ) VALUES ( 'hi' )";
7139     r = run_query(hdb, 0, query);
7140     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7141
7142     query = "INSERT INTO `Table` ( `A` ) VALUES ( hi )";
7143     r = run_query(hdb, 0, query);
7144     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7145
7146     query = "SELECT * FROM Table WHERE `A` = 'hi'";
7147     r = run_query(hdb, 0, query);
7148     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7149
7150     query = "SELECT * FROM `Table` WHERE `A` = hi";
7151     r = run_query(hdb, 0, query);
7152     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7153
7154     query = "SELECT * FROM Table";
7155     r = run_query(hdb, 0, query);
7156     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7157
7158     query = "SELECT * FROM Table2";
7159     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7160     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7161     r = MsiViewExecute(hview, 0);
7162     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7163
7164     r = MsiViewFetch(hview, &hrec);
7165     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7166
7167     MsiViewClose(hview);
7168     MsiCloseHandle(hview);
7169
7170     query = "SELECT * FROM `Table` WHERE A = 'hi'";
7171     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7172     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7173     r = MsiViewExecute(hview, 0);
7174     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7175
7176     r = MsiViewFetch(hview, &hrec);
7177     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7178
7179     size = MAX_PATH;
7180     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7181     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7182     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
7183
7184     MsiCloseHandle(hrec);
7185
7186     r = MsiViewFetch(hview, &hrec);
7187     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7188
7189     MsiViewClose(hview);
7190     MsiCloseHandle(hview);
7191     MsiCloseHandle(hdb);
7192     DeleteFileA(msifile);
7193 }
7194
7195 static void read_file_data(LPCSTR filename, LPSTR buffer)
7196 {
7197     HANDLE file;
7198     DWORD read;
7199
7200     file = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
7201     ZeroMemory(buffer, MAX_PATH);
7202     ReadFile(file, buffer, MAX_PATH, &read, NULL);
7203     CloseHandle(file);
7204 }
7205
7206 static void test_forcecodepage(void)
7207 {
7208     MSIHANDLE hdb;
7209     const char *query;
7210     char buffer[MAX_PATH];
7211     UINT r;
7212
7213     DeleteFileA(msifile);
7214     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
7215
7216     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7217     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7218
7219     query = "SELECT * FROM `_ForceCodepage`";
7220     r = run_query(hdb, 0, query);
7221     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7222
7223     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
7224     r = run_query(hdb, 0, query);
7225     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7226
7227     query = "SELECT * FROM `_ForceCodepage`";
7228     r = run_query(hdb, 0, query);
7229     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7230
7231     r = MsiDatabaseCommit(hdb);
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     MsiCloseHandle(hdb);
7239
7240     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_DIRECT, &hdb);
7241     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7242
7243     query = "SELECT * FROM `_ForceCodepage`";
7244     r = run_query(hdb, 0, query);
7245     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7246
7247     r = MsiDatabaseExportA(hdb, "_ForceCodepage", CURR_DIR, "forcecodepage.idt");
7248     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7249
7250     read_file_data("forcecodepage.idt", buffer);
7251     ok(!lstrcmpA(buffer, "\r\n\r\n0\t_ForceCodepage\r\n"),
7252        "Expected \"\r\n\r\n0\t_ForceCodepage\r\n\", got \"%s\"\n", buffer);
7253
7254     create_file_data("forcecodepage.idt", "\r\n\r\n850\t_ForceCodepage\r\n", 0);
7255
7256     r = MsiDatabaseImportA(hdb, CURR_DIR, "forcecodepage.idt");
7257     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7258
7259     r = MsiDatabaseExportA(hdb, "_ForceCodepage", CURR_DIR, "forcecodepage.idt");
7260     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7261
7262     read_file_data("forcecodepage.idt", buffer);
7263     ok(!lstrcmpA(buffer, "\r\n\r\n850\t_ForceCodepage\r\n"),
7264        "Expected \"\r\n\r\n850\t_ForceCodepage\r\n\", got \"%s\"\n", buffer);
7265
7266     create_file_data("forcecodepage.idt", "\r\n\r\n9999\t_ForceCodepage\r\n", 0);
7267
7268     r = MsiDatabaseImportA(hdb, CURR_DIR, "forcecodepage.idt");
7269     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_SUCCESS, got %d\n", r);
7270
7271     MsiCloseHandle(hdb);
7272     DeleteFileA(msifile);
7273     DeleteFileA("forcecodepage.idt");
7274 }
7275
7276 static void test_viewmodify_refresh(void)
7277 {
7278     MSIHANDLE hdb, hview, hrec;
7279     const char *query;
7280     char buffer[MAX_PATH];
7281     UINT r;
7282     DWORD size;
7283
7284     DeleteFileA(msifile);
7285
7286     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7287     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7288
7289     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL, `B` INT PRIMARY KEY `A` )";
7290     r = run_query(hdb, 0, query);
7291     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7292
7293     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hi', 1 )";
7294     r = run_query(hdb, 0, query);
7295     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7296
7297     query = "SELECT * FROM `Table`";
7298     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7299     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7300     r = MsiViewExecute(hview, 0);
7301     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7302
7303     r = MsiViewFetch(hview, &hrec);
7304     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7305
7306     query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hi'";
7307     r = run_query(hdb, 0, query);
7308     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7309
7310     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7311     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7312
7313     size = MAX_PATH;
7314     r = MsiRecordGetStringA(hrec, 1, buffer, &size);
7315     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7316     ok(!lstrcmpA(buffer, "hi"), "Expected \"hi\", got \"%s\"\n", buffer);
7317     ok(size == 2, "Expected 2, got %d\n", size);
7318
7319     r = MsiRecordGetInteger(hrec, 2);
7320     ok(r == 2, "Expected 2, got %d\n", r);
7321
7322     MsiCloseHandle(hrec);
7323     MsiViewClose(hview);
7324     MsiCloseHandle(hview);
7325
7326     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hello', 3 )";
7327     r = run_query(hdb, 0, query);
7328     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7329
7330     query = "SELECT * FROM `Table` WHERE `B` = 3";
7331     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7332     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7333     r = MsiViewExecute(hview, 0);
7334     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7335
7336     r = MsiViewFetch(hview, &hrec);
7337     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7338
7339     query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hello'";
7340     r = run_query(hdb, 0, query);
7341     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7342
7343     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hithere', 3 )";
7344     r = run_query(hdb, 0, query);
7345     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7346
7347     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7348     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7349
7350     size = MAX_PATH;
7351     r = MsiRecordGetStringA(hrec, 1, buffer, &size);
7352     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7353     ok(!lstrcmpA(buffer, "hello"), "Expected \"hello\", got \"%s\"\n", buffer);
7354     ok(size == 5, "Expected 5, got %d\n", size);
7355
7356     r = MsiRecordGetInteger(hrec, 2);
7357     ok(r == 2, "Expected 2, got %d\n", r);
7358
7359     MsiCloseHandle(hrec);
7360     MsiViewClose(hview);
7361     MsiCloseHandle(hview);
7362     MsiCloseHandle(hdb);
7363     DeleteFileA(msifile);
7364 }
7365
7366 static void test_where_viewmodify(void)
7367 {
7368     MSIHANDLE hdb, hview, hrec;
7369     const char *query;
7370     UINT r;
7371
7372     DeleteFileA(msifile);
7373
7374     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7375     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7376
7377     query = "CREATE TABLE `Table` ( `A` INT, `B` INT PRIMARY KEY `A` )";
7378     r = run_query(hdb, 0, query);
7379     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7380
7381     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 1, 2 )";
7382     r = run_query(hdb, 0, query);
7383     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7384
7385     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 3, 4 )";
7386     r = run_query(hdb, 0, query);
7387     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7388
7389     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 5, 6 )";
7390     r = run_query(hdb, 0, query);
7391     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7392
7393     /* `B` = 3 doesn't match, but the view shouldn't be executed */
7394     query = "SELECT * FROM `Table` WHERE `B` = 3";
7395     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7396     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7397
7398     hrec = MsiCreateRecord(2);
7399     MsiRecordSetInteger(hrec, 1, 7);
7400     MsiRecordSetInteger(hrec, 2, 8);
7401
7402     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
7403     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7404
7405     MsiCloseHandle(hrec);
7406     MsiViewClose(hview);
7407     MsiCloseHandle(hview);
7408
7409     query = "SELECT * FROM `Table` WHERE `A` = 7";
7410     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7411     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7412     r = MsiViewExecute(hview, 0);
7413     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7414
7415     r = MsiViewFetch(hview, &hrec);
7416     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7417
7418     r = MsiRecordGetInteger(hrec, 1);
7419     ok(r == 7, "Expected 7, got %d\n", r);
7420
7421     r = MsiRecordGetInteger(hrec, 2);
7422     ok(r == 8, "Expected 8, got %d\n", r);
7423
7424     MsiRecordSetInteger(hrec, 2, 9);
7425
7426     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
7427     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7428
7429     MsiCloseHandle(hrec);
7430     MsiViewClose(hview);
7431     MsiCloseHandle(hview);
7432
7433     query = "SELECT * FROM `Table` WHERE `A` = 7";
7434     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7435     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7436     r = MsiViewExecute(hview, 0);
7437     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7438
7439     r = MsiViewFetch(hview, &hrec);
7440     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7441
7442     r = MsiRecordGetInteger(hrec, 1);
7443     ok(r == 7, "Expected 7, got %d\n", r);
7444
7445     r = MsiRecordGetInteger(hrec, 2);
7446     ok(r == 9, "Expected 9, got %d\n", r);
7447
7448     query = "UPDATE `Table` SET `B` = 10 WHERE `A` = 7";
7449     r = run_query(hdb, 0, query);
7450     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7451
7452     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7453     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7454
7455     r = MsiRecordGetInteger(hrec, 1);
7456     ok(r == 7, "Expected 7, got %d\n", r);
7457
7458     r = MsiRecordGetInteger(hrec, 2);
7459     ok(r == 10, "Expected 10, got %d\n", r);
7460
7461     MsiCloseHandle(hrec);
7462     MsiViewClose(hview);
7463     MsiCloseHandle(hview);
7464     MsiCloseHandle(hdb);
7465 }
7466
7467 static BOOL create_storage(LPCSTR name)
7468 {
7469     WCHAR nameW[MAX_PATH];
7470     IStorage *stg;
7471     IStream *stm;
7472     HRESULT hr;
7473     DWORD count;
7474     BOOL res = FALSE;
7475
7476     MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, MAX_PATH);
7477     hr = StgCreateDocfile(nameW, STGM_CREATE | STGM_READWRITE |
7478                           STGM_DIRECT | STGM_SHARE_EXCLUSIVE, 0, &stg);
7479     if (FAILED(hr))
7480         return FALSE;
7481
7482     hr = IStorage_CreateStream(stg, nameW, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
7483                                0, 0, &stm);
7484     if (FAILED(hr))
7485         goto done;
7486
7487     hr = IStream_Write(stm, "stgdata", 8, &count);
7488     if (SUCCEEDED(hr))
7489         res = TRUE;
7490
7491 done:
7492     IStream_Release(stm);
7493     IStorage_Release(stg);
7494
7495     return res;
7496 }
7497
7498 static void test_storages_table(void)
7499 {
7500     MSIHANDLE hdb, hview, hrec;
7501     IStorage *stg, *inner;
7502     IStream *stm;
7503     char file[MAX_PATH];
7504     char buf[MAX_PATH];
7505     WCHAR name[MAX_PATH];
7506     LPCSTR query;
7507     HRESULT hr;
7508     DWORD size;
7509     UINT r;
7510
7511     hdb = create_db();
7512     ok(hdb, "failed to create db\n");
7513
7514     r = MsiDatabaseCommit(hdb);
7515     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
7516
7517     MsiCloseHandle(hdb);
7518
7519     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb);
7520     ok(r == ERROR_SUCCESS , "Failed to open database\n");
7521
7522     /* check the column types */
7523     hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_TYPES);
7524     ok(hrec, "failed to get column info hrecord\n");
7525     ok(check_record(hrec, 1, "s62"), "wrong hrecord type\n");
7526     ok(check_record(hrec, 2, "V0"), "wrong hrecord type\n");
7527
7528     MsiCloseHandle(hrec);
7529
7530     /* now try the names */
7531     hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_NAMES);
7532     ok(hrec, "failed to get column info hrecord\n");
7533     ok(check_record(hrec, 1, "Name"), "wrong hrecord type\n");
7534     ok(check_record(hrec, 2, "Data"), "wrong hrecord type\n");
7535
7536     MsiCloseHandle(hrec);
7537
7538     create_storage("storage.bin");
7539
7540     hrec = MsiCreateRecord(2);
7541     MsiRecordSetStringA(hrec, 1, "stgname");
7542
7543     r = MsiRecordSetStreamA(hrec, 2, "storage.bin");
7544     ok(r == ERROR_SUCCESS, "Failed to add stream data to the hrecord: %d\n", r);
7545
7546     DeleteFileA("storage.bin");
7547
7548     query = "INSERT INTO `_Storages` (`Name`, `Data`) VALUES (?, ?)";
7549     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7550     ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
7551
7552     r = MsiViewExecute(hview, hrec);
7553     ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
7554
7555     MsiCloseHandle(hrec);
7556     MsiViewClose(hview);
7557     MsiCloseHandle(hview);
7558
7559     query = "SELECT `Name`, `Data` FROM `_Storages`";
7560     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7561     ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
7562
7563     r = MsiViewExecute(hview, 0);
7564     ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
7565
7566     r = MsiViewFetch(hview, &hrec);
7567     ok(r == ERROR_SUCCESS, "Failed to fetch hrecord: %d\n", r);
7568
7569     size = MAX_PATH;
7570     r = MsiRecordGetStringA(hrec, 1, file, &size);
7571     ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
7572     ok(!lstrcmpA(file, "stgname"), "Expected \"stgname\", got \"%s\"\n", file);
7573
7574     size = MAX_PATH;
7575     lstrcpyA(buf, "apple");
7576     r = MsiRecordReadStream(hrec, 2, buf, &size);
7577     ok(r == ERROR_INVALID_DATA, "Expected ERROR_INVALID_DATA, got %d\n", r);
7578     ok(!lstrcmpA(buf, "apple"), "Expected buf to be unchanged, got %s\n", buf);
7579     ok(size == 0, "Expected 0, got %d\n", size);
7580
7581     MsiCloseHandle(hrec);
7582
7583     r = MsiViewFetch(hview, &hrec);
7584     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7585
7586     MsiViewClose(hview);
7587     MsiCloseHandle(hview);
7588
7589     MsiDatabaseCommit(hdb);
7590     MsiCloseHandle(hdb);
7591
7592     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, MAX_PATH);
7593     hr = StgOpenStorage(name, NULL, STGM_DIRECT | STGM_READ |
7594                         STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
7595     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7596     ok(stg != NULL, "Expected non-NULL storage\n");
7597
7598     MultiByteToWideChar(CP_ACP, 0, "stgname", -1, name, MAX_PATH);
7599     hr = IStorage_OpenStorage(stg, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE,
7600                               NULL, 0, &inner);
7601     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7602     ok(inner != NULL, "Expected non-NULL storage\n");
7603
7604     MultiByteToWideChar(CP_ACP, 0, "storage.bin", -1, name, MAX_PATH);
7605     hr = IStorage_OpenStream(inner, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
7606     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7607     ok(stm != NULL, "Expected non-NULL stream\n");
7608
7609     hr = IStream_Read(stm, buf, MAX_PATH, &size);
7610     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
7611     ok(size == 8, "Expected 8, got %d\n", size);
7612     ok(!lstrcmpA(buf, "stgdata"), "Expected \"stgdata\", got \"%s\"\n", buf);
7613
7614     IStream_Release(stm);
7615     IStorage_Release(inner);
7616
7617     IStorage_Release(stg);
7618     DeleteFileA(msifile);
7619 }
7620
7621 static void test_dbtopackage(void)
7622 {
7623     MSIHANDLE hdb, hpkg;
7624     CHAR package[12], buf[MAX_PATH];
7625     DWORD size;
7626     UINT r;
7627
7628     /* create an empty database, transact mode */
7629     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7630     ok(r == ERROR_SUCCESS, "Failed to create database\n");
7631
7632     set_summary_info(hdb);
7633
7634     r = create_directory_table(hdb);
7635     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7636
7637     r = create_custom_action_table(hdb);
7638     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7639
7640     r = add_custom_action_entry(hdb, "'SetProp', 51, 'MYPROP', 'grape'");
7641     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7642
7643     sprintf(package, "#%u", hdb);
7644     r = MsiOpenPackageA(package, &hpkg);
7645     if (r == ERROR_INSTALL_PACKAGE_REJECTED)
7646     {
7647         skip("Not enough rights to perform tests\n");
7648         goto error;
7649     }
7650     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7651
7652     /* property is not set yet */
7653     size = MAX_PATH;
7654     lstrcpyA(buf, "kiwi");
7655     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7656     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7657     ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7658     ok(size == 0, "Expected 0, got %d\n", size);
7659
7660     /* run the custom action to set the property */
7661     r = MsiDoActionA(hpkg, "SetProp");
7662     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7663
7664     /* property is now set */
7665     size = MAX_PATH;
7666     lstrcpyA(buf, "kiwi");
7667     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7668     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7669     ok(!lstrcmpA(buf, "grape"), "Expected \"grape\", got \"%s\"\n", buf);
7670     ok(size == 5, "Expected 5, got %d\n", size);
7671
7672     MsiCloseHandle(hpkg);
7673
7674     /* reset the package */
7675     r = MsiOpenPackageA(package, &hpkg);
7676     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7677
7678     /* property is not set anymore */
7679     size = MAX_PATH;
7680     lstrcpyA(buf, "kiwi");
7681     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7682     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7683     todo_wine
7684     {
7685         ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7686         ok(size == 0, "Expected 0, got %d\n", size);
7687     }
7688
7689     MsiCloseHandle(hdb);
7690     MsiCloseHandle(hpkg);
7691
7692     /* create an empty database, direct mode */
7693     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATEDIRECT, &hdb);
7694     ok(r == ERROR_SUCCESS, "Failed to create database\n");
7695
7696     set_summary_info(hdb);
7697
7698     r = create_directory_table(hdb);
7699     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7700
7701     r = create_custom_action_table(hdb);
7702     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7703
7704     r = add_custom_action_entry(hdb, "'SetProp', 51, 'MYPROP', 'grape'");
7705     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7706
7707     sprintf(package, "#%u", hdb);
7708     r = MsiOpenPackageA(package, &hpkg);
7709     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7710
7711     /* property is not set yet */
7712     size = MAX_PATH;
7713     lstrcpyA(buf, "kiwi");
7714     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7715     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7716     ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7717     ok(size == 0, "Expected 0, got %d\n", size);
7718
7719     /* run the custom action to set the property */
7720     r = MsiDoActionA(hpkg, "SetProp");
7721     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7722
7723     /* property is now set */
7724     size = MAX_PATH;
7725     lstrcpyA(buf, "kiwi");
7726     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7727     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7728     ok(!lstrcmpA(buf, "grape"), "Expected \"grape\", got \"%s\"\n", buf);
7729     ok(size == 5, "Expected 5, got %d\n", size);
7730
7731     MsiCloseHandle(hpkg);
7732
7733     /* reset the package */
7734     r = MsiOpenPackageA(package, &hpkg);
7735     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7736
7737     /* property is not set anymore */
7738     size = MAX_PATH;
7739     lstrcpyA(buf, "kiwi");
7740     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7741     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7742     todo_wine
7743     {
7744         ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7745         ok(size == 0, "Expected 0, got %d\n", size);
7746     }
7747
7748     MsiCloseHandle(hpkg);
7749
7750 error:
7751     MsiCloseHandle(hdb);
7752     DeleteFileA(msifile);
7753 }
7754
7755 static void test_droptable(void)
7756 {
7757     MSIHANDLE hdb, hview, hrec;
7758     CHAR buf[MAX_PATH];
7759     LPCSTR query;
7760     DWORD size;
7761     UINT r;
7762
7763     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7764     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7765
7766     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
7767     r = run_query(hdb, 0, query);
7768     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7769
7770     query = "SELECT * FROM `One`";
7771     r = do_query(hdb, query, &hrec);
7772     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7773
7774     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7775     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7776     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7777     r = MsiViewExecute(hview, 0);
7778     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7779
7780     r = MsiViewFetch(hview, &hrec);
7781     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7782
7783     size = MAX_PATH;
7784     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7785     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7786     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7787
7788     MsiCloseHandle(hrec);
7789     MsiViewClose(hview);
7790     MsiCloseHandle(hview);
7791
7792     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7793     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7794     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7795     r = MsiViewExecute(hview, 0);
7796     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7797
7798     r = MsiViewFetch(hview, &hrec);
7799     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7800
7801     size = MAX_PATH;
7802     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7803     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7804     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7805
7806     r = MsiRecordGetInteger(hrec, 2);
7807     ok(r == 1, "Expected 1, got %d\n", r);
7808
7809     size = MAX_PATH;
7810     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7811     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7812     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7813
7814     MsiCloseHandle(hrec);
7815
7816     r = MsiViewFetch(hview, &hrec);
7817     ok(r == ERROR_NO_MORE_ITEMS,
7818        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7819
7820     MsiViewClose(hview);
7821     MsiCloseHandle(hview);
7822
7823     query = "DROP `One`";
7824     r = run_query(hdb, 0, query);
7825     ok(r == ERROR_BAD_QUERY_SYNTAX,
7826        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7827
7828     query = "DROP TABLE";
7829     r = run_query(hdb, 0, query);
7830     ok(r == ERROR_BAD_QUERY_SYNTAX,
7831        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7832
7833     query = "DROP TABLE `One`";
7834     hview = 0;
7835     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7836     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7837     r = MsiViewExecute(hview, 0);
7838     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7839
7840     r = MsiViewFetch(hview, &hrec);
7841     ok(r == ERROR_FUNCTION_FAILED,
7842        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
7843
7844     MsiViewClose(hview);
7845     MsiCloseHandle(hview);
7846
7847     query = "SELECT * FROM `IDontExist`";
7848     r = do_query(hdb, query, &hrec);
7849     ok(r == ERROR_BAD_QUERY_SYNTAX,
7850        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7851
7852     query = "SELECT * FROM `One`";
7853     r = do_query(hdb, query, &hrec);
7854     ok(r == ERROR_BAD_QUERY_SYNTAX,
7855        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7856
7857     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
7858     r = run_query(hdb, 0, query);
7859     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7860
7861     query = "DROP TABLE One";
7862     r = run_query(hdb, 0, query);
7863     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7864
7865     query = "SELECT * FROM `One`";
7866     r = do_query(hdb, query, &hrec);
7867     ok(r == ERROR_BAD_QUERY_SYNTAX,
7868        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7869
7870     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7871     r = do_query(hdb, query, &hrec);
7872     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7873
7874     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7875     r = do_query(hdb, query, &hrec);
7876     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7877
7878     query = "CREATE TABLE `One` ( `B` INT, `C` INT PRIMARY KEY `B` )";
7879     r = run_query(hdb, 0, query);
7880     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7881
7882     query = "SELECT * FROM `One`";
7883     r = do_query(hdb, query, &hrec);
7884     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7885
7886     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7887     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7888     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7889     r = MsiViewExecute(hview, 0);
7890     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7891
7892     r = MsiViewFetch(hview, &hrec);
7893     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7894
7895     size = MAX_PATH;
7896     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7897     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7898     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7899
7900     MsiCloseHandle(hrec);
7901     MsiViewClose(hview);
7902     MsiCloseHandle(hview);
7903
7904     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7905     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7906     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7907     r = MsiViewExecute(hview, 0);
7908     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7909
7910     r = MsiViewFetch(hview, &hrec);
7911     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7912
7913     size = MAX_PATH;
7914     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7915     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7916     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7917
7918     r = MsiRecordGetInteger(hrec, 2);
7919     ok(r == 1, "Expected 1, got %d\n", r);
7920
7921     size = MAX_PATH;
7922     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7923     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7924     ok(!lstrcmpA(buf, "B"), "Expected \"B\", got \"%s\"\n", buf);
7925
7926     MsiCloseHandle(hrec);
7927
7928     r = MsiViewFetch(hview, &hrec);
7929     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7930
7931     size = MAX_PATH;
7932     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7933     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7934     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7935
7936     r = MsiRecordGetInteger(hrec, 2);
7937     ok(r == 2, "Expected 2, got %d\n", r);
7938
7939     size = MAX_PATH;
7940     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7941     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7942     ok(!lstrcmpA(buf, "C"), "Expected \"C\", got \"%s\"\n", buf);
7943
7944     MsiCloseHandle(hrec);
7945
7946     r = MsiViewFetch(hview, &hrec);
7947     ok(r == ERROR_NO_MORE_ITEMS,
7948        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7949
7950     MsiViewClose(hview);
7951     MsiCloseHandle(hview);
7952
7953     query = "DROP TABLE One";
7954     r = run_query(hdb, 0, query);
7955     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7956
7957     query = "SELECT * FROM `One`";
7958     r = do_query(hdb, query, &hrec);
7959     ok(r == ERROR_BAD_QUERY_SYNTAX,
7960        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7961
7962     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7963     r = do_query(hdb, query, &hrec);
7964     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7965
7966     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7967     r = do_query(hdb, query, &hrec);
7968     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7969
7970     MsiCloseHandle(hdb);
7971     DeleteFileA(msifile);
7972 }
7973
7974 static void test_dbmerge(void)
7975 {
7976     static const WCHAR refdbW[] = {'r','e','f','d','b','.','m','s','i',0};
7977     MSIHANDLE hdb, href, hview, hrec;
7978     CHAR buf[MAX_PATH];
7979     LPCSTR query;
7980     DWORD size;
7981     UINT r;
7982
7983     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7984     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7985
7986     r = MsiOpenDatabaseW(refdbW, MSIDBOPEN_CREATE, &href);
7987     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7988
7989     /* hDatabase is invalid */
7990     r = MsiDatabaseMergeA(0, href, "MergeErrors");
7991     ok(r == ERROR_INVALID_HANDLE,
7992        "Expected ERROR_INVALID_HANDLE, got %d\n", r);
7993
7994     /* hDatabaseMerge is invalid */
7995     r = MsiDatabaseMergeA(hdb, 0, "MergeErrors");
7996     ok(r == ERROR_INVALID_HANDLE,
7997        "Expected ERROR_INVALID_HANDLE, got %d\n", r);
7998
7999     /* szTableName is NULL */
8000     r = MsiDatabaseMergeA(hdb, href, NULL);
8001     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8002
8003     /* szTableName is empty */
8004     r = MsiDatabaseMergeA(hdb, href, "");
8005     ok(r == ERROR_INVALID_TABLE, "Expected ERROR_INVALID_TABLE, got %d\n", r);
8006
8007     /* both DBs empty, szTableName is valid */
8008     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8009     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8010
8011     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
8012     r = run_query(hdb, 0, query);
8013     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8014
8015     query = "CREATE TABLE `One` ( `A` CHAR(72) PRIMARY KEY `A` )";
8016     r = run_query(href, 0, query);
8017     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8018
8019     /* column types don't match */
8020     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8021     ok(r == ERROR_DATATYPE_MISMATCH,
8022        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8023
8024     /* nothing in MergeErrors */
8025     query = "SELECT * FROM `MergeErrors`";
8026     r = do_query(hdb, query, &hrec);
8027     ok(r == ERROR_BAD_QUERY_SYNTAX,
8028        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8029
8030     query = "DROP TABLE `One`";
8031     r = run_query(hdb, 0, query);
8032     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8033
8034     query = "DROP TABLE `One`";
8035     r = run_query(href, 0, query);
8036     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8037
8038     query = "CREATE TABLE `One` ( "
8039         "`A` CHAR(72), "
8040         "`B` CHAR(56), "
8041         "`C` CHAR(64) LOCALIZABLE, "
8042         "`D` LONGCHAR, "
8043         "`E` CHAR(72) NOT NULL, "
8044         "`F` CHAR(56) NOT NULL, "
8045         "`G` CHAR(64) NOT NULL LOCALIZABLE, "
8046         "`H` LONGCHAR NOT NULL "
8047         "PRIMARY KEY `A` )";
8048     r = run_query(hdb, 0, query);
8049     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8050
8051     query = "CREATE TABLE `One` ( "
8052         "`A` CHAR(64), "
8053         "`B` CHAR(64), "
8054         "`C` CHAR(64), "
8055         "`D` CHAR(64), "
8056         "`E` CHAR(64) NOT NULL, "
8057         "`F` CHAR(64) NOT NULL, "
8058         "`G` CHAR(64) NOT NULL, "
8059         "`H` CHAR(64) NOT NULL "
8060         "PRIMARY KEY `A` )";
8061     r = run_query(href, 0, query);
8062     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8063
8064     /* column sting types don't match exactly */
8065     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8066     ok(r == ERROR_SUCCESS,
8067        "Expected ERROR_SUCCESS, got %d\n", r);
8068
8069     /* nothing in MergeErrors */
8070     query = "SELECT * FROM `MergeErrors`";
8071     r = do_query(hdb, query, &hrec);
8072     ok(r == ERROR_BAD_QUERY_SYNTAX,
8073        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8074
8075     query = "DROP TABLE `One`";
8076     r = run_query(hdb, 0, query);
8077     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8078
8079     query = "DROP TABLE `One`";
8080     r = run_query(href, 0, query);
8081     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8082
8083     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8084     r = run_query(hdb, 0, query);
8085     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8086
8087     query = "CREATE TABLE `One` ( `A` INT, `C` INT PRIMARY KEY `A` )";
8088     r = run_query(href, 0, query);
8089     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8090
8091     /* column names don't match */
8092     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8093     ok(r == ERROR_DATATYPE_MISMATCH,
8094        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8095
8096     /* nothing in MergeErrors */
8097     query = "SELECT * FROM `MergeErrors`";
8098     r = do_query(hdb, query, &hrec);
8099     ok(r == ERROR_BAD_QUERY_SYNTAX,
8100        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8101
8102     query = "DROP TABLE `One`";
8103     r = run_query(hdb, 0, query);
8104     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8105
8106     query = "DROP TABLE `One`";
8107     r = run_query(href, 0, query);
8108     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8109
8110     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8111     r = run_query(hdb, 0, query);
8112     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8113
8114     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `B` )";
8115     r = run_query(href, 0, query);
8116     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8117
8118     /* primary keys don't match */
8119     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8120     ok(r == ERROR_DATATYPE_MISMATCH,
8121        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8122
8123     /* nothing in MergeErrors */
8124     query = "SELECT * FROM `MergeErrors`";
8125     r = do_query(hdb, query, &hrec);
8126     ok(r == ERROR_BAD_QUERY_SYNTAX,
8127        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8128
8129     query = "DROP TABLE `One`";
8130     r = run_query(hdb, 0, query);
8131     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8132
8133     query = "DROP TABLE `One`";
8134     r = run_query(href, 0, query);
8135     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8136
8137     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8138     r = run_query(hdb, 0, query);
8139     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8140
8141     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A`, `B` )";
8142     r = run_query(href, 0, query);
8143     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8144
8145     /* number of primary keys doesn't match */
8146     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8147     ok(r == ERROR_DATATYPE_MISMATCH,
8148        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8149
8150     /* nothing in MergeErrors */
8151     query = "SELECT * FROM `MergeErrors`";
8152     r = do_query(hdb, query, &hrec);
8153     ok(r == ERROR_BAD_QUERY_SYNTAX,
8154        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8155
8156     query = "DROP TABLE `One`";
8157     r = run_query(hdb, 0, query);
8158     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8159
8160     query = "DROP TABLE `One`";
8161     r = run_query(href, 0, query);
8162     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8163
8164     query = "CREATE TABLE `One` ( `A` INT, `B` INT, `C` INT PRIMARY KEY `A` )";
8165     r = run_query(hdb, 0, query);
8166     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8167
8168     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8169     r = run_query(href, 0, query);
8170     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8171
8172     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 2 )";
8173     r = run_query(href, 0, query);
8174     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8175
8176     /* number of columns doesn't match */
8177     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8178     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8179
8180     query = "SELECT * FROM `One`";
8181     r = do_query(hdb, query, &hrec);
8182     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8183
8184     r = MsiRecordGetInteger(hrec, 1);
8185     ok(r == 1, "Expected 1, got %d\n", r);
8186
8187     r = MsiRecordGetInteger(hrec, 2);
8188     ok(r == 2, "Expected 2, got %d\n", r);
8189
8190     r = MsiRecordGetInteger(hrec, 3);
8191     ok(r == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", r);
8192
8193     MsiCloseHandle(hrec);
8194
8195     /* nothing in MergeErrors */
8196     query = "SELECT * FROM `MergeErrors`";
8197     r = do_query(hdb, query, &hrec);
8198     ok(r == ERROR_BAD_QUERY_SYNTAX,
8199        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8200
8201     query = "DROP TABLE `One`";
8202     r = run_query(hdb, 0, query);
8203     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8204
8205     query = "DROP TABLE `One`";
8206     r = run_query(href, 0, query);
8207     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8208
8209     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8210     r = run_query(hdb, 0, query);
8211     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8212
8213     query = "CREATE TABLE `One` ( `A` INT, `B` INT, `C` INT PRIMARY KEY `A` )";
8214     r = run_query(href, 0, query);
8215     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8216
8217     query = "INSERT INTO `One` ( `A`, `B`, `C` ) VALUES ( 1, 2, 3 )";
8218     r = run_query(href, 0, query);
8219     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8220
8221     /* number of columns doesn't match */
8222     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8223     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8224
8225     query = "SELECT * FROM `One`";
8226     r = do_query(hdb, query, &hrec);
8227     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8228
8229     r = MsiRecordGetInteger(hrec, 1);
8230     ok(r == 1, "Expected 1, got %d\n", r);
8231
8232     r = MsiRecordGetInteger(hrec, 2);
8233     ok(r == 2, "Expected 2, got %d\n", r);
8234
8235     r = MsiRecordGetInteger(hrec, 3);
8236     ok(r == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", r);
8237
8238     MsiCloseHandle(hrec);
8239
8240     /* nothing in MergeErrors */
8241     query = "SELECT * FROM `MergeErrors`";
8242     r = do_query(hdb, query, &hrec);
8243     ok(r == ERROR_BAD_QUERY_SYNTAX,
8244        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8245
8246     query = "DROP TABLE `One`";
8247     r = run_query(hdb, 0, query);
8248     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8249
8250     query = "DROP TABLE `One`";
8251     r = run_query(href, 0, query);
8252     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8253
8254     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8255     r = run_query(hdb, 0, query);
8256     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8257
8258     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 1 )";
8259     r = run_query(hdb, 0, query);
8260     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8261
8262     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 2 )";
8263     r = run_query(hdb, 0, query);
8264     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8265
8266     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8267     r = run_query(href, 0, query);
8268     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8269
8270     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 2 )";
8271     r = run_query(href, 0, query);
8272     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8273
8274     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 3 )";
8275     r = run_query(href, 0, query);
8276     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8277
8278     /* primary keys match, rows do not */
8279     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8280     ok(r == ERROR_FUNCTION_FAILED,
8281        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8282
8283     /* nothing in MergeErrors */
8284     query = "SELECT * FROM `MergeErrors`";
8285     r = do_query(hdb, query, &hrec);
8286     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8287
8288     size = MAX_PATH;
8289     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8290     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8291     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
8292
8293     r = MsiRecordGetInteger(hrec, 2);
8294     ok(r == 2, "Expected 2, got %d\n", r);
8295
8296     MsiCloseHandle(hrec);
8297
8298     r = MsiDatabaseOpenViewA(hdb, "SELECT * FROM `MergeErrors`", &hview);
8299     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8300
8301     r = MsiViewGetColumnInfo(hview, MSICOLINFO_NAMES, &hrec);
8302     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8303
8304     size = MAX_PATH;
8305     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8306     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8307     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
8308
8309     size = MAX_PATH;
8310     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8311     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8312     ok(!lstrcmpA(buf, "NumRowMergeConflicts"),
8313        "Expected \"NumRowMergeConflicts\", got \"%s\"\n", buf);
8314
8315     MsiCloseHandle(hrec);
8316
8317     r = MsiViewGetColumnInfo(hview, MSICOLINFO_TYPES, &hrec);
8318     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8319
8320     size = MAX_PATH;
8321     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8322     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8323     ok(!lstrcmpA(buf, "s255"), "Expected \"s255\", got \"%s\"\n", buf);
8324
8325     size = MAX_PATH;
8326     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8327     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8328     ok(!lstrcmpA(buf, "i2"), "Expected \"i2\", got \"%s\"\n", buf);
8329
8330     MsiCloseHandle(hrec);
8331     MsiViewClose(hview);
8332     MsiCloseHandle(hview);
8333
8334     query = "DROP TABLE `MergeErrors`";
8335     r = run_query(hdb, 0, query);
8336     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8337
8338     query = "DROP TABLE `One`";
8339     r = run_query(hdb, 0, query);
8340     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8341
8342     query = "DROP TABLE `One`";
8343     r = run_query(href, 0, query);
8344     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8345
8346     query = "CREATE TABLE `One` ( `A` INT, `B` CHAR(72) PRIMARY KEY `A` )";
8347     r = run_query(href, 0, query);
8348     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8349
8350     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'hi' )";
8351     r = run_query(href, 0, query);
8352     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8353
8354     /* table from merged database is not in target database */
8355     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8356     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8357
8358     query = "SELECT * FROM `One`";
8359     r = do_query(hdb, query, &hrec);
8360     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8361
8362     r = MsiRecordGetInteger(hrec, 1);
8363     ok(r == 1, "Expected 1, got %d\n", r);
8364
8365     size = MAX_PATH;
8366     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8367     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8368     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8369
8370     MsiCloseHandle(hrec);
8371
8372     /* nothing in MergeErrors */
8373     query = "SELECT * FROM `MergeErrors`";
8374     r = do_query(hdb, query, &hrec);
8375     ok(r == ERROR_BAD_QUERY_SYNTAX,
8376        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8377
8378     query = "DROP TABLE `One`";
8379     r = run_query(hdb, 0, query);
8380     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8381
8382     query = "DROP TABLE `One`";
8383     r = run_query(href, 0, query);
8384     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8385
8386     query = "CREATE TABLE `One` ( "
8387             "`A` CHAR(72), `B` INT PRIMARY KEY `A` )";
8388     r = run_query(hdb, 0, query);
8389     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8390
8391     query = "CREATE TABLE `One` ( "
8392             "`A` CHAR(72), `B` INT PRIMARY KEY `A` )";
8393     r = run_query(href, 0, query);
8394     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8395
8396     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 'hi', 1 )";
8397     r = run_query(href, 0, query);
8398     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8399
8400     /* primary key is string */
8401     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8402     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8403
8404     query = "SELECT * FROM `One`";
8405     r = do_query(hdb, query, &hrec);
8406     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8407
8408     size = MAX_PATH;
8409     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8410     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8411     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8412
8413     r = MsiRecordGetInteger(hrec, 2);
8414     ok(r == 1, "Expected 1, got %d\n", r);
8415
8416     MsiCloseHandle(hrec);
8417
8418     /* nothing in MergeErrors */
8419     query = "SELECT * FROM `MergeErrors`";
8420     r = do_query(hdb, query, &hrec);
8421     ok(r == ERROR_BAD_QUERY_SYNTAX,
8422        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8423
8424     create_file_data("codepage.idt", "\r\n\r\n850\t_ForceCodepage\r\n", 0);
8425
8426     GetCurrentDirectoryA(MAX_PATH, buf);
8427     r = MsiDatabaseImportA(hdb, buf, "codepage.idt");
8428     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8429
8430     query = "DROP TABLE `One`";
8431     r = run_query(hdb, 0, query);
8432     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8433
8434     query = "DROP TABLE `One`";
8435     r = run_query(href, 0, query);
8436     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8437
8438     query = "CREATE TABLE `One` ( "
8439             "`A` INT, `B` CHAR(72) LOCALIZABLE PRIMARY KEY `A` )";
8440     r = run_query(hdb, 0, query);
8441     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8442
8443     query = "CREATE TABLE `One` ( "
8444             "`A` INT, `B` CHAR(72) LOCALIZABLE PRIMARY KEY `A` )";
8445     r = run_query(href, 0, query);
8446     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8447
8448     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'hi' )";
8449     r = run_query(href, 0, query);
8450     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8451
8452     /* code page does not match */
8453     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8454     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8455
8456     query = "SELECT * FROM `One`";
8457     r = do_query(hdb, query, &hrec);
8458     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8459
8460     r = MsiRecordGetInteger(hrec, 1);
8461     ok(r == 1, "Expected 1, got %d\n", r);
8462
8463     size = MAX_PATH;
8464     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8465     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8466     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8467
8468     MsiCloseHandle(hrec);
8469
8470     /* nothing in MergeErrors */
8471     query = "SELECT * FROM `MergeErrors`";
8472     r = do_query(hdb, query, &hrec);
8473     ok(r == ERROR_BAD_QUERY_SYNTAX,
8474        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8475
8476     query = "DROP TABLE `One`";
8477     r = run_query(hdb, 0, query);
8478     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8479
8480     query = "DROP TABLE `One`";
8481     r = run_query(href, 0, query);
8482     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8483
8484     query = "CREATE TABLE `One` ( `A` INT, `B` OBJECT PRIMARY KEY `A` )";
8485     r = run_query(hdb, 0, query);
8486     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8487
8488     query = "CREATE TABLE `One` ( `A` INT, `B` OBJECT PRIMARY KEY `A` )";
8489     r = run_query(href, 0, query);
8490     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8491
8492     create_file("binary.dat");
8493     hrec = MsiCreateRecord(1);
8494     MsiRecordSetStreamA(hrec, 1, "binary.dat");
8495
8496     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, ? )";
8497     r = run_query(href, hrec, query);
8498     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8499
8500     MsiCloseHandle(hrec);
8501
8502     /* binary data to merge */
8503     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8504     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8505
8506     query = "SELECT * FROM `One`";
8507     r = do_query(hdb, query, &hrec);
8508     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8509
8510     r = MsiRecordGetInteger(hrec, 1);
8511     ok(r == 1, "Expected 1, got %d\n", r);
8512
8513     size = MAX_PATH;
8514     ZeroMemory(buf, MAX_PATH);
8515     r = MsiRecordReadStream(hrec, 2, buf, &size);
8516     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8517     ok(!lstrcmpA(buf, "binary.dat\n"),
8518        "Expected \"binary.dat\\n\", got \"%s\"\n", buf);
8519
8520     MsiCloseHandle(hrec);
8521
8522     /* nothing in MergeErrors */
8523     query = "SELECT * FROM `MergeErrors`";
8524     r = do_query(hdb, query, &hrec);
8525     ok(r == ERROR_BAD_QUERY_SYNTAX,
8526        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8527
8528     query = "DROP TABLE `One`";
8529     r = run_query(hdb, 0, query);
8530     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8531
8532     query = "DROP TABLE `One`";
8533     r = run_query(href, 0, query);
8534     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8535
8536     query = "CREATE TABLE `One` ( `A` INT, `B` CHAR(72) PRIMARY KEY `A` )";
8537     r = run_query(hdb, 0, query);
8538     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8539     r = run_query(href, 0, query);
8540     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8541
8542     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'foo' )";
8543     r = run_query(href, 0, query);
8544     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8545
8546     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 'bar' )";
8547     r = run_query(href, 0, query);
8548     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8549
8550     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8551     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8552
8553     query = "SELECT * FROM `One`";
8554     r = MsiDatabaseOpenViewA(hdb, query, &hview);
8555     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8556     r = MsiViewExecute(hview, 0);
8557     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8558
8559     r = MsiViewFetch(hview, &hrec);
8560     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8561
8562     r = MsiRecordGetInteger(hrec, 1);
8563     ok(r == 1, "Expected 1, got %d\n", r);
8564
8565     size = MAX_PATH;
8566     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8567     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8568     ok(!lstrcmpA(buf, "foo"), "Expected \"foo\", got \"%s\"\n", buf);
8569
8570     MsiCloseHandle(hrec);
8571
8572     r = MsiViewFetch(hview, &hrec);
8573     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8574
8575     r = MsiRecordGetInteger(hrec, 1);
8576     ok(r == 2, "Expected 2, got %d\n", r);
8577
8578     size = MAX_PATH;
8579     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8580     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8581     ok(!lstrcmpA(buf, "bar"), "Expected \"bar\", got \"%s\"\n", buf);
8582
8583     MsiCloseHandle(hrec);
8584
8585     r = MsiViewFetch(hview, &hrec);
8586     ok(r == ERROR_NO_MORE_ITEMS,
8587        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8588
8589     MsiViewClose(hview);
8590     MsiCloseHandle(hview);
8591
8592     MsiCloseHandle(hdb);
8593     MsiCloseHandle(href);
8594     DeleteFileA(msifile);
8595     DeleteFileW(refdbW);
8596     DeleteFileA("codepage.idt");
8597     DeleteFileA("binary.dat");
8598 }
8599
8600 static void test_select_with_tablenames(void)
8601 {
8602     MSIHANDLE hdb, view, rec;
8603     LPCSTR query;
8604     UINT r;
8605     int i;
8606
8607     int vals[4][2] = {
8608         {1,12},
8609         {4,12},
8610         {1,15},
8611         {4,15}};
8612
8613     hdb = create_db();
8614     ok(hdb, "failed to create db\n");
8615
8616     /* Build a pair of tables with the same column names, but unique data */
8617     query = "CREATE TABLE `T1` ( `A` SHORT, `B` SHORT PRIMARY KEY `A`)";
8618     r = run_query(hdb, 0, query);
8619     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8620
8621     query = "INSERT INTO `T1` ( `A`, `B` ) VALUES ( 1, 2 )";
8622     r = run_query(hdb, 0, query);
8623     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8624
8625     query = "INSERT INTO `T1` ( `A`, `B` ) VALUES ( 4, 5 )";
8626     r = run_query(hdb, 0, query);
8627     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8628
8629     query = "CREATE TABLE `T2` ( `A` SHORT, `B` SHORT PRIMARY KEY `A`)";
8630     r = run_query(hdb, 0, query);
8631     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8632
8633     query = "INSERT INTO `T2` ( `A`, `B` ) VALUES ( 11, 12 )";
8634     r = run_query(hdb, 0, query);
8635     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8636
8637     query = "INSERT INTO `T2` ( `A`, `B` ) VALUES ( 14, 15 )";
8638     r = run_query(hdb, 0, query);
8639     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8640
8641
8642     /* Test that selection based on prefixing the column with the table
8643      * actually selects the right data */
8644
8645     query = "SELECT T1.A, T2.B FROM T1,T2";
8646     r = MsiDatabaseOpenViewA(hdb, query, &view);
8647     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8648     r = MsiViewExecute(view, 0);
8649     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8650
8651     for (i = 0; i < 4; i++)
8652     {
8653         r = MsiViewFetch(view, &rec);
8654         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8655
8656         r = MsiRecordGetInteger(rec, 1);
8657         ok(r == vals[i][0], "Expected %d, got %d\n", vals[i][0], r);
8658
8659         r = MsiRecordGetInteger(rec, 2);
8660         ok(r == vals[i][1], "Expected %d, got %d\n", vals[i][1], r);
8661
8662         MsiCloseHandle(rec);
8663     }
8664
8665     r = MsiViewFetch(view, &rec);
8666     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8667
8668     MsiViewClose(view);
8669     MsiCloseHandle(view);
8670     MsiCloseHandle(hdb);
8671     DeleteFileA(msifile);
8672 }
8673
8674 static const UINT ordervals[6][3] =
8675 {
8676     { MSI_NULL_INTEGER, 12, 13 },
8677     { 1, 2, 3 },
8678     { 6, 4, 5 },
8679     { 8, 9, 7 },
8680     { 10, 11, MSI_NULL_INTEGER },
8681     { 14, MSI_NULL_INTEGER, 15 }
8682 };
8683
8684 static void test_insertorder(void)
8685 {
8686     MSIHANDLE hdb, view, rec;
8687     LPCSTR query;
8688     UINT r;
8689     int i;
8690
8691     hdb = create_db();
8692     ok(hdb, "failed to create db\n");
8693
8694     query = "CREATE TABLE `T` ( `A` SHORT, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
8695     r = run_query(hdb, 0, query);
8696     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8697
8698     query = "INSERT INTO `T` ( `A`, `B`, `C` ) VALUES ( 1, 2, 3 )";
8699     r = run_query(hdb, 0, query);
8700     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8701
8702     query = "INSERT INTO `T` ( `B`, `C`, `A` ) VALUES ( 4, 5, 6 )";
8703     r = run_query(hdb, 0, query);
8704     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8705
8706     query = "INSERT INTO `T` ( `C`, `A`, `B` ) VALUES ( 7, 8, 9 )";
8707     r = run_query(hdb, 0, query);
8708     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8709
8710     query = "INSERT INTO `T` ( `A`, `B` ) VALUES ( 10, 11 )";
8711     r = run_query(hdb, 0, query);
8712     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8713
8714     query = "INSERT INTO `T` ( `B`, `C` ) VALUES ( 12, 13 )";
8715     r = run_query(hdb, 0, query);
8716     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8717
8718     /* fails because the primary key already
8719      * has an MSI_NULL_INTEGER value set above
8720      */
8721     query = "INSERT INTO `T` ( `C` ) VALUES ( 14 )";
8722     r = run_query(hdb, 0, query);
8723     ok(r == ERROR_FUNCTION_FAILED,
8724        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8725
8726     /* replicate the error where primary key is set twice */
8727     query = "INSERT INTO `T` ( `A`, `C` ) VALUES ( 1, 14 )";
8728     r = run_query(hdb, 0, query);
8729     ok(r == ERROR_FUNCTION_FAILED,
8730        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8731
8732     query = "INSERT INTO `T` ( `A`, `C` ) VALUES ( 14, 15 )";
8733     r = run_query(hdb, 0, query);
8734     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8735
8736     query = "INSERT INTO `T` VALUES ( 16 )";
8737     r = run_query(hdb, 0, query);
8738     ok(r == ERROR_BAD_QUERY_SYNTAX,
8739        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8740
8741     query = "INSERT INTO `T` VALUES ( 17, 18 )";
8742     r = run_query(hdb, 0, query);
8743     ok(r == ERROR_BAD_QUERY_SYNTAX,
8744        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8745
8746     query = "INSERT INTO `T` VALUES ( 19, 20, 21 )";
8747     r = run_query(hdb, 0, query);
8748     ok(r == ERROR_BAD_QUERY_SYNTAX,
8749        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8750
8751     query = "SELECT * FROM `T`";
8752     r = MsiDatabaseOpenViewA(hdb, query, &view);
8753     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8754     r = MsiViewExecute(view, 0);
8755     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8756
8757     for (i = 0; i < 6; i++)
8758     {
8759         r = MsiViewFetch(view, &rec);
8760         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8761
8762         r = MsiRecordGetInteger(rec, 1);
8763         ok(r == ordervals[i][0], "Expected %d, got %d\n", ordervals[i][0], r);
8764
8765         r = MsiRecordGetInteger(rec, 2);
8766         ok(r == ordervals[i][1], "Expected %d, got %d\n", ordervals[i][1], r);
8767
8768         r = MsiRecordGetInteger(rec, 3);
8769         ok(r == ordervals[i][2], "Expected %d, got %d\n", ordervals[i][2], r);
8770
8771         MsiCloseHandle(rec);
8772     }
8773
8774     r = MsiViewFetch(view, &rec);
8775     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8776
8777     MsiViewClose(view);
8778     MsiCloseHandle(view);
8779
8780     query = "DELETE FROM `T` WHERE `A` IS NULL";
8781     r = run_query(hdb, 0, query);
8782     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8783
8784     query = "INSERT INTO `T` ( `B`, `C` ) VALUES ( 12, 13 ) TEMPORARY";
8785     r = run_query(hdb, 0, query);
8786     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8787
8788     query = "SELECT * FROM `T`";
8789     r = MsiDatabaseOpenViewA(hdb, query, &view);
8790     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8791     r = MsiViewExecute(view, 0);
8792     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8793
8794     for (i = 0; i < 6; i++)
8795     {
8796         r = MsiViewFetch(view, &rec);
8797         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8798
8799         r = MsiRecordGetInteger(rec, 1);
8800         ok(r == ordervals[i][0], "Expected %d, got %d\n", ordervals[i][0], r);
8801
8802         r = MsiRecordGetInteger(rec, 2);
8803         ok(r == ordervals[i][1], "Expected %d, got %d\n", ordervals[i][1], r);
8804
8805         r = MsiRecordGetInteger(rec, 3);
8806         ok(r == ordervals[i][2], "Expected %d, got %d\n", ordervals[i][2], r);
8807
8808         MsiCloseHandle(rec);
8809     }
8810
8811     r = MsiViewFetch(view, &rec);
8812     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8813
8814     MsiViewClose(view);
8815     MsiCloseHandle(view);
8816     MsiCloseHandle(hdb);
8817     DeleteFileA(msifile);
8818 }
8819
8820 static void test_columnorder(void)
8821 {
8822     MSIHANDLE hdb, view, rec;
8823     char buf[MAX_PATH];
8824     LPCSTR query;
8825     DWORD sz;
8826     UINT r;
8827
8828     hdb = create_db();
8829     ok(hdb, "failed to create db\n");
8830
8831     /* Each column is a slot:
8832      * ---------------------
8833      * | B | C | A | E | D |
8834      * ---------------------
8835      *
8836      * When a column is selected as a primary key,
8837      * the column occupying the nth primary key slot is swapped
8838      * with the current position of the primary key in question:
8839      *
8840      * set primary key `D`
8841      * ---------------------    ---------------------
8842      * | B | C | A | E | D | -> | D | C | A | E | B |
8843      * ---------------------    ---------------------
8844      *
8845      * set primary key `E`
8846      * ---------------------    ---------------------
8847      * | D | C | A | E | B | -> | D | E | A | C | B |
8848      * ---------------------    ---------------------
8849      */
8850
8851     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL, `C` SHORT NOT NULL, "
8852             "`A` CHAR(255), `E` INT, `D` CHAR(255) NOT NULL "
8853             "PRIMARY KEY `D`, `E`)";
8854     r = run_query(hdb, 0, query);
8855     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8856
8857     query = "SELECT * FROM `T`";
8858     r = MsiDatabaseOpenViewA(hdb, query, &view);
8859     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8860
8861     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
8862     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8863
8864     sz = MAX_PATH;
8865     lstrcpyA(buf, "kiwi");
8866     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8867     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8868     ok(!lstrcmpA("s255", buf), "Expected \"s255\", got \"%s\"\n", buf);
8869
8870     sz = MAX_PATH;
8871     lstrcpyA(buf, "kiwi");
8872     r = MsiRecordGetStringA(rec, 2, buf, &sz);
8873     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8874     ok(!lstrcmpA("I2", buf), "Expected \"I2\", got \"%s\"\n", buf);
8875
8876     sz = MAX_PATH;
8877     lstrcpyA(buf, "kiwi");
8878     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8879     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8880     ok(!lstrcmpA("S255", buf), "Expected \"S255\", got \"%s\"\n", buf);
8881
8882     sz = MAX_PATH;
8883     lstrcpyA(buf, "kiwi");
8884     r = MsiRecordGetStringA(rec, 4, buf, &sz);
8885     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8886     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
8887
8888     sz = MAX_PATH;
8889     lstrcpyA(buf, "kiwi");
8890     r = MsiRecordGetStringA(rec, 5, buf, &sz);
8891     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8892     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
8893
8894     MsiCloseHandle(rec);
8895
8896     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
8897     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8898
8899     sz = MAX_PATH;
8900     lstrcpyA(buf, "kiwi");
8901     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8902     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8903     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
8904
8905     sz = MAX_PATH;
8906     lstrcpyA(buf, "kiwi");
8907     r = MsiRecordGetStringA(rec, 2, buf, &sz);
8908     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8909     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
8910
8911     sz = MAX_PATH;
8912     lstrcpyA(buf, "kiwi");
8913     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8914     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8915     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
8916
8917     sz = MAX_PATH;
8918     lstrcpyA(buf, "kiwi");
8919     r = MsiRecordGetStringA(rec, 4, buf, &sz);
8920     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8921     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
8922
8923     sz = MAX_PATH;
8924     lstrcpyA(buf, "kiwi");
8925     r = MsiRecordGetStringA(rec, 5, buf, &sz);
8926     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8927     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
8928
8929     MsiCloseHandle(rec);
8930     MsiViewClose(view);
8931     MsiCloseHandle(view);
8932
8933     query = "INSERT INTO `T` ( `B`, `C`, `A`, `E`, `D` ) "
8934             "VALUES ( 1, 2, 'a', 3, 'bc' )";
8935     r = run_query(hdb, 0, query);
8936     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8937
8938     query = "SELECT * FROM `T`";
8939     r = do_query(hdb, query, &rec);
8940     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8941
8942     sz = MAX_PATH;
8943     lstrcpyA(buf, "kiwi");
8944     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8945     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8946     ok(!lstrcmpA("bc", buf), "Expected \"bc\", got \"%s\"\n", buf);
8947
8948     r = MsiRecordGetInteger(rec, 2);
8949     ok(r == 3, "Expected 3, got %d\n", r);
8950
8951     sz = MAX_PATH;
8952     lstrcpyA(buf, "kiwi");
8953     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8954     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8955     ok(!lstrcmpA("a", buf), "Expected \"a\", got \"%s\"\n", buf);
8956
8957     r = MsiRecordGetInteger(rec, 4);
8958     ok(r == 2, "Expected 2, got %d\n", r);
8959
8960     r = MsiRecordGetInteger(rec, 5);
8961     ok(r == 1, "Expected 1, got %d\n", r);
8962
8963     MsiCloseHandle(rec);
8964
8965     query = "SELECT * FROM `_Columns` WHERE `Table` = 'T'";
8966     r = MsiDatabaseOpenViewA(hdb, query, &view);
8967     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8968     r = MsiViewExecute(view, 0);
8969     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8970
8971     r = MsiViewFetch(view, &rec);
8972     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8973
8974     sz = MAX_PATH;
8975     lstrcpyA(buf, "kiwi");
8976     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8977     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8978     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8979
8980     r = MsiRecordGetInteger(rec, 2);
8981     ok(r == 1, "Expected 1, got %d\n", r);
8982
8983     sz = MAX_PATH;
8984     lstrcpyA(buf, "kiwi");
8985     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8986     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8987     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
8988
8989     MsiCloseHandle(rec);
8990
8991     r = MsiViewFetch(view, &rec);
8992     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8993
8994     sz = MAX_PATH;
8995     lstrcpyA(buf, "kiwi");
8996     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8997     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8998     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8999
9000     r = MsiRecordGetInteger(rec, 2);
9001     ok(r == 2, "Expected 2, got %d\n", r);
9002
9003     sz = MAX_PATH;
9004     lstrcpyA(buf, "kiwi");
9005     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9006     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9007     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
9008
9009     MsiCloseHandle(rec);
9010
9011     r = MsiViewFetch(view, &rec);
9012     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9013
9014     sz = MAX_PATH;
9015     lstrcpyA(buf, "kiwi");
9016     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9017     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9018     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9019
9020     r = MsiRecordGetInteger(rec, 2);
9021     ok(r == 3, "Expected 3, got %d\n", r);
9022
9023     sz = MAX_PATH;
9024     lstrcpyA(buf, "kiwi");
9025     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9026     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9027     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
9028
9029     MsiCloseHandle(rec);
9030
9031     r = MsiViewFetch(view, &rec);
9032     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9033
9034     sz = MAX_PATH;
9035     lstrcpyA(buf, "kiwi");
9036     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9037     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9038     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9039
9040     r = MsiRecordGetInteger(rec, 2);
9041     ok(r == 4, "Expected 4, got %d\n", r);
9042
9043     sz = MAX_PATH;
9044     lstrcpyA(buf, "kiwi");
9045     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9046     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9047     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
9048
9049     MsiCloseHandle(rec);
9050
9051     r = MsiViewFetch(view, &rec);
9052     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9053
9054     sz = MAX_PATH;
9055     lstrcpyA(buf, "kiwi");
9056     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9057     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9058     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9059
9060     r = MsiRecordGetInteger(rec, 2);
9061     ok(r == 5, "Expected 5, got %d\n", r);
9062
9063     sz = MAX_PATH;
9064     lstrcpyA(buf, "kiwi");
9065     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9066     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9067     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
9068
9069     MsiCloseHandle(rec);
9070
9071     r = MsiViewFetch(view, &rec);
9072     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
9073
9074     MsiViewClose(view);
9075     MsiCloseHandle(view);
9076
9077     query = "CREATE TABLE `Z` ( `B` SHORT NOT NULL, `C` SHORT NOT NULL, "
9078             "`A` CHAR(255), `E` INT, `D` CHAR(255) NOT NULL "
9079             "PRIMARY KEY `C`, `A`, `D`)";
9080     r = run_query(hdb, 0, query);
9081     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9082
9083     query = "SELECT * FROM `Z`";
9084     r = MsiDatabaseOpenViewA(hdb, query, &view);
9085     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9086
9087     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
9088     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9089
9090     sz = MAX_PATH;
9091     lstrcpyA(buf, "kiwi");
9092     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9093     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9094     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
9095
9096     sz = MAX_PATH;
9097     lstrcpyA(buf, "kiwi");
9098     r = MsiRecordGetStringA(rec, 2, buf, &sz);
9099     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9100     ok(!lstrcmpA("S255", buf), "Expected \"S255\", got \"%s\"\n", buf);
9101
9102     sz = MAX_PATH;
9103     lstrcpyA(buf, "kiwi");
9104     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9105     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9106     ok(!lstrcmpA("s255", buf), "Expected \"s255\", got \"%s\"\n", buf);
9107
9108     sz = MAX_PATH;
9109     lstrcpyA(buf, "kiwi");
9110     r = MsiRecordGetStringA(rec, 4, buf, &sz);
9111     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9112     ok(!lstrcmpA("I2", buf), "Expected \"I2\", got \"%s\"\n", buf);
9113
9114     sz = MAX_PATH;
9115     lstrcpyA(buf, "kiwi");
9116     r = MsiRecordGetStringA(rec, 5, buf, &sz);
9117     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9118     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
9119
9120     MsiCloseHandle(rec);
9121
9122     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
9123     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9124
9125     sz = MAX_PATH;
9126     lstrcpyA(buf, "kiwi");
9127     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9128     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9129     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
9130
9131     sz = MAX_PATH;
9132     lstrcpyA(buf, "kiwi");
9133     r = MsiRecordGetStringA(rec, 2, buf, &sz);
9134     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9135     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
9136
9137     sz = MAX_PATH;
9138     lstrcpyA(buf, "kiwi");
9139     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9140     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9141     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
9142
9143     sz = MAX_PATH;
9144     lstrcpyA(buf, "kiwi");
9145     r = MsiRecordGetStringA(rec, 4, buf, &sz);
9146     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9147     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
9148
9149     sz = MAX_PATH;
9150     lstrcpyA(buf, "kiwi");
9151     r = MsiRecordGetStringA(rec, 5, buf, &sz);
9152     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9153     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
9154
9155     MsiCloseHandle(rec);
9156     MsiViewClose(view);
9157     MsiCloseHandle(view);
9158
9159     query = "INSERT INTO `Z` ( `B`, `C`, `A`, `E`, `D` ) "
9160             "VALUES ( 1, 2, 'a', 3, 'bc' )";
9161     r = run_query(hdb, 0, query);
9162     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9163
9164     query = "SELECT * FROM `Z`";
9165     r = do_query(hdb, query, &rec);
9166     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9167
9168     r = MsiRecordGetInteger(rec, 1);
9169     ok(r == 2, "Expected 2, got %d\n", r);
9170
9171     sz = MAX_PATH;
9172     lstrcpyA(buf, "kiwi");
9173     r = MsiRecordGetStringA(rec, 2, buf, &sz);
9174     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9175     ok(!lstrcmpA("a", buf), "Expected \"a\", got \"%s\"\n", buf);
9176
9177     sz = MAX_PATH;
9178     lstrcpyA(buf, "kiwi");
9179     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9180     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9181     ok(!lstrcmpA("bc", buf), "Expected \"bc\", got \"%s\"\n", buf);
9182
9183     r = MsiRecordGetInteger(rec, 4);
9184     ok(r == 3, "Expected 3, got %d\n", r);
9185
9186     r = MsiRecordGetInteger(rec, 5);
9187     ok(r == 1, "Expected 1, got %d\n", r);
9188
9189     MsiCloseHandle(rec);
9190
9191     query = "SELECT * FROM `_Columns` WHERE `Table` = 'T'";
9192     r = MsiDatabaseOpenViewA(hdb, query, &view);
9193     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9194     r = MsiViewExecute(view, 0);
9195     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9196
9197     r = MsiViewFetch(view, &rec);
9198     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9199
9200     sz = MAX_PATH;
9201     lstrcpyA(buf, "kiwi");
9202     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9203     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9204     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9205
9206     r = MsiRecordGetInteger(rec, 2);
9207     ok(r == 1, "Expected 1, got %d\n", r);
9208
9209     sz = MAX_PATH;
9210     lstrcpyA(buf, "kiwi");
9211     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9212     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9213     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
9214
9215     MsiCloseHandle(rec);
9216
9217     r = MsiViewFetch(view, &rec);
9218     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9219
9220     sz = MAX_PATH;
9221     lstrcpyA(buf, "kiwi");
9222     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9223     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9224     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9225
9226     r = MsiRecordGetInteger(rec, 2);
9227     ok(r == 2, "Expected 2, got %d\n", r);
9228
9229     sz = MAX_PATH;
9230     lstrcpyA(buf, "kiwi");
9231     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9232     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9233     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
9234
9235     MsiCloseHandle(rec);
9236
9237     r = MsiViewFetch(view, &rec);
9238     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9239
9240     sz = MAX_PATH;
9241     lstrcpyA(buf, "kiwi");
9242     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9243     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9244     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9245
9246     r = MsiRecordGetInteger(rec, 2);
9247     ok(r == 3, "Expected 3, got %d\n", r);
9248
9249     sz = MAX_PATH;
9250     lstrcpyA(buf, "kiwi");
9251     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9252     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9253     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
9254
9255     MsiCloseHandle(rec);
9256
9257     r = MsiViewFetch(view, &rec);
9258     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9259
9260     sz = MAX_PATH;
9261     lstrcpyA(buf, "kiwi");
9262     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9263     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9264     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9265
9266     r = MsiRecordGetInteger(rec, 2);
9267     ok(r == 4, "Expected 4, got %d\n", r);
9268
9269     sz = MAX_PATH;
9270     lstrcpyA(buf, "kiwi");
9271     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9272     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9273     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
9274
9275     MsiCloseHandle(rec);
9276
9277     r = MsiViewFetch(view, &rec);
9278     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9279
9280     sz = MAX_PATH;
9281     lstrcpyA(buf, "kiwi");
9282     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9283     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9284     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9285
9286     r = MsiRecordGetInteger(rec, 2);
9287     ok(r == 5, "Expected 5, got %d\n", r);
9288
9289     sz = MAX_PATH;
9290     lstrcpyA(buf, "kiwi");
9291     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9292     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9293     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
9294
9295     MsiCloseHandle(rec);
9296
9297     r = MsiViewFetch(view, &rec);
9298     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
9299
9300     MsiViewClose(view);
9301     MsiCloseHandle(view);
9302
9303     MsiCloseHandle(hdb);
9304     DeleteFileA(msifile);
9305 }
9306
9307 static void test_createtable(void)
9308 {
9309     MSIHANDLE hdb, htab = 0, hrec = 0;
9310     LPCSTR query;
9311     UINT res;
9312     DWORD size;
9313     char buffer[0x20];
9314
9315     hdb = create_db();
9316     ok(hdb, "failed to create db\n");
9317
9318     query = "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL PRIMARY KEY `foo`)";
9319     res = MsiDatabaseOpenViewA( hdb, query, &htab );
9320     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9321     if(res == ERROR_SUCCESS )
9322     {
9323         res = MsiViewExecute( htab, hrec );
9324         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9325
9326         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
9327         todo_wine ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9328
9329         size = sizeof(buffer);
9330         res = MsiRecordGetStringA(hrec, 1, buffer, &size );
9331         todo_wine ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9332         MsiCloseHandle( hrec );
9333
9334         res = MsiViewClose( htab );
9335         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9336
9337         res = MsiCloseHandle( htab );
9338         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9339     }
9340
9341     query = "CREATE TABLE `a` (`b` INT PRIMARY KEY `b`)";
9342     res = MsiDatabaseOpenViewA( hdb, query, &htab );
9343     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9344     if(res == ERROR_SUCCESS )
9345     {
9346         res = MsiViewExecute( htab, 0 );
9347         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9348
9349         res = MsiViewClose( htab );
9350         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9351
9352         res = MsiCloseHandle( htab );
9353         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9354
9355         query = "SELECT * FROM `a`";
9356         res = MsiDatabaseOpenViewA( hdb, query, &htab );
9357         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9358
9359         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
9360         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9361
9362         buffer[0] = 0;
9363         size = sizeof(buffer);
9364         res = MsiRecordGetStringA(hrec, 1, buffer, &size );
9365         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9366         ok(!strcmp(buffer,"b"), "b != %s\n", buffer);
9367         MsiCloseHandle( hrec );
9368
9369         res = MsiViewClose( htab );
9370         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9371
9372         res = MsiCloseHandle( htab );
9373         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9374
9375         res = MsiDatabaseCommit(hdb);
9376         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9377
9378         res = MsiCloseHandle(hdb);
9379         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9380
9381         res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
9382         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9383
9384         query = "SELECT * FROM `a`";
9385         res = MsiDatabaseOpenViewA( hdb, query, &htab );
9386         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9387
9388         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
9389         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9390
9391         buffer[0] = 0;
9392         size = sizeof(buffer);
9393         res = MsiRecordGetStringA(hrec, 1, buffer, &size );
9394         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9395         ok(!strcmp(buffer,"b"), "b != %s\n", buffer);
9396
9397         res = MsiCloseHandle( hrec );
9398         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9399
9400         res = MsiViewClose( htab );
9401         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9402
9403         res = MsiCloseHandle( htab );
9404         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9405     }
9406
9407     res = MsiDatabaseCommit(hdb);
9408     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9409
9410     res = MsiCloseHandle(hdb);
9411     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9412
9413     DeleteFileA(msifile);
9414 }
9415
9416 static void test_embedded_nulls(void)
9417 {
9418     static const char control_table[] =
9419         "Dialog\tText\n"
9420         "s72\tL0\n"
9421         "Control\tDialog\n"
9422         "LicenseAgreementDlg\ttext\x11\x19text\0text";
9423     UINT r, sz;
9424     MSIHANDLE hdb, hrec;
9425     char buffer[32];
9426
9427     r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
9428     ok( r == ERROR_SUCCESS, "failed to open database %u\n", r );
9429
9430     GetCurrentDirectoryA( MAX_PATH, CURR_DIR );
9431     write_file( "temp_file", control_table, sizeof(control_table) );
9432     r = MsiDatabaseImportA( hdb, CURR_DIR, "temp_file" );
9433     ok( r == ERROR_SUCCESS, "failed to import table %u\n", r );
9434     DeleteFileA( "temp_file" );
9435
9436     r = do_query( hdb, "SELECT `Text` FROM `Control` WHERE `Dialog` = 'LicenseAgreementDlg'", &hrec );
9437     ok( r == ERROR_SUCCESS, "query failed %u\n", r );
9438
9439     buffer[0] = 0;
9440     sz = sizeof(buffer);
9441     r = MsiRecordGetStringA( hrec, 1, buffer, &sz );
9442     ok( r == ERROR_SUCCESS, "failed to get string %u\n", r );
9443     ok( !memcmp( "text\r\ntext\ntext", buffer, sizeof("text\r\ntext\ntext") - 1 ), "wrong buffer contents \"%s\"\n", buffer );
9444
9445     MsiCloseHandle( hrec );
9446     MsiCloseHandle( hdb );
9447     DeleteFileA( msifile );
9448 }
9449
9450 static void test_select_column_names(void)
9451 {
9452     MSIHANDLE hdb = 0, rec, rec2, view;
9453     char buffer[32];
9454     UINT r, size;
9455
9456     DeleteFileA(msifile);
9457
9458     r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
9459     ok( r == ERROR_SUCCESS , "failed to open database: %u\n", r );
9460
9461     r = try_query( hdb, "CREATE TABLE `t` (`a` CHAR NOT NULL, `b` CHAR PRIMARY KEY `a`)");
9462     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9463
9464     r = try_query( hdb, "SELECT `t`.`b` FROM `t` WHERE `t`.`b` = `x`" );
9465     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9466
9467     r = try_query( hdb, "SELECT '', `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
9468     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9469
9470     r = try_query( hdb, "SELECT *, `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
9471     todo_wine ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
9472
9473     r = try_query( hdb, "SELECT 'b', `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
9474     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9475
9476     r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x'" );
9477     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9478
9479     r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x' ORDER BY `b`" );
9480     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9481
9482     r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x' ORDER BY 'b'" );
9483     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9484
9485     r = try_query( hdb, "SELECT 't'.'b' FROM `t` WHERE `t`.`b` = 'x'" );
9486     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9487
9488     r = try_query( hdb, "SELECT 'b' FROM `t` WHERE `t`.`b` = 'x'" );
9489     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9490
9491     r = try_query( hdb, "INSERT INTO `t` ( `a`, `b` ) VALUES( '1', '2' )" );
9492     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9493
9494     r = try_query( hdb, "INSERT INTO `t` ( `a`, `b` ) VALUES( '3', '4' )" );
9495     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9496
9497     r = MsiDatabaseOpenViewA( hdb, "SELECT '' FROM `t`", &view );
9498     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9499
9500     r = MsiViewExecute( view, 0 );
9501     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9502
9503     r = MsiViewFetch( view, &rec );
9504     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9505     r = MsiRecordGetFieldCount( rec );
9506     ok( r == 1, "got %u\n",  r );
9507     r = MsiViewGetColumnInfo( view, MSICOLINFO_NAMES, &rec2 );
9508     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9509     r = MsiRecordGetFieldCount( rec2 );
9510     ok( r == 1, "got %u\n",  r );
9511     size = sizeof(buffer);
9512     memset( buffer, 0x55, sizeof(buffer) );
9513     r = MsiRecordGetStringA( rec2, 1, buffer, &size );
9514     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9515     ok( !buffer[0], "got \"%s\"\n", buffer );
9516     MsiCloseHandle( rec2 );
9517     r = MsiViewGetColumnInfo( view, MSICOLINFO_TYPES, &rec2 );
9518     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9519     r = MsiRecordGetFieldCount( rec2 );
9520     ok( r == 1, "got %u\n",  r );
9521     size = sizeof(buffer);
9522     memset( buffer, 0x55, sizeof(buffer) );
9523     r = MsiRecordGetStringA( rec2, 1, buffer, &size );
9524     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9525     ok( !lstrcmpA( buffer, "f0" ), "got \"%s\"\n", buffer );
9526     MsiCloseHandle( rec2 );
9527
9528     size = sizeof(buffer);
9529     memset( buffer, 0x55, sizeof(buffer) );
9530     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9531     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9532     ok( !buffer[0], "got \"%s\"\n", buffer );
9533     MsiCloseHandle( rec );
9534
9535     r = MsiViewFetch( view, &rec );
9536     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9537     size = sizeof(buffer);
9538     memset( buffer, 0x55, sizeof(buffer) );
9539     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9540     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9541     ok( !buffer[0], "got \"%s\"\n", buffer );
9542     MsiCloseHandle( rec );
9543
9544     r = MsiViewFetch( view, &rec );
9545     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9546     MsiCloseHandle( rec );
9547
9548     MsiViewClose( view );
9549     MsiCloseHandle( view );
9550
9551     r = MsiDatabaseOpenViewA( hdb, "SELECT `a`, '' FROM `t`", &view );
9552     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9553
9554     r = MsiViewExecute( view, 0 );
9555     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9556
9557     r = MsiViewFetch( view, &rec );
9558     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9559     r = MsiRecordGetFieldCount( rec );
9560     ok( r == 2, "got %u\n",  r );
9561     size = sizeof(buffer);
9562     memset( buffer, 0x55, sizeof(buffer) );
9563     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9564     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9565     ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
9566     MsiCloseHandle( rec );
9567
9568     r = MsiViewFetch( view, &rec );
9569     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9570     size = sizeof(buffer);
9571     memset( buffer, 0x55, sizeof(buffer) );
9572     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9573     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9574     ok( !buffer[0], "got \"%s\"\n", buffer );
9575     MsiCloseHandle( rec );
9576
9577     r = MsiViewFetch( view, &rec );
9578     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9579     MsiCloseHandle( rec );
9580
9581     MsiViewClose( view );
9582     MsiCloseHandle( view );
9583
9584     r = MsiDatabaseOpenViewA( hdb, "SELECT '', `a` FROM `t`", &view );
9585     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9586
9587     r = MsiViewExecute( view, 0 );
9588     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9589
9590     r = MsiViewFetch( view, &rec );
9591     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9592     r = MsiRecordGetFieldCount( rec );
9593     ok( r == 2, "got %u\n",  r );
9594     size = sizeof(buffer);
9595     memset( buffer, 0x55, sizeof(buffer) );
9596     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9597     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9598     ok( !buffer[0], "got \"%s\"\n", buffer );
9599     size = sizeof(buffer);
9600     memset( buffer, 0x55, sizeof(buffer) );
9601     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9602     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9603     ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
9604     MsiCloseHandle( rec );
9605
9606     r = MsiViewFetch( view, &rec );
9607     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9608     size = sizeof(buffer);
9609     memset( buffer, 0x55, sizeof(buffer) );
9610     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9611     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9612     ok( !buffer[0], "got \"%s\"\n", buffer );
9613     size = sizeof(buffer);
9614     memset( buffer, 0x55, sizeof(buffer) );
9615     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9616     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9617     ok( !lstrcmpA( buffer, "3" ), "got \"%s\"\n", buffer );
9618     MsiCloseHandle( rec );
9619
9620     r = MsiViewFetch( view, &rec );
9621     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9622     MsiCloseHandle( rec );
9623
9624     MsiViewClose( view );
9625     MsiCloseHandle( view );
9626
9627     r = MsiDatabaseOpenViewA( hdb, "SELECT `a`, '', `b` FROM `t`", &view );
9628     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9629
9630     r = MsiViewExecute( view, 0 );
9631     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9632
9633     r = MsiViewFetch( view, &rec );
9634     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9635     r = MsiRecordGetFieldCount( rec );
9636     ok( r == 3, "got %u\n",  r );
9637     size = sizeof(buffer);
9638     memset( buffer, 0x55, sizeof(buffer) );
9639     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9640     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9641     ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
9642     size = sizeof(buffer);
9643     memset( buffer, 0x55, sizeof(buffer) );
9644     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9645     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9646     ok( !buffer[0], "got \"%s\"\n", buffer );
9647     size = sizeof(buffer);
9648     memset( buffer, 0x55, sizeof(buffer) );
9649     r = MsiRecordGetStringA( rec, 3, buffer, &size );
9650     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9651     ok( !lstrcmpA( buffer, "2" ), "got \"%s\"\n", buffer );
9652     MsiCloseHandle( rec );
9653
9654     r = MsiViewFetch( view, &rec );
9655     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9656     size = sizeof(buffer);
9657     memset( buffer, 0x55, sizeof(buffer) );
9658     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9659     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9660     ok( !lstrcmpA( buffer, "3" ), "got \"%s\"\n", buffer );
9661     size = sizeof(buffer);
9662     memset( buffer, 0x55, sizeof(buffer) );
9663     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9664     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9665     ok( !buffer[0], "got \"%s\"\n", buffer );
9666     size = sizeof(buffer);
9667     memset( buffer, 0x55, sizeof(buffer) );
9668     r = MsiRecordGetStringA( rec, 3, buffer, &size );
9669     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9670     ok( !lstrcmpA( buffer, "4" ), "got \"%s\"\n", buffer );
9671     MsiCloseHandle( rec );
9672
9673     r = MsiViewFetch( view, &rec );
9674     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9675     MsiCloseHandle( rec );
9676
9677     MsiViewClose( view );
9678     MsiCloseHandle( view );
9679
9680     r = try_query( hdb, "SELECT '' FROM `t` WHERE `t`.`b` = 'x'" );
9681     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9682
9683     r = try_query( hdb, "SELECT `` FROM `t` WHERE `t`.`b` = 'x'" );
9684     todo_wine ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9685
9686     r = try_query( hdb, "SELECT `b` FROM 't' WHERE `t`.`b` = 'x'" );
9687     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9688
9689     r = try_query( hdb, "SELECT `b` FROM `t` WHERE 'b' = 'x'" );
9690     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9691
9692     r = try_query( hdb, "SELECT `t`.`b`, `` FROM `t` WHERE `t`.`b` = 'x'" );
9693     todo_wine ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9694
9695     r = MsiCloseHandle( hdb );
9696     ok(r == ERROR_SUCCESS , "failed to close database: %u\n", r);
9697 }
9698
9699 START_TEST(db)
9700 {
9701     test_msidatabase();
9702     test_msiinsert();
9703     test_msidecomposedesc();
9704     test_msibadqueries();
9705     test_viewmodify();
9706     test_viewgetcolumninfo();
9707     test_getcolinfo();
9708     test_msiexport();
9709     test_longstrings();
9710     test_streamtable();
9711     test_binary();
9712     test_where_not_in_selected();
9713     test_where();
9714     test_msiimport();
9715     test_binary_import();
9716     test_markers();
9717     test_handle_limit();
9718     test_try_transform();
9719     test_join();
9720     test_temporary_table();
9721     test_alter();
9722     test_integers();
9723     test_update();
9724     test_special_tables();
9725     test_tables_order();
9726     test_rows_order();
9727     test_select_markers();
9728     test_viewmodify_update();
9729     test_viewmodify_assign();
9730     test_stringtable();
9731     test_viewmodify_delete();
9732     test_defaultdatabase();
9733     test_order();
9734     test_viewmodify_delete_temporary();
9735     test_deleterow();
9736     test_quotes();
9737     test_carriagereturn();
9738     test_noquotes();
9739     test_forcecodepage();
9740     test_viewmodify_refresh();
9741     test_where_viewmodify();
9742     test_storages_table();
9743     test_dbtopackage();
9744     test_droptable();
9745     test_dbmerge();
9746     test_select_with_tablenames();
9747     test_insertorder();
9748     test_columnorder();
9749     test_suminfo_import();
9750     test_createtable();
9751     test_collation();
9752     test_embedded_nulls();
9753     test_select_column_names();
9754 }