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