rostests/winetests/msi/db.c

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