dlls/msi/tests/db.c

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