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